@ls-stack/utils 3.13.0 → 3.15.0

package/lib/arrayUtils.cjs

@@ -34,11 +34,14 @@ __export(arrayUtils_exports, {
 });
 module.exports = __toCommonJS(arrayUtils_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isFunction(value) {
   return typeof value === "function";
 }
 
+// src/assertions.ts
+var isFunction2 = isFunction;
+
 // src/arrayUtils.ts
 function filterAndMap(array, mapFilter) {
   const result = [];
@@ -145,7 +148,7 @@ function truncateArray(array, maxLength, appendIfTruncated) {
   const truncate = array.length > maxLength;
   const result = truncate ? [...array.slice(0, maxLength)] : array;
   if (truncate && appendIfTruncated) {
-    if (isFunction(appendIfTruncated)) {
+    if (isFunction2(appendIfTruncated)) {
       return [...result, appendIfTruncated(array.length - maxLength)];
     }
     return [...result, appendIfTruncated];

package/lib/arrayUtils.js

@@ -10,8 +10,9 @@ import {
   rejectDuplicates,
   sortBy,
   truncateArray
-} from "./chunk-UTFE4P3P.js";
-import "./chunk-3XCS7FVO.js";
+} from "./chunk-DMW5Q4T2.js";
+import "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 export {
   arrayWithPrev,
   arrayWithPrevAndIndex,

package/lib/assertions.cjs

@@ -24,66 +24,74 @@ __export(assertions_exports, {
   assertIsNotUndefined: () => assertIsNotUndefined,
   exhaustiveCheck: () => exhaustiveCheck,
   invariant: () => invariant,
-  isFunction: () => isFunction,
-  isObject: () => isObject,
-  isPlainObject: () => isPlainObject,
-  isPromise: () => isPromise,
+  isFunction: () => isFunction2,
+  isObject: () => isObject2,
+  isPlainObject: () => isPlainObject2,
+  isPromise: () => isPromise2,
   notNullish: () => notNullish,
   notUndefined: () => notUndefined
 });
 module.exports = __toCommonJS(assertions_exports);
+
+// src/typeGuards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value && isFunction(value.then);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+
+// src/assertions.ts
 var undefErrMsg = "not undefined assertion failed";
 var nullishErrMsg = "not nullish assertion failed";
-function notUndefined(value, errorMsg = undefErrMsg) {
+function notUndefined(value, error = undefErrMsg) {
   if (value === void 0) {
-    throw new Error(errorMsg);
+    throw typeof error === "function" ? error() : new Error(error);
   }
   return value;
 }
-function notNullish(value, errorMsg = nullishErrMsg) {
+function notNullish(value, error = nullishErrMsg) {
   if (value === void 0 || value === null) {
-    throw new Error(errorMsg);
+    throw typeof error === "function" ? error() : new Error(error);
   }
   return value;
 }
-function assertIsNotNullish(value, errorMsg = nullishErrMsg) {
+function assertIsNotNullish(value, error = nullishErrMsg) {
   if (value === void 0 || value === null) {
-    throw new Error(errorMsg);
+    throw typeof error === "function" ? error() : new Error(error);
   }
 }
-function assertIsNotUndefined(value, errorMsg = undefErrMsg) {
+function assertIsNotUndefined(value, error = undefErrMsg) {
   if (value === void 0) {
-    throw new Error(errorMsg);
+    throw typeof error === "function" ? error() : new Error(error);
   }
 }
-function invariant(condition, errorMsg = "Invariant violation") {
+function invariant(condition, error = "Invariant violation") {
   if (!condition) {
-    throw new Error(`Invariant violation: ${errorMsg}`);
+    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
   }
 }
 function exhaustiveCheck(narrowedType) {
   return new Error("This should never happen");
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isPromise(value) {
-  return isObject(value) && "then" in value && isFunction(value.then);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object) return true;
-  const objectCtorString = Object.prototype.constructor.toString();
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
+var isFunction2 = isFunction;
+var isObject2 = isObject;
+var isPlainObject2 = isPlainObject;
+var isPromise2 = isPromise;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assertIsNotNullish,

package/lib/assertions.d.cts

@@ -1,17 +1,181 @@
+import { isFunction as isFunction$1, isObject as isObject$1, isPlainObject as isPlainObject$1, isPromise as isPromise$1 } from './typeGuards.cjs';
+
 type NotUndefined<T> = T extends undefined ? never : T;
 type StrictNonUndefined<T, N = unknown> = undefined extends T ? NotUndefined<T> : N;
-declare function notUndefined<T>(value: T, errorMsg?: string): StrictNonUndefined<T>;
+/**
+ * Ensures a value is not undefined and returns it with the correct type.
+ *
+ * Throws an error if the value is undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to check for undefined
+ * @param error - Error message string or function that returns an Error to throw if value is undefined
+ * @returns The input value with undefined excluded from its type
+ * @throws {Error} When the value is undefined
+ *
+ * @example
+ * ```typescript
+ * const maybeString: string | undefined = getValue();
+ * const definiteString = notUndefined(maybeString); // Type: string
+ *
+ * // With custom error message
+ * const value = notUndefined(maybeValue, 'Value must be defined');
+ *
+ * // With custom error function
+ * const value = notUndefined(maybeValue, () => new ValidationError('Required field'));
+ * ```
+ */
+declare function notUndefined<T>(value: T, error?: string | (() => Error)): StrictNonUndefined<T>;
 type StrictNonNullable<T, N = unknown> = undefined extends T ? NonNullable<T> : null extends T ? NonNullable<T> : N;
-declare function notNullish<T>(value: T, errorMsg?: string): StrictNonNullable<T>;
-declare function assertIsNotNullish<T>(value: T, errorMsg?: string): asserts value is StrictNonNullable<T, never>;
-declare function assertIsNotUndefined<T>(value: T, errorMsg?: string): asserts value is StrictNonUndefined<T, never>;
-/** Use this function to assert that a certain condition is always true. */
-declare function invariant(condition: any, errorMsg?: string): asserts condition;
-/** ensures all type possibilities are being handled */
+/**
+ * Ensures a value is not null or undefined and returns it with the correct type.
+ *
+ * Throws an error if the value is null or undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to check for null or undefined
+ * @param error - Error message string or function that returns an Error to throw if value is nullish
+ * @returns The input value with null and undefined excluded from its type
+ * @throws {Error} When the value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const maybeString: string | null | undefined = getValue();
+ * const definiteString = notNullish(maybeString); // Type: string
+ *
+ * // With custom error message
+ * const value = notNullish(maybeValue, 'Value cannot be null or undefined');
+ *
+ * // With custom error function
+ * const value = notNullish(maybeValue, () => new ValidationError('Required field'));
+ * ```
+ */
+declare function notNullish<T>(value: T, error?: string | (() => Error)): StrictNonNullable<T>;
+/**
+ * Asserts that a value is not null or undefined using TypeScript's assertion signature.
+ *
+ * Throws an error if the value is null or undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to assert is not null or undefined
+ * @param error - Error message string or function that returns an Error to throw if value is nullish
+ * @throws {Error} When the value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * function processValue(input: string | null | undefined) {
+ *   assertIsNotNullish(input);
+ *   // TypeScript now knows input is string
+ *   console.log(input.toUpperCase());
+ * }
+ *
+ * // With custom error
+ * assertIsNotNullish(value, 'Value is required for processing');
+ * ```
+ */
+declare function assertIsNotNullish<T>(value: T, error?: string | (() => Error)): asserts value is StrictNonNullable<T, never>;
+/**
+ * Asserts that a value is not undefined using TypeScript's assertion signature.
+ *
+ * Throws an error if the value is undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to assert is not undefined
+ * @param error - Error message string or function that returns an Error to throw if value is undefined
+ * @throws {Error} When the value is undefined
+ *
+ * @example
+ * ```typescript
+ * function processValue(input: string | undefined) {
+ *   assertIsNotUndefined(input);
+ *   // TypeScript now knows input is string
+ *   console.log(input.toUpperCase());
+ * }
+ *
+ * // With custom error
+ * assertIsNotUndefined(value, 'Value must be defined');
+ * ```
+ */
+declare function assertIsNotUndefined<T>(value: T, error?: string | (() => Error)): asserts value is StrictNonUndefined<T, never>;
+/**
+ * Asserts that a condition is always true, throwing an error if it's falsy.
+ *
+ * This function is useful for enforcing invariants in your code - conditions that
+ * should always be true. It uses TypeScript's assertion signature to narrow types
+ * based on the condition.
+ *
+ * @param condition - The condition to check (any truthy/falsy value)
+ * @param error - Error message string or function that returns an Error to throw if condition is falsy
+ * @throws {Error} When the condition is falsy
+ *
+ * @example
+ * ```typescript
+ * function divide(a: number, b: number) {
+ *   invariant(b !== 0, 'Division by zero is not allowed');
+ *   return a / b;
+ * }
+ *
+ * // Type narrowing example
+ * function processUser(user: User | null) {
+ *   invariant(user, 'User must be logged in');
+ *   // TypeScript now knows user is User, not null
+ *   console.log(user.name);
+ * }
+ *
+ * // With custom error function
+ * invariant(isValid, () => new ValidationError('Invalid state detected'));
+ * ```
+ */
+declare function invariant(condition: any, error?: string | (() => Error)): asserts condition;
+/**
+ * Ensures exhaustive type checking in switch statements or conditional logic.
+ *
+ * This function should be used in the default case of switch statements or
+ * the final else branch of conditional logic to ensure all possible cases
+ * are handled. It helps catch missing cases at compile time when new union
+ * members are added.
+ *
+ * @template Except - The type that should never be reached
+ * @param narrowedType - The value that should never exist at runtime
+ * @returns An Error object (this function should never actually execute)
+ *
+ * @example
+ * ```typescript
+ * type Status = 'pending' | 'success' | 'error';
+ *
+ * function handleStatus(status: Status) {
+ *   switch (status) {
+ *     case 'pending':
+ *       return 'Loading...';
+ *     case 'success':
+ *       return 'Done!';
+ *     case 'error':
+ *       return 'Failed!';
+ *     default:
+ *       throw exhaustiveCheck(status); // TypeScript error if Status gains new members
+ *   }
+ * }
+ *
+ * // In conditional logic
+ * function processValue(value: string | number) {
+ *   if (typeof value === 'string') {
+ *     return value.toUpperCase();
+ *   } else if (typeof value === 'number') {
+ *     return value.toString();
+ *   } else {
+ *     throw exhaustiveCheck(value); // Ensures all cases are covered
+ *   }
+ * }
+ * ```
+ */
 declare function exhaustiveCheck<Except = never>(narrowedType: NoInfer<Except>): Error;
-declare function isObject(value: unknown): value is Record<string, unknown>;
-declare function isFunction(value: unknown): value is (...args: any[]) => any;
-declare function isPromise(value: unknown): value is Promise<unknown>;
-declare function isPlainObject(value: any): value is Record<string, unknown>;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isFunction: typeof isFunction$1;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isObject: typeof isObject$1;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isPlainObject: typeof isPlainObject$1;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isPromise: typeof isPromise$1;
 
 export { assertIsNotNullish, assertIsNotUndefined, exhaustiveCheck, invariant, isFunction, isObject, isPlainObject, isPromise, notNullish, notUndefined };

package/lib/assertions.d.ts

@@ -1,17 +1,181 @@
+import { isFunction as isFunction$1, isObject as isObject$1, isPlainObject as isPlainObject$1, isPromise as isPromise$1 } from './typeGuards.js';
+
 type NotUndefined<T> = T extends undefined ? never : T;
 type StrictNonUndefined<T, N = unknown> = undefined extends T ? NotUndefined<T> : N;
-declare function notUndefined<T>(value: T, errorMsg?: string): StrictNonUndefined<T>;
+/**
+ * Ensures a value is not undefined and returns it with the correct type.
+ *
+ * Throws an error if the value is undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to check for undefined
+ * @param error - Error message string or function that returns an Error to throw if value is undefined
+ * @returns The input value with undefined excluded from its type
+ * @throws {Error} When the value is undefined
+ *
+ * @example
+ * ```typescript
+ * const maybeString: string | undefined = getValue();
+ * const definiteString = notUndefined(maybeString); // Type: string
+ *
+ * // With custom error message
+ * const value = notUndefined(maybeValue, 'Value must be defined');
+ *
+ * // With custom error function
+ * const value = notUndefined(maybeValue, () => new ValidationError('Required field'));
+ * ```
+ */
+declare function notUndefined<T>(value: T, error?: string | (() => Error)): StrictNonUndefined<T>;
 type StrictNonNullable<T, N = unknown> = undefined extends T ? NonNullable<T> : null extends T ? NonNullable<T> : N;
-declare function notNullish<T>(value: T, errorMsg?: string): StrictNonNullable<T>;
-declare function assertIsNotNullish<T>(value: T, errorMsg?: string): asserts value is StrictNonNullable<T, never>;
-declare function assertIsNotUndefined<T>(value: T, errorMsg?: string): asserts value is StrictNonUndefined<T, never>;
-/** Use this function to assert that a certain condition is always true. */
-declare function invariant(condition: any, errorMsg?: string): asserts condition;
-/** ensures all type possibilities are being handled */
+/**
+ * Ensures a value is not null or undefined and returns it with the correct type.
+ *
+ * Throws an error if the value is null or undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to check for null or undefined
+ * @param error - Error message string or function that returns an Error to throw if value is nullish
+ * @returns The input value with null and undefined excluded from its type
+ * @throws {Error} When the value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const maybeString: string | null | undefined = getValue();
+ * const definiteString = notNullish(maybeString); // Type: string
+ *
+ * // With custom error message
+ * const value = notNullish(maybeValue, 'Value cannot be null or undefined');
+ *
+ * // With custom error function
+ * const value = notNullish(maybeValue, () => new ValidationError('Required field'));
+ * ```
+ */
+declare function notNullish<T>(value: T, error?: string | (() => Error)): StrictNonNullable<T>;
+/**
+ * Asserts that a value is not null or undefined using TypeScript's assertion signature.
+ *
+ * Throws an error if the value is null or undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to assert is not null or undefined
+ * @param error - Error message string or function that returns an Error to throw if value is nullish
+ * @throws {Error} When the value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * function processValue(input: string | null | undefined) {
+ *   assertIsNotNullish(input);
+ *   // TypeScript now knows input is string
+ *   console.log(input.toUpperCase());
+ * }
+ *
+ * // With custom error
+ * assertIsNotNullish(value, 'Value is required for processing');
+ * ```
+ */
+declare function assertIsNotNullish<T>(value: T, error?: string | (() => Error)): asserts value is StrictNonNullable<T, never>;
+/**
+ * Asserts that a value is not undefined using TypeScript's assertion signature.
+ *
+ * Throws an error if the value is undefined. Use it instead of `!` operator for better type safety.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to assert is not undefined
+ * @param error - Error message string or function that returns an Error to throw if value is undefined
+ * @throws {Error} When the value is undefined
+ *
+ * @example
+ * ```typescript
+ * function processValue(input: string | undefined) {
+ *   assertIsNotUndefined(input);
+ *   // TypeScript now knows input is string
+ *   console.log(input.toUpperCase());
+ * }
+ *
+ * // With custom error
+ * assertIsNotUndefined(value, 'Value must be defined');
+ * ```
+ */
+declare function assertIsNotUndefined<T>(value: T, error?: string | (() => Error)): asserts value is StrictNonUndefined<T, never>;
+/**
+ * Asserts that a condition is always true, throwing an error if it's falsy.
+ *
+ * This function is useful for enforcing invariants in your code - conditions that
+ * should always be true. It uses TypeScript's assertion signature to narrow types
+ * based on the condition.
+ *
+ * @param condition - The condition to check (any truthy/falsy value)
+ * @param error - Error message string or function that returns an Error to throw if condition is falsy
+ * @throws {Error} When the condition is falsy
+ *
+ * @example
+ * ```typescript
+ * function divide(a: number, b: number) {
+ *   invariant(b !== 0, 'Division by zero is not allowed');
+ *   return a / b;
+ * }
+ *
+ * // Type narrowing example
+ * function processUser(user: User | null) {
+ *   invariant(user, 'User must be logged in');
+ *   // TypeScript now knows user is User, not null
+ *   console.log(user.name);
+ * }
+ *
+ * // With custom error function
+ * invariant(isValid, () => new ValidationError('Invalid state detected'));
+ * ```
+ */
+declare function invariant(condition: any, error?: string | (() => Error)): asserts condition;
+/**
+ * Ensures exhaustive type checking in switch statements or conditional logic.
+ *
+ * This function should be used in the default case of switch statements or
+ * the final else branch of conditional logic to ensure all possible cases
+ * are handled. It helps catch missing cases at compile time when new union
+ * members are added.
+ *
+ * @template Except - The type that should never be reached
+ * @param narrowedType - The value that should never exist at runtime
+ * @returns An Error object (this function should never actually execute)
+ *
+ * @example
+ * ```typescript
+ * type Status = 'pending' | 'success' | 'error';
+ *
+ * function handleStatus(status: Status) {
+ *   switch (status) {
+ *     case 'pending':
+ *       return 'Loading...';
+ *     case 'success':
+ *       return 'Done!';
+ *     case 'error':
+ *       return 'Failed!';
+ *     default:
+ *       throw exhaustiveCheck(status); // TypeScript error if Status gains new members
+ *   }
+ * }
+ *
+ * // In conditional logic
+ * function processValue(value: string | number) {
+ *   if (typeof value === 'string') {
+ *     return value.toUpperCase();
+ *   } else if (typeof value === 'number') {
+ *     return value.toString();
+ *   } else {
+ *     throw exhaustiveCheck(value); // Ensures all cases are covered
+ *   }
+ * }
+ * ```
+ */
 declare function exhaustiveCheck<Except = never>(narrowedType: NoInfer<Except>): Error;
-declare function isObject(value: unknown): value is Record<string, unknown>;
-declare function isFunction(value: unknown): value is (...args: any[]) => any;
-declare function isPromise(value: unknown): value is Promise<unknown>;
-declare function isPlainObject(value: any): value is Record<string, unknown>;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isFunction: typeof isFunction$1;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isObject: typeof isObject$1;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isPlainObject: typeof isPlainObject$1;
+/** @deprecated use import from `@ls-stack/typeGuards` instead */
+declare const isPromise: typeof isPromise$1;
 
 export { assertIsNotNullish, assertIsNotUndefined, exhaustiveCheck, invariant, isFunction, isObject, isPlainObject, isPromise, notNullish, notUndefined };

package/lib/assertions.js

@@ -9,7 +9,8 @@ import {
   isPromise,
   notNullish,
   notUndefined
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 export {
   assertIsNotNullish,
   assertIsNotUndefined,

package/lib/cache.cjs

@@ -27,7 +27,7 @@ __export(cache_exports, {
 });
 module.exports = __toCommonJS(cache_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -38,6 +38,9 @@ function isPromise(value) {
   return isObject(value) && "then" in value && isFunction(value.then);
 }
 
+// src/assertions.ts
+var isPromise2 = isPromise;
+
 // src/time.ts
 var MINUTE_AS_MS = 60 * 1e3;
 var HOUR_AS_MS = 60 * MINUTE_AS_MS;
@@ -152,7 +155,7 @@ function createCache({
         cleanExpiredItems();
         return unwrappedValue.value;
       }
-      if (isPromise(entry.value)) {
+      if (isPromise2(entry.value)) {
         throw new Error(
           "Cache value is a promise, use getOrInsertAsync instead"
         );
@@ -161,7 +164,7 @@ function createCache({
     },
     async getOrInsertAsync(cacheKey, val, options) {
       const entry = cache.get(cacheKey);
-      if (entry && isPromise(entry.value)) {
+      if (entry && isPromise2(entry.value)) {
         return entry.value;
       }
       const now = Date.now();
@@ -207,7 +210,7 @@ function createCache({
       if (!entry || isExpired(entry, Date.now())) {
         return void 0;
       }
-      if (isPromise(entry.value)) {
+      if (isPromise2(entry.value)) {
         throw new Error("Cache value is a promise, use getAsync instead");
       }
       return entry.value;

package/lib/cache.js

@@ -5,7 +5,8 @@ import "./chunk-HTCYUMDR.js";
 import "./chunk-II4R3VVX.js";
 import {
   isPromise
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/cache.ts
 function cachedGetter(getter) {

package/lib/{chunk-UTFE4P3P.js → chunk-DMW5Q4T2.js}

@@ -1,6 +1,6 @@
 import {
   isFunction
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
 
 // src/arrayUtils.ts
 function filterAndMap(array, mapFilter) {

package/lib/{chunk-OHHF4CJZ.js → chunk-GKOTKAIV.js}

@@ -1,6 +1,6 @@
 import {
   isFunction
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
 
 // src/enhancedMap.ts
 var enhancedMapReject = Symbol();

package/lib/{chunk-U44EKR2F.js → chunk-NH2LCAQS.js}

@@ -1,6 +1,6 @@
 import {
   isObject
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
 
 // src/getCompositeKey.ts
 function getCompositeKey(input, maxSortingDepth = 3) {

package/lib/chunk-SSKW673U.js

@@ -0,0 +1,36 @@
+// src/typeGuards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value && isFunction(value.then);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+function isNonEmptyArray(value) {
+  return value.length > 0;
+}
+function arrayHasAtLeastXItems(array, minLength) {
+  return array.length >= minLength;
+}
+
+export {
+  isObject,
+  isFunction,
+  isPromise,
+  isPlainObject,
+  isNonEmptyArray,
+  arrayHasAtLeastXItems
+};