@fluixi/compiler 1.0.0-alpha.82 → 1.0.0-alpha.84

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;