@vuu-ui/vuu-utils 4.0.0-alpha.1 → 4.0.0-alpha.10

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.10",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -16,14 +16,14 @@
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.1",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.1"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.10",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.10"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.1",
+    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.10",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"
@@ -38,6 +38,7 @@
   "exports": {
     ".": {
       "import": "./src/index.js",
+      "default": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },

package/src/array-utils.js

@@ -1,3 +1,4 @@
+const simpleIdentity = (a, b)=>a === b;
 function partition(array, test, pass = [], fail = []) {
     for(let i = 0, len = array.length; i < len; i++)(test(array[i], i) ? pass : fail).push(array[i]);
     return [
@@ -41,12 +42,23 @@ const moveItem = (items, fromIndex, toIndex)=>{
         }
     }
 };
-const getAddedItems = (values, newValues)=>{
-    const isNew = (v)=>!values?.includes(v);
-    if (void 0 === values) return newValues;
-    if (newValues.some(isNew)) return newValues.filter(isNew);
+const getAddedItems = (currentItems, newItems, compareItems = simpleIdentity)=>{
+    if (void 0 === currentItems) return newItems;
+    const isNew = (item)=>currentItems.every((currentItem)=>false === compareItems(item, currentItem));
+    if (newItems.some(isNew)) return newItems.filter(isNew);
     return [];
 };
+const getRemovedItems = (currentItems, newItems, compareItems = simpleIdentity)=>{
+    if (void 0 === newItems) return currentItems;
+    const isRemoved = (item)=>newItems.every((newItem)=>false === compareItems(item, newItem));
+    if (currentItems.some(isRemoved)) return currentItems.filter(isRemoved);
+    return [];
+};
+const containsSubsetOfItems = (allItems, comparedItems)=>{
+    if (comparedItems.length > allItems.length) return false;
+    const invalidItems = getAddedItems(allItems, comparedItems);
+    return 0 === invalidItems.length;
+};
 const getMissingItems = (sourceItems, items, identity)=>items.filter((i)=>-1 === sourceItems.findIndex((s)=>identity(s) === i));
 const reorderItems = (originalItems, orderedNames)=>{
     const orderedItems = [];
@@ -58,4 +70,4 @@ const reorderItems = (originalItems, orderedNames)=>{
     }
     return orderedItems;
 };
-export { getAddedItems, getMissingItems, itemsChanged, itemsOrOrderChanged, moveItem, moveItemDeprecated, partition, reorderItems };
+export { containsSubsetOfItems, getAddedItems, getMissingItems, getRemovedItems, itemsChanged, itemsOrOrderChanged, moveItem, moveItemDeprecated, partition, reorderItems };

package/src/form-utils.js

@@ -38,11 +38,15 @@ function getTypedValue(value, type, throwIfInvalid = false, options) {
         case "int":
             if (stringIsValidInt(value)) return parseInt(value, 10);
             if (!throwIfInvalid) return;
-            throw Error(`value ${value} is not a valid ${type}`);
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "whole number", getActualType(value));
         case "long":
             if (stringIsValidLong(value)) return value;
             if (!throwIfInvalid) return;
-            throw Error(`value ${value} is not a valid ${type}`);
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "whole number", getActualType(value));
+        case "char":
+            if (1 === value.length) return value;
+            if (!throwIfInvalid) return;
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "single character", getActualType(value));
         case "scaleddecimal2":
             return ScaledDecimal2(value);
         case "scaleddecimal4":

package/src/useResizeObserver.js

@@ -29,7 +29,7 @@ const getTargetSize = (element, size, dimension)=>{
             return 0;
     }
 };
-const resizeObserver = new ResizeObserver((entries)=>{
+const resizeObserver = "u" < typeof ResizeObserver ? void 0 : new ResizeObserver((entries)=>{
     for (const entry of entries){
         const { target, borderBoxSize, contentBoxSize } = entry;
         const observedTarget = observedMap.get(target);
@@ -81,7 +81,7 @@ function useResizeObserver(ref, dimensions, onResize, reportInitialSize = false)
             if (observedTarget) {
                 const measurements = measure(target);
                 observedTarget.measurements = measurements;
-                resizeObserver.observe(target);
+                resizeObserver?.observe(target);
                 if (reportInitialSize) onResize(measurements);
             } else console.log("%cuseResizeObserver an target expected to be under observation wa snot found. This warrants investigation", "font-weight:bold; color:red;");
         }
@@ -93,7 +93,7 @@ function useResizeObserver(ref, dimensions, onResize, reportInitialSize = false)
         }
         return ()=>{
             if (target && observedMap.has(target)) {
-                resizeObserver.unobserve(target);
+                resizeObserver?.unobserve(target);
                 observedMap.delete(target);
             }
         };

package/types/array-utils.d.ts

@@ -1,11 +1,14 @@
 export type PartitionTest<T> = (value: T, index: number) => boolean;
+export type ItemComparator<T> = (firstItem: T, secondItem: T) => boolean;
 export declare function partition<T>(array: T[], test: PartitionTest<T>, pass?: T[], fail?: T[]): [T[], T[]];
-export declare function itemsChanged<T = unknown>(currentItems: T[], newItems: T[], identityProperty?: string): boolean;
-export declare function itemsOrOrderChanged<T = unknown>(currentItems: T[], newItems: T[], identityProperty?: string): boolean;
+export declare function itemsChanged<T = unknown>(currentItems: readonly T[], newItems: readonly T[], identityProperty?: string): boolean;
+export declare function itemsOrOrderChanged<T = unknown>(currentItems: readonly T[], newItems: readonly T[], identityProperty?: string): boolean;
 export declare const moveItemDeprecated: <T = unknown>(items: T[], item: T, moveTo: number) => T[];
 export declare const moveItem: <T = unknown>(items: T[], fromIndex: number, toIndex: number) => T[];
-export declare const getAddedItems: <T>(values: undefined | T[], newValues: T[]) => T[];
-export declare const getMissingItems: <T, I>(sourceItems: T[], items: I[], identity: (s: T) => I) => I[];
+export declare const getAddedItems: <T>(currentItems: undefined | readonly T[], newItems: readonly T[], compareItems?: ItemComparator<T>) => readonly T[];
+export declare const getRemovedItems: <T>(currentItems: readonly T[], newItems: undefined | readonly T[], compareItems?: ItemComparator<T>) => readonly T[];
+export declare const containsSubsetOfItems: <T>(allItems: readonly T[], comparedItems: readonly T[]) => boolean;
+export declare const getMissingItems: <T, I>(sourceItems: readonly T[], items: readonly I[], identity: (s: T) => I) => I[];
 /**
  * Given an ordered list of item names, return items in same order
  */

package/types/column-utils.d.ts

@@ -171,39 +171,7 @@ export declare const setCalculatedColumnType: (column: ColumnDescriptor, serverD
 export declare const setCalculatedColumnExpression: (column: ColumnDescriptor, expression: string) => ColumnDescriptor;
 export declare const moveColumnTo: (columns: ColumnDescriptor[], column: ColumnDescriptor, newIndex: number) => ColumnDescriptor[];
 export declare function replaceColumn<C extends ColumnDescriptor = RuntimeColumnDescriptor>(columns: readonly C[], column: C): C[];
-export declare const applyDefaultColumnConfig: ({ columns: columnsProp, table }: TableSchema, getDefaultColumnConfig?: DefaultColumnConfiguration, includeVuuDefaultColumns?: boolean) => (SchemaColumn | {
-    aggregate?: VuuAggType;
-    align?: ColumnAlignment;
-    allowColumnHeaderMenu?: false;
-    className?: string;
-    colHeaderContentRenderer?: string;
-    colHeaderLabelRenderer?: string;
-    exportFormatter?: (value: unknown) => string;
-    flex?: number;
-    getIcon?: (row: DataRow) => string | undefined;
-    groupable?: boolean;
-    heading?: string[];
-    hidden?: boolean;
-    isSystemColumn?: boolean;
-    locked?: Exclude<PinLocation, "left"> | false;
-    maxWidth?: number;
-    minWidth?: number;
-    pin?: PinLocation | false;
-    removeable?: boolean;
-    resizeable?: boolean;
-    selected?: boolean;
-    sortable?: boolean;
-    source?: "client" | "server";
-    status?: import("@salt-ds/core").ValidationStatus;
-    width?: number;
-    editableBulk?: import("@vuu-ui/vuu-data-types").BulkEdit;
-    label?: string;
-    required?: boolean;
-    type?: DataValueType;
-    editable?: import("@vuu-ui/vuu-data-types").DataEditable | undefined;
-    name: string;
-    serverDataType: VuuColumnDataType;
-})[] | readonly SchemaColumn[];
+export declare const applyDefaultColumnConfig: ({ columns: columnsProp, table }: TableSchema, getDefaultColumnConfig?: DefaultColumnConfiguration, includeVuuDefaultColumns?: boolean) => readonly SchemaColumn[];
 export type columnOptions = {
     availableWidth?: number;
     columnLayout?: ColumnLayout;