ts-data-forge 1.2.0 → 1.3.0

package/README.md

@@ -139,6 +139,7 @@ expectType<{ x: number }, { x: number }>('=');
 // The following would cause a compile-time error:
 // expectType<User, Admin>("="); // Error: Type 'User' is not strictly equal to type 'Admin'.
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 expectType<User, any>('!='); // Error: Comparisons with `any` are also strictly checked.
 ```
 
@@ -147,55 +148,53 @@ expectType<User, any>('!='); // Error: Comparisons with `any` are also strictly
 Handle nullable values and error-prone operations safely.
 
 ```typescript
-import { Optional, Result, pipe, match } from 'ts-data-forge';
+import { match, Optional, pipe, Result } from 'ts-data-forge';
 
 // Optional for nullable values
 const maybeValue = Optional.some(42);
-const nothing = Optional.none;
 
 const doubled = Optional.map(maybeValue, (x) => x * 2);
-console.log(Optional.unwrapOr(doubled, 0)); // 84
+
+assert.strictEqual(Optional.unwrapOr(doubled, 0), 84);
 
 // Result for error handling
 const success = Result.ok(42);
-const failure = Result.err('Something went wrong');
 
 const mapped = Result.map(success, (x) => x * 2);
-if (Result.isOk(mapped)) {
-    console.log(mapped.value); // 84
-}
+
+assert.deepStrictEqual(mapped, Result.ok(84));
 
 // Advanced pipe usage
-const processNumber = (input: number) =>
+const processNumber = (input: number): Optional<number> =>
     pipe(input)
         .map((x) => x * 2) // Regular transformation
         .map((x) => x + 10) // Chain transformations
-        .map((x) => (x > 50 ? Optional.some(x) : Optional.none)) // Convert to Optional
-        .mapOptional((x) => x / 2).value; // Continue with Optional chain and get final Optional<number>
+        .map((x) => (x > 50 ? Optional.some(x / 2) : Optional.none)).value; // Get the result
+
+assert.deepStrictEqual(processNumber(30), Optional.some(35));
 
-console.log(processNumber(30)); // Optional.some(35)
-console.log(processNumber(10)); // Optional.none
+assert.deepStrictEqual(processNumber(10), Optional.none);
 
 // Pattern matching with match
 type Status = 'loading' | 'success' | 'error';
 
-const handleStatus = (status: Status, data?: string) =>
+const handleStatus = (status: Status, data?: string): string =>
     match(status, {
         loading: 'Please wait...',
         success: `Data: ${data ?? 'No data'}`,
         error: 'An error occurred',
     });
 
-console.log(handleStatus('loading')); // 'Please wait...'
-console.log(handleStatus('success', 'Hello')); // 'Data: Hello'
-console.log(handleStatus('error')); // 'An error occurred'
+assert.strictEqual(handleStatus('loading'), 'Please wait...');
+assert.strictEqual(handleStatus('success', 'Hello'), 'Data: Hello');
+assert.strictEqual(handleStatus('error'), 'An error occurred');
 
 // Pattern matching with Result
-const processResult = (result: Result<number, string>) =>
+const processResult = (result: Result<number, string>): string =>
     Result.isOk(result) ? `Success: ${result.value}` : `Error: ${result.value}`;
 
-console.log(processResult(Result.ok(42))); // 'Success: 42'
-console.log(processResult(Result.err('Failed'))); // 'Error: Failed'
+assert.strictEqual(processResult(Result.ok(42)), 'Success: 42');
+assert.strictEqual(processResult(Result.err('Failed')), 'Error: Failed');
 ```
 
 ### 3. Number Utilities with `Num` and Branded Number Types
@@ -206,32 +205,35 @@ The `Num` object provides safe and convenient functions for numerical operations
 import { Num } from 'ts-data-forge';
 
 // Basic conversions
-const num = Num.from('123'); // 123
-const invalid = Num.from('abc'); // NaN
+assert.strictEqual(Num.from('123'), 123);
+assert.strictEqual(Number.isNaN(Num.from('abc')), true);
 
 // Range checking
 const inRange = Num.isInRange(0, 10);
-console.log(inRange(5)); // true
-console.log(inRange(0)); // true (inclusive lower bound)
-console.log(inRange(10)); // false (exclusive upper bound)
+
+assert.strictEqual(inRange(5), true);
+assert.strictEqual(inRange(0), true); // (inclusive lower bound)
+assert.strictEqual(inRange(10), false); // (exclusive upper bound)
 
 // Clamping values
 const clamp = Num.clamp(0, 100);
-console.log(clamp(150)); // 100
-console.log(clamp(-10)); // 0
+
+assert.strictEqual(clamp(150), 100);
+assert.strictEqual(clamp(-10), 0);
 
 // Rounding utilities
 const round2 = Num.round(2);
-console.log(round2(3.14159)); // 3.14
 
-console.log(Num.roundAt(3.14159, 3)); // 3.142
-console.log(Num.roundToInt(3.7) satisfies Int); // 4
+assert.strictEqual(round2(3.14159), 3.14);
+assert.strictEqual(Num.roundAt(3.14159, 3), 3.142);
+assert.strictEqual(Num.roundToInt(3.7), 4);
 
 // Type guards
-declare const value: number;
+const value = 5; // example value
 if (Num.isNonZero(value)) {
     // value is guaranteed to be non-zero
     const result = Num.div(10, value); // Safe division
+    assert.strictEqual(result, 2);
 }
 ```
 
@@ -241,22 +243,16 @@ if (Num.isNonZero(value)) {
 
 ```typescript
 import {
-    asInt,
-    asUint,
     asFiniteNumber,
-    asSafeInt,
+    asInt,
     asInt16,
-    asUint32,
     asNonZeroInt,
     asPositiveInt,
-    Int,
-    Uint,
-    FiniteNumber,
-    SafeInt,
+    asSafeInt,
+    asUint,
+    asUint32,
     Int16,
-    Uint32,
     NonZeroInt,
-    PositiveInt,
 } from 'ts-data-forge';
 
 // Basic branded types
@@ -265,25 +261,42 @@ const unsigned = asUint(42); // Uint - non-negative integer
 const finite = asFiniteNumber(3.14); // FiniteNumber - finite floating-point
 const safeInt = asSafeInt(42); // SafeInt - integer in safe range
 
-const nonInteger = asInt(3.14); // This line causes a runtime error
+assert.strictEqual(integer, 42);
+assert.strictEqual(unsigned, 42);
+assert.strictEqual(finite, 3.14);
+assert.strictEqual(safeInt, 42);
+
+// This line would cause a runtime error:
+assert.throw(() => {
+    asInt(3.14);
+});
 
 // Range-constrained types (16-bit, 32-bit)
 const int16 = asInt16(1000); // Int16: [-32768, 32767]
 const uint32 = asUint32(3000000000); // Uint32: [0, 4294967295]
+assert.strictEqual(int16, 1000);
+assert.strictEqual(uint32, 3000000000);
 
 // Non-zero and positive variants
 const nonZeroInt = asNonZeroInt(5); // NonZeroInt - excludes zero
 const positiveInt = asPositiveInt(10); // PositiveInt - excludes zero and negatives
+assert.strictEqual(nonZeroInt, 5);
+assert.strictEqual(positiveInt, 10);
 
 // Type-safe arithmetic with automatic clamping
 const sum = Int16.add(int16, asInt16(2000)); // Int16 (3000)
 const clamped = Int16.clamp(100000); // Int16 (32767 - clamped to MAX_VALUE)
+assert.strictEqual(sum, 3000);
+assert.strictEqual(clamped, 32767);
 
 // Safe division with non-zero types
 const ratio = NonZeroInt.div(asNonZeroInt(10), nonZeroInt); // No division by zero risk
+assert.strictEqual(ratio, 2);
 
 // Random generation within type constraints
 const randomInt16 = Int16.random(); // Int16 (random value in valid range)
+assert.strictEqual(-32768 <= randomInt16, true);
+assert.strictEqual(randomInt16 <= 32767, true);
 ```
 
 ### 4. Array Utilities with `Arr`
@@ -291,39 +304,54 @@ const randomInt16 = Int16.random(); // Int16 (random value in valid range)
 The `Arr` object provides a rich set of functions for array manipulation.
 
 ```typescript
-import { Arr } from 'ts-data-forge';
+import { Arr, expectType, Optional } from 'ts-data-forge';
 
 const numbers: readonly number[] = [1, 2, 3, 4, 5, 2, 3];
-const people = [
-    { name: 'Alice', age: 30 },
-    { name: 'Bob', age: 25 },
-    { name: 'Charlie', age: 35 },
-] as const;
 
 // Reduction
 const sum = Arr.sum(numbers);
-console.log(sum); // 20
 
-// Array creation
-const zeros: readonly [0, 0, 0, 0, 0] = Arr.zeros(5); // [0, 0, 0, 0, 0]
-const range: readonly [1, 2, 3] = Arr.range(1, 4); // [1, 2, 3]
+assert.strictEqual(sum, 20);
 
 // Type-safe length checking
 if (Arr.isArrayAtLeastLength(numbers, 2)) {
-    // numbers is now guaranteed to have at least 3 elements
+    // numbers is now guaranteed to have at least 2 elements
     expectType<typeof numbers, readonly [number, number, ...number[]]>('=');
-    console.log(numbers[1]); // Safe access to index 2
+    assert.strictEqual(numbers[1], 2); // Safe access to index 1
 }
 
 // Take first n elements
-const firstThree = Arr.take(numbers, 3); // [1, 2, 3]
+const firstThree = Arr.take(numbers, 3);
 
-// Find maximum by property
-const oldestPerson = Arr.maxBy(people, (person) => person.age);
-console.log(oldestPerson?.name); // 'Charlie'
+assert.deepStrictEqual(firstThree, [1, 2, 3]);
 
 // Remove duplicates
-const unique = Arr.uniq(numbers); // [1, 2, 3, 4, 5]
+const unique = Arr.uniq(numbers);
+
+assert.deepStrictEqual(unique, [1, 2, 3, 4, 5]);
+
+// Array creation
+const zeros: readonly [0, 0, 0, 0, 0] = Arr.zeros(5);
+assert.deepStrictEqual(zeros, [0, 0, 0, 0, 0]);
+
+const range: readonly [1, 2, 3] = Arr.range(1, 4);
+assert.deepStrictEqual(range, [1, 2, 3]);
+
+const people = [
+    { name: 'Alice', age: 30 },
+    { name: 'Bob', age: 25 },
+    { name: 'Charlie', age: 35 },
+] as const;
+
+// Find maximum by property
+const oldestPerson = Arr.maxBy(people, (person) => person.age);
+assert.deepStrictEqual(
+    oldestPerson,
+    Optional.some({ name: 'Charlie', age: 35 } as const),
+);
+if (Optional.isSome(oldestPerson)) {
+    assert.strictEqual(oldestPerson.value.name, 'Charlie');
+}
 ```
 
 ### 5. Immutable Collections: `IMap` and `ISet`
@@ -331,7 +359,7 @@ const unique = Arr.uniq(numbers); // [1, 2, 3, 4, 5]
 Type-safe, immutable data structures.
 
 ```typescript
-import { IMap, ISet, pipe } from 'ts-data-forge';
+import { Arr, IMap, ISet, Optional } from 'ts-data-forge';
 
 // IMap usage - immutable operations
 const originalMap = IMap.create<string, number>([]);
@@ -339,34 +367,37 @@ const mapWithOne = originalMap.set('one', 1);
 const mapWithTwo = mapWithOne.set('two', 2);
 
 // Original map is unchanged
-console.log(originalMap.size); // 0
-console.log(mapWithTwo.get('one')); // Optional.some(1)
-console.log(mapWithTwo.has('three')); // false
+assert.strictEqual(originalMap.size, 0);
+assert.deepStrictEqual(mapWithTwo.get('one'), Optional.some(1));
+
+assert.strictEqual(mapWithTwo.has('three'), false);
 
 // Using pipe for fluent updates
-const idMap = pipe(Arr.seq(10))
-    .map(Arr.map<number>(i => [i, i.toString()])
-     .map(Arr.skip(1)) // [ [1, "1"], ..., [9, "9"]]
-    .map(IMap.create<number, string>).value;
+const sequence = Arr.seq(10); // [0, 1, 2, ..., 9]
+const pairs = sequence.map(
+    (i) => [i, i.toString()] as readonly [number, string],
+);
+const skipped = Arr.skip(pairs, 1); // [[1, "1"], ..., [9, "9"]]
+const idMap = IMap.create<number, string>(skipped);
 
-console.log(idMap.size); // 9
+assert.strictEqual(idMap.size, 9);
 
 // Efficient batch updates with withMutations
 const idMapUpdated = idMap.withMutations([
-    { type: 'set', key: 99, value: "99" },
-    { type: 'update', key: 5, value: "five" },
+    { type: 'set', key: 99, value: '99' },
+    { type: 'update', key: 5, updater: () => 'five' },
     { type: 'delete', key: 4 },
 ]);
 
-console.log(idMapUpdated.size); // 9
+assert.strictEqual(idMapUpdated.size, 9);
 
 // ISet usage
 const originalSet = ISet.create<number>([]);
 const setWithItems = originalSet.add(1).add(2).add(1); // Duplicate ignored
 
-console.log(originalSet.size); // 0 (unchanged)
-console.log(setWithItems.has(1)); // true
-console.log(setWithItems.size); // 2
+assert.strictEqual(originalSet.size, 0); // (unchanged)
+assert.strictEqual(setWithItems.has(1), true);
+assert.strictEqual(setWithItems.size, 2);
 ```
 
 ### 6. Type Guards
@@ -374,9 +405,9 @@ console.log(setWithItems.size); // 2
 Safe type narrowing with comprehensive type guards.
 
 ```typescript
-import { isNonNullObject, isRecord, hasKey } from 'ts-data-forge';
+import { hasKey, isNonNullObject, isRecord } from 'ts-data-forge';
 
-function processData(data: unknown) {
+const processData = (data: unknown): string | undefined => {
     if (isRecord(data)) {
         // data is now UnknownRecord (= Readonly<Record<string, unknown>>)
         if (
@@ -384,17 +415,24 @@ function processData(data: unknown) {
             // data is now ReadonlyRecord<"name", unknown> & UnknownRecord
             typeof data.name === 'string'
         ) {
-            console.log(`Hello, ${data.name}!`);
+            return `Hello, ${data.name}!`;
         }
     }
-}
+    return undefined;
+};
 
 // Non-null object checking
-declare const value: unknown;
+const value: unknown = { key: 'value' };
+
 if (isNonNullObject(value)) {
     // value is guaranteed to be a non-null object
-    console.log(Object.keys(value));
+    assert.deepStrictEqual(Object.keys(value), ['key']);
 }
+
+// Example usage
+assert.strictEqual(processData({ name: 'Alice' }), 'Hello, Alice!');
+assert.strictEqual(processData({ age: 30 }), undefined);
+assert.strictEqual(processData('not an object'), undefined);
 ```
 
 ### 7. Iteration with `range`
@@ -405,18 +443,27 @@ Generate ranges for iteration and array creation.
 import { range } from 'ts-data-forge';
 
 // Traditional for loop using range
+const values: number[] = [];
 for (const i of range(0, 5)) {
-    console.log(i); // 0, 1, 2, 3, 4
+    values.push(i);
 }
 
+assert.deepStrictEqual(values, [0, 1, 2, 3, 4]);
+
 // Create arrays from ranges
-const numbers = Array.from(range(1, 4)); // [1, 2, 3]
-const squares = Array.from(range(1, 6), (x) => x * x); // [1, 4, 9, 16, 25]
+const numbers = Array.from(range(1, 4));
+const squares = Array.from(range(1, 6), (x) => x * x);
+
+assert.deepStrictEqual(numbers, [1, 2, 3]);
+assert.deepStrictEqual(squares, [1, 4, 9, 16, 25]);
 
 // Step ranges
+const stepValues: number[] = [];
 for (const i of range(0, 10, 2)) {
-    console.log(i); // 0, 2, 4, 6, 8
+    stepValues.push(i);
 }
+
+assert.deepStrictEqual(stepValues, [0, 2, 4, 6, 8]);
 ```
 
 ### 8. Mutability Utilities with `castMutable`
@@ -424,23 +471,23 @@ for (const i of range(0, 10, 2)) {
 Safely work with readonly types when interfacing with mutable APIs.
 
 ```tsx
-import { Autocomplete } from '@mui/material';
 import { castMutable } from 'ts-data-forge';
 
-const readonlyOptions: readonly string[] = ['Option 1', 'Option 2', 'Option 3'];
+// Example: Material-UI Autocomplete
+import { Autocomplete, TextField } from '@mui/material';
 
-const SomeComponent: React.FC = () => {
-    // Component implementation
-    return (
-        <Autocomplete
-            // Use castMutable to safely pass readonly array to mutable API. This is safer than casting with `as`, as it simply changes type `readonly T[]` to `T[]`.
-            options={castMutable(readonlyOptions)}
-            // ...
-        />
-    );
-};
+export const SomeComponent: React.FC = () => (
+    <Autocomplete
+        options={castMutable(readonlyOptions)}
+        renderInput={(params) => (
+            <TextField {...params} placeholder="Select an option" />
+        )}
+    />
+);
+
+const readonlyOptions: readonly string[] = ['Option 1', 'Option 2', 'Option 3'];
 
-// Immer.js example - draft properties need mutable types
+// Immer.js example
 import { produce } from 'immer';
 
 type State = Readonly<{
@@ -458,7 +505,8 @@ const updatedState = produce(initialState, (draft) => {
     draft.items = castMutable(newItems); // Safe cast for assignment
 });
 
-console.log(updatedState.items); // ['newItem1', 'newItem2']
+assert.deepStrictEqual(initialState.items, ['item1', 'item2']);
+assert.deepStrictEqual(updatedState.items, ['newItem1', 'newItem2']);
 ```
 
 ## Modules Overview

package/dist/index.d.mts

@@ -8,4 +8,5 @@ export * from './json/index.mjs';
 export * from './number/index.mjs';
 export * from './object/index.mjs';
 export * from './others/index.mjs';
+export * from './promise/index.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/index.mjs

@@ -58,4 +58,5 @@ export { mapNullable } from './others/map-nullable.mjs';
 export { memoizeFunction } from './others/memoize-function.mjs';
 export { tp } from './others/tuple.mjs';
 export { unknownToString } from './others/unknown-to-string.mjs';
+export { createPromise } from './promise/promise.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/promise/index.d.mts

@@ -0,0 +1,2 @@
+export * from './promise.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/promise/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/promise/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/promise/index.mjs

@@ -0,0 +1,2 @@
+export { createPromise } from './promise.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/promise/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/promise/promise.d.mts

@@ -0,0 +1,32 @@
+import { Result } from '../functional/index.mjs';
+/**
+ * Creates a Promise that wraps the result in a Result type for type-safe error handling.
+ * This function is an alternative to `new Promise(executor)` that provides enhanced type safety
+ * by returning a Result type instead of throwing exceptions.
+ *
+ * @template S - The type of successful value
+ * @template E - The type of error value
+ * @param executor - Function that takes resolve and reject callbacks
+ * @returns A Promise that resolves to a Result containing either success or error
+ *
+ * @example
+ * ```typescript
+ * const result = await createPromise<string, Error>((resolve, reject) => {
+ *   setTimeout(() => {
+ *     if (Math.random() > 0.5) {
+ *       resolve("Success!");
+ *     } else {
+ *       reject(new Error("Failed"));
+ *     }
+ *   }, 1000);
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // "Success!"
+ * } else {
+ *   console.log(result.error); // Error: Failed
+ * }
+ * ```
+ */
+export declare const createPromise: <S, E>(executor: (resolve: (value: S) => void, reject: (reason?: E) => void) => void) => Promise<Result<S, E>>;
+//# sourceMappingURL=promise.d.mts.map

package/dist/promise/promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.mts","sourceRoot":"","sources":["../../src/promise/promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,KAC5E,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIK,CAAC"}

package/dist/promise/promise.mjs

@@ -0,0 +1,38 @@
+import '../functional/optional.mjs';
+import { Result } from '../functional/result.mjs';
+
+/**
+ * Creates a Promise that wraps the result in a Result type for type-safe error handling.
+ * This function is an alternative to `new Promise(executor)` that provides enhanced type safety
+ * by returning a Result type instead of throwing exceptions.
+ *
+ * @template S - The type of successful value
+ * @template E - The type of error value
+ * @param executor - Function that takes resolve and reject callbacks
+ * @returns A Promise that resolves to a Result containing either success or error
+ *
+ * @example
+ * ```typescript
+ * const result = await createPromise<string, Error>((resolve, reject) => {
+ *   setTimeout(() => {
+ *     if (Math.random() > 0.5) {
+ *       resolve("Success!");
+ *     } else {
+ *       reject(new Error("Failed"));
+ *     }
+ *   }, 1000);
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // "Success!"
+ * } else {
+ *   console.log(result.error); // Error: Failed
+ * }
+ * ```
+ */
+const createPromise = (executor) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Result.fromPromise(new Promise(executor));
+
+export { createPromise };
+//# sourceMappingURL=promise.mjs.map

package/dist/promise/promise.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.mjs","sources":["../../src/promise/promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,aAAa,GAAG,CAC3B,QAA6E;AAE7E;AACA,MAAM,CAAC,WAAW,CAAC,IAAI,OAAO,CAAI,QAAQ,CAAC;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -45,15 +45,20 @@
     "gi": "npm run z:node-esm -- ./scripts/cmd/gi.mjs",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "lint:samples": "eslint ./samples",
     "md": "markdownlint-cli2",
     "test": "npm run z:vitest -- run",
     "test:cov": "npm run z:vitest -- run --coverage",
     "test:cov:ui": "vite preview --outDir ./coverage",
+    "test:samples": "vitest --config ./samples/vitest.config.ts",
     "test:ui": "npm run z:vitest -- --ui",
     "testw": "npm run z:vitest -- watch",
+    "testw:samples": "npm run test:samples -- watch",
     "tsc": "tsc --noEmit",
-    "tscw": "tsc --noEmit --watch",
+    "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
+    "tscw:samples": "tsc --noEmit --watch -p ./samples/tsconfig.json",
     "type-check": "tsc --noEmit",
+    "type-check:samples": "tsc --noEmit -p ./samples/tsconfig.json",
     "update-packages": "npx npm-check-updates -u --install always --reject @types/node",
     "z:node-esm": "node --import tsx/esm",
     "z:vitest": "vitest --config ./configs/vitest.config.ts"
@@ -62,10 +67,13 @@
     "ts-type-forge": "^2.0.3"
   },
   "devDependencies": {
-    "@eslint/js": "^9.29.0",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.1",
+    "@eslint/js": "^9.30.0",
+    "@mui/material": "^7.1.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-strip": "^3.0.4",
-    "@rollup/plugin-typescript": "^12.1.2",
+    "@rollup/plugin-typescript": "^12.1.4",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
@@ -78,17 +86,18 @@
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.0.0",
     "cspell": "^9.1.1",
-    "eslint": "^9.29.0",
+    "eslint": "^9.30.0",
     "fast-glob": "^3.3.3",
+    "immer": "^10.1.1",
     "markdownlint-cli2": "^0.18.1",
     "prettier": "^3.5.3",
     "prettier-plugin-organize-imports": "^4.1.0",
-    "prettier-plugin-packagejson": "^2.5.15",
-    "rollup": "^4.44.0",
+    "prettier-plugin-packagejson": "^2.5.17",
+    "rollup": "^4.44.1",
     "semantic-release": "^24.2.5",
-    "ts-repo-utils": "^2.2.0",
+    "ts-repo-utils": "^3.0.1",
     "tsx": "^4.20.3",
-    "typedoc": "^0.28.5",
+    "typedoc": "^0.28.6",
     "typedoc-plugin-markdown": "^4.7.0",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.34.1",

package/src/index.mts

@@ -8,3 +8,4 @@ export * from './json/index.mjs';
 export * from './number/index.mjs';
 export * from './object/index.mjs';
 export * from './others/index.mjs';
+export * from './promise/index.mjs';

package/src/promise/index.mts

@@ -0,0 +1 @@
+export * from './promise.mjs';

package/src/promise/promise.mts

@@ -0,0 +1,38 @@
+import { Result } from '../functional/index.mjs';
+
+/**
+ * Creates a Promise that wraps the result in a Result type for type-safe error handling.
+ * This function is an alternative to `new Promise(executor)` that provides enhanced type safety
+ * by returning a Result type instead of throwing exceptions.
+ *
+ * @template S - The type of successful value
+ * @template E - The type of error value
+ * @param executor - Function that takes resolve and reject callbacks
+ * @returns A Promise that resolves to a Result containing either success or error
+ *
+ * @example
+ * ```typescript
+ * const result = await createPromise<string, Error>((resolve, reject) => {
+ *   setTimeout(() => {
+ *     if (Math.random() > 0.5) {
+ *       resolve("Success!");
+ *     } else {
+ *       reject(new Error("Failed"));
+ *     }
+ *   }, 1000);
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // "Success!"
+ * } else {
+ *   console.log(result.error); // Error: Failed
+ * }
+ * ```
+ */
+export const createPromise = <S, E>(
+  executor: (resolve: (value: S) => void, reject: (reason?: E) => void) => void,
+): Promise<Result<S, E>> =>
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  Result.fromPromise(new Promise<S>(executor)) satisfies Promise<
+    Result<S, unknown>
+  > as Promise<Result<S, E>>;