NGX Cookie Service

https://github.com/stevermeister/ngx-cookie-service
Admin
NGX Cookie Service is a lightweight and performant Angular service that enables applications to...
Tokens:26,198
Snippets:318
Trust Score:9.5
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install ngx-cookie-service-ssr

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Commands to install the SSR-specific library.

```shell
npm install ngx-cookie-service-ssr --save

       # or

       yarn add ngx-cookie-service-ssr
```

--------------------------------

### Install ngx-cookie-service

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Commands to install the library using npm or yarn.

```bash
npm install ngx-cookie-service --save

# or

yarn add ngx-cookie-service
```

--------------------------------

### Install SSR Cookie Service

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service/README.md

Commands to install the SSR-specific cookie library.

```shell
    npm install ngx-cookie-service-ssr --save

    # or

    yarn add ngx-cookie-service-ssr
```

--------------------------------

### Import and use cookie services

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/types.md

Examples for importing services and types, and implementing them within an Angular component.

```typescript
// Basic import
import { CookieService, CookieOptions, SameSite } from 'ngx-cookie-service';

// SSR version
import { SsrCookieService, CookieOptions, SameSite } from 'ngx-cookie-service-ssr';

// Using types in your components
import { Component } from '@angular/core';
import { CookieService, CookieOptions } from 'ngx-cookie-service';

@Component({
  selector: 'app-typed-cookies',
  template: `...`
})
export class TypedCookiesComponent {
  constructor(private cookieService: CookieService) {}

  createOptions(): CookieOptions {
    return {
      expires: 7,
      path: '/',
      secure: true,
      sameSite: 'Strict'
    };
  }

  setSameSite(level: SameSite) {
    this.cookieService.set('preference', 'value', { sameSite: level });
  }
}
```

--------------------------------

### Set Cookie with Options Object

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/CookieService.md

Defines the method signature for setting a cookie using a configuration object and provides examples for complex and simple cookie creation.

```typescript
set(
  name: string,
  value: string,
  options?: CookieOptions
): void
```

```typescript
this.cookieService.set('userData', JSON.stringify(user), {
  expires: 30,
  path: '/',
  domain: 'example.com',
  secure: true,
  sameSite: 'Strict',
  partitioned: true
});

// Simple cookie
this.cookieService.set('locale', 'en-US', { path: '/' });
```

--------------------------------

### get(name: string): string

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Retrieves the value of a specific cookie.

```APIDOC
## get(name: string): string

### Description
Gets the value of the cookie with the specified name.

### Parameters
- **name** (string) - Required - The name of the cookie to retrieve.

### Returns
- **string** - The value of the cookie.
```

--------------------------------

### Configure Express Server for SSR

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Setup the Express engine to provide request and response objects to the Angular application.

```typescript
import { APP_BASE_HREF } from '@angular/common';
import { REQUEST, RESPONSE_INIT } from '@angular/core';
import { ngExpressEngine } from '@nguniversal/express-engine';
import * as express from 'express';
import { join } from 'path';
import { AppServerModule } from './src/main.server';
import { environment } from './src/environments/environment';

const server = express();
const distFolder = join(process.cwd(), 'dist/my-app/browser');
const indexHtml = join(distFolder, 'index.html');

server.engine('html', ngExpressEngine({
  bootstrap: AppServerModule,
}));

server.set('view engine', 'html');
server.set('views', distFolder);

// Server-side rendering
server.get('*', (req, res) => {
  res.render(indexHtml, {
    req,
    providers: [
      { provide: APP_BASE_HREF, useValue: req.baseUrl },
      { provide: REQUEST, useValue: req },
      { provide: RESPONSE_INIT, useValue: res }
    ]
  });
});

server.listen(4000, () => {
  console.log(`Node Express server listening on http://localhost:4000`);
});
```

--------------------------------

### get(name: string): string

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service/README.md

Retrieves the value of a specific cookie by its name.

```APIDOC
## get(name: string): string

### Description
Gets the value of the cookie with the specified `name`.

### Parameters
- **name** (string) - Required - The name of the cookie to retrieve.

### Returns
- **string** - The value of the cookie.
```

--------------------------------

### Implement SsrCookieService in Angular

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Example of using SsrCookieService to retrieve cookies in an environment that supports both server-side and client-side rendering.

```typescript
import { SsrCookieService } from 'ngx-cookie-service-ssr';
import { Component } from '@angular/core';

@Component({
  selector: 'app-ssr-root',
  template: `<p>{{ sessionId }}</p>`,
  standalone: true
})
export class SsrComponent {
  sessionId: string;

  constructor(private cookieService: SsrCookieService) {
    // Works in both browser and server
    this.sessionId = this.cookieService.get('sessionToken');
  }
}
```

--------------------------------

### Implement CookieService in Angular

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Example of injecting and using CookieService to set a secure cookie within an Angular component.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `<button (click)="setToken()">Set Token</button>`,
  standalone: true,
  providers: [CookieService]
})
export class AppComponent {
  constructor(private cookieService: CookieService) {}

  setToken() {
    this.cookieService.set('authToken', 'abc123', {
      expires: 7,
      path: '/',
      secure: true,
      sameSite: 'Strict'
    });
  }
}
```

--------------------------------

### Handle Missing Cookies

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

The get() method returns an empty string when a cookie is not found, allowing for simple truthy or equality checks.

```typescript
import { CookieService } from 'ngx-cookie-service';

@Component({
  selector: 'app-cookie-read',
  template: `
    <p *ngIf="userToken">Token: {{ userToken }}</p>
    <p *ngIf="!userToken">No token found</p>
  `
})
export class CookieReadComponent {
  userToken: string;

  constructor(private cookieService: CookieService) {
    // Always returns string, never null/undefined
    this.userToken = this.cookieService.get('authToken');
    
    // Check for empty string to detect missing cookie
    if (this.userToken === '') {
      console.log('Cookie not found');
    } else {
      console.log('Cookie found:', this.userToken);
    }
  }
}
```

--------------------------------

### Reinstalling node modules

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Use these commands to resolve 'token missing' or 'no provider' errors caused by package manager issues.

```bash
rm -rf node_modules
yarn # or `npm install`
```

--------------------------------

### Handling SameSite=None Cookies

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

Demonstrates the incorrect usage that triggers a warning and the correct implementation using the secure flag.

```typescript
import { CookieService } from 'ngx-cookie-service';

@Component({
  selector: 'app-cross-site',
  template: `...`,
  standalone: true
})
export class CrossSiteComponent {
  constructor(private cookieService: CookieService) {}

  setCrossSiteCookie() {
    // WRONG: triggers warning, auto-corrected by service
    this.cookieService.set('tracking', 'id123', {
      sameSite: 'None'
      // secure is missing, warning logged, service forces it
    });

    // RIGHT: explicitly set secure: true with sameSite: 'None'
    this.cookieService.set('tracking', 'id123', {
      sameSite: 'None',
      secure: true     // Explicitly set - no warning
    });
  }
}
```

--------------------------------

### Project File Structure

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Visual representation of the library's source code organization, including main services and test files.

```text
projects/
├── ngx-cookie-service/
│   └── src/
│       ├── lib/
│       │   ├── cookie.service.ts          (main service)
│       │   └── cookie.service.spec.ts     (tests)
│       └── public-api.ts                  (exports)
└── ngx-cookie-service-ssr/
    └── src/
        ├── lib/
        │   ├── ssr-cookie.service.ts      (SSR service)
        │   └── ssr-cookie.service.spec.ts (tests)
        └── public-api.ts                  (exports)
```

--------------------------------

### Provide REQUEST and RESPONSE_INIT tokens for SSR

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

Ensure the REQUEST and RESPONSE_INIT tokens are provided in the server configuration to enable cookie reading and writing.

```typescript
// In server.ts or app.config.server.ts
import { REQUEST, RESPONSE_INIT } from '@angular/core';

server.get('*', (req, res) => {
  res.render(indexHtml, {
    req,
    providers: [
      // Provide REQUEST and RESPONSE_INIT
      { provide: REQUEST, useValue: req },
      { provide: RESPONSE_INIT, useValue: res }
    ]
  });
});
```

```typescript
// In server.ts
import { RESPONSE_INIT } from '@angular/core';

server.get('*', (req, res) => {
  res.render(indexHtml, {
    req,
    providers: [
      // Must provide RESPONSE_INIT for cookie setting
      { provide: RESPONSE_INIT, useValue: res }
    ]
  });
});
```

--------------------------------

### Create a Preferences Service with ngx-cookie-service

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Implements a wrapper service to handle JSON serialization and default values for user preferences stored in cookies.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class PreferencesService {
  private readonly defaultPreferences = {
    theme: 'light',
    language: 'en',
    compact: false
  };

  constructor(private cookieService: CookieService) {}

  set<T extends Record<string, any>>(key: keyof typeof this.defaultPreferences, value: T): void {
    // Store preferences for 1 year
    this.cookieService.set(`pref_${String(key)}`, JSON.stringify(value), {
      expires: 365,
      path: '/',
      sameSite: 'Lax'
    });
  }

  get<T>(key: keyof typeof this.defaultPreferences): T {
    const cookie = this.cookieService.get(`pref_${String(key)}`);
    
    if (!cookie) {
      return this.defaultPreferences[key] as T;
    }

    try {
      return JSON.parse(cookie);
    } catch (e) {
      return this.defaultPreferences[key] as T;
    }
  }

  reset(): void {
    Object.keys(this.defaultPreferences).forEach(key => {
      this.cookieService.delete(`pref_${key}`);
    });
  }
}
```

--------------------------------

### Create a custom cookie service wrapper

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Define a service that wraps CookieService to enforce default options like path, secure, and sameSite.

```typescript
import { Injectable } from '@angular/core';
import { CookieService, CookieOptions } from 'ngx-cookie-service';

@Injectable({ providedIn: 'root' })
export class ConfiguredCookieService {
  private readonly defaultOptions: CookieOptions = {
    path: '/',
    secure: true,
    sameSite: 'Strict'
  };

  constructor(private cookieService: CookieService) {}

  setSecure(name: string, value: string, expires: number = 7) {
    this.cookieService.set(name, value, {
      ...this.defaultOptions,
      expires
    });
  }

  get(name: string): string {
    return this.cookieService.get(name);
  }

  delete(name: string) {
    this.cookieService.delete(name, this.defaultOptions.path);
  }
}
```

--------------------------------

### Basic Cookie Usage in Angular

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Demonstrates setting a simple session cookie within an Angular component.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { Component } from '@angular/core';

@Component({
  selector: 'app-simple',
  template: `<button (click)="save()">Save Preference</button>`,
  standalone: true
})
export class SimpleComponent {
  constructor(private cookieService: CookieService) {}

  save() {
    // Simple session cookie
    this.cookieService.set('preference', 'dark');
  }
}
```

--------------------------------

### Define Third-Party Tracking Cookie Options

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Configure tracking cookies with partitioned storage (CHIPS) and cross-site access permissions.

```typescript
const trackingOptions: CookieOptions = {
  expires: 30,
  path: '/',
  secure: true,
  sameSite: 'None',            // Required for cross-site
  partitioned: true            // CHIPS: partition by top-level site
};
this.cookieService.set('trackingId', id, trackingOptions);
```

--------------------------------

### getAll(): {}

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Retrieves all accessible cookies.

```APIDOC
## getAll(): {}

### Description
Returns a map of key-value pairs for all cookies that can be accessed.

### Returns
- **{}** - An object containing all cookie key-value pairs.
```

--------------------------------

### Import SsrCookieService

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/SsrCookieService.md

Import the service from the library package.

```typescript
import { SsrCookieService } from 'ngx-cookie-service-ssr';
```

--------------------------------

### Handle Cross-Domain Cookie Restrictions

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

Demonstrates how to set cookies correctly within the same domain or parent domain, while noting that setting cookies for external domains will be rejected by the browser.

```typescript
import { CookieService } from 'ngx-cookie-service';

@Component({
  selector: 'app-domain-handling',
  template: `...`
})
export class DomainHandlingComponent {
  constructor(private cookieService: CookieService) {}

  attemptCrossDomain() {
    // If current domain is example.com:
    
    // WORKS: same domain
    this.cookieService.set('token', 'value', {
      domain: 'example.com',
      path: '/'
    });

    // WORKS: no domain specified (uses current)
    this.cookieService.set('token', 'value', { path: '/' });

    // FAILS: other domain (browser rejects)
    this.cookieService.set('token', 'value', {
      domain: 'other-domain.com',  // Won't be set
      path: '/'
    });

    // WORKS: subdomain (if current domain is subdomain)
    if (location.hostname === 'app.example.com') {
      this.cookieService.set('token', 'value', {
        domain: 'example.com',  // Parent domain accessible
        path: '/'
      });
    }
  }
}
```

--------------------------------

### Secure Token Storage Implementation

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Demonstrates storing, retrieving, and clearing authentication tokens with strict security attributes like HTTPS-only and SameSite enforcement.

```typescript
@Injectable({ providedIn: 'root' })
export class SecureTokenService {
  constructor(private cookieService: CookieService) {}

  storeToken(token: string, expiresIn: number = 3600): void {
    // Best practices for token storage
    this.cookieService.set('authToken', token, {
      expires: expiresIn / 86400,  // Convert seconds to days
      path: '/',
      domain: undefined,           // Current domain only
      secure: true,                // HTTPS only
      sameSite: 'Strict',          // No cross-site sending
      partitioned: false           // Not a third-party cookie
    });
  }

  retrieveToken(): string | null {
    const token = this.cookieService.get('authToken');
    return token || null;
  }

  clearToken(): void {
    // Match all attributes when deleting
    this.cookieService.delete('authToken', '/', undefined, true);
  }

  validateToken(): boolean {
    return this.cookieService.check('authToken') && 
           !!this.cookieService.get('authToken');
  }
}
```

--------------------------------

### Configure cookie with CookieOptions

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/types.md

Demonstrates using the CookieOptions interface to set a secure cookie with specific attributes.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { Component } from '@angular/core';

@Component({
  selector: 'app-config-cookie',
  template: `<button (click)="setSecureCookie()">Set Secure Cookie</button>`
})
export class ConfigCookieComponent {
  constructor(private cookieService: CookieService) {}

  setSecureCookie() {
    const options: CookieOptions = {
      expires: 30,
      path: '/',
      domain: 'example.com',
      secure: true,
      sameSite: 'Strict',
      partitioned: false
    };
    this.cookieService.set('authToken', 'abc123xyz', options);
  }
}
```

--------------------------------

### set(name: string, value: string, options?: object)

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Sets a cookie with the specified name and value, with optional configuration.

```APIDOC
## set(name: string, value: string, options?: object)

### Description
Sets a cookie with the specified name and value. Optional parameters include expires, path, domain, secure, and sameSite.

### Parameters
- **name** (string) - Required - The name of the cookie.
- **value** (string) - Required - The value of the cookie.
- **options** (object) - Optional - Configuration object including expires, path, domain, secure, and sameSite.
```

--------------------------------

### getAll(): {}

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service/README.md

Retrieves all accessible cookies as a map of key-value pairs.

```APIDOC
## getAll(): {}

### Description
Returns a map of key-value pairs for cookies that can be accessed.

### Returns
- **{}** - An object containing all accessible cookies.
```

--------------------------------

### Implement TypedCookieService

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Create a wrapper service that handles JSON serialization and provides default cookie options.

```typescript
import { CookieService, CookieOptions } from 'ngx-cookie-service';
import { Injectable } from '@angular/core';

interface CookieMetadata {
  expires: number;
  path: string;
  secure: boolean;
  sameSite: 'Lax' | 'Strict' | 'None';
}

@Injectable({ providedIn: 'root' })
export class TypedCookieService {
  private readonly defaults: CookieMetadata = {
    expires: 7,
    path: '/',
    secure: true,
    sameSite: 'Lax'
  };

  constructor(private cookieService: CookieService) {}

  set<T>(key: string, value: T, options?: Partial<CookieMetadata>): void {
    const merged = { ...this.defaults, ...options };
    const serialized = JSON.stringify(value);
    
    this.cookieService.set(key, serialized, {
      expires: merged.expires,
      path: merged.path,
      secure: merged.secure,
      sameSite: merged.sameSite
    });
  }

  get<T>(key: string, defaultValue?: T): T | undefined {
    const cookie = this.cookieService.get(key);
    
    if (!cookie) {
      return defaultValue;
    }

    try {
      return JSON.parse(cookie) as T;
    } catch (e) {
      console.error(`Failed to parse cookie ${key}:`, e);
      return defaultValue;
    }
  }

  delete(key: string): void {
    this.cookieService.delete(key, this.defaults.path);
  }

  has(key: string): boolean {
    return this.cookieService.check(key);
  }
}
```

--------------------------------

### Set Cookie with Options

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/SsrCookieService.md

Set a cookie with configuration options, supporting server-side specific flags like httpOnly.

```typescript
set(name: string, value: string, options?: CookieOptions): void
```

```typescript
// Set a simple cookie
this.cookieService.set('userId', '123', { path: '/' });

// Server-side secure cookie with HttpOnly flag
this.cookieService.set('sessionToken', 'token123', {
  expires: 7,
  path: '/',
  domain: 'example.com',
  secure: true,
  sameSite: 'Strict',
  httpOnly: true,  // Server-side only
  maxAge: 604800   // 7 days in seconds
});

// Partitioned cookie (CHIPS)
this.cookieService.set('partitioned_data', 'value', {
  path: '/',
  secure: true,
  sameSite: 'None',
  partitioned: true
});
```

--------------------------------

### Set a cookie

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Creates or updates a cookie. The sameSite attribute defaults to 'Lax', and 'None' requires the secure flag to be set.

```typescript
cookieService.set('test', 'Hello World');
cookieService.set('test', 'Hello World', { expires: 2, sameSite: 'Lax' });
```

--------------------------------

### set(name: string, value: string, options?: object)

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service/README.md

Sets a cookie with a specified name, value, and optional configuration parameters.

```APIDOC
## set(name: string, value: string, options?: object)

### Description
Sets a cookie with the specified `name` and `value`. Optional parameters include expires, path, domain, secure, and sameSite.

### Parameters
- **name** (string) - Required
- **value** (string) - Required
- **options** (object) - Optional - Includes expires (number|Date), path (string), domain (string), secure (boolean), and sameSite ('Lax'|'Strict'|'None').
```

--------------------------------

### Implement Refresh Token Pattern

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Handles dual-token storage with different expiration times for access and refresh tokens.

```typescript
@Injectable({ providedIn: 'root' })
export class TokenService {
  private readonly accessTokenKey = 'accessToken';
  private readonly refreshTokenKey = 'refreshToken';

  constructor(
    private http: HttpClient,
    private cookieService: CookieService
  ) {}

  setTokens(accessToken: string, refreshToken: string): void {
    // Short-lived access token
    this.cookieService.set(this.accessTokenKey, accessToken, {
      expires: 0.0833,  // 2 hours in days
      path: '/',
      secure: true,
      sameSite: 'Strict',
      httpOnly: true  // If using SSR
    });

    // Longer-lived refresh token
    this.cookieService.set(this.refreshTokenKey, refreshToken, {
      expires: 30,      // 30 days
      path: '/',
      secure: true,
      sameSite: 'Strict',
      httpOnly: true
    });
  }

  getAccessToken(): string {
    return this.cookieService.get(this.accessTokenKey);
  }

  getRefreshToken(): string {
    return this.cookieService.get(this.refreshTokenKey);
  }

  clearTokens(): void {
    this.cookieService.delete(this.accessTokenKey);
    this.cookieService.delete(this.refreshTokenKey);
  }
}
```

--------------------------------

### SameSite=None Warning Message

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

The console warning message displayed when a cookie is set with sameSite='None' but without secure=true.

```text
[ngx-cookie-service] Cookie {name} was forced with secure flag because sameSite=None.
More details : https://github.com/stevermeister/ngx-cookie-service/issues/86#issuecomment-597720130
```

--------------------------------

### Implement Authentication Service with Token Storage

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Manages user authentication state by storing and retrieving tokens in cookies with secure attributes.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({ providedIn: 'root' })
export class AuthService {
  constructor(
    private http: HttpClient,
    private cookieService: CookieService
  ) {}

  login(username: string, password: string): Observable<any> {
    return new Observable(observer => {
      this.http.post('/api/auth/login', { username, password })
        .subscribe({
          next: (response: any) => {
            // Store token with secure attributes
            this.cookieService.set('authToken', response.token, {
              expires: 7,           // 7 days
              path: '/',
              secure: true,         // HTTPS only
              sameSite: 'Strict'    // No cross-site sending
            });
            
            observer.next(response);
            observer.complete();
          },
          error: (error) => observer.error(error)
        });
    });
  }

  logout(): void {
    // Delete the token
    this.cookieService.delete('authToken', '/', 'localhost', true);
  }

  isAuthenticated(): boolean {
    return this.cookieService.check('authToken');
  }

  getToken(): string {
    return this.cookieService.get('authToken');
  }
}
```

--------------------------------

### Configure SsrCookieService for SSR

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Provides the necessary REQUEST and RESPONSE_INIT tokens in the server-side rendering environment.

```typescript
import { SsrCookieService } from 'ngx-cookie-service-ssr';
import { REQUEST, RESPONSE_INIT } from '@angular/core';

// For SSR environments, provide REQUEST and RESPONSE_INIT in server.ts:
server.get('*', (req, res) => {
  res.render(indexHtml, {
    req,
    providers: [
      { provide: APP_BASE_HREF, useValue: req.baseUrl },
      { provide: REQUEST, useValue: req },
      { provide: RESPONSE_INIT, useValue: res },
    ]
  });
});
```

--------------------------------

### Configure Cookie Security Attributes

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Individual configuration snippets for enforcing security best practices like SameSite, HttpOnly, and partitioning.

```typescript
sameSite: 'Strict'  // Only send with same-site requests
```

```typescript
httpOnly: true  // Prevents XSS access
```

```typescript
path: '/'  // Avoid implicit paths
```

```typescript
// Must provide same path, domain, secure, sameSite as set()
```

```typescript
sameSite: 'None',
secure: true,
partitioned: true  // CHIPS - partition by top-level site
```

--------------------------------

### Configure SSR Cookie Support

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Provide REQUEST and RESPONSE_INIT tokens in the server-side rendering configuration to enable cookie service functionality during SSR.

```typescript
import { APP_BASE_HREF } from '@angular/common';
import { REQUEST, RESPONSE_INIT } from '@angular/core';
import { express } from 'express';

const server = express();

// SSR rendering with cookie support
server.get('*', (req, res) => {
  res.render(indexHtml, {
    req,
    providers: [
      // Standard Angular providers
      { provide: APP_BASE_HREF, useValue: req.baseUrl },
      
      // Request/Response for SsrCookieService
      { provide: REQUEST, useValue: req },
      { provide: RESPONSE_INIT, useValue: res },
    ]
  });
});
```

--------------------------------

### Third-Party Tracking with CHIPS

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Enables partitioned cookies for cross-site tracking scenarios using the CHIPS (Cookies Having Independent Partitioned State) standard.

```typescript
@Injectable({ providedIn: 'root' })
export class TrackingService {
  constructor(private cookieService: CookieService) {}

  setTrackingId(trackingId: string): void {
    // CHIPS: Partitioned by top-level site
    this.cookieService.set('_tracking_id', trackingId, {
      expires: 365,
      path: '/',
      secure: true,
      sameSite: 'None',       // Required for cross-site
      partitioned: true       // Partition by top-level site
    });
  }
}
```

--------------------------------

### CookieOptions

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/types.md

Interface for configuring cookie options when using the set() method.

```APIDOC
## CookieOptions

### Description
Interface for cookie configuration options. Used with the set() method's options-based overload.

### Fields
- **expires** (number | Date) - Optional - Cookie expiration: number of days from now, or absolute Date.
- **path** (string) - Optional - Cookie path (e.g., '/', '/admin').
- **domain** (string) - Optional - Cookie domain.
- **secure** (boolean) - Optional - Mark cookie as secure (HTTPS only). Defaults to false.
- **sameSite** (SameSite) - Optional - CSRF protection level: 'Lax', 'None', or 'Strict'. Defaults to 'Lax'.
- **partitioned** (boolean) - Optional - Enable partitioned cookie storage (CHIPS). Defaults to false.
```

--------------------------------

### Handle SSR Environment Checks

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

Use isPlatformBrowser to verify the environment before performing cookie operations to prevent issues in server-side rendering.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { Component, inject } from '@angular/core';
import { isPlatformBrowser } from '@angular/common';
import { PLATFORM_ID } from '@angular/core';

@Component({
  selector: 'app-ssr-aware',
  template: `...`,
  standalone: true
})
export class SsrAwareComponent {
  cookieService = inject(CookieService);
  platformId = inject(PLATFORM_ID);

  setIfBrowser() {
    // Check environment before relying on cookies
    if (isPlatformBrowser(this.platformId)) {
      this.cookieService.set('browserCookie', 'value');
    } else {
      // Server-side: use SsrCookieService instead
      console.log('Server environment: use SsrCookieService');
    }
  }
}
```

--------------------------------

### Manage Localhost Cookie Persistence

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

Shows how to ensure cookies persist on localhost by explicitly defining the path attribute, avoiding issues with implicit browser defaults.

```typescript
import { CookieService } from 'ngx-cookie-service';

@Component({
  selector: 'app-localhost-cookie',
  template: `...`
})
export class LocalhostCookieComponent {
  constructor(private cookieService: CookieService) {}

  setLocalCookie() {
    // BETTER: always specify path explicitly
    this.cookieService.set('token', 'value', {
      path: '/',  // Explicitly set path
      expires: 7
    });

    // WORKS: object syntax
    this.cookieService.set('token', 'value', {
      path: '/',
      secure: false,  // OK for localhost
      sameSite: 'Lax'
    });

    // AVOID: implicit defaults
    // this.cookieService.set('token', 'value');  // May not work on localhost
  }
}
```

--------------------------------

### set(name: string, value: string, ...)

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/README.md

Sets a cookie with the specified name and value.

```APIDOC
## set(name: string, value: string, options?: object)

### Description
Sets a cookie with the specified name and value. Optional parameters include expires, path, domain, secure, and sameSite.

### Parameters
- **name** (string) - Required
- **value** (string) - Required
- **options** (object) - Optional - Includes expires (number|Date), path (string), domain (string), secure (boolean), and sameSite ('Lax'|'Strict'|'None').
```

--------------------------------

### Secure Production Cookie Configuration

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Configures cookies with security flags like secure, sameSite, and domain restrictions for production environments.

```typescript
import { CookieService, CookieOptions } from 'ngx-cookie-service';
import { Component } from '@angular/core';

@Component({
  selector: 'app-secure',
  template: `<button (click)="authenticate()">Login</button>`,
  standalone: true
})
export class SecureComponent {
  constructor(private cookieService: CookieService) {}

  authenticate() {
    // Recommended security options for production
    const options: CookieOptions = {
      expires: 7,              // 7 days
      path: '/',
      domain: 'example.com',   // Must match your domain
      secure: true,            // HTTPS only
      sameSite: 'Strict',      // Strongest CSRF protection
      partitioned: false       // Optional, for third-party contexts
    };
    this.cookieService.set('authToken', 'token_value_here', options);
  }
}
```

--------------------------------

### Define CookieService

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/CookieService.md

The service is provided at the root level for dependency injection.

```typescript
@Injectable({
  providedIn: 'root',
})
export class CookieService {
  constructor();
}
```

--------------------------------

### Synchronize cookies across browser tabs

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Uses the window storage event to listen for changes and update cookies accordingly.

```typescript
@Injectable({ providedIn: 'root' })
export class StorageService {
  constructor(private cookieService: CookieService) {
    // Listen for storage changes from other tabs
    window.addEventListener('storage', (event) => {
      if (event.key?.startsWith('sync_')) {
        this.onStorageChange(event);
      }
    });
  }

  private onStorageChange(event: StorageEvent): void {
    // Cookies are synchronized across tabs automatically
    // Use localStorage for cross-tab communication
    const key = event.key?.replace('sync_', '');
    if (key && event.newValue) {
      this.cookieService.set(key, event.newValue, { path: '/' });
    }
  }
}
```

--------------------------------

### Configure HttpOnly for SSR

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Use httpOnly flags in server environments to mitigate XSS risks for sensitive data.

```typescript
// Server environment: use httpOnly to prevent XSS
const options: CookieOptions = {
  httpOnly: true,              // JavaScript cannot access
  secure: true,
  sameSite: 'Strict'
};
this.cookieService.set('sessionToken', token, options);
```

--------------------------------

### Configure SSR Server Providers

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Update the server.ts file to provide request and response objects for cookie access.

```typescript
server.get('*', (req, res) => {
  res.render(indexHtml, { req, providers: [{ provide: APP_BASE_HREF, useValue: req.baseUrl }] });
});
```

```typescript
server.get('*', (req, res) => {
  res.render(indexHtml, {
    req,
    providers: [
      { provide: APP_BASE_HREF, useValue: req.baseUrl },
      { provide: 'REQUEST', useValue: req },
      { provide: 'RESPONSE', useValue: res },
    ],
  });
});
```

--------------------------------

### Inject CookieService via Constructor

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Standard constructor-based dependency injection for Angular components.

```typescript
import { Component } from '@angular/core';
import { CookieService } from 'ngx-cookie-service';

@Component({
  selector: 'app-classic',
  template: `...`,
  providers: [CookieService]
})
export class ClassicComponent {
  constructor(private cookieService: CookieService) {
    this.cookieService.set('token', 'value');
  }
}
```

--------------------------------

### CookieOptions Interface (Client-side)

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Configuration options available for the standard ngx-cookie-service.

```typescript
interface CookieOptions {
  expires?: number | Date;     // Expiration: days (number) or absolute date
  path?: string;               // Cookie path, e.g., '/', '/app'
  domain?: string;             // Cookie domain
  secure?: boolean;            // HTTPS only
  sameSite?: SameSite;          // CSRF protection: 'Lax', 'None', 'Strict'
  partitioned?: boolean;       // Partitioned storage (CHIPS)
}
```

--------------------------------

### Configure CookieService in Angular

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Demonstrates providing CookieService in standalone components or using the inject function in Angular 14+.

```typescript
import { CookieService } from 'ngx-cookie-service';
import { NgModule } from '@angular/core';

// Automatic: service is provided at root
// No configuration needed in module

// Option 1: Import in standalone component
import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `...`,
  providers: [CookieService],
  standalone: true
})
export class AppComponent {}

// Option 2: Inject using inject() function (Angular 14+)
import { inject } from '@angular/core';

export class MyService {
  cookieService = inject(CookieService);
}
```

--------------------------------

### Define User Preference Cookie Options

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Set long-lived cookies for non-sensitive user preferences with relaxed sameSite policies.

```typescript
const preferenceOptions: CookieOptions = {
  expires: 365,                // 1 year
  path: '/',
  secure: false,               // OK for non-sensitive data
  sameSite: 'Lax'
};
this.cookieService.set('theme', 'dark', preferenceOptions);
```

--------------------------------

### Set Cookie with Individual Parameters

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/SsrCookieService.md

Defines the signature for setting a cookie using individual arguments. This overload supports backward compatibility with legacy parameter-based APIs.

```typescript
set(
  name: string,
  value: string,
  expiresOrOptions?: number | Date | CookieOptions,
  path?: string,
  domain?: string,
  secure?: boolean,
  sameSite?: SameSite,
  partitioned?: boolean
): void
```

```typescript
// 7-day expiration
this.cookieService.set('theme', 'dark', 7, '/');

// Specific date expiration
const expireDate = new Date();
expireDate.setDate(expireDate.getDate() + 30);
this.cookieService.set('pref', 'value', expireDate, '/');

// With all parameters
this.cookieService.set('auth', 'token', 1, '/', 'example.com', true, 'Strict', true);
```

--------------------------------

### Inspect Cookies via Console

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Logs cookie data to the console for verification during development.

```typescript
// Log all cookies
console.log(this.cookieService.getAll());

// Check specific cookie
console.log(this.cookieService.get('authToken'));

// Verify cookie exists
console.log(this.cookieService.check('authToken'));
```

--------------------------------

### CookieService.check

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Checks if a cookie exists.

```APIDOC
## check(name)

### Description
Returns true if a cookie with the specified name exists, otherwise false.

### Parameters
- **name** (string) - Required - The name of the cookie to check.
```

--------------------------------

### Define SsrCookieService

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/SsrCookieService.md

The service is provided at the root level for dependency injection.

```typescript
@Injectable({
  providedIn: 'root',
})
export class SsrCookieService {
  constructor();
}
```

--------------------------------

### Secure Cross-Site Cookies

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Configure sameSite and secure attributes for cookies intended for cross-site requests.

```typescript
// For cookies sent in cross-site requests
const options: CookieOptions = {
  sameSite: 'None',            // Required for cross-site
  secure: true,                // Also required with None
  partitioned: true            // CHIPS: recommended for third-party
};
// Service auto-enforces secure: true if sameSite: 'None'
```

--------------------------------

### set(name, value, expiresOrOptions, path, domain, secure, sameSite, partitioned)

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/api-reference/SsrCookieService.md

Sets a cookie with the specified name, value, and optional attributes. This method normalizes parameters and supports both legacy argument-based calls and modern options objects.

```APIDOC
## set(name: string, value: string, expiresOrOptions?: number | Date | CookieOptions, path?: string, domain?: string, secure?: boolean, sameSite?: SameSite, partitioned?: boolean): void

### Description
Sets a cookie with individual parameter arguments. This method normalizes parameters and delegates to the options-based overload.

### Parameters
- **name** (string) - Required - Cookie name
- **value** (string) - Required - Cookie value
- **expiresOrOptions** (number | Date | CookieOptions) - Optional - Expiration (days or Date) or full options object
- **path** (string) - Optional - Cookie path
- **domain** (string) - Optional - Cookie domain
- **secure** (boolean) - Optional - Secure flag
- **sameSite** ('Lax' | 'None' | 'Strict') - Optional - SameSite attribute
- **partitioned** (boolean) - Optional - Partitioned flag

### Returns
- **void**
```

--------------------------------

### check(name: string): boolean

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service-ssr/README.md

Checks if a cookie with the given name exists.

```APIDOC
## check(name: string): boolean

### Description
Checks if a cookie with the given name can be accessed or found.

### Parameters
- **name** (string) - Required - The name of the cookie to check.

### Returns
- **boolean** - Returns true if the cookie exists, false otherwise.
```

--------------------------------

### Batch Cookie Operations

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Iterates over a record of key-value pairs to set multiple cookies efficiently.

```typescript
setMultiple(cookies: Record<string, string>): void {
  Object.entries(cookies).forEach(([name, value]) => {
    this.cookieService.set(name, value, { path: '/' });
  });
}
```

--------------------------------

### Set HttpOnly Cookies on Server

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Configure cookies with security flags like httpOnly to prevent client-side access.

```typescript
import { SsrCookieService } from 'ngx-cookie-service-ssr';
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class SsrAuthService {
  constructor(
    private cookieService: SsrCookieService,
    private http: HttpClient
  ) {}

  authenticate(credentials: any): void {
    this.http.post('/api/auth', credentials).subscribe(response => {
      // Set HttpOnly cookie on server
      this.cookieService.set('sessionToken', response.token, {
        path: '/',
        secure: true,
        sameSite: 'Strict',
        httpOnly: true,      // Cannot be accessed by JavaScript
        maxAge: 86400        // 24 hours
      });
    });
  }
}
```

--------------------------------

### CookieService Method Signatures

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Definitions for standard CookieService methods.

```typescript
check(name: string): boolean

get(name: string): string

getAll(): Record<string, string>

set(
  name: string,
  value: string,
  expires?: number | Date,
  path?: string,
  domain?: string,
  secure?: boolean,
  sameSite?: SameSite,
  partitioned?: boolean
): void

set(
  name: string,
  value: string,
  options?: CookieOptions
): void

delete(
  name: string,
  path?: string,
  domain?: string,
  secure?: boolean,
  sameSite?: SameSite
): void

deleteAll(
  path?: string,
  domain?: string,
  secure?: boolean,
  sameSite?: SameSite
): void
```

--------------------------------

### Implement RobustCookieService for Error Handling

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Wraps standard CookieService methods in try-catch blocks to prevent runtime exceptions. Use this pattern to provide fallback values and log errors during cookie interactions.

```typescript
@Injectable({ providedIn: 'root' })
export class RobustCookieService {
  constructor(private cookieService: CookieService) {}

  safeGet(key: string, fallback: string = ''): string {
    try {
      const value = this.cookieService.get(key);
      return value || fallback;
    } catch (e) {
      console.error(`Failed to read cookie ${key}:`, e);
      return fallback;
    }
  }

  safeSet(key: string, value: string, options?: any): boolean {
    try {
      this.cookieService.set(key, value, options);
      return true;
    } catch (e) {
      console.error(`Failed to set cookie ${key}:`, e);
      return false;
    }
  }

  safeDelete(key: string): boolean {
    try {
      this.cookieService.delete(key);
      return true;
    } catch (e) {
      console.error(`Failed to delete cookie ${key}:`, e);
      return false;
    }
  }
}
```

--------------------------------

### check(name: string): boolean

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/projects/ngx-cookie-service/README.md

Checks if a cookie with the given name exists and can be accessed.

```APIDOC
## check(name: string): boolean

### Description
Checks if a cookie with the given `name` can be accessed or found.

### Parameters
- **name** (string) - Required - The name of the cookie to check.

### Returns
- **boolean** - Returns true if the cookie exists, false otherwise.
```

--------------------------------

### Consume Preferences in an Angular Component

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Demonstrates injecting the custom preferences service to read and update user settings within a component.

```typescript
@Component({
  selector: 'app-preferences',
  template: `
    <label>
      <input type="checkbox" [checked]="compactMode" (change)="toggleCompact()">
      Compact Mode
    </label>
    <select [value]="theme" (change)="setTheme($event)">
      <option value="light">Light</option>
      <option value="dark">Dark</option>
    </select>
  `
})
export class PreferencesComponent {
  theme: string;
  compactMode: boolean;

  constructor(private preferencesService: PreferencesService) {
    this.theme = preferencesService.get('theme');
    this.compactMode = preferencesService.get('compact');
  }

  setTheme(event: Event): void {
    const theme = (event.target as HTMLSelectElement).value;
    this.preferencesService.set('theme', theme);
    this.theme = theme;
  }

  toggleCompact(): void {
    this.compactMode = !this.compactMode;
    this.preferencesService.set('compact', this.compactMode);
  }
}
```

--------------------------------

### Inject CookieService into Injectable Services

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Demonstrates injecting the service into an injectable class for use in application logic.

```typescript
import { Injectable } from '@angular/core';
import { CookieService } from 'ngx-cookie-service';

@Injectable({ providedIn: 'root' })
export class AuthService {
  constructor(private cookieService: CookieService) {}

  authenticate(token: string) {
    this.cookieService.set('authToken', token, {
      secure: true,
      sameSite: 'Strict'
    });
  }
}
```

--------------------------------

### Define Authentication Token Cookie Options

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/configuration.md

Secure sensitive authentication tokens using strict security flags, httpOnly, and explicit maxAge for SSR.

```typescript
const authOptions: CookieOptions = {
  expires: 7,                  // 7 days
  path: '/',
  secure: true,
  sameSite: 'Strict',
  httpOnly: true,              // SSR: prevent XSS access
  maxAge: 604800               // SSR: 7 days in seconds
};
this.cookieService.set('authToken', token, authOptions);
```

--------------------------------

### Mocking CookieService with Jasmine

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/usage-guide.md

Uses jasmine.createSpyObj to mock CookieService methods, preventing actual browser cookie manipulation during unit tests.

```typescript
import { TestBed } from '@angular/core/testing';
import { CookieService } from 'ngx-cookie-service';
import { MyComponent } from './my.component';

describe('MyComponent with Mocked Cookies', () => {
  let component: MyComponent;
  let cookieService: jasmine.SpyObj<CookieService>;

  beforeEach(() => {
    const cookieSpy = jasmine.createSpyObj('CookieService', [
      'set',
      'get',
      'check',
      'delete',
      'getAll',
      'deleteAll'
    ]);

    TestBed.configureTestingModule({
      declarations: [MyComponent],
      providers: [
        { provide: CookieService, useValue: cookieSpy }
      ]
    });

    component = TestBed.createComponent(MyComponent).componentInstance;
    cookieService = TestBed.inject(CookieService) as jasmine.SpyObj<CookieService>;
  });

  it('should set token on login', () => {
    component.login('user@example.com', 'password');
    expect(cookieService.set).toHaveBeenCalled();
  });

  it('should read token on init', () => {
    cookieService.get.and.returnValue('my-token');
    component.ngOnInit();
    expect(component.token).toBe('my-token');
  });
});
```

--------------------------------

### Handle Cookie Deletion with Attributes

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/errors.md

Ensure that delete() calls include the exact path, domain, and other attributes used during creation to avoid silent deletion failures.

```typescript
import { CookieService } from 'ngx-cookie-service';

@Component({
  selector: 'app-cookie-delete',
  template: `<button (click)="cleanup()">Logout</button>`
})
export class CookieDeleteComponent {
  constructor(private cookieService: CookieService) {}

  setTokenCookie() {
    // Set cookie with specific attributes
    this.cookieService.set('authToken', 'token123', {
      expires: 7,
      path: '/app',
      domain: 'example.com',
      secure: true,
      sameSite: 'Strict'
    });
  }

  cleanup() {
    // WRONG: missing attributes, delete fails silently
    this.cookieService.delete('authToken');

    // RIGHT: provide same path and domain
    this.cookieService.delete('authToken', '/app', 'example.com', true, 'Strict');
  }
}
```

--------------------------------

### Define ngx-cookie-service-ssr exports

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/types.md

Exports available from the ngx-cookie-service-ssr entry point.

```typescript
export type SameSite = 'Lax' | 'None' | 'Strict';
export interface CookieOptions { ... }
export class SsrCookieService { ... }
```

--------------------------------

### Set a Basic Cookie

Source: https://github.com/stevermeister/ngx-cookie-service/blob/master/_autodocs/index.md

Sets a simple cookie with a name and value.

```typescript
this.cookieService.set('theme', 'dark');
```
Tokens:
Raw