@uniform-ts/core 0.0.8 → 0.1.0

package/dist/index.mjs

@@ -716,6 +716,124 @@ function getDefaultValue(field) {
       return void 0;
   }
 }
+
+// src/utils/reindexDynamicMeta.ts
+function buildKeyPattern(arrayName) {
+  return new RegExp(`^${escapeRegExp(arrayName)}\\.(\\d+)\\.(.+)$`);
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function reindexDynamicMeta(dynamicMeta, arrayName, mutation) {
+  const pattern = buildKeyPattern(arrayName);
+  const matched = [];
+  const result = {};
+  for (const [key, value] of Object.entries(dynamicMeta)) {
+    const match = pattern.exec(key);
+    if (match) {
+      matched.push({
+        key,
+        index: parseInt(match[1], 10),
+        childField: match[2],
+        value
+      });
+    } else {
+      result[key] = value;
+    }
+  }
+  if (!isValidMutation(mutation)) {
+    return dynamicMeta;
+  }
+  switch (mutation.type) {
+    case "remove":
+      applyRemove(matched, mutation.index, arrayName, result);
+      break;
+    case "move":
+      applyMove(matched, mutation.from, mutation.to, arrayName, result);
+      break;
+    case "duplicate":
+      applyDuplicate(matched, mutation.index, arrayName, result);
+      break;
+    case "add":
+      applyAdd(matched, mutation.index, arrayName, result);
+      break;
+  }
+  return result;
+}
+function isValidMutation(mutation, _entries) {
+  switch (mutation.type) {
+    case "remove":
+      return mutation.index >= 0;
+    case "move":
+      return mutation.from >= 0 && mutation.to >= 0;
+    case "duplicate":
+      return mutation.index >= 0;
+    case "add":
+      return mutation.index >= 0;
+  }
+}
+function buildKey(arrayName, index, childField) {
+  return `${arrayName}.${index}.${childField}`;
+}
+function applyRemove(entries, removedIndex, arrayName, result) {
+  for (const entry of entries) {
+    if (entry.index === removedIndex) {
+      continue;
+    } else if (entry.index > removedIndex) {
+      result[buildKey(arrayName, entry.index - 1, entry.childField)] = entry.value;
+    } else {
+      result[buildKey(arrayName, entry.index, entry.childField)] = entry.value;
+    }
+  }
+}
+function applyMove(entries, from, to, arrayName, result) {
+  if (from === to) {
+    for (const entry of entries) {
+      result[buildKey(arrayName, entry.index, entry.childField)] = entry.value;
+    }
+    return;
+  }
+  for (const entry of entries) {
+    let newIndex;
+    if (entry.index === from) {
+      newIndex = to;
+    } else if (from < to) {
+      if (entry.index > from && entry.index <= to) {
+        newIndex = entry.index - 1;
+      } else {
+        newIndex = entry.index;
+      }
+    } else {
+      if (entry.index >= to && entry.index < from) {
+        newIndex = entry.index + 1;
+      } else {
+        newIndex = entry.index;
+      }
+    }
+    result[buildKey(arrayName, newIndex, entry.childField)] = entry.value;
+  }
+}
+function applyDuplicate(entries, sourceIndex, arrayName, result) {
+  for (const entry of entries) {
+    if (entry.index === sourceIndex) {
+      result[buildKey(arrayName, entry.index, entry.childField)] = entry.value;
+      result[buildKey(arrayName, sourceIndex + 1, entry.childField)] = entry.value;
+    } else if (entry.index > sourceIndex) {
+      result[buildKey(arrayName, entry.index + 1, entry.childField)] = entry.value;
+    } else {
+      result[buildKey(arrayName, entry.index, entry.childField)] = entry.value;
+    }
+  }
+}
+function applyAdd(entries, newIndex, arrayName, result) {
+  for (const entry of entries) {
+    if (entry.index >= newIndex) {
+      result[buildKey(arrayName, entry.index + 1, entry.childField)] = entry.value;
+    } else {
+      result[buildKey(arrayName, entry.index, entry.childField)] = entry.value;
+    }
+  }
+}
 function getRowSummary(row, itemConfig, index, itemSummary) {
   if (itemConfig.type === "object") {
     for (const child of itemConfig.children) {
@@ -728,8 +846,43 @@ function getRowSummary(row, itemConfig, index, itemSummary) {
   }
   return itemSummary?.(index) ?? `Item ${index + 1}`;
 }
+function bindRowIndexToItemConfig(itemConfig, rowIndex) {
+  if (itemConfig.type !== "object") return itemConfig;
+  const children = itemConfig.children.map((child) => {
+    if (!child.meta.onChange) return child;
+    const originalOnChange = child.meta.onChange;
+    return {
+      ...child,
+      meta: {
+        ...child.meta,
+        onChange: (value, formMethods) => {
+          void originalOnChange(value, formMethods, rowIndex);
+        }
+      }
+    };
+  });
+  return { ...itemConfig, children };
+}
+function applyRowDynamicMeta(itemConfig, rowOverrides) {
+  if (itemConfig.type !== "object") return itemConfig;
+  const children = itemConfig.children.map((child) => {
+    const override = rowOverrides[child.name];
+    if (!override) return child;
+    const { options, label, ...metaOverrides } = override;
+    let updated = {
+      ...child,
+      ...label !== void 0 ? { label } : {},
+      meta: { ...child.meta, ...metaOverrides }
+    };
+    if (options !== void 0 && updated.type === "select") {
+      updated = { ...updated, options };
+    }
+    return updated;
+  });
+  return { ...itemConfig, children };
+}
 function ArrayField({ field, control, effectiveName }) {
-  const { classNames, layout, labels } = useAutoFormContext();
+  const { classNames, layout, labels, setDynamicMeta } = useAutoFormContext();
   const {
     fields: rows,
     append,
@@ -775,6 +928,7 @@ function ArrayField({ field, control, effectiveName }) {
   } = layout.arrayButtons;
   const ArrayFieldLayout = layout.arrayFieldLayout;
   const RowLayout = layout.arrayRowLayout;
+  const rowDynamicMeta = field._rowDynamicMeta;
   const renderedRows = rows.map((row, index) => {
     const isCollapsed = showCollapse && collapsed.has(index);
     const collapseButton = showCollapse && CollapseBtn ? /* @__PURE__ */ jsxs(
@@ -806,7 +960,16 @@ function ArrayField({ field, control, effectiveName }) {
       {
         type: "button",
         className: classNames.arrayMove,
-        onClick: () => move(index, index - 1),
+        onClick: () => {
+          move(index, index - 1);
+          setDynamicMeta(
+            (prev) => reindexDynamicMeta(prev, effectiveName, {
+              type: "move",
+              from: index,
+              to: index - 1
+            })
+          );
+        },
         disabled: index === 0,
         "aria-label": labels.arrayAriaMoveUp?.(index) ?? `Move item ${index + 1} up`,
         children: labels.arrayMoveUp ?? "\u2191"
@@ -817,7 +980,16 @@ function ArrayField({ field, control, effectiveName }) {
       {
         type: "button",
         className: classNames.arrayMove,
-        onClick: () => move(index, index + 1),
+        onClick: () => {
+          move(index, index + 1);
+          setDynamicMeta(
+            (prev) => reindexDynamicMeta(prev, effectiveName, {
+              type: "move",
+              from: index,
+              to: index + 1
+            })
+          );
+        },
         disabled: index === rows.length - 1,
         "aria-label": labels.arrayAriaMoveDown?.(index) ?? `Move item ${index + 1} down`,
         children: labels.arrayMoveDown ?? "\u2193"
@@ -833,6 +1005,12 @@ function ArrayField({ field, control, effectiveName }) {
             Object.entries(row).filter(([k]) => k !== "id")
           );
           insert(index + 1, values);
+          setDynamicMeta(
+            (prev) => reindexDynamicMeta(prev, effectiveName, {
+              type: "duplicate",
+              index
+            })
+          );
         },
         "aria-label": labels.arrayAriaDuplicate?.(index) ?? `Duplicate item ${index + 1}`,
         children: labels.arrayDuplicate ?? "Duplicate"
@@ -843,7 +1021,15 @@ function ArrayField({ field, control, effectiveName }) {
       {
         type: "button",
         className: classNames.arrayRemove,
-        onClick: () => remove(index),
+        onClick: () => {
+          remove(index);
+          setDynamicMeta(
+            (prev) => reindexDynamicMeta(prev, effectiveName, {
+              type: "remove",
+              index
+            })
+          );
+        },
         disabled: atMin,
         "aria-label": labels.arrayAriaRemove?.(index) ?? `Remove item ${index + 1}`,
         children: labels.arrayRemove ?? "Remove"
@@ -852,7 +1038,10 @@ function ArrayField({ field, control, effectiveName }) {
     const fieldContent = !isCollapsed ? /* @__PURE__ */ jsx(
       FieldRenderer,
       {
-        field: effectiveItemConfig,
+        field: bindRowIndexToItemConfig(
+          rowDynamicMeta?.[index] ? applyRowDynamicMeta(effectiveItemConfig, rowDynamicMeta[index]) : effectiveItemConfig,
+          index
+        ),
         control,
         namePrefix: `${effectiveName}.${index}`
       }
@@ -880,7 +1069,16 @@ function ArrayField({ field, control, effectiveName }) {
       type: "button",
       className: classNames.arrayAdd,
       disabled: atMax,
-      onClick: () => append(getDefaultValue(itemConfig)),
+      onClick: () => {
+        const newIndex = rows.length;
+        append(getDefaultValue(itemConfig));
+        setDynamicMeta(
+          (prev) => reindexDynamicMeta(prev, effectiveName, {
+            type: "add",
+            index: newIndex
+          })
+        );
+      },
       children: labels.arrayAdd ?? "Add"
     }
   ) : null;
@@ -1133,6 +1331,28 @@ function useLatestRef(value) {
   return ref;
 }
 
+// src/utils/createRowScopedContext.ts
+function createRowScopedContext(baseCtx, arrayName, rowIndex, itemFieldNames, getValues) {
+  return {
+    ...baseCtx,
+    getValues,
+    setFieldMeta: (field, meta) => {
+      const fieldStr = field;
+      const prefix = arrayName + ".";
+      const childName = fieldStr.startsWith(prefix) ? fieldStr.slice(prefix.length) : fieldStr;
+      if (itemFieldNames.has(childName)) {
+        const qualifiedKey = `${arrayName}.${rowIndex}.${childName}`;
+        baseCtx.setFieldMeta(
+          qualifiedKey,
+          meta
+        );
+      } else {
+        baseCtx.setFieldMeta(field, meta);
+      }
+    }
+  };
+}
+
 // src/utils/fieldPipeline.ts
 function applyFieldOverrides(fields, overrides) {
   return fields.map((field) => {
@@ -1193,10 +1413,74 @@ function injectOnChangeHandlers(fields, uniForm, ctx, handlerKeys = new Set(uniF
     } else if (updated.type === "array") {
       const prefix = field.name + ".";
       const itemKeys = /* @__PURE__ */ new Set();
+      const indexedKeys = /* @__PURE__ */ new Set();
       for (const key of handlerKeys) {
-        if (key.startsWith(prefix)) itemKeys.add(key.slice(prefix.length));
+        if (key.startsWith(prefix)) {
+          const remainder = key.slice(prefix.length);
+          const indexMatch = remainder.match(/^(\d+)\.(.+)$/);
+          if (indexMatch) {
+            indexedKeys.add(remainder);
+            itemKeys.add(indexMatch[2]);
+          } else {
+            itemKeys.add(remainder);
+          }
+        }
       }
-      if (itemKeys.size) {
+      if (itemKeys.size && updated.itemConfig.type === "object") {
+        const itemFieldNames = new Set(
+          updated.itemConfig.children.map((c) => c.name)
+        );
+        const arrayName = field.name;
+        const newChildren = updated.itemConfig.children.map((child) => {
+          if (!itemKeys.has(child.name)) return child;
+          const existingOnChange = child.meta.onChange;
+          const rowAwareHandler = (value, formMethods, rowIndex) => {
+            void existingOnChange?.(value, formMethods);
+            const rowCtx = createRowScopedContext(
+              ctx,
+              arrayName,
+              rowIndex,
+              itemFieldNames,
+              () => {
+                const allValues = ctx.getValues();
+                const arrayValues = allValues?.[arrayName];
+                if (Array.isArray(arrayValues)) {
+                  return arrayValues[rowIndex] ?? {};
+                }
+                return {};
+              }
+            );
+            void uniForm._fireHandler(
+              `${arrayName}.${child.name}`,
+              value,
+              rowCtx
+            );
+            const indexedKey = `${rowIndex}.${child.name}`;
+            if (indexedKeys.has(indexedKey)) {
+              void uniForm._fireHandler(
+                `${arrayName}.${indexedKey}`,
+                value,
+                rowCtx
+              );
+            }
+          };
+          return {
+            ...child,
+            meta: {
+              ...child.meta,
+              // Cast to FieldMeta onChange type — ArrayField's bindRowIndexToItemConfig
+              // will call this with the rowIndex third argument at render time.
+              onChange: rowAwareHandler
+            }
+          };
+        });
+        const newItemConfig = {
+          ...updated.itemConfig,
+          children: newChildren
+        };
+        if (newItemConfig !== updated.itemConfig)
+          updated = { ...updated, itemConfig: newItemConfig };
+      } else if (itemKeys.size) {
         const remappedUniForm = {
           _getWatchedFields: () => Array.from(itemKeys),
           _fireHandlers: (name, value, c) => uniForm._fireHandler(`${field.name}.${name}`, value, c)
@@ -1242,18 +1526,43 @@ function injectConditions(fields, conditions) {
     return updated;
   });
 }
+var ROW_KEY_PATTERN = /^(.+?)\.(\d+)\.(.+)$/;
 function applyDynamicMeta(fields, overrides) {
   if (!Object.keys(overrides).length) return fields;
   return fields.map((field) => {
     const override = overrides[field.name];
-    if (!override) return field;
-    const { options, label, ...metaOverrides } = override;
-    return {
-      ...field,
-      ...label !== void 0 ? { label } : {},
-      ...options !== void 0 ? { options } : {},
-      meta: { ...field.meta, ...metaOverrides }
-    };
+    let updated = field;
+    if (override) {
+      const { options, label, ...metaOverrides } = override;
+      updated = {
+        ...field,
+        ...label !== void 0 ? { label } : {},
+        ...options !== void 0 ? { options } : {},
+        meta: { ...field.meta, ...metaOverrides }
+      };
+    }
+    if (updated.type === "array") {
+      const prefix = `${updated.name}.`;
+      let rowDynamicMeta;
+      for (const [key, value] of Object.entries(overrides)) {
+        if (!key.startsWith(prefix)) continue;
+        const match = ROW_KEY_PATTERN.exec(key);
+        if (!match) continue;
+        const [, matchedArrayName, indexStr, childField] = match;
+        if (matchedArrayName !== updated.name) continue;
+        const rowIndex = Number(indexStr);
+        if (!rowDynamicMeta) rowDynamicMeta = {};
+        if (!rowDynamicMeta[rowIndex]) rowDynamicMeta[rowIndex] = {};
+        rowDynamicMeta[rowIndex][childField] = value;
+      }
+      if (rowDynamicMeta) {
+        updated = {
+          ...updated,
+          _rowDynamicMeta: rowDynamicMeta
+        };
+      }
+    }
+    return updated;
   });
 }
 function buildDefaults(fields) {
@@ -1571,7 +1880,8 @@ function AutoForm(props) {
       messages,
       labels,
       formMethods,
-      control
+      control,
+      setDynamicMeta
     }),
     [
       registry,
@@ -1585,7 +1895,8 @@ function AutoForm(props) {
       messages,
       labels,
       formMethods,
-      control
+      control,
+      setDynamicMeta
     ]
   );
   if (isLoadingDefaults) {
@@ -1702,6 +2013,10 @@ var UniForm = class {
    * Replaces any previously registered handler for that field — only one
    * handler per field is kept. This prevents accidental handler accumulation
    * when called inside a React render cycle.
+   *
+   * Supports both generic array paths (`"tasks.priority"` — fires for all rows)
+   * and indexed paths (`"tasks.0.priority"` — fires only for row 0).
+   *
    * Returns `this` for fluent chaining.
    */
   setOnChange(field, handler) {