@splendidlabz/utils 1.11.3 → 1.11.4

package/{src/lib/arrays/join.js → dist/types/lib/arrays/join.d.cts}

@@ -1,4 +1,3 @@
-import { lastArrayItem } from './item-position.js'
 /**
  * Joins an array with a conjunction (and/or)
  * @param {Array<string>} array - Array of strings to join
@@ -9,12 +8,8 @@ import { lastArrayItem } from './item-position.js'
  * joinWithConjunction(['a', 'b', 'c']) // 'a, b, and c'
  * joinWithConjunction(['a', 'b'], { conjunction: 'or' }) // 'a or b'
  */
-export function joinWithConjunction(array, { conjunction = 'and' } = {}) {
-  if (!array?.length) return ''
-  if (array.length === 1) return array[0]
-  if (array.length === 2) return `${array[0]} ${conjunction} ${array[1]}`
+declare function joinWithConjunction(array: Array<string>, { conjunction }?: {
+    conjunction?: string;
+}): string;
 
-  const lastItem = lastArrayItem(array)
-  const rest = array.slice(0, -1)
-  return `${rest.join(', ')} ${conjunction} ${lastItem}`
-}
+export { joinWithConjunction };

package/dist/types/lib/arrays/shuffle.d.cts

@@ -0,0 +1,3 @@
+declare function shuffle(array: any): any;
+
+export { shuffle };

package/dist/types/lib/arrays/sort.d.cts

@@ -0,0 +1,32 @@
+/**
+ * Sorts an array of objects, numbers, or strings without mutating the original array.
+ * Supports nested properties, multiple sort keys, and various data types.
+ *
+ * @template T
+ * @param {T[]} array - Array to sort
+ * @param {Object} [options] - Sort options
+ * @param {string|string[]|null} [options.props=null] - Property or array of properties to sort by. If null, sorts simple arrays
+ * @param {boolean} [options.reverse=false] - Whether to sort in reverse order
+ * @returns {T[]} New sorted array
+ * @example
+ * // Sort simple array
+ * sort([3, 1, 2]) // [1, 2, 3]
+ *
+ * // Sort objects by single property
+ * sort(users, { props: 'name' })
+ *
+ * // Sort objects by multiple properties
+ * sort(users, { props: ['age', 'name'] })
+ *
+ * // Sort in reverse order
+ * sort(users, { props: 'age', reverse: true })
+ *
+ * // Sort by nested property
+ * sort(users, { props: 'address.city' })
+ */
+declare function sort<T>(array: T[], { props, reverse }?: {
+    props?: string | string[] | null;
+    reverse?: boolean;
+}): T[];
+
+export { sort };

package/dist/types/lib/arrays/split-array.d.cts

@@ -0,0 +1,6 @@
+declare function splitArray(array: any, predicate: any): {
+    picked: any[];
+    omitted: any[];
+};
+
+export { splitArray };

package/dist/types/lib/arrays/unique.d.cts

@@ -0,0 +1,3 @@
+declare function uniqueArray(array: any): any[];
+
+export { uniqueArray };

package/dist/types/lib/auth/index.d.cts

@@ -0,0 +1 @@
+export { AuthManager, RouteManager } from './route-manager.cjs';

package/dist/types/lib/auth/route-manager.d.cts

@@ -0,0 +1,28 @@
+/**
+  // Usage ... Probably should use either protected or bypass, not both.
+  // Maybe ... glob would be a better for this
+  @example
+  const config = {
+    routeConfig: {
+      startsWith: ['/dashboard']
+    }
+    bypassRoutes: {
+      is: ['/'],
+      startsWith: ['/fonts', '/auth', '/favicon', '/images'],
+      includes: ['/meh'],
+    }
+  }
+  const {isProtectedRoute, isBypassRoute} = AuthManager(config)
+  if (!isProtectedRoute(context.url.pathname)) return next() // Handle only protected routes
+  if (isBypassRoute(context.url.pathname)) return next() // Bypass all non protected routes
+ */
+declare function RouteManager(config: any): {
+    isProtectedRoute(pathname: any): any;
+    isBypassRoute(pathname: any): any;
+};
+declare function AuthManager(config: any): {
+    isProtectedRoute(pathname: any): any;
+    isBypassRoute(pathname: any): any;
+};
+
+export { AuthManager, RouteManager };

package/dist/types/lib/checks.d.cts

@@ -0,0 +1,33 @@
+/**
+ * Checks if a value is a plain object (not an array or null)
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is a plain object
+ * @example
+ * isObject({}) // true
+ * isObject([]) // false
+ * isObject(null) // false
+ */
+declare function isObject(x: unknown): boolean;
+/**
+ * Checks if a value is an array
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is an array
+ * @example
+ * isArray([]) // true
+ * isArray({}) // false
+ */
+declare function isArray(x: unknown): boolean;
+/**
+ * Checks if a value is not a plain object
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is not a plain object
+ * @example
+ * notObject([]) // true
+ * notObject(null) // true
+ * notObject({}) // false
+ */
+declare function notObject(x: unknown): boolean;
+declare function getType(x: any): "string" | "integer" | "float" | "boolean" | "function" | "undefined" | "symbol" | "bigint" | "array" | "object" | "unknown";
+declare function isFunction(x: any): boolean;
+
+export { getType, isArray, isFunction, isObject, notObject };

package/dist/types/lib/date/days.d.cts

@@ -0,0 +1,7 @@
+declare const DAYS: {
+    short: string;
+    long: string;
+    numeric: number;
+}[];
+
+export { DAYS };

package/dist/types/lib/date/index.d.cts

@@ -0,0 +1,3 @@
+export { DAYS } from './days.cjs';
+export { MONTHS } from './months.cjs';
+export { getTimeInMs, ms, toDays, toHours, toMinutes, toReadableTime, toSeconds, toWeeks } from './time.cjs';

package/dist/types/lib/date/months.d.cts

@@ -0,0 +1,11 @@
+declare const MONTHS: {
+    long: string;
+    short: string;
+    numeric: number;
+    lastDay: {
+        default: number;
+        leapYear: number;
+    };
+}[];
+
+export { MONTHS };

package/dist/types/lib/date/time.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Convert a time string to milliseconds
+ * @param {string} arg - The time string to convert
+ * @returns {number}
+ */
+declare function ms(arg: string): number;
+declare function getTimeInMs(value: any, unit?: string): any;
+declare function toWeeks(ms: any): number;
+declare function toDays(ms: any): number;
+declare function toHours(ms: any): number;
+declare function toMinutes(ms: any): number;
+declare function toSeconds(ms: any): number;
+declare function toReadableTime(ms: any): {
+    weeks: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+};
+
+export { getTimeInMs, ms, toDays, toHours, toMinutes, toReadableTime, toSeconds, toWeeks };

package/dist/types/lib/form/form-data.d.cts

@@ -0,0 +1,9 @@
+/**
+ * Converts Form Data into an object
+ * @param {FormData} formData
+ * @returns Object
+ */
+declare function formDataToObject(formData: FormData): {};
+declare function flattenArrayFields(inputObject: any): {};
+
+export { flattenArrayFields, formDataToObject };

package/dist/types/lib/form/index.d.cts

@@ -0,0 +1,2 @@
+export { flattenArrayFields, formDataToObject } from './form-data.cjs';
+export { SanitizeOptions, sanitize, sanitizeArray, sanitizeObject } from './sanitize.cjs';

package/{src/lib/form/sanitize.js → dist/types/lib/form/sanitize.d.cts}

@@ -3,12 +3,11 @@
  * @property {Function} [sanitizer] - Function to sanitize strings
  * @property {*} [additional] - Any additional properties are passed through to the sanitizer function
  */
-
 /**
  * Core sanitization function that handles different value types.
  * Throws if no sanitizer function is provided.
  * Any additional properties in options are passed through to the sanitizer function.
- * 
+ *
  * @param {*} value - The value to sanitize
  * @param {SanitizeOptions} [options={}] - Sanitization options
  * @throws {Error} If sanitizer function is not provided
@@ -16,65 +15,46 @@
  * @example
  * // Basic sanitization
  * sanitize('hello', { sanitizer: str => str.trim() })
- * 
+ *
  * // With additional options passed to sanitizer
- * sanitize('hello', { 
+ * sanitize('hello', {
  *   sanitizer: (str, length, char) => str.padEnd(length, char),
  *   length: 10,
  *   char: '-'
  * })
  */
-export function sanitize(value, options = {}) {
-  const { sanitizer, ...rest } = options
-  if (!sanitizer) throw new Error('sanitizer function is required')
-
-  if (typeof value === 'string') return sanitizer(value, rest)
-  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest })
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, val]) => [
-        key,
-        sanitize(val, { sanitizer, ...rest }),
-      ]),
-    )
-  }
-  return value
-}
+declare function sanitize(value: any, options?: SanitizeOptions): any;
+type SanitizeOptions = {
+    /**
+     * - Function to sanitize strings
+     */
+    sanitizer?: Function;
+    /**
+     * - Any additional properties are passed through to the sanitizer function
+     */
+    additional?: any;
+};
 /**
  * Sanitizes an array by recursively sanitizing each element.
  * Throws if no sanitizer function is provided.
  * Any additional properties in options are passed through to the sanitizer function.
- * 
+ *
  * @param {Array} arr - Array to sanitize
  * @param {SanitizeOptions} options - Sanitization options
  * @throws {Error} If sanitizer function is not provided
  * @returns {Array} New array with sanitized values
  */
-function sanitizeArray(arr, { sanitizer, ...rest }) {
-  if (!sanitizer) throw new Error('sanitizer function is required')
-  return arr.map(item => sanitize(item, { sanitizer, ...rest }))
-}
-
+declare function sanitizeArray(arr: any[], { sanitizer, ...rest }: SanitizeOptions): any[];
 /**
  * Sanitizes all string values in an object recursively.
  * Throws if no sanitizer function is not provided.
  * Any additional properties in options are passed through to the sanitizer function.
- * 
+ *
  * @param {Object} obj - Object to sanitize
  * @param {SanitizeOptions} [options={}] - Sanitization options
  * @throws {Error} If sanitizer function is not provided
  * @returns {Object} New object with sanitized values
  */
-function sanitizeObject(obj, { sanitizer, ...options } = {}) {
-  if (!sanitizer) throw new Error('sanitizer function is required')
-  if (Array.isArray(obj)) return sanitizeArray(obj, { sanitizer, ...options })
-
-  return Object.fromEntries(
-    Object.entries(obj).map(([key, value]) => [
-      key,
-      sanitize(value, { sanitizer, ...options }),
-    ]),
-  )
-}
+declare function sanitizeObject(obj: any, { sanitizer, ...options }?: SanitizeOptions): any;
 
-export { sanitizeArray, sanitizeObject }
+export { type SanitizeOptions, sanitize, sanitizeArray, sanitizeObject };

package/{src/lib/functions/callback.js → dist/types/lib/functions/callback.d.cts}

@@ -3,6 +3,6 @@
  * @param {Function|*} fn - The potential callback function
  * @param {...*} data - Data arguments to pass to the callback
  */
-export function runCallback(fn, ...data) {
-  if (typeof fn === 'function') fn(data)
-}
+declare function runCallback(fn: Function | any, ...data: any[]): void;
+
+export { runCallback };

package/dist/types/lib/functions/debounce.d.cts

@@ -0,0 +1,3 @@
+declare function debounce(callback: any, wait: any, immediate?: boolean): () => void;
+
+export { debounce };

package/dist/types/lib/functions/env.d.cts

@@ -0,0 +1,3 @@
+declare function getEnv(): "browser" | "node";
+
+export { getEnv };

package/{src/lib/functions/functional.js → dist/types/lib/functions/functional.d.cts}

@@ -10,18 +10,7 @@
  * curriedAdd(1, 2)(3) // 6
  * curriedAdd(1)(2, 3) // 6
  */
-export function curry(fn) {
-  return function curried(...args) {
-    if (args.length >= fn.length) {
-      return fn.apply(this, args)
-    } else {
-      return function (...moreArgs) {
-        return curried.apply(this, args.concat(moreArgs))
-      }
-    }
-  }
-}
-
+declare function curry(fn: Function): Function;
 /**
  * Composes functions from right to left (synchronous)
  * @param {...Function} fns - Functions to compose
@@ -33,12 +22,7 @@ export function curry(fn) {
  * const composed = compose(add1, multiply2)
  * composed(3) // 7 (3 * 2 + 1)
  */
-export function compose(...fns) {
-  return function (value) {
-    return fns.reduceRight((acc, fn) => fn(acc), value)
-  }
-}
-
+declare function compose(...fns: Function[]): Function;
 /**
  * Composes functions from right to left (asynchronous)
  * @param {...Function} fns - Functions to compose (can be sync or async)
@@ -49,15 +33,7 @@ export function compose(...fns) {
  * const multiplyAsync = async x => x * 2
  * await composeAsync(add1, multiplyAsync)(3) // 7 (3 * 2 + 1)
  */
-export function composeAsync(...fns) {
-  return async function (value) {
-    return fns.reduceRight(async (acc, fn) => {
-      const result = await acc
-      return await fn(result)
-    }, value)
-  }
-}
-
+declare function composeAsync(...fns: Function[]): Function;
 /**
  * Pipes functions from left to right (synchronous)
  * @param {...Function} fns - Functions to pipe
@@ -69,12 +45,7 @@ export function composeAsync(...fns) {
  * const piped = pipe(add1, multiply2)
  * piped(3) // 8 (3 + 1) * 2
  */
-export function pipe(...fns) {
-  return function (value) {
-    return fns.reduce((acc, fn) => fn(acc), value)
-  }
-}
-
+declare function pipe(...fns: Function[]): Function;
 /**
  * Pipes functions from left to right (asynchronous)
  * @param {...Function} fns - Functions to pipe (can be sync or async)
@@ -85,15 +56,7 @@ export function pipe(...fns) {
  * const multiplyAsync = async x => x * 2
  * await pipeAsync(add1, multiplyAsync)(3) // 8 ((3 + 1) * 2)
  */
-export function pipeAsync(...fns) {
-  return async function (value) {
-    return fns.reduce(async (acc, fn) => {
-      const result = await acc
-      return await fn(result)
-    }, value)
-  }
-}
-
+declare function pipeAsync(...fns: Function[]): Function;
 /**
  * Calls a function n times with the current index and returns an array of results
  * @param {Function} fn - Function to call (receives index as argument)
@@ -104,10 +67,6 @@ export function pipeAsync(...fns) {
  * times(i => i * 2, 3) // [0, 2, 4]
  * times(() => Math.random(), 2) // [0.123, 0.456] (random values)
  */
-export function times(fn, n) {
-  const result = []
-  for (let i = 0; i < n; i++) {
-    result.push(fn(i))
-  }
-  return result
-}
+declare function times(fn: Function, n: number): any[];
+
+export { compose, composeAsync, curry, pipe, pipeAsync, times };

package/dist/types/lib/functions/index.d.cts

@@ -0,0 +1,5 @@
+export { debounce } from './debounce.cjs';
+export { getEnv } from './env.cjs';
+export { compose, composeAsync, curry, pipe, pipeAsync, times } from './functional.cjs';
+export { throttle } from './throttle.cjs';
+export { delay, timeout, wait } from './timeout.cjs';

package/dist/types/lib/functions/throttle.d.cts

@@ -0,0 +1,3 @@
+declare function throttle(callback: any, wait: any): (...args: any[]) => void;
+
+export { throttle };

package/dist/types/lib/functions/timeout.d.cts

@@ -0,0 +1,5 @@
+declare function timeout(wait: any, callback: any): void;
+declare function delay(ms: any): Promise<any>;
+declare function wait(ms: any): Promise<any>;
+
+export { delay, timeout, wait };

package/dist/types/lib/hash.d.cts

@@ -0,0 +1,3 @@
+declare function isHashedValue(value: any, type?: string): boolean;
+
+export { isHashedValue };

package/dist/types/lib/index.d.cts

@@ -0,0 +1,43 @@
+export { isLastItem, last, lastArrayItem } from './arrays/item-position.cjs';
+export { joinWithConjunction } from './arrays/join.cjs';
+export { shuffle } from './arrays/shuffle.cjs';
+export { sort } from './arrays/sort.cjs';
+export { splitArray } from './arrays/split-array.cjs';
+export { uniqueArray } from './arrays/unique.cjs';
+export { AuthManager, RouteManager } from './auth/route-manager.cjs';
+export { getType, isArray, isFunction, isObject, notObject } from './checks.cjs';
+export { DAYS } from './date/days.cjs';
+export { MONTHS } from './date/months.cjs';
+export { getTimeInMs, ms, toDays, toHours, toMinutes, toReadableTime, toSeconds, toWeeks } from './date/time.cjs';
+export { flattenArrayFields, formDataToObject } from './form/form-data.cjs';
+export { SanitizeOptions, sanitize, sanitizeArray, sanitizeObject } from './form/sanitize.cjs';
+export { debounce } from './functions/debounce.cjs';
+export { getEnv } from './functions/env.cjs';
+export { compose, composeAsync, curry, pipe, pipeAsync, times } from './functions/functional.cjs';
+export { throttle } from './functions/throttle.cjs';
+export { delay, timeout, wait } from './functions/timeout.cjs';
+export { isHashedValue } from './hash.cjs';
+export { splitUnit } from './numbers/index.cjs';
+export { camelCaseKeys } from './objects/camelcase-keys.cjs';
+export { isEmpty, notEmpty } from './objects/empty.cjs';
+export { isEqual, notEqual } from './objects/equal.cjs';
+export { extendObject } from './objects/extend.cjs';
+export { flattenObject } from './objects/flatten.cjs';
+export { parseJSON } from './objects/json.cjs';
+export { objectForEach, objectMap } from './objects/loop.cjs';
+export { concatMix, createMix, mix } from './objects/mix/mix.cjs';
+export { getNestedProperty, getNestedProperty2, getNestedValue } from './objects/nested-property.cjs';
+export { normalizeObject } from './objects/normalize-object.cjs';
+export { omitEmpty } from './objects/omit-empty.cjs';
+export { sizeOf } from './objects/size.cjs';
+export { splitObject } from './objects/split.cjs';
+export { reject } from './promises/reject.cjs';
+export { createSSE, parseSSE } from './sse.cjs';
+export { toCamel, toKebab, toLower, toPascal, toSentence, toSlug, toTitle, toUpper } from './strings/convert-case/convert-case.cjs';
+export { markdown, treatMarkdownWhitespace } from './strings/markdown.cjs';
+export { parseFullName } from './strings/name.cjs';
+export { pluralize } from './strings/pluralize.cjs';
+export { plural, stripNumbers, toQueryString } from './strings/query-string.cjs';
+export { toStyleString } from './style/index.cjs';
+export { getSymbol, getSymbolValue } from './symbols/symbols.cjs';
+export { toDegrees, toRadians } from './numbers/math.cjs';

package/dist/types/lib/numbers/index.d.cts

@@ -0,0 +1,5 @@
+export { toDegrees, toRadians } from './math.cjs';
+
+declare function splitUnit(string: any): any[];
+
+export { splitUnit };

package/dist/types/lib/numbers/math.d.cts

@@ -0,0 +1,4 @@
+declare function toDegrees(angle: any): number;
+declare function toRadians(angle: any): number;
+
+export { toDegrees, toRadians };

package/dist/types/lib/objects/camelcase-keys.d.cts

@@ -0,0 +1,3 @@
+declare function camelCaseKeys(obj: any): any;
+
+export { camelCaseKeys };

package/dist/types/lib/objects/empty.d.cts

@@ -0,0 +1,4 @@
+declare function isEmpty(obj: any): boolean;
+declare function notEmpty(obj: any): boolean;
+
+export { isEmpty, notEmpty };

package/dist/types/lib/objects/equal.d.cts

@@ -0,0 +1,4 @@
+declare function isEqual(a: any, b: any): boolean;
+declare function notEqual(a: any, b: any): boolean;
+
+export { isEqual, notEqual };

package/dist/types/lib/objects/extend.d.cts

@@ -0,0 +1,6 @@
+declare function extendObject(object: any): {
+    orig: any;
+    extended: any;
+};
+
+export { extendObject };

package/dist/types/lib/objects/flatten.d.cts

@@ -0,0 +1,6 @@
+declare function flattenObject(obj: any, { separator, prefix }: {
+    separator: any;
+    prefix?: string;
+}): {};
+
+export { flattenObject };

package/dist/types/lib/objects/index.d.cts

@@ -0,0 +1,13 @@
+export { camelCaseKeys } from './camelcase-keys.cjs';
+export { isEmpty, notEmpty } from './empty.cjs';
+export { isEqual, notEqual } from './equal.cjs';
+export { extendObject } from './extend.cjs';
+export { flattenObject } from './flatten.cjs';
+export { parseJSON } from './json.cjs';
+export { objectForEach, objectMap } from './loop.cjs';
+export { concatMix, createMix, mix } from './mix/mix.cjs';
+export { getNestedProperty, getNestedProperty2, getNestedValue } from './nested-property.cjs';
+export { normalizeObject } from './normalize-object.cjs';
+export { omitEmpty } from './omit-empty.cjs';
+export { sizeOf } from './size.cjs';
+export { splitObject } from './split.cjs';

package/dist/types/lib/objects/json.d.cts

@@ -0,0 +1,3 @@
+declare function parseJSON(value: any, defaultValue?: {}): any;
+
+export { parseJSON };

package/dist/types/lib/objects/loop.d.cts

@@ -0,0 +1,4 @@
+declare function objectForEach(object: any, callback: any): void;
+declare function objectMap(object: any, callback: any): any[];
+
+export { objectForEach, objectMap };

package/dist/types/lib/objects/mix/mix.d.cts

@@ -0,0 +1,44 @@
+/**
+ * Creates a customized mix function with specific options for array handling.
+ *
+ * @param {Object} [userOptions={}] - Configuration options for the mix function.
+ * @param {('replace'|'concat')} [userOptions.array='replace'] - How to handle array merging:
+ *   - 'replace': Arrays from later sources completely replace arrays from earlier sources
+ *   - 'concat': Arrays are concatenated together
+ * @return {Function} A mix function configured with the provided options.
+ *
+ * @example
+ * // Create mix function that concatenates arrays
+ * const concatMix = createMix({ array: 'concat' })
+ * const obj1 = { items: [1, 2] }
+ * const obj2 = { items: [3, 4] }
+ * const result = concatMix(obj1, obj2)
+ * // Returns: { items: [1, 2, 3, 4] }
+ *
+ * @example
+ * // Create mix function that replaces arrays (default behavior)
+ * const replaceMix = createMix({ array: 'replace' })
+ * const obj1 = { items: [1, 2] }
+ * const obj2 = { items: [3, 4] }
+ * const result = replaceMix(obj1, obj2)
+ * // Returns: { items: [3, 4] }
+ */
+declare function createMix(userOptions?: {
+    array?: ("replace" | "concat");
+}): Function;
+/**
+ * Deep merges multiple objects into a new object with intelligent handling of arrays and nested objects.
+ *
+ * @param {...Object} sources - Objects to merge. Null and undefined values are skipped.
+ * @return {Object} A new object containing the merged properties from all sources.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { x: 10 } }
+ * const obj2 = { b: { y: 20 }, c: 3 }
+ * const result = mix(obj1, obj2)
+ * // Returns: { a: 1, b: { x: 10, y: 20 }, c: 3 }
+ */
+declare const mix: Function;
+declare const concatMix: Function;
+
+export { concatMix, createMix, mix };

package/{src/lib/objects/nested-property.js → dist/types/lib/objects/nested-property.d.cts}

@@ -17,25 +17,8 @@
  * let path = ['one', 'two', 'three'];
  * console.log(getNestedProperty(object, path)); // Outputs: "value"
  */
+declare function getNestedProperty(object: any, pathArr: any[]): any;
+declare function getNestedProperty2(object: any, path: any): any;
+declare function getNestedValue(object: any, path: any): any;
 
-// Array syntax
-export function getNestedProperty(object, pathArr) {
-  return pathArr.reduce(
-    (nestedObject, key) =>
-      nestedObject && nestedObject[key] !== 'undefined'
-        ? nestedObject[key]
-        : undefined,
-    object,
-  )
-}
-
-// Dot syntax
-export function getNestedProperty2(object, path) {
-  const pathArray = path.split('.')
-  return getNestedProperty(object, pathArray)
-}
-
-// Same as dot syntax, but terser and more readable name
-export function getNestedValue(object, path) {
-  return path.split('.').reduce((acc, part) => acc?.[part], object)
-}
+export { getNestedProperty, getNestedProperty2, getNestedValue };

package/dist/types/lib/objects/normalize-object.d.cts

@@ -0,0 +1,3 @@
+declare function normalizeObject(object: any): any;
+
+export { normalizeObject };

package/dist/types/lib/objects/omit-empty.d.cts

@@ -0,0 +1,3 @@
+declare function omitEmpty(obj: any, shallow?: boolean): any;
+
+export { omitEmpty };

package/dist/types/lib/objects/size.d.cts

@@ -0,0 +1,3 @@
+declare function sizeOf(obj: any): string;
+
+export { sizeOf };