@whatwg-node/cookie-store 0.0.1-alpha-20230425095535-e20a748

package/cjs/CookieChangeEvent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieChangeEvent = void 0;
+const events_1 = require("@whatwg-node/events");
+class CookieChangeEvent extends events_1.Event {
+    constructor(type, eventInitDict = { changed: [], deleted: [] }) {
+        super(type, eventInitDict);
+        this.changed = eventInitDict.changed || [];
+        this.deleted = eventInitDict.deleted || [];
+    }
+}
+exports.CookieChangeEvent = CookieChangeEvent;

package/cjs/CookieStore.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieStore = void 0;
+const events_1 = require("@whatwg-node/events");
+const CookieChangeEvent_js_1 = require("./CookieChangeEvent.js");
+const parse_js_1 = require("./parse.js");
+class CookieStore extends events_1.EventTarget {
+    get [Symbol.toStringTag]() {
+        return 'CookieStore';
+    }
+    constructor(cookieString) {
+        super();
+        this.cookieMap = new Map();
+        this.cookieMap = (0, parse_js_1.parse)(cookieString);
+    }
+    async get(init) {
+        if (init == null) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        else if (init instanceof Object && !Object.keys(init).length) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        return (await this.getAll(init))[0];
+    }
+    async set(init, possibleValue) {
+        var _a, _b, _c;
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            item.value = possibleValue;
+        }
+        else {
+            Object.assign(item, init);
+            if (item.path && !item.path.startsWith('/')) {
+                throw new TypeError('Cookie path must start with "/"');
+            }
+            if ((_a = item.domain) === null || _a === void 0 ? void 0 : _a.startsWith('.')) {
+                throw new TypeError('Cookie domain cannot start with "."');
+            }
+            if (((_b = item.name) === null || _b === void 0 ? void 0 : _b.startsWith('__Host')) && item.domain) {
+                throw new TypeError('Cookie domain must not be specified for host cookies');
+            }
+            if (((_c = item.name) === null || _c === void 0 ? void 0 : _c.startsWith('__Host')) && item.path !== '/') {
+                throw new TypeError('Cookie path must not be specified for host cookies');
+            }
+            if (item.path && item.path.endsWith('/')) {
+                item.path = item.path.slice(0, -1);
+            }
+            if (item.path === '') {
+                item.path = '/';
+            }
+        }
+        if (item.name === '' && item.value && item.value.includes('=')) {
+            throw new TypeError("Cookie value cannot contain '=' if the name is empty");
+        }
+        if (item.name && item.name.startsWith('__Host')) {
+            item.secure = true;
+        }
+        const previousCookie = await this.get(item);
+        this.cookieMap.set(item.name || '', item);
+        if (this.onchange) {
+            const changed = [];
+            const deleted = [];
+            if (previousCookie && !(await this.get(item))) {
+                deleted.push({ ...item, value: undefined });
+            }
+            else {
+                changed.push(item);
+            }
+            const event = new CookieChangeEvent_js_1.CookieChangeEvent('change', { changed, deleted });
+            this.onchange(event);
+        }
+    }
+    async getAll(init) {
+        const cookies = Array.from(this.cookieMap.values());
+        if (init == null || Object.keys(init).length === 0) {
+            return cookies;
+        }
+        let name;
+        if (typeof init === 'string') {
+            name = init;
+        }
+        else {
+            name = init.name;
+        }
+        return cookies.filter(cookie => cookie.name === name);
+    }
+    async delete(init) {
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+        }
+        else {
+            Object.assign(item, init);
+        }
+        item.expires = 0;
+        await this.set(item);
+    }
+    get cookieString() {
+        const cookieStrings = [];
+        for (const [, item] of this.cookieMap) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            let cookieString = `${item.name}=${encodeURIComponent(item.value)}`;
+            if (item.domain) {
+                cookieString += '; Domain=' + item.domain;
+            }
+            if (item.path) {
+                cookieString += '; Path=' + item.path;
+            }
+            if (typeof item.expires === 'number') {
+                cookieString += '; Expires=' + new Date(item.expires).toUTCString();
+            }
+            if ((item.name && item.name.startsWith('__Secure')) || item.secure) {
+                item.sameSite = 'lax';
+                cookieString += '; Secure';
+            }
+            switch (item.sameSite) {
+                case 'lax':
+                    cookieString += '; SameSite=Lax';
+                    break;
+                case 'strict':
+                    cookieString += '; SameSite=Strict';
+                    break;
+                case 'none':
+                    cookieString += '; SameSite=None';
+                    break;
+            }
+            cookieStrings.push(cookieString);
+        }
+        return cookieStrings.join('; ');
+    }
+}
+exports.CookieStore = CookieStore;

package/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./CookieChangeEvent.js"), exports);
+tslib_1.__exportStar(require("./CookieStore.js"), exports);
+tslib_1.__exportStar(require("./parse.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/parse.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const decode = decodeURIComponent;
+const pairSplitRegExp = /; */;
+// Try decoding a string using a decoding function.
+function tryDecode(str, decode) {
+    try {
+        return typeof decode === 'boolean' ? decodeURIComponent(str) : decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+function parse(str, options = {}) {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const map = new Map();
+    const opt = options || {};
+    const pairs = str.split(pairSplitRegExp);
+    const dec = opt.decode || decode;
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        let eqIdx = pair.indexOf('=');
+        // skip things that don't look like key=value
+        if (eqIdx < 0) {
+            continue;
+        }
+        const key = pair.substr(0, eqIdx).trim();
+        let val = pair.substr(++eqIdx, pair.length).trim();
+        // quoted values
+        if (val[0] === '"') {
+            val = val.slice(1, -1);
+        }
+        const cookiesPerKey = map.get(key);
+        if (!cookiesPerKey) {
+            map.set(key, { name: key, value: tryDecode(val, dec) });
+        }
+    }
+    return map;
+}
+exports.parse = parse;

package/esm/CookieChangeEvent.js

@@ -0,0 +1,8 @@
+import { Event } from '@whatwg-node/events';
+export class CookieChangeEvent extends Event {
+    constructor(type, eventInitDict = { changed: [], deleted: [] }) {
+        super(type, eventInitDict);
+        this.changed = eventInitDict.changed || [];
+        this.deleted = eventInitDict.deleted || [];
+    }
+}

package/esm/CookieStore.js

@@ -0,0 +1,146 @@
+import { EventTarget } from '@whatwg-node/events';
+import { CookieChangeEvent } from './CookieChangeEvent.js';
+import { parse } from './parse.js';
+export class CookieStore extends EventTarget {
+    get [Symbol.toStringTag]() {
+        return 'CookieStore';
+    }
+    constructor(cookieString) {
+        super();
+        this.cookieMap = new Map();
+        this.cookieMap = parse(cookieString);
+    }
+    async get(init) {
+        if (init == null) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        else if (init instanceof Object && !Object.keys(init).length) {
+            throw new TypeError('CookieStoreGetOptions must not be empty');
+        }
+        return (await this.getAll(init))[0];
+    }
+    async set(init, possibleValue) {
+        var _a, _b, _c;
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            item.value = possibleValue;
+        }
+        else {
+            Object.assign(item, init);
+            if (item.path && !item.path.startsWith('/')) {
+                throw new TypeError('Cookie path must start with "/"');
+            }
+            if ((_a = item.domain) === null || _a === void 0 ? void 0 : _a.startsWith('.')) {
+                throw new TypeError('Cookie domain cannot start with "."');
+            }
+            if (((_b = item.name) === null || _b === void 0 ? void 0 : _b.startsWith('__Host')) && item.domain) {
+                throw new TypeError('Cookie domain must not be specified for host cookies');
+            }
+            if (((_c = item.name) === null || _c === void 0 ? void 0 : _c.startsWith('__Host')) && item.path !== '/') {
+                throw new TypeError('Cookie path must not be specified for host cookies');
+            }
+            if (item.path && item.path.endsWith('/')) {
+                item.path = item.path.slice(0, -1);
+            }
+            if (item.path === '') {
+                item.path = '/';
+            }
+        }
+        if (item.name === '' && item.value && item.value.includes('=')) {
+            throw new TypeError("Cookie value cannot contain '=' if the name is empty");
+        }
+        if (item.name && item.name.startsWith('__Host')) {
+            item.secure = true;
+        }
+        const previousCookie = await this.get(item);
+        this.cookieMap.set(item.name || '', item);
+        if (this.onchange) {
+            const changed = [];
+            const deleted = [];
+            if (previousCookie && !(await this.get(item))) {
+                deleted.push({ ...item, value: undefined });
+            }
+            else {
+                changed.push(item);
+            }
+            const event = new CookieChangeEvent('change', { changed, deleted });
+            this.onchange(event);
+        }
+    }
+    async getAll(init) {
+        const cookies = Array.from(this.cookieMap.values());
+        if (init == null || Object.keys(init).length === 0) {
+            return cookies;
+        }
+        let name;
+        if (typeof init === 'string') {
+            name = init;
+        }
+        else {
+            name = init.name;
+        }
+        return cookies.filter(cookie => cookie.name === name);
+    }
+    async delete(init) {
+        const item = {
+            name: '',
+            value: '',
+            path: '/',
+            secure: false,
+            sameSite: 'strict',
+            expires: null,
+            domain: null,
+        };
+        if (typeof init === 'string') {
+            item.name = init;
+        }
+        else {
+            Object.assign(item, init);
+        }
+        item.expires = 0;
+        await this.set(item);
+    }
+    get cookieString() {
+        const cookieStrings = [];
+        for (const [, item] of this.cookieMap) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            let cookieString = `${item.name}=${encodeURIComponent(item.value)}`;
+            if (item.domain) {
+                cookieString += '; Domain=' + item.domain;
+            }
+            if (item.path) {
+                cookieString += '; Path=' + item.path;
+            }
+            if (typeof item.expires === 'number') {
+                cookieString += '; Expires=' + new Date(item.expires).toUTCString();
+            }
+            if ((item.name && item.name.startsWith('__Secure')) || item.secure) {
+                item.sameSite = 'lax';
+                cookieString += '; Secure';
+            }
+            switch (item.sameSite) {
+                case 'lax':
+                    cookieString += '; SameSite=Lax';
+                    break;
+                case 'strict':
+                    cookieString += '; SameSite=Strict';
+                    break;
+                case 'none':
+                    cookieString += '; SameSite=None';
+                    break;
+            }
+            cookieStrings.push(cookieString);
+        }
+        return cookieStrings.join('; ');
+    }
+}

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './CookieChangeEvent.js';
+export * from './CookieStore.js';
+export * from './parse.js';
+export * from './types.js';

package/esm/parse.js

@@ -0,0 +1,45 @@
+const decode = decodeURIComponent;
+const pairSplitRegExp = /; */;
+// Try decoding a string using a decoding function.
+function tryDecode(str, decode) {
+    try {
+        return typeof decode === 'boolean' ? decodeURIComponent(str) : decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+export function parse(str, options = {}) {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const map = new Map();
+    const opt = options || {};
+    const pairs = str.split(pairSplitRegExp);
+    const dec = opt.decode || decode;
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        let eqIdx = pair.indexOf('=');
+        // skip things that don't look like key=value
+        if (eqIdx < 0) {
+            continue;
+        }
+        const key = pair.substr(0, eqIdx).trim();
+        let val = pair.substr(++eqIdx, pair.length).trim();
+        // quoted values
+        if (val[0] === '"') {
+            val = val.slice(1, -1);
+        }
+        const cookiesPerKey = map.get(key);
+        if (!cookiesPerKey) {
+            map.set(key, { name: key, value: tryDecode(val, dec) });
+        }
+    }
+    return map;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@whatwg-node/cookie-store",
+  "version": "0.0.1-alpha-20230425095535-e20a748",
+  "description": "Cookie Store",
+  "sideEffects": false,
+  "dependencies": {
+    "@whatwg-node/events": "^0.0.3",
+    "tslib": "^2.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/cookie-store"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/CookieChangeEvent.d.cts

@@ -0,0 +1,7 @@
+import { Event } from '@whatwg-node/events';
+import { CookieChangeEventInit, CookieList } from './types.cjs';
+export declare class CookieChangeEvent extends Event {
+    changed: CookieList;
+    deleted: CookieList;
+    constructor(type: string, eventInitDict?: CookieChangeEventInit);
+}

package/typings/CookieChangeEvent.d.ts

@@ -0,0 +1,7 @@
+import { Event } from '@whatwg-node/events';
+import { CookieChangeEventInit, CookieList } from './types.js';
+export declare class CookieChangeEvent extends Event {
+    changed: CookieList;
+    deleted: CookieList;
+    constructor(type: string, eventInitDict?: CookieChangeEventInit);
+}

package/typings/CookieStore.d.cts

@@ -0,0 +1,14 @@
+import { EventTarget } from '@whatwg-node/events';
+import { CookieChangeEvent } from './CookieChangeEvent.cjs';
+import { Cookie, CookieListItem, CookieStoreDeleteOptions, CookieStoreGetOptions } from './types.cjs';
+export declare class CookieStore extends EventTarget {
+    onchange?: (event: CookieChangeEvent) => void;
+    private cookieMap;
+    get [Symbol.toStringTag](): 'CookieStore';
+    constructor(cookieString: string);
+    get(init?: CookieStoreGetOptions['name'] | CookieStoreGetOptions): Promise<Cookie | undefined>;
+    set(init: CookieListItem | string, possibleValue?: string): Promise<void>;
+    getAll(init?: CookieStoreGetOptions['name'] | CookieStoreGetOptions): Promise<Cookie[]>;
+    delete(init: CookieStoreDeleteOptions['name'] | CookieStoreDeleteOptions): Promise<void>;
+    get cookieString(): string;
+}

package/typings/CookieStore.d.ts

@@ -0,0 +1,14 @@
+import { EventTarget } from '@whatwg-node/events';
+import { CookieChangeEvent } from './CookieChangeEvent.js';
+import { Cookie, CookieListItem, CookieStoreDeleteOptions, CookieStoreGetOptions } from './types.js';
+export declare class CookieStore extends EventTarget {
+    onchange?: (event: CookieChangeEvent) => void;
+    private cookieMap;
+    get [Symbol.toStringTag](): 'CookieStore';
+    constructor(cookieString: string);
+    get(init?: CookieStoreGetOptions['name'] | CookieStoreGetOptions): Promise<Cookie | undefined>;
+    set(init: CookieListItem | string, possibleValue?: string): Promise<void>;
+    getAll(init?: CookieStoreGetOptions['name'] | CookieStoreGetOptions): Promise<Cookie[]>;
+    delete(init: CookieStoreDeleteOptions['name'] | CookieStoreDeleteOptions): Promise<void>;
+    get cookieString(): string;
+}

package/typings/index.d.cts

@@ -0,0 +1,4 @@
+export * from './CookieChangeEvent.cjs';
+export * from './CookieStore.cjs';
+export * from './parse.cjs';
+export * from './types.cjs';

package/typings/index.d.ts

@@ -0,0 +1,4 @@
+export * from './CookieChangeEvent.js';
+export * from './CookieStore.js';
+export * from './parse.js';
+export * from './types.js';

package/typings/parse.d.cts

@@ -0,0 +1,11 @@
+import { Cookie } from './types.cjs';
+export interface ParseOptions {
+    decode?: boolean;
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+export declare function parse(str: string, options?: ParseOptions): Map<string, Cookie>;

package/typings/parse.d.ts

@@ -0,0 +1,11 @@
+import { Cookie } from './types.js';
+export interface ParseOptions {
+    decode?: boolean;
+}
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ */
+export declare function parse(str: string, options?: ParseOptions): Map<string, Cookie>;

package/typings/types.d.cts

@@ -0,0 +1,33 @@
+export interface Cookie {
+    domain?: string;
+    expires?: number;
+    name: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: CookieSameSite;
+    value: string;
+}
+export interface CookieStoreDeleteOptions {
+    name: string;
+    domain?: string;
+    path?: string;
+}
+export interface CookieStoreGetOptions {
+    name?: string;
+    url?: string;
+}
+export type CookieSameSite = 'strict' | 'lax' | 'none';
+export interface CookieListItem {
+    name?: string;
+    value?: string;
+    domain: string | null;
+    path?: string;
+    expires: Date | number | null;
+    secure?: boolean;
+    sameSite?: CookieSameSite;
+}
+export type CookieList = CookieListItem[];
+export interface CookieChangeEventInit extends EventInit {
+    changed: CookieList;
+    deleted: CookieList;
+}

package/typings/types.d.ts

@@ -0,0 +1,33 @@
+export interface Cookie {
+    domain?: string;
+    expires?: number;
+    name: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: CookieSameSite;
+    value: string;
+}
+export interface CookieStoreDeleteOptions {
+    name: string;
+    domain?: string;
+    path?: string;
+}
+export interface CookieStoreGetOptions {
+    name?: string;
+    url?: string;
+}
+export type CookieSameSite = 'strict' | 'lax' | 'none';
+export interface CookieListItem {
+    name?: string;
+    value?: string;
+    domain: string | null;
+    path?: string;
+    expires: Date | number | null;
+    secure?: boolean;
+    sameSite?: CookieSameSite;
+}
+export type CookieList = CookieListItem[];
+export interface CookieChangeEventInit extends EventInit {
+    changed: CookieList;
+    deleted: CookieList;
+}