@fluixi/compiler 1.0.0-alpha.100

package/dist/integrations.mjs

@@ -0,0 +1,810 @@
+/*! @fluixi/compiler v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  styleIds
+} from "./chunk-NU3W67UZ.mjs";
+import {
+  INTRINSICS,
+  TAG_INTRINSICS,
+  builtinComponentMap,
+  createComponentResolver
+} from "./chunk-GX5XV6Z7.mjs";
+import "./chunk-3AICWNF7.mjs";
+import {
+  __require
+} from "./chunk-SKAVY75W.mjs";
+
+// src/resolve/write-globals.ts
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, relative, sep, resolve as resolvePath } from "node:path";
+
+// src/resolve/component-globals.ts
+var DOM_GLOBALS = /* @__PURE__ */ new Set([
+  "Text",
+  "Image",
+  "Option",
+  "Audio",
+  "Comment",
+  "Range",
+  "Selection",
+  "Notification",
+  "Event",
+  "Document",
+  "Element",
+  "Node",
+  "Screen",
+  "Window",
+  "Location",
+  "History",
+  "Storage",
+  "Response",
+  "Request",
+  "Headers"
+]);
+function packageOf(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return void 0;
+  if (/^[~@]\//.test(specifier)) return void 0;
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function namespaceAlias(module) {
+  return `_${module.replace(/[^A-Za-z0-9]/g, "_")}`;
+}
+function componentGlobals(rules, options = {}) {
+  const {
+    available: availableList,
+    builtins = true,
+    intrinsics = true,
+    generator = "@fluixi/compiler",
+    specifier = (module) => module,
+    candidates = []
+  } = options;
+  const all = [...rules];
+  if (builtins) {
+    all.push({ components: builtinComponentMap() });
+  }
+  const resolver = createComponentResolver(all);
+  const available = availableList ? new Set(availableList) : void 0;
+  const declared = [];
+  const shadowedByDom = [];
+  const unavailable = [];
+  const resolved = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set([...resolver.names(), ...[...candidates].filter((n) => /^[A-Za-z_$][\w$]*$/.test(n))]);
+  for (const name of [...names].sort()) {
+    const target = resolver.resolve(name);
+    if (!target) continue;
+    const pkg = packageOf(target.module);
+    if (DOM_GLOBALS.has(name)) shadowedByDom.push(name);
+    else if (available && pkg && !available.has(pkg)) unavailable.push(name);
+    else {
+      declared.push(name);
+      resolved.set(name, target);
+    }
+  }
+  const usableIntrinsics = intrinsics ? Object.entries({ ...INTRINSICS, ...TAG_INTRINSICS }).filter(([, i]) => {
+    const pkg = packageOf(i.module);
+    return !available || !pkg || available.has(pkg);
+  }) : [];
+  const intrinsicModules = [...new Set(usableIntrinsics.map(([, i]) => i.module))];
+  const modules = [
+    .../* @__PURE__ */ new Set([...declared.map((name) => resolved.get(name).module), ...intrinsicModules])
+  ].sort();
+  const imports = modules.map(
+    (m) => `import * as ${namespaceAlias(m)} from '${specifier(m)}';`
+  );
+  const lines = declared.map((name) => {
+    const target = resolved.get(name);
+    const ns = namespaceAlias(target.module);
+    return target.export === "default" ? `  const ${name}: typeof ${ns}.default;` : `  export import ${name} = ${ns}.${target.export};`;
+  });
+  const note = shadowedByDom.length > 0 ? `//
+// Import these explicitly: lib.dom already declares the name, so an ambient
+// declaration cannot win:
+` + shadowedByDom.map((n) => {
+    const module = resolver.resolve(n)?.module;
+    return `//   import { ${n} } from '${module ? specifier(module) : ""}';
+`;
+  }).join("") : "";
+  const intrinsicLines = usableIntrinsics.map(
+    ([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`
+  );
+  const patternRules = rules.filter((rule) => "match" in rule).length;
+  const patternNote = patternRules === 0 ? "" : options.candidates ? `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"}: declared for the files the module path
+// points at. A name with no such file still resolves at build time; declare it by hand.
+` : `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"} cannot be declared:
+// a pattern matches unboundedly many names, so there is no list to emit. Those
+// tags still resolve at build time; declare them by hand if the editor needs them.
+`;
+  const source = `// GENERATED by ${generator}, do not edit.
+//
+// The components \`resolve\` supplies without an import. This describes what the
+// compiler already does; it does not enable it.
+` + note + patternNote + (imports.length > 0 ? `
+${imports.join("\n")}
+` : "\n") + `
+declare global {
+${[...lines, ...intrinsicLines].join("\n")}
+}
+`;
+  return { source, declared, shadowedByDom, unavailable, patternRules };
+}
+
+// src/resolve/write-globals.ts
+var GENERATED_MARKER = "GENERATED by @fluixi/compiler";
+var DEFAULT_GLOBALS_PATH = "fluixi.d.ts";
+function coveredByInclude(root, target) {
+  let config;
+  try {
+    const raw = readFileSync(resolvePath(root, "tsconfig.json"), "utf8");
+    config = JSON.parse(raw.replace(/^\s*\/\/.*$/gm, ""));
+  } catch {
+    return void 0;
+  }
+  if (config.extends !== void 0) return void 0;
+  if (!Array.isArray(config.include)) return true;
+  const relative3 = relativePosix(root, target);
+  return config.include.some((entry) => {
+    if (typeof entry !== "string") return false;
+    const pattern = entry.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(?:.*/)?").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${pattern}(?:/.*)?$`).test(relative3);
+  });
+}
+function relativePosix(from, to) {
+  return relative(from, to).split(sep).join("/");
+}
+function forTypeScript(module, outDir, root) {
+  if (!module.startsWith("/")) return module;
+  const absolute = resolvePath(root, module.slice(1));
+  let rel = relative(outDir, absolute).split(sep).join("/");
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel.replace(/\.(tsx|ts|jsx|mts|cts)$/, ".js");
+}
+function projectDependencies(root) {
+  try {
+    const manifest = JSON.parse(readFileSync(resolvePath(root, "package.json"), "utf8"));
+    return [
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {}),
+      ...Object.keys(manifest.peerDependencies ?? {})
+    ];
+  } catch {
+    return void 0;
+  }
+}
+function patternCandidates(rules, root) {
+  const out = [];
+  for (const rule of rules) {
+    if (!("match" in rule) || !rule.module.startsWith("/")) continue;
+    const dir = dirname(rule.module);
+    const file = basename(rule.module);
+    const group = file.match(/\$\d+/);
+    if (dir.includes("$") || !group || file.indexOf("$", group.index + 1) !== -1) continue;
+    const before = file.slice(0, group.index);
+    const after = file.slice(group.index + group[0].length);
+    let entries;
+    try {
+      entries = readdirSync(resolvePath(root, dir.slice(1)));
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.length > before.length + after.length && entry.startsWith(before) && entry.endsWith(after)) {
+        out.push(entry.slice(before.length, entry.length - after.length));
+      }
+    }
+  }
+  return out;
+}
+function writeComponentGlobals(options, root) {
+  if (options.globals === false) return { status: "skipped", reason: "disabled" };
+  const rules = options.resolve ?? [];
+  const target = resolvePath(root, options.globals ?? DEFAULT_GLOBALS_PATH);
+  let existing;
+  try {
+    existing = readFileSync(target, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  if (existing !== void 0 && !existing.includes(GENERATED_MARKER)) {
+    return { status: "skipped", reason: "foreign-file", path: target };
+  }
+  const { source, declared } = componentGlobals(rules, {
+    available: projectDependencies(root),
+    candidates: patternCandidates(rules, root),
+    specifier: (module) => forTypeScript(module, dirname(target), root)
+  });
+  if (existing === source) {
+    return {
+      status: "unchanged",
+      path: target,
+      declared: declared.length,
+      warning: warnIfUnreachable(root, target)
+    };
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, source);
+  return {
+    status: "written",
+    path: target,
+    declared: declared.length,
+    warning: warnIfUnreachable(root, target)
+  };
+}
+function warnIfUnreachable(root, target) {
+  if (coveredByInclude(root, target) !== false) return void 0;
+  const relative3 = relativePosix(root, target);
+  return `[fluixi] ${relative3} is not covered by "include" in tsconfig.json, so TypeScript will ignore it and every resolved component stays "Cannot find name". Add "${relative3}" to "include".`;
+}
+
+// src/vite-styles.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname2, extname, join, relative as relative2 } from "node:path";
+var STYLE_ID = /\.fx-(\d+)\.css(?:\?inline)?$/;
+var LITERAL_ID = /\.fx-literal-([\w$]+)\.css\?inline$/;
+var SUFFIX = /\.fx-(?:\d+|literal-[\w$]+)\.css(?:\?inline)?$/;
+var styleId = styleIds.block;
+function firstLoc(nodes) {
+  for (const node of nodes) {
+    if (node.loc) return node.loc.source;
+    if ((node.kind === "rule" || node.kind === "at-rule") && node.nodes.length) {
+      const inner = firstLoc(node.nodes);
+      if (inner) return inner;
+    }
+  }
+  return void 0;
+}
+var ownerOf = (id) => id.slice(0, id.search(SUFFIX));
+var loader = (name) => `const href = new URL(${JSON.stringify(`./${name}`)}, import.meta.url).href;
+if (typeof document !== 'undefined' && !document.querySelector(\`link[data-fx-css="\${href}"]\`)) {
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.href = href;
+  link.dataset.fxCss = href;
+  document.head.appendChild(link);
+}
+`;
+function createComponentStyles(compile) {
+  let api;
+  let server;
+  let root = process.cwd();
+  let library;
+  const emitted = /* @__PURE__ */ new Map();
+  const fileOf = (id) => existsSync(id) ? id : join(root, id);
+  const cache = /* @__PURE__ */ new Map();
+  const resolveReference = async (ref, importer, ctx, seen, modules) => {
+    const resolved = await ctx.resolve?.(ref.source, importer);
+    if (!resolved) return null;
+    const file = resolved.id.split("?")[0];
+    if (seen.has(file)) return null;
+    let code;
+    try {
+      code = readFileSync2(fileOf(file), "utf8");
+    } catch {
+      return null;
+    }
+    const styles = api.styles(file);
+    let result = compile(code, file, styles);
+    if (result?.styleReferences?.length) {
+      const imported = await resolveAll(result.styleReferences, file, ctx, /* @__PURE__ */ new Set([...seen, file]), modules);
+      result = compile(code, file, { ...styles, imported, importedModules: modules });
+    }
+    const literal = result?.styleLiterals?.find((l) => l.name === ref.name);
+    if (!literal) return null;
+    const nodes = literal.nodes ?? styles.process(literal.css, file);
+    const named = firstLoc(nodes);
+    if (named) modules.set(named, { id: file, code });
+    return nodes;
+  };
+  const resolveAll = async (refs, importer, ctx, seen, modules) => {
+    const imported = /* @__PURE__ */ new Map();
+    for (const ref of refs) {
+      const nodes = await resolveReference(ref, importer, ctx, seen, modules);
+      if (nodes) imported.set(`${ref.source}#${ref.name}`, nodes);
+    }
+    return imported;
+  };
+  const run = async (code, id, ctx) => {
+    const file = fileOf(id);
+    const styles = api.styles(file);
+    let result = compile(code, file, styles);
+    if (result?.styleReferences?.length) {
+      const modules = /* @__PURE__ */ new Map();
+      const imported = await resolveAll(result.styleReferences, id, ctx, /* @__PURE__ */ new Set([file]), modules);
+      result = compile(code, file, { ...styles, imported, importedModules: modules });
+    }
+    const css = (result?.styles ?? []).map((s) => s.css);
+    const maps = (result?.styles ?? []).map((s) => s.map ?? null);
+    const literals = new Map((result?.styleLiterals ?? []).map((l) => [l.name, l.css]));
+    const before = cache.get(file);
+    cache.set(file, { source: code, css, maps, literals });
+    if (server && before) {
+      for (let i = 0; i < css.length; i++) {
+        if (before.css[i] === css[i]) continue;
+        const mod = server.moduleGraph.getModuleById(styleId(file, i));
+        if (mod) void server.reloadModule(mod);
+      }
+    }
+    const page = (result?.styles ?? []).flatMap((s, i) => s.shadow ? [] : [i]);
+    if (!result || page.length === 0) return result;
+    if (library) {
+      const name = `${basename2(file, extname(file))}.css`;
+      if (existsSync(join(dirname2(file), name))) {
+        throw new Error(`[fluixi] ${file} has <style> blocks, and ${name} next to it would be overwritten by their CSS. Rename one of them.`);
+      }
+      const out = join(relative2(library, dirname2(file)), name);
+      emitted.set(out, page.map((i) => css[i]).join("\n"));
+      emitted.set(`${out}.js`, loader(name));
+      return { ...result, code: `${result.code}
+import ${JSON.stringify(`./${name}`)};` };
+    }
+    const imports = page.map((i) => `
+import ${JSON.stringify(styleId(file, i))};`).join("");
+    return { ...result, code: result.code + imports };
+  };
+  return {
+    /** Looks for @fluixi-css/vite among the plugins; without it component styles stay off. */
+    connect(plugins, projectRoot) {
+      if (projectRoot) root = projectRoot;
+      api = (plugins ?? []).map((p) => p?.api?.fluixiCss).find((a) => Boolean(a));
+      api?.useComponentStyles();
+    },
+    /** Turns on library output, from the directory of a `build.lib` entry. */
+    setLibrary(entryDir) {
+      library = entryDir;
+    },
+    /** A library build's style import: left for the package's consumer to bundle. */
+    isLibraryImport(id, importer) {
+      if (library === void 0 || !importer || !id.startsWith("./") || !id.endsWith(".css")) return false;
+      return emitted.has(join(relative2(library, dirname2(fileOf(importer))), id));
+    },
+    /** The style files a library build writes, by path under the output directory. */
+    libraryFiles() {
+      return emitted;
+    },
+    get active() {
+      return api !== void 0;
+    },
+    setServer(dev) {
+      server = dev;
+    },
+    isStyle(id) {
+      return STYLE_ID.test(id) || LITERAL_ID.test(id);
+    },
+    /**
+     * A style request as the module id Vite keeps: its owner's absolute path, then the suffix.
+     * One id per block however it was asked for (`/src/card.tsx.fx-0.css` from a page, the
+     * absolute path from the component), or the reload after an edit misses the copy in use.
+     * A css`` value imported from another module names that module relatively, as written.
+     */
+    async resolveId(id, importer, ctx) {
+      const at = id.search(SUFFIX);
+      const owner = id.slice(0, at);
+      if (!owner.startsWith(".")) return fileOf(owner) + id.slice(at);
+      const resolved = importer ? await ctx.resolve?.(owner, importer) : null;
+      return resolved ? resolved.id.split("?")[0] + id.slice(at) : null;
+    },
+    /**
+     * The style modules of a changed file, for the update Vite sends. Their ids do not name the
+     * file (they end in `.css`), so Vite would not find them itself.
+     */
+    hotModules(file, graph) {
+      const entry = cache.get(file);
+      if (!entry) return [];
+      const paths = [
+        ...entry.css.map((_, i) => styleId(file, i)),
+        ...[...entry.literals.keys()].map((name) => styleIds.literal(file, name).replace(/\?inline$/, ""))
+      ];
+      return paths.flatMap((path) => [...graph.getModulesByFile(path) ?? []]);
+    },
+    compile: run,
+    /**
+     * A block's CSS and its map back to the module, compiling the module again when the cache
+     * does not match the file.
+     */
+    async load(id, ctx) {
+      const match = STYLE_ID.exec(id);
+      const literal = LITERAL_ID.exec(id);
+      if (!match && !literal || !api) return null;
+      const file = ownerOf(id);
+      let source;
+      try {
+        source = readFileSync2(fileOf(file), "utf8");
+      } catch {
+        return null;
+      }
+      if (cache.get(fileOf(file))?.source !== source) await run(source, file, ctx);
+      const entry = cache.get(fileOf(file));
+      if (literal) {
+        const css = entry?.literals.get(literal[1]);
+        if (css === void 0) throw new Error(`[fluixi] ${literal[1]} in ${file} is not a css\`\` value, so it cannot be a shadow root's styles.`);
+        return { code: css, map: null, moduleType: "css" };
+      }
+      const index = Number(match[1]);
+      return { code: entry?.css[index] ?? "", map: entry?.maps[index] ?? null, moduleType: "css" };
+    }
+  };
+}
+
+// src/integrations.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname3, join as _join, resolve as resolvePath2 } from "node:path";
+async function createBabelPlugin(options = {}) {
+  let pluginModule = null;
+  try {
+    pluginModule = await import("./babel-I6BUWUCU.mjs");
+  } catch (e) {
+    console.warn("Could not load the babel front-end:", e);
+  }
+  return {
+    name: "babel-fluixi-jsx",
+    plugin: pluginModule ? pluginModule.default || pluginModule : null,
+    // Provide options mapping
+    getOptions() {
+      return {
+        importSource: options.importSource || "@fluixi/jsx",
+        development: options.development || false,
+        delegateEvents: options.delegateEvents !== false,
+        ...options.format ? { format: options.format } : {},
+        // Forwarded explicitly: getOptions() is an allowlist, so an option missing
+        // here is silently dropped rather than rejected.
+        ...options.resolve ? { resolve: options.resolve } : {},
+        ...options.templateClone !== void 0 ? { templateClone: options.templateClone } : {},
+        ...options.partialTemplates !== void 0 ? { partialTemplates: options.partialTemplates } : {},
+        ...options.litTag ? { litTag: options.litTag } : {},
+        ...options.signalModule ? { signalModule: options.signalModule } : {},
+        ...options.controlFlowModule ? { controlFlowModule: options.controlFlowModule } : {},
+        ...options.routerModule ? { routerModule: options.routerModule } : {},
+        ...options.reactiveModule ? { reactiveModule: options.reactiveModule } : {}
+      };
+    }
+  };
+}
+function createTypeScriptTransformer(options = {}) {
+  const ts = tryRequire("typescript");
+  if (!ts) {
+    console.warn("TypeScript not found, transformer unavailable");
+    return (context) => (sourceFile) => sourceFile;
+  }
+  return (context) => {
+    const visitor = (node) => {
+      if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+        return transformTSJSXNode(node, options, ts);
+      }
+      return ts.visitEachChild(node, visitor, context);
+    };
+    return (sourceFile) => {
+      return ts.visitNode(sourceFile, visitor);
+    };
+  };
+}
+function transformTSJSXNode(node, options, ts) {
+  return node;
+}
+function tryRequire(moduleName) {
+  try {
+    return __require(moduleName);
+  } catch (e) {
+    return null;
+  }
+}
+var RETIRED_SUBPATHS = {
+  "@fluixi/core/router-next": "is now @fluixi/core/router",
+  "@fluixi/core/rx": "is gone — import signals and effects from @fluixi/reactive, or the server primitives it resolved to under node from @fluixi/core/server"
+};
+function createVitePlugin(options = {}) {
+  let transformTemplates;
+  let projectRoot = process.cwd();
+  const componentStyles = createComponentStyles((code, id, styles) => {
+    return transformTemplates(code, id, { ...transformOptions(options, id), sourceRoot: projectRoot, styles });
+  });
+  return {
+    name: "vite-fluixi-jsx",
+    enforce: "pre",
+    // JSX the compiler leaves alone goes to Vite's own transform: Oxc in Vite 8 (Rolldown),
+    // esbuild before, which Vite 8 warns about.
+    // In dev, CSS maps are on unless the app says otherwise, so devtools show the line a
+    // component's rule was written on. Vite leaves them off by default; a build never has them.
+    config(user) {
+      const importSource = options.importSource || "@fluixi/jsx";
+      const jsx = this && this.meta?.rolldownVersion ? { oxc: { jsx: { runtime: "automatic", importSource } } } : { esbuild: { jsx: "automatic", jsxImportSource: importSource } };
+      return user?.css?.devSourcemap === void 0 ? { ...jsx, css: { devSourcemap: true } } : jsx;
+    },
+    // Written once per build, and on dev-server start, rather than per transform: the
+    // set of resolvable names comes from config, so nothing a file does can change it.
+    async configResolved(config) {
+      const outcome = writeComponentGlobals(options, config?.root ?? process.cwd());
+      if (outcome.warning) console.warn(outcome.warning);
+      if (options.babel) return;
+      projectRoot = config?.root ?? projectRoot;
+      componentStyles.connect(config?.plugins, config?.root);
+      const entry = config?.command === "build" && config.build?.lib ? config.build.lib.entry : void 0;
+      const first = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : entry && typeof entry === "object" ? Object.values(entry)[0] : void 0;
+      if (typeof first === "string") componentStyles.setLibrary(dirname3(resolvePath2(config.root ?? process.cwd(), first)));
+      if (componentStyles.active) ({ transformTemplates } = await import("./transform-3W45L3EA.mjs"));
+    },
+    generateBundle() {
+      for (const [fileName, source] of componentStyles.libraryFiles()) this.emitFile({ type: "asset", fileName, source });
+    },
+    // An edited component's style modules go out with its update: their ids end in `.css`, so
+    // Vite does not connect them to the file.
+    handleHotUpdate(ctx) {
+      if (!componentStyles.active) return void 0;
+      const styles = componentStyles.hotModules(ctx.file, ctx.server.moduleGraph);
+      return styles.length ? [...ctx.modules, ...styles] : void 0;
+    },
+    configureServer(server) {
+      componentStyles.setServer(server);
+    },
+    load(id) {
+      return componentStyles.isStyle(id) ? componentStyles.load(id, this) : null;
+    },
+    // A subpath we retired resolves to nothing, and the bundler reports that as
+    // `Missing "./x" specifier`, which names neither the replacement nor the file
+    // that asked. Answer it here, where the rename is known.
+    resolveId(id, importer) {
+      if (componentStyles.isStyle(id)) return componentStyles.resolveId(id, importer, this);
+      if (componentStyles.isLibraryImport(id, importer)) return { id, external: true };
+      const moved = RETIRED_SUBPATHS[id];
+      if (!moved) return null;
+      throw new Error(
+        `[fluixi] ${id} ${moved}` + (importer ? `
+  imported by ${importer}` : "")
+      );
+    },
+    async transform(code, id) {
+      if (!/\.(jsx|tsx|ts)$/i.test(id)) {
+        return null;
+      }
+      if (!options.babel && componentStyles.active) {
+        const result = await componentStyles.compile(code, id, this);
+        reportDiagnostics(result, id);
+        return result;
+      }
+      if (!options.babel) return compileModule(code, id, options);
+      const babelPlugin = await createBabelPlugin(options);
+      try {
+        const babel = await import("@babel/core").catch(() => null);
+        if (!babel) {
+          throw new Error(
+            `[fluixi] @babel/core is required to compile ${id} but could not be loaded. Install it alongside @fluixi/compiler.`
+          );
+        }
+        const isTSX = /\.tsx$/.test(id);
+        const isTS = /\.ts$/.test(id);
+        const presets = [];
+        const plugins = [];
+        if (isTSX || isTS) {
+          const tsPreset = await import("@babel/preset-typescript").then((m) => m.default || m).catch(() => null);
+          if (tsPreset) {
+            presets.push([
+              tsPreset,
+              {
+                isTSX,
+                allExtensions: true,
+                // Important: preserve JSX so our plugin can transform it
+                jsxPragma: "jsx",
+                jsxPragmaFrag: "Fragment",
+                onlyRemoveTypeImports: true
+              }
+            ]);
+          }
+        }
+        if (babelPlugin && babelPlugin.plugin) {
+          plugins.push([babelPlugin.plugin, babelPlugin.getOptions()]);
+        } else {
+          console.warn("[createVitePlugin] custom babel plugin not found");
+        }
+        const result = await babel.transformAsync(code, {
+          filename: id,
+          configFile: false,
+          babelrc: false,
+          presets,
+          plugins,
+          sourceMaps: options.sourceMaps !== false
+        });
+        return {
+          code: result?.code || code,
+          map: result?.map
+        };
+      } catch (e) {
+        throw e;
+      }
+    }
+  };
+}
+function marks(options, id) {
+  if (options.sourceLocations !== true) return false;
+  if (options.sourceLocationsExternal) return true;
+  if (!id || id.includes("/node_modules/")) return false;
+  const root = options.sourceRoot;
+  if (!root) return true;
+  const base = root.endsWith("/") ? root : `${root}/`;
+  return id.startsWith(base);
+}
+function transformOptions(options, id) {
+  return {
+    resolve: options.resolve,
+    litTag: options.litTag,
+    sourceLocations: marks(options, id),
+    sourceRoot: options.sourceRoot,
+    templateClone: options.templateClone,
+    partialTemplates: options.partialTemplates,
+    runtimeModule: options.signalModule,
+    controlFlowModule: options.controlFlowModule,
+    routerModule: options.routerModule,
+    reactiveModule: options.reactiveModule,
+    propsDestructure: options.propsDestructure
+  };
+}
+async function rewriteProps(code, id, options) {
+  if (options.propsDestructure === false) return code;
+  const { transformProps } = await import("./transform-3W45L3EA.mjs");
+  const result = transformProps(code, id);
+  reportDiagnostics({ propsDiagnostics: result.diagnostics }, id);
+  return result.rewritten > 0 ? result.code : code;
+}
+var reported = /* @__PURE__ */ new Set();
+function reportDiagnostics(result, id) {
+  const r = result;
+  const say = (message) => {
+    const key = `${id}\0${message}`;
+    if (reported.has(key)) return;
+    reported.add(key);
+    console.warn(`[fluixi] ${id}: ${message}`);
+  };
+  for (const d of r?.unresolvedDiagnostics ?? []) say(d.message);
+  for (const d of r?.loadDiagnostics ?? []) say(d.message);
+  for (const d of r?.intrinsicDiagnostics ?? []) say(d.message);
+  for (const d of r?.styleDiagnostics ?? []) say(`${d.line}:${d.column + 1} ${d.message}`);
+  for (const d of r?.propsDiagnostics ?? []) {
+    say(`\`${d.name}\` was left destructured: ${d.message}. It reads once instead of tracking.`);
+  }
+}
+async function compileModule(code, id, options) {
+  if (!options.babel) {
+    const { transformTemplates } = await import("./transform-3W45L3EA.mjs");
+    const result2 = transformTemplates(code, id, transformOptions(options, id));
+    reportDiagnostics(result2, id);
+    return result2;
+  }
+  const source = await rewriteProps(code, id, options);
+  const babel = await import("@babel/core").catch(() => null);
+  const plugin = await createBabelPlugin(options);
+  if (!babel || !plugin.plugin) {
+    throw new Error(
+      `[fluixi] babel: true needs @babel/core, which could not be loaded for ${id}. Install it, or drop the option to use the built-in compiler.`
+    );
+  }
+  const result = await babel.transformAsync(source, {
+    filename: id,
+    configFile: false,
+    babelrc: false,
+    plugins: [[plugin.plugin, plugin.getOptions()]],
+    sourceMaps: options.sourceMaps !== false
+  });
+  return result?.code ? { code: result.code, map: result.map } : null;
+}
+function createWebpackLoader(options = {}) {
+  return async function(source) {
+    const callback = this.async();
+    compileModule(source, this.resourcePath, options).then((result) => {
+      callback(null, result?.code, result?.map);
+    }).catch((err) => {
+      callback(err);
+    });
+  };
+}
+function createRollupPlugin(options = {}) {
+  return {
+    name: "rollup-fluixi-jsx",
+    async transform(code, id) {
+      if (!/\.[jt]sx?$/.test(id)) return null;
+      return compileModule(code, id, options);
+    }
+  };
+}
+function createESBuildPlugin(options = {}) {
+  return {
+    name: "esbuild-fluixi-jsx",
+    setup(build) {
+      build.onLoad({ filter: /\.[jt]sx?$/ }, async (args) => {
+        const { readFileSync: readFileSync4 } = await import("node:fs");
+        const source = readFileSync4(args.path, "utf8");
+        try {
+          const result = await compileModule(source, args.path, options);
+          return {
+            contents: result?.code ?? source,
+            loader: args.path.endsWith("x") ? "tsx" : "ts"
+          };
+        } catch (e) {
+          return {
+            errors: [
+              {
+                text: `Transform error: ${e}`
+              }
+            ]
+          };
+        }
+      });
+    }
+  };
+}
+var SERVER_FNS_VMOD = "virtual:fluixi-server-fns";
+function hasServerDirective(source) {
+  const withoutComments = source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/[^\n]*/g, "$1");
+  return /(^|[\s;{(,])['"]use server['"]/.test(withoutComments);
+}
+function findServerFnModules(dir, out = []) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (e.name === "node_modules" || e.name === "dist" || e.name.startsWith(".")) continue;
+    const full = _join(dir, e.name);
+    if (e.isDirectory()) findServerFnModules(full, out);
+    else if (/\.[jt]sx?$/.test(e.name)) {
+      try {
+        if (hasServerDirective(readFileSync3(full, "utf8"))) out.push(full);
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+function serverFunctionsVitePlugin(options = {}) {
+  let root = process.cwd();
+  return {
+    name: "fluixi-server-functions",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(id) {
+      return id === SERVER_FNS_VMOD || id === "@fluixi/start/server-fns" ? "\0" + SERVER_FNS_VMOD : null;
+    },
+    load(id) {
+      if (id !== "\0" + SERVER_FNS_VMOD) return null;
+      const mods = findServerFnModules(_join(root, "src"));
+      const setup = `import '@fluixi/start/server-fn-setup';
+`;
+      const imports = mods.map((m) => `import ${JSON.stringify(m)};`).join("\n");
+      const dispatcher = `
+export { isServerFnRequest, handleServerFn } from '@fluixi/start/server-fn';
+`;
+      return setup + imports + dispatcher;
+    },
+    async transform(code, id, opts) {
+      if (!/\.[jt]sx?$/.test(id)) return null;
+      if (!code.includes("use server")) return null;
+      const args = { ssr: !!opts?.ssr, filename: id, root };
+      if (options.babel) {
+        const { transformServerFunctions } = await import("./server-functions-UAZKOLZW.mjs");
+        return transformServerFunctions(code, args);
+      }
+      const { transformServerFns } = await import("./server-fns-VZLHMQTC.mjs");
+      return transformServerFns(code, args);
+    }
+  };
+}
+var integrations_default = {
+  createBabelPlugin,
+  createTypeScriptTransformer,
+  createVitePlugin,
+  createWebpackLoader,
+  createRollupPlugin,
+  createESBuildPlugin
+};
+export {
+  createBabelPlugin,
+  createESBuildPlugin,
+  createRollupPlugin,
+  createTypeScriptTransformer,
+  createVitePlugin,
+  createWebpackLoader,
+  integrations_default as default,
+  serverFunctionsVitePlugin
+};