@fluixi/compiler 1.0.0-alpha.100

package/dist/frontend/babel/lower-template.d.cts

@@ -0,0 +1,23 @@
+/**
+ * Babel adapter for `` html`...` `` templates.
+ *
+ * The lowering itself is in ../../lower/template.ts and takes no Babel. What is
+ * left here is the part that genuinely needs to read JavaScript: turning each
+ * `${…}` into a `TemplateHole`: its source text, whether it is reactive, and
+ * the two structural facts the lowering branches on (a single-expression arrow,
+ * an object literal).
+ *
+ * Nested JSX and nested `` html`` `` inside a hole are compiled here too, by
+ * `genExpr`, so the code the lowering receives is already plain JavaScript.
+ */
+import { types as t } from '@babel/core';
+import type { IRNode } from '../../ir/nodes.cjs';
+import { type NestedHook } from './build-ir.cjs';
+/**
+ * Build IR from a lit `` html`...` `` / `` svg`...` `` TaggedTemplateExpression.
+ * `used` collects runtime symbols emitted for anything nested inside a hole.
+ */
+export declare function lowerLitTemplate(node: t.TaggedTemplateExpression, used: Set<string>, opts?: {
+    svg?: boolean;
+    onNested?: NestedHook;
+}): IRNode;

package/dist/frontend/babel/lower-template.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Babel adapter for `` html`...` `` templates.
+ *
+ * The lowering itself is in ../../lower/template.ts and takes no Babel. What is
+ * left here is the part that genuinely needs to read JavaScript: turning each
+ * `${…}` into a `TemplateHole`: its source text, whether it is reactive, and
+ * the two structural facts the lowering branches on (a single-expression arrow,
+ * an object literal).
+ *
+ * Nested JSX and nested `` html`` `` inside a hole are compiled here too, by
+ * `genExpr`, so the code the lowering receives is already plain JavaScript.
+ */
+import { types as t } from '@babel/core';
+import type { IRNode } from '../../ir/nodes.js';
+import { type NestedHook } from './build-ir.js';
+/**
+ * Build IR from a lit `` html`...` `` / `` svg`...` `` TaggedTemplateExpression.
+ * `used` collects runtime symbols emitted for anything nested inside a hole.
+ */
+export declare function lowerLitTemplate(node: t.TaggedTemplateExpression, used: Set<string>, opts?: {
+    svg?: boolean;
+    onNested?: NestedHook;
+}): IRNode;
+//# sourceMappingURL=lower-template.d.ts.map

package/dist/frontend/babel/lower-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower-template.d.ts","sourceRoot":"","sources":["../../../src/frontend/babel/lower-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,KAAK,IAAI,CAAC,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAA2B,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAgCzE;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,CAAC,CAAC,wBAAwB,EAChC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,EACjB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAO,GAClD,MAAM,CAIR"}

package/dist/frontend/babel/lower-template.js

@@ -0,0 +1,64 @@
+/**
+ * Babel adapter for `` html`...` `` templates.
+ *
+ * The lowering itself is in ../../lower/template.ts and takes no Babel. What is
+ * left here is the part that genuinely needs to read JavaScript: turning each
+ * `${…}` into a `TemplateHole`: its source text, whether it is reactive, and
+ * the two structural facts the lowering branches on (a single-expression arrow,
+ * an object literal).
+ *
+ * Nested JSX and nested `` html`` `` inside a hole are compiled here too, by
+ * `genExpr`, so the code the lowering receives is already plain JavaScript.
+ */
+import { types as t } from '@babel/core';
+import _generate from '@babel/generator';
+import { lowerTemplate } from '../../lower/template.js';
+import { genExpr, isReactiveExpr } from './build-ir.js';
+const generate = _generate.default ?? _generate;
+function gen(node) {
+    return generate(node, { concise: true }).code;
+}
+/** Describe one `${…}` for the lowering. */
+function bindHole(expr, used, onNested) {
+    const hole = {
+        code: genExpr(expr, used, onNested),
+        reactive: isReactiveExpr(expr),
+    };
+    // `${item => <li>${item}</li>}`: `each` lowers this into For's render
+    // function, which needs the parameters and the body apart from each other. A
+    // block body is not a render expression, so it stays an ordinary hole.
+    if (t.isArrowFunctionExpression(expr) && !t.isBlockStatement(expr.body)) {
+        const body = expr.body;
+        hole.arrow = {
+            params: expr.params.map((p) => gen(p)),
+            body: genExpr(body, used, onNested),
+            bodyReactive: isReactiveExpr(body),
+        };
+    }
+    // `class=${{ active: on() }}` lowers to classList rather than className.
+    if (t.isObjectExpression(expr))
+        hole.object = true;
+    return hole;
+}
+/**
+ * Build IR from a lit `` html`...` `` / `` svg`...` `` TaggedTemplateExpression.
+ * `used` collects runtime symbols emitted for anything nested inside a hole.
+ */
+export function lowerLitTemplate(node, used, opts = {}) {
+    const quasi = node.quasi;
+    const holes = quasi.expressions.map((e) => bindHole(e, used, opts.onNested));
+    return lowerTemplate(buildPieces(quasi), holes, used, opts);
+}
+/** Turn a Babel TemplateLiteral into position-carrying parser pieces. */
+function buildPieces(quasi) {
+    const pieces = [];
+    quasi.quasis.forEach((q, i) => {
+        const text = q.value.cooked ?? q.value.raw;
+        pieces.push({ kind: 'static', text, start: q.start ?? 0 });
+        if (i < quasi.expressions.length) {
+            const e = quasi.expressions[i];
+            pieces.push({ kind: 'hole', index: i, start: e.start ?? 0, end: e.end ?? 0 });
+        }
+    });
+    return pieces;
+}