ts-data-forge 3.2.0 → 3.3.1

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

@@ -1,187 +1,31 @@
 /**
  * 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.
+ * 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.
+ * 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.
+ * 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[] } }>
- * ```
- *
+ * @returns The same value with readonly modifiers recursively added to all
+ *   properties
  * @see castReadonly - For shallow readonly casting
  * @see castDeepMutable - For the opposite operation (use with extreme caution)
  */

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

@@ -1 +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"}
+{"version":3,"file":"cast-readonly.d.mts","sourceRoot":"","sources":["../../src/others/cast-readonly.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAG,SAAS,CAAC,KAAG,QAAQ,CAAC,CAAC,CAChC,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAG,SAAS,CAAC,KAAG,YAAY,CAAC,CAAC,CAEpC,CAAC"}

package/dist/others/cast-readonly.mjs

@@ -1,192 +1,36 @@
 /**
  * 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.
+ * 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.
+ * 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.
+ * 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[] } }>
- * ```
- *
+ * @returns The same value with readonly modifiers recursively added to all
+ *   properties
  * @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
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 mutable;
 
 export { castDeepReadonly, castReadonly };

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

@@ -1 +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;;;;"}
+{"version":3,"file":"cast-readonly.mjs","sources":["../../src/others/cast-readonly.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;AAaG;AACI,MAAM,YAAY,GAAG,CAAK,OAAU,KACzC;AAEF;;;;;;;;;;;;;;;AAeG;AACI,MAAM,gBAAgB,GAAG,CAAK,OAAU;AAC7C;AACA;;;;"}

package/dist/others/if-then.d.mts

@@ -1,98 +1,21 @@
 /**
  * Implements the logical implication (if-then) operator.
  *
- * Returns `true` if the antecedent is `false` or the consequent is `true`.
- * In logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨ consequent`.
+ * Returns `true` if the antecedent is `false` or the consequent is `true`. In
+ * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨
+ * consequent`.
  *
  * **Truth table:**
+ *
  * - `true → true` = `true` (valid implication)
  * - `true → false` = `false` (invalid implication)
  * - `false → true` = `true` (vacuously true)
  * - `false → false` = `true` (vacuously true)
  *
  * @param antecedent - The condition (if part)
- * @param consequent - The result that should hold if the condition is true (then part)
+ * @param consequent - The result that should hold if the condition is true
+ *   (then part)
  * @returns `true` if the implication holds, `false` otherwise
- *
- * @example Basic truth table demonstration
- * ```typescript
- * ifThen(true, true);   // true  (if true then true = true)
- * ifThen(true, false);  // false (if true then false = false)
- * ifThen(false, true);  // true  (if false then true = true - vacuously true)
- * ifThen(false, false); // true  (if false then false = true - vacuously true)
- * ```
- *
- * @example Validation logic - "if required then must have value"
- * ```typescript
- * function validateField(value: string, isRequired: boolean): boolean {
- *   const hasValue = value.trim().length > 0;
- *   return ifThen(isRequired, hasValue);
- * }
- *
- * validateField('hello', true);  // true (required and has value)
- * validateField('', true);       // false (required but no value)
- * validateField('', false);      // true (not required, so valid)
- * validateField('hello', false); // true (not required, but has value is fine)
- * ```
- *
- * @example Access control - "if admin then has all permissions"
- * ```typescript
- * function checkPermission(user: User, permission: string): boolean {
- *   const isAdmin = user.role === 'admin';
- *   const hasPermission = user.permissions.includes(permission);
- *
- *   // Admin must have all permissions
- *   return ifThen(isAdmin, hasPermission);
- * }
- *
- * const adminUser = { role: 'admin', permissions: ['read', 'write'] };
- * checkPermission(adminUser, 'delete'); // false (admin without delete permission = invalid)
- *
- * const regularUser = { role: 'user', permissions: ['read'] };
- * checkPermission(regularUser, 'delete'); // true (non-admin without permission is valid)
- * ```
- *
- * @example Contract validation - "if premium then features enabled"
- * ```typescript
- * interface Subscription {
- *   isPremium: boolean;
- *   features: {
- *     advancedAnalytics: boolean;
- *     unlimitedStorage: boolean;
- *     prioritySupport: boolean;
- *   };
- * }
- *
- * function validateSubscription(sub: Subscription): boolean {
- *   // If premium, then all premium features must be enabled
- *   return ifThen(sub.isPremium,
- *     sub.features.advancedAnalytics &&
- *     sub.features.unlimitedStorage &&
- *     sub.features.prioritySupport
- *   );
- * }
- * ```
- *
- * @example Chaining multiple implications
- * ```typescript
- * // "If A then B" AND "If B then C"
- * function validateChain(a: boolean, b: boolean, c: boolean): boolean {
- *   return ifThen(a, b) && ifThen(b, c);
- * }
- *
- * validateChain(true, true, true);   // true (valid chain)
- * validateChain(true, false, true);  // false (breaks at first implication)
- * validateChain(false, false, false); // true (vacuously true chain)
- * ```
- *
- * @example Negation patterns
- * ```typescript
- * // "If not expired then valid" is equivalent to "expired OR valid"
- * const isExpired = Date.now() > expiryDate;
- * const isValid = checkValidity();
- * const result = ifThen(!isExpired, isValid);
- * // Same as: isExpired || isValid
- * ```
  */
 export declare const ifThen: (antecedent: boolean, consequent: boolean) => boolean;
 //# sourceMappingURL=if-then.d.mts.map

package/dist/others/if-then.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,eAAO,MAAM,MAAM,GAAI,YAAY,OAAO,EAAE,YAAY,OAAO,KAAG,OACvC,CAAC"}
+{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,GAAI,YAAY,OAAO,EAAE,YAAY,OAAO,KAAG,OACvC,CAAC"}

package/dist/others/if-then.mjs

@@ -1,98 +1,21 @@
 /**
  * Implements the logical implication (if-then) operator.
  *
- * Returns `true` if the antecedent is `false` or the consequent is `true`.
- * In logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨ consequent`.
+ * Returns `true` if the antecedent is `false` or the consequent is `true`. In
+ * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨
+ * consequent`.
  *
  * **Truth table:**
+ *
  * - `true → true` = `true` (valid implication)
  * - `true → false` = `false` (invalid implication)
  * - `false → true` = `true` (vacuously true)
  * - `false → false` = `true` (vacuously true)
  *
  * @param antecedent - The condition (if part)
- * @param consequent - The result that should hold if the condition is true (then part)
+ * @param consequent - The result that should hold if the condition is true
+ *   (then part)
  * @returns `true` if the implication holds, `false` otherwise
- *
- * @example Basic truth table demonstration
- * ```typescript
- * ifThen(true, true);   // true  (if true then true = true)
- * ifThen(true, false);  // false (if true then false = false)
- * ifThen(false, true);  // true  (if false then true = true - vacuously true)
- * ifThen(false, false); // true  (if false then false = true - vacuously true)
- * ```
- *
- * @example Validation logic - "if required then must have value"
- * ```typescript
- * function validateField(value: string, isRequired: boolean): boolean {
- *   const hasValue = value.trim().length > 0;
- *   return ifThen(isRequired, hasValue);
- * }
- *
- * validateField('hello', true);  // true (required and has value)
- * validateField('', true);       // false (required but no value)
- * validateField('', false);      // true (not required, so valid)
- * validateField('hello', false); // true (not required, but has value is fine)
- * ```
- *
- * @example Access control - "if admin then has all permissions"
- * ```typescript
- * function checkPermission(user: User, permission: string): boolean {
- *   const isAdmin = user.role === 'admin';
- *   const hasPermission = user.permissions.includes(permission);
- *
- *   // Admin must have all permissions
- *   return ifThen(isAdmin, hasPermission);
- * }
- *
- * const adminUser = { role: 'admin', permissions: ['read', 'write'] };
- * checkPermission(adminUser, 'delete'); // false (admin without delete permission = invalid)
- *
- * const regularUser = { role: 'user', permissions: ['read'] };
- * checkPermission(regularUser, 'delete'); // true (non-admin without permission is valid)
- * ```
- *
- * @example Contract validation - "if premium then features enabled"
- * ```typescript
- * interface Subscription {
- *   isPremium: boolean;
- *   features: {
- *     advancedAnalytics: boolean;
- *     unlimitedStorage: boolean;
- *     prioritySupport: boolean;
- *   };
- * }
- *
- * function validateSubscription(sub: Subscription): boolean {
- *   // If premium, then all premium features must be enabled
- *   return ifThen(sub.isPremium,
- *     sub.features.advancedAnalytics &&
- *     sub.features.unlimitedStorage &&
- *     sub.features.prioritySupport
- *   );
- * }
- * ```
- *
- * @example Chaining multiple implications
- * ```typescript
- * // "If A then B" AND "If B then C"
- * function validateChain(a: boolean, b: boolean, c: boolean): boolean {
- *   return ifThen(a, b) && ifThen(b, c);
- * }
- *
- * validateChain(true, true, true);   // true (valid chain)
- * validateChain(true, false, true);  // false (breaks at first implication)
- * validateChain(false, false, false); // true (vacuously true chain)
- * ```
- *
- * @example Negation patterns
- * ```typescript
- * // "If not expired then valid" is equivalent to "expired OR valid"
- * const isExpired = Date.now() > expiryDate;
- * const isValid = checkValidity();
- * const result = ifThen(!isExpired, isValid);
- * // Same as: isExpired || isValid
- * ```
  */
 const ifThen = (antecedent, consequent) => !antecedent || consequent;
 

package/dist/others/if-then.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"if-then.mjs","sources":["../../src/others/if-then.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FG;AACI,MAAM,MAAM,GAAG,CAAC,UAAmB,EAAE,UAAmB,KAC7D,CAAC,UAAU,IAAI;;;;"}
+{"version":3,"file":"if-then.mjs","sources":["../../src/others/if-then.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,MAAM,GAAG,CAAC,UAAmB,EAAE,UAAmB,KAC7D,CAAC,UAAU,IAAI;;;;"}