@cookie-store/core 0.1.0

package/.lintstagedrc.json

@@ -0,0 +1,4 @@
+{
+  "**/*.{js,mjs,ts,tsx,md,mdx}": ["eslint --fix", "prettier --check --write"],
+  "**/*.{json,yml}": ["prettier --check --write"]
+}

package/.turbo/turbo-build.log

@@ -0,0 +1,20 @@
+
+> @cookie-store/core@0.1.0 build /home/runner/work/cookie-store/cookie-store/packages/core
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/cookie-store/cookie-store/packages/core/tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+ESM dist/index.js 2.88 KB
+ESM ⚡️ Build success in 18ms
+CJS dist/index.cjs 3.94 KB
+CJS ⚡️ Build success in 18ms
+DTS Build start
+DTS ⚡️ Build success in 960ms
+DTS dist/index.d.cts 607.00 B
+DTS dist/index.d.ts  607.00 B

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @cookie-store/core
+
+## 0.1.0
+
+### Minor Changes
+
+- [`6008502`](https://github.com/junwen-k/cookie-store/commit/60085029b5ef3f426b59e3436a187c013c7fba35) Thanks [@junwen-k](https://github.com/junwen-k)! - feat: initial commit

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kwan Jun Wen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @cookie-store/core
+
+Synchronous cache for the [Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/Cookie_Store_API). Mirrors cookies in memory for synchronous reads so framework bindings can stay reactive. This package is internal and not meant for general or public use.
+
+## Scope
+
+This package targets **main thread (document)** usage for UI reactivity only. As the [Cookie Store API docs](https://developer.mozilla.org/en-US/docs/Web/API/Cookie_Store_API) state:
+
+> "The `url` option enables the modification of a cookie scoped under a particular URL. Service workers can obtain cookies that would be sent to any URL under their scope. From a document you may only obtain the cookies at the current URL, so the only valid URL in a document context is the document's URL."
+
+The `url` (`CookieStoreGetOptions`) option is strictly for service workers and is omitted from this API.
+
+## Usage
+
+```ts
+import { cookieStoreCache } from '@cookie-store/core';
+
+// Sync read
+const session = cookieStoreCache.get('session');
+
+// Writes use the native API
+await window.cookieStore.set('session', 'token', {
+  expires: Date.now() + 86400000,
+});
+```

package/dist/index.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CookieStoreCache: () => CookieStoreCache,
+  cookieStoreCache: () => cookieStoreCache
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cookie-store-cache.ts
+var _cookies, _CookieStoreCache_instances, initialize_fn, initializeCookies_fn, initializeListeners_fn, _handleChange;
+var CookieStoreCache = class {
+  constructor() {
+    __privateAdd(this, _CookieStoreCache_instances);
+    __privateAdd(this, _cookies, []);
+    __privateAdd(this, _handleChange, (event) => {
+      let nextCookies = [...__privateGet(this, _cookies)];
+      event.changed.forEach((changed) => {
+        const index = nextCookies.findIndex((c) => c.name === changed.name);
+        if (index !== -1) {
+          nextCookies[index] = changed;
+        } else {
+          nextCookies.push(changed);
+        }
+      });
+      event.deleted.forEach((deleted) => {
+        nextCookies = nextCookies.filter((c) => c.name !== deleted.name);
+      });
+      __privateSet(this, _cookies, nextCookies);
+    });
+    if (typeof window !== "undefined" && "cookieStore" in window) {
+      __privateMethod(this, _CookieStoreCache_instances, initialize_fn).call(this);
+    }
+  }
+  get(name) {
+    return __privateGet(this, _cookies).find((cookie) => cookie.name === name) ?? null;
+  }
+  getAll(name) {
+    if (name) {
+      return __privateGet(this, _cookies).filter((cookie) => cookie.name === name);
+    }
+    return __privateGet(this, _cookies);
+  }
+  addEventListener(...args) {
+    window.cookieStore?.addEventListener(...args);
+  }
+  removeEventListener(...args) {
+    window.cookieStore?.removeEventListener(...args);
+  }
+};
+_cookies = new WeakMap();
+_CookieStoreCache_instances = new WeakSet();
+initialize_fn = async function() {
+  try {
+    await __privateMethod(this, _CookieStoreCache_instances, initializeCookies_fn).call(this);
+  } catch {
+  }
+  __privateMethod(this, _CookieStoreCache_instances, initializeListeners_fn).call(this);
+};
+initializeCookies_fn = async function() {
+  const cookies = await window.cookieStore.getAll();
+  __privateSet(this, _cookies, [...cookies]);
+};
+initializeListeners_fn = function() {
+  window.cookieStore.addEventListener("change", __privateGet(this, _handleChange));
+};
+_handleChange = new WeakMap();
+var cookieStoreCache = new CookieStoreCache();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CookieStoreCache,
+  cookieStoreCache
+});

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Synchronous cache for the Cookie Store API using an immutable-on-write pattern.
+ * Maintains an in-memory mirror of cookies for synchronous read access.
+ */
+declare class CookieStoreCache {
+    #private;
+    constructor();
+    get(name: string): CookieListItem | null;
+    getAll(name?: string): CookieList;
+    addEventListener(...args: Parameters<typeof window.cookieStore.addEventListener>): void;
+    removeEventListener(...args: Parameters<typeof window.cookieStore.removeEventListener>): void;
+}
+declare const cookieStoreCache: CookieStoreCache;
+
+export { CookieStoreCache, cookieStoreCache };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Synchronous cache for the Cookie Store API using an immutable-on-write pattern.
+ * Maintains an in-memory mirror of cookies for synchronous read access.
+ */
+declare class CookieStoreCache {
+    #private;
+    constructor();
+    get(name: string): CookieListItem | null;
+    getAll(name?: string): CookieList;
+    addEventListener(...args: Parameters<typeof window.cookieStore.addEventListener>): void;
+    removeEventListener(...args: Parameters<typeof window.cookieStore.removeEventListener>): void;
+}
+declare const cookieStoreCache: CookieStoreCache;
+
+export { CookieStoreCache, cookieStoreCache };

package/dist/index.js

@@ -0,0 +1,72 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/cookie-store-cache.ts
+var _cookies, _CookieStoreCache_instances, initialize_fn, initializeCookies_fn, initializeListeners_fn, _handleChange;
+var CookieStoreCache = class {
+  constructor() {
+    __privateAdd(this, _CookieStoreCache_instances);
+    __privateAdd(this, _cookies, []);
+    __privateAdd(this, _handleChange, (event) => {
+      let nextCookies = [...__privateGet(this, _cookies)];
+      event.changed.forEach((changed) => {
+        const index = nextCookies.findIndex((c) => c.name === changed.name);
+        if (index !== -1) {
+          nextCookies[index] = changed;
+        } else {
+          nextCookies.push(changed);
+        }
+      });
+      event.deleted.forEach((deleted) => {
+        nextCookies = nextCookies.filter((c) => c.name !== deleted.name);
+      });
+      __privateSet(this, _cookies, nextCookies);
+    });
+    if (typeof window !== "undefined" && "cookieStore" in window) {
+      __privateMethod(this, _CookieStoreCache_instances, initialize_fn).call(this);
+    }
+  }
+  get(name) {
+    return __privateGet(this, _cookies).find((cookie) => cookie.name === name) ?? null;
+  }
+  getAll(name) {
+    if (name) {
+      return __privateGet(this, _cookies).filter((cookie) => cookie.name === name);
+    }
+    return __privateGet(this, _cookies);
+  }
+  addEventListener(...args) {
+    window.cookieStore?.addEventListener(...args);
+  }
+  removeEventListener(...args) {
+    window.cookieStore?.removeEventListener(...args);
+  }
+};
+_cookies = new WeakMap();
+_CookieStoreCache_instances = new WeakSet();
+initialize_fn = async function() {
+  try {
+    await __privateMethod(this, _CookieStoreCache_instances, initializeCookies_fn).call(this);
+  } catch {
+  }
+  __privateMethod(this, _CookieStoreCache_instances, initializeListeners_fn).call(this);
+};
+initializeCookies_fn = async function() {
+  const cookies = await window.cookieStore.getAll();
+  __privateSet(this, _cookies, [...cookies]);
+};
+initializeListeners_fn = function() {
+  window.cookieStore.addEventListener("change", __privateGet(this, _handleChange));
+};
+_handleChange = new WeakMap();
+var cookieStoreCache = new CookieStoreCache();
+export {
+  CookieStoreCache,
+  cookieStoreCache
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cookie-store/core",
+  "description": "Simple in-memory mirror of the Cookie Store API for synchronous reads.",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "@vitest/browser-playwright": "^4.0.18",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsup": "^8.5.0",
+    "vitest": "^4.0.18",
+    "@cookie-store/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "dev": "turbo watch build",
+    "build": "tsup",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/cookie-store-cache.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CookieStoreCache, cookieStoreCache } from './cookie-store-cache';
+
+describe('CookieStoreCache', () => {
+  beforeEach(async () => {
+    const allCookies = await window.cookieStore.getAll();
+    await Promise.all(allCookies.map((cookie) => window.cookieStore.delete(cookie.name!)));
+  });
+
+  describe('get', () => {
+    it('should return null when cookie does not exist', () => {
+      expect(cookieStoreCache.get('nonexistent')).toBeNull();
+    });
+
+    it('should return cookie after it is set', async () => {
+      await window.cookieStore.set('test', 'value123');
+
+      await vi.waitFor(() => {
+        const cookie = cookieStoreCache.get('test');
+        expect(cookie).not.toBeNull();
+        expect(cookie?.name).toBe('test');
+        expect(cookie?.value).toBe('value123');
+      });
+    });
+
+    it('should return null after cookie is deleted', async () => {
+      await window.cookieStore.set('test', 'value123');
+
+      await vi.waitFor(() => {
+        expect(cookieStoreCache.get('test')).not.toBeNull();
+      });
+
+      await window.cookieStore.delete('test');
+
+      await vi.waitFor(() => {
+        expect(cookieStoreCache.get('test')).toBeNull();
+      });
+    });
+  });
+
+  describe('getAll', () => {
+    it('should return empty array when no cookies exist', () => {
+      expect(cookieStoreCache.getAll()).toEqual([]);
+    });
+
+    it('should return all cookies as array', async () => {
+      await window.cookieStore.set('cookie1', 'value1');
+      await window.cookieStore.set('cookie2', 'value2');
+      await window.cookieStore.set('cookie3', 'value3');
+
+      await vi.waitFor(() => {
+        const cookies = cookieStoreCache.getAll();
+        expect(cookies.length).toBe(3);
+
+        const cookieMap = new Map(cookies.map((c) => [c.name, c]));
+        expect(cookieMap.get('cookie1')?.value).toBe('value1');
+        expect(cookieMap.get('cookie2')?.value).toBe('value2');
+        expect(cookieMap.get('cookie3')?.value).toBe('value3');
+      });
+    });
+  });
+
+  describe('singleton cookieStoreCache', () => {
+    it('should export a singleton instance', () => {
+      expect(cookieStoreCache).toBeInstanceOf(CookieStoreCache);
+    });
+
+    it('should work with the singleton', async () => {
+      await window.cookieStore.set('singleton-test', 'singleton-value');
+
+      await vi.waitFor(() => {
+        const cookie = cookieStoreCache.get('singleton-test');
+        expect(cookie?.value).toBe('singleton-value');
+      });
+    });
+  });
+});

package/src/cookie-store-cache.ts

@@ -0,0 +1,73 @@
+/**
+ * Synchronous cache for the Cookie Store API using an immutable-on-write pattern.
+ * Maintains an in-memory mirror of cookies for synchronous read access.
+ */
+export class CookieStoreCache {
+  #cookies: CookieList = [];
+
+  constructor() {
+    // Only initialize in browser with Cookie Store API support
+    if (typeof window !== 'undefined' && 'cookieStore' in window) {
+      this.#initialize();
+    }
+  }
+
+  async #initialize() {
+    try {
+      await this.#initializeCookies();
+    } catch {
+      // Do nothing
+    }
+    this.#initializeListeners();
+  }
+
+  async #initializeCookies() {
+    const cookies = await window.cookieStore.getAll();
+
+    this.#cookies = [...cookies];
+  }
+
+  #initializeListeners() {
+    window.cookieStore.addEventListener('change', this.#handleChange);
+  }
+
+  #handleChange = (event: CookieChangeEvent) => {
+    let nextCookies = [...this.#cookies];
+
+    event.changed.forEach((changed) => {
+      const index = nextCookies.findIndex((c) => c.name === changed.name);
+      if (index !== -1) {
+        nextCookies[index] = changed;
+      } else {
+        nextCookies.push(changed);
+      }
+    });
+
+    event.deleted.forEach((deleted) => {
+      nextCookies = nextCookies.filter((c) => c.name !== deleted.name);
+    });
+
+    this.#cookies = nextCookies;
+  };
+
+  get(name: string): CookieListItem | null {
+    return this.#cookies.find((cookie) => cookie.name === name) ?? null;
+  }
+
+  getAll(name?: string): CookieList {
+    if (name) {
+      return this.#cookies.filter((cookie) => cookie.name === name);
+    }
+    return this.#cookies;
+  }
+
+  addEventListener(...args: Parameters<typeof window.cookieStore.addEventListener>): void {
+    window.cookieStore?.addEventListener(...args);
+  }
+
+  removeEventListener(...args: Parameters<typeof window.cookieStore.removeEventListener>): void {
+    window.cookieStore?.removeEventListener(...args);
+  }
+}
+
+export const cookieStoreCache = new CookieStoreCache();

package/src/index.ts

@@ -0,0 +1,3 @@
+/* v8 ignore start */
+export * from './cookie-store-cache';
+/* v8 ignore stop */

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@cookie-store/typescript-config/browser.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts"]
+}

package/tsconfig.test.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@cookie-store/typescript-config/browser.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { playwright } from '@vitest/browser-playwright';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    browser: {
+      enabled: true,
+      headless: true,
+      provider: playwright(),
+      instances: [{ browser: 'chromium' }],
+    },
+    typecheck: {
+      enabled: true,
+      tsconfig: './tsconfig.test.json',
+    },
+    coverage: {
+      provider: 'v8',
+    },
+  },
+});