cogsbox-state 0.5.465 → 0.5.466

package/src/store.ts

@@ -7,7 +7,7 @@ import type {
   UpdateTypeDetail,
 } from './CogsState.js';
 
-import { startTransition, type ReactNode } from 'react';
+import { type ReactNode } from 'react';
 
 export type FreshValuesObject = {
   pathsToValues?: string[];
@@ -28,7 +28,6 @@ export type FormRefStoreState = {
   registerFormRef: (id: string, ref: React.RefObject<any>) => void;
   getFormRef: (id: string) => React.RefObject<any> | undefined;
   removeFormRef: (id: string) => void;
-  // New method to get all refs for a stateKey
   getFormRefsByStateKey: (
     stateKey: string
   ) => Map<string, React.RefObject<any>>;
@@ -53,7 +52,6 @@ export const formRefStore = create<FormRefStoreState>((set, get) => ({
       return { formRefs: newRefs };
     }),
 
-  // Get all refs that start with the stateKey prefix
   getFormRefsByStateKey: (stateKey) => {
     const allRefs = get().formRefs;
     const stateKeyPrefix = stateKey + '.';
@@ -83,26 +81,25 @@ export type ComponentsType = {
 };
 
 export type ValidationStatus =
-  | 'NOT_VALIDATED' // Never run
-  | 'VALIDATING' // Currently running
-  | 'VALID' // Passed
-  | 'INVALID'; // Failed
+  | 'NOT_VALIDATED'
+  | 'VALIDATING'
+  | 'VALID'
+  | 'INVALID';
 
 export type ValidationError = {
   source: 'client' | 'sync_engine' | 'api';
   message: string;
-  severity: 'warning' | 'error'; // warning = gentle, error = blocking
-  code?: string; // Optional error code
+  severity: 'warning' | 'error';
+  code?: string;
 };
 
 export type ValidationState = {
   status: ValidationStatus;
   errors: ValidationError[];
   lastValidated?: number;
-  validatedValue?: any; // Value when last validated
+  validatedValue?: any;
 };
 
-// This is the new definition for the metadata object
 export type ShadowMetadata = {
   id?: string;
   stateSource?: 'default' | 'server' | 'localStorage';
@@ -156,28 +153,23 @@ export type ShadowMetadata = {
   >;
 } & ComponentsType;
 
-// The shadow node itself can have a value and the metadata object.
 type ShadowNode = {
   value?: any;
   _meta?: ShadowMetadata;
-  [key: string]: any; // For nested data properties
+  [key: string]: any;
 };
 
 export type CogsGlobalState = {
   // NEW shadow store
-  shadowStateStore: Map<string, ShadowNode>; // Changed ShadowMetadata to ShadowNode
+  shadowStateStore: Map<string, ShadowNode>;
   setTransformCache: (
     key: string,
     path: string[],
     cacheKey: string,
     cacheData: any
   ) => void;
-  // NEW functions
   initializeShadowState: (key: string, initialState: any) => void;
-
-  // REFACTORED: getShadowNode gets the whole object (data + _meta)
   getShadowNode: (key: string, path: string[]) => ShadowNode | undefined;
-  // REFACTORED: getShadowMetadata now returns just the _meta field
   getShadowMetadata: (
     key: string,
     path: string[]
@@ -191,6 +183,18 @@ export type CogsGlobalState = {
     log?: boolean
   ) => any;
   updateShadowAtPath: (key: string, path: string[], newValue: any) => void;
+  insertManyShadowArrayElements: (
+    key: string,
+    arrayPath: string[],
+    newItems: any[],
+    index?: number
+  ) => void;
+  addItemsToArrayNode: (
+    key: string,
+    arrayPath: string[],
+    newItems: any,
+    newKeys: string[]
+  ) => void;
   insertShadowArrayElement: (
     key: string,
     arrayPath: string[],
@@ -209,13 +213,11 @@ export type CogsGlobalState = {
     dependencyPath: string[],
     fullComponentId: string
   ) => void;
-
   markAsDirty: (
     key: string,
     path: string[],
     options: { bubble: boolean }
   ) => void;
-  // These method signatures stay the same
 
   pathSubscribers: Map<string, Set<(newValue: any) => void>>;
   subscribeToPath: (
@@ -230,12 +232,8 @@ export type CogsGlobalState = {
   clearSelectedIndex: ({ arrayKey }: { arrayKey: string }) => void;
   clearSelectedIndexesForState: (stateKey: string) => void;
 
-  // --- Core State and Updaters ---
-
   initialStateOptions: { [key: string]: OptionsType };
-
   initialStateGlobal: { [key: string]: StateValue };
-
   updateInitialStateGlobal: (key: string, newState: StateValue) => void;
 
   getInitialOptions: (key: string) => OptionsType | undefined;
@@ -260,46 +258,35 @@ export type CogsGlobalState = {
   getSyncInfo: (key: string) => SyncInfo | null;
 };
 
-// ✅ CHANGE 1: `METADATA_KEYS` now only contains `_meta` and `value`.
-// The other keys are now properties of the `ShadowMetadata` type.
-export const METADATA_KEYS = new Set(['_meta', 'value']);
-
-/**
- * The single source of truth for converting a regular JS value/object
- * into the shadow state tree format with the new `_meta` structure.
- */
-// ✅ CHANGE 2: `buildShadowNode` now creates the `_meta` field.
 export function buildShadowNode(value: any): ShadowNode {
-  // Primitives and null are wrapped.
   if (value === null || typeof value !== 'object') {
     return { value };
   }
 
-  // Arrays are converted to an object with id-keyed children and metadata in `_meta`.
   if (Array.isArray(value)) {
-    const arrayNode: ShadowNode = { _meta: { arrayKeys: [] } }; // Initialize with _meta and arrayKeys
+    const arrayNode: ShadowNode = { _meta: { arrayKeys: [] } };
     const idKeys: string[] = [];
+
     value.forEach((item) => {
       const itemId = `id:${ulid()}`;
-      arrayNode[itemId] = buildShadowNode(item); // Recurse for each item
+      arrayNode[itemId] = buildShadowNode(item);
       idKeys.push(itemId);
     });
-    arrayNode._meta!.arrayKeys = idKeys; // Set the final ordered keys
+
+    arrayNode._meta!.arrayKeys = idKeys;
     return arrayNode;
   }
 
-  // Plain objects are recursively processed.
   if (value.constructor === Object) {
-    const objectNode: ShadowNode = { _meta: {} }; // Initialize with an empty meta object
+    const objectNode: ShadowNode = { _meta: {} };
     for (const key in value) {
       if (Object.prototype.hasOwnProperty.call(value, key)) {
-        objectNode[key] = buildShadowNode(value[key]); // Recurse for each property
+        objectNode[key] = buildShadowNode(value[key]);
       }
     }
     return objectNode;
   }
 
-  // Fallback for other object types (Date, etc.) - treat them as primitives.
   return { value };
 }
 
@@ -312,7 +299,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     cacheKey: string,
     cacheData: any
   ) => {
-    // This function now uses setShadowMetadata which correctly places the data.
     const metadata = get().getShadowMetadata(key, path) || {};
     if (!metadata.transformCaches) {
       metadata.transformCaches = new Map();
@@ -350,7 +336,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       newShadowStore.delete(`[${key}`);
 
       const newRoot = buildShadowNode(initialState);
-      // Ensure _meta exists before assigning to it
+
       if (!newRoot._meta) newRoot._meta = {};
       Object.assign(newRoot._meta, preservedMetadata);
 
@@ -361,7 +347,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     });
   },
 
-  // ✅ NEW HELPER: Gets the entire node (data and metadata).
   getShadowNode: (key: string, path: string[]): ShadowNode | undefined => {
     const store = get().shadowStateStore;
     let current: any = store.get(key) || store.get(`[${key}`);
@@ -377,7 +362,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     return current;
   },
 
-  // ✅ REFACTORED: Returns only the `_meta` part of a node.
   getShadowMetadata: (
     key: string,
     path: string[]
@@ -386,7 +370,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     return node?._meta;
   },
 
-  // ✅ REFACTORED: Sets data within the `_meta` object.
   setShadowMetadata: (
     key: string,
     path: string[],
@@ -408,11 +391,10 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       let current = clonedRoot;
       for (const segment of path) {
         const nextNode = current[segment] || {};
-        current[segment] = { ...nextNode }; // Clone for immutability
+        current[segment] = { ...nextNode };
         current = current[segment];
       }
 
-      // Ensure _meta object exists and merge the new metadata into it
       current._meta = { ...(current._meta || {}), ...newMetadata };
 
       return { shadowStateStore: newStore };
@@ -430,9 +412,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
 
     const nodeKeys = Object.keys(node);
 
-    // ✅ FIX: A node is a primitive wrapper ONLY if its keys are 'value' and/or '_meta'.
-    // This prevents objects in your data that happen to have a "value" property from being
-    // incorrectly treated as wrappers.
     const isPrimitiveWrapper =
       Object.prototype.hasOwnProperty.call(node, 'value') &&
       nodeKeys.every((k) => k === 'value' || k === '_meta');
@@ -456,61 +435,77 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       );
     }
 
-    // Object Reconstruction (This part is also correct)
     const result: any = {};
     for (const propKey of nodeKeys) {
-      // We correctly ignore metadata and array item keys here.
       if (propKey !== '_meta' && !propKey.startsWith('id:')) {
         result[propKey] = get().getShadowValue(key, [...path, propKey]);
       }
     }
     return result;
   },
-
-  // ✅ REFACTORED: Correctly preserves `_meta` on updates.
   updateShadowAtPath: (key, path, newValue) => {
     set((state) => {
       const newStore = new Map(state.shadowStateStore);
       const rootKey = newStore.has(`[${key}`) ? `[${key}` : key;
       let root = newStore.get(rootKey);
-
       if (!root) return state;
-
       const clonedRoot: any = { ...root };
       newStore.set(rootKey, clonedRoot);
+      let parentNode = clonedRoot;
+      for (let i = 0; i < path.length - 1; i++) {
+        parentNode[path[i]!] = { ...(parentNode[path[i]!] || {}) };
+        parentNode = parentNode[path[i]!];
+      }
+      const targetNode =
+        path.length === 0 ? parentNode : parentNode[path[path.length - 1]!];
+
+      if (!targetNode) {
+        parentNode[path[path.length - 1]!] = buildShadowNode(newValue);
+        return { shadowStateStore: newStore };
+      }
 
-      if (path.length === 0) {
-        const newRootStructure = buildShadowNode(newValue);
-        // Preserve the top-level metadata
-        if (clonedRoot._meta) {
-          newRootStructure._meta = {
-            ...(newRootStructure._meta || {}),
-            ...clonedRoot._meta,
-          };
+      function intelligentMerge(nodeToUpdate: any, plainValue: any) {
+        if (
+          typeof plainValue !== 'object' ||
+          plainValue === null ||
+          Array.isArray(plainValue)
+        ) {
+          const oldMeta = nodeToUpdate._meta;
+          const newNode = buildShadowNode(plainValue);
+          if (oldMeta) {
+            newNode._meta = { ...oldMeta, ...(newNode._meta || {}) };
+          }
+          Object.keys(nodeToUpdate).forEach((key) => delete nodeToUpdate[key]);
+          Object.assign(nodeToUpdate, newNode);
+          return;
         }
-        newStore.set(rootKey, newRootStructure);
-      } else {
-        let current = clonedRoot;
-        const parentPath = path.slice(0, -1);
-        for (const segment of parentPath) {
-          current[segment] = { ...current[segment] };
-          current = current[segment];
+
+        const plainValueKeys = new Set(Object.keys(plainValue));
+
+        for (const propKey of plainValueKeys) {
+          const childValue = plainValue[propKey];
+          if (nodeToUpdate[propKey]) {
+            intelligentMerge(nodeToUpdate[propKey], childValue);
+          } else {
+            nodeToUpdate[propKey] = buildShadowNode(childValue);
+          }
         }
 
-        const lastSegment = path[path.length - 1]!;
-        const existingNode = current[lastSegment] || {};
-        const newNodeStructure = buildShadowNode(newValue);
+        for (const nodeKey in nodeToUpdate) {
+          if (
+            nodeKey === '_meta' ||
+            !Object.prototype.hasOwnProperty.call(nodeToUpdate, nodeKey)
+          )
+            continue;
 
-        // This merge is critical: it preserves existing metadata during an update.
-        if (existingNode._meta) {
-          newNodeStructure._meta = {
-            ...(newNodeStructure._meta || {}),
-            ...existingNode._meta,
-          };
+          if (!plainValueKeys.has(nodeKey)) {
+            delete nodeToUpdate[nodeKey];
+          }
         }
-        current[lastSegment] = newNodeStructure;
       }
 
+      intelligentMerge(targetNode, newValue);
+
       get().notifyPathSubscribers([key, ...path].join('.'), {
         type: 'UPDATE',
         newValue,
@@ -518,8 +513,33 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       return { shadowStateStore: newStore };
     });
   },
+  addItemsToArrayNode: (key, arrayPath, newItems, newKeys) => {
+    set((state) => {
+      const newStore = new Map(state.shadowStateStore);
+      const rootKey = newStore.has(`[${key}`) ? `[${key}` : key;
+      let root = newStore.get(rootKey);
+      if (!root) {
+        console.error('Root not found for state key:', key);
+        return state;
+      }
+
+      const clonedRoot = { ...root };
+      newStore.set(rootKey, clonedRoot);
+
+      let current = clonedRoot;
+      for (const segment of arrayPath) {
+        const nextNode = current[segment] || {};
+        current[segment] = { ...nextNode };
+        current = current[segment];
+      }
+
+      Object.assign(current, newItems);
+      current._meta = { ...(current._meta || {}), arrayKeys: newKeys };
+
+      return { shadowStateStore: newStore };
+    });
+  },
 
-  // ✅ REFACTORED: Works with `_meta.arrayKeys`.
   insertShadowArrayElement: (key, arrayPath, newItem, index) => {
     const arrayNode = get().getShadowNode(key, arrayPath);
     if (!arrayNode?._meta?.arrayKeys) {
@@ -530,53 +550,67 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     }
 
     const newItemId = `id:${ulid()}`;
-    const newItemNode = buildShadowNode(newItem);
+    const itemsToAdd = { [newItemId]: buildShadowNode(newItem) };
 
-    // Update the `arrayKeys` in the metadata
     const currentKeys = arrayNode._meta.arrayKeys;
     const newKeys = [...currentKeys];
-    if (index !== undefined && index >= 0 && index <= newKeys.length) {
-      newKeys.splice(index, 0, newItemId);
-    } else {
-      newKeys.push(newItemId);
+    const insertionPoint =
+      index !== undefined && index >= 0 && index <= newKeys.length
+        ? index
+        : newKeys.length;
+    newKeys.splice(insertionPoint, 0, newItemId);
+
+    get().addItemsToArrayNode(key, arrayPath, itemsToAdd, newKeys);
+
+    const arrayKey = [key, ...arrayPath].join('.');
+    get().notifyPathSubscribers(arrayKey, {
+      type: 'INSERT',
+      path: arrayKey,
+      itemKey: `${arrayKey}.${newItemId}`,
+      index: insertionPoint,
+    });
+  },
+  insertManyShadowArrayElements: (key, arrayPath, newItems, index) => {
+    if (!newItems || newItems.length === 0) {
+      return;
     }
 
-    // Update transform caches if they exist
-    if (arrayNode._meta.transformCaches) {
-      arrayNode._meta.transformCaches.forEach((cache) => {
-        if (cache.validIds && Array.isArray(cache.validIds)) {
-          const matchesFilters = cache.transforms.every((transform) =>
-            transform.type === 'filter' ? transform.fn(newItem) : true
-          );
-          if (matchesFilters) {
-            cache.validIds = [...cache.validIds];
-            if (index !== undefined) {
-              cache.validIds.splice(index, 0, newItemId);
-            } else {
-              cache.validIds.push(newItemId);
-            }
-          }
-        }
-      });
+    const arrayNode = get().getShadowNode(key, arrayPath);
+    if (!arrayNode?._meta?.arrayKeys) {
+      console.error(
+        `Array not found at path: ${[key, ...arrayPath].join('.')}`
+      );
+      return;
     }
 
-    // Directly set the new item and updated metadata on the node before setting state
-    arrayNode[newItemId] = newItemNode;
-    arrayNode._meta.arrayKeys = newKeys;
+    const itemsToAdd: Record<string, any> = {};
+    const newIds: string[] = [];
 
-    get().setShadowMetadata(key, arrayPath, { arrayKeys: newKeys });
+    newItems.forEach((item) => {
+      const newItemId = `id:${ulid()}`;
+      newIds.push(newItemId);
+      itemsToAdd[newItemId] = buildShadowNode(item);
+    });
+
+    const currentKeys = arrayNode._meta.arrayKeys;
+    const finalKeys = [...currentKeys];
+    const insertionPoint =
+      index !== undefined && index >= 0 && index <= finalKeys.length
+        ? index
+        : finalKeys.length;
+    finalKeys.splice(insertionPoint, 0, ...newIds);
+
+    get().addItemsToArrayNode(key, arrayPath, itemsToAdd, finalKeys);
 
-    // Trigger notifications
     const arrayKey = [key, ...arrayPath].join('.');
     get().notifyPathSubscribers(arrayKey, {
-      type: 'INSERT',
+      type: 'INSERT_MANY',
       path: arrayKey,
-      itemKey: `${arrayKey}.${newItemId}`,
-      index: index ?? newKeys.length - 1,
+      count: newItems.length,
+      index: insertionPoint,
     });
   },
 
-  // ✅ REFACTORED: Works with `_meta.arrayKeys`.
   removeShadowArrayElement: (key, itemPath) => {
     if (itemPath.length === 0) return;
 
@@ -587,13 +621,9 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     const arrayNode = get().getShadowNode(key, arrayPath);
     if (!arrayNode?._meta?.arrayKeys) return;
 
-    // Filter the item's ID from the `arrayKeys` metadata
     const newKeys = arrayNode._meta.arrayKeys.filter((k) => k !== itemId);
-
-    // Delete the item's data from the node
     delete arrayNode[itemId];
 
-    // Persist the modified array node back to the store
     get().setShadowMetadata(key, arrayPath, { arrayKeys: newKeys });
 
     const arrayKey = [key, ...arrayPath].join('.');
@@ -604,9 +634,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     });
   },
 
-  // The rest of the functions are updated to use the new helpers (`getShadowMetadata`, `setShadowMetadata`)
-  // which abstracts away the `_meta` implementation detail.
-
   addPathComponent: (stateKey, dependencyPath, fullComponentId) => {
     const metadata = get().getShadowMetadata(stateKey, dependencyPath) || {};
     const newPathComponents = new Set(metadata.pathComponents);
@@ -646,15 +673,14 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     }
   },
 
-  // ✅ REFACTORED: `markAsDirty` now correctly writes to `_meta.isDirty`.
   markAsDirty: (key, path, options = { bubble: true }) => {
     const setDirtyOnPath = (pathToMark: string[]) => {
       const node = get().getShadowNode(key, pathToMark);
       if (node?._meta?.isDirty) {
-        return true; // Already dirty, stop bubbling
+        return true;
       }
       get().setShadowMetadata(key, pathToMark, { isDirty: true });
-      return false; // Was not dirty before
+      return false;
     };
 
     setDirtyOnPath(path);
@@ -664,7 +690,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       while (parentPath.length > 0) {
         parentPath.pop();
         if (setDirtyOnPath(parentPath)) {
-          break; // Stop if parent was already dirty
+          break;
         }
       }
     }
@@ -708,7 +734,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       subs.forEach((callback) => callback(newValue));
     }
   },
-
   selectedIndicesMap: new Map<string, string>(),
   getSelectedIndex: (arrayKey, validIds) => {
     const itemKey = get().selectedIndicesMap.get(arrayKey);
@@ -723,39 +748,51 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     return arrayKeys ? arrayKeys.indexOf(itemKey) : -1;
   },
 
-  setSelectedIndex: (arrayKey, itemKey) => {
+  setSelectedIndex: (arrayKey: string, itemKey: string | undefined) => {
     set((state) => {
-      const newMap = new Map(state.selectedIndicesMap);
-      const oldSelection = newMap.get(arrayKey);
-      if (oldSelection) {
-        get().notifyPathSubscribers(oldSelection, { type: 'THIS_UNSELECTED' });
-      }
+      const newMap = new Map(state.selectedIndicesMap); // CREATE A NEW MAP!
 
       if (itemKey === undefined) {
         newMap.delete(arrayKey);
       } else {
+        if (newMap.has(arrayKey)) {
+          get().notifyPathSubscribers(newMap.get(arrayKey)!, {
+            type: 'THIS_UNSELECTED',
+          });
+        }
         newMap.set(arrayKey, itemKey);
         get().notifyPathSubscribers(itemKey, { type: 'THIS_SELECTED' });
       }
 
       get().notifyPathSubscribers(arrayKey, { type: 'GET_SELECTED' });
-      return { selectedIndicesMap: newMap };
+
+      return {
+        ...state,
+        selectedIndicesMap: newMap,
+      };
     });
   },
 
-  clearSelectedIndex: ({ arrayKey }) => {
+  clearSelectedIndex: ({ arrayKey }: { arrayKey: string }): void => {
     set((state) => {
-      const newMap = new Map(state.selectedIndicesMap);
+      const newMap = new Map(state.selectedIndicesMap); // CREATE A NEW MAP!
       const actualKey = newMap.get(arrayKey);
       if (actualKey) {
-        get().notifyPathSubscribers(actualKey, { type: 'CLEAR_SELECTION' });
+        get().notifyPathSubscribers(actualKey, {
+          type: 'CLEAR_SELECTION',
+        });
       }
+
       newMap.delete(arrayKey);
-      get().notifyPathSubscribers(arrayKey, { type: 'CLEAR_SELECTION' });
-      return { selectedIndicesMap: newMap };
+      get().notifyPathSubscribers(arrayKey, {
+        type: 'CLEAR_SELECTION',
+      });
+      return {
+        ...state,
+        selectedIndicesMap: newMap,
+      };
     });
   },
-
   clearSelectedIndexesForState: (stateKey) => {
     set((state) => {
       const newMap = new Map(state.selectedIndicesMap);

package/dist/Functions.d.ts

@@ -1,11 +0,0 @@
-import { FormOptsType } from './CogsState';
-import { default as React } from 'react';
-
-export type ValidationWrapperProps = {
-    formOpts?: FormOptsType;
-    path: string[];
-    stateKey: string;
-    children: React.ReactNode;
-};
-export declare function ValidationWrapper({ formOpts, path, stateKey, children, }: ValidationWrapperProps): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=Functions.d.ts.map

package/dist/Functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Functions.d.ts","sourceRoot":"","sources":["../src/Functions.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,QAAQ,GACT,EAAE,sBAAsB,2CAgDxB"}

package/dist/Functions.jsx

@@ -1,29 +0,0 @@
-import { jsx as o, Fragment as w } from "react/jsx-runtime";
-import d from "react";
-import { getGlobalStore as M } from "./store.js";
-function F({
-  formOpts: a,
-  path: e,
-  stateKey: s,
-  children: n
-}) {
-  const { getInitialOptions: c, getShadowMetadata: v, getShadowValue: S } = M.getState(), i = c(s), g = v(s, e)?.validation, f = g?.status || "NOT_VALIDATED", r = (g?.errors || []).map((t) => ({
-    ...t,
-    path: e
-  })), l = r.filter((t) => t.severity === "error").map((t) => t.message), m = r.filter((t) => t.severity === "warning").map((t) => t.message), h = l[0] || m[0];
-  return /* @__PURE__ */ o(w, { children: i?.formElements?.validation && !a?.validation?.disable ? i.formElements.validation({
-    children: /* @__PURE__ */ o(d.Fragment, { children: n }, e.toString()),
-    status: f,
-    // Now passes the new ValidationStatus type
-    message: a?.validation?.hideMessage ? "" : a?.validation?.message || h || "",
-    hasErrors: l.length > 0,
-    hasWarnings: m.length > 0,
-    allErrors: r,
-    path: e,
-    getData: () => S(s, e)
-  }) : /* @__PURE__ */ o(d.Fragment, { children: n }, e.toString()) });
-}
-export {
-  F as ValidationWrapper
-};
-//# sourceMappingURL=Functions.jsx.map

package/dist/Functions.jsx.map

@@ -1 +0,0 @@
-{"version":3,"file":"Functions.jsx","sources":["../src/Functions.tsx"],"sourcesContent":["import { type FormOptsType } from './CogsState';\r\nimport React from 'react';\r\nimport { getGlobalStore, ValidationError } from './store';\r\nimport { get } from 'http';\r\n\r\nexport type ValidationWrapperProps = {\r\n  formOpts?: FormOptsType;\r\n  path: string[];\r\n  stateKey: string;\r\n  children: React.ReactNode;\r\n};\r\n\r\nexport function ValidationWrapper({\r\n  formOpts,\r\n  path,\r\n  stateKey,\r\n  children,\r\n}: ValidationWrapperProps) {\r\n  const { getInitialOptions, getShadowMetadata, getShadowValue } =\r\n    getGlobalStore.getState();\r\n  const thisStateOpts = getInitialOptions(stateKey!);\r\n\r\n  const shadowMeta = getShadowMetadata(stateKey!, path);\r\n  const validationState = shadowMeta?.validation;\r\n\r\n  const status = validationState?.status || 'NOT_VALIDATED';\r\n\r\n  const errors = (validationState?.errors || []).map((err) => ({\r\n    ...err,\r\n    path: path,\r\n  })) as ValidationError[];\r\n  const errorMessages = errors\r\n    .filter((err) => err.severity === 'error')\r\n    .map((err) => err.message);\r\n  const warningMessages = errors\r\n    .filter((err) => err.severity === 'warning')\r\n    .map((err) => err.message);\r\n\r\n  // Use first error, or first warning if no errors\r\n  const message = errorMessages[0] || warningMessages[0];\r\n\r\n  return (\r\n    <>\r\n      {thisStateOpts?.formElements?.validation &&\r\n      !formOpts?.validation?.disable ? (\r\n        thisStateOpts.formElements!.validation!({\r\n          children: (\r\n            <React.Fragment key={path.toString()}>{children}</React.Fragment>\r\n          ),\r\n          status, // Now passes the new ValidationStatus type\r\n          message: formOpts?.validation?.hideMessage\r\n            ? ''\r\n            : formOpts?.validation?.message || message || '',\r\n\r\n          hasErrors: errorMessages.length > 0,\r\n          hasWarnings: warningMessages.length > 0,\r\n          allErrors: errors,\r\n          path: path,\r\n          getData: () => getShadowValue(stateKey!, path),\r\n        })\r\n      ) : (\r\n        <React.Fragment key={path.toString()}>{children}</React.Fragment>\r\n      )}\r\n    </>\r\n  );\r\n}\r\n"],"names":["ValidationWrapper","formOpts","path","stateKey","children","getInitialOptions","getShadowMetadata","getShadowValue","getGlobalStore","thisStateOpts","validationState","status","errors","err","errorMessages","warningMessages","message","jsx","Fragment","React"],"mappings":";;;AAYO,SAASA,EAAkB;AAAA,EAChC,UAAAC;AAAA,EACA,MAAAC;AAAA,EACA,UAAAC;AAAA,EACA,UAAAC;AACF,GAA2B;AACzB,QAAM,EAAE,mBAAAC,GAAmB,mBAAAC,GAAmB,gBAAAC,EAAA,IAC5CC,EAAe,SAAA,GACXC,IAAgBJ,EAAkBF,CAAS,GAG3CO,IADaJ,EAAkBH,GAAWD,CAAI,GAChB,YAE9BS,IAASD,GAAiB,UAAU,iBAEpCE,KAAUF,GAAiB,UAAU,CAAA,GAAI,IAAI,CAACG,OAAS;AAAA,IAC3D,GAAGA;AAAA,IACH,MAAAX;AAAA,EAAA,EACA,GACIY,IAAgBF,EACnB,OAAO,CAACC,MAAQA,EAAI,aAAa,OAAO,EACxC,IAAI,CAACA,MAAQA,EAAI,OAAO,GACrBE,IAAkBH,EACrB,OAAO,CAACC,MAAQA,EAAI,aAAa,SAAS,EAC1C,IAAI,CAACA,MAAQA,EAAI,OAAO,GAGrBG,IAAUF,EAAc,CAAC,KAAKC,EAAgB,CAAC;AAErD,SACE,gBAAAE,EAAAC,GAAA,EACG,UAAAT,GAAe,cAAc,cAC9B,CAACR,GAAU,YAAY,UACrBQ,EAAc,aAAc,WAAY;AAAA,IACtC,4BACGU,EAAM,UAAN,EAAsC,UAAAf,KAAlBF,EAAK,UAAsB;AAAA,IAElD,QAAAS;AAAA;AAAA,IACA,SAASV,GAAU,YAAY,cAC3B,KACAA,GAAU,YAAY,WAAWe,KAAW;AAAA,IAEhD,WAAWF,EAAc,SAAS;AAAA,IAClC,aAAaC,EAAgB,SAAS;AAAA,IACtC,WAAWH;AAAA,IACX,MAAAV;AAAA,IACA,SAAS,MAAMK,EAAeJ,GAAWD,CAAI;AAAA,EAAA,CAC9C,IAED,gBAAAe,EAACE,EAAM,UAAN,EAAsC,UAAAf,EAAA,GAAlBF,EAAK,SAAA,CAAsB,GAEpD;AAEJ;"}