@b9g/platform 0.1.4 → 0.1.5

package/src/cookie-store.js

@@ -0,0 +1,231 @@
+/// <reference types="./cookie-store.d.ts" />
+// src/cookie-store.ts
+function parseCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader)
+    return cookies;
+  const pairs = cookieHeader.split(/;\s*/);
+  for (const pair of pairs) {
+    const [name, ...valueParts] = pair.split("=");
+    if (name) {
+      const value = valueParts.join("=");
+      cookies.set(name.trim(), decodeURIComponent(value || ""));
+    }
+  }
+  return cookies;
+}
+function serializeCookie(cookie) {
+  let header = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+  if (cookie.expires !== void 0 && cookie.expires !== null) {
+    const date = new Date(cookie.expires);
+    header += `; Expires=${date.toUTCString()}`;
+  }
+  if (cookie.domain) {
+    header += `; Domain=${cookie.domain}`;
+  }
+  if (cookie.path) {
+    header += `; Path=${cookie.path}`;
+  } else {
+    header += `; Path=/`;
+  }
+  if (cookie.sameSite) {
+    header += `; SameSite=${cookie.sameSite.charAt(0).toUpperCase() + cookie.sameSite.slice(1)}`;
+  } else {
+    header += `; SameSite=Strict`;
+  }
+  if (cookie.partitioned) {
+    header += `; Partitioned`;
+  }
+  header += `; Secure`;
+  return header;
+}
+function parseSetCookieHeader(setCookieHeader) {
+  const parts = setCookieHeader.split(/;\s*/);
+  const [nameValue, ...attributes] = parts;
+  const [name, ...valueParts] = nameValue.split("=");
+  const value = valueParts.join("=");
+  const cookie = {
+    name: decodeURIComponent(name.trim()),
+    value: decodeURIComponent(value || "")
+  };
+  for (const attr of attributes) {
+    const [key, ...attrValueParts] = attr.split("=");
+    const attrKey = key.trim().toLowerCase();
+    const attrValue = attrValueParts.join("=").trim();
+    switch (attrKey) {
+      case "expires":
+        cookie.expires = new Date(attrValue).getTime();
+        break;
+      case "max-age":
+        cookie.expires = Date.now() + parseInt(attrValue, 10) * 1e3;
+        break;
+      case "domain":
+        cookie.domain = attrValue;
+        break;
+      case "path":
+        cookie.path = attrValue;
+        break;
+      case "secure":
+        cookie.secure = true;
+        break;
+      case "samesite":
+        cookie.sameSite = attrValue.toLowerCase();
+        break;
+      case "partitioned":
+        cookie.partitioned = true;
+        break;
+    }
+  }
+  return cookie;
+}
+var RequestCookieStore = class extends EventTarget {
+  #cookies;
+  #changes;
+  // null = deleted
+  #request;
+  // Event handler for cookie changes (spec compliance)
+  // eslint-disable-next-line no-restricted-syntax
+  onchange = null;
+  constructor(request) {
+    super();
+    this.#cookies = /* @__PURE__ */ new Map();
+    this.#changes = /* @__PURE__ */ new Map();
+    this.#request = request || null;
+    if (request) {
+      const cookieHeader = request.headers.get("cookie");
+      if (cookieHeader) {
+        const parsed = parseCookieHeader(cookieHeader);
+        for (const [name, value] of parsed) {
+          this.#cookies.set(name, { name, value });
+        }
+      }
+    }
+  }
+  /**
+   * Get a single cookie by name
+   */
+  async get(nameOrOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
+    if (!name) {
+      throw new TypeError("Cookie name is required");
+    }
+    if (this.#changes.has(name)) {
+      const change = this.#changes.get(name);
+      if (change === null || change === void 0)
+        return null;
+      return {
+        name: change.name,
+        value: change.value,
+        domain: change.domain ?? void 0,
+        path: change.path,
+        expires: change.expires ?? void 0,
+        sameSite: change.sameSite,
+        partitioned: change.partitioned
+      };
+    }
+    return this.#cookies.get(name) || null;
+  }
+  /**
+   * Get all cookies matching the filter
+   */
+  async getAll(nameOrOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
+    const result = [];
+    const allNames = /* @__PURE__ */ new Set([
+      ...this.#cookies.keys(),
+      ...this.#changes.keys()
+    ]);
+    for (const cookieName of allNames) {
+      if (name && cookieName !== name)
+        continue;
+      if (this.#changes.has(cookieName) && this.#changes.get(cookieName) === null) {
+        continue;
+      }
+      const cookie = await this.get(cookieName);
+      if (cookie) {
+        result.push(cookie);
+      }
+    }
+    return result;
+  }
+  /**
+   * Set a cookie
+   */
+  async set(nameOrOptions, value) {
+    let cookie;
+    if (typeof nameOrOptions === "string") {
+      if (value === void 0) {
+        throw new TypeError("Cookie value is required");
+      }
+      cookie = {
+        name: nameOrOptions,
+        value,
+        path: "/",
+        sameSite: "strict"
+      };
+    } else {
+      cookie = {
+        path: "/",
+        sameSite: "strict",
+        ...nameOrOptions
+      };
+    }
+    const size = cookie.name.length + cookie.value.length;
+    if (size > 4096) {
+      throw new TypeError(
+        `Cookie name+value too large: ${size} bytes (max 4096)`
+      );
+    }
+    this.#changes.set(cookie.name, cookie);
+  }
+  /**
+   * Delete a cookie
+   */
+  async delete(nameOrOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
+    if (!name) {
+      throw new TypeError("Cookie name is required");
+    }
+    this.#changes.set(name, null);
+  }
+  /**
+   * Get Set-Cookie headers for all changes
+   * This should be called when constructing the Response
+   */
+  getSetCookieHeaders() {
+    const headers = [];
+    for (const [name, change] of this.#changes) {
+      if (change === null) {
+        headers.push(
+          serializeCookie({
+            name,
+            value: "",
+            expires: 0,
+            path: "/"
+          })
+        );
+      } else {
+        headers.push(serializeCookie(change));
+      }
+    }
+    return headers;
+  }
+  /**
+   * Check if there are any pending changes
+   */
+  hasChanges() {
+    return this.#changes.size > 0;
+  }
+  /**
+   * Clear all pending changes (for testing/reset)
+   */
+  clearChanges() {
+    this.#changes.clear();
+  }
+};
+export {
+  RequestCookieStore,
+  parseCookieHeader,
+  parseSetCookieHeader,
+  serializeCookie
+};

package/src/index.d.ts

@@ -4,12 +4,192 @@
  * Platform = "ServiceWorker entrypoint loader for JavaScript runtimes"
  * Core responsibility: Take a ServiceWorker-style app file and make it run in this environment.
  */
-export type { Platform, CacheConfig, CacheBackendConfig, ServerOptions, CorsConfig, Handler, Server, ServiceWorkerOptions, ServiceWorkerInstance, PlatformDetection, PlatformRegistry, } from "./types.js";
-export { BasePlatform } from "./types.js";
-export { ServiceWorkerRuntime, createServiceWorkerGlobals, type ShovelFetchEvent, type ShovelInstallEvent, type ShovelActivateEvent, type ShovelStaticEvent, type BucketStorage as BucketStorageInterface, } from "./service-worker.js";
-export { PlatformBucketStorage, createBucketStorage, } from "./directory-storage.js";
-export { platformRegistry, detectPlatform, getPlatform, getPlatformAsync, } from "./registry.js";
-export { detectRuntime, detectDevelopmentPlatform, detectPlatforms, getBestPlatformDetection, resolvePlatform, createPlatform, displayPlatformInfo, } from "./detection.js";
-export { parseTTL, mergeCacheConfig, validateCacheConfig, createCorsHeaders, mergeHeaders, isPreflightRequest, createPreflightResponse, } from "./utils.js";
-export { getDirectoryHandle, getBucket, getFileSystemRoot } from "./filesystem.js";
-export { WorkerPool, type WorkerFactory, type PlatformWorker, type WorkerPoolOptions } from "./worker-pool.js";
+/**
+ * Platform configuration
+ * Extended by platform-specific implementations (NodePlatformOptions, etc.)
+ */
+export interface PlatformConfig {
+}
+/**
+ * Server options for platform implementations
+ */
+export interface ServerOptions {
+    /** Port to listen on */
+    port?: number;
+    /** Host to bind to */
+    host?: string;
+    /** Development mode settings */
+    development?: {
+        /** Source maps support */
+        sourceMaps?: boolean;
+        /** Verbose logging */
+        verbose?: boolean;
+    };
+}
+/**
+ * Request handler function (Web Fetch API compatible)
+ */
+export type Handler = (request: Request, context?: any) => Promise<Response> | Response;
+/**
+ * Server instance returned by platform.createServer()
+ */
+export interface Server {
+    /** Start listening for requests */
+    listen(): Promise<void>;
+    /** Stop the server */
+    close(): Promise<void>;
+    /** Get server address information */
+    address(): {
+        port: number;
+        host: string;
+    };
+    /** Get server URL */
+    readonly url: string;
+    /** Whether server is ready to accept requests */
+    readonly ready: boolean;
+}
+/**
+ * ServiceWorker entrypoint options
+ */
+export interface ServiceWorkerOptions {
+    /** Additional context to provide */
+    context?: any;
+    /** Number of worker threads (Node/Bun only) */
+    workerCount?: number;
+    /** Enable hot reload (dev mode) - forces worker mode for reliable reloading */
+    hotReload?: boolean;
+}
+/**
+ * ServiceWorker instance returned by platform
+ */
+export interface ServiceWorkerInstance {
+    /** The ServiceWorker runtime */
+    runtime: any;
+    /** Handle HTTP request */
+    handleRequest(request: Request): Promise<Response>;
+    /** Install the ServiceWorker */
+    install(): Promise<void>;
+    /** Activate the ServiceWorker */
+    activate(): Promise<void>;
+    /** Check if ready to handle requests */
+    readonly ready: boolean;
+    /** Dispose of resources */
+    dispose(): Promise<void>;
+}
+/**
+ * Platform interface - ServiceWorker entrypoint loader for JavaScript runtimes
+ *
+ * The core responsibility: "Take a ServiceWorker-style app file and make it run in this environment"
+ */
+export interface Platform {
+    /**
+     * Platform name for identification
+     */
+    readonly name: string;
+    /**
+     * Load and run a ServiceWorker-style entrypoint
+     * This is where all the platform-specific complexity lives
+     */
+    loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
+    /**
+     * SUPPORTING UTILITY - Create cache storage
+     * Returns empty CacheStorage - applications create caches on-demand via caches.open()
+     */
+    createCaches(): Promise<CacheStorage>;
+    /**
+     * SUPPORTING UTILITY - Create server instance for this platform
+     */
+    createServer(handler: Handler, options?: ServerOptions): Server;
+}
+/**
+ * Platform registry - internal implementation
+ */
+interface PlatformRegistry {
+    /** Register a platform implementation */
+    register(name: string, platform: any): void;
+    /** Get platform by name */
+    get(name: string): any | undefined;
+    /** Get all registered platforms */
+    list(): string[];
+}
+/**
+ * Detect the current JavaScript runtime
+ */
+export declare function detectRuntime(): "bun" | "deno" | "node";
+/**
+ * Detect deployment platform from environment
+ *
+ * Supports:
+ * - Cloudflare Workers
+ *
+ * Future platforms (Lambda, Vercel, Netlify, Deno) will be added post-launch
+ */
+export declare function detectDeploymentPlatform(): string | null;
+/**
+ * Detect platform for development
+ *
+ * Priority:
+ * 1. Check package.json for installed @b9g/platform-* package
+ * 2. Fallback to current runtime (bun/node/deno)
+ */
+export declare function detectDevelopmentPlatform(): string;
+/**
+ * Resolve platform name from options or auto-detect
+ *
+ * Priority:
+ * 1. Explicit --platform or --target flag
+ * 2. Deployment platform detection (production environments)
+ * 3. Development platform detection (local runtime)
+ */
+export declare function resolvePlatform(options: {
+    platform?: string;
+    target?: string;
+}): string;
+/**
+ * Create platform instance based on name
+ */
+export declare function createPlatform(platformName: string, options?: any): Promise<any>;
+/**
+ * Base platform class with shared adapter loading logic
+ * Platform implementations extend this and provide platform-specific methods
+ */
+export declare abstract class BasePlatform implements Platform {
+    config: PlatformConfig;
+    constructor(config?: PlatformConfig);
+    abstract readonly name: string;
+    abstract loadServiceWorker(entrypoint: string, options?: any): Promise<any>;
+    abstract createServer(handler: any, options?: any): any;
+    /**
+     * Create cache storage
+     * Returns empty CacheStorage - applications create caches on-demand via caches.open()
+     */
+    createCaches(): Promise<CacheStorage>;
+}
+/**
+ * Global platform registry
+ */
+declare class DefaultPlatformRegistry implements PlatformRegistry {
+    #private;
+    constructor();
+    register(name: string, platform: Platform): void;
+    get(name: string): Platform | undefined;
+    list(): string[];
+}
+/**
+ * Global platform registry instance
+ */
+export declare const platformRegistry: DefaultPlatformRegistry;
+/**
+ * Get platform by name with error handling
+ */
+export declare function getPlatform(name?: string): Platform;
+/**
+ * Get platform with async auto-registration fallback
+ */
+export declare function getPlatformAsync(name?: string): Promise<Platform>;
+export { ServiceWorkerPool, type WorkerPoolOptions, type WorkerMessage, type WorkerRequest, type WorkerResponse, type WorkerLoadMessage, type WorkerReadyMessage, type WorkerErrorMessage, type WorkerInitMessage, type WorkerInitializedMessage, } from "./worker-pool.js";
+export { SingleThreadedRuntime, type SingleThreadedRuntimeOptions, } from "./single-threaded.js";
+export { ShovelServiceWorkerRegistration, ShovelGlobalScope, FetchEvent, InstallEvent, ActivateEvent, ExtendableEvent, } from "./runtime.js";
+export { RequestCookieStore, type CookieListItem, type CookieInit, type CookieStoreGetOptions, type CookieStoreDeleteOptions, type CookieSameSite, type CookieList, parseCookieHeader, serializeCookie, parseSetCookieHeader, } from "./cookie-store.js";
+export { CustomBucketStorage } from "@b9g/filesystem";
+export { loadConfig, getCacheConfig, getBucketConfig, parseConfigExpr, processConfigValue, matchPattern, createBucketFactory, createCacheFactory, type ShovelConfig, type CacheConfig, type BucketConfig, type BucketFactoryOptions, type CacheFactoryOptions, type ProcessedShovelConfig, } from "./config.js";