@barefootjs/go-template 0.16.0 → 0.17.1

package/dist/adapter/analysis/component-tree.d.ts

@@ -0,0 +1,23 @@
+/**
+ * IR component-tree analysis for the Go html/template adapter.
+ *
+ * Pure structural walks over the IR — no adapter instance state, no rendering.
+ * Only the two entry points (`hasClientInteractivity`,
+ * `findNestedComponents`) are exported; the recursive collectors stay
+ * module-internal.
+ */
+import type { ComponentIR, IRNode } from '@barefootjs/jsx';
+import type { NestedComponentInfo } from '../lib/types.ts';
+/**
+ * Does the component need client JS? True when it has reactive state
+ * (signals), effects, onMounts, any event handler in the tree, or any
+ * child component (which needs the parent's hydration).
+ */
+export declare function hasClientInteractivity(ir: ComponentIR): boolean;
+/**
+ * Find all nested components (loops with `childComponent`). Returns extended
+ * info that includes whether the component comes from a dynamic (signal) array
+ * loop vs a static one.
+ */
+export declare function findNestedComponents(node: IRNode): NestedComponentInfo[];
+//# sourceMappingURL=component-tree.d.ts.map

package/dist/adapter/analysis/component-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-tree.d.ts","sourceRoot":"","sources":["../../../src/adapter/analysis/component-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,MAAM,EAOP,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAQ/D;AAyED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAIxE"}

package/dist/adapter/emit-context.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The contract extracted emit modules depend on instead of the concrete
+ * `GoTemplateAdapter`.
+ *
+ * The Go adapter's lowering is deeply mutually recursive (expression ↔
+ * condition ↔ rendering), so a module pulled out still needs to call back into
+ * the shared per-compile state and the recursive entry points. `GoEmitContext`
+ * is that seam: extracted free functions take it as their first argument, and
+ * the adapter — which owns the state and implements the entry points — passes
+ * `this`. Modules depend on this narrow interface, so they stay unit-testable
+ * against a stub.
+ *
+ * Keep this surface minimal: add a member only when an extracted module
+ * genuinely needs it, so the seam documents the real cross-module coupling.
+ */
+import type { ParsedExpr } from '@barefootjs/jsx';
+import type { CompileState } from './lib/compile-state.ts';
+export interface GoEmitContext {
+    /** Per-compile mutable state (signals, consts, type tables, errors, …). */
+    readonly state: CompileState;
+    /**
+     * Lower a JS expression to its Go-template form (the core recursive entry).
+     * `preParsed` reuses an already-built tree instead of re-parsing `jsExpr`.
+     */
+    convertExpressionToGo(jsExpr: string, out?: {
+        parsed?: ParsedExpr;
+    }, preParsed?: ParsedExpr): string;
+    /**
+     * Lower a JS condition to a Go-template bool + any hoisted preamble.
+     * `preParsed` reuses an already-built tree instead of re-parsing `jsCondition`.
+     */
+    convertConditionToGo(jsCondition: string, preParsed?: ParsedExpr): {
+        condition: string;
+        preamble: string;
+    };
+    /** Extract the prop name from a `props.X ?? …` initial value, or null. */
+    extractPropNameFromInitialValue(initialValue: string): string | null;
+    /**
+     * Parse a signal-time initial value `props.X ?? <literal>` into the source
+     * prop name and the Go-formatted fallback, or null when it isn't that shape.
+     */
+    extractPropFallback(initialValue: string): {
+        propName: string;
+        goFallback: string;
+    } | null;
+    /**
+     * Inline a module string const by name as a Go double-quoted literal
+     * (`"<escaped>"`), or null when the name is not such a const (loop vars and
+     * outer-loop params are excluded).
+     */
+    resolveModuleStringConst(name: string): string | null;
+}
+//# sourceMappingURL=emit-context.d.ts.map

package/dist/adapter/emit-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-context.d.ts","sourceRoot":"","sources":["../../src/adapter/emit-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAE1D,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAE5B;;;OAGG;IACH,qBAAqB,CACnB,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,UAAU,CAAA;KAAE,EAC7B,SAAS,CAAC,EAAE,UAAU,GACrB,MAAM,CAAA;IAET;;;OAGG;IACH,oBAAoB,CAClB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,UAAU,GACrB;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAE1C,0EAA0E;IAC1E,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAEpE;;;OAGG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAE1F;;;;OAIG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CACtD"}

package/dist/adapter/expr/helper-inline.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Inlining of component-scope arrow-const helpers at a call site.
+ *
+ * When a JSX expression calls a local `const f = (a) => …` helper, the Go
+ * adapter has no function to emit — it inlines the helper body with the call
+ * args substituted for the params, so the result lowers like any inline
+ * expression. The substitution is scope-blind, so the guards here reject bodies
+ * where a param replacement could be wrong.
+ */
+import { type ParsedExpr } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+/**
+ * Inline a call to a local arrow-const helper.
+ *
+ * @param callParsed the call's already-built `ParsedExpr`. Must be a `call`
+ *   node; inlining is declined without it.
+ * @returns the substituted body tree, or null when the expression isn't such a
+ *   call or the body isn't substitution-safe (nested functions, helper-calling
+ *   helpers, spread args, …)
+ */
+export declare function inlineLocalHelperCall(ctx: GoEmitContext, jsExpr: string, callParsed?: ParsedExpr): ParsedExpr | null;
+/**
+ * Re-build `body` with each identifier named in `subs` replaced by the
+ * substitution's `ParsedExpr` subtree. The substitution is the arg subtree
+ * itself, so operator precedence survives without parenthesisation (the tree
+ * *is* the precedence). Non-value identifier positions — the property NAME in
+ * `a.b`, a plain `{ k: … }` key — are not visited, so a param sharing a name
+ * with a member or key is left untouched.
+ */
+export declare function substituteHelperParams(body: ParsedExpr, subs: ReadonlyMap<string, ParsedExpr>): ParsedExpr;
+//# sourceMappingURL=helper-inline.d.ts.map

package/dist/adapter/expr/helper-inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper-inline.d.ts","sourceRoot":"","sources":["../../../src/adapter/expr/helper-inline.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,aAAa,EAClB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,UAAU,GAAG,IAAI,CA6CnB;AAmFD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GACpC,UAAU,CAqDZ"}

package/dist/adapter/expr/url-builder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Go lowering of helper calls to template expressions. Renders backend-neutral
+ * `LoweringNode`s produced by registered lowering plugins (#2057) — one uniform
+ * path for both userland plugins and built-ins like `queryHref` (a default plugin
+ * that lowers to `bf_query`, #2042). Every node funnels through
+ * `renderLoweringNode`, which maps a logical helper id to its Go helper; the
+ * adapter carries no per-API recognition branch of its own.
+ */
+import { type ParsedExpr } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+/**
+ * Lower a helper call to a Go template expression, or null when no registered
+ * plugin recognises it (→ the generic lowering). Matchers — including the
+ * built-in `queryHref` plugin (#2042) — are bound to the component metadata at
+ * init (`ctx.state.loweringMatchers`), so this is one uniform loop with no
+ * per-API branch.
+ *
+ * Cheap-out: no active matchers → null; else reuse `preParsed` when it's already
+ * a call, otherwise a regex pre-filter gates the parse so non-call expressions
+ * never pay for `parseExpression`.
+ */
+export declare function lowerRegisteredCall(ctx: GoEmitContext, jsExpr: string, preParsed?: ParsedExpr): string | null;
+//# sourceMappingURL=url-builder.d.ts.map

package/dist/adapter/expr/url-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-builder.d.ts","sourceRoot":"","sources":["../../../src/adapter/expr/url-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAwCvD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,aAAa,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,UAAU,GACrB,MAAM,GAAG,IAAI,CAmBf"}