devflare 1.0.0-next.21 → 1.0.0-next.23

package/dist/index-3tkzn06q.js

@@ -0,0 +1,413 @@
+import {
+  createContextProxy,
+  createFetchEvent,
+  getContextOrNull,
+  runWithEventContext
+} from "./index-c1cj9085.js";
+
+// src/runtime/exports.ts
+function createReadonlyProxy(getter, name) {
+  return createContextProxy(getter, name, { mutable: false });
+}
+var env = createReadonlyProxy(() => getContextOrNull()?.env, "env");
+var vars = createReadonlyProxy(() => getContextOrNull()?.env, "vars");
+var ctx = createReadonlyProxy(() => getContextOrNull()?.ctx, "ctx");
+var event = createReadonlyProxy(() => getContextOrNull()?.event, "event");
+var locals = createContextProxy(() => getContextOrNull()?.locals, "locals");
+// src/runtime/middleware.ts
+var FETCH_SEQUENCE_SYMBOL = Symbol.for("devflare.fetch-sequence");
+var FETCH_RESOLVE_STYLE_SYMBOL = Symbol.for("devflare.fetch-resolve-style");
+var FETCH_WORKER_STYLE_SYMBOL = Symbol.for("devflare.fetch-worker-style");
+var QUEUE_WORKER_STYLE_SYMBOL = Symbol.for("devflare.queue-worker-style");
+var SCHEDULED_WORKER_STYLE_SYMBOL = Symbol.for("devflare.scheduled-worker-style");
+function createNotFoundResponse() {
+  return new Response("Not Found", { status: 404 });
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function markResolveStyle(handler) {
+  Object.defineProperty(handler, FETCH_RESOLVE_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function markWorkerStyle(handler) {
+  Object.defineProperty(handler, FETCH_WORKER_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function defineFetchHandler(handler, options) {
+  if (options?.style === "resolve") {
+    return markResolveStyle(handler);
+  }
+  if (options?.style === "worker") {
+    return markWorkerStyle(handler);
+  }
+  return handler;
+}
+function hasResolveStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[FETCH_RESOLVE_STYLE_SYMBOL] || record[FETCH_SEQUENCE_SYMBOL]);
+}
+function hasWorkerStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[FETCH_WORKER_STYLE_SYMBOL]);
+}
+function isResolveStyleFunction(handler) {
+  return hasResolveStyleMarker(handler);
+}
+function assertExplicit2ArgStyle(handler) {
+  if (handler.length !== 2) {
+    return;
+  }
+  if (hasResolveStyleMarker(handler) || hasWorkerStyleMarker(handler)) {
+    return;
+  }
+  throw new Error("[devflare] Ambiguous 2-argument fetch handler. The calling convention must be declared explicitly via " + "`defineFetchHandler(fn, { style: 'resolve' })` (for `(event, resolve) => Response`) or " + "`defineFetchHandler(fn, { style: 'worker' })` (for `(request, env) => Response`). " + "Single-arg `(event) => Response` and 3-arg worker-style `(request, env, ctx) => Response` " + "handlers do not require wrapping.");
+}
+function defineQueueHandler(handler) {
+  Object.defineProperty(handler, QUEUE_WORKER_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function defineScheduledHandler(handler) {
+  Object.defineProperty(handler, SCHEDULED_WORKER_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function hasQueueWorkerStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[QUEUE_WORKER_STYLE_SYMBOL]);
+}
+function hasScheduledWorkerStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[SCHEDULED_WORKER_STYLE_SYMBOL]);
+}
+function assertExplicitQueueHandlerStyle(handler) {
+  if (handler.length !== 2) {
+    return;
+  }
+  if (hasQueueWorkerStyleMarker(handler)) {
+    return;
+  }
+  throw new Error("[devflare] Ambiguous 2-argument queue handler. The calling convention must be declared explicitly via " + "`defineQueueHandler(fn)` for `(batch, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(batch, env, ctx) => void` handlers do not require wrapping.");
+}
+function assertExplicitScheduledHandlerStyle(handler) {
+  if (handler.length !== 2) {
+    return;
+  }
+  if (hasScheduledWorkerStyleMarker(handler)) {
+    return;
+  }
+  throw new Error("[devflare] Ambiguous 2-argument scheduled handler. The calling convention must be declared explicitly via " + "`defineScheduledHandler(fn)` for `(controller, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(controller, env, ctx) => void` handlers do not require wrapping.");
+}
+function isWorkerStyleFetchFunction(handler) {
+  if (isResolveStyleFunction(handler)) {
+    return false;
+  }
+  if (handler.length >= 3) {
+    return true;
+  }
+  return hasWorkerStyleMarker(handler);
+}
+function invokeWorkerStyleFetchFunction(handler, event2) {
+  return handler(event2.request, event2.env, event2.ctx);
+}
+function bindMethod(target, key) {
+  if (!target || typeof target !== "object") {
+    return null;
+  }
+  const value = target[key];
+  if (!isFunction(value)) {
+    return null;
+  }
+  const boundHandler = value.bind(target);
+  if (isResolveStyleFunction(value)) {
+    markResolveStyle(boundHandler);
+  }
+  if (hasWorkerStyleMarker(value)) {
+    markWorkerStyle(boundHandler);
+  }
+  return boundHandler;
+}
+function createFetchSequence(middlewares) {
+  return async (event2, resolve = async () => createNotFoundResponse()) => {
+    const executeMiddleware = async (index, activeEvent) => {
+      if (index >= middlewares.length) {
+        return resolve(activeEvent);
+      }
+      const middleware = middlewares[index];
+      return middleware(activeEvent, async (nextEvent = activeEvent) => {
+        return executeMiddleware(index + 1, nextEvent);
+      });
+    };
+    return executeMiddleware(0, event2);
+  };
+}
+function sequence(...middlewares) {
+  const composed = createFetchSequence(middlewares);
+  Object.defineProperty(composed, FETCH_SEQUENCE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return markResolveStyle(composed);
+}
+function getDefaultHandleHandler(module) {
+  return bindMethod(module.default, "handle");
+}
+function getDefaultFetchHandler(module) {
+  const defaultExport = module.default;
+  if (isFunction(defaultExport)) {
+    return defaultExport;
+  }
+  return bindMethod(defaultExport, "fetch");
+}
+function getPrimaryFetchEntryCandidates(module) {
+  const candidates = [];
+  const namedHandle = isFunction(module.handle) ? module.handle : null;
+  if (namedHandle) {
+    candidates.push({
+      name: "handle",
+      handler: namedHandle
+    });
+  }
+  const namedFetch = isFunction(module.fetch) ? module.fetch : null;
+  if (namedFetch) {
+    candidates.push({
+      name: "fetch",
+      handler: namedFetch
+    });
+  }
+  const defaultHandle = getDefaultHandleHandler(module);
+  if (defaultHandle) {
+    candidates.push({
+      name: "default.handle",
+      handler: defaultHandle
+    });
+  }
+  const defaultFetch = getDefaultFetchHandler(module);
+  if (defaultFetch) {
+    candidates.push({
+      name: isFunction(module.default) ? "default" : "default.fetch",
+      handler: defaultFetch
+    });
+  }
+  return candidates;
+}
+function assertSinglePrimaryFetchEntry(candidates) {
+  if (candidates.length <= 1) {
+    return;
+  }
+  const foundEntries = candidates.map(({ name }) => `"${name}"`).join(", ");
+  throw new Error(`Ambiguous fetch entry module. Export exactly one primary fetch entry per module. ` + `Use either "fetch" or "handle" (or one default equivalent), not both. ` + `Found: ${foundEntries}`);
+}
+function resolveMethodHandler(module, method) {
+  const normalizedMethod = method.toUpperCase();
+  const directHandler = isFunction(module[normalizedMethod]) ? module[normalizedMethod] : bindMethod(module.default, normalizedMethod);
+  if (directHandler) {
+    return {
+      handler: directHandler,
+      stripBody: false
+    };
+  }
+  if (normalizedMethod === "HEAD") {
+    const getHandler = isFunction(module.GET) ? module.GET : bindMethod(module.default, "GET");
+    if (getHandler) {
+      return {
+        handler: getHandler,
+        stripBody: true
+      };
+    }
+  }
+  const allHandler = isFunction(module.ALL) ? module.ALL : bindMethod(module.default, "ALL");
+  if (allHandler) {
+    return {
+      handler: allHandler,
+      stripBody: false
+    };
+  }
+  return null;
+}
+async function invokeResolvedFetchHandler(handler, event2) {
+  if (isResolveStyleFunction(handler)) {
+    return handler(event2, async () => createNotFoundResponse());
+  }
+  if (isWorkerStyleFetchFunction(handler)) {
+    return invokeWorkerStyleFetchFunction(handler, event2);
+  }
+  assertExplicit2ArgStyle(handler);
+  return handler(event2);
+}
+function resolveFetchHandler(module) {
+  const candidates = getPrimaryFetchEntryCandidates(module);
+  assertSinglePrimaryFetchEntry(candidates);
+  return candidates[0]?.handler ?? null;
+}
+async function invokeFetchHandler(handler, event2, resolve = async () => createNotFoundResponse()) {
+  if (!isFunction(handler)) {
+    return resolve(event2);
+  }
+  if (isResolveStyleFunction(handler)) {
+    const response2 = await handler(event2, resolve);
+    return response2 ?? createNotFoundResponse();
+  }
+  if (isWorkerStyleFetchFunction(handler)) {
+    const response2 = await invokeWorkerStyleFetchFunction(handler, event2);
+    return response2 ?? createNotFoundResponse();
+  }
+  assertExplicit2ArgStyle(handler);
+  const response = await handler(event2);
+  return response ?? createNotFoundResponse();
+}
+function createResolveFetch(module, _currentEntry, initialEvent, options = {}) {
+  return async (nextEvent = initialEvent) => {
+    return runWithEventContext(nextEvent, async () => {
+      const methodResolution = resolveMethodHandler(module, nextEvent.request.method);
+      if (methodResolution) {
+        const response = await invokeResolvedFetchHandler(methodResolution.handler, nextEvent);
+        const finalResponse = response ?? createNotFoundResponse();
+        if (methodResolution.stripBody) {
+          return new Response(null, finalResponse);
+        }
+        return finalResponse;
+      }
+      if (options.fallbackResolve) {
+        return options.fallbackResolve(nextEvent);
+      }
+      return createNotFoundResponse();
+    });
+  };
+}
+async function invokeFetchModule(module, event2, fallbackResolve) {
+  const handler = resolveFetchHandler(module);
+  if (!handler) {
+    return createResolveFetch(module, null, event2, { fallbackResolve })(event2);
+  }
+  return invokeFetchHandler(handler, event2, createResolveFetch(module, handler, event2, { fallbackResolve }));
+}
+// src/runtime/router/index.ts
+function normalizePathname(pathname) {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  const trimmed = normalized.replace(/\/+$|\/+$/g, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function getPathSegments(pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname === "/") {
+    return [];
+  }
+  return normalizedPathname.slice(1).split("/").filter(Boolean).map(decodePathSegment);
+}
+function getMatchPathname(input) {
+  if (input instanceof Request) {
+    return new URL(input.url).pathname;
+  }
+  if (input instanceof URL) {
+    return input.pathname;
+  }
+  if (input.includes("://")) {
+    return new URL(input).pathname;
+  }
+  return input;
+}
+function matchRouteSegments(routeSegments, pathnameSegments) {
+  if (routeSegments.length === 0) {
+    return pathnameSegments.length === 0 ? {} : null;
+  }
+  const params = {};
+  let routeIndex = 0;
+  let pathIndex = 0;
+  while (routeIndex < routeSegments.length) {
+    const routeSegment = routeSegments[routeIndex];
+    if (routeSegment.type === "optional-rest") {
+      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
+      pathIndex = pathnameSegments.length;
+      routeIndex += 1;
+      continue;
+    }
+    if (routeSegment.type === "rest") {
+      if (pathIndex >= pathnameSegments.length) {
+        return null;
+      }
+      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
+      pathIndex = pathnameSegments.length;
+      routeIndex += 1;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === undefined) {
+      return null;
+    }
+    if (routeSegment.type === "static") {
+      if (pathnameSegment !== routeSegment.value) {
+        return null;
+      }
+    } else {
+      params[routeSegment.name] = pathnameSegment;
+    }
+    pathIndex += 1;
+    routeIndex += 1;
+  }
+  if (pathIndex !== pathnameSegments.length) {
+    return null;
+  }
+  return params;
+}
+function matchFetchRoute(routes, input) {
+  const pathnameSegments = getPathSegments(getMatchPathname(input));
+  for (const route of routes) {
+    const params = matchRouteSegments(route.segments, pathnameSegments);
+    if (params) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+}
+async function invokeRouteModules(routes, event2) {
+  const match = matchFetchRoute(routes, event2.request);
+  if (!match) {
+    return new Response("Not Found", { status: 404 });
+  }
+  const routeEvent = createFetchEvent(event2.request, event2.env, event2.ctx, {
+    params: match.params,
+    locals: event2.locals
+  });
+  return runWithEventContext(routeEvent, () => invokeFetchModule(match.route.module, routeEvent));
+}
+function createRouteResolve(routes, initialEvent) {
+  return async (nextEvent = initialEvent) => {
+    return invokeRouteModules(routes, nextEvent);
+  };
+}
+export { env, vars, ctx, event, locals, markResolveStyle, markWorkerStyle, defineFetchHandler, defineQueueHandler, defineScheduledHandler, assertExplicitQueueHandlerStyle, assertExplicitScheduledHandlerStyle, sequence, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, matchFetchRoute, invokeRouteModules, createRouteResolve };