@types/tough-cookie

Version 4.0.5
Published 1 year ago
13.5 kB
No dependencies
MIT license

Install

npm i @types/tough-cookie

yarn add @types/tough-cookie

pnpm add @types/tough-cookie

Overview

TypeScript definitions for tough-cookie

Index

Variables

variable PrefixSecurityEnum

const PrefixSecurityEnum: Readonly<{
    DISABLED: string;
    SILENT: string;
    STRICT: string;
}>;

variable version

const version: string;

Functions

function canonicalDomain

canonicalDomain: (str: string) => string;

Transforms a domain-name into a canonical domain-name. The canonical domain-name is a trimmed, lowercased, stripped-of-leading-dot and optionally punycode-encoded domain-name (Section 5.1.2 of RFC6265). For the most part, this function is idempotent (can be run again on its output without ill effects).

function cookieCompare

cookieCompare: (a: Cookie, b: Cookie) => number;

function defaultPath

defaultPath: (path: string) => string;

Given a current request/response path, gives the Path apropriate for storing in a cookie. This is basically the "directory" of a "file" in the path, but is specified by Section 5.1.4 of the RFC.
The path parameter MUST be only the pathname part of a URI (i.e. excludes the hostname, query, fragment, etc.). This is the .pathname property of node's uri.parse() output.

function domainMatch

domainMatch: (str: string, domStr: string, canonicalize?: boolean) => boolean;

Answers "does this real domain match the domain in a cookie?". The str is the "current" domain-name and the domStr is the "cookie" domain-name. Matches according to RFC6265 Section 5.1.3, but it helps to think of it as a "suffix match".
The canonicalize parameter will run the other two parameters through canonicalDomain or not.

function formatDate

formatDate: (date: Date) => string;

Format a Date into a RFC1123 string (the RFC6265-recommended format).

function fromJSON

fromJSON: (string: string) => Cookie;

alias for Cookie.fromJSON(string)

function getPublicSuffix

getPublicSuffix: (hostname: string) => string | null;

function parse

parse: (
    cookieString: string,
    options?: Cookie.ParseOptions
) => Cookie | undefined;

alias for Cookie.parse(cookieString[, options])

function parseDate

parseDate: (string: string) => Date;

Parse a cookie date string into a Date. Parses according to RFC6265 Section 5.1.1, not Date.parse().

function pathMatch

pathMatch: (reqPath: string, cookiePath: string) => boolean;

Answers "does the request-path path-match a given cookie-path?" as per RFC6265 Section 5.1.4. Returns a boolean.
This is essentially a prefix-match where cookiePath is a prefix of reqPath.

function permuteDomain

permuteDomain: (domain: string, allowSpecialUseDomain?: boolean) => string[];

function permutePath

permutePath: (path: string) => string[];

Classes

class Cookie {}

constructor(properties?: Cookie.Properties);

creation: Date;

creationIndex: number;

domain: string;

expires: Date | 'Infinity';

extensions: string[];

hostOnly: boolean;

httpOnly: boolean;

key: string;

lastAccessed: Date;

maxAge: number | 'Infinity' | '-Infinity';

path: string;

pathIsDefault: boolean;

sameSite: string;

secure: boolean;

value: string;

canonicalizedDomain: () => string | null;

cdomain: () => string | null;

clone: () => Cookie;

cookieString: () => string;

expiryDate: (now?: number) => Date;

expiryTime: (now?: number) => number;

static fromJSON: (strOrObj: string | object) => Cookie | null;

inspect: () => string;

isPersistent: () => boolean;

static parse: (
    cookieString: string,
    options?: Cookie.ParseOptions
) => Cookie | undefined;

setExpires: (exp: Date | string) => void;

setMaxAge: (number: number) => void;

toJSON: () => { [key: string]: any };

toString: () => string;

TTL: (now?: Date) => number | typeof Infinity;

validate: () => boolean | string;

class CookieJar

class CookieJar {}

constructor

constructor(store?: Store, options?: CookieJar.Options);

method clone

clone: {
    (store?: Store): Promise<CookieJar>;
    (store: Store, cb: (err: Error, newJar: CookieJar) => void): void;
    (cb: (err: Error, newJar: CookieJar) => void): void;
};

method cloneSync

cloneSync: (store?: Store) => CookieJar;

method deserialize

static deserialize: {
    (
        serialized: CookieJar.Serialized | string,
        store?: Store
    ): Promise<CookieJar>;
    (
        serialized: string | CookieJar.Serialized,
        store: Store,
        cb: (err: Error, object: CookieJar) => void
    ): void;
    (
        serialized: string | CookieJar.Serialized,
        cb: (err: Error, object: CookieJar) => void
    ): void;
};

method deserializeSync

static deserializeSync: (
    serialized: CookieJar.Serialized | string,
    store?: Store
) => CookieJar;

method fromJSON

static fromJSON: (string: string) => CookieJar;

method getCookies

getCookies: {
    (currentUrl: string, options?: CookieJar.GetCookiesOptions): Promise<
        Cookie[]
    >;
    (
        currentUrl: string,
        options: CookieJar.GetCookiesOptions,
        cb: (err: Error, cookies: Cookie[]) => void
    ): void;
    (currentUrl: string, cb: (err: Error, cookies: Cookie[]) => void): void;
};

method getCookiesSync

getCookiesSync: (
    currentUrl: string,
    options?: CookieJar.GetCookiesOptions
) => Cookie[];

method getCookieString

getCookieString: {
    (currentUrl: string, options?: CookieJar.GetCookiesOptions): Promise<string>;
    (
        currentUrl: string,
        options: CookieJar.GetCookiesOptions,
        cb: (err: Error, cookies: string) => void
    ): void;
    (currentUrl: string, cb: (err: Error, cookies: string) => void): void;
};

method getCookieStringSync

getCookieStringSync: (
    currentUrl: string,
    options?: CookieJar.GetCookiesOptions
) => string;

method getSetCookieStrings

getSetCookieStrings: {
    (currentUrl: string, options?: CookieJar.GetCookiesOptions): Promise<
        string[]
    >;
    (
        currentUrl: string,
        options: CookieJar.GetCookiesOptions,
        cb: (err: Error, cookies: string[]) => void
    ): void;
    (currentUrl: string, cb: (err: Error, cookies: string[]) => void): void;
};

method getSetCookieStringsSync

getSetCookieStringsSync: (
    currentUrl: string,
    options?: CookieJar.GetCookiesOptions
) => string[];

method removeAllCookies

removeAllCookies: { (): Promise<void>; (cb: (err: Error) => void): void };

method removeAllCookiesSync

removeAllCookiesSync: () => void;

method serialize

serialize: {
    (): Promise<CookieJar.Serialized>;
    (cb: (err: Error, serializedObject: CookieJar.Serialized) => void): void;
};

method serializeSync

serializeSync: () => CookieJar.Serialized;

method setCookie

setCookie: {
    (
        cookieOrString: Cookie | string,
        currentUrl: string,
        options?: CookieJar.SetCookieOptions
    ): Promise<Cookie>;
    (
        cookieOrString: string | Cookie,
        currentUrl: string,
        options: CookieJar.SetCookieOptions,
        cb: (err: Error, cookie: Cookie) => void
    ): void;
    (
        cookieOrString: string | Cookie,
        currentUrl: string,
        cb: (err: Error, cookie: Cookie) => void
    ): void;
};

method setCookieSync

setCookieSync: (
    cookieOrString: Cookie | string,
    currentUrl: string,
    options?: CookieJar.SetCookieOptions
) => Cookie;

method toJSON

toJSON: () => CookieJar.Serialized;

class MemoryCookieStore

class MemoryCookieStore extends Store {}

method findCookie

findCookie: {
    (
        domain: string,
        path: string,
        key: string,
        cb: (err: Error | null, cookie: Cookie | null) => void
    ): void;
    (domain: string, path: string, key: string): Promise<Cookie>;
};

method findCookies

findCookies: {
    (
        domain: string,
        path: string,
        allowSpecialUseDomain: boolean,
        cb: (err: Error | null, cookie: Cookie[]) => void
    ): void;
    (
        domain: string,
        path: string,
        cb: (err: Error, cookie: Cookie[]) => void
    ): void;
    (domain: string, path: string, allowSpecialUseDomain?: boolean): Promise<
        Cookie[]
    >;
};

method getAllCookies

getAllCookies: {
    (cb: (err: Error | null, cookie: Cookie[]) => void): void;
    (): Promise<Cookie[]>;
};

method putCookie

putCookie: {
    (cookie: Cookie, cb: (err: Error | null) => void): void;
    (cookie: Cookie): Promise<void>;
};

method removeCookie

removeCookie: {
    (
        domain: string,
        path: string,
        key: string,
        cb: (err: Error | null) => void
    ): void;
    (domain: string, path: string, key: string): Promise<void>;
};

method removeCookies

removeCookies: {
    (domain: string, path: string, cb: (err: Error | null) => void): void;
    (domain: string, path: string): Promise<void>;
};

method updateCookie

updateCookie: {
    (
        oldCookie: Cookie,
        newCookie: Cookie,
        cb: (err: Error | null) => void
    ): void;
    (oldCookie: Cookie, newCookie: Cookie): Promise<void>;
};

class Store

abstract class Store {}

property synchronous

synchronous: boolean;

method findCookie

findCookie: (
    domain: string,
    path: string,
    key: string,
    cb: (err: Error | null, cookie: Cookie | null) => void
) => void;

method findCookies

findCookies: (
    domain: string,
    path: string,
    allowSpecialUseDomain: boolean,
    cb: (err: Error | null, cookie: Cookie[]) => void
) => void;

method getAllCookies

getAllCookies: (cb: (err: Error | null, cookie: Cookie[]) => void) => void;

method putCookie

putCookie: (cookie: Cookie, cb: (err: Error | null) => void) => void;

method removeCookie

removeCookie: (
    domain: string,
    path: string,
    key: string,
    cb: (err: Error | null) => void
) => void;

method removeCookies

removeCookies: (
    domain: string,
    path: string,
    cb: (err: Error | null) => void
) => void;

method updateCookie

updateCookie: (
    oldCookie: Cookie,
    newCookie: Cookie,
    cb: (err: Error | null) => void
) => void;

Namespaces

namespace Cookie {}

interface ParseOptions {}

loose?: boolean | undefined;

interface Properties {}

creation?: Date | undefined;

creationIndex?: number | undefined;

domain?: string | undefined;

expires?: Date | 'Infinity' | undefined;

extensions?: string[] | undefined;

hostOnly?: boolean | undefined;

httpOnly?: boolean | undefined;

key?: string | undefined;

lastAccessed?: Date | undefined;

maxAge?: number | 'Infinity' | '-Infinity' | undefined;

path?: string | undefined;

pathIsDefault?: boolean | undefined;

sameSite?: string | undefined;

secure?: boolean | undefined;

value?: string | undefined;

interface Serialized {}

[key: string]: any;

namespace CookieJar

namespace CookieJar {}

interface GetCookiesOptions

interface GetCookiesOptions {}

property allPaths

allPaths?: boolean | undefined;

property expire

expire?: boolean | undefined;

property http

http?: boolean | undefined;

property now

now?: Date | undefined;

property secure

secure?: boolean | undefined;

interface Options

interface Options {}

property allowSpecialUseDomain

allowSpecialUseDomain?: boolean | undefined;

property looseMode

looseMode?: boolean | undefined;

property prefixSecurity

prefixSecurity?: string | undefined;

property rejectPublicSuffixes

rejectPublicSuffixes?: boolean | undefined;

interface Serialized

interface Serialized {}

property cookies

cookies: Cookie.Serialized[];

property rejectPublicSuffixes

rejectPublicSuffixes: boolean;

property storeType

storeType: string;

property version

version: string;

interface SetCookieOptions

interface SetCookieOptions {}

property http

http?: boolean | undefined;

property ignoreError

ignoreError?: boolean | undefined;

property now

now?: Date | undefined;

property secure

secure?: boolean | undefined;

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/tough-cookie.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/tough-cookie)

HTML

<a href="https://www.jsdocs.io/package/@types/tough-cookie"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 4201 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/tough-cookie

Install

Overview

Index

Variables

Functions

Classes

Namespaces

Variables

variable PrefixSecurityEnum

variable version

Functions

function canonicalDomain

function cookieCompare

function defaultPath

function domainMatch

function formatDate

function fromJSON

function getPublicSuffix

function parse

function parseDate

function pathMatch

function permuteDomain

function permutePath

Classes

class Cookie

constructor

property creation

property creationIndex

property domain

property expires

property extensions

property hostOnly

property httpOnly

property key

property lastAccessed

property maxAge

property path

property pathIsDefault

property sameSite

property secure

property value

method canonicalizedDomain

method cdomain

method clone

method cookieString

method expiryDate

method expiryTime

method fromJSON

method inspect

method isPersistent

method parse

method setExpires

method setMaxAge

method toJSON

method toString

method TTL

method validate

class CookieJar

constructor

method clone

method cloneSync

method deserialize

method deserializeSync

method fromJSON

method getCookies

method getCookiesSync

method getCookieString

method getCookieStringSync

method getSetCookieStrings

method getSetCookieStringsSync

method removeAllCookies

method removeAllCookiesSync

method serialize

method serializeSync

method setCookie

method setCookieSync

method toJSON

class MemoryCookieStore

method findCookie