@b9g/platform 0.1.0

package/src/filesystem.js

@@ -0,0 +1,10 @@
+/// <reference types="./filesystem.d.ts" />
+// src/filesystem.ts
+import { getPlatformAsync } from "./registry.js";
+async function getFileSystemRoot(name) {
+  const platform = await getPlatformAsync();
+  return await platform.getFileSystemRoot(name);
+}
+export {
+  getFileSystemRoot
+};

package/src/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @b9g/platform - Platform interface for ServiceWorker entrypoint loading
+ *
+ * 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 DirectoryStorage, } from "./service-worker.js";
+export { PlatformDirectoryStorage, createDirectoryStorage, } 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 { getFileSystemRoot } from "./filesystem.js";

package/src/index.js

@@ -0,0 +1,62 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+import { BasePlatform } from "./types.js";
+import {
+  ServiceWorkerRuntime,
+  createServiceWorkerGlobals
+} from "./service-worker.js";
+import {
+  PlatformDirectoryStorage,
+  createDirectoryStorage
+} from "./directory-storage.js";
+import {
+  platformRegistry,
+  detectPlatform,
+  getPlatform,
+  getPlatformAsync
+} from "./registry.js";
+import {
+  detectRuntime,
+  detectDevelopmentPlatform,
+  detectPlatforms,
+  getBestPlatformDetection,
+  resolvePlatform,
+  createPlatform,
+  displayPlatformInfo
+} from "./detection.js";
+import {
+  parseTTL,
+  mergeCacheConfig,
+  validateCacheConfig,
+  createCorsHeaders,
+  mergeHeaders,
+  isPreflightRequest,
+  createPreflightResponse
+} from "./utils.js";
+import { getFileSystemRoot } from "./filesystem.js";
+export {
+  BasePlatform,
+  PlatformDirectoryStorage,
+  ServiceWorkerRuntime,
+  createCorsHeaders,
+  createDirectoryStorage,
+  createPlatform,
+  createPreflightResponse,
+  createServiceWorkerGlobals,
+  detectDevelopmentPlatform,
+  detectPlatform,
+  detectPlatforms,
+  detectRuntime,
+  displayPlatformInfo,
+  getBestPlatformDetection,
+  getFileSystemRoot,
+  getPlatform,
+  getPlatformAsync,
+  isPreflightRequest,
+  mergeCacheConfig,
+  mergeHeaders,
+  parseTTL,
+  platformRegistry,
+  resolvePlatform,
+  validateCacheConfig
+};

package/src/registry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Platform registry for auto-detection and management
+ */
+import type { Platform, PlatformDetection, PlatformRegistry } from "./types.js";
+/**
+ * Global platform registry
+ */
+declare class DefaultPlatformRegistry implements PlatformRegistry {
+    private platforms;
+    register(name: string, platform: Platform): void;
+    get(name: string): Platform | undefined;
+    detect(): PlatformDetection;
+    list(): string[];
+}
+/**
+ * Global platform registry instance
+ */
+export declare const platformRegistry: DefaultPlatformRegistry;
+/**
+ * Auto-detect and return the appropriate platform
+ */
+export declare function detectPlatform(): Platform | null;
+/**
+ * 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 {};

package/src/registry.js

@@ -0,0 +1,74 @@
+/// <reference types="./registry.d.ts" />
+// src/registry.ts
+import { getBestPlatformDetection } from "./detection.js";
+var DefaultPlatformRegistry = class {
+  platforms = /* @__PURE__ */ new Map();
+  register(name, platform) {
+    this.platforms.set(name, platform);
+  }
+  get(name) {
+    return this.platforms.get(name);
+  }
+  detect() {
+    return getBestPlatformDetection();
+  }
+  list() {
+    return Array.from(this.platforms.keys());
+  }
+};
+var platformRegistry = new DefaultPlatformRegistry();
+function detectPlatform() {
+  const detection = platformRegistry.detect();
+  if (detection.confidence > 0.5) {
+    const platform = platformRegistry.get(detection.platform);
+    if (platform) {
+      return platform;
+    }
+  }
+  return null;
+}
+function getPlatform(name) {
+  if (name) {
+    const platform = platformRegistry.get(name);
+    if (!platform) {
+      const available = platformRegistry.list();
+      throw new Error(
+        `Platform '${name}' not found. Available platforms: ${available.join(", ")}`
+      );
+    }
+    return platform;
+  }
+  const detected = detectPlatform();
+  if (!detected) {
+    throw new Error(
+      "No platform could be auto-detected. Please register a platform manually or specify a platform name."
+    );
+  }
+  return detected;
+}
+async function getPlatformAsync(name) {
+  if (name) {
+    const platform = platformRegistry.get(name);
+    if (!platform) {
+      const available = platformRegistry.list();
+      throw new Error(
+        `Platform '${name}' not found. Available platforms: ${available.join(", ")}`
+      );
+    }
+    return platform;
+  }
+  const detected = detectPlatform();
+  if (!detected) {
+    const { createNodePlatform } = await import("@b9g/platform-node");
+    const nodePlatform = createNodePlatform();
+    platformRegistry.register("node", nodePlatform);
+    return nodePlatform;
+  }
+  return detected;
+}
+export {
+  detectPlatform,
+  getPlatform,
+  getPlatformAsync,
+  platformRegistry
+};

package/src/service-worker.d.ts

@@ -0,0 +1,149 @@
+/**
+ * ServiceWorker runtime environment for Shovel entrypoints
+ *
+ * Provides ServiceWorker APIs (self, addEventListener, etc.) in any JavaScript runtime
+ */
+/**
+ * ServiceWorker-style fetch event
+ */
+export interface ShovelFetchEvent extends Event {
+    readonly type: "fetch";
+    readonly request: Request;
+    respondWith(response: Response | Promise<Response>): void;
+    waitUntil(promise: Promise<any>): void;
+}
+/**
+ * ServiceWorker-style install event
+ */
+export interface ShovelInstallEvent extends Event {
+    readonly type: "install";
+    waitUntil(promise: Promise<any>): void;
+}
+/**
+ * ServiceWorker-style activate event
+ */
+export interface ShovelActivateEvent extends Event {
+    readonly type: "activate";
+    waitUntil(promise: Promise<any>): void;
+}
+/**
+ * Static generation event for collecting routes
+ */
+export interface ShovelStaticEvent extends Event {
+    readonly type: "static";
+    readonly detail: {
+        outDir: string;
+        baseUrl?: string;
+    };
+    waitUntil(promise: Promise<string[]>): void;
+}
+/**
+ * ServiceWorker runtime that can be embedded in any platform
+ */
+export declare class ServiceWorkerRuntime extends EventTarget {
+    private pendingPromises;
+    private isInstalled;
+    private isActivated;
+    constructor();
+    /**
+     * Create a fetch event and dispatch it
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * Install the ServiceWorker
+     */
+    install(): Promise<void>;
+    /**
+     * Activate the ServiceWorker
+     */
+    activate(): Promise<void>;
+    /**
+     * Collect static routes for pre-rendering
+     */
+    collectStaticRoutes(outDir: string, baseUrl?: string): Promise<string[]>;
+    /**
+     * Check if ready to handle requests
+     */
+    get ready(): boolean;
+    /**
+     * Wait for all pending promises to resolve
+     */
+    waitForPending(): Promise<void>;
+    /**
+     * Reset the ServiceWorker state (for hot reloading)
+     */
+    reset(): void;
+}
+/**
+ * Directory storage interface - parallels CacheStorage for filesystem access
+ * This could become a future web standard
+ */
+export interface DirectoryStorage {
+    /**
+     * Open a named directory - returns FileSystemDirectoryHandle
+     * Well-known names: 'assets', 'static', 'server', 'client'
+     */
+    open(name: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * Check if a named directory exists
+     */
+    has(name: string): Promise<boolean>;
+    /**
+     * Delete a named directory and all its contents
+     */
+    delete(name: string): Promise<boolean>;
+    /**
+     * List all available directory names
+     */
+    keys(): Promise<string[]>;
+}
+/**
+ * Create ServiceWorker globals for a module context
+ */
+export declare function createServiceWorkerGlobals(runtime: ServiceWorkerRuntime, options?: {
+    caches?: any;
+    dirs?: DirectoryStorage;
+}): {
+    self: ServiceWorkerRuntime;
+    addEventListener: any;
+    removeEventListener: any;
+    dispatchEvent: any;
+    skipWaiting: () => Promise<void>;
+    clients: {
+        claim: () => Promise<void>;
+        matchAll: () => Promise<any[]>;
+    };
+    console: Console;
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    setInterval: typeof setInterval;
+    clearInterval: typeof clearInterval;
+    fetch: typeof fetch;
+    Request: {
+        new (input: RequestInfo | URL, init?: RequestInit): Request;
+        prototype: Request;
+    };
+    Response: {
+        new (body?: BodyInit | null, init?: ResponseInit): Response;
+        prototype: Response;
+        error(): Response;
+        json(data: any, init?: ResponseInit): Response;
+        redirect(url: string | URL, status?: number): Response;
+    };
+    Headers: {
+        new (init?: HeadersInit): Headers;
+        prototype: Headers;
+    };
+    URL: {
+        new (url: string | URL, base?: string | URL): URL;
+        prototype: URL;
+        canParse(url: string | URL, base?: string | URL): boolean;
+        createObjectURL(obj: Blob | MediaSource): string;
+        parse(url: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(url: string): void;
+    };
+    URLSearchParams: {
+        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+        prototype: URLSearchParams;
+    };
+};

package/src/service-worker.js

@@ -0,0 +1,183 @@
+/// <reference types="./service-worker.d.ts" />
+// src/service-worker.ts
+var ServiceWorkerRuntime = class extends EventTarget {
+  pendingPromises = /* @__PURE__ */ new Set();
+  isInstalled = false;
+  isActivated = false;
+  constructor() {
+    super();
+  }
+  /**
+   * Create a fetch event and dispatch it
+   */
+  async handleRequest(request) {
+    if (!this.isActivated) {
+      throw new Error("ServiceWorker not activated");
+    }
+    return new Promise((resolve, reject) => {
+      let responded = false;
+      const promises = [];
+      const event = Object.assign(new Event("fetch"), {
+        request,
+        respondWith: (response) => {
+          if (responded) {
+            throw new Error("respondWith() already called");
+          }
+          responded = true;
+          Promise.resolve(response).then(resolve).catch(reject);
+        },
+        waitUntil: (promise) => {
+          promises.push(promise);
+          this.pendingPromises.add(promise);
+          promise.finally(() => this.pendingPromises.delete(promise));
+        }
+      });
+      this.dispatchEvent(event);
+      if (!responded) {
+        reject(new Error("No response provided for fetch event"));
+      }
+      Promise.allSettled(promises).catch(console.error);
+    });
+  }
+  /**
+   * Install the ServiceWorker
+   */
+  async install() {
+    if (this.isInstalled)
+      return;
+    return new Promise((resolve, reject) => {
+      const promises = [];
+      let installCancelled = false;
+      const event = Object.assign(new Event("install"), {
+        waitUntil: (promise) => {
+          promises.push(promise);
+          this.pendingPromises.add(promise);
+          promise.finally(() => this.pendingPromises.delete(promise));
+        }
+      });
+      this.dispatchEvent(event);
+      Promise.allSettled(promises).then(() => {
+        if (!installCancelled) {
+          this.isInstalled = true;
+          resolve();
+        }
+      }).catch(reject);
+    });
+  }
+  /**
+   * Activate the ServiceWorker
+   */
+  async activate() {
+    if (!this.isInstalled) {
+      throw new Error("ServiceWorker must be installed before activation");
+    }
+    if (this.isActivated)
+      return;
+    return new Promise((resolve, reject) => {
+      const promises = [];
+      const event = Object.assign(new Event("activate"), {
+        waitUntil: (promise) => {
+          promises.push(promise);
+          this.pendingPromises.add(promise);
+          promise.finally(() => this.pendingPromises.delete(promise));
+        }
+      });
+      this.dispatchEvent(event);
+      Promise.allSettled(promises).then(() => {
+        this.isActivated = true;
+        resolve();
+      }).catch(reject);
+    });
+  }
+  /**
+   * Collect static routes for pre-rendering
+   */
+  async collectStaticRoutes(outDir, baseUrl) {
+    return new Promise((resolve, reject) => {
+      let routes = [];
+      const promises = [];
+      const event = Object.assign(new Event("static"), {
+        detail: { outDir, baseUrl },
+        waitUntil: (promise) => {
+          promises.push(
+            promise.then((routeList) => {
+              routes = routes.concat(routeList);
+            })
+          );
+          this.pendingPromises.add(promise);
+          promise.finally(() => this.pendingPromises.delete(promise));
+        }
+      });
+      this.dispatchEvent(event);
+      if (promises.length === 0) {
+        resolve([]);
+      } else {
+        Promise.allSettled(promises).then(() => resolve([...new Set(routes)])).catch(reject);
+      }
+    });
+  }
+  /**
+   * Check if ready to handle requests
+   */
+  get ready() {
+    return this.isInstalled && this.isActivated;
+  }
+  /**
+   * Wait for all pending promises to resolve
+   */
+  async waitForPending() {
+    if (this.pendingPromises.size > 0) {
+      await Promise.allSettled([...this.pendingPromises]);
+    }
+  }
+  /**
+   * Reset the ServiceWorker state (for hot reloading)
+   */
+  reset() {
+    this.isInstalled = false;
+    this.isActivated = false;
+    this.pendingPromises.clear();
+    const listeners = this._listeners;
+    if (listeners) {
+      for (const type in listeners) {
+        delete listeners[type];
+      }
+    }
+  }
+};
+function createServiceWorkerGlobals(runtime, options = {}) {
+  if (options.caches) {
+    runtime.caches = options.caches;
+  }
+  if (options.dirs) {
+    runtime.dirs = options.dirs;
+  }
+  return {
+    self: runtime,
+    addEventListener: runtime.addEventListener.bind(runtime),
+    removeEventListener: runtime.removeEventListener.bind(runtime),
+    dispatchEvent: runtime.dispatchEvent.bind(runtime),
+    // ServiceWorker-specific globals that might be useful
+    skipWaiting: () => Promise.resolve(),
+    clients: {
+      claim: () => Promise.resolve(),
+      matchAll: () => Promise.resolve([])
+    },
+    // Standard globals
+    console,
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    fetch,
+    Request,
+    Response,
+    Headers,
+    URL,
+    URLSearchParams
+  };
+}
+export {
+  ServiceWorkerRuntime,
+  createServiceWorkerGlobals
+};