tutuca 0.9.78 → 0.9.80

package/dist/tutuca-dev.ext.js

@@ -477,6 +477,7 @@ var G_BOOL = K_FIELD | K_METHOD | K_BIND | K_DYN | K_CONST;
 var G_TEXT = G_BOOL | K_STRTPL;
 var G_COMPONENT = K_FIELD | K_SEQ | K_DYN;
 var G_SEQUENCE = K_FIELD | K_DYN;
+var G_PROVIDE = K_FIELD | K_SEQ;
 var G_FIELD = K_FIELD | K_METHOD | K_CONST | K_STR | K_SEQ;
 var G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_REQUEST | K_CONST;
 var G_PRED_ARG = G_BOOL | K_STR;
@@ -595,6 +596,9 @@ class ValParser {
   parseField(s, px) {
     return this._parseSingle(s, px, G_FIELD);
   }
+  parseProvide(s, px) {
+    return this._parseSingle(s, px, G_PROVIDE);
+  }
   parseHandlerArg(s, px) {
     return this._parseSingle(s, px, G_HANDLER_ARG);
   }
@@ -1581,21 +1585,22 @@ function h(tagName, properties, children, namespace) {
 }
 
 // src/anode.js
-function resolveDynProducer(comp, dynName) {
-  const dyn = comp?.dynamic?.[dynName];
-  if (dyn == null)
-    return null;
-  let producerComp, producerDyn;
-  if (dyn.compName != null) {
-    producerComp = comp.scope?.lookupComponent(dyn.compName);
-    producerDyn = producerComp?.dynamic?.[dyn.dynName];
+function resolveDynProducer(comp, name) {
+  let producerComp, producerProvide;
+  const lk = comp?.lookup?.[name];
+  if (lk != null) {
+    producerComp = comp.scope?.lookupComponent(lk.compName);
+    producerProvide = producerComp?.provide?.[lk.provideName];
   } else {
+    const p = comp?.provide?.[name];
+    if (p == null)
+      return null;
     producerComp = comp;
-    producerDyn = dyn;
+    producerProvide = p;
   }
-  if (producerComp == null || producerDyn == null)
+  if (producerComp == null || producerProvide == null)
     return null;
-  const pi = producerDyn.val?.toPathItem?.() ?? null;
+  const pi = producerProvide.val?.toPathItem?.() ?? null;
   return { producerCompId: producerComp.id, producerSteps: pi ? [pi] : [] };
 }
 
@@ -4720,7 +4725,7 @@ function closestName(name, candidates, maxDistance = 2) {
 }
 
 // tools/core/lint-check.js
-var KNOWN_COMPONENT_SPEC_KEYS = new Set("name view style commonStyle globalStyle input receive bubble response alter on views dynamic fields methods statics".split(" "));
+var KNOWN_COMPONENT_SPEC_KEYS = new Set("name view style commonStyle globalStyle input receive bubble response alter views provide lookup fields methods statics".split(" "));
 var EMPTY_SET = new Set;
 var KNOWN_DIRECTIVE_NAMES = new Set([
   "dangerouslysetinnerhtml",
@@ -4740,6 +4745,9 @@ var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
 var ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED";
 var DYN_VAL_NOT_DEFINED = "DYN_VAL_NOT_DEFINED";
 var DYN_ALIAS_NOT_REFERENCED = "DYN_ALIAS_NOT_REFERENCED";
+var PROVIDE_NOT_ADDRESSABLE = "PROVIDE_NOT_ADDRESSABLE";
+var LOOKUP_BAD_SHAPE = "LOOKUP_BAD_SHAPE";
+var LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED";
 var RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
 var UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
 var UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
@@ -4826,8 +4834,6 @@ function classifyBadValue(value) {
   const s = value.trim();
   if (s === "")
     return null;
-  if (/\{[^}]*\}/.test(s) && !s.startsWith("$'"))
-    return "legacy-template";
   if (/\s\?\s.+\s:\s/.test(s))
     return "ternary";
   if (/===|!==|==|!=|<=|>=|\s<\s|\s>\s/.test(s))
@@ -4839,7 +4845,6 @@ function classifyBadValue(value) {
   return null;
 }
 var UNSUPPORTED_EXPR_GUIDANCE = {
-  "legacy-template": "Unquoted {...} string templates are no longer supported. Wrap the value in $'...', e.g. $'flex {.color}'.",
   ternary: "Ternary expressions aren't supported in dynamic attributes. Define a method or computed field on the component that returns the value, then reference it as '$methodName'.",
   comparison: "Comparisons aren't supported in dynamic attributes. Define a method like 'isFooSelected' that returns the boolean, then reference it as '$isFooSelected'.",
   logical: "Logical operators aren't supported in dynamic attributes. Combine the conditions in a method on the component and reference it as '$methodName'.",
@@ -4849,6 +4854,8 @@ function checkComponent(Comp, lx = new LintContext, { wellKnownExtras = EMPTY_SE
   return lx.push({ componentName: Comp.name }, () => {
     checkUnknownSpecKeys(lx, Comp, wellKnownExtras);
     checkFieldDeclarations(lx, Comp);
+    checkProvidesAreAddressable(lx, Comp);
+    checkLookupShapes(lx, Comp);
     const referencedAlters = new Set;
     const referencedInputs = new Set;
     const referencedDynamics = new Set;
@@ -5029,10 +5036,11 @@ function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedDyna
   }
 }
 function mkAttrValEnv(Comp, referencedAlters, referencedDynamics) {
-  const { scope, alter, dynamic, Class } = Comp;
+  const { scope, alter, provide, lookup, Class } = Comp;
   const { prototype: proto } = Class;
   const { fields } = Class.getMetaClass();
-  return { fields, proto, scope, alter, referencedAlters, dynamicMap: dynamic, referencedDynamics };
+  const dynamicMap = { ...provide, ...lookup };
+  return { fields, proto, scope, alter, referencedAlters, dynamicMap, referencedDynamics };
 }
 function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
   const { input, views, Class } = Comp;
@@ -5346,10 +5354,51 @@ function checkUnreferencedInputHandlers(lx, Comp, referencedInputs) {
     }
   }
 }
+function checkProvidesAreAddressable(lx, Comp) {
+  for (const name in Comp._rawProvide) {
+    if (Comp.provide[name] === undefined) {
+      lx.error(PROVIDE_NOT_ADDRESSABLE, { name, value: Comp._rawProvide[name] });
+    }
+  }
+}
+var KNOWN_LOOKUP_KEYS = new Set(["for", "default"]);
+function checkLookupShapes(lx, Comp) {
+  for (const name in Comp._rawLookup) {
+    const raw = Comp._rawLookup[name];
+    let target;
+    if (typeof raw === "string") {
+      target = raw;
+    } else if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      lx.error(LOOKUP_BAD_SHAPE, {
+        name,
+        problem: 'must be a "Producer.provideName" string or a { for, default } object'
+      });
+      continue;
+    } else {
+      const extra = Object.keys(raw).filter((k) => !KNOWN_LOOKUP_KEYS.has(k));
+      if (extra.length > 0) {
+        lx.error(LOOKUP_BAD_SHAPE, { name, problem: `unknown key(s): ${extra.join(", ")}` });
+        continue;
+      }
+      if (typeof raw.for !== "string") {
+        lx.error(LOOKUP_BAD_SHAPE, { name, problem: "'for' is required and must be a string" });
+        continue;
+      }
+      if (raw.default !== undefined && typeof raw.default !== "string") {
+        lx.error(LOOKUP_BAD_SHAPE, { name, problem: "'default' must be a string" });
+        continue;
+      }
+      target = raw.for;
+    }
+    const parts = target.split(".");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      lx.error(LOOKUP_TARGET_MALFORMED, { name, target });
+    }
+  }
+}
 function checkUnreferencedDynamics(lx, Comp, referencedDynamics) {
-  for (const name in Comp.dynamic) {
-    const dyn = Comp.dynamic[name];
-    if (dyn.constructor.name === "DynamicAlias" && !referencedDynamics.has(name)) {
+  for (const name in Comp.lookup) {
+    if (!referencedDynamics.has(name)) {
       lx.hint(DYN_ALIAS_NOT_REFERENCED, { name });
     }
   }
@@ -5831,7 +5880,6 @@ function reportTestReportToConsole(report) {
 
 // tools/format/lint.js
 var UNSUPPORTED_EXPR_LABEL = {
-  "legacy-template": "string template",
   ternary: "ternary expression",
   comparison: "comparison",
   logical: "logical expression",
@@ -5951,7 +5999,13 @@ function lintIdToMessage(id, info) {
     case "DYN_VAL_NOT_DEFINED":
       return `Dynamic variable '*${info.name}' is not defined${fmtOriginSuffix(info)}`;
     case "DYN_ALIAS_NOT_REFERENCED":
-      return `Dynamic '${info.name}' is defined but never used — remove it or reference it as '*${info.name}' in a view`;
+      return `Lookup '${info.name}' is defined but never used — remove it or reference it as '*${info.name}' in a view`;
+    case "PROVIDE_NOT_ADDRESSABLE":
+      return `Provide '${info.name}' value '${info.value}' must be a field ('.f') or seq-access ('.s[.k]') — a method/constant can't be a render target`;
+    case "LOOKUP_BAD_SHAPE":
+      return `Lookup '${info.name}' has an invalid shape: ${info.problem}`;
+    case "LOOKUP_TARGET_MALFORMED":
+      return `Lookup '${info.name}' target '${info.target}' must be 'Producer.provideName' (a string, or the 'for' of { for, default })`;
     case "UNKNOWN_MACRO_ARG":
       return `Argument '${info.name}' is not declared in macro '${info.macroName}'`;
     case "UNKNOWN_DIRECTIVE":
@@ -6081,9 +6135,6 @@ class Components {
   getCompFor(v) {
     return v?.[this.getComponentSymbol]?.() ?? null;
   }
-  getOnEnterFor(v) {
-    return this.getCompFor(v)?.on.stackEnter ?? defaultOnStackEnter;
-  }
   getHandlerFor(v, name, key) {
     return this.getCompFor(v)?.[key][name] ?? null;
   }
@@ -6153,36 +6204,30 @@ class ComponentStack {
   }
 }
 
-class Dynamic {
+class ProvideInfo {
   constructor(name, val, symbol) {
     this.name = name;
     this.val = val;
     this.symbol = symbol;
   }
-  getSymbol(_stack) {
-    return this.symbol;
-  }
-  evalAndBind(stack, binds) {
-    binds[this.getSymbol(stack)] = this.val.eval(stack);
-  }
 }
 
-class DynamicAlias extends Dynamic {
-  constructor(name, val, compName, dynName) {
-    super(name, val, null);
+class LookupInfo {
+  constructor(name, compName, provideName, val) {
+    this.name = name;
     this.compName = compName;
-    this.dynName = dynName;
-  }
-  _resolveSymbol(stack) {
-    return stack.lookupType(this.compName)?.dynamic[this.dynName]?.symbol ?? null;
+    this.provideName = provideName;
+    this.val = val;
+    this._sym = undefined;
   }
-  getSymbol(stack) {
-    this.symbol ??= this._resolveSymbol(stack);
-    return this.symbol;
+  getProducerSymbol(stack) {
+    if (this._sym === undefined)
+      this._sym = stack.lookupType(this.compName)?.provide?.[this.provideName]?.symbol ?? null;
+    return this._sym;
   }
 }
 var isString = (v) => typeof v === "string";
-var _rawSpecKeys = "name view style commonStyle globalStyle input receive bubble response alter on views dynamic fields methods statics";
+var _rawSpecKeys = "name view style commonStyle globalStyle input receive bubble response alter views provide lookup fields methods statics";
 var KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
 var _compId = 0;
 
@@ -6199,35 +6244,47 @@ class Component {
     this.bubble = o.bubble ?? {};
     this.response = o.response ?? {};
     this.alter = o.alter ?? {};
-    this.on = { stackEnter: o.on?.stackEnter ?? defaultOnStackEnter };
     for (const name in o.views ?? {}) {
       const v = o.views[name];
       const { view, style } = isString(v) ? { view: v } : v;
       this.views[name] = new View(name, view, style);
     }
-    this._rawDynamic = o.dynamic ?? {};
-    this.dynamic = {};
+    this._rawProvide = o.provide ?? {};
+    this._rawLookup = o.lookup ?? {};
+    this.provide = {};
+    this.lookup = {};
     this.scope = null;
+    this.spec = o;
     this.extra = {};
     for (const key of Object.keys(o))
       if (!KNOWN_SPEC_KEYS.has(key))
         this.extra[key] = o[key];
   }
+  clone() {
+    return Component.fromSpec(this.spec);
+  }
   compile(ParseContext2) {
     for (const name in this.views)
       this.views[name].compile(new ParseContext2, this.scope, this.id);
-    for (const key in this._rawDynamic) {
-      const dinfo = this._rawDynamic[key];
-      if (isString(dinfo)) {
-        const val = vp.parseField(dinfo, this.views.main.ctx);
-        this.dynamic[key] = new Dynamic(key, val, Symbol(key));
-      } else if (isString(dinfo?.default) && isString(dinfo?.for)) {
-        const val = vp.parseField(dinfo.default, this.views.main.ctx);
-        const [compName, dynName] = dinfo.for.split(".");
-        if (isString(compName) && isString(dynName))
-          this.dynamic[key] = new DynamicAlias(key, val, compName, dynName);
-      }
+    const ctx = this.views.main.ctx;
+    for (const key in this._rawProvide) {
+      const val = vp.parseProvide(this._rawProvide[key], ctx);
+      if (val)
+        this.provide[key] = new ProvideInfo(key, val, Symbol(key));
+    }
+    for (const key in this._rawLookup) {
+      const linfo = this._rawLookup[key];
+      const forStr = isString(linfo) ? linfo : isString(linfo?.for) ? linfo.for : null;
+      const [compName, provideName] = forStr === null ? [] : forStr.split(".");
+      if (!isString(compName) || !isString(provideName))
+        continue;
+      const defStr = isString(linfo?.default) ? linfo.default : null;
+      const val = defStr === null ? null : vp.parseField(defStr, ctx);
+      this.lookup[key] = new LookupInfo(key, compName, provideName, val);
     }
+    for (const key in this.lookup)
+      if (this.provide[key] !== undefined)
+        console.warn("name declared in both provide and lookup", this.name, key);
   }
   make(args, opts) {
     return this.Class.make(args, opts ?? { scope: this.scope });
@@ -6255,9 +6312,6 @@ class Component {
 `);
   }
 }
-function defaultOnStackEnter() {
-  return null;
-}
 
 // src/stack.js
 var STOP = Symbol("STOP");
@@ -6316,47 +6370,61 @@ class Stack {
     this.viewsId = viewsId;
     this.ctx = ctx;
   }
-  _enrichOnEnter() {
-    return this.withDynamicBinds(this.comps.getOnEnterFor(this.it).call(this.it));
+  _pushProvides() {
+    const provide = this.comps.getCompFor(this.it)?.provide;
+    if (provide == null)
+      return this;
+    const dynObj = {};
+    let has = false;
+    for (const k in provide) {
+      dynObj[provide[k].symbol] = provide[k].val.eval(this);
+      has = true;
+    }
+    if (!has)
+      return this;
+    const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
+    const { comps, it, binds, views, viewsId, ctx } = this;
+    return new Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
   }
   static root(comps, it, ctx) {
     const binds = [new BindFrame(it, { it }, true), null];
     const dynBinds = [new ObjectFrame({}), null];
     const views = ["main", null];
-    return new Stack(comps, it, binds, dynBinds, views, "", ctx)._enrichOnEnter();
+    return new Stack(comps, it, binds, dynBinds, views, "", ctx)._pushProvides();
   }
   enter(it, bindings = {}, isFrame = true) {
     const { comps, binds, dynBinds, views, viewsId, ctx } = this;
     const newBinds = [new BindFrame(it, bindings, isFrame), binds];
     const stack = new Stack(comps, it, newBinds, dynBinds, views, viewsId, ctx);
-    return isFrame ? stack._enrichOnEnter() : stack;
+    return isFrame ? stack._pushProvides() : stack;
   }
   pushViewName(name) {
     const { comps, it, binds, dynBinds, views, ctx } = this;
     const newViews = [name, views];
     return new Stack(comps, it, binds, dynBinds, newViews, computeViewsId(newViews), ctx);
   }
-  withDynamicBinds(dynamics) {
-    if (dynamics == null || dynamics.length === 0)
-      return this;
-    const dynObj = {};
-    const comp = this.comps.getCompFor(this.it);
-    for (const dynName of dynamics)
-      comp.dynamic[dynName].evalAndBind(this, dynObj);
-    const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
-    const { comps, it, binds, views, viewsId, ctx } = this;
-    return new Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
+  _pushDynBindValuesToArray(arr, comp) {
+    for (const k in comp.provide)
+      arr.push(this._lookupProvide(comp.provide[k]));
+    for (const k in comp.lookup)
+      arr.push(this._lookupAlias(comp.lookup[k]));
   }
-  _pushDynBindValuesToArray(arr, dyns) {
-    for (const k in dyns)
-      arr.push(this._lookupDynamicWithDynVal(dyns[k]));
+  _lookupProvide(p) {
+    return lookup(this.dynBinds, p.symbol) ?? p.val.eval(this) ?? null;
   }
-  _lookupDynamicWithDynVal(d) {
-    return lookup(this.dynBinds, d.getSymbol(this)) ?? d.val?.eval(this) ?? null;
+  _lookupAlias(lk) {
+    const sym = lk.getProducerSymbol(this);
+    return (sym != null ? lookup(this.dynBinds, sym) : null) ?? lk.val?.eval(this) ?? null;
   }
   lookupDynamic(name) {
-    const d = this.comps.getCompFor(this.it)?.dynamic[name];
-    return d ? this._lookupDynamicWithDynVal(d) : null;
+    const comp = this.comps.getCompFor(this.it);
+    if (comp == null)
+      return null;
+    const lk = comp.lookup[name];
+    if (lk !== undefined)
+      return this._lookupAlias(lk);
+    const p = comp.provide[name];
+    return p !== undefined ? this._lookupProvide(p) : null;
   }
   lookupBind(name) {
     return lookup(this.binds, name);
@@ -7391,7 +7459,8 @@ function classFromData(name, { fields = {}, methods, statics }) {
     b.statics(statics);
   return b.build();
 }
-var component = (opts) => new Component(classFromData(opts.name, opts), opts);
+Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
+var component = (opts) => Component.fromSpec(opts);
 
 // src/renderer.js
 import { isIndexed, isKeyed } from "immutable";
@@ -7513,7 +7582,7 @@ class Renderer {
   _rValComp(stack, val, comp, node, key, viewName) {
     const cacheKey = `${viewName ?? stack.viewsId ?? ""}-${key}`;
     const cachePath = [node, val];
-    stack._pushDynBindValuesToArray(cachePath, comp.dynamic);
+    stack._pushDynBindValuesToArray(cachePath, comp);
     const cachedNode = this.cache.get(cachePath, cacheKey);
     if (cachedNode)
       return cachedNode;
@@ -8171,6 +8240,7 @@ export {
   REDUNDANT_TEMPLATE_STRING,
   ParseContext,
   PairSorting,
+  PROVIDE_NOT_ADDRESSABLE,
   PLACEHOLDERLESS_TEMPLATE_STRING,
   OrderedSet,
   OrderedMap2 as OrderedMap,
@@ -8190,6 +8260,8 @@ export {
   LintContext,
   LintComponentResult,
   LintClassCollectorCtx,
+  LOOKUP_TARGET_MALFORMED,
+  LOOKUP_BAD_SHAPE,
   KList,
   Set3 as ISet,
   INPUT_HANDLER_NOT_REFERENCED,