@ls-stack/utils 3.29.0 → 3.30.1

package/docs/_media/modules.md

@@ -47,6 +47,8 @@
 - [timers](timers.md)
 - [tsResult](tsResult/README.md)
 - [typeGuards](typeGuards.md)
+- [typeUtils](typeUtils/README.md)
+- [typeUtils.typesTest](typeUtils.typesTest.md)
 - [typingFnUtils](typingFnUtils/README.md)
 - [typingTestUtils](typingTestUtils.md)
 - [typingUtils](typingUtils.md)

package/docs/modules.md

@@ -47,6 +47,8 @@
 - [timers](timers.md)
 - [tsResult](tsResult/README.md)
 - [typeGuards](typeGuards.md)
+- [typeUtils](typeUtils/README.md)
+- [typeUtils.typesTest](typeUtils.typesTest.md)
 - [typingFnUtils](typingFnUtils/README.md)
 - [typingTestUtils](typingTestUtils.md)
 - [typingUtils](typingUtils.md)

package/docs/retryOnError/-internal-.md

@@ -50,6 +50,36 @@ Defined in: [packages/utils/src/retryOnError.ts:18](https://github.com/lucasols/
 
 Disable retries
 
+##### onRetry()?
+
+```ts
+optional onRetry: (error, lastAttempt) => void;
+```
+
+Defined in: [packages/utils/src/retryOnError.ts:20](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L20)
+
+Function to call when retry happens
+
+###### Parameters
+
+###### error
+
+`Error`
+
+###### lastAttempt
+
+###### duration
+
+`number`
+
+###### retry
+
+`number`
+
+###### Returns
+
+`void`
+
 ##### retryCondition()?
 
 ```ts

package/docs/retryOnError/README.md

@@ -23,7 +23,7 @@ function retryOnError<T>(
 originalMaxRetries): Promise<T>;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:41](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L41)
+Defined in: [packages/utils/src/retryOnError.ts:46](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L46)
 
 Retries a function on error with configurable retry logic.
 
@@ -97,7 +97,7 @@ function retryResultOnError<T, E>(
 __originalMaxRetries): Promise<Result<T, E>>;
 ```
 
-Defined in: [packages/utils/src/retryOnError.ts:116](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L116)
+Defined in: [packages/utils/src/retryOnError.ts:132](https://github.com/lucasols/utils/blob/main/packages/utils/src/retryOnError.ts#L132)
 
 Retries a result function on error with configurable retry logic.
 
@@ -141,6 +141,10 @@ Configuration options
 
 `boolean`
 
+###### onRetry?
+
+(`error`, `lastAttempt`) => `void`
+
 ###### retryCondition?
 
 (`error`, `lastAttempt`) => `boolean`

package/docs/typeUtils/-internal-.md

@@ -0,0 +1,99 @@
+[**@ls-stack/utils**](../README.md)
+
+***
+
+[@ls-stack/utils](../modules.md) / [typeUtils](README.md) / \<internal\>
+
+# \<internal\>
+
+## Type Aliases
+
+### BuildArrayPath\<BasePath\>
+
+```ts
+type BuildArrayPath<BasePath> = BasePath extends "$" ? "[*]" : `${BasePath}[*]`;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:62](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L62)
+
+#### Type Parameters
+
+##### BasePath
+
+`BasePath` *extends* `string`
+
+***
+
+### BuildPath\<BasePath, Key\>
+
+```ts
+type BuildPath<BasePath, Key> = BasePath extends "$" ? Key extends string | number ? `${Key}` : never : Key extends string | number ? `${BasePath}.${Key}` : never;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:54](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L54)
+
+#### Type Parameters
+
+##### BasePath
+
+`BasePath` *extends* `string`
+
+##### Key
+
+`Key` *extends* `PropertyKey`
+
+***
+
+### DeepReplaceValueImpl\<T, ReplaceType, NewType, SkipPaths, SkipType, Path\>
+
+```ts
+type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths, SkipType, Path> = SkipPaths extends string ? PathMatches<Path, SkipPaths> extends true ? T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly infer U[] ? DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>[] : T extends SkipType ? T : T extends Record<string, any> ? { [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>> } : T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly infer U[] ? DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>[] : T extends SkipType ? T : T extends Record<string, any> ? { [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>> } : T;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:65](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L65)
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+##### ReplaceType
+
+`ReplaceType`
+
+##### NewType
+
+`NewType`
+
+##### SkipPaths
+
+`SkipPaths` *extends* `string` \| `undefined`
+
+##### SkipType
+
+`SkipType`
+
+##### Path
+
+`Path` *extends* `string` = `"$"`
+
+***
+
+### PathMatches\<CurrentPath, SkipPaths\>
+
+```ts
+type PathMatches<CurrentPath, SkipPaths> = true extends SkipPaths extends any ? CurrentPath extends SkipPaths ? true : SkipPaths extends `${infer Prefix}[*]${infer Suffix}` ? CurrentPath extends `${Prefix}[${string}]${Suffix}` ? true : false : false : false ? true : false;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:40](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L40)
+
+#### Type Parameters
+
+##### CurrentPath
+
+`CurrentPath` *extends* `string`
+
+##### SkipPaths
+
+`SkipPaths` *extends* `string`

package/docs/typeUtils/README.md

@@ -0,0 +1,177 @@
+[**@ls-stack/utils**](../README.md)
+
+***
+
+[@ls-stack/utils](../modules.md) / typeUtils
+
+# typeUtils
+
+## Modules
+
+- [\<internal\>](-internal-.md)
+
+## Type Aliases
+
+### DeepPrettify\<T\>
+
+```ts
+type DeepPrettify<T> = { [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K] } & object;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:25](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L25)
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+***
+
+### DeepReplaceValue\<T, ReplaceType, NewType, SkipPaths, SkipTypes\>
+
+```ts
+type DeepReplaceValue<T, ReplaceType, NewType, SkipPaths, SkipTypes> = DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths, SkipTypes>;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:141](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L141)
+
+Replaces all values that extends `ReplaceType` with `NewType` in a deeply nested object or array.
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+The object or array to replace values in.
+
+##### ReplaceType
+
+`ReplaceType`
+
+The type to replace.
+
+##### NewType
+
+`NewType`
+
+The new type to replace with.
+
+##### SkipPaths
+
+`SkipPaths` *extends* `string` \| `undefined` = `undefined`
+
+The paths to skip in transverse. e.g. 'a.b.c' | 'array[*].b'
+
+##### SkipTypes
+
+`SkipTypes` = [`DefaultSkipTransverseDeepReplace`](#defaultskiptransversedeepreplace)
+
+The types to skip in transverse and replace.
+
+***
+
+### DefaultSkipTransverseDeepReplace
+
+```ts
+type DefaultSkipTransverseDeepReplace = 
+  | Date
+  | RegExp
+  | (...args) => any
+  | Error
+  | Set<any>
+  | Map<any, any>
+  | WeakSet<any>
+| WeakMap<any, any>;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:30](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L30)
+
+***
+
+### IsAny\<T\>
+
+```ts
+type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:14](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L14)
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+***
+
+### NonPartial\<T\>
+
+```ts
+type NonPartial<T> = { [K in keyof Required<T>]: T[K] };
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:5](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L5)
+
+#### Type Parameters
+
+##### T
+
+`T`
+
+***
+
+### ObjKeysWithValuesOfType\<Obj, ValueType\>
+
+```ts
+type ObjKeysWithValuesOfType<Obj, ValueType> = { [K in keyof Obj]: Obj[K] extends ValueType ? K : never }[keyof Obj];
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:7](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L7)
+
+#### Type Parameters
+
+##### Obj
+
+`Obj` *extends* `Record`\<`PropertyKey`, `unknown`\>
+
+##### ValueType
+
+`ValueType`
+
+***
+
+### PartialRecord\<K, T\>
+
+```ts
+type PartialRecord<K, T> = { [P in K]?: T };
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:1](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L1)
+
+#### Type Parameters
+
+##### K
+
+`K` *extends* keyof `any`
+
+##### T
+
+`T`
+
+***
+
+### Prettify\<T\>
+
+```ts
+type Prettify<T> = { [P in keyof T]: T[P] } & object;
+```
+
+Defined in: [packages/utils/src/typeUtils.ts:21](https://github.com/lucasols/utils/blob/main/packages/utils/src/typeUtils.ts#L21)
+
+#### Type Parameters
+
+##### T
+
+`T` *extends* `Record`\<`string`, `unknown`\>

package/docs/typeUtils.typesTest.md

@@ -0,0 +1,7 @@
+[**@ls-stack/utils**](README.md)
+
+***
+
+[@ls-stack/utils](modules.md) / typeUtils.typesTest
+
+# typeUtils.typesTest

package/docs/typingUtils.md

@@ -8,13 +8,13 @@
 
 ## Type Aliases
 
-### DeepPrettify\<T\>
+### ~~DeepPrettify\<T\>~~
 
 ```ts
 type DeepPrettify<T> = { [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K] } & object;
 ```
 
-Defined in: [packages/utils/src/typingUtils.ts:25](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L25)
+Defined in: [packages/utils/src/typingUtils.ts:31](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L31)
 
 #### Type Parameters
 
@@ -22,15 +22,19 @@ Defined in: [packages/utils/src/typingUtils.ts:25](https://github.com/lucasols/u
 
 `T`
 
+#### Deprecated
+
+Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead
+
 ***
 
-### IsAny\<T\>
+### ~~IsAny\<T\>~~
 
 ```ts
 type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
 ```
 
-Defined in: [packages/utils/src/typingUtils.ts:14](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L14)
+Defined in: [packages/utils/src/typingUtils.ts:18](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L18)
 
 #### Type Parameters
 
@@ -38,15 +42,19 @@ Defined in: [packages/utils/src/typingUtils.ts:14](https://github.com/lucasols/u
 
 `T`
 
+#### Deprecated
+
+Use `IsAny` from `@ls-stack/utils/typeUtils` instead
+
 ***
 
-### NonPartial\<T\>
+### ~~NonPartial\<T\>~~
 
 ```ts
 type NonPartial<T> = { [K in keyof Required<T>]: T[K] };
 ```
 
-Defined in: [packages/utils/src/typingUtils.ts:5](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L5)
+Defined in: [packages/utils/src/typingUtils.ts:7](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L7)
 
 #### Type Parameters
 
@@ -54,15 +62,19 @@ Defined in: [packages/utils/src/typingUtils.ts:5](https://github.com/lucasols/ut
 
 `T`
 
+#### Deprecated
+
+Use `NonPartial` from `@ls-stack/utils/typeUtils` instead
+
 ***
 
-### ObjKeysWithValuesOfType\<Obj, ValueType\>
+### ~~ObjKeysWithValuesOfType\<Obj, ValueType\>~~
 
 ```ts
 type ObjKeysWithValuesOfType<Obj, ValueType> = { [K in keyof Obj]: Obj[K] extends ValueType ? K : never }[keyof Obj];
 ```
 
-Defined in: [packages/utils/src/typingUtils.ts:7](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L7)
+Defined in: [packages/utils/src/typingUtils.ts:10](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L10)
 
 #### Type Parameters
 
@@ -74,15 +86,19 @@ Defined in: [packages/utils/src/typingUtils.ts:7](https://github.com/lucasols/ut
 
 `ValueType`
 
+#### Deprecated
+
+Use `ObjKeysWithValuesOfType` from `@ls-stack/utils/typeUtils` instead
+
 ***
 
-### PartialRecord\<K, T\>
+### ~~PartialRecord\<K, T\>~~
 
 ```ts
 type PartialRecord<K, T> = { [P in K]?: T };
 ```
 
-Defined in: [packages/utils/src/typingUtils.ts:1](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L1)
+Defined in: [packages/utils/src/typingUtils.ts:2](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L2)
 
 #### Type Parameters
 
@@ -94,18 +110,26 @@ Defined in: [packages/utils/src/typingUtils.ts:1](https://github.com/lucasols/ut
 
 `T`
 
+#### Deprecated
+
+Use `PartialRecord` from `@ls-stack/utils/typeUtils` instead
+
 ***
 
-### Prettify\<T\>
+### ~~Prettify\<T\>~~
 
 ```ts
 type Prettify<T> = { [P in keyof T]: T[P] } & object;
 ```
 
-Defined in: [packages/utils/src/typingUtils.ts:21](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L21)
+Defined in: [packages/utils/src/typingUtils.ts:26](https://github.com/lucasols/utils/blob/main/packages/utils/src/typingUtils.ts#L26)
 
 #### Type Parameters
 
 ##### T
 
 `T` *extends* `Record`\<`string`, `unknown`\>
+
+#### Deprecated
+
+Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead

package/lib/retryOnError.cjs

@@ -33,7 +33,7 @@ function sleep(ms) {
 
 // src/retryOnError.ts
 async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMaxRetries = maxRetries) {
-  const { delayBetweenRetriesMs, retryCondition, disableRetries } = options;
+  const { delayBetweenRetriesMs, retryCondition, disableRetries, onRetry } = options;
   if (options.debugId) {
     if (retry > 0) {
       console.info(
@@ -47,12 +47,19 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
   } catch (error) {
     if (maxRetries > 0 && !disableRetries) {
       const errorDuration = Date.now() - startTime;
-      const shouldRetry = retryCondition ? retryCondition((0, import_t_result.unknownToError)(error), {
+      const normalizedError = (0, import_t_result.unknownToError)(error);
+      const shouldRetry = retryCondition ? retryCondition(normalizedError, {
         duration: errorDuration,
         retry
       }) : true;
       if (!shouldRetry) {
-        throw error;
+        throw normalizedError;
+      }
+      if (onRetry) {
+        onRetry(normalizedError, {
+          duration: errorDuration,
+          retry
+        });
       }
       if (delayBetweenRetriesMs) {
         await sleep(
@@ -72,7 +79,7 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
   }
 }
 async function retryResultOnError(fn, maxRetries, options = {}, __retry = 0, __originalMaxRetries = maxRetries) {
-  const { delayBetweenRetriesMs, retryCondition } = options;
+  const { delayBetweenRetriesMs, retryCondition, onRetry } = options;
   if (options.debugId) {
     if (__retry > 0) {
       console.info(
@@ -94,6 +101,12 @@ async function retryResultOnError(fn, maxRetries, options = {}, __retry = 0, __o
     if (!shouldRetry) {
       return result;
     }
+    if (onRetry) {
+      onRetry(result.error, {
+        duration: errorDuration,
+        retry: __retry
+      });
+    }
     if (delayBetweenRetriesMs) {
       await sleep(
         typeof delayBetweenRetriesMs === "function" ? delayBetweenRetriesMs(__retry) : delayBetweenRetriesMs

package/lib/retryOnError.d.cts

@@ -15,6 +15,11 @@ type RetryOptions = {
     debugId?: string;
     /** Disable retries */
     disableRetries?: boolean;
+    /** Function to call when retry happens */
+    onRetry?: (error: Error, lastAttempt: {
+        duration: number;
+        retry: number;
+    }) => void;
 };
 /**
  * Retries a function on error with configurable retry logic.
@@ -50,6 +55,7 @@ declare function retryOnError<T>(fn: (ctx: {
  * @param options.retryCondition
  * @param options.debugId
  * @param options.disableRetries
+ * @param options.onRetry
  * @param __retry - internal use only
  * @param __originalMaxRetries - internal use only
  * @returns Promise resolving to the function result or rejecting with the final error
@@ -65,6 +71,10 @@ declare function retryResultOnError<T, E extends ResultValidErrors>(fn: (ctx: {
     }) => boolean;
     debugId?: string;
     disableRetries?: boolean;
+    onRetry?: (error: E, lastAttempt: {
+        duration: number;
+        retry: number;
+    }) => void;
 }, __retry?: number, __originalMaxRetries?: number): Promise<Result<T, E>>;
 
 export { retryOnError, retryResultOnError };

package/lib/retryOnError.d.ts

@@ -15,6 +15,11 @@ type RetryOptions = {
     debugId?: string;
     /** Disable retries */
     disableRetries?: boolean;
+    /** Function to call when retry happens */
+    onRetry?: (error: Error, lastAttempt: {
+        duration: number;
+        retry: number;
+    }) => void;
 };
 /**
  * Retries a function on error with configurable retry logic.
@@ -50,6 +55,7 @@ declare function retryOnError<T>(fn: (ctx: {
  * @param options.retryCondition
  * @param options.debugId
  * @param options.disableRetries
+ * @param options.onRetry
  * @param __retry - internal use only
  * @param __originalMaxRetries - internal use only
  * @returns Promise resolving to the function result or rejecting with the final error
@@ -65,6 +71,10 @@ declare function retryResultOnError<T, E extends ResultValidErrors>(fn: (ctx: {
     }) => boolean;
     debugId?: string;
     disableRetries?: boolean;
+    onRetry?: (error: E, lastAttempt: {
+        duration: number;
+        retry: number;
+    }) => void;
 }, __retry?: number, __originalMaxRetries?: number): Promise<Result<T, E>>;
 
 export { retryOnError, retryResultOnError };

package/lib/retryOnError.js

@@ -5,7 +5,7 @@ import {
 // src/retryOnError.ts
 import { unknownToError } from "t-result";
 async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMaxRetries = maxRetries) {
-  const { delayBetweenRetriesMs, retryCondition, disableRetries } = options;
+  const { delayBetweenRetriesMs, retryCondition, disableRetries, onRetry } = options;
   if (options.debugId) {
     if (retry > 0) {
       console.info(
@@ -19,12 +19,19 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
   } catch (error) {
     if (maxRetries > 0 && !disableRetries) {
       const errorDuration = Date.now() - startTime;
-      const shouldRetry = retryCondition ? retryCondition(unknownToError(error), {
+      const normalizedError = unknownToError(error);
+      const shouldRetry = retryCondition ? retryCondition(normalizedError, {
         duration: errorDuration,
         retry
       }) : true;
       if (!shouldRetry) {
-        throw error;
+        throw normalizedError;
+      }
+      if (onRetry) {
+        onRetry(normalizedError, {
+          duration: errorDuration,
+          retry
+        });
       }
       if (delayBetweenRetriesMs) {
         await sleep(
@@ -44,7 +51,7 @@ async function retryOnError(fn, maxRetries, options = {}, retry = 0, originalMax
   }
 }
 async function retryResultOnError(fn, maxRetries, options = {}, __retry = 0, __originalMaxRetries = maxRetries) {
-  const { delayBetweenRetriesMs, retryCondition } = options;
+  const { delayBetweenRetriesMs, retryCondition, onRetry } = options;
   if (options.debugId) {
     if (__retry > 0) {
       console.info(
@@ -66,6 +73,12 @@ async function retryResultOnError(fn, maxRetries, options = {}, __retry = 0, __o
     if (!shouldRetry) {
       return result;
     }
+    if (onRetry) {
+      onRetry(result.error, {
+        duration: errorDuration,
+        retry: __retry
+      });
+    }
     if (delayBetweenRetriesMs) {
       await sleep(
         typeof delayBetweenRetriesMs === "function" ? delayBetweenRetriesMs(__retry) : delayBetweenRetriesMs

package/lib/typeUtils.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/typeUtils.ts
+var typeUtils_exports = {};
+module.exports = __toCommonJS(typeUtils_exports);

package/lib/typeUtils.d.cts

@@ -0,0 +1,39 @@
+type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+type NonPartial<T> = {
+    [K in keyof Required<T>]: T[K];
+};
+type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
+    [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
+}[keyof Obj];
+type IsAny<T> = unknown extends T ? [
+    keyof T
+] extends [never] ? false : true : false;
+type Prettify<T extends Record<string, unknown>> = {
+    [P in keyof T]: T[P];
+} & {};
+type DeepPrettify<T> = {
+    [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
+} & {};
+type DefaultSkipTransverseDeepReplace = Date | RegExp | ((...args: any[]) => any) | Error | Set<any> | Map<any, any> | WeakSet<any> | WeakMap<any, any>;
+type PathMatches<CurrentPath extends string, SkipPaths extends string> = true extends (SkipPaths extends any ? CurrentPath extends SkipPaths ? true : SkipPaths extends `${infer Prefix}[*]${infer Suffix}` ? CurrentPath extends `${Prefix}[${string}]${Suffix}` ? true : false : false : false) ? true : false;
+type BuildPath<BasePath extends string, Key extends PropertyKey> = BasePath extends '$' ? Key extends string | number ? `${Key}` : never : Key extends string | number ? `${BasePath}.${Key}` : never;
+type BuildArrayPath<BasePath extends string> = BasePath extends '$' ? '[*]' : `${BasePath}[*]`;
+type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | undefined, SkipType, Path extends string = '$'> = SkipPaths extends string ? PathMatches<Path, SkipPaths> extends true ? T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
+    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
+} : T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
+    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
+} : T;
+/**
+ * Replaces all values that extends `ReplaceType` with `NewType` in a deeply nested object or array.
+ *
+ * @template T - The object or array to replace values in.
+ * @template ReplaceType - The type to replace.
+ * @template NewType - The new type to replace with.
+ * @template SkipPaths - The paths to skip in transverse. e.g. 'a.b.c' | 'array[*].b'
+ * @template SkipTypes - The types to skip in transverse and replace.
+ */
+type DeepReplaceValue<T, ReplaceType, NewType, SkipPaths extends string | undefined = undefined, SkipTypes = DefaultSkipTransverseDeepReplace> = DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths, SkipTypes>;
+
+export type { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, NonPartial, ObjKeysWithValuesOfType, PartialRecord, Prettify };

package/lib/typeUtils.d.ts

@@ -0,0 +1,39 @@
+type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+type NonPartial<T> = {
+    [K in keyof Required<T>]: T[K];
+};
+type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
+    [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
+}[keyof Obj];
+type IsAny<T> = unknown extends T ? [
+    keyof T
+] extends [never] ? false : true : false;
+type Prettify<T extends Record<string, unknown>> = {
+    [P in keyof T]: T[P];
+} & {};
+type DeepPrettify<T> = {
+    [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
+} & {};
+type DefaultSkipTransverseDeepReplace = Date | RegExp | ((...args: any[]) => any) | Error | Set<any> | Map<any, any> | WeakSet<any> | WeakMap<any, any>;
+type PathMatches<CurrentPath extends string, SkipPaths extends string> = true extends (SkipPaths extends any ? CurrentPath extends SkipPaths ? true : SkipPaths extends `${infer Prefix}[*]${infer Suffix}` ? CurrentPath extends `${Prefix}[${string}]${Suffix}` ? true : false : false : false) ? true : false;
+type BuildPath<BasePath extends string, Key extends PropertyKey> = BasePath extends '$' ? Key extends string | number ? `${Key}` : never : Key extends string | number ? `${BasePath}.${Key}` : never;
+type BuildArrayPath<BasePath extends string> = BasePath extends '$' ? '[*]' : `${BasePath}[*]`;
+type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | undefined, SkipType, Path extends string = '$'> = SkipPaths extends string ? PathMatches<Path, SkipPaths> extends true ? T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
+    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
+} : T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
+    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
+} : T;
+/**
+ * Replaces all values that extends `ReplaceType` with `NewType` in a deeply nested object or array.
+ *
+ * @template T - The object or array to replace values in.
+ * @template ReplaceType - The type to replace.
+ * @template NewType - The new type to replace with.
+ * @template SkipPaths - The paths to skip in transverse. e.g. 'a.b.c' | 'array[*].b'
+ * @template SkipTypes - The types to skip in transverse and replace.
+ */
+type DeepReplaceValue<T, ReplaceType, NewType, SkipPaths extends string | undefined = undefined, SkipTypes = DefaultSkipTransverseDeepReplace> = DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths, SkipTypes>;
+
+export type { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, NonPartial, ObjKeysWithValuesOfType, PartialRecord, Prettify };

package/lib/typingUtils.d.cts

@@ -1,18 +1,24 @@
+/** @deprecated Use `PartialRecord` from `@ls-stack/utils/typeUtils` instead */
 type PartialRecord<K extends keyof any, T> = {
     [P in K]?: T;
 };
+/** @deprecated Use `NonPartial` from `@ls-stack/utils/typeUtils` instead */
 type NonPartial<T> = {
     [K in keyof Required<T>]: T[K];
 };
+/** @deprecated Use `ObjKeysWithValuesOfType` from `@ls-stack/utils/typeUtils` instead */
 type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
     [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
 }[keyof Obj];
+/** @deprecated Use `IsAny` from `@ls-stack/utils/typeUtils` instead */
 type IsAny<T> = unknown extends T ? [
     keyof T
 ] extends [never] ? false : true : false;
+/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
 type Prettify<T extends Record<string, unknown>> = {
     [P in keyof T]: T[P];
 } & {};
+/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
 type DeepPrettify<T> = {
     [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
 } & {};

package/lib/typingUtils.d.ts

@@ -1,18 +1,24 @@
+/** @deprecated Use `PartialRecord` from `@ls-stack/utils/typeUtils` instead */
 type PartialRecord<K extends keyof any, T> = {
     [P in K]?: T;
 };
+/** @deprecated Use `NonPartial` from `@ls-stack/utils/typeUtils` instead */
 type NonPartial<T> = {
     [K in keyof Required<T>]: T[K];
 };
+/** @deprecated Use `ObjKeysWithValuesOfType` from `@ls-stack/utils/typeUtils` instead */
 type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
     [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
 }[keyof Obj];
+/** @deprecated Use `IsAny` from `@ls-stack/utils/typeUtils` instead */
 type IsAny<T> = unknown extends T ? [
     keyof T
 ] extends [never] ? false : true : false;
+/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
 type Prettify<T extends Record<string, unknown>> = {
     [P in keyof T]: T[P];
 } & {};
+/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
 type DeepPrettify<T> = {
     [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
 } & {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.29.0",
+  "version": "3.30.1",
   "license": "MIT",
   "files": [
     "lib",
@@ -184,6 +184,14 @@
       "import": "./lib/typeGuards.js",
       "require": "./lib/typeGuards.cjs"
     },
+    "./typeUtils": {
+      "import": "./lib/typeUtils.js",
+      "require": "./lib/typeUtils.cjs"
+    },
+    "./typeUtils.typesTest": {
+      "import": "./lib/typeUtils.typesTest.js",
+      "require": "./lib/typeUtils.typesTest.cjs"
+    },
     "./typingFnUtils": {
       "import": "./lib/typingFnUtils.js",
       "require": "./lib/typingFnUtils.cjs"