weifuwu 0.55.3 → 0.56.1

package/dist/components/index.js

@@ -1,4 +1,8 @@
 // src/client/vnode.ts
+var ASYNC_MARK = "__wfAsyncComponent";
+function isAsyncComponent(type) {
+  return typeof type === "function" && type?.[ASYNC_MARK] === true;
+}
 var Fragment = /* @__PURE__ */ Symbol("Fragment");
 var Portal = /* @__PURE__ */ Symbol("Portal");
 function h(type, props, ...children) {
@@ -467,10 +471,11 @@ function renderValue(v, ctx) {
   }
   if (vnode.type === Fragment) {
     const frag = document.createDocumentFragment();
-    forEach(vnode.props?.children, (child) => {
+    const children = vnode.props?.children == null ? [] : Array.isArray(vnode.props.children) ? vnode.props.children : [vnode.props.children];
+    for (const child of children) {
       const node = renderValue(child, ctx);
       if (node != null) frag.appendChild(node);
-    });
+    }
     return frag;
   }
   if (typeof vnode.type === "function") {
@@ -513,6 +518,54 @@ function renderValue(v, ctx) {
   if (typeof vnode.props?.ref === "function") vnode.props.ref(el);
   return el;
 }
+var asyncFactoryCache = /* @__PURE__ */ new WeakMap();
+function startAsyncFactory(Comp, ctx) {
+  const existing = asyncFactoryCache.get(Comp);
+  if (existing) return existing;
+  const entry = { promise: null };
+  entry.promise = Promise.resolve().then(() => Comp(ctx)).then((def) => {
+    if (typeof def !== "function") {
+      throw new Error(
+        `asyncComponent factory <${Comp.name || "anonymous"}> must return a Component (initProps, ctx) => (props) => VNode.`
+      );
+    }
+    entry.resolved = def;
+    return def;
+  });
+  asyncFactoryCache.set(Comp, entry);
+  return entry;
+}
+function resolveAsyncFactorySync(Comp) {
+  return asyncFactoryCache.get(Comp)?.resolved;
+}
+function scheduleFullReRender(ctx) {
+  const ui = ctx.ui;
+  if (ui && typeof ui.render === "function") ui.render(["_wf_root"]);
+}
+function mountComponent(Comp, props, vnode, ctx) {
+  let def;
+  if (isAsyncComponent(Comp)) {
+    def = resolveAsyncFactorySync(Comp);
+    if (!def) {
+      void startAsyncFactory(Comp, ctx).promise.then(
+        () => scheduleFullReRender(ctx),
+        () => {
+        }
+      );
+      return null;
+    }
+  } else {
+    def = Comp;
+  }
+  let childVNode = def(props, ctx);
+  if (typeof childVNode !== "function") {
+    throw new Error(
+      `Component ${Comp.name || "anonymous"} must return a render function. Use (init_props, ctx) => (props) => VNode pattern.`
+    );
+  }
+  vnode._render = childVNode;
+  return childVNode(props);
+}
 function renderComponent(Comp, props, vnode, ctx) {
   ;
   ctx.ui = ctx.ui ?? {};
@@ -527,14 +580,7 @@ function renderComponent(Comp, props, vnode, ctx) {
   vnode._ctxVersion = childCtx.ui._ctxVersion ?? 0;
   let childVNode;
   try {
-    childVNode = Comp(props, childCtx);
-    if (typeof childVNode !== "function") {
-      throw new Error(
-        `Component ${Comp.name || "anonymous"} must return a render function. Use (init_props, ctx) => (props) => VNode pattern.`
-      );
-    }
-    vnode._render = childVNode;
-    childVNode = childVNode(props);
+    childVNode = mountComponent(Comp, props, vnode, childCtx);
   } catch (e) {
     const errHandler = ctx.ui?._errorHandler;
     if (errHandler) {
@@ -591,14 +637,6 @@ function renderPortal(vnode, ctx) {
     if (node != null) sub.appendChild(node);
   }
 }
-function forEach(children, fn) {
-  if (children == null) return;
-  if (Array.isArray(children)) {
-    children.forEach(fn);
-    return;
-  }
-  fn(children);
-}
 function flattenChildren(children) {
   if (children == null) return [];
   if (!Array.isArray(children)) return [children];

package/dist/db/postgres/connection.d.ts

@@ -39,9 +39,9 @@ export declare class PgConnection {
     private onReady;
     private onAuthFail;
     private expectingAuth;
-    private authStage;
     private authCtx;
     private prepared;
+    private static readonly PREPARED_MAX;
     private stmtSeq;
     private currentQuery;
     private onData;
@@ -49,6 +49,10 @@ export declare class PgConnection {
     /** SCRAM client-final 消息 */
     private scramFinal;
     private scramServerSignature;
+    /** LRU 读取：命中移到尾部（最近使用），超限删最旧 */
+    private getPrepared;
+    /** LRU 写入：刷新位置；超上限淘汰最旧（长运行服务防无限累积） */
+    private setPrepared;
     /** 事务：BEGIN → fn(tx) → COMMIT；fn 抛错 → ROLLBACK（回滚失败吞掉，保留原始错误） */
     transaction<T>(fn: (tx: {
         query: (sql: string, params?: (string | number | boolean | object | null)[]) => Promise<Row[]>;

package/dist/db/postgres/protocol.d.ts

@@ -21,7 +21,10 @@ export declare function startupMessage(params: Record<string, string>): Uint8Arr
 export declare function queryMessage(sql: string): Uint8Array;
 /** Parse: P + statementName\0 + query\0 + paramTypeCount(2) + OIDs */
 export declare function parseMessage(name: string, sql: string, paramTypes?: number[]): Uint8Array;
-/** Bind: B + portal\0 + statement\0 + fmtCount + formats + paramCount + params + resultFmtCount */
+/**
+ * Bind: B + portal\0 + statement\0 + fmtCount + formats + paramCount + params + resultFmtCount
+ * 两遍法：先算 payload 总长 → 预分配一次写入（buffer + offset 指针，避免 number[] 累积 O(n²)）。
+ */
 export declare function bindMessage(statement: string, params: (string | Uint8Array | null)[], paramFormats?: number[]): Uint8Array;
 /** Execute: E + portal\0 + maxRows(4) */
 export declare function executeMessage(portal?: string, maxRows?: number): Uint8Array;

package/dist/db/redis/client.d.ts

@@ -15,9 +15,14 @@ export declare class RedisClient {
     private constructor();
     /** 建立连接并返回就绪的客户端 */
     static connect(options?: RedisClientOptions): Promise<RedisClient>;
-    /** 底层命令透传（RESP 值） */
-    command(name: string, ...args: (string | number)[]): Promise<RespValue>;
+    /** 底层命令透传（RESP 值）；Buffer 参数字节原样发送 */
+    command(name: string, ...args: (string | number | Buffer)[]): Promise<RespValue>;
     get(key: string): Promise<string | null>;
+    /**
+     * 二进制安全读取：返回原始字节（Uint8Array），不经过字符串解码。
+     * 用于缓存二进制 payload（序列化字节、图片等）。key 不存在返回 null。
+     */
+    getBuffer(key: string): Promise<Uint8Array | null>;
     /**
      * SET。ttl 秒可省略；传入即安全生效（内部转 SET key val EX ttl）。
      */

package/dist/db/redis/connection.d.ts

@@ -18,6 +18,8 @@ export interface RedisConnectionOptions {
     maxRetries?: number;
     /** 未连接时命令是否入队等待（ioredis enableOfflineQueue 语义）。默认 true。 */
     enableOfflineQueue?: boolean;
+    /** 离线队列上限。默认 5000。超限命令立即 reject（防断线期间无限累积）。 */
+    maxOfflineQueue?: number;
 }
 export declare class RedisConnection {
     readonly ready = false;
@@ -25,6 +27,8 @@ export declare class RedisConnection {
     private socket;
     private parser;
     private pending;
+    /** pending 头指针（避免 shift() O(n)——消费后定期 compact） */
+    private pendingHead;
     private offlineQueue;
     private subs;
     private psubs;
@@ -42,8 +46,13 @@ export declare class RedisConnection {
     private openSocket;
     private handleDisconnect;
     private onData;
-    /** 发送命令并等待响应（单连接严格有序）。未 ready 时入离线队列（enableOfflineQueue）或拒绝。 */
-    command(name: string, ...args: (string | number)[]): Promise<RespValue>;
+    /**
+     * 发送命令并等待响应（单连接严格有序）。未 ready 时入离线队列（enableOfflineQueue）或拒绝。
+     * opts.asBuffer=true：响应保留原始字节（Uint8Array）——getBuffer 等二进制场景。
+     */
+    command(name: string, ...args: (string | number | Buffer | {
+        asBuffer?: boolean;
+    })[]): Promise<RespValue>;
     private sendNow;
     private flushOffline;
     /** 批量执行：一次 write 发送所有命令字节，响应按序路由（管道） */

package/dist/db/redis/pool.d.ts

@@ -34,6 +34,8 @@ export declare class RedisPool {
     private next;
     command(name: string, ...args: (string | number)[]): Promise<RespValue>;
     get(key: string): Promise<string | null>;
+    /** 二进制安全读取（原始字节，不解码） */
+    getBuffer(key: string): Promise<Uint8Array | null>;
     set(key: string, value: string | number, ttl?: number): Promise<'OK'>;
     del(...keys: string[]): Promise<number>;
     incr(key: string): Promise<number>;

package/dist/db/redis/resp.d.ts

@@ -7,7 +7,7 @@
  * 解码为增量式：连接层可喂入任意分片，累积到完整消息后取回。
  */
 import { DbError } from '../errors.ts';
-export type RespValue = string | number | null | RespError | RespValue[];
+export type RespValue = string | number | null | RespError | RespValue[] | Uint8Array;
 /** 服务器错误响应（-ERR ...） */
 export declare class RespError extends DbError {
     constructor(message: string);
@@ -16,9 +16,11 @@ export declare class RespError extends DbError {
 export declare class IncompleteError extends Error {
     constructor();
 }
-/** 编码命令为 RESP 数组字节 */
+/** 递归解码字节值（bulk → string）。decodeBytes=false 时字节原样保留（二进制安全）。 */
+export declare function decodeValue(v: RespValue, decodeBytes: boolean): RespValue;
+/** 编码命令为 RESP 数组字节。Buffer 参数字节原样写入（二进制安全，零损坏）。 */
 export declare function encodeCommand(args: (string | number | Buffer)[]): Uint8Array;
-/** 从完整 buffer 解析单个 RESP 值（非增量——单消息场景） */
+/** 从完整 buffer 解析单个 RESP 值（非增量——单消息场景，解码为 string 语义） */
 export declare function parseReply(data: Uint8Array): RespValue;
 export declare class RespParser {
     private buf;
@@ -35,8 +37,13 @@ export declare class RespParser {
     /** 全部消费后压缩（释放底层） */
     private compact;
     private parseValue;
+    /**
+     * 读整数（: 或 $ 长度）：扫描数字字符边算值，直到 \r\n（手动解析，免 parseInt + 字符串）。
+     * 支持负号（-1）。未读到终止符抛 IncompleteError（push 回滚）。
+     */
+    private readInt;
     /** 读一行（到 \r\n），返回行内容（不含 type 字节与 \r\n），并推进 off */
     private readLine;
-    /** 读 len 字节的 bulk 内容 + \r\n */
-    private readBulk;
+    /** 读 len 字节的 bulk 内容 + \r\n（字节中立——不 decode，由调用方决定 string/Buffer） */
+    private readBulkBytes;
 }

package/dist/dev/index.js

@@ -0,0 +1,23 @@
+// src/dev/index.ts
+import { registerHooks } from "node:module";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { transformSync } from "esbuild";
+registerHooks({
+  load(url, context, next) {
+    if (url.startsWith("file:") && (url.endsWith(".ts") || url.endsWith(".tsx"))) {
+      const file = fileURLToPath(url);
+      const code = readFileSync(file, "utf-8");
+      const result = transformSync(code, {
+        loader: url.endsWith(".tsx") ? "tsx" : "ts",
+        jsx: "automatic",
+        jsxImportSource: "weifuwu/client",
+        format: "esm",
+        sourcemap: "inline",
+        target: "node22"
+      });
+      return { format: "module", source: result.code, shortCircuit: true };
+    }
+    return next(url, context);
+  }
+});

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export type { CORSOptions } from './middleware/cors.ts';
 export { serveStatic } from './middleware/static.ts';
 export type { ServeStaticOptions } from './middleware/static.ts';
 export { ui } from './ui/index.ts';
+export { uiSsr } from './ui/ssr-page.ts';
+export type { UiSsrOptions } from './ui/ssr-page.ts';
 export type { GraphQLOptions, GraphQLHandler } from './graphql.ts';
 export { postgres, MIGRATIONS_TABLE } from './postgres/index.ts';
 export type { PostgresOptions, PostgresClient, PostgresInjected } from './postgres/types.ts';