marko 6.0.1 → 6.0.2

package/dist/translator/index.js

@@ -1518,6 +1518,22 @@ var reasonExprs = /* @__PURE__ */ new WeakMap();
 var keyedReasonExprs = /* @__PURE__ */ new WeakMap();
 var serializeKeysByBinding = /* @__PURE__ */ new WeakMap();
 var serializeKeyBySourceModifier = {};
+function forceOwnersSerialize(from, to, prop) {
+  let cur = from;
+  while (cur !== to && cur.parent) {
+    forceSectionSerialize(cur, prop);
+    cur = cur.parent;
+  }
+}
+function addOwnersSerializeReason(from, to, reason, prop) {
+  if (reason) {
+    let cur = from;
+    while (cur !== to && cur.parent) {
+      addSectionSerializeReason(cur, reason, prop);
+      cur = cur.parent;
+    }
+  }
+}
 function forceSectionSerialize(section, prop) {
   if (prop) {
     forceSerializeKey(section, getSectionPropSerializeReasonKey(section, prop));
@@ -1961,7 +1977,6 @@ function startSection(path5) {
       bindings: void 0,
       hoisted: void 0,
       isHoistThrough: void 0,
-      assignments: void 0,
       serializeReason: void 0,
       serializeReasons: /* @__PURE__ */ new Map(),
       content: getContentInfo(path5),
@@ -2105,9 +2120,6 @@ var isSerializedSection = (section) => {
   }
   return true;
 };
-function isSectionWithHoists(section) {
-  return !!(section.hoisted || section.isHoistThrough || section.referencedHoists);
-}
 function isImmediateOwner(section, binding) {
   return section.parent?.id === binding.section.id;
 }
@@ -2811,7 +2823,7 @@ var return_default = {
     }
     if (attrs2.valueChange) {
       forceSectionSerialize(
-        getSection(tag),
+        getOrCreateSection(tag),
         getAccessorProp().TagVariableChange
       );
     }
@@ -3588,12 +3600,8 @@ function writeHTMLResumeStatements(path5) {
   const body = path5.node.body;
   const allSignals = Array.from(getSignals(section).values());
   const scopeIdIdentifier = getScopeIdIdentifier(section);
-  const serializeOwnersUntilBinding = (binding) => serializeOwners(section, binding.section);
-  forEach(section.assignments, serializeOwnersUntilBinding);
-  forEach(section.referencedHoists, serializeOwnersUntilBinding);
   forEach(section.referencedClosures, (closure) => {
     if (closure.sources) {
-      serializeOwnersUntilBinding(closure);
       if (isDynamicClosure(section, closure)) {
         const closureSignal = getSignal(closure.section, closure);
         let identifier = htmlDynamicClosureInstancesIdentifier.get(closureSignal);
@@ -3722,6 +3730,23 @@ function writeHTMLResumeStatements(path5) {
       )
     );
   });
+  if (section.parent) {
+    const ownerAccessor = getAccessorProp().Owner;
+    const ownerReason = getSectionSerializeReason(section, ownerAccessor);
+    if (ownerReason) {
+      const getOwnerExpr = callRuntime(
+        "ensureScopeWithId",
+        getScopeIdIdentifier(section.parent)
+      );
+      serializedLookup.delete(ownerAccessor);
+      serializedProperties.push(
+        toObjectProperty(
+          ownerAccessor,
+          sectionSerializeReason && (sectionSerializeReason === ownerReason || sectionSerializeReason !== true && ownerReason !== true && compareSerializeReasons(sectionSerializeReason, ownerReason) === 0) ? getOwnerExpr : getExprIfSerialized(ownerReason, getOwnerExpr)
+        )
+      );
+    }
+  }
   for (const [key, { expression, reason }] of serializedLookup) {
     serializedProperties.push(
       toObjectProperty(key, getExprIfSerialized(reason, expression))
@@ -3806,23 +3831,6 @@ function writeHTMLResumeStatements(path5) {
     body.push(import_compiler20.types.returnStatement(returnIdentifier));
   }
 }
-function serializeOwners(from, to) {
-  const ownerProp = getAccessorProp().Owner;
-  let cur = from;
-  while (cur !== to) {
-    const parent = cur.parent;
-    if (!parent) break;
-    const serialized = getSerializedAccessors(cur);
-    nonAnalyzedForceSerializedSection.add(cur);
-    cur = parent;
-    if (!serialized.has(ownerProp)) {
-      serialized.set(ownerProp, {
-        expression: callRuntime("ensureScopeWithId", getScopeIdIdentifier(cur)),
-        reason: true
-      });
-    }
-  }
-}
 function getSetup(section) {
   return getSignals(section).get(void 0)?.identifier;
 }
@@ -4321,6 +4329,7 @@ function createBinding(name2, type, section, upstreamAlias, property, loc = null
     property,
     declared,
     closureSections: void 0,
+    assignmentSections: void 0,
     excludeProperties: void 0,
     serializeSources: void 0,
     sources: void 0,
@@ -4418,7 +4427,6 @@ function trackHoistedReference(referencePath, binding) {
       currentSection = currentSection.parent;
     }
   }
-  extra.hoistedBinding = hoistedBinding;
   if (isInvokedFunction(referencePath)) {
     extra.read = createRead(hoistedBinding, void 0);
     extra.section = referenceSection;
@@ -4461,7 +4469,10 @@ function trackAssignment(assignment, binding) {
   forEachIdentifier(assignment.node, (id) => {
     if (id.name === binding.name) {
       const extra = id.extra ??= {};
-      section.assignments = bindingUtil.add(section.assignments, binding);
+      binding.assignmentSections = sectionUtil.add(
+        binding.assignmentSections,
+        section
+      );
       extra.assignment = binding;
       extra.section = section;
     }
@@ -4707,6 +4718,10 @@ function finalizeReferences() {
       if (binding.hoists.size) {
         forceBindingSerialize(binding.section, binding);
       }
+      forEach(
+        binding.assignmentSections,
+        (assignedSection) => forceOwnersSerialize(assignedSection, section, getAccessorProp().Owner)
+      );
       if (find(section.bindings, ({ name: name3 }) => name3 === binding.name)) {
         binding.name = generateUid(name2);
       }
@@ -4726,6 +4741,12 @@ function finalizeReferences() {
           section2.referencedClosures,
           binding
         );
+        addOwnersSerializeReason(
+          section2,
+          binding.section,
+          binding.serializeSources,
+          getAccessorProp().Owner
+        );
       }
       if (isEffect) {
         forEach(
@@ -4736,9 +4757,16 @@ function finalizeReferences() {
     }
   }
   forEachSection((section) => {
-    if (isSectionWithHoists(section)) {
+    if (section.isHoistThrough) {
       forceSectionSerialize(section);
     }
+    forEach(section.referencedHoists, (hoistedBinding) => {
+      forceOwnersSerialize(
+        section,
+        hoistedBinding.section,
+        getAccessorProp().Owner
+      );
+    });
     if (section.parent && section.isBranch && section.sectionAccessor && section.upstreamExpression) {
       addSectionSerializeReasonRef(section, getDirectClosures(section));
       addSectionSerializeReasonExpr(section, section.upstreamExpression);
@@ -5756,22 +5784,27 @@ var native_tag_default = {
           );
         }
         if (node.var) {
-          forceSectionSerialize(tagSection);
           forceBindingSerialize(tagSection, nodeBinding);
-          const varBinding = tag.scope.getBinding(node.var.name);
-          for (const referencePath of varBinding.referencePaths) {
-            const referenceSection = getSection(referencePath);
-            setReferencesScope(referencePath);
-            if (!isSameOrChildSection(tagSection, referenceSection)) {
+          for (const ref of tag.scope.getBinding(node.var.name).referencePaths) {
+            const refSection = getOrCreateSection(ref);
+            setReferencesScope(ref);
+            if (isSameOrChildSection(tagSection, refSection)) {
+              forceOwnersSerialize(
+                refSection,
+                tagSection,
+                getAccessorProp().Owner
+              );
+              if (!isInvokedFunction(ref)) {
+                tagExtra[kGetterId] ||= getRegisterUID(
+                  tagSection,
+                  nodeBinding.name
+                );
+              }
+            } else {
               trackHoistedReference(
-                referencePath,
+                ref,
                 nodeBinding
               );
-            } else if (!isInvokedFunction(referencePath)) {
-              tagExtra[kGetterId] ||= getRegisterUID(
-                tagSection,
-                nodeBinding.name
-              );
             }
           }
         } else if (hasEventHandlers || spreadReferenceNodes) {
@@ -5804,12 +5837,6 @@ var native_tag_default = {
         const varBinding = tag.scope.getBinding(varName);
         const getterId = tagExtra[kGetterId];
         if (isHTML) {
-          for (const reference of varBinding.referencePaths) {
-            const referenceSection = getSection(reference);
-            if (!reference.node.extra?.hoist) {
-              serializeOwners(referenceSection, tagSection);
-            }
-          }
           translateVar(
             tag,
             callRuntime(
@@ -5838,8 +5865,8 @@ var native_tag_default = {
             );
           }
           for (const reference of varBinding.referencePaths) {
-            if (!reference.node.extra?.hoistedBinding) {
-              const referenceSection = getSection(reference);
+            const referenceSection = getSection(reference);
+            if (isSameOrChildSection(tagSection, referenceSection)) {
               if (isInvokedFunction(reference)) {
                 reference.parentPath.replaceWith(
                   import_compiler31.types.expressionStatement(
@@ -7347,9 +7374,19 @@ var html_script_default = {
       if (node.var) {
         forceBindingSerialize(tagSection, nodeBinding);
         for (const ref of tag.scope.getBinding(node.var.name).referencePaths) {
-          if (!isInvokedFunction(ref)) {
-            tagExtra[kGetterId3] = getRegisterUID(tagSection, "#script");
-            break;
+          const refSection = getOrCreateSection(ref);
+          setReferencesScope(ref);
+          if (isSameOrChildSection(tagSection, refSection)) {
+            forceOwnersSerialize(
+              refSection,
+              tagSection,
+              getAccessorProp().Owner
+            );
+            if (!tagExtra[kGetterId3] && !isInvokedFunction(ref)) {
+              tagExtra[kGetterId3] = getRegisterUID(tagSection, "#script");
+            }
+          } else {
+            trackHoistedReference(ref, nodeBinding);
           }
         }
       } else if (hasEventHandlers || spreadReferenceNodes) {
@@ -7374,11 +7411,6 @@ var html_script_default = {
       if (hasVar) {
         const getterId = tagExtra[kGetterId3];
         if (isHTML) {
-          const varName = tag.node.var.name;
-          const references = tag.scope.getBinding(varName).referencePaths;
-          for (const reference of references) {
-            serializeOwners(getSection(reference), tagSection);
-          }
           translateVar(
             tag,
             callRuntime(
@@ -7754,9 +7786,19 @@ var html_style_default = {
       if (node.var) {
         forceBindingSerialize(tagSection, nodeBinding);
         for (const ref of tag.scope.getBinding(node.var.name).referencePaths) {
-          if (!isInvokedFunction(ref)) {
-            tagExtra[kGetterId4] = getRegisterUID(tagSection, "#style");
-            break;
+          const refSection = getOrCreateSection(ref);
+          setReferencesScope(ref);
+          if (isSameOrChildSection(tagSection, refSection)) {
+            forceOwnersSerialize(
+              refSection,
+              tagSection,
+              getAccessorProp().Owner
+            );
+            if (!tagExtra[kGetterId4] && !isInvokedFunction(ref)) {
+              tagExtra[kGetterId4] = getRegisterUID(tagSection, "#style");
+            }
+          } else {
+            trackHoistedReference(ref, nodeBinding);
           }
         }
       } else if (hasEventHandlers || spreadReferenceNodes) {
@@ -7781,11 +7823,6 @@ var html_style_default = {
       if (hasVar) {
         const getterId = tagExtra[kGetterId4];
         if (isHTML) {
-          const varName = tag.node.var.name;
-          const references = tag.scope.getBinding(varName).referencePaths;
-          for (const reference of references) {
-            serializeOwners(getSection(reference), tagSection);
-          }
           translateVar(
             tag,
             callRuntime(
@@ -8545,17 +8582,18 @@ var let_default = {
         "The `let` tag `valueChange` attribute must be a function."
       );
     }
+    const tagSection = getOrCreateSection(tag);
     const binding = trackVarReferences(tag, 1 /* let */);
     setBindingValueExpr(
       binding,
-      mergeReferences(getOrCreateSection(tag), tag.node, [
+      mergeReferences(tagSection, tag.node, [
         valueAttr?.value,
         valueChangeAttr?.value
       ])
     );
     if (valueChangeAttr) {
       forceBindingSerialize(
-        getSection(tag),
+        tagSection,
         binding,
         getAccessorPrefix().TagVariableChange
       );

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

@@ -21,6 +21,7 @@ export interface Binding {
     loc: t.SourceLocation | null;
     section: Section;
     closureSections: Opt<Section>;
+    assignmentSections: Opt<Section>;
     sources: Opt<Binding>;
     serializeSources: undefined | SerializeReason;
     aliases: Set<Binding>;
@@ -45,7 +46,6 @@ declare module "@marko/compiler/dist/types" {
         section?: Section;
         referencedBindings?: ReferencedBindings;
         binding?: Binding;
-        hoistedBinding?: Binding;
         assignment?: Binding;
         read?: {
             binding: Binding;

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

@@ -28,7 +28,6 @@ export interface Section {
     serializeReason: undefined | SerializeReason;
     serializeReasons: Map<symbol, SerializeReason>;
     isHoistThrough: true | undefined;
-    assignments: ReferencedBindings;
     upstreamExpression: t.NodeExtra | undefined;
     downstreamBinding: Binding | undefined;
     hasAbortSignal: boolean;
@@ -53,7 +52,6 @@ export declare function startSection(path: t.NodePath<t.MarkoTagBody | t.Program
 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;

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

@@ -12,7 +12,8 @@ export type SerializeReason = true | DynamicSerializeReason;
 export type SerializeKey = symbol & {
     __serialize_key__: 1;
 };
-export declare function forceParentSectionsSerialize(from: Section, to?: Section): void;
+export declare function forceOwnersSerialize(from: Section, to: Section, prop?: AccessorProp | symbol): void;
+export declare function addOwnersSerializeReason(from: Section, to: Section, reason: undefined | boolean | SerializeReason, prop?: AccessorProp | symbol): 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;

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

@@ -56,7 +56,6 @@ 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>): void;
-export declare function serializeOwners(from: Section, to?: Section): 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;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",