@ls-stack/utils 3.40.0 → 3.42.0

package/dist/chunk-GMJTLFM6.js

@@ -0,0 +1,60 @@
+// src/typingFnUtils.ts
+function asNonPartial(obj) {
+  return obj;
+}
+function typedObjectEntries(obj) {
+  return Object.entries(obj);
+}
+function strictTypedObjectEntries(obj) {
+  return Object.entries(obj);
+}
+function typedObjectKeys(obj) {
+  return Object.keys(obj);
+}
+function asType(value) {
+  return value;
+}
+function narrowStringToUnion(key, union) {
+  if (!key) return void 0;
+  if (union instanceof Set) {
+    return union.has(key) ? key : void 0;
+  }
+  if (union.includes(key)) {
+    return key;
+  }
+  return void 0;
+}
+function typeOnRightExtendsLeftType() {
+  return void 0;
+}
+var isSubTypeOf = typeOnRightExtendsLeftType;
+function isObjKey(key, obj) {
+  return typeof key === "string" && key in obj;
+}
+function unionsAreTheSame(_diff) {
+}
+function asPartialUndefinedValues(value) {
+  return value;
+}
+function isNonEmptyArray(array) {
+  return array.length > 0;
+}
+function objectHasKey(obj, key) {
+  return key in obj;
+}
+
+export {
+  asNonPartial,
+  typedObjectEntries,
+  strictTypedObjectEntries,
+  typedObjectKeys,
+  asType,
+  narrowStringToUnion,
+  typeOnRightExtendsLeftType,
+  isSubTypeOf,
+  isObjKey,
+  unionsAreTheSame,
+  asPartialUndefinedValues,
+  isNonEmptyArray,
+  objectHasKey
+};

package/dist/{chunk-GHAQOUA6.js → chunk-Y45CE75W.js}

@@ -1,3 +1,10 @@
+import {
+  typedObjectEntries
+} from "./chunk-GMJTLFM6.js";
+import {
+  sortBy
+} from "./chunk-27AL66CH.js";
+
 // src/objUtils.ts
 function objectTypedEntries(obj) {
   return Object.entries(obj);
@@ -38,6 +45,18 @@ function rejectObjUndefinedValues(obj) {
   }
   return result;
 }
+function filterObjectKeys(obj, predicate) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(
+      ([key, value]) => predicate(key, value)
+    )
+  );
+}
+function sortObjectKeys(obj, sortByFn, options) {
+  return Object.fromEntries(
+    sortBy(typedObjectEntries(obj), sortByFn, options)
+  );
+}
 
 export {
   objectTypedEntries,
@@ -46,5 +65,7 @@ export {
   mapObjectToObject,
   omit,
   looseGetObjectProperty,
-  rejectObjUndefinedValues
+  rejectObjUndefinedValues,
+  filterObjectKeys,
+  sortObjectKeys
 };

package/dist/concurrentCalls.d.cts

@@ -58,7 +58,8 @@ declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error>
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently and collects the results in
+ * a easier to use format.
  *
  * @template R - The type of the result value.
  */
@@ -88,7 +89,8 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently with metadata for each call
+ * and collects the results in a easier to use format.
  *
  * @template M - The type of the call metadata.
  * @template R - The type of the result value.
@@ -97,13 +99,15 @@ declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknow
 type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
 type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
 /**
- * Executes multiple asynchronous result calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently and collects the
+ * results in a easier to use format.
  *
  * @template R - The type of the result function that will be called.
  */
 declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 /**
- * Executes multiple asynchronous result calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently with metadata for
+ * each call and collects the results in a easier to use format.
  *
  * @template ResultFn - The type of the result function that will be called.
  */

package/dist/concurrentCalls.d.ts

@@ -58,7 +58,8 @@ declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error>
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently and collects the results in
+ * a easier to use format.
  *
  * @template R - The type of the result value.
  */
@@ -88,7 +89,8 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently with metadata for each call
+ * and collects the results in a easier to use format.
  *
  * @template M - The type of the call metadata.
  * @template R - The type of the result value.
@@ -97,13 +99,15 @@ declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknow
 type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
 type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
 /**
- * Executes multiple asynchronous result calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently and collects the
+ * results in a easier to use format.
  *
  * @template R - The type of the result function that will be called.
  */
 declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 /**
- * Executes multiple asynchronous result calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently with metadata for
+ * each call and collects the results in a easier to use format.
  *
  * @template ResultFn - The type of the result function that will be called.
  */

package/dist/concurrentCalls.js

@@ -1,6 +1,6 @@
 import {
   truncateString
-} from "./chunk-KW55OTUG.js";
+} from "./chunk-B3KFV2MH.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";

package/dist/debounce.d.cts

@@ -1,38 +1,30 @@
 type DebounceOptions = {
-    /**
-     * @see _.leading
-     */
+    /** @see _.leading */
     leading?: boolean;
-    /**
-     * @see _.maxWait
-     */
+    /** @see _.maxWait */
     maxWait?: number;
-    /**
-     * @see _.trailing
-     */
+    /** @see _.trailing */
     trailing?: boolean;
 };
 interface DebouncedFunc<T extends (...args: any[]) => void> {
     /**
      * Call the original function, but applying the debounce rules.
      *
-     * If the debounced function can be run immediately, this calls it and returns its return
-     * value.
+     * If the debounced function can be run immediately, this calls it and returns
+     * its return value.
      *
-     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
-     * function was not invoked yet.
+     * Otherwise, it returns the return value of the last invocation, or undefined
+     * if the debounced function was not invoked yet.
      */
     (...args: Parameters<T>): ReturnType<T> | undefined;
-    /**
-     * Throw away any pending invocation of the debounced function.
-     */
+    /** Throw away any pending invocation of the debounced function. */
     cancel: () => void;
     /**
-     * If there is a pending invocation of the debounced function, invoke it immediately and return
-     * its return value.
+     * If there is a pending invocation of the debounced function, invoke it
+     * immediately and return its return value.
      *
-     * Otherwise, return the value from the last invocation, or undefined if the debounced function
-     * was never invoked.
+     * Otherwise, return the value from the last invocation, or undefined if the
+     * debounced function was never invoked.
      */
     flush: () => ReturnType<T> | undefined;
 }

package/dist/debounce.d.ts

@@ -1,38 +1,30 @@
 type DebounceOptions = {
-    /**
-     * @see _.leading
-     */
+    /** @see _.leading */
     leading?: boolean;
-    /**
-     * @see _.maxWait
-     */
+    /** @see _.maxWait */
     maxWait?: number;
-    /**
-     * @see _.trailing
-     */
+    /** @see _.trailing */
     trailing?: boolean;
 };
 interface DebouncedFunc<T extends (...args: any[]) => void> {
     /**
      * Call the original function, but applying the debounce rules.
      *
-     * If the debounced function can be run immediately, this calls it and returns its return
-     * value.
+     * If the debounced function can be run immediately, this calls it and returns
+     * its return value.
      *
-     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
-     * function was not invoked yet.
+     * Otherwise, it returns the return value of the last invocation, or undefined
+     * if the debounced function was not invoked yet.
      */
     (...args: Parameters<T>): ReturnType<T> | undefined;
-    /**
-     * Throw away any pending invocation of the debounced function.
-     */
+    /** Throw away any pending invocation of the debounced function. */
     cancel: () => void;
     /**
-     * If there is a pending invocation of the debounced function, invoke it immediately and return
-     * its return value.
+     * If there is a pending invocation of the debounced function, invoke it
+     * immediately and return its return value.
      *
-     * Otherwise, return the value from the last invocation, or undefined if the debounced function
-     * was never invoked.
+     * Otherwise, return the value from the last invocation, or undefined if the
+     * debounced function was never invoked.
      */
     flush: () => ReturnType<T> | undefined;
 }

package/dist/dedent.d.cts

@@ -1,72 +1,72 @@
-/**
- * Configuration options for the dedent function behavior
- */
+/** Configuration options for the dedent function behavior */
 interface DedentOptions {
     /**
-     * Whether to process escape sequences like \n, \`, \$, and \{
-     * When true, allows using escaped characters in template literals
+     * Whether to process escape sequences like \n, `, $, and { When true, allows
+     * using escaped characters in template literals
+     *
      * @default true for template literals, false for plain strings
      */
     escapeSpecialCharacters?: boolean;
     /**
      * Whether to trim leading and trailing whitespace from the final result
+     *
      * @default true
      */
     trimWhitespace?: boolean;
     /**
      * Whether to preserve relative indentation of interpolated multi-line values
-     * When true, multi-line interpolations are re-indented to match the surrounding context
+     * When true, multi-line interpolations are re-indented to match the
+     * surrounding context
+     *
      * @default true
      */
     identInterpolations?: boolean;
     /**
-     * Whether to display nullish or false values (false, null, undefined) in interpolations
-     * When false, nullish or false values are skipped entirely
+     * Whether to display nullish or false values (false, null, undefined) in
+     * interpolations When false, nullish or false values are skipped entirely
+     *
      * @default false
      */
     showNullishOrFalseValues?: boolean;
 }
 type InterpolationValue = string | number | boolean | null | undefined;
 /**
- * Dedent function interface that can be used both as a template tag and a regular function
+ * Dedent function interface that can be used both as a template tag and a
+ * regular function
  */
 interface Dedent {
-    /**
-     * Process a plain string to remove common indentation
-     */
+    /** Process a plain string to remove common indentation */
     (literals: string): string;
     /**
-     * Process a template literal to remove common indentation while handling interpolations
+     * Process a template literal to remove common indentation while handling
+     * interpolations
      */
     (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
-    /**
-     * Create a new dedent function with custom options
-     */
+    /** Create a new dedent function with custom options */
     withOptions: CreateDedent;
 }
-/**
- * Factory function type for creating dedent functions with custom options
- */
+/** Factory function type for creating dedent functions with custom options */
 type CreateDedent = (options: DedentOptions) => Dedent;
 /**
- * Remove common leading indentation from multi-line strings while preserving relative indentation.
- * Can be used as a tagged template literal or called with a plain string.
+ * Remove common leading indentation from multi-line strings while preserving
+ * relative indentation. Can be used as a tagged template literal or called with
+ * a plain string.
  *
- * By default, it will dedent interpolated multi-line strings to match the surrounding context.
- * And it will not show falsy values.
+ * By default, it will dedent interpolated multi-line strings to match the
+ * surrounding context. And it will not show falsy values.
  *
  * @example
- * ```typescript
- * const text = dedent`
+ *   ```typescript
+ *   const text = dedent`;
  *   function hello() {
  *     console.log('world');
  *   }
- * `;
- * // Result:
- * "function hello() {
- *   console.log('world');
- * }"
- * ```
+ *   `;
+ *   // Result:
+ *   "function hello() {
+ *     console.log('world');
+ *   }"
+ *   ```;
  */
 declare const dedent: Dedent;
 

package/dist/dedent.d.ts

@@ -1,72 +1,72 @@
-/**
- * Configuration options for the dedent function behavior
- */
+/** Configuration options for the dedent function behavior */
 interface DedentOptions {
     /**
-     * Whether to process escape sequences like \n, \`, \$, and \{
-     * When true, allows using escaped characters in template literals
+     * Whether to process escape sequences like \n, `, $, and { When true, allows
+     * using escaped characters in template literals
+     *
      * @default true for template literals, false for plain strings
      */
     escapeSpecialCharacters?: boolean;
     /**
      * Whether to trim leading and trailing whitespace from the final result
+     *
      * @default true
      */
     trimWhitespace?: boolean;
     /**
      * Whether to preserve relative indentation of interpolated multi-line values
-     * When true, multi-line interpolations are re-indented to match the surrounding context
+     * When true, multi-line interpolations are re-indented to match the
+     * surrounding context
+     *
      * @default true
      */
     identInterpolations?: boolean;
     /**
-     * Whether to display nullish or false values (false, null, undefined) in interpolations
-     * When false, nullish or false values are skipped entirely
+     * Whether to display nullish or false values (false, null, undefined) in
+     * interpolations When false, nullish or false values are skipped entirely
+     *
      * @default false
      */
     showNullishOrFalseValues?: boolean;
 }
 type InterpolationValue = string | number | boolean | null | undefined;
 /**
- * Dedent function interface that can be used both as a template tag and a regular function
+ * Dedent function interface that can be used both as a template tag and a
+ * regular function
  */
 interface Dedent {
-    /**
-     * Process a plain string to remove common indentation
-     */
+    /** Process a plain string to remove common indentation */
     (literals: string): string;
     /**
-     * Process a template literal to remove common indentation while handling interpolations
+     * Process a template literal to remove common indentation while handling
+     * interpolations
      */
     (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
-    /**
-     * Create a new dedent function with custom options
-     */
+    /** Create a new dedent function with custom options */
     withOptions: CreateDedent;
 }
-/**
- * Factory function type for creating dedent functions with custom options
- */
+/** Factory function type for creating dedent functions with custom options */
 type CreateDedent = (options: DedentOptions) => Dedent;
 /**
- * Remove common leading indentation from multi-line strings while preserving relative indentation.
- * Can be used as a tagged template literal or called with a plain string.
+ * Remove common leading indentation from multi-line strings while preserving
+ * relative indentation. Can be used as a tagged template literal or called with
+ * a plain string.
  *
- * By default, it will dedent interpolated multi-line strings to match the surrounding context.
- * And it will not show falsy values.
+ * By default, it will dedent interpolated multi-line strings to match the
+ * surrounding context. And it will not show falsy values.
  *
  * @example
- * ```typescript
- * const text = dedent`
+ *   ```typescript
+ *   const text = dedent`;
  *   function hello() {
  *     console.log('world');
  *   }
- * `;
- * // Result:
- * "function hello() {
- *   console.log('world');
- * }"
- * ```
+ *   `;
+ *   // Result:
+ *   "function hello() {
+ *     console.log('world');
+ *   }"
+ *   ```;
  */
 declare const dedent: Dedent;
 

package/dist/deepEqual.d.cts

@@ -1,18 +1,19 @@
 /**
  * Deep equality comparison between two values
+ *
+ * @example
+ *   ```ts
+ *   deepEqual({a: 1}, {a: 1}) // true
+ *   deepEqual({a: 1}, {a: 2}) // false
+ *   deepEqual([1, {b: 2}], [1, {b: 2}]) // true
+ *   deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
+ *   deepEqual(new Set([1, 2]), new Set([1, 2])) // true
+ *   ```;
+ *
  * @param foo First value to compare
  * @param bar Second value to compare
  * @param maxDepth Maximum comparison depth (default: 20)
  * @returns True if values are deeply equal, false otherwise
- *
- * @example
- * ```ts
- * deepEqual({a: 1}, {a: 1}) // true
- * deepEqual({a: 1}, {a: 2}) // false
- * deepEqual([1, {b: 2}], [1, {b: 2}]) // true
- * deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
- * deepEqual(new Set([1, 2]), new Set([1, 2])) // true
- * ```
  */
 declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
 declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;

package/dist/deepEqual.d.ts

@@ -1,18 +1,19 @@
 /**
  * Deep equality comparison between two values
+ *
+ * @example
+ *   ```ts
+ *   deepEqual({a: 1}, {a: 1}) // true
+ *   deepEqual({a: 1}, {a: 2}) // false
+ *   deepEqual([1, {b: 2}], [1, {b: 2}]) // true
+ *   deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
+ *   deepEqual(new Set([1, 2]), new Set([1, 2])) // true
+ *   ```;
+ *
  * @param foo First value to compare
  * @param bar Second value to compare
  * @param maxDepth Maximum comparison depth (default: 20)
  * @returns True if values are deeply equal, false otherwise
- *
- * @example
- * ```ts
- * deepEqual({a: 1}, {a: 1}) // true
- * deepEqual({a: 1}, {a: 2}) // false
- * deepEqual([1, {b: 2}], [1, {b: 2}]) // true
- * deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
- * deepEqual(new Set([1, 2]), new Set([1, 2])) // true
- * ```
  */
 declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
 declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;

package/dist/filterObjectOrArrayKeys.d.cts

@@ -2,22 +2,27 @@
  * Filters the keys of an object based on the provided patterns.
  *
  * Filtering patterns in `rejectKeys` and `filterKeys`:
+ *
  * - `'prop'` - Only root-level properties named 'prop'
  * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
- * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes
+ *   root-level matches)
  * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
  * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
  * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
- * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name
+ *   `nested`
  * - `'prop[0]'` - The first item of the `prop` array
  * - `'prop[*]'` - All items of the `prop` array
  * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
  * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
  * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
  * - `'prop[0-2]'` - The first three items of the `prop` array
- * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the
+ *   end
  * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
  * - Root array:
+ *
  *   - `'[0]'` - The first item of the root array
  *   - `'[*]'` - All items of the array
  *   - `'[0].nested'` - `nested` prop of the first item of the array
@@ -26,30 +31,50 @@
  *   - `'[0-2]'` - The first three items of the array
  *   - `'[4-*]'` - All items of the array from the fourth index to the end
  * - Pattern expansion with parentheses:
- *   - `'prop.test.(prop1|prop2|prop3)'` - Expands to `prop.test.prop1`, `prop.test.prop2`, and `prop.test.prop3`
- *   - `'components[*].(table_id|columns|filters[*].value)'` - Expands to `components[*].table_id`, `components[*].columns`, and `components[*].filters[*].value`
+ *
+ *   - `'prop.test.(prop1|prop2|prop3)'` - Expands to `prop.test.prop1`,
+ *       `prop.test.prop2`, and `prop.test.prop3`
+ *   - `'components[*].(table_id|columns|filters[*].value)'` - Expands to
+ *       `components[*].table_id`, `components[*].columns`, and
+ *       `components[*].filters[*].value`
  *   - `'(users|admins)[*].name'` - Expands to `users[*].name` and `admins[*].name`
  * - Array filtering by value:
- *   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal to `John`
- *   - `'users[%name="John" | "Jane"]'` - Value-level OR using `|` for multiple values of same property
- *   - `'users[%name="Alice" || %age=35]'` - Property-level OR using `||` for different properties
- *   - `'users[%age=30 && %role="admin"]'` - Property-level AND using `&&` for different properties
- *   - Note: Mixing `&&` and `||` in the same filter is not supported - use separate filter patterns instead
+ *
+ *   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal
+ *       to `John`
+ *   - `'users[%name="John" | "Jane"]'` - Value-level OR using `|` for multiple
+ *       values of same property
+ *   - `'users[%name="Alice" || %age=35]'` - Property-level OR using `||` for
+ *       different properties
+ *   - `'users[%age=30 && %role="admin"]'` - Property-level AND using `&&` for
+ *       different properties
+ *   - Note: Mixing `&&` and `||` in the same filter is not supported - use separate
+ *       filter patterns instead
  *   - `'users[%config.name="John" | "Jane"]'` - Dot notation is supported
- *   - `'users[%name*="oh"]'` - Contains operator (*=) - filters users where name contains "oh"
- *   - `'users[%name^="Jo"]'` - Starts with operator (^=) - filters users where name starts with "Jo"
- *   - `'users[%name$="hn"]'` - Ends with operator ($=) - filters users where name ends with "hn"
- *   - `'users[%name!="John"]'` - Not equal operator (!=) - filters users where name is not "John"
- *   - `'users[%name!*="admin"]'` - Not contains operator (!*=) - filters users where name doesn't contain "admin"
- *   - `'users[i%name="john"]'` - Case-insensitive matching (i% prefix) - matches "John", "JOHN", "john", etc.
+ *   - `'users[%name*="oh"]'` - Contains operator (*=) - filters users where name
+ *       contains "oh"
+ *   - `'users[%name^="Jo"]'` - Starts with operator (^=) - filters users where name
+ *       starts with "Jo"
+ *   - `'users[%name$="hn"]'` - Ends with operator ($=) - filters users where name
+ *       ends with "hn"
+ *   - `'users[%name!="John"]'` - Not equal operator (!=) - filters users where name
+ *       is not "John"
+ *   - `'users[%name!*="admin"]'` - Not contains operator (!*=) - filters users
+ *       where name doesn't contain "admin"
+ *   - `'users[i%name="john"]'` - Case-insensitive matching (i% prefix) - matches
+ *       "John", "JOHN", "john", etc.
  *
  * @param objOrArray - The object or array to filter.
  * @param options - The options for the filter.
  * @param options.filterKeys - The keys to filter.
  * @param options.rejectKeys - The keys to reject.
- * @param options.rejectEmptyObjectsInArray - Whether to reject empty objects in arrays (default: true).
- * @param options.sortKeys - Sort all keys by a specific order (optional, preserves original order when not specified).
- * @param options.sortPatterns - Sort specific keys by pattern. Use to control the order of specific properties. The same patterns as `filterKeys` are supported.
+ * @param options.rejectEmptyObjectsInArray - Whether to reject empty objects in
+ *   arrays (default: true).
+ * @param options.sortKeys - Sort all keys by a specific order (optional,
+ *   preserves original order when not specified).
+ * @param options.sortPatterns - Sort specific keys by pattern. Use to control
+ *   the order of specific properties. The same patterns as `filterKeys` are
+ *   supported.
  * @returns The filtered object or array.
  */
 declare function filterObjectOrArrayKeys(objOrArray: Record<string, any> | Record<string, any>[], { filterKeys, rejectKeys, rejectEmptyObjectsInArray, sortKeys, sortPatterns, }: {