@getforma/core 1.2.0 → 1.3.0

package/dist/runtime-hardened.cjs

@@ -241,14 +241,18 @@ function reconcileList(parent, oldItems, newItems, oldNodes, keyFn, createFn, up
   }
   const oldKeyMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < oldLen; i++) {
-    oldKeyMap.set(keyFn(oldItems[i]), i);
+    const k = keyFn(oldItems[i]);
+    const bucket = oldKeyMap.get(k);
+    if (bucket) bucket.push(i);
+    else oldKeyMap.set(k, [i]);
   }
   const oldIndices = new Array(newLen);
   const oldUsed = new Uint8Array(oldLen);
   for (let i = 0; i < newLen; i++) {
     const key = keyFn(newItems[i]);
-    const oldIdx = oldKeyMap.get(key);
-    if (oldIdx !== void 0) {
+    const bucket = oldKeyMap.get(key);
+    if (bucket && bucket.length > 0) {
+      const oldIdx = bucket.shift();
       oldIndices[i] = oldIdx;
       oldUsed[oldIdx] = 1;
     } else {
@@ -597,12 +601,12 @@ function findInsertionPoint(parent, newChild, newChildren) {
   return null;
 }
 function createReconciler(config) {
-  let _lastHtml = "";
+  const lastHtmlByContainer = /* @__PURE__ */ new WeakMap();
   return function reconcile2(container, html) {
     const trimmed = html.trim();
     if (!trimmed) return;
-    if (trimmed === _lastHtml && container.hasChildNodes()) return;
-    _lastHtml = trimmed;
+    if (lastHtmlByContainer.get(container) === trimmed && container.hasChildNodes()) return;
+    lastHtmlByContainer.set(container, trimmed);
     config.disconnectObserver();
     try {
       if (!container.hasChildNodes() || container.children.length === 0) {
@@ -916,9 +920,97 @@ var RE_TERNARY = /^(.+?)\s*\?\s*(.+?)\s*:\s*(.+)$/;
 var RE_NULLISH = /^(.+?)\s*\?\?\s*(.+)$/;
 var RE_AND = /^(.+?)\s*&&\s*(.+)$/;
 var RE_OR = /^(.+?)\s*\|\|\s*(.+)$/;
-var RE_COMPARISON = /^(.+?)\s*(===|!==|==|!=|>=|<=|>|<)\s*(.+)$/;
-var RE_MUL = /^(.+?)\s*([*/%])\s*(.+)$/;
-var RE_ADD = /^(.+?)\s*([+-])\s*(.+)$/;
+var UNARY_PRECEDERS = "+-*/%<>=!&|^~(,[{?:";
+function matchBinaryOp(expr, ops) {
+  const SQ = String.fromCharCode(39);
+  const DQ = String.fromCharCode(34);
+  const BT = String.fromCharCode(96);
+  const BS = String.fromCharCode(92);
+  let depth = 0;
+  let inSingle = false, inDouble = false, inTemplate = false, escaped = false;
+  let prevSig = "";
+  let bestIdx = -1;
+  let bestOp = "";
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === BS && (inSingle || inDouble || inTemplate)) {
+      escaped = true;
+      continue;
+    }
+    if (inSingle) {
+      if (ch === SQ) {
+        inSingle = false;
+        prevSig = DQ;
+      }
+      continue;
+    }
+    if (inDouble) {
+      if (ch === DQ) {
+        inDouble = false;
+        prevSig = DQ;
+      }
+      continue;
+    }
+    if (inTemplate) {
+      if (ch === BT) {
+        inTemplate = false;
+        prevSig = DQ;
+      }
+      continue;
+    }
+    if (ch === SQ) {
+      inSingle = true;
+      continue;
+    }
+    if (ch === DQ) {
+      inDouble = true;
+      continue;
+    }
+    if (ch === BT) {
+      inTemplate = true;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      prevSig = ch;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      if (depth > 0) depth--;
+      prevSig = ch;
+      continue;
+    }
+    if (depth !== 0) continue;
+    if (ch === " " || ch === "	" || ch === "\n") continue;
+    if (i > 0) {
+      let matchedOp = "";
+      for (const op of ops) {
+        if (expr.startsWith(op, i)) {
+          matchedOp = op;
+          break;
+        }
+      }
+      if (matchedOp) {
+        const isPlusMinus = matchedOp === "+" || matchedOp === "-";
+        const unary = isPlusMinus && (prevSig === "" || UNARY_PRECEDERS.includes(prevSig));
+        if (!unary) {
+          bestIdx = i;
+          bestOp = matchedOp;
+        }
+        i += matchedOp.length - 1;
+        prevSig = matchedOp[matchedOp.length - 1];
+        continue;
+      }
+    }
+    prevSig = ch;
+  }
+  if (bestIdx === -1) return null;
+  return { left: expr.slice(0, bestIdx).trim(), op: bestOp, right: expr.slice(bestIdx + bestOp.length).trim() };
+}
 var RE_TEMPLATE_LIT = /^`([^`]*)`$/;
 var RE_TEMPLATE_INTERP = /\$\{([^}]+)\}/g;
 var RE_GROUP_METHOD_CALL = /^\((.+)\)\.(\w+)\((.*)\)$/;
@@ -1875,12 +1967,12 @@ function parseExpressionUncached(expr, scope) {
       return () => left() && right();
     }
   }
-  const compMatch = expr.match(RE_COMPARISON);
+  const compMatch = matchBinaryOp(expr, ["===", "!==", "==", "!=", ">=", "<=", ">", "<"]);
   if (compMatch) {
-    const left = parseExpression(compMatch[1].trim(), scope);
-    const right = parseExpression(compMatch[3].trim(), scope);
+    const left = parseExpression(compMatch.left, scope);
+    const right = parseExpression(compMatch.right, scope);
     if (left && right) {
-      const op = compMatch[2];
+      const op = compMatch.op;
       return () => {
         const l = left(), r = right();
         switch (op) {
@@ -1904,12 +1996,12 @@ function parseExpressionUncached(expr, scope) {
       };
     }
   }
-  const addMatch = expr.match(RE_ADD);
+  const addMatch = matchBinaryOp(expr, ["+", "-"]);
   if (addMatch) {
-    const left = parseExpression(addMatch[1].trim(), scope);
-    const right = parseExpression(addMatch[3].trim(), scope);
+    const left = parseExpression(addMatch.left, scope);
+    const right = parseExpression(addMatch.right, scope);
     if (left && right) {
-      const op = addMatch[2];
+      const op = addMatch.op;
       return () => {
         const l = left(), r = right();
         if (op === "+") return l + r;
@@ -1917,12 +2009,12 @@ function parseExpressionUncached(expr, scope) {
       };
     }
   }
-  const mulMatch = expr.match(RE_MUL);
+  const mulMatch = matchBinaryOp(expr, ["*", "/", "%"]);
   if (mulMatch) {
-    const left = parseExpression(mulMatch[1].trim(), scope);
-    const right = parseExpression(mulMatch[3].trim(), scope);
+    const left = parseExpression(mulMatch.left, scope);
+    const right = parseExpression(mulMatch.right, scope);
     if (left && right) {
-      const op = mulMatch[2];
+      const op = mulMatch.op;
       return () => {
         const l = left(), r = right();
         switch (op) {
@@ -2347,25 +2439,61 @@ function bindElement(el, scope, disposers) {
   const modelExpr = !known || known.has("data-model") ? el.getAttribute("data-model") : null;
   if (modelExpr) {
     const prop = modelExpr.replace(RE_STRIP_BRACES, "").trim();
-    const getter = scope.getters[prop];
-    const setter = scope.setters[prop];
+    let getter = scope.getters[prop];
+    let setter = scope.setters[prop];
+    if ((!getter || !setter) && prop.includes(".")) {
+      getter = buildEvaluator(prop, scope);
+      const lastDot = prop.lastIndexOf(".");
+      const basePath = prop.slice(0, lastDot);
+      const key = prop.slice(lastDot + 1);
+      const baseGet = buildEvaluator(basePath, scope);
+      setter = (v) => {
+        const base = baseGet();
+        if (base != null && typeof base === "object") base[key] = v;
+      };
+    }
     if (getter && setter) {
       const input = el;
+      const tag = input.tagName;
       const dispose = internalEffect(() => {
         const val = getter();
-        if (input.type === "checkbox") {
+        const type = input.type;
+        if (type === "checkbox") {
           input.checked = !!val;
+          const indetExpr = el.getAttribute("data-model-indeterminate");
+          if (indetExpr) {
+            const indetGetter = scope.getters[indetExpr.replace(RE_STRIP_BRACES, "").trim()];
+            if (indetGetter) input.indeterminate = !!indetGetter();
+          }
+        } else if (type === "radio") {
+          input.checked = String(val) === input.value;
+        } else if (tag === "SELECT" && input.multiple) {
+          const sel = input;
+          const arr = Array.isArray(val) ? val.map(String) : [];
+          for (const opt of Array.from(sel.options)) opt.selected = arr.includes(opt.value);
         } else {
           input.value = String(val ?? "");
         }
       });
       disposers.push(dispose);
-      const event = input.type === "checkbox" ? "change" : "input";
+      const event = input.type === "checkbox" || input.type === "radio" || tag === "SELECT" ? "change" : "input";
       const onModelInput = () => {
-        if (input.type === "checkbox") {
+        const type = input.type;
+        if (type === "checkbox") {
           setter(input.checked);
-        } else if (input.type === "number" || input.type === "range") {
-          setter(Number(input.value));
+        } else if (type === "radio") {
+          if (input.checked) setter(input.value);
+        } else if (tag === "SELECT" && input.multiple) {
+          const sel = input;
+          setter(Array.from(sel.selectedOptions).map((o) => o.value));
+        } else if (type === "number" || type === "range") {
+          const raw = input.value;
+          if (raw === "") {
+            setter(null);
+          } else {
+            const n = Number(raw);
+            if (!Number.isNaN(n)) setter(n);
+          }
         } else {
           setter(input.value);
         }
@@ -2557,59 +2685,30 @@ function bindElement(el, scope, disposers) {
           }
         }
         const prevNodes = new Set(oldNodes);
-        if (keyProp) {
-          const result = reconcileList(
-            el,
-            oldItems,
-            rawItems,
-            oldNodes,
-            (item) => String(item?.[keyProp] ?? ""),
-            (item) => {
-              const idx = rawItems.indexOf(item);
-              return createBoundClone2(item, idx);
-            },
-            (node, item) => {
-              const idx = rawItems.indexOf(item);
-              updateBoundClone2(node, item, idx);
-            },
-            void 0,
-            // beforeNode
-            listHooks
-          );
-          const nextNodes = new Set(result.nodes);
-          for (const n of prevNodes) {
-            if (!nextNodes.has(n)) {
-              if (n.hasAttribute?.("data-forma-leaving")) continue;
-              disposeCloneBindings2(n);
-            }
-          }
-          oldItems = result.items;
-          oldNodes = result.nodes;
-        } else {
-          const wrapped = rawItems.map((item, i) => ({ __idx: i, __item: item }));
-          const oldWrapped = oldItems;
-          const result = reconcileList(
-            el,
-            oldWrapped,
-            wrapped,
-            oldNodes,
-            (w) => w.__idx,
-            (w) => createBoundClone2(w.__item, w.__idx),
-            (node, w) => updateBoundClone2(node, w.__item, w.__idx),
-            void 0,
-            // beforeNode
-            listHooks
-          );
-          const nextNodes = new Set(result.nodes);
-          for (const n of prevNodes) {
-            if (!nextNodes.has(n)) {
-              if (n.hasAttribute?.("data-forma-leaving")) continue;
-              disposeCloneBindings2(n);
-            }
+        const wrapped = rawItems.map((item, i) => ({ __idx: i, __item: item }));
+        const oldWrapped = oldItems;
+        const keyFn = keyProp ? (w) => String(w.__item?.[keyProp] ?? "") : (w) => w.__idx;
+        const result = reconcileList(
+          el,
+          oldWrapped,
+          wrapped,
+          oldNodes,
+          keyFn,
+          (w) => createBoundClone2(w.__item, w.__idx),
+          (node, w) => updateBoundClone2(node, w.__item, w.__idx),
+          void 0,
+          // beforeNode
+          listHooks
+        );
+        const nextNodes = new Set(result.nodes);
+        for (const n of prevNodes) {
+          if (!nextNodes.has(n)) {
+            if (n.hasAttribute?.("data-forma-leaving")) continue;
+            disposeCloneBindings2(n);
           }
-          oldItems = result.items;
-          oldNodes = result.nodes;
         }
+        oldItems = result.items;
+        oldNodes = result.nodes;
       });
       disposers.push(dispose);
     }