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

package/dist/frontend/babel/build-ir.d.cts

@@ -0,0 +1,35 @@
+/**
+ * Babel front-end: build the host-agnostic IR from a JSX AST node.
+ *
+ * This is the parsing-end half of the pipeline (AST -> IR); the imperative
+ * backend's emit() is the codegen half (IR -> code). Keeping the JSX analysis
+ * here and the code generation in the backend is what lets a future swc
+ * front-end reuse the exact same backend.
+ *
+ * JSX can appear nested inside arbitrary expressions (render-props, ternaries,
+ * `fallback={<p/>}`, `arr.map(x => <li/>)`, `() => cond && <div/>`, …). The IR
+ * models prop/child *expressions* as code strings, so any JSX inside such an
+ * expression is recursively compiled (build-ir -> emit) and spliced back in,
+ * with the runtime symbols it uses collected into `used` for import injection.
+ */
+import { types as t } from '@babel/core';
+import type { IRNode } from '../../ir/nodes.cjs';
+/** Stringify an expression, compiling any JSX nested inside it first. */
+export declare function genExpr(node: t.Expression, used: Set<string>, onNested?: NestedHook): string;
+/**
+ * Called with the IR of JSX (or a template) found inside an expression.
+ *
+ * That IR is compiled and thrown away during the walk, so anything the module
+ * needs because of it: a component import, a delegated event, has to be taken
+ * off it here or it is lost. Without this, `{(b) => <Input/>}` emitted a
+ * reference to `Input` that nothing imported.
+ */
+export type NestedHook = (ir: IRNode) => void;
+export declare const SVG_TAGS: Set<string>;
+export declare function isReactiveExpr(node: t.Expression): boolean;
+/**
+ * Build IR from a JSX node. The builder is shared (lower/jsx.ts); what this
+ * front-end supplies is how an expression becomes source, `genExpr`, which also
+ * compiles any JSX or `` html`` `` nested inside it.
+ */
+export declare function buildIR(node: t.JSXElement | t.JSXFragment, used?: Set<string>, onNested?: NestedHook): IRNode;

package/dist/frontend/babel/build-ir.d.ts

@@ -20,7 +20,7 @@ export declare function genExpr(node: t.Expression, used: Set<string>, onNested?
  * Called with the IR of JSX (or a template) found inside an expression.
  *
  * That IR is compiled and thrown away during the walk, so anything the module
- * needs because of it — a component import, a delegated event — has to be taken
+ * needs because of it: a component import, a delegated event, has to be taken
  * off it here or it is lost. Without this, `{(b) => <Input/>}` emitted a
  * reference to `Input` that nothing imported.
  */
@@ -29,7 +29,7 @@ export declare const SVG_TAGS: Set<string>;
 export declare function isReactiveExpr(node: t.Expression): boolean;
 /**
  * Build IR from a JSX node. The builder is shared (lower/jsx.ts); what this
- * front-end supplies is how an expression becomes source — `genExpr`, which also
+ * front-end supplies is how an expression becomes source, `genExpr`, which also
  * compiles any JSX or `` html`` `` nested inside it.
  */
 export declare function buildIR(node: t.JSXElement | t.JSXFragment, used?: Set<string>, onNested?: NestedHook): IRNode;

package/dist/frontend/babel/build-ir.js

@@ -107,14 +107,14 @@ export function isReactiveExpr(node) {
 }
 /**
  * Build IR from a JSX node. The builder is shared (lower/jsx.ts); what this
- * front-end supplies is how an expression becomes source — `genExpr`, which also
+ * front-end supplies is how an expression becomes source, `genExpr`, which also
  * compiles any JSX or `` html`` `` nested inside it.
  */
 export function buildIR(node, used = new Set(), onNested) {
     const ir = buildJsxIR(node, {
         code: (n) => 
         // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
-        // through the nested-JSX compile — it only ever needs printing.
+        // through the nested-JSX compile: it only ever needs printing.
         n.type === 'JSXMemberExpression'
             ? gen(n)
             : genExpr(n, used, onNested),