nuxt-ui-tools 0.1.3 → 1.0.0

package/dist/runtime/shared/utils/object.js

@@ -1,38 +1,46 @@
+import { isObject } from "./predicate.js";
 export function omit(obj, keys) {
   const result = structuredClone(obj);
   for (const path of keys) {
     const parts = path.split(".");
     if (parts.length === 1) {
-      delete result?.[parts?.[0] ?? ""];
+      delete result[parts[0] ?? ""];
       continue;
     }
     let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i] ?? "";
-      if (current === void 0 || current === null) break;
-      if (Array.isArray(current[part])) {
-        const remainingPath = parts.slice(i + 1).join(".");
-        const remainingParts = remainingPath.split(".");
-        for (const item of current[part]) {
-          if (item && typeof item === "object") {
-            let itemCurrent = item;
-            for (let j = 0; j < remainingParts.length - 1; j++) {
-              if (itemCurrent === void 0 || itemCurrent === null) break;
-              itemCurrent = itemCurrent[remainingParts[j] ?? ""];
-            }
-            if (itemCurrent !== void 0 && itemCurrent !== null) {
-              delete itemCurrent[remainingParts[remainingParts.length - 1] ?? ""];
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      const part = parts[index] ?? "";
+      const child = current[part];
+      if (Array.isArray(child)) {
+        const remainingParts = parts.slice(index + 1);
+        for (const item of child) {
+          if (!isObject(item)) {
+            continue;
+          }
+          let itemCurrent = item;
+          for (const remainingPart of remainingParts.slice(0, -1)) {
+            const nested = itemCurrent[remainingPart];
+            if (!isObject(nested)) {
+              break;
             }
+            itemCurrent = nested;
+          }
+          const lastPart2 = remainingParts.at(-1);
+          if (lastPart2 !== void 0) {
+            delete itemCurrent[lastPart2];
           }
         }
         break;
-      } else {
-        current = current[part];
       }
+      if (!isObject(child)) {
+        break;
+      }
+      current = child;
     }
-    if (current !== void 0 && current !== null && !Array.isArray(result[parts[0] ?? ""])) {
-      const lastPart = parts[parts.length - 1];
-      delete current[lastPart ?? ""];
+    const firstPart = parts[0];
+    const lastPart = parts.at(-1);
+    if (firstPart !== void 0 && lastPart !== void 0 && !Array.isArray(result[firstPart])) {
+      delete current[lastPart];
     }
   }
   return result;
@@ -43,24 +51,36 @@ export function pick(obj, keys) {
     const parts = path.split(".");
     let current = obj;
     let target = result;
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i] ?? "";
-      const isLast = i === parts.length - 1;
-      if (current === void 0 || current === null) break;
+    for (let index = 0; index < parts.length; index += 1) {
+      const part = parts[index];
+      if (part === void 0) {
+        continue;
+      }
+      const isLast = index === parts.length - 1;
       if (isLast) {
         target[part] = current[part];
-      } else {
-        target[part] = target[part] || {};
-        target = target[part];
-        current = current[part];
+        continue;
+      }
+      const nextTarget = isObject(target[part]) ? target[part] : {};
+      target[part] = nextTarget;
+      target = nextTarget;
+      const nextCurrent = current[part];
+      if (!isObject(nextCurrent)) {
+        break;
       }
+      current = nextCurrent;
     }
   }
   return result;
 }
 export function getObjectProperty(source, path) {
-  return path.split(".").reduce((current, segment) => {
-    if (!current || typeof current !== "object") return void 0;
-    return current[segment];
-  }, source);
+  return path.split(".").reduce(
+    (current, segment) => {
+      if (!isObject(current)) {
+        return;
+      }
+      return current[segment];
+    },
+    isObject(source) ? source : void 0
+  );
 }

package/dist/runtime/shared/utils/path.d.ts

@@ -1,9 +1,11 @@
 import type { GenericObject } from '../types/utils.js';
+type PathValue = GenericObject[string];
 export declare function pathSegments(path: string | readonly string[]): string[];
-export declare function getPathValue(source: unknown, path: string | readonly string[]): unknown;
+export declare function getPathValue<T>(source: T, path: string | readonly string[]): unknown;
 export declare function relativePathSegments(parentPath: readonly string[], key?: string): string[];
 export declare function getScopedPathValue(source: GenericObject, key: string, parentPath: readonly string[]): unknown;
-export declare function setPathValue(target: GenericObject, path: string | readonly string[], value: unknown): void;
-export declare function cloneValue(value: unknown): unknown;
+export declare function setPathValue<T extends GenericObject>(target: T, path: string | readonly string[], value: PathValue): void;
+export declare function cloneValue<T>(value: T): PathValue;
 export declare function mergeObjects(target: GenericObject, source: GenericObject): void;
-export declare function isRecord(value: unknown): value is GenericObject;
+export declare function isRecord<T>(value: T): value is T & GenericObject;
+export {};

package/dist/runtime/shared/utils/path.js

@@ -1,12 +1,18 @@
+import { isObject, isString } from "./predicate.js";
 export function pathSegments(path) {
-  const rawSegments = typeof path === "string" ? path.split(".") : path;
+  const rawSegments = isString(path) ? path.split(".") : path;
   return rawSegments.flatMap((segment) => segment.split(".")).filter(Boolean);
 }
 export function getPathValue(source, path) {
-  return pathSegments(path).reduce((current, segment) => {
-    if (!isPathContainer(current)) return void 0;
-    return getContainerValue(current, segment);
-  }, source);
+  return pathSegments(path).reduce(
+    (current, segment) => {
+      if (!isPathContainer(current)) {
+        return;
+      }
+      return getContainerValue(current, segment);
+    },
+    isPathContainer(source) ? source : void 0
+  );
 }
 export function relativePathSegments(parentPath, key = "") {
   const offset = scopedPathOffset(key);
@@ -17,8 +23,12 @@ export function relativePathSegments(parentPath, key = "") {
   ].flatMap((segment) => segment.split(".")).filter(Boolean);
 }
 export function getScopedPathValue(source, key, parentPath) {
-  if (key === "$root") return source;
-  if (key.includes("$parent")) return getPathValue(source, relativePathSegments(parentPath, key));
+  if (key === "$root") {
+    return source;
+  }
+  if (key.includes("$parent")) {
+    return getPathValue(source, relativePathSegments(parentPath, key));
+  }
   return getPathValue(source, key);
 }
 export function setPathValue(target, path, value) {
@@ -40,10 +50,16 @@ export function setPathValue(target, path, value) {
   });
 }
 export function cloneValue(value) {
-  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
-  if (!isRecord(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneValue(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
   const output = {};
-  for (const [key, child] of Object.entries(value)) output[key] = cloneValue(child);
+  for (const [key, child] of Object.entries(value)) {
+    output[key] = cloneValue(child);
+  }
   return output;
 }
 export function mergeObjects(target, source) {
@@ -56,13 +72,15 @@ export function mergeObjects(target, source) {
   }
 }
 export function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return isObject(value) && !Array.isArray(value);
 }
 function isPathContainer(value) {
   return isRecord(value) || Array.isArray(value);
 }
 function getContainerValue(container, segment) {
-  if (Array.isArray(container)) return container[Number(segment)];
+  if (Array.isArray(container)) {
+    return container[Number(segment)];
+  }
   return container[segment];
 }
 function setContainerValue(container, segment, value) {
@@ -73,7 +91,7 @@ function setContainerValue(container, segment, value) {
   container[segment] = value;
 }
 function shouldCreateArray(segment) {
-  return typeof segment === "string" && /^\d+$/.test(segment);
+  return segment !== void 0 && /^\d+$/u.test(segment);
 }
 function scopedPathOffset(key) {
   const firstSegment = key.split(".")[0];

package/dist/runtime/shared/utils/predicate.d.ts

@@ -1,213 +1,106 @@
-/**
- * Type predicate to filter out null and undefined values from arrays.
- * @example
- * const arr = [1, null, 2, undefined, 3]
- * const filtered = arr.filter(isDefined) // typed as number[]
- */
+import type { GenericObject } from '../types/utils.js';
+/** A record whose values are decoded by the owning boundary. */
+export type Dictionary = object;
+type FunctionValue = (...args: never[]) => GenericObject[string];
+type FunctionLike<T> = T extends (...args: infer TArgs) => infer TResult ? (...args: TArgs) => TResult : FunctionValue;
+/** Type predicate to filter out null and undefined values from arrays. */
 export declare function isDefined<T>(value: T): value is NonNullable<T>;
-/**
- * Type predicate to check if a value is null.
- */
-export declare function isNull(value: unknown): value is null;
-/**
- * Type predicate to check if a value is undefined.
- */
-export declare function isUndefined(value: unknown): value is undefined;
-/**
- * Type predicate to check if a value is null or undefined.
- */
-export declare function isNullish(value: unknown): value is null | undefined;
-/**
- * Type predicate to check if a value is a string.
- */
-export declare function isString(value: unknown): value is string;
-/**
- * Type predicate to check if a value is a non-empty string.
- */
-export declare function isNonEmptyString(value: unknown): value is string;
-/**
- * Type predicate to check if a value is a number (excluding NaN).
- */
-export declare function isNumber(value: unknown): value is number;
-/**
- * Type predicate to check if a value is a finite number.
- */
-export declare function isFiniteNumber(value: unknown): value is number;
-/**
- * Type predicate to check if a value is an integer.
- */
-export declare function isInteger(value: unknown): value is number;
-/**
- * Type predicate to check if a value is a positive number.
- */
-export declare function isPositiveNumber(value: unknown): value is number;
-/**
- * Type predicate to check if a value is a non-negative number (>= 0).
- */
-export declare function isNonNegativeNumber(value: unknown): value is number;
-/**
- * Type predicate to check if a value is a boolean.
- */
-export declare function isBoolean(value: unknown): value is boolean;
-/**
- * Type predicate to check if a value is a function.
- */
-export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
-/**
- * Type predicate to check if a value is an object (excluding null).
- */
-export declare function isObject(value: unknown): value is Record<string, unknown>;
-/**
- * Type predicate to check if a value is a symbol.
- */
-export declare function isSymbol(value: unknown): value is symbol;
-/**
- * Type predicate to check if a value is a bigint.
- */
-export declare function isBigInt(value: unknown): value is bigint;
-/**
- * Type predicate to check if a value is a Date object.
- */
-export declare function isDate(value: unknown): value is Date;
-/**
- * Type predicate to check if a value is a valid Date object.
- */
-export declare function isValidDate(value: unknown): value is Date;
-/**
- * Type predicate to check if a value is a RegExp.
- */
-export declare function isRegExp(value: unknown): value is RegExp;
-/**
- * Type predicate to check if a value is a Promise.
- */
-export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
-/**
- * Type predicate to check if a value is an Error.
- */
-export declare function isError(value: unknown): value is Error;
-/**
- * Type predicate to check if a value is a plain object (not null, not array, not class instance).
- */
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/**
- * Type predicate to check if a value is an array.
- */
-export declare function isArray<T = unknown>(value: unknown): value is T[];
-/**
- * Type predicate to check if a value is a non-empty array.
- */
-export declare function isNonEmptyArray<T>(value: T[]): value is [T, ...T[]];
-export declare function isNonEmptyArray(value: unknown): value is [unknown, ...unknown[]];
-/**
- * Type predicate to check if a value is an array of a specific type.
- */
-export declare function isArrayOf<T>(value: unknown, predicate: (item: unknown) => item is T): value is T[];
-/**
- * Type predicate to check if a value is a non-empty plain object.
- */
-export declare function isNonEmptyObject(value: unknown): value is Record<string, unknown>;
-/**
- * Type predicate to check if a value is a primitive (string, number, boolean, null, undefined, symbol, bigint).
- */
-export declare function isPrimitive(value: unknown): value is string | number | boolean | null | undefined | symbol | bigint;
-/**
- * Type predicate to check if a value has a specific property.
- */
-export declare function hasProperty<K extends PropertyKey>(value: unknown, key: K): value is Record<K, unknown>;
-/**
- * Type predicate to check if a value has specific properties.
- */
-export declare function hasProperties<K extends PropertyKey>(value: unknown, keys: K[]): value is Record<K, unknown>;
-/**
- * Type predicate to check if a value has a property with a specific type.
- */
-export declare function hasTypedProperty<K extends PropertyKey, T>(value: unknown, key: K, predicate: (prop: unknown) => prop is T): value is Record<K, T>;
-/**
- * Creates a type predicate that checks if a value equals one of the given values.
- * @example
- * const isStatus = isOneOf(['pending', 'active', 'completed'] as const)
- * if (isStatus(value)) { // value is 'pending' | 'active' | 'completed' }
- */
-export declare function isOneOf<const T extends readonly unknown[]>(values: T): (value: unknown) => value is T[number];
-/**
- * Creates a negated type predicate.
- * @example
- * const isNotNull = not(isNull)
- * const values = [1, null, 2].filter(isNotNull) // typed as (number | null)[] -> filters nulls
- */
+/** Type predicate to check if a value is null. */
+export declare function isNull<T>(value: T): value is T & null;
+/** Type predicate to check if a value is undefined. */
+export declare function isUndefined<T>(value: T): value is T & undefined;
+/** Type predicate to check if a value is null or undefined. */
+export declare function isNullish<T>(value: T): value is T & (null | undefined);
+/** Type predicate to check if a value is a string. */
+export declare function isString<T>(value: T): value is T & string;
+/** Type predicate to check if a value is a non-empty string. */
+export declare function isNonEmptyString<T>(value: T): value is T & string;
+/** Type predicate to check if a value is a number (excluding NaN). */
+export declare function isNumber<T>(value: T): value is T & number;
+/** Type predicate to check if a value is a finite number. */
+export declare function isFiniteNumber<T>(value: T): value is T & number;
+/** Type predicate to check if a value is an integer. */
+export declare function isInteger<T>(value: T): value is T & number;
+/** Type predicate to check if a value is a positive number. */
+export declare function isPositiveNumber<T>(value: T): value is T & number;
+/** Type predicate to check if a value is a non-negative number. */
+export declare function isNonNegativeNumber<T>(value: T): value is T & number;
+/** Type predicate to check if a value is a boolean. */
+export declare function isBoolean<T>(value: T): value is T & boolean;
+/** Type predicate to check if a value is callable, including async and generator functions. */
+export declare function isFunction<T>(value: T): value is T & FunctionLike<T>;
+/** Type predicate to check if a value is an object (excluding null and arrays). */
+export declare function isObject<T>(value: T): value is T & GenericObject;
+/** Type predicate to check if a value is a symbol. */
+export declare function isSymbol<T>(value: T): value is T & symbol;
+/** Type predicate to check if a value is a bigint. */
+export declare function isBigInt<T>(value: T): value is T & bigint;
+/** Type predicate to check if a value is a Date object with a valid timestamp. */
+export declare function isDate<T>(value: T): value is T & Date;
+/** Type predicate to check if a value is a valid Date object. */
+export declare function isValidDate<T>(value: T): value is T & Date;
+/** Type predicate to check if a value is a RegExp. */
+export declare function isRegExp<T>(value: T): value is T & RegExp;
+/** Type predicate to check if a value is a Promise. */
+export declare function isPromise<T>(value: T): value is T & Promise<unknown>;
+/** Type predicate to check if a value is an Error. */
+export declare function isError<T>(value: T): value is T & Error;
+/** Type predicate to check if a value is a plain object. */
+export declare function isPlainObject<T>(value: T): value is T & GenericObject;
+/** Type predicate to check if a value is an array. */
+export declare function isArray<T, TItem = never>(value: T): value is T & TItem[];
+/** Type predicate to check if a value is a non-empty array. */
+export declare function isNonEmptyArray<T, TItem = never>(value: T): value is T & [TItem, ...TItem[]];
+/** Type predicate to check if a value is an array whose items match a predicate. */
+export declare function isArrayOf<T, TItem extends T>(value: T, predicate: (item: T & TItem) => item is TItem): value is T & TItem[];
+/** Type predicate to check if a value is a non-empty plain object. */
+export declare function isNonEmptyObject<T>(value: T): value is T & GenericObject;
+/** Type predicate to check if a value is a primitive. */
+export declare function isPrimitive<T>(value: T): value is T & (string | number | boolean | null | undefined | symbol | bigint);
+/** Type predicate to check if a value has a specific property. */
+export declare function hasProperty<T, K extends PropertyKey>(value: T, key: K): value is T & GenericObject;
+/** Type predicate to check if a value has specific properties. */
+export declare function hasProperties<T, K extends PropertyKey>(value: T, keys: K[]): value is T & GenericObject;
+/** Type predicate to check if a value has a property with a specific type. */
+export declare function hasTypedProperty<T, K extends string, TValue>(value: T, key: K, predicate: (property: GenericObject[string]) => property is GenericObject[string] & TValue): boolean;
+/** Creates a type predicate that checks if a value equals one of the given values. */
+export declare function isOneOf<const T extends readonly PropertyKey[]>(values: T): <TValue>(value: TValue) => value is TValue & T[number];
+/** Creates a negated type predicate. */
 export declare function not<T, S extends T>(predicate: (value: T) => value is S): (value: T) => value is Exclude<T, S>;
-/**
- * Creates a type predicate that checks if a value matches all predicates.
- */
-export declare function all<T, S extends T>(...predicates: Array<(value: T) => value is S>): (value: T) => value is S;
-/**
- * Creates a type predicate that checks if a value matches any of the predicates.
- */
-export declare function some<T, S extends T>(...predicates: Array<(value: T) => value is S>): (value: T) => value is S;
-/**
- * Type predicate to check if a value is truthy.
- * Filters out: false, 0, '', null, undefined, NaN
- */
+/** Creates a type predicate that checks if a value matches all predicates. */
+export declare function all<T, S extends T>(...predicates: ((value: T) => value is S)[]): (value: T) => value is S;
+/** Creates a type predicate that checks if a value matches any predicate. */
+export declare function some<T, S extends T>(...predicates: ((value: T) => value is S)[]): (value: T) => value is S;
+/** Type predicate to check if a value is truthy. */
 export declare function isTruthy<T>(value: T): value is Exclude<T, false | 0 | '' | null | undefined>;
-/**
- * Type predicate to check if a value is falsy.
- */
-export declare function isFalsy(value: unknown): value is false | 0 | '' | null | undefined;
-/**
- * Type predicate to check if a string matches a pattern.
- */
-export declare function matchesPattern(pattern: RegExp): (value: unknown) => value is string;
-/**
- * Type predicate to check if a value is a valid email string.
- */
-export declare function isEmail(value: unknown): value is string;
-/**
- * Type predicate to check if a value is a valid URL string.
- */
-export declare function isURL(value: unknown): value is string;
-/**
- * Type predicate to check if a value is a valid UUID string.
- */
-export declare const isUUID: (value: unknown) => value is string;
-/**
- * Type predicate to check if a value is an instance of a class.
- */
-export declare function isInstanceOf<T>(constructor: new (...args: any[]) => T): (value: unknown) => value is T;
-/**
- * Type predicate to check if a value is a Map.
- */
-export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
-/**
- * Type predicate to check if a value is a Set.
- */
-export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
-/**
- * Type predicate to check if a value is a WeakMap.
- */
-export declare function isWeakMap<K extends WeakKey = WeakKey, V = unknown>(value: unknown): value is WeakMap<K, V>;
-/**
- * Type predicate to check if a value is a WeakSet.
- */
-export declare function isWeakSet<T extends WeakKey = WeakKey>(value: unknown): value is WeakSet<T>;
-/**
- * Type predicate to check if a value is iterable.
- */
-export declare function isIterable<T = unknown>(value: unknown): value is Iterable<T>;
-/**
- * Type predicate to check if a value is an ArrayBuffer.
- */
-export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
-/**
- * Type predicate to check if a value is a TypedArray.
- */
-export declare function isTypedArray(value: unknown): value is Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-/**
- * Asserts that a value satisfies a type predicate, throwing if it doesn't.
- * @throws {Error} If the value doesn't satisfy the predicate
- */
-export declare function assertType<T>(value: unknown, predicate: (value: unknown) => value is T, message?: string): asserts value is T;
-/**
- * Asserts that a value is defined (not null or undefined).
- * @throws {Error} If the value is null or undefined
- */
+/** Type predicate to check if a value is falsy. */
+export declare function isFalsy<T>(value: T): value is T & (false | 0 | '' | null | undefined);
+/** Type predicate to check if a string matches a pattern. */
+export declare function matchesPattern(pattern: RegExp): <T>(value: T) => value is T & string;
+/** Type predicate to check if a value is a valid email string. */
+export declare function isEmail<T>(value: T): value is T & string;
+/** Type predicate to check if a value is a valid URL string. */
+export declare function isURL<T>(value: T): value is T & string;
+/** Type predicate to check if a value is a valid UUID string. */
+export declare const isUUID: <T>(value: T) => value is T & string;
+/** Creates a predicate that checks if a value is an instance of a class. */
+export declare function isInstanceOf<T, C extends abstract new (...args: never[]) => T>(constructor: C): <TValue>(value: TValue) => value is TValue & T;
+/** Type predicate to check if a value is a Map. */
+export declare function isMap<T, K = never, V = never>(value: T): value is T & Map<K, V>;
+/** Type predicate to check if a value is a Set. */
+export declare function isSet<T, TValue = never>(value: T): value is T & Set<TValue>;
+/** Type predicate to check if a value is a WeakMap. */
+export declare function isWeakMap<T, K extends WeakKey = WeakKey, V = never>(value: T): value is T & WeakMap<K, V>;
+/** Type predicate to check if a value is a WeakSet. */
+export declare function isWeakSet<T, TValue extends WeakKey = WeakKey>(value: T): value is T & WeakSet<TValue>;
+/** Type predicate to check if a value is iterable. */
+export declare function isIterable<T>(value: T): value is T & Iterable<unknown>;
+/** Type predicate to check if a value is an ArrayBuffer. */
+export declare function isArrayBuffer<T>(value: T): value is T & ArrayBuffer;
+/** Type predicate to check if a value is a TypedArray. */
+export declare function isTypedArray<T>(value: T): value is T & ArrayBufferView;
+/** Asserts that a value satisfies a type predicate. */
+export declare function assertType<TValue, T>(value: TValue, predicate: (value: TValue) => value is TValue & T, message?: string): asserts value is TValue & T;
+/** Asserts that a value is defined (not null or undefined). */
 export declare function assertDefined<T>(value: T, message?: string): asserts value is NonNullable<T>;
+export {};