supercookie/dist/index.d.ts

A tool for managing and creating the most versatile cookies ever seen without all the fuss.

type CookieStoreSetOptions = Partial<CookieStoreGetObject> & {
    name: string;
};
interface CookieStoreGetObject {
    name: string;
    domain: string | null;
    expires: number | null;
    partitioned: boolean;
    path: string;
    sameSite: 'strict' | 'lax' | 'none';
    secure: boolean;
    value: string | null;
}
interface CookieEvent extends Omit<Event, 'target'> {
    changed: (CookieStoreGetObject & {
        name: string;
    })[];
}
export interface SuperCookieInitOptions<V = any> {
    domain?: string;
    expires?: Date | number | string | null | false;
    name: string | number;
    partitioned?: boolean;
    path?: string;
    sameSite?: 'strict' | 'lax' | 'none';
    secure?: boolean;
    value?: V;
    preserveFalsyExpirations?: boolean;
    onReady?: () => void;
}
interface SuperCookieSetOptions<V = any> extends Omit<SuperCookieInitOptions<V>, 'name' | 'value'> {
    name?: string | number;
    value?: V;
}
interface SuperCookieDefaults<V = any> extends Omit<SuperCookieSetOptions<V>, 'expires' | 'name'> {
    expires?: Date | false;
    name: string;
}
interface CookieStoreGetReturn extends Omit<CookieStoreSetOptions, 'value' | 'expires' | 'name' | "preserveFalsyExpirations"> {
    expires: string;
    name: string;
    value: string;
}
interface SuperCookieEvent<V = any> extends Omit<CookieEvent, 'changed'> {
    changed: SuperCookieDefaults<V>[];
}
interface TargetedSuperCookieEvent<V = any> extends SuperCookieEvent<V> {
    change: SuperCookieDefaults<V>;
}
export default class SuperCookie<V = any> {
    private __pVals;
    private static __listeners;
    constructor(parameters: Omit<SuperCookieInitOptions<V>, 'name'> & {
        name: string | number;
    });
    constructor(name: SuperCookieInitOptions['name'], parameters?: Omit<SuperCookieInitOptions<V>, 'name'>);
    constructor(name: SuperCookieInitOptions['name'], value: SuperCookieInitOptions["value"], parameters?: Partial<Omit<SuperCookieInitOptions, 'name' | 'value'>>);
    get name(): string;
    set name(value: string);
    get value(): V;
    set value(value: V);
    get domain(): string;
    set domain(value: string);
    get expires(): string | number | false | Date | null;
    set expires(value: string | number | false | Date | null);
    get partitioned(): boolean;
    set partitioned(v: boolean);
    get path(): string;
    set path(value: string);
    get sameSite(): "strict" | "lax" | "none";
    set sameSite(sameSite: "strict" | "lax" | "none");
    get secure(): boolean;
    set secure(value: boolean);
    get cookie(): Partial<CookieStoreSetOptions>;
    set cookie(v: Partial<CookieStoreSetOptions>);
    get parameters(): SuperCookieDefaults<V> & {
        (): SuperCookieDefaults;
    };
    set parameters(parameters: Omit<SuperCookieSetOptions<V>, 'name'> & {
        name: string | number;
    });
    ready: boolean;
    preserveFalsyExpirations: boolean;
    private get __theThenValue();
    private __thenHolder;
    set then(v: (func: (thisArg: SuperCookie) => void) => void);
    private get __listeners();
    private __formatter;
    private set __theThenValue(value);
    addEventListener(listener: (event: TargetedSuperCookieEvent) => void): void;
    asObject: () => SuperCookieDefaults;
    copy: (name: string) => SuperCookie<V>;
    delete: () => void;
    deleteSync: () => void;
    equals: (cookie: CookieStoreGetReturn | SuperCookieSetOptions) => boolean;
    get: () => Promise<SuperCookieDefaults<V>>;
    getSync: () => {
        name: string;
        value: string;
    };
    onReady: () => void;
    removeEventListener(listener: (event: SuperCookieEvent) => void): void;
    set<SV = V>(parameters?: Omit<SuperCookieInitOptions<V>, 'name'>): Promise<void>;
    set<SV = V>(value?: SuperCookieSetOptions["value"], parameters?: Partial<Omit<SuperCookieSetOptions, 'name' | 'value'>>): Promise<void>;
    setSync<SV = V>(parameters?: Omit<SuperCookieInitOptions<SV>, 'name'>): void;
    setSync<SV = V>(value: any, parameters?: Omit<SuperCookieInitOptions<SV>, 'name' | 'value'>): void;
    get then(): (func: (thisArg: SuperCookie) => void) => void;
    toString: () => string;
    static addEventListener<V = any>(listener: (evt: SuperCookieEvent<V>) => void): void;
    static copy(name: string, newName: string, { preserveFalsyExpirations }?: {
        preserveFalsyExpirations?: boolean;
    }): Promise<SuperCookie<any>>;
    static delete(name: string, pathAndDomain: {
        path?: string;
        domain?: string;
    }): void;
    static delete(name: string, path?: string): void;
    static get(name: string, options?: {
        preserveFalsyExpirations?: boolean;
    }): Promise<SuperCookieDefaults<any>>;
    static getAll(options: {
        preserveFalsyExpirations?: boolean;
    }): Promise<SuperCookieDefaults[]>;
    static getSync: (cookieName: string, options?: {
        preserveFalsyExpirations?: boolean;
    }) => {
        name: string;
        value: string;
    };
    static getAllSync: (options?: {
        preserveFalsyExpirations?: boolean;
    }) => {
        name: string;
        value: any;
    }[];
    static equals: (cookie1: SuperCookie | SuperCookieSetOptions | CookieStoreGetReturn, cookie2: SuperCookie | SuperCookieSetOptions | CookieStoreGetReturn) => boolean;
    static removeEventListener(listener: (changes: CookieEvent) => void): void;
    static set<V = any>(parameters: SuperCookieSetOptions<V> & {
        name: string | number;
    }): Promise<void>;
    static set<V = any>(name: SuperCookieSetOptions['name'], parameters?: Omit<SuperCookieSetOptions<V>, 'name'>): Promise<void>;
    static set<V = any>(name: SuperCookieSetOptions['name'], value: V, parameters?: Partial<Omit<SuperCookieSetOptions, 'name' | 'value'>>): Promise<void>;
    static setSync<SV = any>(params?: SuperCookieInitOptions<SV>): void;
    static setSync<SV = any>(name: string, params?: Omit<SuperCookieInitOptions<SV>, 'name'>): void;
    static setSync<SV = any>(name: string, value: SV, params?: Omit<SuperCookieInitOptions<SV>, 'name' | 'value'>): void;
    private static get __cookieStore();
    private static get __dCookie();
    private __prune;
    private static __compareObject;
    private static __cookievalueConvert;
    private static __formatter;
    private static __getAllSimpleSync;
    private static __sortFromArgs;
    private static __superCookieValueConvert;
}
export {};