marko 6.0.31 → 6.0.33

package/dist/common/types.d.ts

@@ -80,6 +80,7 @@ export interface Template {
     render(input?: Input): RenderedTemplate;
 }
 export interface MountedTemplate {
+    value: unknown;
     update(input: unknown): void;
     destroy(): void;
 }

package/dist/debug/dom.js

@@ -2303,6 +2303,7 @@ function mount(input = {}, reference, position) {
       nextSibling = reference.nextSibling;
       break;
   }
+  let curValue;
   const args = this.___params;
   const effects = prepareEffects(() => {
     branch = createBranch(
@@ -2311,6 +2312,9 @@ function mount(input = {}, reference, position) {
       void 0,
       parentNode
     );
+    branch["#TagVariable" /* TagVariable */] = (newValue) => {
+      curValue = newValue;
+    };
     this.___setup?.(branch);
     args?.(branch, input);
   });
@@ -2322,6 +2326,12 @@ function mount(input = {}, reference, position) {
   );
   runEffects(effects);
   return {
+    get value() {
+      return curValue;
+    },
+    set value(newValue) {
+      tagVarSignalChange(branch, newValue);
+    },
     update(newInput) {
       if (args) {
         runEffects(

package/dist/debug/dom.mjs

@@ -2210,6 +2210,7 @@ function mount(input = {}, reference, position) {
       nextSibling = reference.nextSibling;
       break;
   }
+  let curValue;
   const args = this.___params;
   const effects = prepareEffects(() => {
     branch = createBranch(
@@ -2218,6 +2219,9 @@ function mount(input = {}, reference, position) {
       void 0,
       parentNode
     );
+    branch["#TagVariable" /* TagVariable */] = (newValue) => {
+      curValue = newValue;
+    };
     this.___setup?.(branch);
     args?.(branch, input);
   });
@@ -2229,6 +2233,12 @@ function mount(input = {}, reference, position) {
   );
   runEffects(effects);
   return {
+    get value() {
+      return curValue;
+    },
+    set value(newValue) {
+      tagVarSignalChange(branch, newValue);
+    },
     update(newInput) {
       if (args) {
         runEffects(

package/dist/dom/template.d.ts

@@ -1,3 +1,3 @@
-import type { Scope, Template } from "../common/types";
-import type { Signal } from "./signals";
+import { type Scope, type Template } from "../common/types";
+import { type Signal } from "./signals";
 export declare const createTemplate: (id: string, template: string | 0, walks?: string | 0, setup?: ((scope: Scope) => void) | 0, inputSignal?: Signal<unknown>) => Template;

package/dist/dom.js

@@ -1509,13 +1509,15 @@ function mount(input = {}, reference, position) {
       parentNode = reference.parentNode, nextSibling = reference.nextSibling;
       break;
   }
-  let args = this.m, effects = prepareEffects(() => {
+  let curValue, args = this.m, effects = prepareEffects(() => {
     branch = createBranch(
       $global,
       this,
       void 0,
       parentNode
-    ), this.D?.(branch), args?.(branch, input);
+    ), branch.e = (newValue) => {
+      curValue = newValue;
+    }, this.D?.(branch), args?.(branch, input);
   });
   return insertChildNodes(
     parentNode,
@@ -1523,6 +1525,12 @@ function mount(input = {}, reference, position) {
     branch.h,
     branch.j
   ), runEffects(effects), {
+    get value() {
+      return curValue;
+    },
+    set value(newValue) {
+      tagVarSignalChange(branch, newValue);
+    },
     update(newInput) {
       args && runEffects(
         prepareEffects(() => {

package/dist/dom.mjs

@@ -1419,13 +1419,15 @@ function mount(input = {}, reference, position) {
       parentNode = reference.parentNode, nextSibling = reference.nextSibling;
       break;
   }
-  let args = this.m, effects = prepareEffects(() => {
+  let curValue, args = this.m, effects = prepareEffects(() => {
     branch = createBranch(
       $global,
       this,
       void 0,
       parentNode
-    ), this.D?.(branch), args?.(branch, input);
+    ), branch.e = (newValue) => {
+      curValue = newValue;
+    }, this.D?.(branch), args?.(branch, input);
   });
   return insertChildNodes(
     parentNode,
@@ -1433,6 +1435,12 @@ function mount(input = {}, reference, position) {
     branch.h,
     branch.j
   ), runEffects(effects), {
+    get value() {
+      return curValue;
+    },
+    set value(newValue) {
+      tagVarSignalChange(branch, newValue);
+    },
     update(newInput) {
       args && runEffects(
         prepareEffects(() => {

package/dist/translator/index.js

@@ -538,6 +538,36 @@ function forEachIdentifier(node, cb) {
       break;
   }
 }
+function forEachIdentifierPath(nodePath, cb) {
+  if (nodePath.isIdentifier()) {
+    cb(nodePath);
+  } else if (nodePath.isObjectPattern()) {
+    for (const prop of nodePath.get("properties")) {
+      if (prop.isObjectProperty()) {
+        const value = prop.get("value");
+        if (value.isAssignmentPattern()) {
+          forEachIdentifierPath(value.get("left"), cb);
+        } else {
+          forEachIdentifierPath(value, cb);
+        }
+      } else if (prop.isRestElement()) {
+        forEachIdentifierPath(prop.get("argument"), cb);
+      }
+    }
+  } else if (nodePath.isArrayPattern()) {
+    for (const el of nodePath.get("elements")) {
+      if (el) {
+        if (el.isRestElement()) {
+          forEachIdentifierPath(el.get("argument"), cb);
+        } else if (el.isAssignmentPattern()) {
+          forEachIdentifierPath(el.get("left"), cb);
+        } else {
+          forEachIdentifierPath(el, cb);
+        }
+      }
+    }
+  }
+}
 
 // src/translator/util/generate-uid.ts
 var import_compiler3 = require("@marko/compiler");
@@ -3313,13 +3343,17 @@ function getTranslatedExtraArgs(signal) {
   }
   return emptyExtraArgs;
 }
-function subscribe(provider, subscriber) {
-  if (Array.isArray(provider)) {
-    provider.forEach((p) => subscribe(p, subscriber));
-    return;
+function subscribe(references, subscriber) {
+  if (references) {
+    forEach(references, (binding) => {
+      const source = binding.property === void 0 && binding.upstreamAlias || binding;
+      const providerSignal = getSignal(subscriber.section, source);
+      providerSignal.intersection = push(
+        providerSignal.intersection,
+        subscriber
+      );
+    });
   }
-  const providerSignal = getSignal(subscriber.section, provider);
-  providerSignal.intersection = push(providerSignal.intersection, subscriber);
 }
 function generateSignalName(referencedBindings) {
   let name2;
@@ -3880,10 +3914,7 @@ function replaceAssignedNode(node) {
     case "UpdateExpression": {
       const { extra } = node.argument;
       if (isAssignedBindingExtra(extra)) {
-        const { buildAssignment } = getSignal(
-          extra.assignment.section,
-          extra.assignment
-        );
+        const buildAssignment = getBuildAssignment(extra);
         if (buildAssignment) {
           const replacement = buildAssignment(
             extra.section,
@@ -3906,10 +3937,7 @@ function replaceAssignedNode(node) {
         case "Identifier": {
           const { extra } = node.left;
           if (isAssignedBindingExtra(extra)) {
-            const { buildAssignment } = getSignal(
-              extra.assignment.section,
-              extra.assignment
-            );
+            const buildAssignment = getBuildAssignment(extra);
             if (buildAssignment) {
               return buildAssignment(
                 extra.section,
@@ -3933,15 +3961,12 @@ function replaceAssignedNode(node) {
           forEachIdentifier(node.left, (id) => {
             const { extra } = id;
             if (isAssignedBindingExtra(extra)) {
-              const signal = getSignal(
-                extra.assignment.section,
-                extra.assignment
-              );
-              if (signal?.buildAssignment) {
+              const buildAssignment = getBuildAssignment(extra);
+              if (buildAssignment) {
                 id.name = generateUid(id.name);
                 (params ||= []).push(import_compiler20.types.identifier(id.name));
                 (assignments ||= []).push(
-                  signal.buildAssignment(extra.section, import_compiler20.types.identifier(id.name))
+                  buildAssignment(extra.section, import_compiler20.types.identifier(id.name))
                 );
               }
             }
@@ -3970,6 +3995,15 @@ function replaceAssignedNode(node) {
       break;
   }
 }
+function getBuildAssignment(extra) {
+  const { assignmentTo, assignment } = extra;
+  if (assignmentTo) {
+    return (_section, value) => {
+      return import_compiler20.types.callExpression(import_compiler20.types.identifier(assignmentTo.name), [value]);
+    };
+  }
+  return getSignal(assignment.section, assignment).buildAssignment;
+}
 var registeredFnsForProgram = /* @__PURE__ */ new WeakMap();
 function replaceRegisteredFunctionNode2(node) {
   switch (node.type) {
@@ -4527,9 +4561,23 @@ function trackReferencesForBinding(babelBinding, binding) {
 function trackAssignment(assignment, binding) {
   const section = getOrCreateSection(assignment);
   setReferencesScope(assignment);
-  forEachIdentifier(assignment.node, (id) => {
-    if (id.name === binding.name) {
-      const extra = id.extra ??= {};
+  forEachIdentifierPath(assignment, (id) => {
+    if (id.node.name === binding.name) {
+      const extra = id.node.extra ??= {};
+      if (binding.upstreamAlias && binding.property !== void 0) {
+        const changePropName = binding.property + "Change";
+        const changeBinding = binding.upstreamAlias.propertyAliases.get(changePropName) || createBinding(
+          generateUid(changePropName),
+          5 /* derived */,
+          binding.section,
+          binding.upstreamAlias,
+          changePropName,
+          id.node.loc,
+          true
+        );
+        extra.assignmentTo = changeBinding;
+        addReadToExpression(id, changeBinding);
+      }
       binding.assignmentSections = sectionUtil.add(
         binding.assignmentSections,
         section
@@ -4676,21 +4724,7 @@ function trackReference(referencePath, binding) {
       prop
     );
   }
-  const fnRoot = getFnRoot(root);
-  const exprRoot = getExprRoot(fnRoot || root);
-  const { section } = addReadToExpression(exprRoot, reference, root.node);
-  if (fnRoot) {
-    const readsByFn = getReadsByFunction();
-    const fnExtra = fnRoot.node.extra ??= {};
-    fnExtra.section = section;
-    readsByFn.set(
-      fnExtra,
-      push(readsByFn.get(fnExtra), {
-        binding: reference,
-        node: root.node
-      })
-    );
-  }
+  addReadToExpression(root, reference);
 }
 var [getMergedReferences] = createProgramState(
   () => /* @__PURE__ */ new Map()
@@ -5138,15 +5172,24 @@ var [getReadsByExpression] = createProgramState(
 var [getReadsByFunction] = createProgramState(
   () => /* @__PURE__ */ new Map()
 );
-function addReadToExpression(path5, binding, node) {
-  const exprExtra = path5.node.extra ??= {};
+function addReadToExpression(root, binding) {
+  const { node } = root;
+  const fnRoot = getFnRoot(root);
+  const exprRoot = getExprRoot(fnRoot || root);
+  const exprExtra = exprRoot.node.extra ??= {};
   const readsByExpression = getReadsByExpression();
-  exprExtra.section = getOrCreateSection(path5);
+  const section = exprExtra.section = getOrCreateSection(exprRoot);
+  const read = { binding, node };
   readsByExpression.set(
     exprExtra,
-    push(readsByExpression.get(exprExtra), { binding, node })
+    push(readsByExpression.get(exprExtra), read)
   );
-  return exprExtra;
+  if (fnRoot) {
+    const readsByFn = getReadsByFunction();
+    const fnExtra = fnRoot.node.extra ??= {};
+    fnExtra.section = section;
+    readsByFn.set(fnExtra, push(readsByFn.get(fnExtra), read));
+  }
 }
 function dropReferences(node) {
   if (Array.isArray(node)) {
@@ -5557,10 +5600,36 @@ function translateVar(tag, initialValue, kind = "const") {
   if (!tagVar) {
     return;
   }
+  forEachIdentifierPath(tag.get("var"), (id) => {
+    const binding = id.node.extra?.binding;
+    if (!binding || !binding.upstreamAlias || !binding.assignmentSections || id.node === tagVar) {
+      return;
+    }
+    const changeName = binding.name + "Change";
+    const changeBinding = binding.upstreamAlias.propertyAliases.get(changeName);
+    if (changeBinding && changeName !== changeBinding.name) {
+      getDestructurePattern(id)?.pushContainer(
+        "properties",
+        import_compiler27.types.objectProperty(
+          import_compiler27.types.identifier(changeName),
+          import_compiler27.types.identifier(changeBinding.name)
+        )
+      );
+    }
+  });
   tag.insertBefore(
     import_compiler27.types.variableDeclaration(kind, [import_compiler27.types.variableDeclarator(tagVar, initialValue)])
   );
 }
+function getDestructurePattern(id) {
+  let cur = id;
+  while (cur) {
+    if (cur.node.type === "ObjectPattern") {
+      return cur;
+    }
+    cur = cur.parentPath;
+  }
+}
 
 // src/translator/core/const.ts
 var const_default = {

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

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

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

@@ -51,6 +51,7 @@ declare module "@marko/compiler/dist/types" {
         referencedBindings?: ReferencedBindings;
         binding?: Binding;
         assignment?: Binding;
+        assignmentTo?: Binding;
         read?: {
             binding: Binding;
             props: Opt<string>;
@@ -86,7 +87,6 @@ export declare function createSources(state: Sources["state"], input: Sources["i
 export declare function compareSources(a: Sources, b: Sources): number;
 export declare function mergeSources(a: undefined | Sources, b: undefined | Sources): Sources | undefined;
 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[];

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

@@ -35,7 +35,7 @@ export declare function getHoistFunctionIdentifier(hoistedBinding: Binding): t.I
 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): t.Expression;
-export declare function subscribe(provider: ReferencedBindings, subscriber: Signal): void;
+export declare function subscribe(references: ReferencedBindings, subscriber: Signal): void;
 export declare function replaceNullishAndEmptyFunctionsWith0(args: (t.Expression | undefined | false)[]): t.Expression[];
 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): void;

package/index.d.ts

@@ -46,7 +46,8 @@ declare global {
       };
 
     /** The result of calling `template.mount`. */
-    export type MountedTemplate<Input = unknown> = {
+    export type MountedTemplate<Input = unknown, Return = unknown> = {
+      value: Return;
       update(input: Marko.TemplateInput<Input>): void;
       destroy(): void;
     };
@@ -95,7 +96,7 @@ declare global {
         input: Marko.TemplateInput<Input>,
         reference: Node,
         position?: "afterbegin" | "afterend" | "beforebegin" | "beforeend",
-      ): Marko.MountedTemplate<typeof input>;
+      ): Marko.MountedTemplate<typeof input, Return>;
       /** @marko-overload-end */
     }
 

package/package.json

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