@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.85

package/dist/frontend/babel/plugin.d.cts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Babel front-end for the Fluixi compiler.
+ * @module @fluixi/babel-plugin-jsx
+ *
+ * This is a host adapter, not the compiler. It parses with babel and, for each
+ * JSX element/fragment and each `` html`...` `` template, hands the node to the
+ * shared pipeline: build IR, run the imperative backend, then splices the
+ * emitted code back into the program. Everything that decides *what* the output
+ * means (directives, control flow, component resolution, load strategies,
+ * reactivity, templates) lives in ../../{ir,resolve,optimize,codegen}, which
+ * import no babel at all.
+ *
+ * What stays here is genuinely host work: dispatching the visitors, collecting
+ * the runtime symbols the backend reported so the imports can be injected, and
+ * hoisting static templates to module scope.
+ */
+import { type ComponentResolverRule } from '../../resolve/component-resolver.cjs';
+import { type PluginObj } from '@babel/core';
+export interface PluginOptions {
+    /**
+     * Import source for the JSX types and for whatever JSX this plugin does not
+     * consume: esbuild's automatic runtime and TypeScript's `jsxImportSource`
+     * both point at it. The compiler itself never emits `jsx()` calls.
+     * @default '@fluixi/jsx'
+     */
+    importSource?: string;
+    /**
+     * Enable development mode with additional checks
+     * @default false
+     */
+    development?: boolean;
+    /**
+     * Enable event delegation
+     * @default true
+     */
+    delegateEvents?: boolean;
+    /**
+     * Generate source maps
+     * @default true
+     */
+    sourceMaps?: boolean;
+    /**
+     * Module name for signal directive
+     * @default '@fluixi/dom'
+     */
+    signalModule?: string;
+    /**
+     * Module name for control flow
+     * @default '@fluixi/dom'
+     */
+    controlFlowModule?: string;
+    /**
+     * Module the router components (Router/Outlet/…) are auto-imported from.
+     * @default '@fluixi/core/router'
+     */
+    routerModule?: string;
+    /** Clone static subtrees from a template. Client-only, see CompilerOptions. */
+    templateClone?: boolean;
+    /** Also clone structure-static subtrees with holes. See CompilerOptions. */
+    partialTemplates?: boolean;
+    /**
+     * Rules that resolve an unbound capitalised tag to a module, so a component can be
+     * used without an import: the configurable form of the built-in
+     * Suspense/Portal/Router auto-import.
+     *
+     * A lexical binding always wins, so an explicit import or a local variable is never
+     * overridden. With no rules, behaviour is exactly as before.
+     */
+    resolve?: readonly ComponentResolverRule[];
+    /**
+     * Where reactive primitives (createMemo) are imported from, the signal core,
+     * not the dom runtime.
+     * @default '@fluixi/reactive/signal'
+     */
+    reactiveModule?: string;
+    /**
+     * Which authoring syntaxes to compile:
+     * - 'jsx': only JSX elements/fragments.
+     * - 'lit': only `` html`...` `` / `` svg`...` `` tagged templates.
+     * - 'both' (default): JSX and `html``` templates in the same file.
+     *
+     * Both syntaxes lower to the same IR and the same imperative backend, so the
+     * choice is about which source forms the plugin touches, not about output.
+     * @default 'both'
+     */
+    format?: 'jsx' | 'lit' | 'both';
+    /**
+     * Tag name that marks a lit template for compilation (when `format` includes
+     * lit). Other tagged templates are left untouched.
+     * @default 'html'
+     */
+    litTag?: string;
+}
+declare const _default: (api: object, options: PluginOptions | null | undefined, dirname: string) => PluginObj<import("@babel/core").PluginPass>;
+export default _default;

package/dist/frontend/babel/plugin.d.ts

@@ -4,7 +4,7 @@
  *
  * This is a host adapter, not the compiler. It parses with babel and, for each
  * JSX element/fragment and each `` html`...` `` template, hands the node to the
- * shared pipeline — build IR, run the imperative backend — then splices the
+ * shared pipeline: build IR, run the imperative backend, then splices the
  * emitted code back into the program. Everything that decides *what* the output
  * means (directives, control flow, component resolution, load strategies,
  * reactivity, templates) lives in ../../{ir,resolve,optimize,codegen}, which
@@ -19,7 +19,7 @@ import { type PluginObj } from '@babel/core';
 export interface PluginOptions {
     /**
      * Import source for the JSX types and for whatever JSX this plugin does not
-     * consume — esbuild's automatic runtime and TypeScript's `jsxImportSource`
+     * consume: esbuild's automatic runtime and TypeScript's `jsxImportSource`
      * both point at it. The compiler itself never emits `jsx()` calls.
      * @default '@fluixi/jsx'
      */
@@ -54,13 +54,13 @@ export interface PluginOptions {
      * @default '@fluixi/core/router'
      */
     routerModule?: string;
-    /** Clone static subtrees from a template. Client-only — see CompilerOptions. */
+    /** Clone static subtrees from a template. Client-only, see CompilerOptions. */
     templateClone?: boolean;
     /** Also clone structure-static subtrees with holes. See CompilerOptions. */
     partialTemplates?: boolean;
     /**
      * Rules that resolve an unbound capitalised tag to a module, so a component can be
-     * used without an import — the configurable form of the built-in
+     * used without an import: the configurable form of the built-in
      * Suspense/Portal/Router auto-import.
      *
      * A lexical binding always wins, so an explicit import or a local variable is never
@@ -68,7 +68,7 @@ export interface PluginOptions {
      */
     resolve?: readonly ComponentResolverRule[];
     /**
-     * Where reactive primitives (createMemo) are imported from — the signal core,
+     * Where reactive primitives (createMemo) are imported from, the signal core,
      * not the dom runtime.
      * @default '@fluixi/reactive/signal'
      */

package/dist/frontend/babel/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/frontend/babel/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAEL,KAAK,qBAAqB,EAG3B,MAAM,qCAAqC,CAAC;AAQ7C,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAUnE,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAE3C;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAEhC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;;AAkDD,wBAgVG"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/frontend/babel/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAEL,KAAK,qBAAqB,EAG3B,MAAM,qCAAqC,CAAC;AAQ7C,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAUnE,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAE3C;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAEhC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;;AAkDD,wBAgVG"}

package/dist/frontend/babel/plugin.js

@@ -4,7 +4,7 @@
  *
  * This is a host adapter, not the compiler. It parses with babel and, for each
  * JSX element/fragment and each `` html`...` `` template, hands the node to the
- * shared pipeline — build IR, run the imperative backend — then splices the
+ * shared pipeline: build IR, run the imperative backend, then splices the
  * emitted code back into the program. Everything that decides *what* the output
  * means (directives, control flow, component resolution, load strategies,
  * reactivity, templates) lives in ../../{ir,resolve,optimize,codegen}, which
@@ -27,7 +27,7 @@ import { imperativeBackend } from '../../codegen/backends/imperative.js';
 // ============================================================================
 // Constants
 // ============================================================================
-// Control-flow components that live in fluixi, NOT @fluixi/dom — they must
+// Control-flow components that live in fluixi, NOT @fluixi/dom, they must
 // be auto-imported from core (dom doesn't export them).
 const CORE_ONLY_CONTROL_FLOW = new Set(CORE_CONTROL_FLOW);
 // Router components auto-imported (from routerModule) the same way control flow is:
@@ -168,7 +168,7 @@ export default declare((api, options = {}) => {
                         // enabling resolution can never change what an existing file means.
                         //
                         // Grouped by module so several components from one package share a single
-                        // declaration, and emitted with the local name equal to the tag — the
+                        // declaration, and emitted with the local name equal to the tag, the
                         // generated code refers to the tag, not to the export.
                         // Deferred components become value bindings, not imports: a literal
                         // `import()` is what lets the bundler split, hash and tree-shake the chunk
@@ -232,7 +232,7 @@ export default declare((api, options = {}) => {
                                     t.variableDeclarator(t.identifier(name), 
                                     // Just the HTML. Parsing is deferred to `templateNode`, which
                                     // knows whether this is a server render, a hydration or a fresh
-                                    // client render — a module-scope `createTemplate` would touch
+                                    // client render: a module-scope `createTemplate` would touch
                                     // `document` at import time and break SSR outright.
                                     t.stringLiteral(html)),
                                 ]));
@@ -242,7 +242,7 @@ export default declare((api, options = {}) => {
                     }
                     // Add all imports at the top, deduped. When a file mixes inline JSX
                     // and html`` (format 'both'), the two injection paths can each emit an
-                    // import for the same module/name — merge per-module and drop repeated
+                    // import for the same module/name: merge per-module and drop repeated
                     // specifiers so we never redeclare a binding.
                     if (imports.length > 0) {
                         path.node.body.unshift(...dedupeImports(imports));
@@ -262,7 +262,7 @@ export default declare((api, options = {}) => {
             },
             TaggedTemplateExpression(path, state) {
                 // `html`...`` and `svg`...`` lower through the same IR and the same
-                // backend as JSX — one pipeline, two authoring syntaxes.
+                // backend as JSX: one pipeline, two authoring syntaxes.
                 if (compileLit &&
                     t.isIdentifier(path.node.tag) &&
                     (path.node.tag.name === litTag || path.node.tag.name === 'svg')) {
@@ -278,14 +278,14 @@ export default declare((api, options = {}) => {
 /**
  * Two usages of one component in the same file share a binding, so their strategies
  * have to agree. The earlier-loading one wins: the module is in whichever chunk loads
- * first regardless, so deferring the other buys nothing — the same reasoning as the
+ * first regardless, so deferring the other buys nothing, the same reasoning as the
  * collapse pass, applied within a file.
  */
 /**
  * What to do with JSX or a template found inside an expression: resolve its
  * component references and record what the module needs, exactly as the
  * top-level node gets. The IR itself is emitted and dropped by the walk, so
- * anything not taken off it here is lost — which is how `{(b) => <Input/>}`
+ * anything not taken off it here is lost: which is how `{(b) => <Input/>}`
  * came out referring to a component nothing imported.
  */
 function nestedHook(state) {
@@ -338,7 +338,7 @@ function adoptTemplates(code, templates, state) {
     }
     // One pass, not one replacement per id. The backend's local ids and the hoisted names
     // share the `_tmpl$N` namespace, so replacing them in sequence can rewrite a name that
-    // an earlier replacement just produced — which silently points a template at another
+    // an earlier replacement just produced: which silently points a template at another
     // template's HTML.
     return code.replace(/_tmpl\$\d+/g, (id) => rename.get(id) ?? id);
 }
@@ -348,7 +348,7 @@ function emitViaIR(node, state) {
     const used = new Set();
     const ir = buildIR(node, used, nestedHook(state));
     // The same passes the lit path runs. Without them `codegen: 'ir'` silently skipped
-    // resolution entirely — a resolved tag compiled to a reference with no import.
+    // resolution entirely: a resolved tag compiled to a reference with no import.
     resolveComponentSources(ir, {
         resolver: state.componentResolver,
         modules: {
@@ -402,7 +402,7 @@ function dedupeImports(imports) {
 }
 /**
  * Lit-pipeline path: build IR from a `` html`...` `` template, emit through the
- * imperative backend, reparse. Mirrors emitViaIR — the whole point is that lit
+ * imperative backend, reparse. Mirrors emitViaIR, the whole point is that lit
  * and JSX share one IR + one backend. Collects runtime imports and the delegated
  * events used so Program.exit wires them.
  */
@@ -411,7 +411,7 @@ function emitLitViaIR(node, state) {
     const svg = t.isIdentifier(node.tag) && node.tag.name === 'svg';
     const ir = buildIRFromLit(node, used, { svg, onNested: nestedHook(state) });
     // Resolve pass: annotate each component reference with where it comes from, before
-    // codegen. Bindings are not checked here — Program.exit knows the whole file's scope
+    // codegen. Bindings are not checked here: Program.exit knows the whole file's scope
     // and drops any injected import whose name turns out to be bound.
     resolveComponentSources(ir, {
         resolver: state.componentResolver,
@@ -434,7 +434,7 @@ function emitLitViaIR(node, state) {
     collectRuntimeNeeds(ir, state);
     state.hasLitIR = true;
     // The IR is emitted as a string and reparsed, so the resulting nodes carry no
-    // position — which is why compiled html`` had no source map at all. Give every
+    // position: which is why compiled html`` had no source map at all. Give every
     // generated node the template's own location so a breakpoint or stack frame
     // lands on the template instead of nowhere.
     const expression = template.expression(adoptTemplates(code, templates, state), {
@@ -487,7 +487,7 @@ function collectRuntimeNeeds(node, state) {
     if (node.kind === 'component' && node.source) {
         // Provenance was decided by the resolve pass and recorded on the node; this only
         // translates it into the two things Program.exit wires. Reading it here rather
-        // than re-resolving is the point — one decision, so import injection and every
+        // than re-resolving is the point: one decision, so import injection and every
         // later pass cannot disagree.
         if (node.source.origin === 'builtin') {
             state.controlFlowComponents.add(node.name);