ts-data-forge 1.0.0 → 1.0.2

package/dist/others/cast-mutable.d.mts

@@ -0,0 +1,110 @@
+/**
+ * Casts a readonly type `T` to its `Mutable<T>` equivalent.
+ *
+ * **⚠️ Safety Warning**: This is a type assertion that bypasses TypeScript's immutability guarantees.
+ * The runtime value remains unchanged - only the type system's view of it changes.
+ * Use with caution as it can lead to unexpected mutations of data that was intended to be immutable.
+ *
+ * @template T - The type of the readonly value
+ * @param readonlyValue - The readonly value to cast to mutable
+ * @returns The same value with readonly modifiers removed from its type
+ *
+ * @example Basic usage with arrays and objects
+ * ```typescript
+ * const readonlyArr: readonly number[] = [1, 2, 3];
+ * const mutableArr = castMutable(readonlyArr);
+ * mutableArr.push(4); // Now allowed by TypeScript
+ *
+ * const readonlyObj: { readonly x: number } = { x: 1 };
+ * const mutableObj = castMutable(readonlyObj);
+ * mutableObj.x = 2; // Now allowed by TypeScript
+ * ```
+ *
+ * @example When to use - Working with third-party APIs
+ * ```typescript
+ * // Some APIs require mutable arrays but you have readonly data
+ * const readonlyData: readonly string[] = ['a', 'b', 'c'];
+ * const sortedData = castMutable([...readonlyData]); // Create a copy first!
+ * legacyApi.sort(sortedData); // API mutates the array
+ * ```
+ *
+ * @example Anti-pattern - Avoid mutating shared data
+ * ```typescript
+ * // ❌ Bad: Mutating data that other code expects to be immutable
+ * const sharedConfig: Readonly<Config> = getConfig();
+ * const mutable = castMutable(sharedConfig);
+ * mutable.apiKey = 'new-key'; // Dangerous! Other code expects this to be immutable
+ *
+ * // ✅ Good: Create a copy if you need to mutate
+ * const configCopy = castMutable({ ...sharedConfig });
+ * configCopy.apiKey = 'new-key'; // Safe - operating on a copy
+ * ```
+ *
+ * @see castDeepMutable - For deeply nested readonly structures
+ * @see castReadonly - For the opposite operation
+ */
+export declare const castMutable: <T>(readonlyValue: T) => Mutable<T>;
+/**
+ * Casts a readonly type `T` to its `DeepMutable<T>` equivalent, recursively removing all readonly modifiers.
+ *
+ * **⚠️ Safety Warning**: This recursively bypasses ALL immutability guarantees in nested structures.
+ * Extremely dangerous for complex data structures as it allows mutation at any depth.
+ * The runtime value is unchanged - only TypeScript's type checking is affected.
+ *
+ * @template T - The type of the deeply readonly value
+ * @param readonlyValue - The deeply readonly value to cast to deeply mutable
+ * @returns The same value with all readonly modifiers recursively removed from its type
+ *
+ * @example Basic usage with nested structures
+ * ```typescript
+ * const readonlyNested: {
+ *   readonly a: { readonly b: readonly number[] }
+ * } = { a: { b: [1, 2, 3] } };
+ *
+ * const mutableNested = castDeepMutable(readonlyNested);
+ * mutableNested.a.b.push(4); // Mutations allowed at all levels
+ * mutableNested.a = { b: [5, 6] }; // Can replace entire objects
+ * mutableNested.a.b[0] = 99; // Can mutate array elements
+ * ```
+ *
+ * @example Practical use case - Working with immutable state updates
+ * ```typescript
+ * // When you need to perform multiple mutations before creating new immutable state
+ * const currentState: DeepReadonly<AppState> = getState();
+ * const draft = castDeepMutable(structuredClone(currentState)); // Clone first!
+ *
+ * // Perform multiple mutations on the draft
+ * draft.users.push(newUser);
+ * draft.settings.theme = 'dark';
+ * draft.data.items[0].completed = true;
+ *
+ * // Create new immutable state from the mutated draft
+ * const newState = castDeepReadonly(draft);
+ * setState(newState);
+ * ```
+ *
+ * @example Type complexity with generics
+ * ```typescript
+ * type DeepReadonlyUser = DeepReadonly<{
+ *   id: number;
+ *   profile: {
+ *     settings: {
+ *       preferences: string[];
+ *     };
+ *   };
+ * }>;
+ *
+ * function updateUserPreferences(user: DeepReadonlyUser, newPref: string) {
+ *   // Create a mutable copy to work with
+ *   const mutableUser = castDeepMutable(structuredClone(user));
+ *   mutableUser.profile.settings.preferences.push(newPref);
+ *   return castDeepReadonly(mutableUser);
+ * }
+ * ```
+ *
+ * @see castMutable - For shallow mutability casting
+ * @see castDeepReadonly - For the opposite operation
+ * @see structuredClone - Recommended for creating safe copies before mutation
+ */
+export declare const castDeepMutable: <T>(readonlyValue: T) => DeepMutable<T>;
+//# sourceMappingURL=cast-mutable.d.mts.map

package/dist/others/cast-mutable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-mutable.d.mts","sourceRoot":"","sources":["../../src/others/cast-mutable.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAG,eAAe,CAAC,KAAG,OAAO,CAAC,CAAC,CAC/B,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAG,eAAe,CAAC,KAAG,WAAW,CAAC,CAAC,CAEnC,CAAC"}

package/dist/others/cast-mutable.mjs

@@ -0,0 +1,114 @@
+/**
+ * Casts a readonly type `T` to its `Mutable<T>` equivalent.
+ *
+ * **⚠️ Safety Warning**: This is a type assertion that bypasses TypeScript's immutability guarantees.
+ * The runtime value remains unchanged - only the type system's view of it changes.
+ * Use with caution as it can lead to unexpected mutations of data that was intended to be immutable.
+ *
+ * @template T - The type of the readonly value
+ * @param readonlyValue - The readonly value to cast to mutable
+ * @returns The same value with readonly modifiers removed from its type
+ *
+ * @example Basic usage with arrays and objects
+ * ```typescript
+ * const readonlyArr: readonly number[] = [1, 2, 3];
+ * const mutableArr = castMutable(readonlyArr);
+ * mutableArr.push(4); // Now allowed by TypeScript
+ *
+ * const readonlyObj: { readonly x: number } = { x: 1 };
+ * const mutableObj = castMutable(readonlyObj);
+ * mutableObj.x = 2; // Now allowed by TypeScript
+ * ```
+ *
+ * @example When to use - Working with third-party APIs
+ * ```typescript
+ * // Some APIs require mutable arrays but you have readonly data
+ * const readonlyData: readonly string[] = ['a', 'b', 'c'];
+ * const sortedData = castMutable([...readonlyData]); // Create a copy first!
+ * legacyApi.sort(sortedData); // API mutates the array
+ * ```
+ *
+ * @example Anti-pattern - Avoid mutating shared data
+ * ```typescript
+ * // ❌ Bad: Mutating data that other code expects to be immutable
+ * const sharedConfig: Readonly<Config> = getConfig();
+ * const mutable = castMutable(sharedConfig);
+ * mutable.apiKey = 'new-key'; // Dangerous! Other code expects this to be immutable
+ *
+ * // ✅ Good: Create a copy if you need to mutate
+ * const configCopy = castMutable({ ...sharedConfig });
+ * configCopy.apiKey = 'new-key'; // Safe - operating on a copy
+ * ```
+ *
+ * @see castDeepMutable - For deeply nested readonly structures
+ * @see castReadonly - For the opposite operation
+ */
+const castMutable = (readonlyValue) => readonlyValue;
+/**
+ * Casts a readonly type `T` to its `DeepMutable<T>` equivalent, recursively removing all readonly modifiers.
+ *
+ * **⚠️ Safety Warning**: This recursively bypasses ALL immutability guarantees in nested structures.
+ * Extremely dangerous for complex data structures as it allows mutation at any depth.
+ * The runtime value is unchanged - only TypeScript's type checking is affected.
+ *
+ * @template T - The type of the deeply readonly value
+ * @param readonlyValue - The deeply readonly value to cast to deeply mutable
+ * @returns The same value with all readonly modifiers recursively removed from its type
+ *
+ * @example Basic usage with nested structures
+ * ```typescript
+ * const readonlyNested: {
+ *   readonly a: { readonly b: readonly number[] }
+ * } = { a: { b: [1, 2, 3] } };
+ *
+ * const mutableNested = castDeepMutable(readonlyNested);
+ * mutableNested.a.b.push(4); // Mutations allowed at all levels
+ * mutableNested.a = { b: [5, 6] }; // Can replace entire objects
+ * mutableNested.a.b[0] = 99; // Can mutate array elements
+ * ```
+ *
+ * @example Practical use case - Working with immutable state updates
+ * ```typescript
+ * // When you need to perform multiple mutations before creating new immutable state
+ * const currentState: DeepReadonly<AppState> = getState();
+ * const draft = castDeepMutable(structuredClone(currentState)); // Clone first!
+ *
+ * // Perform multiple mutations on the draft
+ * draft.users.push(newUser);
+ * draft.settings.theme = 'dark';
+ * draft.data.items[0].completed = true;
+ *
+ * // Create new immutable state from the mutated draft
+ * const newState = castDeepReadonly(draft);
+ * setState(newState);
+ * ```
+ *
+ * @example Type complexity with generics
+ * ```typescript
+ * type DeepReadonlyUser = DeepReadonly<{
+ *   id: number;
+ *   profile: {
+ *     settings: {
+ *       preferences: string[];
+ *     };
+ *   };
+ * }>;
+ *
+ * function updateUserPreferences(user: DeepReadonlyUser, newPref: string) {
+ *   // Create a mutable copy to work with
+ *   const mutableUser = castDeepMutable(structuredClone(user));
+ *   mutableUser.profile.settings.preferences.push(newPref);
+ *   return castDeepReadonly(mutableUser);
+ * }
+ * ```
+ *
+ * @see castMutable - For shallow mutability casting
+ * @see castDeepReadonly - For the opposite operation
+ * @see structuredClone - Recommended for creating safe copies before mutation
+ */
+const castDeepMutable = (readonlyValue) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+readonlyValue;
+
+export { castDeepMutable, castMutable };
+//# sourceMappingURL=cast-mutable.mjs.map

package/dist/others/cast-mutable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-mutable.mjs","sources":["../../src/others/cast-mutable.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CG;AACI,MAAM,WAAW,GAAG,CAAK,aAAgB,KAC9C;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DG;AACI,MAAM,eAAe,GAAG,CAAK,aAAgB;AAClD;AACA;;;;"}

package/dist/others/cast-readonly.d.mts

@@ -0,0 +1,189 @@
+/**
+ * Casts a mutable type `T` to its `Readonly<T>` equivalent.
+ *
+ * This is a safe type assertion that adds immutability constraints at the type level.
+ * The runtime value remains unchanged - only TypeScript's view of it becomes readonly.
+ * This helps prevent accidental mutations and makes code intentions clearer.
+ *
+ * @template T - The type of the mutable value
+ * @param mutable - The mutable value to cast to readonly
+ * @returns The same value with readonly modifiers added to its type
+ *
+ * @example Basic usage with arrays and objects
+ * ```typescript
+ * const mutableArr: number[] = [1, 2, 3];
+ * const readonlyArr = castReadonly(mutableArr);
+ * // readonlyArr.push(4); // ❌ TypeScript Error: no 'push' on readonly array
+ *
+ * const mutableObj = { x: 1, y: 2 };
+ * const readonlyObj = castReadonly(mutableObj);
+ * // readonlyObj.x = 5; // ❌ TypeScript Error: cannot assign to readonly property
+ * ```
+ *
+ * @example Protecting function return values
+ * ```typescript
+ * // Prevent callers from mutating internal state
+ * class UserService {
+ *   private users: User[] = [];
+ *
+ *   getUsers(): readonly User[] {
+ *     return castReadonly(this.users); // Callers can't mutate the array
+ *   }
+ * }
+ *
+ * const service = new UserService();
+ * const users = service.getUsers();
+ * // users.push(newUser); // ❌ TypeScript prevents this
+ * ```
+ *
+ * @example Creating immutable configurations
+ * ```typescript
+ * // Start with mutable object for initialization
+ * const config = {
+ *   apiUrl: 'https://api.example.com',
+ *   timeout: 5000,
+ *   retries: 3
+ * };
+ *
+ * // Validate and process config...
+ *
+ * // Export as readonly to prevent modifications
+ * export const APP_CONFIG = castReadonly(config);
+ * // APP_CONFIG.timeout = 10000; // ❌ TypeScript Error
+ * ```
+ *
+ * @example Working with array methods
+ * ```typescript
+ * const numbers: number[] = [1, 2, 3, 4, 5];
+ * const readonlyNumbers = castReadonly(numbers);
+ *
+ * // Read operations still work
+ * const doubled = readonlyNumbers.map(n => n * 2); // ✅ Returns new array
+ * const sum = readonlyNumbers.reduce((a, b) => a + b, 0); // ✅ Works
+ * const first = readonlyNumbers[0]; // ✅ Reading is allowed
+ *
+ * // Mutations are prevented
+ * // readonlyNumbers[0] = 10; // ❌ TypeScript Error
+ * // readonlyNumbers.sort(); // ❌ TypeScript Error (sort mutates)
+ * ```
+ *
+ * @see castDeepReadonly - For deeply nested structures
+ * @see castMutable - For the opposite operation (use with caution)
+ */
+export declare const castReadonly: <T>(mutable: T) => Readonly<T>;
+/**
+ * Casts a mutable type `T` to its `DeepReadonly<T>` equivalent, recursively adding readonly modifiers.
+ *
+ * This is a safe type assertion that adds immutability constraints at ALL levels of nesting.
+ * Provides complete protection against mutations in complex data structures.
+ * The runtime value is unchanged - only TypeScript's type checking is enhanced.
+ *
+ * @template T - The type of the mutable value
+ * @param mutable - The mutable value to cast to deeply readonly
+ * @returns The same value with readonly modifiers recursively added to all properties
+ *
+ * @example Basic usage with nested structures
+ * ```typescript
+ * const mutableNested = {
+ *   a: { b: [1, 2, 3] },
+ *   c: { d: { e: 'value' } }
+ * };
+ *
+ * const readonlyNested = castDeepReadonly(mutableNested);
+ * // readonlyNested.a.b.push(4); // ❌ Error: readonly at all levels
+ * // readonlyNested.c.d.e = 'new'; // ❌ Error: readonly at all levels
+ * // readonlyNested.a = {}; // ❌ Error: cannot reassign readonly property
+ * ```
+ *
+ * @example Protecting complex state objects
+ * ```typescript
+ * interface AppState {
+ *   user: {
+ *     id: number;
+ *     profile: {
+ *       name: string;
+ *       settings: {
+ *         theme: string;
+ *         notifications: boolean[];
+ *       };
+ *     };
+ *   };
+ *   data: {
+ *     items: Array<{ id: number; value: string }>;
+ *   };
+ * }
+ *
+ * class StateManager {
+ *   private state: AppState = initialState;
+ *
+ *   getState(): DeepReadonly<AppState> {
+ *     return castDeepReadonly(this.state);
+ *   }
+ *
+ *   // Mutations only allowed through specific methods
+ *   updateTheme(theme: string) {
+ *     this.state.user.profile.settings.theme = theme;
+ *   }
+ * }
+ * ```
+ *
+ * @example Creating immutable API responses
+ * ```typescript
+ * async function fetchUserData(): Promise<DeepReadonly<UserData>> {
+ *   const response = await api.get<UserData>('/user');
+ *
+ *   // Process and validate data...
+ *
+ *   // Return as deeply immutable to prevent accidental mutations
+ *   return castDeepReadonly(response.data);
+ * }
+ *
+ * const userData = await fetchUserData();
+ * // userData is fully protected from mutations at any depth
+ * // userData.preferences.emails.push('new@email.com'); // ❌ TypeScript Error
+ * ```
+ *
+ * @example Working with Redux or state management
+ * ```typescript
+ * // Redux reducer example
+ * type State = DeepReadonly<AppState>;
+ *
+ * function reducer(state: State, action: Action): State {
+ *   switch (action.type) {
+ *     case 'UPDATE_USER_NAME':
+ *       // Must create new objects, can't mutate
+ *       return castDeepReadonly({
+ *         ...state,
+ *         user: {
+ *           ...state.user,
+ *           profile: {
+ *             ...state.user.profile,
+ *             name: action.payload
+ *           }
+ *         }
+ *       });
+ *     default:
+ *       return state;
+ *   }
+ * }
+ * ```
+ *
+ * @example Type inference with generics
+ * ```typescript
+ * function processData<T>(data: T): DeepReadonly<T> {
+ *   // Perform processing...
+ *   console.log('Processing:', data);
+ *
+ *   // Return immutable version
+ *   return castDeepReadonly(data);
+ * }
+ *
+ * const result = processData({ nested: { value: [1, 2, 3] } });
+ * // Type of result is DeepReadonly<{ nested: { value: number[] } }>
+ * ```
+ *
+ * @see castReadonly - For shallow readonly casting
+ * @see castDeepMutable - For the opposite operation (use with extreme caution)
+ */
+export declare const castDeepReadonly: <T>(mutable: T) => DeepReadonly<T>;
+//# sourceMappingURL=cast-readonly.d.mts.map

package/dist/others/cast-readonly.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-readonly.d.mts","sourceRoot":"","sources":["../../src/others/cast-readonly.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAG,SAAS,CAAC,KAAG,QAAQ,CAAC,CAAC,CAChC,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAG,SAAS,CAAC,KAAG,YAAY,CAAC,CAAC,CAEpC,CAAC"}

package/dist/others/cast-readonly.mjs

@@ -0,0 +1,193 @@
+/**
+ * Casts a mutable type `T` to its `Readonly<T>` equivalent.
+ *
+ * This is a safe type assertion that adds immutability constraints at the type level.
+ * The runtime value remains unchanged - only TypeScript's view of it becomes readonly.
+ * This helps prevent accidental mutations and makes code intentions clearer.
+ *
+ * @template T - The type of the mutable value
+ * @param mutable - The mutable value to cast to readonly
+ * @returns The same value with readonly modifiers added to its type
+ *
+ * @example Basic usage with arrays and objects
+ * ```typescript
+ * const mutableArr: number[] = [1, 2, 3];
+ * const readonlyArr = castReadonly(mutableArr);
+ * // readonlyArr.push(4); // ❌ TypeScript Error: no 'push' on readonly array
+ *
+ * const mutableObj = { x: 1, y: 2 };
+ * const readonlyObj = castReadonly(mutableObj);
+ * // readonlyObj.x = 5; // ❌ TypeScript Error: cannot assign to readonly property
+ * ```
+ *
+ * @example Protecting function return values
+ * ```typescript
+ * // Prevent callers from mutating internal state
+ * class UserService {
+ *   private users: User[] = [];
+ *
+ *   getUsers(): readonly User[] {
+ *     return castReadonly(this.users); // Callers can't mutate the array
+ *   }
+ * }
+ *
+ * const service = new UserService();
+ * const users = service.getUsers();
+ * // users.push(newUser); // ❌ TypeScript prevents this
+ * ```
+ *
+ * @example Creating immutable configurations
+ * ```typescript
+ * // Start with mutable object for initialization
+ * const config = {
+ *   apiUrl: 'https://api.example.com',
+ *   timeout: 5000,
+ *   retries: 3
+ * };
+ *
+ * // Validate and process config...
+ *
+ * // Export as readonly to prevent modifications
+ * export const APP_CONFIG = castReadonly(config);
+ * // APP_CONFIG.timeout = 10000; // ❌ TypeScript Error
+ * ```
+ *
+ * @example Working with array methods
+ * ```typescript
+ * const numbers: number[] = [1, 2, 3, 4, 5];
+ * const readonlyNumbers = castReadonly(numbers);
+ *
+ * // Read operations still work
+ * const doubled = readonlyNumbers.map(n => n * 2); // ✅ Returns new array
+ * const sum = readonlyNumbers.reduce((a, b) => a + b, 0); // ✅ Works
+ * const first = readonlyNumbers[0]; // ✅ Reading is allowed
+ *
+ * // Mutations are prevented
+ * // readonlyNumbers[0] = 10; // ❌ TypeScript Error
+ * // readonlyNumbers.sort(); // ❌ TypeScript Error (sort mutates)
+ * ```
+ *
+ * @see castDeepReadonly - For deeply nested structures
+ * @see castMutable - For the opposite operation (use with caution)
+ */
+const castReadonly = (mutable) => mutable;
+/**
+ * Casts a mutable type `T` to its `DeepReadonly<T>` equivalent, recursively adding readonly modifiers.
+ *
+ * This is a safe type assertion that adds immutability constraints at ALL levels of nesting.
+ * Provides complete protection against mutations in complex data structures.
+ * The runtime value is unchanged - only TypeScript's type checking is enhanced.
+ *
+ * @template T - The type of the mutable value
+ * @param mutable - The mutable value to cast to deeply readonly
+ * @returns The same value with readonly modifiers recursively added to all properties
+ *
+ * @example Basic usage with nested structures
+ * ```typescript
+ * const mutableNested = {
+ *   a: { b: [1, 2, 3] },
+ *   c: { d: { e: 'value' } }
+ * };
+ *
+ * const readonlyNested = castDeepReadonly(mutableNested);
+ * // readonlyNested.a.b.push(4); // ❌ Error: readonly at all levels
+ * // readonlyNested.c.d.e = 'new'; // ❌ Error: readonly at all levels
+ * // readonlyNested.a = {}; // ❌ Error: cannot reassign readonly property
+ * ```
+ *
+ * @example Protecting complex state objects
+ * ```typescript
+ * interface AppState {
+ *   user: {
+ *     id: number;
+ *     profile: {
+ *       name: string;
+ *       settings: {
+ *         theme: string;
+ *         notifications: boolean[];
+ *       };
+ *     };
+ *   };
+ *   data: {
+ *     items: Array<{ id: number; value: string }>;
+ *   };
+ * }
+ *
+ * class StateManager {
+ *   private state: AppState = initialState;
+ *
+ *   getState(): DeepReadonly<AppState> {
+ *     return castDeepReadonly(this.state);
+ *   }
+ *
+ *   // Mutations only allowed through specific methods
+ *   updateTheme(theme: string) {
+ *     this.state.user.profile.settings.theme = theme;
+ *   }
+ * }
+ * ```
+ *
+ * @example Creating immutable API responses
+ * ```typescript
+ * async function fetchUserData(): Promise<DeepReadonly<UserData>> {
+ *   const response = await api.get<UserData>('/user');
+ *
+ *   // Process and validate data...
+ *
+ *   // Return as deeply immutable to prevent accidental mutations
+ *   return castDeepReadonly(response.data);
+ * }
+ *
+ * const userData = await fetchUserData();
+ * // userData is fully protected from mutations at any depth
+ * // userData.preferences.emails.push('new@email.com'); // ❌ TypeScript Error
+ * ```
+ *
+ * @example Working with Redux or state management
+ * ```typescript
+ * // Redux reducer example
+ * type State = DeepReadonly<AppState>;
+ *
+ * function reducer(state: State, action: Action): State {
+ *   switch (action.type) {
+ *     case 'UPDATE_USER_NAME':
+ *       // Must create new objects, can't mutate
+ *       return castDeepReadonly({
+ *         ...state,
+ *         user: {
+ *           ...state.user,
+ *           profile: {
+ *             ...state.user.profile,
+ *             name: action.payload
+ *           }
+ *         }
+ *       });
+ *     default:
+ *       return state;
+ *   }
+ * }
+ * ```
+ *
+ * @example Type inference with generics
+ * ```typescript
+ * function processData<T>(data: T): DeepReadonly<T> {
+ *   // Perform processing...
+ *   console.log('Processing:', data);
+ *
+ *   // Return immutable version
+ *   return castDeepReadonly(data);
+ * }
+ *
+ * const result = processData({ nested: { value: [1, 2, 3] } });
+ * // Type of result is DeepReadonly<{ nested: { value: number[] } }>
+ * ```
+ *
+ * @see castReadonly - For shallow readonly casting
+ * @see castDeepMutable - For the opposite operation (use with extreme caution)
+ */
+const castDeepReadonly = (mutable) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+mutable;
+
+export { castDeepReadonly, castReadonly };
+//# sourceMappingURL=cast-readonly.mjs.map

package/dist/others/cast-readonly.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cast-readonly.mjs","sources":["../../src/others/cast-readonly.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEG;AACI,MAAM,YAAY,GAAG,CAAK,OAAU,KACzC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiHG;AACI,MAAM,gBAAgB,GAAG,CAAK,OAAU;AAC7C;AACA;;;;"}