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

package/dist/lower/compile-template.d.cts

@@ -0,0 +1,69 @@
+import { type ComponentResolverRule } from '../resolve/component-resolver.cjs';
+import type { IRNode } from '../ir/nodes.cjs';
+import { type TemplateHole } from './template.cjs';
+export type { TemplateHole };
+import type { Piece } from '@fluixi/template-parser';
+import type { StaticTemplate } from '../codegen/backend.cjs';
+export interface TemplateSource {
+    /**
+     * The static text runs, in order. Always one more than `holes`, the text
+     * before the first `${`, between each pair, and after the last `}`.
+     */
+    statics: readonly string[];
+    /** One descriptor per `${…}`, in source order. */
+    holes: readonly TemplateHole[];
+}
+export interface CompileTemplateOptions {
+    /** An `` svg`...` `` root, which changes how the parser namespaces tags. */
+    svg?: boolean;
+    /** Clone static subtrees from a template instead of building them element by element. */
+    templateClone?: boolean;
+    /** Also clone subtrees whose structure is static but which contain holes. */
+    partialTemplates?: boolean;
+    /** Rules that resolve an unbound capitalised tag to a module. */
+    resolve?: readonly ComponentResolverRule[];
+    /** Where control-flow components are imported from. @default '@fluixi/dom' */
+    controlFlowModule?: string;
+    /** Where core-only components (Suspense, Portal) come from. @default '@fluixi/core' */
+    coreModule?: string;
+    /** Where router components come from. @default '@fluixi/core/router' */
+    routerModule?: string;
+    /**
+     * Leave static templates as `_tmpl$N` references and hand them back, for a
+     * caller that has a module scope to declare them in. Off inlines them.
+     */
+    hoistTemplates?: boolean;
+    /**
+     * The author's file, and a way to turn the parser's offsets into positions in it.
+     *
+     * Only when the host asked for source locations. Together they let a tag written inside a
+     * template carry the same mark a JSX tag does: without it the nodes it makes are the only
+     * ones in a component with no mark of their own, and they take whichever one was left.
+     */
+    sourceFile?: string;
+    positionAt?: (offset: number) => {
+        line: number;
+        column: number;
+    };
+}
+export interface CompileTemplateResult {
+    /** A JavaScript expression that builds the DOM when evaluated. */
+    code: string;
+    /** Runtime symbols the code refers to, for the caller to import. */
+    imports: string[];
+    /** The IR it was emitted from, for a caller that wants to inspect or transform it. */
+    ir: IRNode;
+    /**
+     * Static templates the code refers to by local `_tmpl$N` id, when the caller
+     * asked to hoist them. `compileTemplate` inlines them instead, it has no module
+     * scope to hoist into.
+     */
+    templates?: StaticTemplate[];
+}
+export declare function compileTemplate(source: TemplateSource, options?: CompileTemplateOptions): CompileTemplateResult;
+/**
+ * Same pipeline entered with pieces that already carry real source offsets, so a
+ * caller reading a file keeps its positions instead of the synthetic ones derived
+ * from the static runs.
+ */
+export declare function compilePieces(pieces: Piece[], holes: readonly TemplateHole[], options?: CompileTemplateOptions): CompileTemplateResult;

package/dist/lower/compile-template.d.ts

@@ -6,7 +6,7 @@ import type { Piece } from '@fluixi/template-parser';
 import type { StaticTemplate } from '../codegen/backend.js';
 export interface TemplateSource {
     /**
-     * The static text runs, in order. Always one more than `holes` — the text
+     * The static text runs, in order. Always one more than `holes`, the text
      * before the first `${`, between each pair, and after the last `}`.
      */
     statics: readonly string[];
@@ -37,7 +37,7 @@ export interface CompileTemplateOptions {
      * The author's file, and a way to turn the parser's offsets into positions in it.
      *
      * Only when the host asked for source locations. Together they let a tag written inside a
-     * template carry the same mark a JSX tag does — without it the nodes it makes are the only
+     * template carry the same mark a JSX tag does: without it the nodes it makes are the only
      * ones in a component with no mark of their own, and they take whichever one was left.
      */
     sourceFile?: string;
@@ -55,7 +55,7 @@ export interface CompileTemplateResult {
     ir: IRNode;
     /**
      * Static templates the code refers to by local `_tmpl$N` id, when the caller
-     * asked to hoist them. `compileTemplate` inlines them instead — it has no module
+     * asked to hoist them. `compileTemplate` inlines them instead, it has no module
      * scope to hoist into.
      */
     templates?: StaticTemplate[];

package/dist/lower/compile-template.js

@@ -6,7 +6,7 @@
  *
  * Finding templates in a module and describing each hole still needs a front-end;
  * everything after that point is here. Passes run in the same order as
- * `emitLitViaIR` — compile-template.spec.ts compares the two.
+ * `emitLitViaIR`: compile-template.spec.ts compares the two.
  */
 import { analyzeStatic } from '../optimize/analyze-static.js';
 import { collapseStrategies } from '../optimize/collapse-strategies.js';