@b9g/platform 0.1.4 → 0.1.5

package/src/index.js

@@ -1,66 +1,259 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
-import { BasePlatform } from "./types.js";
+import * as Path from "path";
+import { readFileSync } from "fs";
+import { CustomCacheStorage } from "@b9g/cache";
+import { MemoryCache } from "@b9g/cache/memory";
 import {
-  ServiceWorkerRuntime,
-  createServiceWorkerGlobals
-} from "./service-worker.js";
+  ServiceWorkerPool
+} from "./worker-pool.js";
 import {
-  PlatformBucketStorage,
-  createBucketStorage
-} from "./directory-storage.js";
+  SingleThreadedRuntime
+} from "./single-threaded.js";
 import {
-  platformRegistry,
-  detectPlatform,
-  getPlatform,
-  getPlatformAsync
-} from "./registry.js";
+  ShovelServiceWorkerRegistration,
+  ShovelGlobalScope,
+  FetchEvent,
+  InstallEvent,
+  ActivateEvent,
+  ExtendableEvent
+} from "./runtime.js";
 import {
-  detectRuntime,
-  detectDevelopmentPlatform,
-  detectPlatforms,
-  getBestPlatformDetection,
-  resolvePlatform,
-  createPlatform,
-  displayPlatformInfo
-} from "./detection.js";
+  RequestCookieStore,
+  parseCookieHeader,
+  serializeCookie,
+  parseSetCookieHeader
+} from "./cookie-store.js";
+import { CustomBucketStorage } from "@b9g/filesystem";
 import {
-  parseTTL,
-  mergeCacheConfig,
-  validateCacheConfig,
-  createCorsHeaders,
-  mergeHeaders,
-  isPreflightRequest,
-  createPreflightResponse
-} from "./utils.js";
-import { getDirectoryHandle, getBucket, getFileSystemRoot } from "./filesystem.js";
-import { WorkerPool } from "./worker-pool.js";
+  loadConfig,
+  getCacheConfig,
+  getBucketConfig,
+  parseConfigExpr,
+  processConfigValue,
+  matchPattern,
+  createBucketFactory,
+  createCacheFactory
+} from "./config.js";
+function detectRuntime() {
+  if (typeof Bun !== "undefined" || process.versions?.bun) {
+    return "bun";
+  }
+  if (typeof Deno !== "undefined") {
+    return "deno";
+  }
+  return "node";
+}
+function detectPlatformFromPackageJSON(cwd) {
+  if (!cwd && typeof process === "undefined") {
+    return null;
+  }
+  try {
+    const pkgPath = Path.join(cwd || process.cwd(), "package.json");
+    const pkgContent = readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(pkgContent);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return selectPlatformFromDeps(deps);
+  } catch {
+    return null;
+  }
+}
+function selectPlatformFromDeps(deps) {
+  const hasBun = deps["@b9g/platform-bun"];
+  const hasNode = deps["@b9g/platform-node"];
+  const hasCloudflare = deps["@b9g/platform-cloudflare"];
+  const installedCount = [hasBun, hasNode, hasCloudflare].filter(
+    Boolean
+  ).length;
+  if (installedCount === 0)
+    return null;
+  if (installedCount === 1) {
+    if (hasBun)
+      return "bun";
+    if (hasNode)
+      return "node";
+    if (hasCloudflare)
+      return "cloudflare";
+  }
+  const runtime = detectRuntime();
+  if (runtime === "bun" && hasBun)
+    return "bun";
+  if (runtime === "node" && hasNode)
+    return "node";
+  if (hasBun)
+    return "bun";
+  if (hasNode)
+    return "node";
+  if (hasCloudflare)
+    return "cloudflare";
+  return null;
+}
+function detectDeploymentPlatform() {
+  if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+    return null;
+  }
+  if (typeof caches !== "undefined" && typeof addEventListener !== "undefined" && typeof fetch !== "undefined" && // Ensure we're not in a browser
+  typeof window === "undefined") {
+    return "cloudflare";
+  }
+  return null;
+}
+function detectDevelopmentPlatform() {
+  const pkgPlatform = detectPlatformFromPackageJSON();
+  if (pkgPlatform) {
+    return pkgPlatform;
+  }
+  const runtime = detectRuntime();
+  switch (runtime) {
+    case "bun":
+      return "bun";
+    case "deno":
+      return "deno";
+    case "node":
+    default:
+      return "node";
+  }
+}
+function resolvePlatform(options) {
+  if (options.platform) {
+    return options.platform;
+  }
+  if (options.target) {
+    return options.target;
+  }
+  const deploymentPlatform = detectDeploymentPlatform();
+  if (deploymentPlatform) {
+    return deploymentPlatform;
+  }
+  return detectDevelopmentPlatform();
+}
+async function createPlatform(platformName, options = {}) {
+  switch (platformName) {
+    case "node": {
+      const modulePath = import.meta.resolve("@b9g/platform-node");
+      const NodePlatform = await import(modulePath).then((m) => m.default);
+      return new NodePlatform(options);
+    }
+    case "bun": {
+      const modulePath = import.meta.resolve("@b9g/platform-bun");
+      const BunPlatform = await import(modulePath).then((m) => m.default);
+      return new BunPlatform(options);
+    }
+    case "cloudflare":
+    case "cloudflare-workers":
+    case "cf": {
+      const modulePath = import.meta.resolve("@b9g/platform-cloudflare");
+      const CloudflarePlatform = await import(modulePath).then(
+        (m) => m.default
+      );
+      return new CloudflarePlatform(options);
+    }
+    default:
+      throw new Error(
+        `Unknown platform: ${platformName}. Available platforms: node, bun, cloudflare`
+      );
+  }
+}
+var BasePlatform = class {
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Create cache storage
+   * Returns empty CacheStorage - applications create caches on-demand via caches.open()
+   */
+  async createCaches() {
+    return new CustomCacheStorage(
+      (name) => new MemoryCache(name)
+    );
+  }
+};
+var DefaultPlatformRegistry = class {
+  #platforms;
+  constructor() {
+    this.#platforms = /* @__PURE__ */ new Map();
+  }
+  register(name, platform) {
+    this.#platforms.set(name, platform);
+  }
+  get(name) {
+    return this.#platforms.get(name);
+  }
+  list() {
+    return Array.from(this.#platforms.keys());
+  }
+};
+var platformRegistry = new DefaultPlatformRegistry();
+function getPlatform(name) {
+  if (name) {
+    const platform2 = platformRegistry.get(name);
+    if (!platform2) {
+      const available = platformRegistry.list();
+      throw new Error(
+        `Platform '${name}' not found. Available platforms: ${available.join(", ")}`
+      );
+    }
+    return platform2;
+  }
+  const platformName = detectDeploymentPlatform() || detectDevelopmentPlatform();
+  const platform = platformRegistry.get(platformName);
+  if (!platform) {
+    throw new Error(
+      `Detected platform '${platformName}' not registered. Please register it manually or specify a platform name.`
+    );
+  }
+  return platform;
+}
+async function getPlatformAsync(name) {
+  if (name) {
+    const platform2 = platformRegistry.get(name);
+    if (!platform2) {
+      const available = platformRegistry.list();
+      throw new Error(
+        `Platform '${name}' not found. Available platforms: ${available.join(", ")}`
+      );
+    }
+    return platform2;
+  }
+  const platformName = detectDeploymentPlatform() || detectDevelopmentPlatform();
+  const platform = platformRegistry.get(platformName);
+  if (!platform) {
+    throw new Error(
+      `Detected platform '${platformName}' not registered. Please register it manually using platformRegistry.register().`
+    );
+  }
+  return platform;
+}
 export {
+  ActivateEvent,
   BasePlatform,
-  PlatformBucketStorage,
-  ServiceWorkerRuntime,
-  WorkerPool,
-  createBucketStorage,
-  createCorsHeaders,
+  CustomBucketStorage,
+  ExtendableEvent,
+  FetchEvent,
+  InstallEvent,
+  RequestCookieStore,
+  ServiceWorkerPool,
+  ShovelGlobalScope,
+  ShovelServiceWorkerRegistration,
+  SingleThreadedRuntime,
+  createBucketFactory,
+  createCacheFactory,
   createPlatform,
-  createPreflightResponse,
-  createServiceWorkerGlobals,
+  detectDeploymentPlatform,
   detectDevelopmentPlatform,
-  detectPlatform,
-  detectPlatforms,
   detectRuntime,
-  displayPlatformInfo,
-  getBestPlatformDetection,
-  getBucket,
-  getDirectoryHandle,
-  getFileSystemRoot,
+  getBucketConfig,
+  getCacheConfig,
   getPlatform,
   getPlatformAsync,
-  isPreflightRequest,
-  mergeCacheConfig,
-  mergeHeaders,
-  parseTTL,
+  loadConfig,
+  matchPattern,
+  parseConfigExpr,
+  parseCookieHeader,
+  parseSetCookieHeader,
   platformRegistry,
+  processConfigValue,
   resolvePlatform,
-  validateCacheConfig
+  serializeCookie
 };