marko 6.0.0-next.3.85 → 6.0.0

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

@@ -3,9 +3,11 @@ declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
         confident?: boolean;
         computed?: unknown;
+        nullable?: boolean;
     }
 }
 export default function evaluate<T extends t.Expression>(value: T): T["extra"] & {
     confident: boolean;
+    nullable: boolean;
     computed: unknown;
 };

package/dist/translator/util/generate-uid.d.ts

@@ -1,3 +1,6 @@
 import { types as t } from "@marko/compiler";
 export declare function generateUid(name?: string): string;
 export declare function generateUidIdentifier(name?: string): t.Identifier;
+export declare function getSharedUid(name: string): string;
+export declare function usedSharedUid(name: string): boolean;
+export declare function getSharedUidIdentifier(name: string): t.Identifier;

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

@@ -5,11 +5,11 @@ export type Compare<T> = (a: T, b: T) => number;
 export declare class Sorted<T> {
     compare: Compare<T>;
     constructor(compare: Compare<T>);
-    add<U extends T>(data: Opt<U>, item: U): OneMany<U>;
-    union<U extends T>(a: Opt<U>, b: Opt<U>): Opt<U>;
-    find<U extends T>(data: Opt<U>, item: U): U | undefined;
-    findIndex<U extends T>(data: Opt<U>, item: U): number;
-    isSuperset<U extends T>(superset: Opt<U>, subset: Opt<U>): boolean;
+    add<U extends NonNullable<T>>(data: Opt<U>, item: U): OneMany<U>;
+    union<U extends NonNullable<T>>(a: Opt<U>, b: Opt<U>): Opt<U>;
+    find<U extends NonNullable<T>>(data: Opt<U>, item: U): U | undefined;
+    findIndex<U extends NonNullable<T>>(data: Opt<U>, item: U): number;
+    isSuperset<U extends NonNullable<T>>(superset: Opt<U>, subset: Opt<U>): boolean;
 }
 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>;
@@ -18,6 +18,8 @@ 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 fromIter<T>(data: Iterable<T>): T | Many<T> | undefined;
 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 toArray<T, R>(data: Opt<T>, cb: (item: T, index: number) => R): R[];
+export declare function filterMap<T, R>(data: Opt<T>, cb: (item: T) => undefined | R): Opt<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[];
+export declare function findIndexSorted<T>(compare: Compare<T>, data: T[], item: T): number;
+export declare function addSorted<T, U extends T[]>(compare: Compare<T>, data: U, item: T): U;

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

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
-import { type Many, type Opt, Sorted } from "./optional";
+import { type Many, type OneMany, type Opt, Sorted } from "./optional";
 import { type Section } from "./sections";
+import { type SerializeReason } from "./serialize-reasons";
 declare const kIsInvoked: unique symbol;
 export type Aliases = undefined | Binding | {
     [property: string]: Aliases;
@@ -21,14 +22,13 @@ export interface Binding {
     section: Section;
     closureSections: Opt<Section>;
     sources: Opt<Binding>;
-    serializeSources: Opt<InputBinding> | true;
+    serializeSources: undefined | SerializeReason;
     aliases: Set<Binding>;
     hoists: Map<Section, Binding>;
     property: string | undefined;
     propertyAliases: Map<string, Binding>;
     excludeProperties: undefined | string[];
     upstreamAlias: Binding | undefined;
-    upstreamExpression: t.NodeExtra | undefined;
     downstreamExpressions: Set<ReferencedExtra>;
     scopeOffset: Binding | undefined;
     export: string | undefined;
@@ -65,17 +65,19 @@ declare module "@marko/compiler/dist/types" {
     interface FunctionExpressionExtra extends FunctionExtra {
     }
 }
-export declare function createBinding(name: string, type: Binding["type"], section: Section, upstreamAlias?: Binding["upstreamAlias"], upstreamExpression?: Binding["upstreamExpression"], property?: string, loc?: t.SourceLocation | null, 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 createBinding(name: string, type: Binding["type"], section: Section, upstreamAlias?: Binding["upstreamAlias"], property?: string, loc?: t.SourceLocation | null, declared?: boolean): Binding;
+export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: BindingType, upstreamAlias?: Binding["upstreamAlias"]): Binding | undefined;
+export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType, upstreamAlias?: Binding["upstreamAlias"]): Binding | undefined;
 export declare function trackHoistedReference(referencePath: t.NodePath<t.Identifier>, binding: Binding): 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 mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]>;
+export declare function compareSerializeReasons(a: OneMany<InputBinding>, b: OneMany<InputBinding>): number;
 export declare function finalizeReferences(): void;
 export declare const intersectionMeta: WeakMap<Intersection, {
     id: number;
     scopeOffset: Binding | undefined;
 }>;
+export declare function setBindingValueExpr(binding: Binding, valueExpr: undefined | boolean | Opt<t.NodeExtra>): void;
 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;

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

@@ -1,6 +1,8 @@
 import { types as t } from "@marko/compiler";
-import { type OneMany, Sorted } from "./optional";
-import type { Binding, InputBinding, ReferencedBindings } from "./references";
+import type { AccessorPrefix } from "../../common/accessor.debug";
+import { Sorted } from "./optional";
+import type { Binding, ReferencedBindings } from "./references";
+import { type SerializeReason } from "./serialize-reasons";
 export declare enum ContentType {
     Comment = 0,
     Dynamic = 1,
@@ -16,14 +18,15 @@ export interface Section {
     parent: Section | undefined;
     sectionAccessor: {
         binding: Binding;
-        prefix: string;
+        prefix: AccessorPrefix;
     } | undefined;
     params: undefined | Binding;
     referencedClosures: ReferencedBindings;
     referencedHoists: ReferencedBindings;
     bindings: ReferencedBindings;
     hoisted: ReferencedBindings;
-    serializeReasons: Map<symbol, true | OneMany<InputBinding>>;
+    serializeReason: undefined | SerializeReason;
+    serializeReasons: Map<symbol, SerializeReason>;
     isHoistThrough: true | undefined;
     assignments: ReferencedBindings;
     upstreamExpression: t.NodeExtra | undefined;
@@ -45,7 +48,6 @@ declare module "@marko/compiler/dist/types" {
         section?: Section;
     }
 }
-export declare const kBranchSerializeReason: unique symbol;
 export declare const sectionUtil: Sorted<Section>;
 export declare function startSection(path: t.NodePath<t.MarkoTagBody | t.Program>): Section | undefined;
 export declare function getOrCreateSection(path: t.NodePath<any>): Section;

package/dist/translator/util/serialize-reasons.d.ts

@@ -1,22 +1,33 @@
 import { types as t } from "@marko/compiler";
 import { AccessorPrefix, AccessorProp } from "../../common/types";
-import { type Opt } from "./optional";
+import { type OneMany, type Opt } from "./optional";
 import { type Binding, type InputBinding, type ReferencedBindings } from "./references";
 import type { Section } from "./sections";
-export declare function forcePropSerialize(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol): void;
-export declare function forceBindingSerialize(section: Section, binding: Binding, prefix?: AccessorPrefix): void;
-export declare function isPropForceSerialized(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol): boolean;
-export declare function isBindingForceSerialized(section: Section, binding: Binding, prefix?: AccessorPrefix): boolean;
-export declare function addPropSerializeReasonExpr(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol, expr: undefined | boolean | Opt<t.NodeExtra>): void;
-export declare function addBindingSerializeReasonExpr(section: Section, binding: Binding, expr: undefined | boolean | Opt<t.NodeExtra>, prefix?: AccessorPrefix): void;
-export declare function addPropSerializeReasonRef(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol, ref: undefined | boolean | ReferencedBindings): void;
-export declare function addBindingSerializeReasonRef(section: Section, binding: Binding, ref: undefined | boolean | ReferencedBindings, prefix?: AccessorPrefix): void;
-export declare function addPropSerializeReason(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol, reason: boolean | Opt<InputBinding>): void;
-export declare function addBindingSerializeReason(section: Section, binding: Binding, reason: boolean | Opt<InputBinding>, prefix?: AccessorPrefix): void;
-export declare function getPropSerializeReason(section: Section, extra: t.NodeExtra, prop: AccessorProp | symbol): true | import("./optional").OneMany<InputBinding> | undefined;
-export declare function getBindingSerializeReason(section: Section, binding: Binding, prefix?: AccessorPrefix): true | import("./optional").OneMany<InputBinding> | undefined;
-export declare function consumeSerializeReasonExprs(section: Section): Map<symbol, Opt<t.NodeExtra>> | undefined;
-export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): true | Opt<InputBinding>;
+export type DynamicSerializeReason = OneMany<InputBinding>;
+export type DynamicSerializeReasons = [
+    DynamicSerializeReason,
+    ...DynamicSerializeReason[]
+];
+export type SerializeReason = true | DynamicSerializeReason;
+export type SerializeKey = symbol & {
+    __serialize_key__: 1;
+};
+export declare function forceParentSectionsSerialize(from: Section, to?: Section): void;
+export declare function forceSectionSerialize(section: Section, prop?: AccessorProp | symbol): void;
+export declare function forceBindingSerialize(section: Section, binding: Binding, prefix?: AccessorPrefix | symbol): void;
+export declare function isSectionForceSerialized(section: Section, prop?: AccessorProp | symbol): boolean;
+export declare function isBindingForceSerialized(section: Section, binding: Binding, prefix?: AccessorPrefix | symbol): boolean;
+export declare function addSectionSerializeReasonExpr(section: Section, expr: undefined | boolean | Opt<t.NodeExtra>, prop?: AccessorProp | symbol): void;
+export declare function addBindingSerializeReasonExpr(section: Section, binding: Binding, expr: undefined | boolean | Opt<t.NodeExtra>, prefix?: AccessorPrefix | symbol): void;
+export declare function addSectionSerializeReasonRef(section: Section, ref: undefined | boolean | ReferencedBindings, prop?: AccessorProp | symbol): void;
+export declare function addBindingSerializeReasonRef(section: Section, binding: Binding, ref: undefined | boolean | ReferencedBindings, prefix?: AccessorPrefix | symbol): void;
+export declare function addSectionSerializeReason(section: Section, reason: undefined | false | SerializeReason, prop?: AccessorProp | symbol): void;
+export declare function addBindingSerializeReason(section: Section, binding: Binding, reason: undefined | false | SerializeReason, prefix?: AccessorPrefix | symbol): void;
+export declare function getSectionSerializeReason(section: Section, prop?: AccessorProp | symbol): SerializeReason | undefined;
+export declare function getBindingSerializeReason(section: Section, binding: Binding, prefix?: AccessorPrefix | symbol): SerializeReason | undefined;
+export declare function applySerializeReasonExprs(section: Section): void;
+export declare function finalizeSectionSerializeReasons(section: Section): void;
+export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): true | InputBinding | import("./optional").Many<InputBinding> | undefined;
 export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra>): true | Opt<InputBinding>;
-export declare function getSerializeSourcesForRef(ref: ReferencedBindings): true | Opt<InputBinding>;
-export declare function mergeSerializeReasons<T extends true | Opt<InputBinding>>(a: T, b: T): T;
+export declare function getSerializeSourcesForRef(ref: ReferencedBindings): true | InputBinding | import("./optional").Many<InputBinding> | undefined;
+export declare function mergeSerializeReasons<T extends undefined | SerializeReason>(a: T, b: T): T;

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

@@ -34,9 +34,8 @@ export type Signal = {
 };
 type closureSignalBuilder = (closure: Binding, render: t.Expression) => t.Expression;
 export declare function setClosureSignalBuilder(tag: t.NodePath<t.MarkoTag>, builder: closureSignalBuilder): void;
-export declare function serializeSectionIfNeeded(section: Section, reason: undefined | boolean | Opt<Binding>): void;
+export declare function setSectionSerializedValue(section: Section, prop: AccessorProp, expression: t.Expression): void;
 export declare function setBindingSerializedValue(section: Section, binding: Binding, expression: t.Expression, prefix?: AccessorPrefix): void;
-export declare function setPropSerializedValue(section: Section, extra: t.NodeExtra, prop: AccessorProp, expression: t.Expression): void;
 export declare function setSerializedValue(section: Section, key: string, expression: t.Expression): void;
 export declare const getHTMLSectionStatements: (section: Section) => t.Statement[];
 export declare function getHoistFunctionIdentifier(hoistedBinding: Binding): t.Identifier;

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

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { type Section } from "../util/sections";
 import { type Binding } from "./references";
+import type { SerializeReason } from "./serialize-reasons";
 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;
@@ -10,4 +11,4 @@ export declare function getSectionMeta(section: Section): {
     walks: t.Expression | undefined;
     writes: t.Expression | undefined;
 };
-export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, binding: Binding): void;
+export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, nodeBinding: Binding, reason: undefined | false | SerializeReason): void;

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

@@ -1,6 +1,6 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "../util/references";
-declare const kBinding: unique symbol;
+declare const kNodeBinding: unique symbol;
 declare const kSiblingText: unique symbol;
 declare enum SiblingText {
     None = 0,
@@ -9,7 +9,7 @@ declare enum SiblingText {
 }
 declare module "@marko/compiler/dist/types" {
     interface MarkoPlaceholderExtra {
-        [kBinding]?: Binding;
+        [kNodeBinding]?: Binding;
         [kSiblingText]?: SiblingText;
     }
 }

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

@@ -1,5 +1,8 @@
 import { types as t } from "@marko/compiler";
+import type { DynamicSerializeReason } from "../../util/serialize-reasons";
 export declare function getTemplateContentName(): string;
+export declare function getExprIfSerialized<T extends undefined | boolean | DynamicSerializeReason, U extends t.Expression>(reason: T, expr: U): T extends {} ? U : undefined;
+export declare function getSerializeGuard<T extends undefined | boolean | DynamicSerializeReason>(reason: T): T extends {} ? t.Expression : undefined;
 declare const _default: {
     translate: {
         exit(this: unknown, program: t.NodePath<t.Program>): void;

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

@@ -1,5 +1,6 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
+import type { DynamicSerializeReason, DynamicSerializeReasons, SerializeReason } from "../../util/serialize-reasons";
 export declare let cleanIdentifier: t.Identifier;
 export declare let scopeIdentifier: t.Identifier;
 export declare function isScopeIdentifier(node: t.Node): node is t.Identifier;
@@ -13,12 +14,14 @@ export type TemplateExport = {
 export type TemplateExports = TemplateExport["props"];
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
+        inputSerializeReasons?: DynamicSerializeReasons;
+        returnSerializeReason?: SerializeReason;
+        returnValueExpr?: t.NodeExtra;
         domExports?: {
             template: string;
             walks: string;
             setup: string;
             input: TemplateExport | undefined;
-            closures: string;
         };
     }
 }
@@ -37,3 +40,4 @@ declare const _default: {
     };
 };
 export default _default;
+export declare function resolveSerializeReasonId(inputSerializeReasons: DynamicSerializeReasons, reason: DynamicSerializeReason): number;

package/dist/translator/visitors/tag/custom-tag.d.ts

@@ -2,10 +2,12 @@ import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
 declare const kChildScopeBinding: unique symbol;
 declare const kChildOffsetScopeBinding: unique symbol;
+declare const kChildInputSerializePropIds: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
         [kChildScopeBinding]?: Binding;
         [kChildOffsetScopeBinding]?: Binding;
+        [kChildInputSerializePropIds]?: [symbol, ...symbol[]];
     }
 }
 declare const _default: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.0-next.3.85",
+  "version": "6.0.0",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -48,7 +48,7 @@
     "build": "node -r ~ts ./scripts/bundle.ts"
   },
   "dependencies": {
-    "@marko/compiler": "^5.39.17",
+    "@marko/compiler": "^5.39.18",
     "csstype": "^3.1.3",
     "magic-string": "^0.30.17"
   },