@fictjs/vite-plugin 0.4.0 → 0.5.1

package/dist/index.cjs

@@ -30,7 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  default: () => fict
+  default: () => fict,
+  registerExtractedHandler: () => registerExtractedHandler
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_crypto = require("crypto");
@@ -38,9 +39,18 @@ var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_core = require("@babel/core");
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var t = __toESM(require("@babel/types"), 1);
 var import_compiler = require("@fictjs/compiler");
+var traverse = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
+var generate = typeof import_generator.default === "function" ? import_generator.default : import_generator.default.default;
 var CACHE_VERSION = 1;
 var MODULE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
+var VIRTUAL_HANDLER_PREFIX = "\0fict-handler:";
+var VIRTUAL_HANDLER_RESOLVE_PREFIX = "virtual:fict-handler:";
+var extractedHandlers = /* @__PURE__ */ new Map();
 function fict(options = {}) {
   const {
     include = ["**/*.tsx", "**/*.jsx"],
@@ -96,6 +106,39 @@ function fict(options = {}) {
       config = resolvedConfig;
       isDev = config.command === "serve" || config.mode === "development";
       resetCache();
+      extractedHandlers.clear();
+    },
+    resolveId(id) {
+      if (id.startsWith(VIRTUAL_HANDLER_RESOLVE_PREFIX)) {
+        return VIRTUAL_HANDLER_PREFIX + id.slice(VIRTUAL_HANDLER_RESOLVE_PREFIX.length);
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(VIRTUAL_HANDLER_PREFIX)) {
+        return null;
+      }
+      const handlerId = id.slice(VIRTUAL_HANDLER_PREFIX.length);
+      console.log(`[fict-plugin] Loading virtual module: ${handlerId}`);
+      console.log(
+        `[fict-plugin] Registry has ${extractedHandlers.size} handlers:`,
+        Array.from(extractedHandlers.keys())
+      );
+      const handler = extractedHandlers.get(handlerId);
+      if (handler) {
+        const generatedCode = generateHandlerModule(handler);
+        console.log(`[fict-plugin] Generated code length: ${generatedCode.length}`);
+        console.log(`[fict-plugin] Generated code preview: ${generatedCode.slice(0, 200)}...`);
+        return generatedCode;
+      }
+      if (!handler) {
+        const [sourceModule, exportName] = parseHandlerId(handlerId);
+        if (sourceModule && exportName) {
+          return `export { ${exportName} as default } from '${sourceModule}'`;
+        }
+        return null;
+      }
+      return generateHandlerModule(handler);
     },
     config(userConfig, env) {
       const userOptimize = userConfig.optimizeDeps;
@@ -145,6 +188,12 @@ function fict(options = {}) {
           // Our plugin will handle the full transformation
           include: /\.(ts|js|mts|mjs|cjs)$/
         },
+        build: {
+          rollupOptions: {
+            // Preserve exports in entry chunks to prevent tree-shaking of handler exports
+            preserveEntrySignatures: "exports-only"
+          }
+        },
         resolve: {
           ...userConfig.resolve ?? {},
           dedupe: Array.from(dedupe)
@@ -171,6 +220,7 @@ function fict(options = {}) {
         ...compilerOptions,
         dev: compilerOptions.dev ?? isDev,
         sourcemap: compilerOptions.sourcemap ?? true,
+        filename,
         moduleMetadata,
         resolveModuleMetadata: (source, importer) => {
           const userResolved = compilerOptions.resolveModuleMetadata?.(source, importer);
@@ -261,9 +311,44 @@ function fict(options = {}) {
         if (!result || !result.code) {
           return null;
         }
+        let finalCode = result.code;
+        let finalMap = result.map;
+        const shouldSplit = options.functionSplitting ?? (config?.command === "build" && (compilerOptions.resumable || !config?.build?.ssr));
+        console.log(
+          `[fict-plugin] shouldSplit=${shouldSplit}, ssr=${config?.build?.ssr}, resumable=${compilerOptions.resumable}, file=${filename}`
+        );
+        if (shouldSplit) {
+          let splitResult = null;
+          try {
+            splitResult = extractAndRewriteHandlers(finalCode, filename);
+          } catch (e) {
+            console.error("[fict-plugin] extractAndRewriteHandlers error:", e);
+          }
+          console.log(
+            `[fict-plugin] splitResult: ${splitResult ? splitResult.handlers.length + " handlers" : "null"}`
+          );
+          if (splitResult) {
+            console.log(
+              `[fict-plugin] Function splitting: ${filename} - ${splitResult.handlers.length} handlers extracted`
+            );
+            finalCode = splitResult.code;
+            finalMap = null;
+            if (config?.command === "build" && !config?.build?.ssr) {
+              for (const handlerName of splitResult.handlers) {
+                const handlerId = createHandlerId(filename, handlerName);
+                const virtualModuleId = `${VIRTUAL_HANDLER_RESOLVE_PREFIX}${handlerId}`;
+                this.emitFile({
+                  type: "chunk",
+                  id: virtualModuleId,
+                  name: `handler-${handlerName}`
+                });
+              }
+            }
+          }
+        }
         const transformed = {
-          code: result.code,
-          map: result.map
+          code: finalCode,
+          map: finalMap
         };
         if (cacheKey) {
           await cacheStore.set(cacheKey, transformed);
@@ -289,6 +374,40 @@ function fict(options = {}) {
           path: "*"
         });
       }
+    },
+    generateBundle(_options, bundle) {
+      if (!config || config.command !== "build") return;
+      if (config.build.ssr) return;
+      const base = config.base ?? "/";
+      const manifest = {};
+      for (const output of Object.values(bundle)) {
+        if (output.type !== "chunk") continue;
+        const fileName = output.fileName;
+        const url = joinBasePath(base, fileName);
+        for (const moduleId of Object.keys(output.modules)) {
+          if (!moduleId) continue;
+          if (moduleId.startsWith(VIRTUAL_HANDLER_PREFIX)) {
+            const handlerId = moduleId.slice(VIRTUAL_HANDLER_PREFIX.length);
+            const virtualKey = `${VIRTUAL_HANDLER_RESOLVE_PREFIX}${handlerId}`;
+            if (!manifest[virtualKey]) {
+              manifest[virtualKey] = url;
+            }
+            continue;
+          }
+          if (moduleId.startsWith("\0")) continue;
+          const normalized = normalizeFileName(moduleId, config.root);
+          if (!import_node_path.default.isAbsolute(normalized)) continue;
+          const key = (0, import_node_url.pathToFileURL)(normalized).href;
+          if (!manifest[key]) {
+            manifest[key] = url;
+          }
+        }
+      }
+      this.emitFile({
+        type: "asset",
+        fileName: "fict.manifest.json",
+        source: JSON.stringify(manifest)
+      });
     }
   };
 }
@@ -353,6 +472,12 @@ function normalizeFileName(id, root) {
   if (root) return import_node_path.default.normalize(import_node_path.default.resolve(root, clean));
   return import_node_path.default.normalize(import_node_path.default.resolve(clean));
 }
+function joinBasePath(base, fileName) {
+  if (!base) return fileName;
+  if (base === "/") return `/${fileName}`;
+  const normalized = base.endsWith("/") ? base : `${base}/`;
+  return `${normalized}${fileName}`;
+}
 function normalizeAliases(aliases) {
   if (!aliases) return [];
   if (Array.isArray(aliases)) {
@@ -537,4 +662,439 @@ async function createTypeScriptProject(ts, rootDir, configPath) {
     dispose: () => service.dispose?.()
   };
 }
+function parseHandlerId(handlerId) {
+  const separatorIndex = handlerId.lastIndexOf("$$");
+  if (separatorIndex === -1) {
+    return [handlerId, "default"];
+  }
+  return [handlerId.slice(0, separatorIndex), handlerId.slice(separatorIndex + 2)];
+}
+function createHandlerId(sourceModule, exportName) {
+  return `${sourceModule}$$${exportName}`;
+}
+function generateHandlerModule(handler) {
+  if (!handler.code) {
+    return `export { ${handler.exportName} as default } from '${handler.sourceModule}';
+`;
+  }
+  const importsByModule = /* @__PURE__ */ new Map();
+  for (const helperName of handler.helpersUsed) {
+    const helper = RUNTIME_HELPERS[helperName];
+    if (!helper) continue;
+    const existing = importsByModule.get(helper.from) ?? [];
+    if (!existing.includes(helper.import)) {
+      existing.push(helper.import);
+    }
+    importsByModule.set(helper.from, existing);
+  }
+  const imports = [];
+  for (const [module2, names] of importsByModule) {
+    imports.push(`import { ${names.join(", ")} } from '${module2}';`);
+  }
+  if (handler.localDeps.length > 0) {
+    const depImports = handler.localDeps.map((dep) => `${HANDLER_DEP_PREFIX}${dep} as ${dep}`);
+    imports.push(`import { ${depImports.join(", ")} } from '${handler.sourceModule}';`);
+  }
+  return `${imports.join("\n")}${imports.length > 0 ? "\n\n" : ""}export default ${handler.code};
+`;
+}
+var HANDLER_DEP_PREFIX = "__fict_dep_";
+function registerExtractedHandler(sourceModule, exportName, helpersUsed, code, localDeps = []) {
+  const handlerId = createHandlerId(sourceModule, exportName);
+  extractedHandlers.set(handlerId, {
+    sourceModule,
+    exportName,
+    helpersUsed,
+    localDeps,
+    code
+  });
+  return `${VIRTUAL_HANDLER_RESOLVE_PREFIX}${handlerId}`;
+}
+var RUNTIME_HELPERS = {
+  __fictUseLexicalScope: { import: "__fictUseLexicalScope", from: "@fictjs/runtime/internal" },
+  __fictGetScopeProps: { import: "__fictGetScopeProps", from: "@fictjs/runtime/internal" },
+  __fictGetSSRScope: { import: "__fictGetSSRScope", from: "@fictjs/runtime/internal" },
+  __fictEnsureScope: { import: "__fictEnsureScope", from: "@fictjs/runtime/internal" },
+  __fictPrepareContext: { import: "__fictPrepareContext", from: "@fictjs/runtime/internal" },
+  __fictPushContext: { import: "__fictPushContext", from: "@fictjs/runtime/internal" },
+  __fictPopContext: { import: "__fictPopContext", from: "@fictjs/runtime/internal" },
+  hydrateComponent: { import: "hydrateComponent", from: "@fictjs/runtime/internal" },
+  __fictQrl: { import: "__fictQrl", from: "@fictjs/runtime/internal" }
+};
+var GLOBAL_IDENTIFIERS = /* @__PURE__ */ new Set([
+  // JavaScript globals
+  "undefined",
+  "null",
+  "true",
+  "false",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "window",
+  "document",
+  "console",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "fetch",
+  "URL",
+  "URLSearchParams",
+  "FormData",
+  "Headers",
+  "Request",
+  "Response",
+  "AbortController",
+  "AbortSignal",
+  // Built-in constructors
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt",
+  "Date",
+  "RegExp",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Proxy",
+  "Reflect",
+  "JSON",
+  "Math",
+  "Intl",
+  // Event and DOM
+  "Event",
+  "CustomEvent",
+  "Element",
+  "Node",
+  "HTMLElement"
+]);
+function collectReferencedIdentifiers(node, localBindings) {
+  const referenced = /* @__PURE__ */ new Set();
+  function visitNode(current, parent, key) {
+    if (!current) return;
+    if (t.isIdentifier(current)) {
+      const name = current.name;
+      if (parent && t.isMemberExpression(parent) && parent.property === current && !parent.computed) {
+        return;
+      }
+      if (parent && t.isObjectProperty(parent) && parent.key === current && !parent.computed) {
+        return;
+      }
+      if (parent && t.isVariableDeclarator(parent) && parent.id === current) {
+        return;
+      }
+      if (parent && (t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent)) && parent.id === current) {
+        return;
+      }
+      if (key === "params") {
+        return;
+      }
+      if (parent && t.isCatchClause(parent) && parent.param === current) {
+        return;
+      }
+      if (localBindings.has(name)) {
+        return;
+      }
+      if (GLOBAL_IDENTIFIERS.has(name)) {
+        return;
+      }
+      if (RUNTIME_HELPERS[name]) {
+        return;
+      }
+      referenced.add(name);
+      return;
+    }
+    for (const nodeKey of Object.keys(current)) {
+      if (nodeKey === "loc" || nodeKey === "start" || nodeKey === "end" || nodeKey === "extra" || nodeKey === "comments" || nodeKey === "leadingComments" || nodeKey === "trailingComments" || nodeKey === "innerComments") {
+        continue;
+      }
+      const child = current[nodeKey];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && item !== null && "type" in item && typeof item.type === "string") {
+            visitNode(item, current, nodeKey);
+          }
+        }
+      } else if (child && typeof child === "object" && child !== null && "type" in child && typeof child.type === "string") {
+        visitNode(child, current, nodeKey);
+      }
+    }
+  }
+  visitNode(node, null, null);
+  return referenced;
+}
+function collectLocalBindings(node) {
+  const bindings = /* @__PURE__ */ new Set();
+  function visitNode(current) {
+    if (!current) return;
+    if (t.isVariableDeclarator(current)) {
+      if (t.isIdentifier(current.id)) {
+        bindings.add(current.id.name);
+      } else if (t.isObjectPattern(current.id) || t.isArrayPattern(current.id)) {
+        const names = collectPatternIdentifiers(current.id);
+        for (const name of names) {
+          bindings.add(name);
+        }
+      }
+    }
+    if (t.isFunctionDeclaration(current)) {
+      if (current.id) {
+        bindings.add(current.id.name);
+      }
+      for (const param of current.params) {
+        const names = collectPatternIdentifiers(param);
+        for (const name of names) {
+          bindings.add(name);
+        }
+      }
+    }
+    if (t.isFunctionExpression(current)) {
+      for (const param of current.params) {
+        const names = collectPatternIdentifiers(param);
+        for (const name of names) {
+          bindings.add(name);
+        }
+      }
+    }
+    if (t.isArrowFunctionExpression(current)) {
+      for (const param of current.params) {
+        const names = collectPatternIdentifiers(param);
+        for (const name of names) {
+          bindings.add(name);
+        }
+      }
+    }
+    if (t.isCatchClause(current)) {
+      if (current.param && t.isIdentifier(current.param)) {
+        bindings.add(current.param.name);
+      }
+    }
+    for (const nodeKey of Object.keys(current)) {
+      if (nodeKey === "loc" || nodeKey === "start" || nodeKey === "end" || nodeKey === "extra" || nodeKey === "comments" || nodeKey === "leadingComments" || nodeKey === "trailingComments" || nodeKey === "innerComments") {
+        continue;
+      }
+      const child = current[nodeKey];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && item !== null && "type" in item && typeof item.type === "string") {
+            visitNode(item);
+          }
+        }
+      } else if (child && typeof child === "object" && child !== null && "type" in child && typeof child.type === "string") {
+        visitNode(child);
+      }
+    }
+  }
+  visitNode(node);
+  return bindings;
+}
+function collectPatternIdentifiers(pattern) {
+  const names = [];
+  if (t.isIdentifier(pattern)) {
+    names.push(pattern.name);
+  } else if (t.isObjectPattern(pattern)) {
+    for (const prop of pattern.properties) {
+      if (t.isObjectProperty(prop) && t.isLVal(prop.value)) {
+        names.push(...collectPatternIdentifiers(prop.value));
+      } else if (t.isRestElement(prop)) {
+        names.push(...collectPatternIdentifiers(prop.argument));
+      }
+    }
+  } else if (t.isArrayPattern(pattern)) {
+    for (const element of pattern.elements) {
+      if (element) {
+        names.push(...collectPatternIdentifiers(element));
+      }
+    }
+  } else if (t.isRestElement(pattern)) {
+    names.push(...collectPatternIdentifiers(pattern.argument));
+  } else if (t.isAssignmentPattern(pattern)) {
+    names.push(...collectPatternIdentifiers(pattern.left));
+  }
+  return names;
+}
+function extractAndRewriteHandlers(code, sourceModule) {
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"]
+    });
+  } catch (e) {
+    console.error("[fict-plugin] Parse error in extractAndRewriteHandlers:", e);
+    return null;
+  }
+  const topLevelDeclarations = /* @__PURE__ */ new Set();
+  const importedNames = /* @__PURE__ */ new Set();
+  for (const node of ast.program.body) {
+    if (t.isImportDeclaration(node)) {
+      for (const specifier of node.specifiers) {
+        if (t.isImportSpecifier(specifier) || t.isImportDefaultSpecifier(specifier)) {
+          importedNames.add(specifier.local.name);
+        } else if (t.isImportNamespaceSpecifier(specifier)) {
+          importedNames.add(specifier.local.name);
+        }
+      }
+      continue;
+    }
+    if (t.isFunctionDeclaration(node) && node.id) {
+      topLevelDeclarations.add(node.id.name);
+      continue;
+    }
+    if (t.isVariableDeclaration(node)) {
+      for (const declarator of node.declarations) {
+        if (t.isIdentifier(declarator.id)) {
+          topLevelDeclarations.add(declarator.id.name);
+        }
+      }
+      continue;
+    }
+    if (t.isClassDeclaration(node) && node.id) {
+      topLevelDeclarations.add(node.id.name);
+      continue;
+    }
+    if (t.isExportNamedDeclaration(node) && node.declaration) {
+      if (t.isFunctionDeclaration(node.declaration) && node.declaration.id) {
+        topLevelDeclarations.add(node.declaration.id.name);
+      } else if (t.isVariableDeclaration(node.declaration)) {
+        for (const declarator of node.declaration.declarations) {
+          if (t.isIdentifier(declarator.id)) {
+            topLevelDeclarations.add(declarator.id.name);
+          }
+        }
+      } else if (t.isClassDeclaration(node.declaration) && node.declaration.id) {
+        topLevelDeclarations.add(node.declaration.id.name);
+      }
+    }
+  }
+  for (const name of importedNames) {
+    topLevelDeclarations.add(name);
+  }
+  const handlerNames = [];
+  const nodesToRemove = /* @__PURE__ */ new Set();
+  const allLocalDeps = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    ExportNamedDeclaration(path2) {
+      const declaration = path2.node.declaration;
+      if (t.isVariableDeclaration(declaration)) {
+        for (const declarator of declaration.declarations) {
+          if (!t.isIdentifier(declarator.id)) continue;
+          const name = declarator.id.name;
+          if (!name.match(/^__fict_e\d+$/)) continue;
+          if (!declarator.init) continue;
+          handlerNames.push(name);
+          const handlerCode = generate(declarator.init).code;
+          const helpersUsed = [];
+          for (const helperName of Object.keys(RUNTIME_HELPERS)) {
+            if (handlerCode.includes(helperName)) {
+              helpersUsed.push(helperName);
+            }
+          }
+          const localBindings = collectLocalBindings(declarator.init);
+          const referencedIds = collectReferencedIdentifiers(declarator.init, localBindings);
+          const localDeps = [];
+          for (const ref of referencedIds) {
+            if (topLevelDeclarations.has(ref) && !ref.match(/^__fict_[er]\d+$/)) {
+              localDeps.push(ref);
+              allLocalDeps.add(ref);
+            }
+          }
+          const handlerId = createHandlerId(sourceModule, name);
+          extractedHandlers.set(handlerId, {
+            sourceModule,
+            exportName: name,
+            helpersUsed,
+            localDeps,
+            code: handlerCode
+          });
+          nodesToRemove.add(path2.node);
+        }
+        return;
+      }
+      if (t.isFunctionDeclaration(declaration) && declaration.id) {
+        const name = declaration.id.name;
+        if (!name.match(/^__fict_e\d+$/)) return;
+        handlerNames.push(name);
+        const params = declaration.params;
+        const body = declaration.body;
+        const arrowFn = t.arrowFunctionExpression(params, body, declaration.async);
+        const handlerCode = generate(arrowFn).code;
+        const helpersUsed = [];
+        for (const helperName of Object.keys(RUNTIME_HELPERS)) {
+          if (handlerCode.includes(helperName)) {
+            helpersUsed.push(helperName);
+          }
+        }
+        const localBindings = collectLocalBindings(arrowFn);
+        const referencedIds = collectReferencedIdentifiers(arrowFn, localBindings);
+        const localDeps = [];
+        for (const ref of referencedIds) {
+          if (topLevelDeclarations.has(ref) && !ref.match(/^__fict_[er]\d+$/)) {
+            localDeps.push(ref);
+            allLocalDeps.add(ref);
+          }
+        }
+        const handlerId = createHandlerId(sourceModule, name);
+        extractedHandlers.set(handlerId, {
+          sourceModule,
+          exportName: name,
+          helpersUsed,
+          localDeps,
+          code: handlerCode
+        });
+        nodesToRemove.add(path2.node);
+      }
+    }
+  });
+  if (handlerNames.length === 0) {
+    return null;
+  }
+  traverse(ast, {
+    ExportNamedDeclaration(path2) {
+      if (nodesToRemove.has(path2.node)) {
+        path2.remove();
+      }
+    },
+    CallExpression(path2) {
+      if (!t.isIdentifier(path2.node.callee, { name: "__fictQrl" })) return;
+      if (path2.node.arguments.length !== 2) return;
+      const secondArg = path2.node.arguments[1];
+      if (!t.isStringLiteral(secondArg)) return;
+      const handlerName = secondArg.value;
+      if (!handlerNames.includes(handlerName)) return;
+      const handlerId = createHandlerId(sourceModule, handlerName);
+      const virtualUrl = `${VIRTUAL_HANDLER_RESOLVE_PREFIX}${handlerId}#default`;
+      path2.replaceWith(t.stringLiteral(virtualUrl));
+    }
+  });
+  if (allLocalDeps.size > 0) {
+    const reExports = [];
+    for (const dep of allLocalDeps) {
+      reExports.push(
+        t.exportSpecifier(t.identifier(dep), t.identifier(`${HANDLER_DEP_PREFIX}${dep}`))
+      );
+    }
+    ast.program.body.push(t.exportNamedDeclaration(null, reExports));
+  }
+  const result = generate(ast, {
+    retainLines: true,
+    compact: false
+  });
+  return { code: result.code, handlers: handlerNames };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerExtractedHandler
+});
 //# sourceMappingURL=index.cjs.map