marko 6.0.10 → 6.0.12

package/dist/translator/index.js

@@ -2909,25 +2909,27 @@ var return_default = {
         const section = getSection(tag);
         const attrs2 = getKnownAttrValues(tag.node);
         if (attrs2.value) {
-          addValue(
+          addStatement(
+            "render",
             section,
             attrs2.value.extra?.referencedBindings,
-            {
-              identifier: importRuntime("tagVarSignal"),
-              hasDownstreamIntersections: () => true
-            },
-            attrs2.value
+            import_compiler17.types.expressionStatement(
+              callRuntime("tagVarSignal", scopeIdentifier, attrs2.value)
+            )
           );
         }
         if (attrs2.valueChange) {
-          addValue(
+          addStatement(
+            "render",
             section,
             attrs2.valueChange.extra?.referencedBindings,
-            {
-              identifier: importRuntime("setTagVarChange"),
-              hasDownstreamIntersections: () => false
-            },
-            attrs2.valueChange
+            import_compiler17.types.expressionStatement(
+              callRuntime(
+                "setTagVarChange",
+                scopeIdentifier,
+                attrs2.valueChange
+              )
+            )
           );
         }
         tag.remove();
@@ -2950,16 +2952,17 @@ var return_default = {
 // src/translator/util/get-defined-binding-expression.ts
 var import_compiler18 = require("@marko/compiler");
 function getDeclaredBindingExpression(binding) {
-  if (binding.declared || !binding.upstreamAlias) {
-    return import_compiler18.types.identifier(binding.name);
-  } else if (binding.property !== void 0) {
+  const canonicalBinding = getCanonicalBinding(binding);
+  if (canonicalBinding.declared || !canonicalBinding.upstreamAlias) {
+    return import_compiler18.types.identifier(canonicalBinding.name);
+  } else if (canonicalBinding.property !== void 0) {
     return toMemberExpression(
-      getDeclaredBindingExpression(binding.upstreamAlias),
-      binding.property,
-      binding.upstreamAlias.nullable
+      getDeclaredBindingExpression(canonicalBinding.upstreamAlias),
+      canonicalBinding.property,
+      canonicalBinding.upstreamAlias.nullable
     );
   } else {
-    return getDeclaredBindingExpression(binding.upstreamAlias);
+    return getDeclaredBindingExpression(canonicalBinding.upstreamAlias);
   }
 }
 
@@ -3066,37 +3069,6 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
         effect: [],
         effectReferencedBindings: void 0,
         subscribers: [],
-        hasDownstreamIntersections: () => {
-          let hasDownstreamIntersections = !!signal.intersection;
-          if (!hasDownstreamIntersections) {
-            for (const value of signal.values) {
-              if (value.signal.hasDownstreamIntersections()) {
-                hasDownstreamIntersections = true;
-                break;
-              }
-            }
-          }
-          if (!hasDownstreamIntersections) {
-            if (!Array.isArray(referencedBindings) && referencedBindings) {
-              for (const alias of referencedBindings.aliases) {
-                if (getSignal(section, alias).hasDownstreamIntersections()) {
-                  hasDownstreamIntersections = true;
-                  break;
-                }
-              }
-              if (!hasDownstreamIntersections) {
-                for (const [, alias] of referencedBindings.propertyAliases) {
-                  if (getSignal(section, alias).hasDownstreamIntersections()) {
-                    hasDownstreamIntersections = true;
-                    break;
-                  }
-                }
-              }
-            }
-          }
-          signal.hasDownstreamIntersections = () => hasDownstreamIntersections;
-          return hasDownstreamIntersections;
-        },
         build: unimplementedBuild,
         export: !!exportName
       }
@@ -3119,17 +3091,18 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
       };
     } else if (referencedBindings.section !== section && bindingUtil.find(section.referencedClosures, referencedBindings)) {
       signal.build = () => {
+        const canonicalClosure = getCanonicalBinding(referencedBindings);
         const render = getSignalFn(signal);
         const closureSignalBuilder = getClosureSignalBuilder(section);
-        return !closureSignalBuilder || isDynamicClosure(section, referencedBindings) ? callRuntime(
+        return !closureSignalBuilder || isDynamicClosure(section, canonicalClosure) ? callRuntime(
           "dynamicClosureRead",
-          getScopeAccessorLiteral(referencedBindings),
+          getScopeAccessorLiteral(canonicalClosure),
           render,
-          isImmediateOwner(section, referencedBindings) ? void 0 : import_compiler20.types.arrowFunctionExpression(
+          isImmediateOwner(section, canonicalClosure) ? void 0 : import_compiler20.types.arrowFunctionExpression(
             [scopeIdentifier],
-            getScopeExpression(section, referencedBindings.section)
+            getScopeExpression(section, canonicalClosure.section)
           )
-        ) : getClosureSignalBuilder(section)(referencedBindings, render);
+        ) : getClosureSignalBuilder(section)(canonicalClosure, render);
       };
     }
   }
@@ -3142,7 +3115,7 @@ function initValue(binding, runtimeHelper = "value") {
     const fn = getSignalFn(signal);
     const isParamBinding = !binding.upstreamAlias && (binding.type === 3 /* param */ || binding.type === 2 /* input */);
     const isNakedAlias = binding.upstreamAlias && !binding.property;
-    const needsGuard = !isNakedAlias && (binding.downstreamExpressions.size || fn.type === "ArrowFunctionExpression" && fn.body.body.length > 0);
+    const needsGuard = !isNakedAlias && (binding.closureSections || binding.downstreamExpressions.size || fn.type === "ArrowFunctionExpression" && fn.body.body.length > 0);
     const needsCache = needsGuard || signal.intersection;
     const needsMarks = isParamBinding || signal.intersection;
     if (needsCache || needsMarks || binding.hoists.size) {
@@ -3171,7 +3144,6 @@ function getSignalFn(signal) {
   const isIntersection = Array.isArray(binding);
   const isBinding = binding && !isIntersection;
   const isValue = isBinding && binding.section === section;
-  let canUseCalleeDirectly = !signal.render.length;
   if (isBinding && (signal.renderReferencedBindings || binding.aliases.size || binding.propertyAliases.size)) {
     const valueParam = import_compiler20.types.identifier(binding.name);
     if (binding.loc) {
@@ -3184,15 +3156,17 @@ function getSignalFn(signal) {
   if (isValue) {
     for (const alias of binding.aliases) {
       const aliasSignal = getSignal(alias.section, alias);
-      signal.render.push(
-        import_compiler20.types.expressionStatement(
-          import_compiler20.types.callExpression(aliasSignal.identifier, [
-            scopeIdentifier,
-            import_compiler20.types.identifier(binding.name),
-            ...getTranslatedExtraArgs(aliasSignal)
-          ])
-        )
-      );
+      if (aliasSignal.render.length || aliasSignal.values.length || aliasSignal.effect.length) {
+        signal.render.push(
+          import_compiler20.types.expressionStatement(
+            import_compiler20.types.callExpression(aliasSignal.identifier, [
+              scopeIdentifier,
+              import_compiler20.types.identifier(binding.name),
+              ...getTranslatedExtraArgs(aliasSignal)
+            ])
+          )
+        );
+      }
     }
     for (const [key, alias] of binding.propertyAliases) {
       const aliasSignal = getSignal(alias.section, alias);
@@ -3212,26 +3186,31 @@ function getSignalFn(signal) {
     }
   }
   for (const value of signal.values) {
-    signal.render.push(
-      import_compiler20.types.expressionStatement(
-        import_compiler20.types.callExpression(value.signal.identifier, [
-          value.scope,
-          value.value,
-          ...getTranslatedExtraArgs(value.signal)
-        ])
-      )
-    );
+    const valSignal = value.signal;
+    if (!valSignal.referencedBindings || Array.isArray(valSignal.referencedBindings) || !valSignal.referencedBindings.upstreamAlias || valSignal.referencedBindings.property || valSignal.effect.length || valSignal.render.length || valSignal.values.length) {
+      signal.render.push(
+        import_compiler20.types.expressionStatement(
+          import_compiler20.types.callExpression(value.signal.identifier, [
+            scopeIdentifier,
+            value.value,
+            ...getTranslatedExtraArgs(value.signal)
+          ])
+        )
+      );
+    } else {
+      signal.render.push(import_compiler20.types.expressionStatement(value.value));
+    }
   }
   forEach(signal.intersection, (intersection) => {
     signal.render.push(
       import_compiler20.types.expressionStatement(import_compiler20.types.callExpression(intersection, [scopeIdentifier]))
     );
   });
-  if (isValue) {
+  if (isValue && binding.sources) {
     let dynamicClosureArgs;
     let dynamicClosureSignalIdentifier;
-    forEach(binding.closureSections, (closureSection) => {
-      if (binding.sources) {
+    if (binding.sources) {
+      forEach(binding.closureSections, (closureSection) => {
         if (isDynamicClosure(closureSection, binding)) {
           if (!dynamicClosureArgs) {
             dynamicClosureArgs = [];
@@ -3258,17 +3237,17 @@ function getSignalFn(signal) {
             )
           );
         }
+      });
+      if (dynamicClosureSignalIdentifier) {
+        (signal.prependStatements ||= []).push(
+          import_compiler20.types.variableDeclaration("const", [
+            import_compiler20.types.variableDeclarator(
+              dynamicClosureSignalIdentifier,
+              callRuntime("dynamicClosure", ...dynamicClosureArgs)
+            )
+          ])
+        );
       }
-    });
-    if (dynamicClosureSignalIdentifier) {
-      (signal.prependStatements ||= []).push(
-        import_compiler20.types.variableDeclaration("const", [
-          import_compiler20.types.variableDeclarator(
-            dynamicClosureSignalIdentifier,
-            callRuntime("dynamicClosure", ...dynamicClosureArgs)
-          )
-        ])
-      );
     }
   }
   if (signal.effect.length) {
@@ -3289,22 +3268,22 @@ function getSignalFn(signal) {
       ])
     );
   }
-  if (canUseCalleeDirectly && signal.render.length === 1) {
+  if (signal.render.length === 1) {
     const render = signal.render[0];
     if (render.type === "ExpressionStatement") {
       const { expression } = render;
       if (expression.type === "CallExpression") {
         const args = expression.arguments;
         if (params.length >= args.length) {
-          for (let i = args.length; i--; ) {
+          let i = args.length;
+          for (; i--; ) {
             const param = params[i];
             const arg = args[i];
             if (arg.type !== "Identifier" || param.name !== arg.name) {
-              canUseCalleeDirectly = false;
               break;
             }
           }
-          if (canUseCalleeDirectly) {
+          if (i === -1) {
             return expression.callee;
           }
         }
@@ -3404,13 +3383,12 @@ function addRenderReferences(signal, referencedBindings) {
     referencedBindings
   );
 }
-function addValue(targetSection, referencedBindings, signal, value, scope = scopeIdentifier) {
+function addValue(targetSection, referencedBindings, signal, value) {
   const parentSignal = getSignal(targetSection, referencedBindings);
   addRenderReferences(parentSignal, referencedBindings);
   parentSignal.values.push({
     signal,
-    value,
-    scope
+    value
   });
 }
 function getResumeRegisterId(section, referencedBindings, type) {
@@ -3535,6 +3513,14 @@ function writeSignals(section) {
       );
     }
     let value = signal.build();
+    if (
+      // It's possible for aliases to render nothing
+      // if they're only consumed in effects/closures.
+      // This ignores writing out those signals in that case.
+      signal.referencedBindings && !Array.isArray(signal.referencedBindings) && signal.referencedBindings.upstreamAlias && !signal.referencedBindings.property && import_compiler20.types.isFunction(value) && import_compiler20.types.isBlockStatement(value.body) && !value.body.body.length
+    ) {
+      continue;
+    }
     if (import_compiler20.types.isCallExpression(value)) {
       replaceNullishAndEmptyFunctionsWith0(value.arguments);
     }
@@ -4403,14 +4389,24 @@ function createBinding(name2, type, section, upstreamAlias, property, loc = null
 function trackVarReferences(tag, type, upstreamAlias) {
   const tagVar = tag.node.var;
   if (tagVar) {
-    const section = getOrCreateSection(tag);
     const canonicalUpstreamAlias = getCanonicalBinding(upstreamAlias);
+    if (canonicalUpstreamAlias) {
+      createBindingsAndTrackReferences(
+        tagVar,
+        canonicalUpstreamAlias.type,
+        tag.scope,
+        canonicalUpstreamAlias.section,
+        canonicalUpstreamAlias,
+        void 0
+      );
+      return canonicalUpstreamAlias;
+    }
     createBindingsAndTrackReferences(
       tagVar,
-      upstreamAlias ? upstreamAlias.type : type,
+      type,
       tag.scope,
-      section,
-      canonicalUpstreamAlias,
+      getOrCreateSection(tag),
+      void 0,
       void 0
     );
     return tagVar.extra?.binding;
@@ -4419,13 +4415,19 @@ function trackVarReferences(tag, type, upstreamAlias) {
 function trackParamsReferences(body, type, upstreamAlias) {
   const params = body.node.params;
   if (body.node.body.length && params.length) {
-    const section = getOrCreateSection(body);
     const canonicalUpstreamAlias = getCanonicalBinding(upstreamAlias);
+    let section;
+    if (canonicalUpstreamAlias) {
+      section = canonicalUpstreamAlias.section;
+      type = canonicalUpstreamAlias.type;
+    } else {
+      section = getOrCreateSection(body);
+    }
     const paramsBinding = canonicalUpstreamAlias || ((body.node.extra ??= {}).binding = createBinding(
       generateUid("params"),
       type,
       section,
-      canonicalUpstreamAlias,
+      void 0,
       void 0
     ));
     section.params = paramsBinding;
@@ -4774,8 +4776,9 @@ function finalizeReferences() {
       section: section2
     } of binding.downstreamExpressions) {
       if (section2 !== binding.section) {
-        binding.closureSections = sectionUtil.add(
-          binding.closureSections,
+        const canonicalUpstreamAlias = getCanonicalBinding(binding);
+        canonicalUpstreamAlias.closureSections = sectionUtil.add(
+          canonicalUpstreamAlias.closureSections,
           section2
         );
         section2.referencedClosures = bindingUtil.add(
@@ -4784,8 +4787,8 @@ function finalizeReferences() {
         );
         addOwnersSerializeReason(
           section2,
-          binding.section,
-          binding.sources,
+          canonicalUpstreamAlias.section,
+          !!isEffect || canonicalUpstreamAlias.sources,
           getAccessorProp().Owner
         );
       }
@@ -5130,18 +5133,20 @@ function getAllTagReferenceNodes(tag, referenceNodes = []) {
   return referenceNodes;
 }
 function getScopeAccessorLiteral(binding, includeId) {
+  const canonicalBinding = getCanonicalBinding(binding);
   if (isOptimize()) {
-    return import_compiler24.types.numericLiteral(binding.id);
+    return import_compiler24.types.numericLiteral(canonicalBinding.id);
   }
   return import_compiler24.types.stringLiteral(
-    binding.name + (includeId || binding.type === 0 /* dom */ ? `/${binding.id}` : "")
+    canonicalBinding.name + (includeId || canonicalBinding.type === 0 /* dom */ ? `/${canonicalBinding.id}` : "")
   );
 }
 function getScopeAccessor(binding, includeId) {
+  const canonicalBinding = getCanonicalBinding(binding);
   if (isOptimize()) {
-    return binding.id + "";
+    return canonicalBinding.id + "";
   }
-  return binding.name + (includeId || binding.type === 0 /* dom */ ? `/${binding.id}` : "");
+  return canonicalBinding.name + (includeId || canonicalBinding.type === 0 /* dom */ ? `/${canonicalBinding.id}` : "");
 }
 function getDebugScopeAccess(binding) {
   let root = binding;
@@ -6786,25 +6791,6 @@ var for_default = {
             import_compiler33.types.identifier(bodySection.name)
           );
         };
-        const params = node.body.params;
-        signal.hasDownstreamIntersections = () => {
-          for (const param of params) {
-            const binding = param.extra?.binding;
-            if (binding) {
-              for (const {
-                referencedBindings: referencedBindings2
-              } of binding.downstreamExpressions) {
-                if (getSignal(
-                  bodySection,
-                  referencedBindings2
-                ).hasDownstreamIntersections()) {
-                  return true;
-                }
-              }
-            }
-          }
-          return false;
-        };
         const forAttrs = getKnownAttrValues(node);
         const loopArgs = getBaseArgsInForTag(forType, forAttrs);
         if (forAttrs.by) {
@@ -9531,7 +9517,6 @@ var try_default = {
           signal,
           propsToExpression(translatedAttrs.properties)
         );
-        signal.hasDownstreamIntersections = () => true;
         tag.remove();
       }
     }
@@ -10298,20 +10283,6 @@ function translateDOM(tag) {
     tagName
   );
   const inputExport = childExports.input;
-  if (inputExport) {
-    writeAttrsToExports(tag, inputExport, `${getTagName(tag) || "tag"}_input`, {
-      circular: childFile.opts.filename === file.opts.filename,
-      tagSection,
-      relativePath,
-      childScopeBinding,
-      attrTagCallsByTag: void 0
-    });
-  }
-  write2`${(0, import_babel_utils47.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
-  injectWalks(
-    tag,
-    (0, import_babel_utils47.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
-  );
   if (node.var) {
     const source = initValue(
       // TODO: support destructuring
@@ -10348,6 +10319,20 @@ function translateDOM(tag) {
       ])
     )
   );
+  if (inputExport) {
+    writeAttrsToExports(tag, inputExport, `${getTagName(tag) || "tag"}_input`, {
+      circular: childFile.opts.filename === file.opts.filename,
+      tagSection,
+      relativePath,
+      childScopeBinding,
+      attrTagCallsByTag: void 0
+    });
+  }
+  write2`${(0, import_babel_utils47.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
+  injectWalks(
+    tag,
+    (0, import_babel_utils47.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
+  );
   tag.remove();
 }
 function getTagRelativePath(tag) {
@@ -10502,14 +10487,18 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       templateExport.id,
       importAlias
     );
-    addValue(
+    addStatement(
+      "render",
       info.tagSection,
       // technically this should be `arg.extra?.referencedBindings`
       // but we should probably ensure all other references are dropped in this case before we do that.
       tag.node.extra?.referencedBindings,
-      identifierToSignal(tagInputIdentifier),
-      import_compiler56.types.isSpreadElement(arg) ? import_compiler56.types.memberExpression(arg.argument, import_compiler56.types.numericLiteral(0), true) : arg,
-      createScopeReadExpression(info.tagSection, info.childScopeBinding)
+      import_compiler56.types.expressionStatement(
+        import_compiler56.types.callExpression(tagInputIdentifier, [
+          createScopeReadExpression(info.tagSection, info.childScopeBinding),
+          import_compiler56.types.isSpreadElement(arg) ? import_compiler56.types.memberExpression(arg.argument, import_compiler56.types.numericLiteral(0), true) : arg
+        ])
+      )
     );
     return;
   }
@@ -10565,12 +10554,16 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         translatedProps = callRuntime("attrTag", translatedProps);
       }
     }
-    addValue(
+    addStatement(
+      "render",
       info.tagSection,
       referencedBindings,
-      identifierToSignal(tagInputIdentifier),
-      translatedProps,
-      createScopeReadExpression(info.tagSection, info.childScopeBinding)
+      import_compiler56.types.expressionStatement(
+        import_compiler56.types.callExpression(tagInputIdentifier, [
+          createScopeReadExpression(info.tagSection, info.childScopeBinding),
+          translatedProps
+        ])
+      )
     );
     return;
   }
@@ -10642,18 +10635,25 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
           `${importAlias}_${attrTagMeta.name}`
         );
         decls.push(import_compiler56.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
-        addValue(
+        addStatement("render", info.tagSection, referencedBindings, [
+          import_compiler56.types.variableDeclaration("let", decls),
+          ...statements
+        ]);
+        addStatement(
+          "render",
           info.tagSection,
           referencedBindings,
-          identifierToSignal(attrExportIdentifier),
-          getAttrTagIdentifier(attrTagMeta),
-          createScopeReadExpression(info.tagSection, info.childScopeBinding)
+          import_compiler56.types.expressionStatement(
+            import_compiler56.types.callExpression(attrExportIdentifier, [
+              createScopeReadExpression(
+                info.tagSection,
+                info.childScopeBinding
+              ),
+              getAttrTagIdentifier(attrTagMeta)
+            ])
+          )
         );
       }
-      addStatement("render", info.tagSection, referencedBindings, [
-        import_compiler56.types.variableDeclaration("let", decls),
-        ...statements
-      ]);
     }
   }
   const bodySection = tag.node.body.extra?.section;
@@ -10666,13 +10666,17 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         templateExport.props.content.id,
         `${importAlias}_content`
       );
-      addValue(
+      addStatement(
+        "render",
         info.tagSection,
         void 0,
         // TODO: pretty sure content needs to have the reference group of it's param defaults.
-        identifierToSignal(contentExportIdentifier),
-        import_compiler56.types.callExpression(import_compiler56.types.identifier(bodySection.name), [scopeIdentifier]),
-        createScopeReadExpression(info.tagSection, info.childScopeBinding)
+        import_compiler56.types.expressionStatement(
+          import_compiler56.types.callExpression(contentExportIdentifier, [
+            createScopeReadExpression(info.tagSection, info.childScopeBinding),
+            import_compiler56.types.callExpression(import_compiler56.types.identifier(bodySection.name), [scopeIdentifier])
+          ])
+        )
       );
     }
   }
@@ -10704,12 +10708,16 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       childAttrExports.id,
       `${importAlias}_${attr2.name}`
     );
-    addValue(
+    addStatement(
+      "render",
       info.tagSection,
       attr2.value.extra?.referencedBindings,
-      identifierToSignal(attrExportIdentifier),
-      attr2.value,
-      createScopeReadExpression(info.tagSection, info.childScopeBinding)
+      import_compiler56.types.expressionStatement(
+        import_compiler56.types.callExpression(attrExportIdentifier, [
+          createScopeReadExpression(info.tagSection, info.childScopeBinding),
+          attr2.value
+        ])
+      )
     );
   }
   const missing = new Set(Object.keys(templateExport.props));
@@ -10735,12 +10743,16 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         childAttrExports.id,
         `${importAlias}_${name2}`
       );
-      addValue(
+      addStatement(
+        "render",
         info.tagSection,
         referencedBindings,
-        identifierToSignal(attrExportIdentifier),
-        getMissingPropValue(name2),
-        createScopeReadExpression(info.tagSection, info.childScopeBinding)
+        import_compiler56.types.expressionStatement(
+          import_compiler56.types.callExpression(attrExportIdentifier, [
+            createScopeReadExpression(info.tagSection, info.childScopeBinding),
+            getMissingPropValue(name2)
+          ])
+        )
       );
     }
   }
@@ -10791,18 +10803,9 @@ function callStatement(id, ...args) {
 function callExpression(id, ...args) {
   return import_compiler56.types.callExpression(id, args.filter(Boolean));
 }
-function identifierToSignal(identifier) {
-  return {
-    identifier,
-    hasDownstreamIntersections: always
-  };
-}
 function buildUndefined2() {
   return import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0));
 }
-function always() {
-  return true;
-}
 
 // src/translator/visitors/tag/dynamic-tag.ts
 var import_compiler57 = require("@marko/compiler");
@@ -11031,7 +11034,6 @@ var dynamic_tag_default = {
             ];
           }
         }
-        signal.hasDownstreamIntersections = () => true;
         addValue(section, tagExtra.referencedBindings, signal, tagExpression);
         tag.remove();
       }

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

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

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

@@ -11,21 +11,14 @@ export type Signal = {
     build: () => t.Expression;
     register?: boolean;
     values: Array<{
-        signal: {
-            identifier: t.Identifier | t.MemberExpression;
-            hasDownstreamIntersections: () => boolean;
-            buildDeclaration?: () => t.VariableDeclaration;
-            extraArgs?: t.Expression[];
-        };
+        signal: Signal;
         value: t.Expression;
-        scope: t.Expression;
     }>;
     intersection: Opt<t.Expression>;
     render: t.Statement[];
     renderReferencedBindings: ReferencedBindings;
     effect: t.Statement[];
     effectReferencedBindings: ReferencedBindings;
-    hasDownstreamIntersections: () => boolean;
     hasDynamicSubscribers?: true;
     export: boolean;
     extraArgs?: t.Expression[];
@@ -41,15 +34,10 @@ export declare const getHTMLSectionStatements: (section: Section) => t.Statement
 export declare function getHoistFunctionIdentifier(hoistedBinding: Binding): t.Identifier;
 export declare function getSignal(section: Section, referencedBindings: ReferencedBindings, name?: string): Signal;
 export declare function initValue(binding: Binding, runtimeHelper?: "value" | "state"): Signal;
-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 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, scope?: t.Expression): void;
+export declare function addValue(targetSection: Section, referencedBindings: ReferencedBindings, signal: Signal["values"][number]["signal"], value: 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;