@flight-framework/core 0.2.2 → 0.2.4

package/dist/index.js

@@ -5,7 +5,7 @@ export { MetricsAggregator, createHttpObserver, createInstrumentedStream, create
 export { DEFAULT_BOT_PATTERNS, addStreamingHeaders, createConditionalStreamer, createStreamingResponse as createConditionalStreamingResponse, createStaticResponse, isBot, isSlowConnection, prefersNoStream, streamIf, supportsStreaming } from './chunk-XOIYNY4I.js';
 export { createHTMXStreamAdapter, createReactStreamAdapter, createSolidStreamAdapter, createStreamAdapter, createSvelteStreamAdapter, createVueStreamAdapter } from './chunk-MQQLYWZZ.js';
 export { createFileRouter, loadRoutes, scanRoutes } from './chunk-54HPVE7N.js';
-export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-JIW55ZVD.js';
+export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-3QP3E7HS.js';
 export { createRouteContext, error, json, parseBody, redirect } from './chunk-W6D62JCI.js';
 export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './chunk-RSVA2EYO.js';
 import './chunk-63SCEXD7.js';
@@ -22,12 +22,12 @@ import './chunk-K2CQZPCG.js';
 export { detectBoundaryType, hasUseClientDirective, hasUseServerDirective } from './chunk-PDW5WCMW.js';
 export { createServerContext, isNotFoundError, isRedirectError as isRscRedirectError, notFound, redirect as rscRedirect } from './chunk-62C7LX2E.js';
 import './chunk-ZVC3ZWLM.js';
-export { createCache } from './chunk-3AIQVGTM.js';
+export { cacheKey, cached, createCache, dedupe, jsonSerializer, memory } from './chunk-R7SQAREQ.js';
 import './chunk-SUILH4ID.js';
-export { createServer } from './chunk-6LYV4VQX.js';
+export { createServer } from './chunk-VOBQDQKX.js';
 export { createRouter } from './chunk-GCQZ4FHI.js';
 export { createMiddlewareChain } from './chunk-KWFX6WHG.js';
-export { defineConfig } from './chunk-3TPAA52K.js';
+export { defineConfig } from './chunk-IXMD5QH2.js';
 import { promises } from 'fs';
 import { dirname, join } from 'path';
 
@@ -488,17 +488,17 @@ async function generateAllStaticPaths(pageModules) {
 }
 var pageCache = /* @__PURE__ */ new Map();
 async function getOrGeneratePage(path, generateFn, revalidate) {
-  const cached = pageCache.get(path);
+  const cached2 = pageCache.get(path);
   const now = Date.now();
-  if (cached) {
+  if (cached2) {
     if (revalidate === false) {
-      return { html: cached.html, fromCache: true };
+      return { html: cached2.html, fromCache: true };
     }
-    if (now < cached.revalidateAfter) {
-      return { html: cached.html, fromCache: true };
+    if (now < cached2.revalidateAfter) {
+      return { html: cached2.html, fromCache: true };
     }
     regeneratePageInBackground(path, generateFn, revalidate || 60);
-    return { html: cached.html, fromCache: true };
+    return { html: cached2.html, fromCache: true };
   }
   const html = await generateFn();
   if (revalidate !== false) {
@@ -875,9 +875,244 @@ function createDevToolsData(startTime, options = {}) {
   };
 }
 
+// src/utils/env.ts
+function isProduction() {
+  if (typeof globalThis !== "undefined" && "process" in globalThis) {
+    const proc = globalThis.process;
+    return proc?.env?.NODE_ENV === "production";
+  }
+  if (typeof import.meta !== "undefined" && "env" in import.meta) {
+    const env = import.meta.env;
+    return env?.MODE === "production" || env?.PROD === true;
+  }
+  return false;
+}
+function isDevelopment() {
+  if (typeof globalThis !== "undefined" && "process" in globalThis) {
+    const proc = globalThis.process;
+    return proc?.env?.NODE_ENV === "development";
+  }
+  if (typeof import.meta !== "undefined" && "env" in import.meta) {
+    const env = import.meta.env;
+    return env?.MODE === "development" || env?.DEV === true;
+  }
+  return true;
+}
+function isTest() {
+  if (typeof globalThis !== "undefined" && "process" in globalThis) {
+    const proc = globalThis.process;
+    return proc?.env?.NODE_ENV === "test";
+  }
+  return false;
+}
+function isServer() {
+  return typeof window === "undefined";
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function getEnvironment() {
+  if (isProduction()) return "production";
+  if (isDevelopment()) return "development";
+  if (isTest()) return "test";
+  return "unknown";
+}
+
+// src/errors/index.ts
+var FlightError = class extends Error {
+  /** HTTP status code */
+  statusCode;
+  /** Short status message */
+  statusMessage;
+  /** Additional error data */
+  data;
+  /** Whether this is a fatal error (shows full-screen) */
+  fatal;
+  /** Unique digest for production error correlation */
+  digest;
+  constructor(options) {
+    super(options.message || options.statusMessage || "An error occurred");
+    this.name = "FlightError";
+    this.statusCode = options.statusCode;
+    this.statusMessage = options.statusMessage || getDefaultStatusMessage(options.statusCode);
+    this.data = options.data;
+    this.fatal = options.fatal ?? false;
+    if (isProduction()) {
+      this.digest = generateDigest();
+    }
+    if (options.cause) {
+      this.cause = options.cause;
+      if (options.cause.stack) {
+        this.stack = `${this.stack}
+Caused by: ${options.cause.stack}`;
+      }
+    }
+  }
+  /**
+   * Convert to plain object for serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      statusMessage: this.statusMessage,
+      data: this.data,
+      fatal: this.fatal,
+      digest: this.digest
+    };
+  }
+};
+var BadRequestError = class extends FlightError {
+  constructor(message, data) {
+    super({ statusCode: 400, message, data });
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends FlightError {
+  constructor(message, data) {
+    super({ statusCode: 401, message: message || "Unauthorized", data });
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends FlightError {
+  constructor(message, data) {
+    super({ statusCode: 403, message: message || "Forbidden", data });
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends FlightError {
+  constructor(message, data) {
+    super({ statusCode: 404, message: message || "Not Found", data });
+    this.name = "NotFoundError";
+  }
+};
+var InternalError = class extends FlightError {
+  constructor(message, data) {
+    super({ statusCode: 500, message: message || "Internal Server Error", data });
+    this.name = "InternalError";
+  }
+};
+function createError(options) {
+  if (typeof options === "string") {
+    return new FlightError({ statusCode: 500, message: options });
+  }
+  return new FlightError(options);
+}
+function notFound2(message, data) {
+  throw new NotFoundError(message, data);
+}
+function forbidden(message, data) {
+  throw new ForbiddenError(message, data);
+}
+function unauthorized(message, data) {
+  throw new UnauthorizedError(message, data);
+}
+function showError(error2) {
+  let flightError;
+  if (typeof error2 === "string") {
+    flightError = new FlightError({ statusCode: 500, message: error2 });
+  } else if (error2 instanceof FlightError) {
+    flightError = error2;
+  } else {
+    flightError = new FlightError(error2);
+  }
+  if (typeof window !== "undefined") {
+    window.__FLIGHT_ERROR__ = flightError;
+    window.dispatchEvent(new CustomEvent("flight:error", {
+      detail: flightError,
+      bubbles: true
+    }));
+  }
+}
+function clearError(options) {
+  if (typeof window !== "undefined") {
+    window.__FLIGHT_ERROR__ = null;
+    window.dispatchEvent(new CustomEvent("flight:error-clear", { bubbles: true }));
+    if (options?.redirect) {
+      window.location.href = options.redirect;
+    }
+  }
+}
+function getError() {
+  if (typeof window !== "undefined") {
+    return window.__FLIGHT_ERROR__ ?? null;
+  }
+  return null;
+}
+function isFlightError(error2) {
+  return error2 instanceof FlightError;
+}
+function isNotFoundError2(error2) {
+  return error2 instanceof NotFoundError || isFlightError(error2) && error2.statusCode === 404;
+}
+function isForbiddenError(error2) {
+  return error2 instanceof ForbiddenError || isFlightError(error2) && error2.statusCode === 403;
+}
+function isUnauthorizedError(error2) {
+  return error2 instanceof UnauthorizedError || isFlightError(error2) && error2.statusCode === 401;
+}
+function getErrorStatusCode(error2) {
+  if (isFlightError(error2)) {
+    return error2.statusCode;
+  }
+  return 500;
+}
+function createErrorResponse(error2) {
+  const flightError = isFlightError(error2) ? error2 : new InternalError(error2 instanceof Error ? error2.message : "Unknown error");
+  return new Response(
+    JSON.stringify({
+      error: flightError.statusMessage,
+      message: flightError.message,
+      statusCode: flightError.statusCode,
+      digest: flightError.digest,
+      ...isDevelopment() && flightError.data ? { data: flightError.data } : {}
+    }),
+    {
+      status: flightError.statusCode,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }
+  );
+}
+function getDefaultStatusMessage(statusCode) {
+  const messages = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    422: "Unprocessable Entity",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout"
+  };
+  return messages[statusCode] || "Error";
+}
+function generateDigest() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10);
+}
+function wrapWithDigest(error2) {
+  const wrapped = error2;
+  if (!wrapped.digest) {
+    wrapped.digest = generateDigest();
+  }
+  return wrapped;
+}
+
 // src/index.ts
 var VERSION = "0.0.1";
 
-export { VERSION, buildCacheControlHeader, createDefaultRouteRules, createDevToolsData, createHtmlStream, createISRCacheFromFlightCache, createMemoryISRCache, createRevalidateHandler, createStreamingResponse3 as createStaticStreamingResponse, expandDynamicRoutes, extractLinks, generateAllStaticPaths, getCacheOptionsFromRule, getISRCache, getOrGeneratePage, getRenderModeFromRule, getRevalidateTime, injectDevTools, isDevToolsEnabled, matchRouteRule, mergeMetadata, mergeRouteRules, prerenderRoutes, purgeAllPages, purgePage, renderMetadataToHead, resolveMetadata, revalidatePath2 as revalidatePath, revalidatePaths, revalidateTag2 as revalidateTag, setISRCache, shouldDynamicallyRender };
+export { BadRequestError, FlightError, ForbiddenError, InternalError, NotFoundError, UnauthorizedError, VERSION, buildCacheControlHeader, clearError, createDefaultRouteRules, createDevToolsData, createError, createErrorResponse, forbidden as createForbidden, createHtmlStream, createISRCacheFromFlightCache, createMemoryISRCache, notFound2 as createNotFound, createRevalidateHandler, createStreamingResponse3 as createStaticStreamingResponse, unauthorized as createUnauthorized, expandDynamicRoutes, extractLinks, generateAllStaticPaths, getCacheOptionsFromRule, getEnvironment, getError, getErrorStatusCode, getISRCache, getOrGeneratePage, getRenderModeFromRule, getRevalidateTime, injectDevTools, isBrowser, isDevToolsEnabled, isDevelopment, isFlightError, isForbiddenError as isForbidden, isNotFoundError2 as isNotFound, isProduction, isServer, isTest, isUnauthorizedError as isUnauthorized, matchRouteRule, mergeMetadata, mergeRouteRules, prerenderRoutes, purgeAllPages, purgePage, renderMetadataToHead, resolveMetadata, revalidatePath2 as revalidatePath, revalidatePaths, revalidateTag2 as revalidateTag, setISRCache, shouldDynamicallyRender, showError, wrapWithDigest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map