regor 1.6.5 → 1.6.7

package/README.md

@@ -262,12 +262,15 @@ createApp(appContext, template, config)
 Regor preprocesses table-related templates to keep markup valid when using
 components in table structures.
 
-- Supported table containers: `table`, `thead`, `tbody`, `tfoot`.
+- Supported table containers: `table`, `caption`, `colgroup`, `thead`,
+  `tbody`, `tfoot`.
 - Component tags directly under row containers are normalized to valid hosts.
 - Component tags directly under `<tr>` are normalized to `<td>` hosts (except
   native `<td>` / `<th>`).
+- Component tags directly under `<colgroup>` are normalized to `<col>` hosts
+  (except native `<col>`).
 - Regor preserves valid table markup while supporting component-based rows and
-  cells in table templates.
+  cells, captions, sections, column groups, and columns in table templates.
 
 Example:
 

package/dist/regor.es2015.cjs.js

@@ -281,7 +281,7 @@ var rawSymbol = Symbol("raw");
 
 // src/reactivity/isRef.ts
 var isRef = (value) => {
-  return value != null && value[srefSymbol] === 1;
+  return value != null && value[srefSymbol] > 0;
 };
 
 // src/app/propValidators.ts
@@ -1137,6 +1137,8 @@ var readonlyRefValueDescriptor = {
   configurable: false
 };
 var defineRefValue = (result, isReadOnly) => {
+  ;
+  result[srefSymbol] = isReadOnly ? 2 : 1;
   Object.defineProperty(
     result,
     "value",
@@ -1274,9 +1276,24 @@ var observe = (source, observer, init, trackUnmount = true) => {
 };
 
 // src/reactivity/entangle.ts
+var isReadonly = (value) => value[srefSymbol] === 2;
 var entangle = (r1, r2) => {
   if (r1 === r2) return () => {
   };
+  const r1Readonly = isReadonly(r1);
+  const r2Readonly = isReadonly(r2);
+  if (r1Readonly && r2Readonly) return () => {
+  };
+  if (r1Readonly) {
+    const stop = observe(r1, () => r2(r1()));
+    r2(r1());
+    return stop;
+  }
+  if (r2Readonly) {
+    const stop = observe(r2, () => r1(r2()));
+    r1(r2());
+    return stop;
+  }
   const stop1 = observe(r1, (v) => r2(v));
   const stop2 = observe(r2, (v) => r1(v));
   r2(r1());
@@ -1539,7 +1556,6 @@ var sref = (value) => {
     }
     return refObj._value;
   };
-  srefFunction[srefSymbol] = 1;
   defineRefValue(srefFunction, false);
   if (isProxy) attachProxyHandle(value);
   return srefFunction;
@@ -2300,7 +2316,7 @@ var DynamicBinder = class {
 // src/reactivity/unref.ts
 var unref = (value) => {
   const anyValue = value;
-  return anyValue != null && anyValue[srefSymbol] === 1 ? anyValue() : anyValue;
+  return anyValue != null && anyValue[srefSymbol] > 0 ? anyValue() : anyValue;
 };
 
 // src/directives/html.ts
@@ -6262,19 +6278,50 @@ var parseTagNameRange = (tagText, isClosing) => {
   while (i < tagText.length && (tagText[i] === " " || tagText[i] === "\n")) ++i;
   if (i >= tagText.length || !isNameChar(tagText[i])) return null;
   const start = i;
-  while (i < tagText.length && isNameChar(tagText[i])) ++i;
-  return { start, end: i };
-};
-var tableScopeTags = /* @__PURE__ */ new Set(["table", "thead", "tbody", "tfoot"]);
-var rowParentTags = /* @__PURE__ */ new Set(["thead", "tbody", "tfoot"]);
-var tableDirectAllowed = /* @__PURE__ */ new Set([
-  "caption",
-  "colgroup",
-  "thead",
-  "tbody",
-  "tfoot",
-  "tr"
-]);
+  let hasUppercase = false;
+  while (i < tagText.length && isNameChar(tagText[i])) {
+    const c = tagText.charCodeAt(i);
+    if (c >= 65 && c <= 90) {
+      hasUppercase = true;
+    }
+    ++i;
+  }
+  return { start, end: i, hasUppercase };
+};
+var isTableScopeTag = (tagName) => {
+  switch (tagName) {
+    case "table":
+    case "thead":
+    case "tbody":
+    case "tfoot":
+      return true;
+    default:
+      return false;
+  }
+};
+var isRowParentTag = (tagName) => {
+  switch (tagName) {
+    case "thead":
+    case "tbody":
+    case "tfoot":
+      return true;
+    default:
+      return false;
+  }
+};
+var isTableDirectAllowed = (tagName) => {
+  switch (tagName) {
+    case "caption":
+    case "colgroup":
+    case "thead":
+    case "tbody":
+    case "tfoot":
+    case "tr":
+      return true;
+    default:
+      return false;
+  }
+};
 var voidElements = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -6291,12 +6338,62 @@ var voidElements = /* @__PURE__ */ new Set([
   "track",
   "wbr"
 ]);
+var getTableAliasHost = (tagName) => {
+  switch (tagName) {
+    case "caption":
+      return "captionx";
+    case "thead":
+      return "theadx";
+    case "tbody":
+      return "tbodyx";
+    case "tfoot":
+      return "tfootx";
+    case "tr":
+      return "trx";
+    case "td":
+      return "tdx";
+    case "th":
+      return "thx";
+    case "colgroup":
+      return "colgroupx";
+    case "col":
+      return "colx";
+    default:
+      return null;
+  }
+};
+var getTableAliasTag = (host) => {
+  switch (host) {
+    case "captionx":
+      return "caption";
+    case "theadx":
+      return "thead";
+    case "tbodyx":
+      return "tbody";
+    case "tfootx":
+      return "tfoot";
+    case "trx":
+      return "tr";
+    case "tdx":
+      return "td";
+    case "thx":
+      return "th";
+    case "colgroupx":
+      return "colgroup";
+    case "colx":
+      return "col";
+    default:
+      return void 0;
+  }
+};
+var closeTag = (tagText, tagName) => `${tagText}</${tagName}>`;
 var expandSelfClosingTag = (tagText, tagName) => `${tagText.slice(0, tagText.length - 2)}></${tagName}>`;
 var preprocess = (template) => {
-  var _a;
+  var _a, _b;
   let i = 0;
   const out = [];
   const stack = [];
+  const ignoredClosingTags = [];
   let tableScopeDepth = 0;
   while (i < template.length) {
     const lt = template.indexOf("<", i);
@@ -6335,12 +6432,21 @@ var preprocess = (template) => {
       continue;
     }
     const tagName = rawTag.slice(range.start, range.end);
+    const nativeTagName = range.hasUppercase ? "" : tagName;
     if (isClosing) {
+      const ignoredClosing = ignoredClosingTags[ignoredClosingTags.length - 1];
+      if ((ignoredClosing == null ? void 0 : ignoredClosing.tagName) === tagName) {
+        ignoredClosingTags.pop();
+        if (ignoredClosing.emit) out.push(rawTag);
+        i = tagEnd + 1;
+        continue;
+      }
       const top = stack[stack.length - 1];
       if (top) {
         stack.pop();
         out.push(top.replacementHost ? `</${top.replacementHost}>` : rawTag);
-        if (tableScopeTags.has(top.effectiveTag)) --tableScopeDepth;
+        if (!top.isTableAlias && isTableScopeTag(top.effectiveTag))
+          --tableScopeDepth;
       } else {
         out.push(rawTag);
       }
@@ -6351,35 +6457,47 @@ var preprocess = (template) => {
     const parent = stack[stack.length - 1];
     let replacementHost = null;
     if (tableScopeDepth === 0) {
-      if (tagName === "tr") replacementHost = "trx";
-      else if (tagName === "td") replacementHost = "tdx";
-      else if (tagName === "th") replacementHost = "thx";
-    } else if (rowParentTags.has((_a = parent == null ? void 0 : parent.effectiveTag) != null ? _a : "")) {
-      replacementHost = tagName === "tr" ? null : "tr";
+      replacementHost = getTableAliasHost(nativeTagName);
+    } else if (isRowParentTag((_a = parent == null ? void 0 : parent.effectiveTag) != null ? _a : "")) {
+      replacementHost = nativeTagName === "tr" ? null : "tr";
     } else if ((parent == null ? void 0 : parent.effectiveTag) === "table") {
-      replacementHost = tableDirectAllowed.has(tagName) ? null : "tr";
+      replacementHost = isTableDirectAllowed(nativeTagName) ? null : "tr";
     } else if ((parent == null ? void 0 : parent.effectiveTag) === "tr") {
-      replacementHost = tagName === "td" || tagName === "th" ? null : "td";
-    }
-    const shouldExpandSelfClosing = selfClosing && !voidElements.has(replacementHost || tagName);
+      replacementHost = nativeTagName === "td" || nativeTagName === "th" ? null : "td";
+    } else if ((parent == null ? void 0 : parent.effectiveTag) === "colgroup") {
+      replacementHost = nativeTagName === "col" ? null : "col";
+    }
+    const aliasTag = getTableAliasTag(replacementHost);
+    const isTableAlias = aliasTag !== void 0;
+    const shouldExpandSelfClosing = selfClosing && !voidElements.has(replacementHost || nativeTagName);
+    const shouldCloseVoidAlias = !!replacementHost && aliasTag === nativeTagName && voidElements.has(nativeTagName);
+    const shouldIgnoreClosingTag = !selfClosing && !!replacementHost && voidElements.has(replacementHost) && !shouldCloseVoidAlias;
+    const shouldIgnoreNativeVoidClosingTag = !selfClosing && !replacementHost && voidElements.has(nativeTagName);
     if (replacementHost) {
-      const isAlias = replacementHost === "trx" || replacementHost === "tdx" || replacementHost === "thx";
-      const rewrittenTag = `${rawTag.slice(0, range.start)}${replacementHost} is="${isAlias ? `r-${tagName}` : `regor:${tagName}`}"${rawTag.slice(range.end)}`;
+      const rewrittenTag = `${rawTag.slice(0, range.start)}${replacementHost} is="${aliasTag ? `r-${aliasTag}` : `regor:${tagName}`}"${rawTag.slice(range.end)}`;
       out.push(
-        shouldExpandSelfClosing ? expandSelfClosingTag(rewrittenTag, replacementHost) : rewrittenTag
+        shouldExpandSelfClosing ? expandSelfClosingTag(rewrittenTag, replacementHost) : shouldCloseVoidAlias ? closeTag(rewrittenTag, replacementHost) : rewrittenTag
       );
     } else {
       out.push(
         shouldExpandSelfClosing ? expandSelfClosingTag(rawTag, tagName) : rawTag
       );
     }
-    if (!selfClosing) {
-      const effectiveTag = replacementHost === "trx" ? "tr" : replacementHost === "tdx" ? "td" : replacementHost === "thx" ? "th" : replacementHost || tagName;
+    if (shouldIgnoreClosingTag) {
+      ignoredClosingTags.push({ tagName, emit: false });
+    } else if (shouldCloseVoidAlias && !selfClosing) {
+      ignoredClosingTags.push({ tagName, emit: false });
+    } else if (shouldIgnoreNativeVoidClosingTag) {
+      ignoredClosingTags.push({ tagName, emit: true });
+    }
+    if (!selfClosing && !shouldCloseVoidAlias && !shouldIgnoreClosingTag && !shouldIgnoreNativeVoidClosingTag && !voidElements.has(replacementHost != null ? replacementHost : nativeTagName)) {
+      const effectiveTag = (_b = aliasTag != null ? aliasTag : replacementHost) != null ? _b : nativeTagName || tagName;
       stack.push({
         replacementHost,
-        effectiveTag
+        effectiveTag,
+        isTableAlias
       });
-      if (tableScopeTags.has(effectiveTag)) ++tableScopeDepth;
+      if (!isTableAlias && isTableScopeTag(effectiveTag)) ++tableScopeDepth;
     }
     i = tagEnd + 1;
   }