@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.32

package/src/adapters/abstract/segment-path-matcher.js

@@ -1,149 +1,147 @@
-function normalizeSegmentPath(pathname) {
-  if (pathname.length > 1 && pathname.endsWith("/")) {
-    return pathname.slice(0, -1);
-  }
-  return pathname;
-}
-function matchApiPathPattern(pattern, pathname) {
-  const normalizedPattern = normalizeSegmentPath(pattern);
-  const normalizedPathname = normalizeSegmentPath(pathname);
-  const patternSegments = normalizedPattern.split("/").filter(Boolean);
-  const pathSegments = normalizedPathname.split("/").filter(Boolean);
-  const params = {};
-  let patternIndex = 0;
-  let pathIndex = 0;
-  while (patternIndex < patternSegments.length && pathIndex < pathSegments.length) {
-    const patternSegment = patternSegments[patternIndex];
-    const pathSegment = pathSegments[pathIndex];
-    if (patternSegment === "*") {
-      return params;
-    }
-    if (patternSegment.startsWith("[...") && patternSegment.endsWith("]")) {
-      const paramName = patternSegment.slice(4, -1);
-      params[paramName] = pathSegments.slice(pathIndex);
-      return params;
-    }
-    if (patternSegment.startsWith(":")) {
-      params[patternSegment.slice(1)] = pathSegment;
-      patternIndex++;
-      pathIndex++;
-      continue;
+export function normalizeSegmentPath(pathname) {
+    if (pathname.length > 1 && pathname.endsWith('/')) {
+        return pathname.slice(0, -1);
     }
-    if (patternSegment.startsWith("[") && patternSegment.endsWith("]")) {
-      params[patternSegment.slice(1, -1)] = pathSegment;
-      patternIndex++;
-      pathIndex++;
-      continue;
+    return pathname;
+}
+export function matchApiPathPattern(pattern, pathname) {
+    const normalizedPattern = normalizeSegmentPath(pattern);
+    const normalizedPathname = normalizeSegmentPath(pathname);
+    const patternSegments = normalizedPattern.split('/').filter(Boolean);
+    const pathSegments = normalizedPathname.split('/').filter(Boolean);
+    const params = {};
+    let patternIndex = 0;
+    let pathIndex = 0;
+    while (patternIndex < patternSegments.length && pathIndex < pathSegments.length) {
+        const patternSegment = patternSegments[patternIndex];
+        const pathSegment = pathSegments[pathIndex];
+        if (patternSegment === '*') {
+            return params;
+        }
+        if (patternSegment.startsWith('[...') && patternSegment.endsWith(']')) {
+            const paramName = patternSegment.slice(4, -1);
+            params[paramName] = pathSegments.slice(pathIndex);
+            return params;
+        }
+        if (patternSegment.startsWith(':')) {
+            params[patternSegment.slice(1)] = pathSegment;
+            patternIndex++;
+            pathIndex++;
+            continue;
+        }
+        if (patternSegment.startsWith('[') && patternSegment.endsWith(']')) {
+            params[patternSegment.slice(1, -1)] = pathSegment;
+            patternIndex++;
+            pathIndex++;
+            continue;
+        }
+        if (patternSegment !== pathSegment) {
+            return null;
+        }
+        patternIndex++;
+        pathIndex++;
     }
-    if (patternSegment !== pathSegment) {
-      return null;
+    if (patternIndex < patternSegments.length) {
+        const remaining = patternSegments.slice(patternIndex);
+        const catchAll = remaining[0];
+        if (remaining.length === 1 && (catchAll === '*' || (catchAll.startsWith('[...') && catchAll.endsWith(']')))) {
+            if (catchAll.startsWith('[...')) {
+                const paramName = catchAll.slice(4, -1);
+                params[paramName] = [];
+            }
+            return params;
+        }
+        return null;
     }
-    patternIndex++;
-    pathIndex++;
-  }
-  if (patternIndex < patternSegments.length) {
-    const remaining = patternSegments.slice(patternIndex);
-    const catchAll = remaining[0];
-    if (remaining.length === 1 && (catchAll === "*" || catchAll.startsWith("[...") && catchAll.endsWith("]"))) {
-      if (catchAll.startsWith("[...")) {
-        const paramName = catchAll.slice(4, -1);
-        params[paramName] = [];
-      }
-      return params;
+    if (pathIndex < pathSegments.length) {
+        return null;
     }
-    return null;
-  }
-  if (pathIndex < pathSegments.length) {
-    return null;
-  }
-  return params;
+    return params;
 }
-function scoreApiPathPattern(pattern) {
-  const segments = normalizeSegmentPath(pattern).split("/").filter(Boolean);
-  let score = 0;
-  for (const segment of segments) {
-    if (segment === "*" || segment.startsWith("[...") && segment.endsWith("]")) {
-      score += 10;
-    } else if (segment.startsWith(":") || segment.startsWith("[") && segment.endsWith("]")) {
-      score += 50;
-    } else {
-      score += 100;
+export function scoreApiPathPattern(pattern) {
+    const segments = normalizeSegmentPath(pattern).split('/').filter(Boolean);
+    let score = 0;
+    for (const segment of segments) {
+        if (segment === '*' || (segment.startsWith('[...') && segment.endsWith(']'))) {
+            score += 10;
+        }
+        else if (segment.startsWith(':') || (segment.startsWith('[') && segment.endsWith(']'))) {
+            score += 50;
+        }
+        else {
+            score += 100;
+        }
     }
-  }
-  return score;
+    return score;
 }
-function matchExplicitStaticPathPattern(pattern, pathname) {
-  const patternSegments = normalizeSegmentPath(pattern).split("/").filter(Boolean);
-  const pathSegments = normalizeSegmentPath(pathname).split("/").filter(Boolean);
-  if (patternSegments.length !== pathSegments.length) {
-    const lastPattern = patternSegments[patternSegments.length - 1];
-    const isCatchAll = lastPattern?.startsWith("[...") || lastPattern?.startsWith(":...");
-    if (!isCatchAll) {
-      return null;
-    }
-  }
-  const params = {};
-  for (let i = 0; i < patternSegments.length; i++) {
-    const patternPart = patternSegments[i];
-    const pathPart = pathSegments[i];
-    if (patternPart.startsWith(":...") || patternPart.startsWith("[...")) {
-      const paramName = patternPart.replace(/^(:\.\.\.|\[\.\.\.)/, "").replace(/\]$/, "");
-      params[paramName] = pathSegments.slice(i).join("/");
-      return params;
+export function matchExplicitStaticPathPattern(pattern, pathname) {
+    const patternSegments = normalizeSegmentPath(pattern).split('/').filter(Boolean);
+    const pathSegments = normalizeSegmentPath(pathname).split('/').filter(Boolean);
+    if (patternSegments.length !== pathSegments.length) {
+        const lastPattern = patternSegments[patternSegments.length - 1];
+        const isCatchAll = lastPattern?.startsWith('[...') || lastPattern?.startsWith(':...');
+        if (!isCatchAll) {
+            return null;
+        }
     }
-    if (patternPart.startsWith(":")) {
-      params[patternPart.slice(1)] = pathPart;
-    } else if (patternPart.startsWith("[") && patternPart.endsWith("]")) {
-      params[patternPart.slice(1, -1)] = pathPart;
-    } else if (patternPart !== pathPart) {
-      return null;
+    const params = {};
+    for (let i = 0; i < patternSegments.length; i++) {
+        const patternPart = patternSegments[i];
+        const pathPart = pathSegments[i];
+        if (patternPart.startsWith(':...') || patternPart.startsWith('[...')) {
+            const paramName = patternPart.replace(/^(:\.\.\.|\[\.\.\.)/, '').replace(/\]$/, '');
+            params[paramName] = pathSegments.slice(i).join('/');
+            return params;
+        }
+        if (patternPart.startsWith(':')) {
+            params[patternPart.slice(1)] = pathPart;
+        }
+        else if (patternPart.startsWith('[') && patternPart.endsWith(']')) {
+            params[patternPart.slice(1, -1)] = pathPart;
+        }
+        else if (patternPart !== pathPart) {
+            return null;
+        }
     }
-  }
-  return params;
+    return params;
 }
-function matchColonSegmentPath(pattern, pathname) {
-  const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = pathname.split("/").filter(Boolean);
-  if (patternSegments.length !== pathSegments.length) {
-    return null;
-  }
-  const params = {};
-  for (let i = 0; i < patternSegments.length; i++) {
-    const patternSegment = patternSegments[i];
-    const pathSegment = pathSegments[i];
-    if (!patternSegment || !pathSegment) {
-      return null;
-    }
-    if (patternSegment.startsWith(":")) {
-      const paramName = patternSegment.slice(1);
-      if (!paramName) {
+export function matchColonSegmentPath(pattern, pathname) {
+    const patternSegments = pattern.split('/').filter(Boolean);
+    const pathSegments = pathname.split('/').filter(Boolean);
+    if (patternSegments.length !== pathSegments.length) {
         return null;
-      }
-      params[paramName] = pathSegment;
-    } else if (patternSegment !== pathSegment) {
-      return null;
     }
-  }
-  return params;
+    const params = {};
+    for (let i = 0; i < patternSegments.length; i++) {
+        const patternSegment = patternSegments[i];
+        const pathSegment = pathSegments[i];
+        if (!patternSegment || !pathSegment) {
+            return null;
+        }
+        if (patternSegment.startsWith(':')) {
+            const paramName = patternSegment.slice(1);
+            if (!paramName) {
+                return null;
+            }
+            params[paramName] = pathSegment;
+        }
+        else if (patternSegment !== pathSegment) {
+            return null;
+        }
+    }
+    return params;
 }
-function scoreColonSegmentPath(pattern) {
-  const segments = pattern.split("/").filter(Boolean);
-  let literals = 0;
-  let dynamics = 0;
-  for (const segment of segments) {
-    if (segment.startsWith(":")) {
-      dynamics += 1;
-    } else {
-      literals += 1;
+export function scoreColonSegmentPath(pattern) {
+    const segments = pattern.split('/').filter(Boolean);
+    let literals = 0;
+    let dynamics = 0;
+    for (const segment of segments) {
+        if (segment.startsWith(':')) {
+            dynamics += 1;
+        }
+        else {
+            literals += 1;
+        }
     }
-  }
-  return literals * 100 - dynamics * 10 + segments.length;
+    return literals * 100 - dynamics * 10 + segments.length;
 }
-export {
-  matchApiPathPattern,
-  matchColonSegmentPath,
-  matchExplicitStaticPathPattern,
-  normalizeSegmentPath,
-  scoreApiPathPattern,
-  scoreColonSegmentPath
-};

package/src/adapters/abstract/server-adapter.js

@@ -1,15 +1,23 @@
-class AbstractServerAdapter {
-  appConfig;
-  options;
-  serveOptions;
-  runtimeOrigin;
-  constructor(options) {
-    this.appConfig = options.appConfig;
-    this.options = options.options || {};
-    this.serveOptions = options.serveOptions || {};
-    this.runtimeOrigin = options.runtimeOrigin;
-  }
+/**
+ * This file contains the abstract server adapter class and its related types.
+ * It is designed to be extended by specific server adapters for different runtimes.
+ * The class provides methods for initializing the server, creating server options,
+ * building static files, and handling HTTP requests.
+ *
+ * @module ServerAdapter
+ */
+/**
+ * Abstract base class for server adapters across different runtimes
+ */
+export class AbstractServerAdapter {
+    appConfig;
+    options;
+    serveOptions;
+    runtimeOrigin;
+    constructor(options) {
+        this.appConfig = options.appConfig;
+        this.options = options.options || {};
+        this.serveOptions = options.serveOptions || {};
+        this.runtimeOrigin = options.runtimeOrigin;
+    }
 }
-export {
-  AbstractServerAdapter
-};

package/src/adapters/abstract/ws-pattern-matcher.js

@@ -1,30 +1,28 @@
-import { matchColonSegmentPath, scoreColonSegmentPath } from "./segment-path-matcher.js";
-function matchWebSocketPath(pattern, pathname) {
-  return matchColonSegmentPath(pattern, pathname);
+import { matchColonSegmentPath, scoreColonSegmentPath } from './segment-path-matcher.js';
+/**
+ * Pattern matcher for WebSocket route paths.
+ */
+export function matchWebSocketPath(pattern, pathname) {
+    return matchColonSegmentPath(pattern, pathname);
 }
-function scoreWebSocketPattern(pattern) {
-  return scoreColonSegmentPath(pattern);
+export function scoreWebSocketPattern(pattern) {
+    return scoreColonSegmentPath(pattern);
 }
-function findWebSocketRoute(handlers, pathname) {
-  let best = null;
-  let index = 0;
-  for (const [pattern, handler] of handlers) {
-    const params = matchColonSegmentPath(pattern, pathname);
-    if (params === null) {
-      index += 1;
-      continue;
+export function findWebSocketRoute(handlers, pathname) {
+    let best = null;
+    let index = 0;
+    for (const [pattern, handler] of handlers) {
+        const params = matchColonSegmentPath(pattern, pathname);
+        if (params === null) {
+            index += 1;
+            continue;
+        }
+        const score = scoreColonSegmentPath(pattern);
+        const match = { handler, params, kind: pattern };
+        if (best === null || score > best.score || (score === best.score && index < best.index)) {
+            best = { score, match, index };
+        }
+        index += 1;
     }
-    const score = scoreColonSegmentPath(pattern);
-    const match = { handler, params, kind: pattern };
-    if (best === null || score > best.score || score === best.score && index < best.index) {
-      best = { score, match, index };
-    }
-    index += 1;
-  }
-  return best?.match ?? null;
+    return best?.match ?? null;
 }
-export {
-  findWebSocketRoute,
-  matchWebSocketPath,
-  scoreWebSocketPattern
-};

package/src/adapters/bun/bun-user-websocket-lifecycle.js

@@ -1,96 +1,93 @@
-import { appLogger } from "../../global/app-logger.js";
-import { invokeWebSocketHandlerHook, toWebSocketCloseInfo } from "../shared/ws/websocket-lifecycle.js";
+import { appLogger } from '../../global/app-logger.js';
+import { invokeWebSocketHandlerHook, toWebSocketCloseInfo } from '../shared/ws/websocket-lifecycle.js';
 function toUpgradeRequest(ws, runtimeOrigin) {
-  const upgradeUrl = ws.data?.upgradeUrl;
-  if (upgradeUrl) {
-    return new Request(upgradeUrl);
-  }
-  return new Request(runtimeOrigin);
+    const upgradeUrl = ws.data?.upgradeUrl;
+    if (upgradeUrl) {
+        return new Request(upgradeUrl);
+    }
+    return new Request(runtimeOrigin);
 }
 async function runUserWebSocketOpen(ws, kind, deps) {
-  const handler = deps.userHandlers.get(kind);
-  if (!handler) {
-    return;
-  }
-  const params = ws.data?.params ?? {};
-  const search = ws.data?.search ?? {};
-  const request = toUpgradeRequest(ws, deps.runtimeOrigin);
-  let context;
-  try {
-    context = await deps.resolveContext(request, handler, kind, params, search);
-  } catch {
-    ws.close(1011, "context initialization failed");
-    return;
-  }
-  ws.data.context = context;
-  const socket = deps.adaptSocket(ws, kind, params, search, context);
-  try {
-    await handler.onConnect?.(socket);
-  } catch (error) {
-    appLogger.error(`[WS:${kind}] onConnect failed:`, error);
-    ws.close(1011, "onConnect failed");
-  }
-}
-function createBunUserWebSocketLifecycle(deps) {
-  const resolveSocketForEvent = (ws) => {
-    const kind = ws.data?.kind;
-    if (!kind) {
-      return void 0;
-    }
     const handler = deps.userHandlers.get(kind);
     if (!handler) {
-      return void 0;
+        return;
     }
-    const params = ws.data?.params ?? {};
+    const params = (ws.data?.params ?? {});
     const search = ws.data?.search ?? {};
-    const socket = deps.adaptSocket(ws, kind, params, search, ws.data?.context);
-    return { kind, handler, socket };
-  };
-  return {
-    open(ws) {
-      const kind = ws.data?.kind;
-      if (!kind) {
-        return;
-      }
-      void runUserWebSocketOpen(ws, kind, deps).catch((error) => {
-        appLogger.error(`[WS:${kind}] open failed:`, error);
-        ws.close(1011, "internal error");
-      });
-    },
-    message(ws, msg) {
-      const resolved = resolveSocketForEvent(ws);
-      if (!resolved) {
-        return;
-      }
-      if (ws.data?.context === void 0 && resolved.handler.context) {
-        appLogger.warn(`[WS:${resolved.kind}] message received before context resolved; dropping.`);
-        return;
-      }
-      const message = typeof msg === "string" ? { kind: "text", text: msg } : { kind: "binary", data: new Uint8Array(msg.buffer, msg.byteOffset, msg.byteLength) };
-      invokeWebSocketHandlerHook(
-        resolved.kind,
-        "onMessage",
-        resolved.handler.onMessage?.(resolved.socket, message)
-      );
-    },
-    close(ws, code, reason) {
-      const resolved = resolveSocketForEvent(ws);
-      if (!resolved) {
-        return;
-      }
-      const event = toWebSocketCloseInfo(code, reason);
-      invokeWebSocketHandlerHook(resolved.kind, "onClose", resolved.handler.onClose?.(resolved.socket, event));
-    },
-    error(ws, error) {
-      const resolved = resolveSocketForEvent(ws);
-      if (!resolved) {
+    const request = toUpgradeRequest(ws, deps.runtimeOrigin);
+    let context;
+    try {
+        context = await deps.resolveContext(request, handler, kind, params, search);
+    }
+    catch {
+        ws.close(1011, 'context initialization failed');
         return;
-      }
-      appLogger.error(`[WS:${resolved.kind}] error:`, error);
-      invokeWebSocketHandlerHook(resolved.kind, "onError", resolved.handler.onError?.(resolved.socket, error));
     }
-  };
+    ws.data.context = context;
+    const socket = deps.adaptSocket(ws, kind, params, search, context);
+    try {
+        await handler.onConnect?.(socket);
+    }
+    catch (error) {
+        appLogger.error(`[WS:${kind}] onConnect failed:`, error);
+        ws.close(1011, 'onConnect failed');
+    }
+}
+export function createBunUserWebSocketLifecycle(deps) {
+    const resolveSocketForEvent = (ws) => {
+        const kind = ws.data?.kind;
+        if (!kind) {
+            return undefined;
+        }
+        const handler = deps.userHandlers.get(kind);
+        if (!handler) {
+            return undefined;
+        }
+        const params = (ws.data?.params ?? {});
+        const search = ws.data?.search ?? {};
+        const socket = deps.adaptSocket(ws, kind, params, search, ws.data?.context);
+        return { kind, handler, socket };
+    };
+    return {
+        open(ws) {
+            const kind = ws.data?.kind;
+            if (!kind) {
+                return;
+            }
+            void runUserWebSocketOpen(ws, kind, deps).catch((error) => {
+                appLogger.error(`[WS:${kind}] open failed:`, error);
+                ws.close(1011, 'internal error');
+            });
+        },
+        message(ws, msg) {
+            const resolved = resolveSocketForEvent(ws);
+            if (!resolved) {
+                return;
+            }
+            if (ws.data?.context === undefined && resolved.handler.context) {
+                appLogger.warn(`[WS:${resolved.kind}] message received before context resolved; dropping.`);
+                return;
+            }
+            const message = typeof msg === 'string'
+                ? { kind: 'text', text: msg }
+                : { kind: 'binary', data: new Uint8Array(msg.buffer, msg.byteOffset, msg.byteLength) };
+            invokeWebSocketHandlerHook(resolved.kind, 'onMessage', resolved.handler.onMessage?.(resolved.socket, message));
+        },
+        close(ws, code, reason) {
+            const resolved = resolveSocketForEvent(ws);
+            if (!resolved) {
+                return;
+            }
+            const event = toWebSocketCloseInfo(code, reason);
+            invokeWebSocketHandlerHook(resolved.kind, 'onClose', resolved.handler.onClose?.(resolved.socket, event));
+        },
+        error(ws, error) {
+            const resolved = resolveSocketForEvent(ws);
+            if (!resolved) {
+                return;
+            }
+            appLogger.error(`[WS:${resolved.kind}] error:`, error);
+            invokeWebSocketHandlerHook(resolved.kind, 'onError', resolved.handler.onError?.(resolved.socket, error));
+        },
+    };
 }
-export {
-  createBunUserWebSocketLifecycle
-};

package/src/adapters/bun/client-bridge.js

@@ -1,51 +1,52 @@
-class ClientBridge {
-  subscribers = /* @__PURE__ */ new Set();
-  subscribe(ws) {
-    this.subscribers.add(ws);
-  }
-  unsubscribe(ws) {
-    this.subscribers.delete(ws);
-  }
-  /**
-   * Broadcast a raw event to all connected clients.
-   */
-  broadcast(event) {
-    const payload = JSON.stringify(event);
-    for (const ws of this.subscribers) {
-      ws.send(payload);
-    }
-  }
-  /**
-   * Trigger a full page reload on all connected clients.
-   */
-  reload() {
-    this.broadcast({ type: "reload" });
-  }
-  /**
-   * Broadcast a CSS update for hot stylesheet reload.
-   */
-  cssUpdate(path) {
-    this.broadcast({ type: "css-update", path, timestamp: Date.now() });
-  }
-  /**
-   * Broadcast a JS module update for hot module replacement.
-   */
-  update(path) {
-    this.broadcast({ type: "update", path, timestamp: Date.now() });
-  }
-  /**
-   * Broadcast an error message to connected clients.
-   */
-  error(message) {
-    this.broadcast({ type: "error", message });
-  }
-  get subscriberCount() {
-    return this.subscribers.size;
-  }
-  destroy() {
-    this.subscribers.clear();
-  }
+/**
+ * Manages WebSocket subscribers and broadcasts development events.
+ * Bridges the gap between the server and the development client.
+ */
+export class ClientBridge {
+    subscribers = new Set();
+    subscribe(ws) {
+        this.subscribers.add(ws);
+    }
+    unsubscribe(ws) {
+        this.subscribers.delete(ws);
+    }
+    /**
+     * Broadcast a raw event to all connected clients.
+     */
+    broadcast(event) {
+        const payload = JSON.stringify(event);
+        for (const ws of this.subscribers) {
+            ws.send(payload);
+        }
+    }
+    /**
+     * Trigger a full page reload on all connected clients.
+     */
+    reload() {
+        this.broadcast({ type: 'reload' });
+    }
+    /**
+     * Broadcast a CSS update for hot stylesheet reload.
+     */
+    cssUpdate(path) {
+        this.broadcast({ type: 'css-update', path, timestamp: Date.now() });
+    }
+    /**
+     * Broadcast a JS module update for hot module replacement.
+     */
+    update(path) {
+        this.broadcast({ type: 'update', path, timestamp: Date.now() });
+    }
+    /**
+     * Broadcast an error message to connected clients.
+     */
+    error(message) {
+        this.broadcast({ type: 'error', message });
+    }
+    get subscriberCount() {
+        return this.subscribers.size;
+    }
+    destroy() {
+        this.subscribers.clear();
+    }
 }
-export {
-  ClientBridge
-};