@lytjs/ssr 6.0.0 → 6.5.0

package/dist/index.cjs

@@ -113,6 +113,7 @@ var VirtualList = component.defineComponent({
     buffer: { type: Number, default: 5 },
     class: { type: String, default: "" }
   },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   setup(props, { slots }) {
     const scrollTop = reactivity.signal(0);
     const visibleCount = reactivity.computedSignal(() => {
@@ -146,6 +147,7 @@ var VirtualList = component.defineComponent({
     return () => {
       const items = visibleData().map((item, index) => {
         const actualIndex = startIndex() + index;
+        const slotContent = slots?.default?.({ item, index: actualIndex });
         return vdom.createVNode(
           "div",
           {
@@ -153,7 +155,7 @@ var VirtualList = component.defineComponent({
             style: `height: ${props.itemHeight}px;`,
             "data-index": actualIndex
           },
-          slots.default?.({ item, index: actualIndex })
+          slotContent
         );
       });
       return vdom.createVNode(
@@ -187,6 +189,38 @@ var VirtualList = component.defineComponent({
   }
 });
 var DEFAULT_CHUNK_SIZE = 4096;
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_FALLBACK_HTML = '<div id="lyt-fallback">\u670D\u52A1\u6B63\u5728\u52A0\u8F7D\u4E2D...</div>';
+var StreamTimeoutError = class extends Error {
+  constructor(message = "Stream rendering timeout") {
+    super(message);
+    this.name = "StreamTimeoutError";
+  }
+};
+var FlowController = class {
+  constructor(maxBytesPerSecond) {
+    this.bytesSentInSecond = 0;
+    this.lastSecondTimestamp = Date.now();
+    this.maxBytesPerSecond = maxBytesPerSecond;
+  }
+  /**
+   * 尝试发送字节，如超出速率则等待
+   */
+  async waitForRateLimit(byteCount) {
+    const now = Date.now();
+    if (now - this.lastSecondTimestamp >= 1e3) {
+      this.bytesSentInSecond = 0;
+      this.lastSecondTimestamp = now;
+    }
+    if (this.bytesSentInSecond + byteCount > this.maxBytesPerSecond) {
+      const waitTime = 1e3 - (now - this.lastSecondTimestamp);
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      this.bytesSentInSecond = 0;
+      this.lastSecondTimestamp = Date.now();
+    }
+    this.bytesSentInSecond += byteCount;
+  }
+};
 var SUSPENSE_TYPE = "Suspense";
 function isSuspenseVNode(vnode) {
   return commonIs.isObject(vnode) && (typeof vnode.type === "object" && vnode.type !== null && "__suspense" in vnode.type || commonIs.isString(vnode.type) && vnode.type === SUSPENSE_TYPE);
@@ -258,11 +292,32 @@ function renderToStream(vnode, options) {
   const {
     chunkSize = DEFAULT_CHUNK_SIZE,
     onShellReady,
-    onError
+    onError,
+    timeout = DEFAULT_TIMEOUT,
+    fallbackHtml = DEFAULT_FALLBACK_HTML,
+    maxBytesPerSecond,
+    errorRecovery = true
   } = options || {};
   const encoder = new TextEncoder();
+  const flowController = maxBytesPerSecond ? new FlowController(maxBytesPerSecond) : null;
+  let timeoutId = null;
   return new ReadableStream({
     start(controller) {
+      timeoutId = setTimeout(() => {
+        try {
+          if (errorRecovery) {
+            console.warn("Stream rendering timed out, using fallback HTML");
+            controller.enqueue(encoder.encode(fallbackHtml));
+            controller.close();
+            onError?.(new StreamTimeoutError("Stream rendering timed out"));
+          } else {
+            controller.error(new StreamTimeoutError("Stream rendering timed out"));
+          }
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          onError?.(error);
+        }
+      }, timeout);
       try {
         const suspenseBoundaryIndex = [];
         const chunks = collectChunks(vnode, suspenseBoundaryIndex);
@@ -273,29 +328,64 @@ function renderToStream(vnode, options) {
           const shellHtml = shellChunks.join("");
           const byteChunks = splitIntoByteChunks(shellHtml, chunkSize);
           for (const chunk of byteChunks) {
-            controller.enqueue(encoder.encode(chunk));
+            sendChunk(controller, encoder, chunk);
           }
           onShellReady?.();
           const remainingChunks = chunks.slice(shellBoundary);
           const remainingHtml = remainingChunks.join("");
           const remainingByteChunks = splitIntoByteChunks(remainingHtml, chunkSize);
           for (const chunk of remainingByteChunks) {
-            controller.enqueue(encoder.encode(chunk));
+            sendChunk(controller, encoder, chunk);
           }
         } else {
           const byteChunks = splitIntoByteChunks(fullHtml, chunkSize);
           for (const chunk of byteChunks) {
-            controller.enqueue(encoder.encode(chunk));
+            sendChunk(controller, encoder, chunk);
           }
         }
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
         controller.close();
       } catch (err) {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
         const error = err instanceof Error ? err : new Error(String(err));
         onError?.(error);
-        controller.error(error);
+        if (errorRecovery) {
+          try {
+            console.warn("Error occurred during stream rendering, using fallback HTML");
+            controller.enqueue(encoder.encode(fallbackHtml));
+            controller.close();
+          } catch (_) {
+            controller.error(error);
+          }
+        } else {
+          controller.error(error);
+        }
+      }
+    },
+    cancel(reason) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
       }
+      console.warn("Stream cancelled:", reason);
     }
   });
+  function sendChunk(controller, encoder2, chunk) {
+    const encoded = encoder2.encode(chunk);
+    if (flowController) {
+      (async () => {
+        await flowController.waitForRateLimit(encoded.length);
+        controller.enqueue(encoded);
+      })();
+    } else {
+      controller.enqueue(encoded);
+    }
+  }
 }
 function renderToStreamAsync(vnode, options) {
   const {
@@ -437,7 +527,12 @@ var DEFAULT_SSG_OPTIONS = {
   siteName: "LytJS Site",
   hashMode: false,
   globalScripts: [],
-  globalStyles: []
+  globalStyles: [],
+  isr: {
+    revalidate: 60,
+    enabled: false,
+    fallback: false
+  }
 };
 function normalizePath(path) {
   let normalized = path.startsWith("/") ? path : `/${path}`;
@@ -556,6 +651,376 @@ function validatePages(pages) {
   }
   return errors;
 }
+var ISRCacheManager = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.revalidateTasks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 获取缓存的页面
+   */
+  get(path) {
+    return this.cache.get(path);
+  }
+  /**
+   * 设置缓存
+   */
+  set(path, html) {
+    this.cache.set(path, {
+      html,
+      timestamp: Date.now(),
+      isRevalidating: false
+    });
+  }
+  /**
+   * 检查是否需要重新验证
+   */
+  needsRevalidation(path, revalidateSeconds) {
+    const entry = this.cache.get(path);
+    if (!entry) return true;
+    const age = (Date.now() - entry.timestamp) / 1e3;
+    return age > revalidateSeconds && !entry.isRevalidating;
+  }
+  /**
+   * 标记为正在重新生成
+   */
+  markRevalidating(path) {
+    const entry = this.cache.get(path);
+    if (entry) {
+      entry.isRevalidating = true;
+    }
+  }
+  /**
+   * 完成重新生成
+   */
+  finishRevalidation(path, html) {
+    this.set(path, html);
+    this.revalidateTasks.delete(path);
+  }
+  /**
+   * 获取正在进行的重新生成任务
+   */
+  getRevalidateTask(path) {
+    return this.revalidateTasks.get(path);
+  }
+  /**
+   * 设置重新生成任务
+   */
+  setRevalidateTask(path, task) {
+    this.revalidateTasks.set(path, task);
+  }
+  /**
+   * 清除过期的缓存
+   */
+  clearExpired(maxAgeSeconds) {
+    const now = Date.now();
+    let cleared = 0;
+    for (const [path, entry] of this.cache) {
+      const age = (now - entry.timestamp) / 1e3;
+      if (age > maxAgeSeconds) {
+        this.cache.delete(path);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+  /**
+   * 获取缓存统计信息
+   */
+  getStats() {
+    return {
+      total: this.cache.size,
+      paths: Array.from(this.cache.keys())
+    };
+  }
+};
+var isrCache = new ISRCacheManager();
+function createISRMiddleware(options) {
+  const { staticPages, revalidate = 60, enabled = true, regenerate } = options;
+  for (const [path, html] of staticPages) {
+    isrCache.set(path, html);
+  }
+  return async (req, res, next) => {
+    if (!enabled) {
+      return next();
+    }
+    let path = req.path;
+    if (path.endsWith("/")) {
+      path = path + "index.html";
+    } else if (!path.endsWith(".html")) {
+      path = path + "/index.html";
+    }
+    const cached = isrCache.get(path);
+    if (cached) {
+      res.setHeader("Cache-Control", `s-maxage=${revalidate}, stale-while-revalidate`);
+      res.setHeader("X-ISR-Cache", "HIT");
+      res.setHeader("X-ISR-Timestamp", cached.timestamp.toString());
+      res.send(cached.html);
+      if (isrCache.needsRevalidation(path, revalidate) && regenerate) {
+        isrCache.markRevalidating(path);
+        try {
+          const newHtml = await regenerate(path);
+          isrCache.finishRevalidation(path, newHtml);
+        } catch (error) {
+          console.error("[ISR] Revalidation failed for", path, error);
+          const entry = isrCache.get(path);
+          if (entry) {
+            entry.isRevalidating = false;
+          }
+        }
+      }
+    } else {
+      if (regenerate) {
+        try {
+          const html = await regenerate(path);
+          isrCache.set(path, html);
+          res.setHeader("X-ISR-Cache", "MISS");
+          res.send(html);
+        } catch (error) {
+          next(error);
+        }
+      } else {
+        next();
+      }
+    }
+  };
+}
+async function revalidateOnDemand(path, regenerate) {
+  const existingTask = isrCache.getRevalidateTask(path);
+  if (existingTask) {
+    return existingTask;
+  }
+  const task = (async () => {
+    isrCache.markRevalidating(path);
+    try {
+      const html = await regenerate();
+      isrCache.finishRevalidation(path, html);
+      return html;
+    } catch (error) {
+      const entry = isrCache.get(path);
+      if (entry) {
+        entry.isRevalidating = false;
+      }
+      throw error;
+    }
+  })();
+  isrCache.setRevalidateTask(path, task);
+  return task;
+}
+function getISRCacheStats() {
+  return isrCache.getStats();
+}
+function clearISRCache(path, maxAge) {
+  if (path) {
+    const cache = isrCache.cache;
+    cache.delete(path);
+  } else if (maxAge) {
+    isrCache.clearExpired(maxAge);
+  }
+}
+var ServerComponentStateManager = class {
+  constructor() {
+    /** 注册的组件 */
+    this.registrations = /* @__PURE__ */ new Map();
+    /** 正在执行的预取请求 */
+    this.pendingPrefetches = /* @__PURE__ */ new Map();
+    /** 组件初始化状态 */
+    this.initializationStates = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 注册服务端组件
+   */
+  register(name, registration) {
+    this.registrations.set(name, registration);
+  }
+  /**
+   * 取消注册服务端组件
+   */
+  unregister(name) {
+    this.registrations.delete(name);
+  }
+  /**
+   * 获取已注册的组件
+   */
+  getRegistration(name) {
+    return this.registrations.get(name);
+  }
+  /**
+   * 初始化服务端组件
+   */
+  async initializeComponent(name, context) {
+    const registration = this.registrations.get(name);
+    if (!registration) {
+      throw new Error(`Server component ${name} not registered`);
+    }
+    if (this.initializationStates.get(name)) {
+      return;
+    }
+    if (registration.onServerInit) {
+      await Promise.resolve(registration.onServerInit(context));
+    }
+    this.initializationStates.set(name, true);
+  }
+  /**
+   * 清理服务端组件
+   */
+  async cleanupComponent(name, context) {
+    const registration = this.registrations.get(name);
+    if (!registration) {
+      return;
+    }
+    if (registration.onServerCleanup) {
+      await Promise.resolve(registration.onServerCleanup(context));
+    }
+    this.initializationStates.delete(name);
+  }
+  /**
+   * 预取组件数据（带缓存）
+   */
+  async prefetchComponentData(name, context, cacheKey) {
+    const registration = this.registrations.get(name);
+    if (!registration || !registration.prefetch) {
+      return { data: {} };
+    }
+    const key = cacheKey || `${name}-${JSON.stringify(context)}`;
+    const existing = this.pendingPrefetches.get(key);
+    if (existing) {
+      return existing;
+    }
+    const promise = registration.prefetch(context).finally(() => {
+      this.pendingPrefetches.delete(key);
+    });
+    this.pendingPrefetches.set(key, promise);
+    return promise;
+  }
+  /**
+   * 清除所有缓存
+   */
+  clearAll() {
+    this.registrations.clear();
+    this.pendingPrefetches.clear();
+    this.initializationStates.clear();
+  }
+};
+var stateManager = new ServerComponentStateManager();
+function registerServerComponent(name, registration) {
+  stateManager.register(name, registration);
+}
+function unregisterServerComponent(name) {
+  stateManager.unregister(name);
+}
+function collectPrefetchComponents(vnode) {
+  const components = [];
+  collectComponentsRecursive(vnode, components);
+  return components;
+}
+function collectComponentsRecursive(vnode, result) {
+  if (!commonIs.isObject(vnode)) {
+    return;
+  }
+  const node = vnode;
+  if (commonIs.isArray(vnode)) {
+    for (const child of vnode) {
+      collectComponentsRecursive(child, result);
+    }
+    return;
+  }
+  if (commonIs.isFunction(node.type)) {
+    const compName = node.type.name;
+    if (compName && stateManager.getRegistration(compName)) {
+      if (!result.includes(compName)) {
+        result.push(compName);
+      }
+    }
+  }
+  const children = node.children;
+  if (commonIs.isArray(children)) {
+    for (const child of children) {
+      collectComponentsRecursive(child, result);
+    }
+  } else if (commonIs.isObject(children)) {
+    collectComponentsRecursive(children, result);
+  }
+}
+async function prefetchAllComponents(components, context) {
+  const results = {};
+  const promises = [];
+  for (const name of components) {
+    const promise = stateManager.prefetchComponentData(name, context).then((result) => {
+      results[name] = result;
+    }).catch((err) => {
+      console.warn(`Prefetch failed for component ${name}`, err);
+      results[name] = { data: {} };
+    });
+    promises.push(promise);
+  }
+  await Promise.all(promises);
+  return results;
+}
+function safeSerializeState(state) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(state, (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    if (value instanceof Date) {
+      return { __type: "Date", value: value.toISOString() };
+    }
+    if (value instanceof RegExp) {
+      return { __type: "RegExp", source: value.source, flags: value.flags };
+    }
+    if (value instanceof Set) {
+      return { __type: "Set", values: Array.from(value) };
+    }
+    if (value instanceof Map) {
+      return { __type: "Map", entries: Array.from(value.entries()) };
+    }
+    return value;
+  });
+}
+function safeDeserializeState(serialized) {
+  return JSON.parse(serialized, (_key, value) => {
+    if (typeof value === "object" && value !== null && "__type" in value) {
+      const typedValue = value;
+      switch (typedValue.__type) {
+        case "Date":
+          return new Date(typedValue.value);
+        case "RegExp":
+          return new RegExp(typedValue.source, typedValue.flags);
+        case "Set":
+          return new Set(typedValue.values);
+        case "Map":
+          return new Map(typedValue.entries);
+      }
+    }
+    return value;
+  });
+}
+function buildDehydratedState(prefetchResults) {
+  const state = {};
+  for (const [name, result] of Object.entries(prefetchResults)) {
+    state[name] = {
+      componentName: name,
+      props: {},
+      data: result.data
+    };
+  }
+  return state;
+}
+function ServerComponent(options) {
+  return function(target) {
+    registerServerComponent(options.name, {
+      name: options.name,
+      render: target.render || (() => ({ type: "div" })),
+      prefetch: options.prefetch,
+      onServerInit: options.onInit,
+      onServerCleanup: options.onCleanup
+    });
+  };
+}
 var HYDRATE_ATTR = "data-hydrate";
 var HYDRATE_STRATEGY_ATTR = "data-hydrate-strategy";
 var DEHYDRATED_STATE_ID = "__LYT_DEHYDRATED_STATE__";
@@ -721,20 +1186,33 @@ function createDehydratedState(vnode, initialState) {
   return `<script id="${DEHYDRATED_STATE_ID}" type="application/json">${safeJson}</script>`;
 }
 
+exports.ServerComponent = ServerComponent;
 exports.VirtualList = VirtualList;
+exports.buildDehydratedState = buildDehydratedState;
+exports.clearISRCache = clearISRCache;
+exports.collectPrefetchComponents = collectPrefetchComponents;
 exports.createDehydratedState = createDehydratedState;
 exports.createHydrationMarkers = createHydrationMarkers;
+exports.createISRMiddleware = createISRMiddleware;
 exports.default = render_default;
 exports.generateRouteManifest = generateRouteManifest;
 exports.generateStaticPages = generateStaticPages;
 exports.getHydrationStrategy = getHydrationStrategy;
+exports.getISRCacheStats = getISRCacheStats;
+exports.prefetchAllComponents = prefetchAllComponents;
+exports.registerServerComponent = registerServerComponent;
 exports.renderToHtml = renderToHtml;
 exports.renderToStream = renderToStream;
 exports.renderToStreamAsync = renderToStreamAsync;
 exports.renderToStreamEnhanced = renderToStreamEnhanced;
 exports.renderToString = renderToString;
 exports.resetComponentIdCounter = resetComponentIdCounter;
+exports.revalidateOnDemand = revalidateOnDemand;
+exports.safeDeserializeState = safeDeserializeState;
+exports.safeSerializeState = safeSerializeState;
 exports.serializeHydrationState = serializeHydrationState;
+exports.stateManager = stateManager;
+exports.unregisterServerComponent = unregisterServerComponent;
 exports.validatePages = validatePages;
 exports.writeStaticFiles = writeStaticFiles;
 //# sourceMappingURL=index.cjs.map