regor 1.6.6 → 1.6.8

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.d.ts

@@ -353,6 +353,10 @@ export type RefParam<TValueType> = Equals<TValueType, MakeRefParam<TValueType>>
 export type MakeRefParam<TValueType> = TValueType extends undefined ? never : TValueType extends Ref<infer V1> ? MakeRefParam<V1> : TValueType extends SRef<infer V2> ? MakeRefParam<V2> : TValueType extends Array<infer V3> ? Array<MakeRefParam<V3>> : TValueType extends RawTypes ? TValueType : {
 	[Key in keyof TValueType]: TValueType[Key] extends Ref<infer V4> ? MakeRefParam<V4> : TValueType[Key] extends SRef<infer V5> ? MakeRefParam<V5> : MakeRefParam<TValueType[Key]>;
 };
+export type RefInit<TValueType> = TValueType extends RawTypes ? never : RefInitField<TValueType>;
+export type RefInitField<TValueType> = Ref<RefParam<TValueType>> | SRef<RefContent<TValueType>> | (TValueType extends undefined ? never : TValueType extends Ref<infer V1> ? Ref<RefParam<V1>> | RefInitField<V1> : TValueType extends SRef<infer V2> ? SRef<V2> | RefInitField<V2> : TValueType extends Array<infer V3> ? Array<RefInitField<V3>> : TValueType extends RawTypes ? TValueType : {
+	[Key in keyof TValueType]: RefInitField<TValueType[Key]>;
+});
 export type SRefContent<TValueType> = Equals<TValueType, MakeSRefContent<TValueType>> extends true ? TValueType : MakeSRefContent<TValueType>;
 export type MakeSRefContent<TValueType> = TValueType extends undefined ? never : TValueType extends Ref<infer V1> ? RefContent<V1> : TValueType extends SRef<infer V2> ? V2 : TValueType extends Array<infer V3> ? V3[] : TValueType extends RawTypes ? TValueType : TValueType;
 export type UnwrapRef<TRef> = TRef extends Ref<infer V1> ? RefContent<V1> : TRef extends SRef<infer V2> ? SRefContent<V2> : TRef;
@@ -790,7 +794,7 @@ export declare const pause: <TValueType extends AnyRef>(source: TValueType) => v
  * @param value - Any value to be converted into a ref object.
  * @returns A ref object representing the input value and its nested properties.
  */
-export declare const ref: <TValueType>(value?: TValueType | RefContent<TValueType> | (TValueType extends Ref<infer V1> ? Ref<RefParam<V1>> : never) | (TValueType extends SRef<infer V2> ? SRef<UnwrapRef<V2>> : never) | RefParam<TValueType> | (TValueType extends Array<infer V1> ? V1[] : never) | null) => IsNull<TValueType> extends true ? Ref<unknown> : Ref<RefParam<TValueType>>;
+export declare function ref<TValueType>(value?: TValueType | RefContent<TValueType> | (TValueType extends Ref<infer V1> ? Ref<RefParam<V1>> : never) | (TValueType extends SRef<infer V2> ? SRef<UnwrapRef<V2>> : never) | RefParam<TValueType> | (TValueType extends Array<infer V1> ? V1[] : never) | null): IsNull<TValueType> extends true ? Ref<unknown> : Ref<RefParam<TValueType>>;
 export declare const resume: <TValueType extends AnyRef>(source: TValueType) => void;
 /**
  * Converts the given value to an sref object and returns the sref.
@@ -816,3 +820,16 @@ export declare const trigger: <TValueType extends AnyRef>(source: TValueType, ev
 export declare const unref: <TValueType>(value: TValueType) => UnwrapRef<TValueType>;
 
 export {};
+
+export declare function ref(value: string): Ref<string>
+export declare function ref(value: number): Ref<number>
+export declare function ref(value: boolean): Ref<boolean>
+export declare function ref(value: bigint): Ref<bigint>
+export declare function ref(value: symbol): Ref<symbol>
+export declare function ref<TValueType>(
+  value: (TValueType extends RawTypes | readonly unknown[]
+    ? never
+    : RefInit<TValueType>) &
+    object,
+): IsNull<TValueType> extends true ? Ref<unknown> : Ref<RefParam<TValueType>>
+export declare function ref(value: string, eventSource?: unknown): Ref<string>

package/dist/regor.es2015.cjs.js

@@ -4245,7 +4245,7 @@ var isDeepRef = (value) => {
 };
 
 // src/reactivity/ref.ts
-var ref = (value) => {
+function ref(value) {
   if (isRaw(value)) return value;
   let result;
   if (isRef(value)) {
@@ -4276,7 +4276,7 @@ var ref = (value) => {
     value[key] = ref(val);
   }
   return result;
-};
+}
 
 // src/app/RegorConfig.ts
 var _RegorConfig = class _RegorConfig {
@@ -6278,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",
@@ -6307,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);
@@ -6351,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);
       }
@@ -6367,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;
   }