@b9g/platform 0.1.4 → 0.1.5

package/src/base-platform.js

@@ -1,114 +0,0 @@
-/// <reference types="./base-platform.d.ts" />
-// src/base-platform.ts
-import { loadCacheAdapter, loadFilesystemAdapter } from "./adapter-registry.js";
-var BasePlatform = class {
-  config;
-  constructor(config = {}) {
-    this.config = config;
-  }
-  /**
-   * Create cache storage with dynamic adapter loading
-   * Uses platform defaults when specific cache types aren't configured
-   */
-  async createCaches(config) {
-    const mergedConfig = this.mergeCacheConfig(config);
-    return this.buildCacheStorage(mergedConfig);
-  }
-  /**
-   * Get platform-specific default cache configuration
-   * Subclasses override this to provide optimal defaults for their runtime
-   */
-  getDefaultCacheConfig() {
-    return {
-      pages: { type: "memory" },
-      api: { type: "memory" },
-      static: { type: "memory" }
-    };
-  }
-  /**
-   * Merge user config with platform defaults
-   */
-  mergeCacheConfig(userConfig) {
-    const defaults = this.getDefaultCacheConfig();
-    const platformConfig = this.config.caches || {};
-    return {
-      ...defaults,
-      ...platformConfig,
-      ...userConfig
-    };
-  }
-  /**
-   * Build CacheStorage instance with dynamic adapter loading
-   */
-  async buildCacheStorage(config) {
-    const caches = /* @__PURE__ */ new Map();
-    for (const [name, cacheConfig] of Object.entries(config)) {
-      if (cacheConfig && typeof cacheConfig === "object" && "type" in cacheConfig) {
-        const cache = await this.loadCacheInstance(cacheConfig);
-        caches.set(name, cache);
-      }
-    }
-    return {
-      async open(name) {
-        const cache = caches.get(name);
-        if (!cache) {
-          throw new Error(`Cache '${name}' not configured`);
-        }
-        return cache;
-      },
-      async delete(name) {
-        const deleted = caches.delete(name);
-        return deleted;
-      },
-      async has(name) {
-        return caches.has(name);
-      },
-      async keys() {
-        return Array.from(caches.keys());
-      }
-    };
-  }
-  /**
-   * Load a single cache instance using dynamic import
-   */
-  async loadCacheInstance(config) {
-    if (!config.type) {
-      throw new Error("Cache configuration must specify a type");
-    }
-    try {
-      return await loadCacheAdapter(config.type, config);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to load cache adapter: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Load filesystem adapter using dynamic import
-   */
-  async loadFilesystemAdapter(config) {
-    const fsConfig = config || this.config.filesystem || this.getDefaultFilesystemConfig();
-    if (!fsConfig.type) {
-      throw new Error("Filesystem configuration must specify a type");
-    }
-    try {
-      return await loadFilesystemAdapter(fsConfig.type, fsConfig);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to load filesystem adapter: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Get platform-specific default filesystem configuration
-   * Subclasses override this to provide optimal defaults for their runtime
-   */
-  getDefaultFilesystemConfig() {
-    return { type: "memory" };
-  }
-};
-export {
-  BasePlatform
-};

package/src/detection.d.ts

@@ -1,36 +0,0 @@
-/**
- * Platform detection utilities
- * Centralized logic for detecting JavaScript runtime and deployment platforms
- */
-import type { PlatformDetection } from "./types.js";
-/**
- * Detect the current JavaScript runtime
- */
-export declare function detectRuntime(): "bun" | "deno" | "node";
-/**
- * Detect platform for development (uses current runtime)
- */
-export declare function detectDevelopmentPlatform(): string;
-/**
- * Comprehensive platform detection with confidence scoring
- */
-export declare function detectPlatforms(): PlatformDetection[];
-/**
- * Get the best platform detection
- */
-export declare function getBestPlatformDetection(): PlatformDetection;
-/**
- * Resolve platform name from options or auto-detect
- */
-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>;
-/**
- * Display platform information (for CLI info command)
- */
-export declare function displayPlatformInfo(platformName: string): void;

package/src/detection.js

@@ -1,126 +0,0 @@
-/// <reference types="./detection.d.ts" />
-// src/detection.ts
-function detectRuntime() {
-  if (typeof Bun !== "undefined" || process.versions?.bun) {
-    return "bun";
-  }
-  if (typeof Deno !== "undefined") {
-    return "deno";
-  }
-  return "node";
-}
-function detectDevelopmentPlatform() {
-  const runtime = detectRuntime();
-  switch (runtime) {
-    case "bun":
-      return "bun";
-    case "deno":
-      return "node";
-    case "node":
-    default:
-      return "node";
-  }
-}
-function detectPlatforms() {
-  const detections = [];
-  if (typeof Bun !== "undefined") {
-    detections.push({
-      platform: "bun",
-      confidence: 0.9,
-      reasons: ["Bun global detected"]
-    });
-  }
-  if (typeof EdgeRuntime !== "undefined") {
-    detections.push({
-      platform: "vercel",
-      confidence: 0.9,
-      reasons: ["Vercel EdgeRuntime detected"]
-    });
-  }
-  if (typeof Deno !== "undefined") {
-    detections.push({
-      platform: "deno",
-      confidence: 0.9,
-      reasons: ["Deno global detected"]
-    });
-  }
-  if (typeof caches !== "undefined" && typeof Response !== "undefined" && typeof crypto !== "undefined") {
-    if (typeof addEventListener !== "undefined" && typeof fetch !== "undefined") {
-      detections.push({
-        platform: "cloudflare-workers",
-        confidence: 0.8,
-        reasons: ["Worker-like environment detected", "Web APIs available"]
-      });
-    }
-  }
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    detections.push({
-      platform: "node",
-      confidence: 0.7,
-      reasons: ["Node.js process detected"]
-    });
-  }
-  if (detections.length === 0) {
-    detections.push({
-      platform: "unknown",
-      confidence: 0,
-      reasons: ["No platform detected"]
-    });
-  }
-  return detections.sort((a, b) => b.confidence - a.confidence);
-}
-function getBestPlatformDetection() {
-  const detections = detectPlatforms();
-  return detections[0];
-}
-function resolvePlatform(options) {
-  if (options.platform) {
-    return options.platform;
-  }
-  if (options.target) {
-    return options.target;
-  }
-  return detectDevelopmentPlatform();
-}
-async function createPlatform(platformName, options = {}) {
-  switch (platformName) {
-    case "node": {
-      const modulePath = import.meta.resolve("@b9g/platform-node");
-      const { createNodePlatform } = await import(modulePath);
-      return createNodePlatform(options);
-    }
-    case "bun": {
-      const modulePath = import.meta.resolve("@b9g/platform-bun");
-      const { createBunPlatform } = await import(modulePath);
-      return createBunPlatform(options);
-    }
-    case "cloudflare":
-    case "cloudflare-workers":
-    case "cf": {
-      const modulePath = import.meta.resolve("@b9g/platform-cloudflare");
-      const { createCloudflarePlatform } = await import(modulePath);
-      return createCloudflarePlatform(options);
-    }
-    default:
-      throw new Error(
-        `Unknown platform: ${platformName}. Available platforms: node, bun, cloudflare`
-      );
-  }
-}
-function displayPlatformInfo(platformName) {
-  const runtime = detectRuntime();
-  const detection = getBestPlatformDetection();
-  console.info(`\u{1F680} Platform: ${platformName}`);
-  console.info(`\u2699\uFE0F  Runtime: ${runtime}`);
-  console.info(`\u{1F50D} Auto-detected: ${detection.platform} (confidence: ${detection.confidence})`);
-  console.info(`\u{1F4A1} Reasons: ${detection.reasons.join(", ")}`);
-}
-export {
-  createPlatform,
-  detectDevelopmentPlatform,
-  detectPlatforms,
-  detectRuntime,
-  displayPlatformInfo,
-  getBestPlatformDetection,
-  resolvePlatform
-};

package/src/directory-storage.d.ts

@@ -1,41 +0,0 @@
-/**
- * Bucket Storage implementation for ServiceWorker self.buckets API
- *
- * This implements the proposed web standard interface that parallels CacheStorage
- * for structured filesystem access in ServiceWorkers.
- */
-import type { BucketStorage as BucketStorageInterface } from "./service-worker.js";
-/**
- * Platform-agnostic bucket storage implementation
- * Uses bucket pattern where each bucket name maps to a separate filesystem root
- */
-export declare class PlatformBucketStorage implements BucketStorageInterface {
-    private buckets;
-    constructor(rootPath?: string);
-    /**
-     * Open a named bucket - creates if it doesn't exist
-     * Well-known names: 'assets', 'static', 'uploads', 'temp'
-     * Special values: '', '/', '.' return the root bucket
-     */
-    open(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Check if a named bucket exists
-     */
-    has(name: string): Promise<boolean>;
-    /**
-     * Delete a named bucket and all its contents
-     */
-    delete(name: string): Promise<boolean>;
-    /**
-     * List all available bucket names
-     */
-    keys(): Promise<string[]>;
-    /**
-     * Alias for open() - for compatibility with File System Access API naming
-     */
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-}
-/**
- * Create a BucketStorage instance from a root path
- */
-export declare function createBucketStorage(rootPath?: string): BucketStorageInterface;

package/src/directory-storage.js

@@ -1,53 +0,0 @@
-/// <reference types="./directory-storage.d.ts" />
-// src/directory-storage.ts
-import { BucketStorage, LocalBucket } from "@b9g/filesystem";
-var PlatformBucketStorage = class {
-  buckets;
-  constructor(rootPath = "./dist") {
-    this.buckets = new BucketStorage((name) => {
-      if (name === "" || name === "/" || name === ".") {
-        return new LocalBucket(rootPath);
-      }
-      return new LocalBucket(`${rootPath}/${name}`);
-    });
-  }
-  /**
-   * Open a named bucket - creates if it doesn't exist
-   * Well-known names: 'assets', 'static', 'uploads', 'temp'
-   * Special values: '', '/', '.' return the root bucket
-   */
-  async open(name) {
-    return await this.buckets.open(name);
-  }
-  /**
-   * Check if a named bucket exists
-   */
-  async has(name) {
-    return await this.buckets.has(name);
-  }
-  /**
-   * Delete a named bucket and all its contents
-   */
-  async delete(name) {
-    return await this.buckets.delete(name);
-  }
-  /**
-   * List all available bucket names
-   */
-  async keys() {
-    return await this.buckets.keys();
-  }
-  /**
-   * Alias for open() - for compatibility with File System Access API naming
-   */
-  async getDirectoryHandle(name) {
-    return await this.open(name);
-  }
-};
-function createBucketStorage(rootPath = "./dist") {
-  return new PlatformBucketStorage(rootPath);
-}
-export {
-  PlatformBucketStorage,
-  createBucketStorage
-};

package/src/filesystem.d.ts

@@ -1,16 +0,0 @@
-/**
- * File System Access API implementation
- */
-/**
- * Get the file system directory handle for the specified name
- * Auto-registers Node.js platform if no platform is detected
- */
-export declare function getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-/**
- * @deprecated Use getDirectoryHandle() instead
- */
-export declare function getBucket(name?: string): Promise<FileSystemDirectoryHandle>;
-/**
- * @deprecated Use getDirectoryHandle() instead
- */
-export declare function getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;

package/src/filesystem.js

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

package/src/registry.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-/// <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

@@ -1,175 +0,0 @@
-/**
- * ServiceWorker runtime environment for Shovel entrypoints
- *
- * Provides ServiceWorker APIs (self, addEventListener, etc.) in any JavaScript runtime
- */
-/**
- * ExtendableEvent base class following ServiceWorker spec
- */
-export declare class ExtendableEvent extends Event {
-    private promises;
-    private pendingPromises;
-    constructor(type: string, pendingPromises: Set<Promise<any>>);
-    waitUntil(promise: Promise<any>): void;
-    getPromises(): Promise<any>[];
-}
-/**
- * ServiceWorker-style fetch event
- */
-export declare class FetchEvent extends ExtendableEvent {
-    readonly request: Request;
-    private responsePromise;
-    private responded;
-    constructor(request: Request, pendingPromises: Set<Promise<any>>);
-    respondWith(response: Response | Promise<Response>): void;
-    getResponse(): Promise<Response> | null;
-    hasResponded(): boolean;
-}
-/**
- * ServiceWorker-style install event
- */
-export declare class InstallEvent extends ExtendableEvent {
-    constructor(pendingPromises: Set<Promise<any>>);
-}
-/**
- * ServiceWorker-style activate event
- */
-export declare class ActivateEvent extends ExtendableEvent {
-    constructor(pendingPromises: Set<Promise<any>>);
-}
-/**
- * Legacy interfaces for backward compatibility
- */
-export interface ShovelFetchEvent extends Event {
-    readonly type: "fetch";
-    readonly request: Request;
-    respondWith(response: Response | Promise<Response>): void;
-    waitUntil(promise: Promise<any>): void;
-}
-export interface ShovelInstallEvent extends Event {
-    readonly type: "install";
-    waitUntil(promise: Promise<any>): void;
-}
-export interface ShovelActivateEvent extends Event {
-    readonly type: "activate";
-    waitUntil(promise: Promise<any>): void;
-}
-/**
- * ServiceWorker runtime that can be embedded in any platform
- */
-export declare class ServiceWorkerRuntime extends EventTarget {
-    private pendingPromises;
-    private isInstalled;
-    private isActivated;
-    private eventListeners;
-    constructor();
-    addEventListener(type: string, listener: Function): void;
-    removeEventListener(type: string, listener: Function): void;
-    /**
-     * Create a fetch event and dispatch it
-     */
-    handleRequest(request: Request): Promise<Response>;
-    /**
-     * Install the ServiceWorker
-     */
-    install(): Promise<void>;
-    /**
-     * Activate the ServiceWorker
-     */
-    activate(): Promise<void>;
-    /**
-     * 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;
-}
-/**
- * Bucket storage interface - parallels CacheStorage for filesystem access
- * This could become a future web standard
- */
-export interface BucketStorage {
-    /**
-     * Open a named bucket - returns FileSystemDirectoryHandle (root of that bucket)
-     * Well-known names: 'assets', 'static', 'uploads', 'temp'
-     */
-    open(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Alias for open() - for compatibility with File System Access API naming
-     */
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Check if a named bucket exists
-     */
-    has(name: string): Promise<boolean>;
-    /**
-     * Delete a named bucket and all its contents
-     */
-    delete(name: string): Promise<boolean>;
-    /**
-     * List all available bucket names
-     */
-    keys(): Promise<string[]>;
-}
-/**
- * Create ServiceWorker globals for a module context
- */
-export declare function createServiceWorkerGlobals(runtime: ServiceWorkerRuntime, options?: {
-    caches?: any;
-    buckets?: BucketStorage;
-    isDevelopment?: boolean;
-    hotReload?: () => Promise<void>;
-}): {
-    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;
-    };
-    caches: any;
-    buckets: BucketStorage;
-    self: ServiceWorkerRuntime;
-    addEventListener: any;
-    removeEventListener: any;
-    dispatchEvent: any;
-    skipWaiting: () => Promise<void>;
-    clients: {
-        claim(): Promise<void>;
-        get(id: string): Promise<any>;
-        matchAll(options?: any): Promise<any[]>;
-        openWindow(url: string | URL): Promise<any>;
-    };
-};