marko 5.37.0 → 6.0.0-3.4

package/dist/translator/util/assert.d.ts

@@ -0,0 +1,3 @@
+import type { types as t } from "@marko/compiler";
+export declare function assertNoSpreadAttrs(tag: t.NodePath<t.MarkoTag>): void;
+export declare function assertNoBodyContent(tag: t.NodePath<t.MarkoTag>): void;

package/dist/translator/util/binding-has-downstream-expressions.d.ts

@@ -0,0 +1,2 @@
+import type { Binding } from "./references";
+export declare function bindingHasDownstreamExpressions(binding: Binding): boolean;

package/dist/translator/util/entry-builder.d.ts

@@ -0,0 +1,19 @@
+import { types as t } from "@marko/compiler";
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        isInteractive?: boolean;
+        hasInteractiveChild?: boolean;
+    }
+}
+type EntryFile = t.BabelFile & {
+    [kState]?: {
+        imports: string[];
+        init: boolean;
+    };
+};
+declare const kState: unique symbol;
+declare const _default: {
+    build(entryFile: EntryFile): t.Statement[];
+    visit(file: t.BabelFile, entryFile: EntryFile, visitChild: (id: string) => void): void;
+};
+export default _default;

package/dist/translator/util/evaluate.d.ts

@@ -0,0 +1,11 @@
+import type { types as t } from "@marko/compiler";
+declare module "@marko/compiler/dist/types" {
+    interface NodeExtra {
+        confident?: boolean;
+        computed?: unknown;
+    }
+}
+export default function evaluate(value: t.Expression): (t.NodeExtra | (t.ArrowFunctionExpressionExtra & t.NodeExtra) | (t.FunctionExpressionExtra & t.NodeExtra)) & {
+    confident: boolean;
+    computed: unknown;
+};

package/dist/translator/util/for-each-identifier.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export declare function forEachIdentifier(node: t.Node, cb: (identifier: t.Identifier) => void): void;

package/dist/translator/util/get-defined-binding-expression.d.ts

@@ -0,0 +1,3 @@
+import { types as t } from "@marko/compiler";
+import type { Binding } from "./references";
+export declare function getDeclaredBindingExpression(binding: Binding): t.Identifier | t.OptionalMemberExpression | t.MemberExpression;

package/dist/translator/util/get-known-attr-values.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export declare function getKnownAttrValues(tag: t.MarkoTag): Record<string, t.Expression>;

package/dist/translator/util/get-parent-tag.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export declare function getParentTag(tag: t.NodePath<t.MarkoTag>): t.NodePath<t.MarkoTag> | undefined;

package/dist/translator/util/get-root.d.ts

@@ -0,0 +1,7 @@
+import type { types as t } from "@marko/compiler";
+type MarkoExprRootPath = t.NodePath<t.MarkoTag | t.MarkoTagBody | t.MarkoAttribute | t.MarkoSpreadAttribute | t.MarkoScriptlet | t.MarkoPlaceholder>;
+export declare function getMarkoRoot(path: t.NodePath<t.Node>): MarkoExprRootPath | null;
+export declare function getExprRoot(path: t.NodePath<t.Node>): t.NodePath<t.Node>;
+export declare function getFnRoot(path: t.NodePath<t.Node>): t.NodePath<t.ArrowFunctionExpression | t.FunctionExpression> | undefined;
+export declare function isMarko(path: t.NodePath<any>): path is MarkoExprRootPath;
+export {};

package/dist/translator/util/get-tag-name.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export declare function getTagName<T extends t.MarkoTag>(tag: t.NodePath<T>): T["name"] extends t.StringLiteral ? string : string | undefined;

package/dist/translator/util/is-core-tag.d.ts

@@ -0,0 +1,10 @@
+import type { types as t } from "@marko/compiler";
+export declare function isCoreTag(tag: t.NodePath): tag is t.NodePath<t.MarkoTag & {
+    name: t.StringLiteral;
+}>;
+export declare function isCoreTagName(tag: t.NodePath, name: string): tag is t.NodePath<t.MarkoTag & {
+    name: t.StringLiteral;
+}>;
+export declare function isConditionTag(tag: t.NodePath): tag is t.NodePath<t.MarkoTag & {
+    name: t.StringLiteral;
+}>;

package/dist/translator/util/is-stateful.d.ts

@@ -0,0 +1,3 @@
+import { type Binding, type ReferencedBindings } from "./references";
+export declare function isStatefulReferences(referencedBindings: ReferencedBindings): boolean;
+export declare function isStatefulBinding(binding: Binding): boolean;

package/dist/translator/util/is-static.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export default function isStatic(path: t.NodePath<any>): path is t.NodePath<t.MarkoScriptlet> | t.NodePath<t.ExportDeclaration> | t.NodePath<t.ImportDeclaration>;

package/dist/translator/util/marko-config.d.ts

@@ -0,0 +1,4 @@
+export declare function isOutputHTML(): boolean;
+export declare function isOutputDOM(): boolean;
+export declare function getMarkoOpts(): Required<import("@marko/compiler").Config>;
+export declare function isOptimize(): boolean;

package/dist/translator/util/nested-attribute-tags.d.ts

@@ -0,0 +1,17 @@
+import { types as t } from "@marko/compiler";
+export type AttrTagLookup = Record<string, {
+    name: string;
+    dynamic: boolean;
+    repeated: boolean;
+    group: AttrTagNames;
+}>;
+type AttrTagNames = string[];
+declare module "@marko/compiler/dist/types" {
+    interface MarkoTagExtra {
+        attributeTags?: AttrTagLookup;
+        attributeTagGroup?: AttrTagLookup[string]["group"];
+    }
+}
+export declare function getAttrTagIdentifier(meta: AttrTagLookup[string]): t.Identifier;
+export declare function analyzeAttributeTags(tag: t.NodePath<t.MarkoTag>): AttrTagLookup | undefined;
+export {};

package/dist/translator/util/normalize-string-expression.d.ts

@@ -0,0 +1,3 @@
+import { types as t } from "@marko/compiler";
+export default function normalizeStringExpression(parts: (string | t.Expression)[]): t.Expression | undefined;
+export declare function appendLiteral(arr: unknown[], str: string): void;

package/dist/translator/util/optional.d.ts

@@ -0,0 +1,20 @@
+export type Many<T> = [T, T, ...T[]];
+export type OneMany<T> = T | Many<T>;
+export type Opt<T> = undefined | OneMany<T>;
+export type Compare<T> = (a: T, b: T) => number;
+export declare class Sorted<T> {
+    compare: Compare<T>;
+    constructor(compare: Compare<T>);
+    add(data: Opt<T>, item: T): OneMany<T>;
+    union(a: Opt<T>, b: Opt<T>): Opt<T>;
+    find(data: Opt<T>, item: T): T | undefined;
+}
+export declare function push<T>(data: Opt<T>, item: T): Opt<T>;
+export declare function concat<T>(a: Opt<T>, b: Opt<T>): Opt<T>;
+export declare function size<T>(data: Opt<T>): number;
+export declare function filter<T>(data: Opt<T>, cb: (item: T) => boolean): Opt<T>;
+export declare function forEach<T>(data: Opt<T>, cb: (item: T, index: number) => void): void;
+export declare function find<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): Opt<T>;
+export declare function map<T, R>(data: Opt<T>, cb: (item: T, index: number) => R): R[];
+export declare function findSorted<T>(compare: Compare<T>, data: T[], item: T): T | undefined;
+export declare function addSorted<T>(compare: Compare<T>, data: T[], item: T): T[];

package/dist/translator/util/plugin-hooks.d.ts

@@ -0,0 +1,4 @@
+import { types as t } from "@marko/compiler";
+import type { Plugin } from "@marko/compiler/babel-utils";
+export declare function enter<T extends t.Node>(modulePlugin: Plugin | void, path: t.NodePath<T>): boolean;
+export declare function exit<T extends t.Node>(modulePlugin: Plugin | void, path: t.NodePath<T>): boolean;

package/dist/translator/util/references.d.ts

@@ -0,0 +1,84 @@
+import { types as t } from "@marko/compiler";
+import { type Many, type Opt, Sorted } from "./optional";
+import { type Section } from "./sections";
+export type Aliases = undefined | Binding | {
+    [property: string]: Aliases;
+};
+export declare enum BindingType {
+    dom = 0,
+    let = 1,
+    input = 2,
+    param = 3,
+    derived = 4
+}
+export type Binding = {
+    id: number;
+    name: string;
+    type: BindingType;
+    section: Section;
+    serialize: boolean | Set<Binding>;
+    aliases: Set<Binding>;
+    property: string | undefined;
+    propertyAliases: Map<string, Binding>;
+    excludeProperties: undefined | string[];
+    upstreamAlias: Binding | undefined;
+    upstreamExpression: t.NodeExtra | undefined;
+    downstreamExpressions: Set<ReferencedExtra>;
+    export: string | undefined;
+    declared: boolean;
+    nullable: boolean;
+};
+export type ReferencedBindings = Opt<Binding>;
+export type Intersection = Many<Binding>;
+declare module "@marko/compiler/dist/types" {
+    interface NodeExtra {
+        section?: Section;
+        referencedBindings?: ReferencedBindings;
+        binding?: Binding;
+        assignment?: Binding;
+        read?: {
+            binding: Binding;
+            props: Opt<string>;
+        };
+        pruned?: true;
+        isEffect?: true;
+    }
+    interface FunctionExtra {
+        referencedBindingsInFunction?: ReferencedBindings;
+    }
+    interface ArrowFunctionExpressionExtra extends FunctionExtra {
+    }
+    interface FunctionDeclarationExtra extends FunctionExtra {
+    }
+    interface FunctionExpressionExtra extends FunctionExtra {
+    }
+}
+export declare function createBinding(name: string, type: Binding["type"], section: Section, upstreamAlias?: Binding["upstreamAlias"], upstreamExpression?: Binding["upstreamExpression"], property?: string, declared?: boolean): Binding;
+export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: BindingType, upstreamAlias?: Binding["upstreamAlias"], upstreamExpression?: Binding["upstreamExpression"]): void;
+export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType, upstreamAlias?: Binding["upstreamAlias"], upstreamExpression?: Binding["upstreamExpression"]): void;
+export declare function setReferencesScope(path: t.NodePath<any>): void;
+export declare function mergeReferences(section: Section, target: t.Node, nodes: (t.Node | undefined)[]): void;
+export declare function finalizeReferences(): void;
+export declare function getSourceBindings(binding: Binding): Set<Binding>;
+export declare const bindingUtil: Sorted<Binding>;
+export declare function addReadToExpression(path: t.NodePath, binding: Binding, node?: t.Identifier | t.MemberExpression): ReferencedExtra;
+export declare function dropReferences(node: t.Node | t.Node[]): void;
+export declare function getCanonicalBinding(binding?: Binding): Binding | undefined;
+export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[]): t.Node[];
+export declare function getScopeAccessorLiteral(binding: Binding): t.StringLiteral | t.NumericLiteral;
+export declare function getReadReplacement(node: t.Identifier | t.MemberExpression): t.Node | undefined;
+export interface ReferencedExtra extends t.NodeExtra {
+    section: Section;
+}
+export declare function isReferencedExtra(extra: t.NodeExtra | undefined): extra is ReferencedExtra;
+export interface AssignedBindingExtra extends ReferencedExtra {
+    assignment: Binding;
+}
+export declare function isAssignedBindingExtra(extra: t.NodeExtra | undefined): extra is AssignedBindingExtra;
+export interface RegisteredFnExtra extends ReferencedExtra {
+    registerId: string;
+    name: string | undefined;
+    referencesScope?: boolean;
+    referencedBindingsInFunction: ReferencedBindings;
+}
+export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): extra is RegisteredFnExtra;

package/dist/translator/util/runtime-info.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    name: string;
+    taglibId: string;
+};
+export default _default;

package/dist/translator/util/runtime.d.ts

@@ -0,0 +1,15 @@
+import { types as t } from "@marko/compiler";
+import { attr, classAttr, escapeScript, escapeStyle, escapeXML, styleAttr, toString } from "../../html";
+type Falsy = false | 0 | "" | null | undefined;
+export declare function importRuntime(name: keyof typeof import("../../dom") | keyof typeof import("../../html")): t.MemberExpression;
+export declare function callRuntime(name: keyof typeof import("../../dom") | keyof typeof import("../../html"), ...args: Array<Parameters<typeof t.callExpression>[1][number] | Falsy>): t.CallExpression;
+export declare function getHTMLRuntime(): {
+    escapeXML: typeof escapeXML;
+    toString: typeof toString;
+    attr: typeof attr;
+    classAttr: typeof classAttr;
+    styleAttr: typeof styleAttr;
+    escapeScript: typeof escapeScript;
+    escapeStyle: typeof escapeStyle;
+};
+export {};

package/dist/translator/util/scope-read.d.ts

@@ -0,0 +1,6 @@
+import { types as t } from "@marko/compiler";
+import { type Binding, type ReferencedBindings } from "./references";
+import type { Section } from "./sections";
+export declare function createScopeReadPattern(section: Section, referencedBindings: ReferencedBindings): t.ObjectPattern;
+export declare function getScopeExpression(section: Section, targetSection: Section): t.Identifier | t.MemberExpression;
+export declare function createScopeReadExpression(section: Section, reference: Binding): t.MemberExpression;

package/dist/translator/util/sections.d.ts

@@ -0,0 +1,51 @@
+import { types as t } from "@marko/compiler";
+import type { Binding, ReferencedBindings } from "./references";
+export declare enum ContentType {
+    Comment = 0,
+    Dynamic = 1,
+    Placeholder = 2,
+    Tag = 3,
+    Text = 4
+}
+export interface Section {
+    id: number;
+    name: string;
+    depth: number;
+    parent: Section | undefined;
+    params: undefined | Binding;
+    closures: ReferencedBindings;
+    bindings: ReferencedBindings;
+    upstreamExpression: t.NodeExtra | undefined;
+    hasCleanup: boolean;
+    content: null | {
+        startType: ContentType;
+        endType: ContentType;
+        singleChild: boolean;
+    };
+}
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        section?: Section;
+        sections?: Section[];
+        assignments?: [
+            valueSection: Section,
+            assignment: t.NodePath<t.UpdateExpression> | t.NodePath<t.AssignmentExpression>
+        ][];
+    }
+    interface MarkoTagBodyExtra {
+        section?: Section;
+    }
+}
+export declare function startSection(path: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
+export declare function getOrCreateSection(path: t.NodePath<any>): Section;
+export declare function getSectionForBody(body: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
+export declare function getSection(path: t.NodePath): Section;
+export declare function getParentSection(path: t.NodePath): Section;
+export declare const getScopeIdIdentifier: (section: Section) => t.Identifier;
+export declare const getSectionParentIsOwner: (section: Section) => boolean, setSectionParentIsOwner: (section: Section, value: boolean) => void;
+export declare const getScopeIdentifier: (section: Section, ignoreDefault?: boolean) => t.Identifier;
+export declare function forEachSection(fn: (section: Section) => void): void;
+export declare function forEachSectionReverse(fn: (section: Section) => void): void;
+export declare function getNodeContentType(path: t.NodePath<t.Statement>, extraMember: "startType" | "endType", contentInfo?: Section["content"]): ContentType | null;
+export declare const isStatefulSection: (section: Section) => boolean;
+export declare const checkStatefulClosures: (section: Section, immediateOnly: boolean) => boolean;

package/dist/translator/util/signals.d.ts

@@ -0,0 +1,61 @@
+import { types as t } from "@marko/compiler";
+import { type Opt } from "./optional";
+import { type Binding, type ReferencedBindings } from "./references";
+import { type Section } from "./sections";
+export type subscribeBuilder = (subscriber: t.Expression) => t.Expression;
+export type registerScopeBuilder = (scope: t.Expression) => t.Expression;
+export type Signal = {
+    identifier: t.Identifier;
+    valueAccessor?: t.Expression;
+    referencedBindings: ReferencedBindings;
+    section: Section;
+    build: () => t.Expression;
+    register?: boolean;
+    isDynamicClosure?: boolean;
+    values: Array<{
+        signal: {
+            identifier: t.Identifier | t.MemberExpression;
+            hasDownstreamIntersections: () => boolean;
+            buildDeclaration?: () => t.VariableDeclaration;
+            extraArgs?: t.Expression[];
+        };
+        value: t.Expression;
+        scope: t.Expression;
+        intersectionExpression?: t.Expression;
+    }>;
+    intersection: Opt<t.Expression>;
+    render: t.Statement[];
+    renderReferencedBindings: ReferencedBindings;
+    effect: t.Statement[];
+    effectReferencedBindings: ReferencedBindings;
+    closures: Map<Section, Signal>;
+    hasDownstreamIntersections: () => boolean;
+    hasDynamicSubscribers?: true;
+    export: boolean;
+    extraArgs?: t.Expression[];
+    buildAssignment?: (valueSection: Section, value: t.Expression) => t.Expression;
+};
+export declare function setSubscriberBuilder(tag: t.NodePath<t.MarkoTag>, builder: subscribeBuilder): void;
+export declare function setForceResumeScope(section: Section): void;
+export declare const getSerializedScopeProperties: (section: Section) => Map<t.StringLiteral | t.NumericLiteral, t.Expression>;
+export declare function getSignal(section: Section, referencedBindings: ReferencedBindings, name?: string): Signal;
+export declare function initValue(binding: Binding, runtimeHelper?: "value" | "state"): Signal;
+export declare function getSignalFn(signal: Signal, params: Array<t.Identifier | t.Pattern>, referencedBindings?: ReferencedBindings): t.ArrowFunctionExpression;
+export declare function buildSignalIntersections(signal: Signal): t.ArrowFunctionExpression | undefined;
+export declare function getDestructureSignal(bindingIdentifiersByName: Record<string, t.Identifier> | t.Identifier[], destructurePattern: t.LVal): {
+    readonly identifier: t.Identifier;
+    build(canCallOnlyWhenDirty?: boolean): t.ArrowFunctionExpression;
+    hasDownstreamIntersections(): boolean;
+} | undefined;
+export declare function subscribe(provider: ReferencedBindings, subscriber: Signal): void;
+export declare function finalizeSignalArgs(args: t.Expression[]): void;
+export declare function addStatement(type: "render" | "effect", targetSection: Section, referencedBindings: ReferencedBindings, statement: t.Statement | t.Statement[], usedReferences?: ReferencedBindings[] | false): void;
+export declare function addValue(targetSection: Section, referencedBindings: ReferencedBindings, signal: Signal["values"][number]["signal"], value: t.Expression, scope?: t.Expression, intersectionExpression?: t.Expression): void;
+export declare function getResumeRegisterId(section: Section, referencedBindings: string | ReferencedBindings, type?: string): string;
+export declare function getRegisterUID(section: Section, name: string): string;
+export declare function writeSignals(section: Section): void;
+export declare function writeRegisteredFns(): void;
+export declare function addHTMLEffectCall(section: Section, referencedBindings?: ReferencedBindings): void;
+export declare function writeHTMLResumeStatements(path: t.NodePath<t.MarkoTagBody | t.Program>, tagVarIdentifier?: t.Identifier): void;
+export declare function getSetup(section: Section): t.Identifier | undefined;
+export declare function replaceRegisteredFunctionNode(node: t.Node): t.CallExpression | t.ClassPrivateProperty | t.ClassProperty | t.VariableDeclaration | t.Identifier | t.ObjectProperty | undefined;

package/dist/translator/util/simplify-fn.d.ts

@@ -0,0 +1,5 @@
+import { types as t } from "@marko/compiler";
+/**
+ * Given any arbitrary function type will normalize method like functions into expressions.
+ */
+export declare function simplifyFunction(fn: t.Function): t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression;

package/dist/translator/util/state.d.ts

@@ -0,0 +1,3 @@
+import type { Section } from "./sections";
+export declare const createProgramState: <T>(init: () => T) => readonly [() => T, (value: T) => void];
+export declare function createSectionState<T = unknown>(key: string, init?: ((section: Section) => T) | (() => T)): readonly [(section: Section) => T, (section: Section, value: T) => void];

package/dist/translator/util/tag-name-type.d.ts

@@ -0,0 +1,16 @@
+import { types as t } from "@marko/compiler";
+declare module "@marko/compiler/dist/types" {
+    interface MarkoTagExtra {
+        tagNameType?: TagNameType;
+        tagNameNullable?: boolean;
+        tagNameDynamic?: boolean;
+        tagNameImported?: string;
+    }
+}
+export declare enum TagNameType {
+    NativeTag = 0,
+    CustomTag = 1,
+    DynamicTag = 2,
+    AttributeTag = 3
+}
+export default function analyzeTagNameType(tag: t.NodePath<t.MarkoTag>): TagNameType;

package/dist/translator/util/to-first-expression-or-block.d.ts

@@ -0,0 +1,3 @@
+import { types as t } from "@marko/compiler";
+export declare function toFirstExpressionOrBlock(stmts: t.Statement[]): t.ArrayExpression | t.ArrowFunctionExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.LogicalExpression | t.BindExpression | t.BlockStatement | t.FunctionExpression | t.BooleanLiteral | t.CallExpression | t.ClassExpression | t.ConditionalExpression | t.DecimalLiteral | t.DoExpression | t.Identifier | t.StringLiteral | t.NumericLiteral | t.NullLiteral | t.RegExpLiteral | t.MemberExpression | t.NewExpression | t.SequenceExpression | t.ParenthesizedExpression | t.ThisExpression | t.UnaryExpression | t.UpdateExpression | t.ImportExpression | t.MetaProperty | t.Super | t.TaggedTemplateExpression | t.TemplateLiteral | t.YieldExpression | t.Import | t.OptionalMemberExpression | t.OptionalCallExpression | t.TypeCastExpression | t.JSXElement | t.JSXFragment | t.RecordExpression | t.TupleExpression | t.ModuleExpression | t.TopicReference | t.PipelineTopicExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.TSInstantiationExpression | t.TSAsExpression | t.TSSatisfiesExpression | t.TSTypeAssertion | t.TSNonNullExpression | t.MarkoParseError;
+export declare function toParenthesizedExpressionIfNeeded(expr: t.Expression): t.ArrayExpression | t.ArrowFunctionExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.LogicalExpression | t.BindExpression | t.FunctionExpression | t.BooleanLiteral | t.CallExpression | t.ClassExpression | t.ConditionalExpression | t.DecimalLiteral | t.DoExpression | t.Identifier | t.StringLiteral | t.NumericLiteral | t.NullLiteral | t.RegExpLiteral | t.MemberExpression | t.NewExpression | t.SequenceExpression | t.ParenthesizedExpression | t.ThisExpression | t.UnaryExpression | t.UpdateExpression | t.ImportExpression | t.MetaProperty | t.Super | t.TaggedTemplateExpression | t.TemplateLiteral | t.YieldExpression | t.Import | t.OptionalMemberExpression | t.OptionalCallExpression | t.TypeCastExpression | t.JSXElement | t.JSXFragment | t.RecordExpression | t.TupleExpression | t.ModuleExpression | t.TopicReference | t.PipelineTopicExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.TSInstantiationExpression | t.TSAsExpression | t.TSSatisfiesExpression | t.TSTypeAssertion | t.TSNonNullExpression | t.MarkoParseError;

package/dist/translator/util/to-first-statement-or-block.d.ts

@@ -0,0 +1,2 @@
+import { types as t } from "@marko/compiler";
+export default function toFirstStatementOrBlock(body: t.BlockStatement | t.Statement[]): t.Statement;

package/dist/translator/util/to-property-name.d.ts

@@ -0,0 +1,7 @@
+import { types as t } from "@marko/compiler";
+export declare function toPropertyName(name: string): t.Identifier | t.StringLiteral | t.NumericLiteral;
+export declare function toObjectProperty(name: string, value: t.Expression): t.ObjectProperty;
+export declare function toMemberExpression(object: t.Expression, key: string): t.MemberExpression;
+export declare function toMemberExpression(object: t.Expression, key: string, optional: false | undefined): t.MemberExpression;
+export declare function toMemberExpression(object: t.Expression, key: string, optional: true): t.OptionalMemberExpression;
+export declare function toMemberExpression(object: t.Expression, key: string, optional?: boolean): t.MemberExpression | t.OptionalMemberExpression;

package/dist/translator/util/translate-attrs.d.ts

@@ -0,0 +1,12 @@
+import { types as t } from "@marko/compiler";
+import { type TemplateExports } from "../visitors/program";
+import { type AttrTagLookup } from "./nested-attribute-tags";
+export declare function translateAttrs(tag: t.NodePath<t.MarkoTag>, templateExports?: TemplateExports, statements?: t.Statement[]): {
+    properties: (t.ObjectMethod | t.ObjectProperty | t.SpreadElement)[];
+    statements: t.Statement[];
+};
+export declare function getTranslatedRenderBodyProperty(props: t.ObjectExpression["properties"]): (t.ObjectProperty & {
+    value: t.Expression;
+}) | undefined;
+export declare function addDynamicAttrTagStatements(attrTags: t.NodePath<t.MarkoTag["attributeTags"][number]>[], index: number, attrTagLookup: AttrTagLookup, statements: t.Statement[], templateExports: TemplateExports): number;
+export declare function propsToExpression(props: t.ObjectExpression["properties"]): t.Expression;

package/dist/translator/util/translate-var.d.ts

@@ -0,0 +1,2 @@
+import { types as t } from "@marko/compiler";
+export default function translateVar(tag: t.NodePath<t.MarkoTag>, initialValue: t.Expression, kind?: "let" | "const"): void;

package/dist/translator/util/traverse.d.ts

@@ -0,0 +1,9 @@
+import { types as t } from "@marko/compiler";
+export declare const skip: unique symbol;
+type VisitValue = null | void | t.Node | t.Node[];
+type VisitKeys<T> = (string | number) & (T extends T ? {
+    [K in keyof T]: T[K] extends VisitValue ? K : never;
+}[keyof T] : never);
+export declare function traverseReplace<T, K extends VisitKeys<T>>(container: T, key: K, enter: (node: t.Node, container: t.Node | t.Node[], key: string | number) => t.Node | void): void;
+export declare function traverseContains(node: undefined | null | t.Node | t.Node[], check: (node: t.Node) => void | boolean | typeof skip): boolean;
+export {};

package/dist/translator/util/visitors.d.ts

@@ -0,0 +1,11 @@
+import type { types as t } from "@marko/compiler";
+export type VisitorType = "migrate" | "transform" | "analyze" | "translate";
+export type TemplateVisitor<T extends t.Node> = Partial<Record<VisitorType, t.VisitNode<unknown, T>>>;
+export declare function extractVisitors<Visitors extends Partial<Record<keyof t.Visitor, TemplateVisitor<any>>>>(visitors: Visitors): Record<VisitorType, t.Visitor<unknown>>;
+export declare function translateByTarget<T extends t.Node>({ html, dom, }: {
+    dom: t.VisitNode<unknown, T>;
+    html: t.VisitNode<unknown, T>;
+}): {
+    readonly enter: (path: t.NodePath<T>) => void;
+    readonly exit: (path: t.NodePath<T>) => void;
+};

package/dist/translator/util/walks.d.ts

@@ -0,0 +1,15 @@
+import { types as t } from "@marko/compiler";
+import { WalkCode } from "../../common/types";
+import { type Section } from "../util/sections";
+export declare enum Step {
+    Enter = 0,
+    Exit = 1
+}
+type VisitCodes = WalkCode.Get | WalkCode.Inside | WalkCode.Replace;
+export declare function enter(path: t.NodePath<any>): void;
+export declare function exit(path: t.NodePath<any>): void;
+export declare function enterShallow(path: t.NodePath<any>): void;
+export declare function injectWalks(path: t.NodePath<any>, expr: t.Expression): void;
+export declare function visit(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder | t.Program>, code?: VisitCodes): void;
+export declare function getWalkString(section: Section): t.Expression;
+export {};

package/dist/translator/util/with-previous-location.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export default function withPreviousLocation<T extends t.Node>(newNode: T, originalNode: t.Node): T;

package/dist/translator/util/writer.d.ts

@@ -0,0 +1,13 @@
+import { types as t } from "@marko/compiler";
+import { type Section } from "../util/sections";
+import { type Binding } from "./references";
+export declare function writeTo(path: t.NodePath<any>, trailer?: boolean): (strs: TemplateStringsArray, ...exprs: Array<string | t.Expression>) => void;
+export declare function consumeHTML(path: t.NodePath<any>): t.ExpressionStatement | undefined;
+export declare function flushBefore(path: t.NodePath<any>): void;
+export declare function flushInto(path: t.NodePath<t.MarkoTag> | t.NodePath<t.Program>): void;
+export declare function getSectionMeta(section: Section): {
+    setup: t.Identifier | undefined;
+    walks: t.Expression;
+    writes: t.Expression;
+};
+export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, binding: Binding): void;

package/dist/translator/visitors/cdata.d.ts

@@ -0,0 +1,7 @@
+import type { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        enter(this: unknown, cdata: t.NodePath<t.MarkoCDATA>): never;
+    };
+};
+export default _default;

package/dist/translator/visitors/comment.d.ts

@@ -0,0 +1,7 @@
+import type { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        exit(this: unknown, comment: t.NodePath<t.MarkoComment>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/declaration.d.ts

@@ -0,0 +1,7 @@
+import type { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        enter(this: unknown, decl: t.NodePath<t.MarkoDeclaration>): never;
+    };
+};
+export default _default;

package/dist/translator/visitors/document-type.d.ts

@@ -0,0 +1,7 @@
+import type { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        exit(this: unknown, documentType: t.NodePath<t.MarkoDocumentType>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/function.d.ts

@@ -0,0 +1,19 @@
+import { types as t } from "@marko/compiler";
+declare module "@marko/compiler/dist/types" {
+    interface FunctionDeclarationExtra {
+        registerId?: string;
+        name?: string;
+    }
+    interface FunctionExpressionExtra {
+        registerId?: string;
+        name?: string;
+    }
+    interface ArrowFunctionExpressionExtra {
+        registerId?: string;
+        name?: string;
+    }
+}
+declare const _default: {
+    analyze(this: unknown, fn: t.NodePath<t.Function>): void;
+};
+export default _default;

package/dist/translator/visitors/import-declaration.d.ts

@@ -0,0 +1,8 @@
+import type { types as t } from "@marko/compiler";
+declare const _default: {
+    analyze(this: unknown, importDecl: t.NodePath<t.ImportDeclaration>): void;
+    translate: {
+        exit(this: unknown, importDecl: t.NodePath<t.ImportDeclaration>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/placeholder.d.ts

@@ -0,0 +1,22 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "../util/references";
+declare const kBinding: unique symbol;
+declare const kSiblingText: unique symbol;
+declare enum SiblingText {
+    None = 0,
+    Before = 1,
+    After = 2
+}
+declare module "@marko/compiler/dist/types" {
+    interface MarkoPlaceholderExtra {
+        [kBinding]?: Binding;
+        [kSiblingText]?: SiblingText;
+    }
+}
+declare const _default: {
+    analyze(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
+    translate: {
+        exit(this: unknown, placeholder: t.NodePath<t.MarkoPlaceholder>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/program/dom.d.ts

@@ -0,0 +1,7 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        exit(this: unknown, program: t.NodePath<t.Program>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/program/html.d.ts

@@ -0,0 +1,8 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        exit(this: unknown, program: t.NodePath<t.Program>): void;
+    };
+};
+export default _default;
+export declare function replaceRegisteredFunctionNode(node: t.Node, container: t.Node[] | t.Node): t.CallExpression | t.ClassPrivateProperty | t.ClassProperty | t.ObjectProperty | undefined;