@fluixi/vite-plugin 1.0.0-alpha.100

package/dist/index.mjs

@@ -0,0 +1,254 @@
+/*! @fluixi/vite-plugin v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/index.ts
+import { createVitePlugin } from "@fluixi/compiler/integrations";
+
+// src/graph-channel.ts
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+var VIRTUAL = "virtual:fluixi/devtools-agent";
+var RESOLVED = `\0${VIRTUAL}`;
+var ENDPOINT = "/__fluixi/graph";
+var EVENT = "fluixi:graph";
+var MISSING = "the plugin could not load @fluixi/devtools from its own dependencies";
+var WAITING = "no page has reported yet — open the application in a browser";
+var INTERVAL = 100;
+var HISTORY = 500;
+var agentSource = (devtools, plugins, signal, reactive) => `
+import { installDevtoolsHook, observeGraph } from ${JSON.stringify(devtools)};
+import ${JSON.stringify(plugins)};
+import { observeReactiveNodes } from ${JSON.stringify(signal)};
+import { VERSION } from ${JSON.stringify(reactive)};
+
+// The runtime this module imports is the application's own, same module graph, same nodes.
+// Nothing waits for the runtime to offer itself; that path is for a tool loaded from outside.
+//
+// \`watch\` is this copy of devtools, handed over with the runtime. A browser extension
+// installs a hook at document_start and so owns it; without this the graph would be built
+// by that extension's build rather than the one shipped alongside this application.
+const hook = installDevtoolsHook();
+hook.inject({ observeReactiveNodes, version: VERSION, watch: observeGraph });
+
+const send = (kind, snapshot) => import.meta.hot?.send(${JSON.stringify(EVENT)}, { kind, snapshot });
+
+const first = hook.snapshot();
+// Kept and handed back, so a browser panel polling the same hook cannot consume what this
+// one has not been told about yet.
+let cursor = first?.cursor;
+send('full', first);
+const timer = setInterval(() => {
+  const delta = hook.snapshot({ partial: true, since: cursor });
+  if (!delta) return;
+  cursor = delta.cursor;
+  // Events count on their own: an effect that ran without changing a value moves no node.
+  if (delta.nodes.length || delta.removed?.length || delta.events?.length) send('delta', delta);
+}, ${INTERVAL});
+
+import.meta.hot?.dispose(() => clearInterval(timer));
+`;
+function ownDevtools() {
+  return resolveForBrowser("@fluixi/devtools");
+}
+function ownPlugins() {
+  return resolveForBrowser("@fluixi/devtools/plugins");
+}
+function resolveForBrowser(spec) {
+  try {
+    const resolved = import.meta.resolve?.(spec);
+    if (resolved) return fileURLToPath(resolved);
+  } catch {
+  }
+  try {
+    const required = createRequire(import.meta.url).resolve(spec);
+    if (!required.endsWith(".cjs")) return required;
+    for (const ext of [".mjs", ".js"]) {
+      const sibling = required.slice(0, -".cjs".length) + ext;
+      if (existsSync(sibling)) return sibling;
+    }
+    return required;
+  } catch {
+    return null;
+  }
+}
+function withGraphChannel(base, enabled, start) {
+  let wire = null;
+  let available = false;
+  let reason = MISSING;
+  let root = process.cwd();
+  let log;
+  let graph = /* @__PURE__ */ new Map();
+  let stamp = 0;
+  let events = [];
+  const baseResolveId = base.resolveId;
+  const baseTransformIndexHtml = base.transformIndexHtml;
+  const baseLoad = base.load;
+  const baseConfigureServer = base.configureServer;
+  return {
+    ...base,
+    resolveId(id, importer) {
+      if (id === VIRTUAL) return RESOLVED;
+      return baseResolveId?.call(this, id, importer) ?? null;
+    },
+    async load(id) {
+      if (id !== RESOLVED) return await baseLoad?.call(this, id) ?? null;
+      const from = join(root, "fluixi-devtools-agent.js");
+      const specs = ["@fluixi/reactive/signal", "@fluixi/reactive"];
+      const ids = await Promise.all(specs.map((spec) => this.resolve?.(spec, from, { skipSelf: true })));
+      const missing = specs.filter((_, i) => !ids[i]?.id);
+      const devtools = ownDevtools();
+      const plugins = ownPlugins();
+      if (missing.length || !devtools || !plugins) {
+        reason = missing.length ? `${missing.join(", ")} did not resolve from ${root}` : MISSING;
+        log?.(`[fluixi] reactive graph off — ${reason}`);
+        return "export {};";
+      }
+      return agentSource(`/@fs/${devtools}`, `/@fs/${plugins}`, ids[0].id, ids[1].id);
+    },
+    async configureServer(server) {
+      await baseConfigureServer?.call(this, server);
+      if (!enabled()) return;
+      root = server.config?.root ?? root;
+      log = server.config?.logger?.info.bind(server.config.logger);
+      wire = await import("@fluixi/devtools/wire").catch(() => null);
+      available = wire !== null;
+      if (wire) start();
+      if (wire) reason = WAITING;
+      else {
+        log?.(`[fluixi] reactive graph off — ${MISSING}`);
+      }
+      server.middlewares.use(ENDPOINT, (_req, res) => {
+        const snapshot = wire ? { ...wire.serializeGraph(graph, stamp || Date.now()), events } : { t: Date.now(), nodes: [] };
+        const body = JSON.stringify(reason ? { ...snapshot, reason } : snapshot);
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(body);
+      });
+      if (!wire) return;
+      server.ws.on(EVENT, (payload) => {
+        const message = payload;
+        if (!message?.snapshot || !wire) return;
+        const full = message.kind === "full";
+        graph = wire.applySnapshot(full ? /* @__PURE__ */ new Map() : graph, message.snapshot);
+        if (full) events = [];
+        const arriving = message.snapshot.events;
+        if (arriving?.length) events = [...events, ...arriving].slice(-HISTORY);
+        stamp = Date.now();
+        reason = null;
+      });
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler(html, ctx) {
+        const inherited = callInheritedHtml(baseTransformIndexHtml, html, ctx);
+        if (!enabled() || !available || !wire) return inherited;
+        return {
+          html: typeof inherited === "string" ? inherited : html,
+          tags: [
+            {
+              tag: "script",
+              // First in the head, so the entry cannot create a node before the agent runs.
+              injectTo: "head-prepend",
+              attrs: { type: "module", src: `/@id/${VIRTUAL}` }
+            }
+          ]
+        };
+      }
+    }
+  };
+}
+function callInheritedHtml(hook, html, ctx) {
+  if (typeof hook === "function") return hook(html, ctx);
+  const handler = hook?.handler;
+  return handler?.(html, ctx);
+}
+
+// src/share.ts
+var PREFIX = "share/";
+var chunkName = (id) => PREFIX + id.replace(/^@/, "").replace(/[^a-zA-Z0-9]+/g, "-");
+function share(options) {
+  const modules = [...new Set(options.modules)];
+  const names = new Map(modules.map((id) => [chunkName(id), id]));
+  if (names.size !== modules.length) {
+    throw new Error("[fluixi] share: two modules map to the same chunk name; list each id once.");
+  }
+  let base = "/";
+  let browser = true;
+  const importMap = (bundle) => {
+    const imports = {};
+    for (const file of Object.values(bundle)) {
+      if (file.type !== "chunk" || !file.name) continue;
+      const id = names.get(file.name);
+      if (id) imports[id] = base + file.fileName;
+    }
+    const missing = modules.filter((id) => !imports[id]);
+    if (missing.length) throw new Error(`[fluixi] share: no chunk was written for ${missing.join(", ")}.`);
+    return { imports };
+  };
+  return {
+    name: "fluixi:share",
+    apply: "build",
+    configResolved(config) {
+      browser = !config.build.ssr;
+      base = config.base.startsWith("/") ? config.base : "/";
+    },
+    buildStart() {
+      if (!browser) return;
+      for (const id of modules) {
+        this.emitFile({ type: "chunk", id, name: chunkName(id), preserveSignature: "strict" });
+      }
+    },
+    generateBundle(_, bundle) {
+      if (!browser) return;
+      this.emitFile({
+        type: "asset",
+        fileName: options.manifest ?? "share.json",
+        source: `${JSON.stringify(importMap(bundle), null, 2)}
+`
+      });
+    },
+    transformIndexHtml: {
+      order: "post",
+      handler(_html, ctx) {
+        if (!browser || !ctx.bundle) return;
+        return [{ tag: "script", attrs: { type: "importmap" }, children: JSON.stringify(importMap(ctx.bundle)), injectTo: "head-prepend" }];
+      }
+    }
+  };
+}
+
+// src/index.ts
+function fluixi(options = {}) {
+  const settings = options;
+  let serving = false;
+  const enabled = () => serving && settings.devtools !== false;
+  const base = createVitePlugin(settings);
+  const inherited = base.configResolved;
+  const start = () => {
+    settings.sourceLocations = true;
+    settings.sourceLocationsExternal = typeof settings.devtools === "object" && settings.devtools.external === true;
+  };
+  return withGraphChannel(
+    {
+      ...base,
+      // Awaited: the compiler's own hook loads the transform it needs for component styles, and
+      // Vite starts transforming as soon as every configResolved has settled.
+      async configResolved(config) {
+        await inherited?.(config);
+        serving = config?.command === "serve";
+        settings.sourceRoot = config.root;
+      }
+    },
+    enabled,
+    start
+  );
+}
+var index_default = fluixi;
+export {
+  createVitePlugin,
+  index_default as default,
+  fluixi,
+  share
+};

package/dist/share.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/share.ts
+var share_exports = {};
+__export(share_exports, {
+  share: () => share
+});
+module.exports = __toCommonJS(share_exports);
+var PREFIX = "share/";
+var chunkName = (id) => PREFIX + id.replace(/^@/, "").replace(/[^a-zA-Z0-9]+/g, "-");
+function share(options) {
+  const modules = [...new Set(options.modules)];
+  const names = new Map(modules.map((id) => [chunkName(id), id]));
+  if (names.size !== modules.length) {
+    throw new Error("[fluixi] share: two modules map to the same chunk name; list each id once.");
+  }
+  let base = "/";
+  let browser = true;
+  const importMap = (bundle) => {
+    const imports = {};
+    for (const file of Object.values(bundle)) {
+      if (file.type !== "chunk" || !file.name) continue;
+      const id = names.get(file.name);
+      if (id) imports[id] = base + file.fileName;
+    }
+    const missing = modules.filter((id) => !imports[id]);
+    if (missing.length) throw new Error(`[fluixi] share: no chunk was written for ${missing.join(", ")}.`);
+    return { imports };
+  };
+  return {
+    name: "fluixi:share",
+    apply: "build",
+    configResolved(config) {
+      browser = !config.build.ssr;
+      base = config.base.startsWith("/") ? config.base : "/";
+    },
+    buildStart() {
+      if (!browser) return;
+      for (const id of modules) {
+        this.emitFile({ type: "chunk", id, name: chunkName(id), preserveSignature: "strict" });
+      }
+    },
+    generateBundle(_, bundle) {
+      if (!browser) return;
+      this.emitFile({
+        type: "asset",
+        fileName: options.manifest ?? "share.json",
+        source: `${JSON.stringify(importMap(bundle), null, 2)}
+`
+      });
+    },
+    transformIndexHtml: {
+      order: "post",
+      handler(_html, ctx) {
+        if (!browser || !ctx.bundle) return;
+        return [{ tag: "script", attrs: { type: "importmap" }, children: JSON.stringify(importMap(ctx.bundle)), injectTo: "head-prepend" }];
+      }
+    }
+  };
+}

package/dist/share.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Modules an app shares with code it loads at run time: plugins installed into a deployment,
+ * not built with the app. Such code imports `@fluixi/core` by name and must get the app's
+ * copy, or it drives a second reactive runtime, a second DI container and a second element
+ * registry.
+ *
+ * In a browser build each shared module becomes its own chunk, keeping every export, and an
+ * import map names it: written as `share.json` next to the assets, and placed first in the
+ * `<head>` of an `index.html` the build processes. A server build is left alone; there the
+ * modules must stay external so loaded code resolves them from `node_modules` (`@fluixi/start`
+ * does that from its own `share` option).
+ *
+ * @module
+ */
+import type { Plugin } from 'vite';
+/** Options of {@link share}. */
+export interface ShareOptions {
+    /**
+     * Module ids to share, each as code will import it: `@fluixi/core`, `@fluixi/core/router`.
+     * A subpath is a module of its own and is listed on its own.
+     */
+    modules: readonly string[];
+    /** File name of the import map written next to the assets. Default `share.json`. */
+    manifest?: string;
+}
+/** What `share.json` holds: an import map. */
+export interface ShareManifest {
+    imports: Record<string, string>;
+}
+/**
+ * Share `modules` with code loaded at run time, through an import map.
+ *
+ * Shared modules are kept whole: their unused exports are not shaken out, since the app cannot
+ * know which ones a plugin will use.
+ *
+ * @example
+ * ```ts
+ * import { fluixi, share } from '@fluixi/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [fluixi(), share({ modules: ['@fluixi/core', '@fluixi/reactive/signal'] })],
+ * });
+ * ```
+ */
+export declare function share(options: ShareOptions): Plugin;
+//# sourceMappingURL=share.d.ts.map

package/dist/share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share.d.ts","sourceRoot":"","sources":["../src/share.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,gCAAgC;AAChC,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,8CAA8C;AAC9C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAOD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAsDnD"}

package/dist/share.js

@@ -0,0 +1,77 @@
+const PREFIX = 'share/';
+/** `@buntubi/sdk/plugins` becomes `buntubi-sdk-plugins`: a chunk name, unique per id. */
+const chunkName = (id) => PREFIX + id.replace(/^@/, '').replace(/[^a-zA-Z0-9]+/g, '-');
+/**
+ * Share `modules` with code loaded at run time, through an import map.
+ *
+ * Shared modules are kept whole: their unused exports are not shaken out, since the app cannot
+ * know which ones a plugin will use.
+ *
+ * @example
+ * ```ts
+ * import { fluixi, share } from '@fluixi/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [fluixi(), share({ modules: ['@fluixi/core', '@fluixi/reactive/signal'] })],
+ * });
+ * ```
+ */
+export function share(options) {
+    const modules = [...new Set(options.modules)];
+    const names = new Map(modules.map((id) => [chunkName(id), id]));
+    if (names.size !== modules.length) {
+        throw new Error('[fluixi] share: two modules map to the same chunk name; list each id once.');
+    }
+    let base = '/';
+    let browser = true;
+    /** The import map, read from the chunks this build wrote. */
+    const importMap = (bundle) => {
+        const imports = {};
+        for (const file of Object.values(bundle)) {
+            if (file.type !== 'chunk' || !file.name)
+                continue;
+            const id = names.get(file.name);
+            if (id)
+                imports[id] = base + file.fileName;
+        }
+        const missing = modules.filter((id) => !imports[id]);
+        if (missing.length)
+            throw new Error(`[fluixi] share: no chunk was written for ${missing.join(', ')}.`);
+        return { imports };
+    };
+    return {
+        name: 'fluixi:share',
+        apply: 'build',
+        configResolved(config) {
+            browser = !config.build.ssr;
+            // A relative base cannot address a chunk from an import map, which resolves against the
+            // page: the deployment's absolute base is what it needs.
+            base = config.base.startsWith('/') ? config.base : '/';
+        },
+        buildStart() {
+            if (!browser)
+                return;
+            for (const id of modules) {
+                this.emitFile({ type: 'chunk', id, name: chunkName(id), preserveSignature: 'strict' });
+            }
+        },
+        generateBundle(_, bundle) {
+            if (!browser)
+                return;
+            this.emitFile({
+                type: 'asset',
+                fileName: options.manifest ?? 'share.json',
+                source: `${JSON.stringify(importMap(bundle), null, 2)}\n`,
+            });
+        },
+        transformIndexHtml: {
+            order: 'post',
+            handler(_html, ctx) {
+                if (!browser || !ctx.bundle)
+                    return;
+                // First in <head>: a module script or preload before it would resolve without the map.
+                return [{ tag: 'script', attrs: { type: 'importmap' }, children: JSON.stringify(importMap(ctx.bundle)), injectTo: 'head-prepend' }];
+            },
+        },
+    };
+}

package/dist/share.mjs

@@ -0,0 +1,56 @@
+// src/share.ts
+var PREFIX = "share/";
+var chunkName = (id) => PREFIX + id.replace(/^@/, "").replace(/[^a-zA-Z0-9]+/g, "-");
+function share(options) {
+  const modules = [...new Set(options.modules)];
+  const names = new Map(modules.map((id) => [chunkName(id), id]));
+  if (names.size !== modules.length) {
+    throw new Error("[fluixi] share: two modules map to the same chunk name; list each id once.");
+  }
+  let base = "/";
+  let browser = true;
+  const importMap = (bundle) => {
+    const imports = {};
+    for (const file of Object.values(bundle)) {
+      if (file.type !== "chunk" || !file.name) continue;
+      const id = names.get(file.name);
+      if (id) imports[id] = base + file.fileName;
+    }
+    const missing = modules.filter((id) => !imports[id]);
+    if (missing.length) throw new Error(`[fluixi] share: no chunk was written for ${missing.join(", ")}.`);
+    return { imports };
+  };
+  return {
+    name: "fluixi:share",
+    apply: "build",
+    configResolved(config) {
+      browser = !config.build.ssr;
+      base = config.base.startsWith("/") ? config.base : "/";
+    },
+    buildStart() {
+      if (!browser) return;
+      for (const id of modules) {
+        this.emitFile({ type: "chunk", id, name: chunkName(id), preserveSignature: "strict" });
+      }
+    },
+    generateBundle(_, bundle) {
+      if (!browser) return;
+      this.emitFile({
+        type: "asset",
+        fileName: options.manifest ?? "share.json",
+        source: `${JSON.stringify(importMap(bundle), null, 2)}
+`
+      });
+    },
+    transformIndexHtml: {
+      order: "post",
+      handler(_html, ctx) {
+        if (!browser || !ctx.bundle) return;
+        return [{ tag: "script", attrs: { type: "importmap" }, children: JSON.stringify(importMap(ctx.bundle)), injectTo: "head-prepend" }];
+      }
+    }
+  };
+}
+export {
+  share
+};