ts-data-forge 6.9.1 → 6.9.3

package/src/number/branded-types/non-zero-int32.mts

@@ -1,6 +1,9 @@
+import { type NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type NonZeroInt32 = TtfImported_NonZeroInt32;
+
 type ElementType = NonZeroInt32;
 
 const typeNameInMessage = 'a non-zero integer in [-2^31, 2^31)';

package/src/number/branded-types/non-zero-safe-int.mts

@@ -1,6 +1,13 @@
+import {
+  type SafeInt,
+  type SafeUint,
+  type NonZeroSafeInt as TtfImported_NonZeroSafeInt,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
+
 type ElementType = NonZeroSafeInt;
 
 const typeNameInMessage = 'a non-zero safe integer';

package/src/number/branded-types/non-zero-uint16.mts

@@ -1,6 +1,9 @@
+import { type NonZeroUint16 as TtfImported_NonZeroUint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type NonZeroUint16 = TtfImported_NonZeroUint16;
+
 type ElementType = NonZeroUint16;
 
 const typeNameInMessage = 'a non-zero integer in [1, 2^16)';

package/src/number/branded-types/non-zero-uint32.mts

@@ -1,6 +1,9 @@
+import { type NonZeroUint32 as TtfImported_NonZeroUint32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type NonZeroUint32 = TtfImported_NonZeroUint32;
+
 type ElementType = NonZeroUint32;
 
 const typeNameInMessage = 'a non-zero integer in [1, 2^32)';

package/src/number/branded-types/positive-finite-number.mts

@@ -1,6 +1,13 @@
+import {
+  type PositiveInt,
+  type PositiveFiniteNumber as TtfImported_PositiveFiniteNumber,
+  type Uint,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveFiniteNumber = TtfImported_PositiveFiniteNumber;
+
 type ElementType = PositiveFiniteNumber;
 
 const typeNameInMessage = 'a positive finite number';

package/src/number/branded-types/positive-int.mts

@@ -1,6 +1,9 @@
+import { type PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveInt = TtfImported_PositiveInt;
+
 type ElementType = PositiveInt;
 
 const typeNameInMessage = 'a positive integer';

package/src/number/branded-types/positive-int16.mts

@@ -1,6 +1,9 @@
+import { type PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveInt16 = TtfImported_PositiveInt16;
+
 type ElementType = PositiveInt16;
 
 const typeNameInMessage = 'a positive integer in [1, 2^15)';

package/src/number/branded-types/positive-int32.mts

@@ -1,6 +1,9 @@
+import { type PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveInt32 = TtfImported_PositiveInt32;
+
 type ElementType = PositiveInt32;
 
 const typeNameInMessage = 'a positive integer in [1, 2^31)';

package/src/number/branded-types/positive-safe-int.mts

@@ -1,6 +1,12 @@
+import {
+  type SafeUint,
+  type PositiveSafeInt as TtfImported_PositiveSafeInt,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveSafeInt = TtfImported_PositiveSafeInt;
+
 type ElementType = PositiveSafeInt;
 
 const typeNameInMessage = 'a positive safe integer';

package/src/number/branded-types/positive-uint16.mts

@@ -1,6 +1,9 @@
+import { type PositiveUint16 as TtfImported_PositiveUint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveUint16 = TtfImported_PositiveUint16;
+
 type ElementType = PositiveUint16;
 
 const typeNameInMessage = 'a positive integer in [1, 2^16)';

package/src/number/branded-types/positive-uint32.mts

@@ -1,6 +1,9 @@
+import { type PositiveUint32 as TtfImported_PositiveUint32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type PositiveUint32 = TtfImported_PositiveUint32;
+
 type ElementType = PositiveUint32;
 
 const typeNameInMessage = 'a positive integer in [1, 2^32)';

package/src/number/branded-types/safe-int.mts

@@ -1,6 +1,12 @@
+import {
+  type SafeUint,
+  type SafeInt as TtfImported_SafeInt,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type SafeInt = TtfImported_SafeInt;
+
 type ElementType = SafeInt;
 
 const typeNameInMessage = 'a safe integer';

package/src/number/branded-types/safe-uint.mts

@@ -1,6 +1,9 @@
+import { type SafeUint as TtfImported_SafeUint } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type SafeUint = TtfImported_SafeUint;
+
 type ElementType = SafeUint;
 
 const typeNameInMessage = 'a non-negative safe integer';

package/src/number/branded-types/uint.mts

@@ -1,6 +1,9 @@
+import { type Uint as TtfImported_Uint } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type Uint = TtfImported_Uint;
+
 type ElementType = Uint;
 
 const typeNameInMessage = 'a non-negative integer';

package/src/number/branded-types/uint16.mts

@@ -1,6 +1,9 @@
+import { type Uint16 as TtfImported_Uint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type Uint16 = TtfImported_Uint16;
+
 type ElementType = Uint16;
 
 const typeNameInMessage = 'a non-negative integer less than 2^16';

package/src/number/branded-types/uint32.mts

@@ -1,6 +1,9 @@
+import { type Uint32 as TtfImported_Uint32 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type Uint32 = TtfImported_Uint32;
+
 type ElementType = Uint32;
 
 const typeNameInMessage = 'a non-negative integer less than 2^32';

package/src/number/enum/int8.mts

@@ -1,6 +1,13 @@
+import {
+  type AbsoluteValue,
+  type Int16,
+  type Int8 as TtfImported_Int8,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type Int8 = TtfImported_Int8;
+
 const typeNameInMessage = 'an integer in [-128, 127]';
 
 const {

package/src/number/enum/uint8.mts

@@ -1,6 +1,9 @@
+import { type Uint8 as TtfImported_Uint8, type Uint16 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
+export type Uint8 = TtfImported_Uint8;
+
 const typeNameInMessage = 'an non-negative integer less than 256';
 
 const {

package/src/number/num.mts

@@ -1,4 +1,22 @@
+import {
+  type Decrement,
+  type Increment,
+  type Index,
+  type Int,
+  type Min,
+  type NaNType,
+  type NegativeIndex,
+  type NonNegativeNumber,
+  type NonZeroNumber,
+  type PositiveNumber,
+  type PositiveSafeIntWithSmallInt,
+  type RelaxedExclude,
+  type SmallInt,
+  type SmallUint,
+  type UnknownBrand,
+} from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
+import { type SmallPositiveInt } from '../types.mjs';
 
 /**
  * Namespace providing utility functions for number manipulation and validation.

package/src/number/num.test.mts

@@ -1,3 +1,4 @@
+import { type NonZeroNumber } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
 import { asNonZeroFiniteNumber } from './branded-types/index.mjs';

package/src/number/refined-number-utils.mts

@@ -1,3 +1,18 @@
+import {
+  type Brand,
+  type ChangeBaseBrand,
+  type GetBrandValuePart,
+  type Int,
+  type IntersectBrand,
+  type NonNegativeNumber,
+  type NonZeroNumber,
+  type RelaxedExclude,
+  type TypeEq,
+  type UnknownBrand,
+  type UnwrapBrandFalseKeys,
+  type UnwrapBrandTrueKeys,
+  type WithSmallInt,
+} from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
 import { Num } from './num.mjs';

package/src/object/object.mts

@@ -1,3 +1,16 @@
+import {
+  type ArrayElement,
+  type Decrement,
+  type DeepOmit,
+  type DeepPick,
+  type IsFixedLengthList,
+  type IsUnion,
+  type List,
+  type ReadonlyRecord,
+  type RelaxedPick,
+  type TypeEq,
+  type UnknownRecord,
+} from 'ts-type-forge';
 import { Arr } from '../array/index.mjs';
 import { hasKey, isRecord } from '../guard/index.mjs';
 

package/src/object/object.test.mts

@@ -1,3 +1,8 @@
+import {
+  type ArrayOfLength,
+  type DeepReadonly,
+  type UnknownRecord,
+} from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
 import { Obj } from './object.mjs';

package/src/others/cast-mutable.mts

@@ -1,3 +1,5 @@
+import { type DeepMutable, type Mutable } from 'ts-type-forge';
+
 /**
  * Casts a readonly type `T` to its `Mutable<T>` equivalent.
  *
@@ -13,6 +15,7 @@
  * @see castReadonly - For the opposite operation
  */
 export const castMutable = <T,>(readonlyValue: T): Mutable<T> =>
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   readonlyValue as Mutable<T>;
 
 /**

package/src/others/cast-readonly.mts

@@ -1,3 +1,5 @@
+import { type DeepReadonly } from 'ts-type-forge';
+
 /**
  * Casts a mutable type `T` to its `Readonly<T>` equivalent.
  *
@@ -13,6 +15,7 @@
  * @see castMutable - For the opposite operation (use with caution)
  */
 export const castReadonly = <T,>(mutable: T): Readonly<T> =>
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   mutable as Readonly<T>;
 
 /**

package/src/others/debounce-function.test.mts

@@ -16,7 +16,6 @@ describe(debounce, () => {
   test('should delay the execution of the function', () => {
     const func = vi.fn();
 
-    // eslint-disable-next-line @typescript-eslint/strict-void-return
     const debouncedFunc = debounce(func, 100);
 
     debouncedFunc();
@@ -35,7 +34,6 @@ describe(debounce, () => {
   test('should only execute the function once after multiple rapid calls', () => {
     const func = vi.fn();
 
-    // eslint-disable-next-line @typescript-eslint/strict-void-return
     const debouncedFunc = debounce(func, 100);
 
     debouncedFunc();

package/src/others/fast-deep-equal.test.mts

@@ -3,8 +3,8 @@
 /* eslint-disable require-unicode-regexp */
 /* eslint-disable no-restricted-globals */
 /* eslint-disable functional/no-class-inheritance */
-
 import * as React from 'react';
+import { type ReadonlyRecord } from 'ts-type-forge';
 import { fastDeepEqual } from './fast-deep-equal.mjs';
 
 const fastDeepEqualUntyped = (a: any, b: any): boolean => fastDeepEqual(a, b);

package/src/others/map-nullable.test.mts

@@ -1,3 +1,4 @@
+import { type DeepReadonly } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
 import { mapNullable } from './map-nullable.mjs';

package/src/others/memoize-function.mts

@@ -1,3 +1,5 @@
+import { type Primitive } from 'ts-type-forge';
+
 /**
  * Creates a memoized version of a function that caches results based on input
  * arguments.

package/src/types.mts

@@ -0,0 +1,131 @@
+import {
+  type IndexOfTuple,
+  type IntersectBrand,
+  type IsFixedLengthList,
+  type NegativeIndexOfTuple,
+  type NegativeInt32,
+  type NormalizeBrandUnion,
+  type PositiveInt,
+  type PositiveNumber,
+  type Primitive,
+  type SafeInt,
+  type SafeUint,
+  type Uint32,
+  type WithSmallInt,
+} from 'ts-type-forge';
+
+export type SmallPositiveInt = WithSmallInt<PositiveInt>;
+
+/** Represents the type of keys that can be used in a standard JavaScript Map. */
+export type MapSetKeyType = Primitive;
+
+export type ArrayIndex<Ar extends readonly unknown[]> =
+  IsFixedLengthList<Ar> extends true ? IndexOfTuple<Ar> : SizeType.Arr;
+
+export type ArgArrayIndex<Ar extends readonly unknown[]> =
+  IsFixedLengthList<Ar> extends true ? IndexOfTuple<Ar> : SizeType.ArgArr;
+
+export type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> =
+  IsFixedLengthList<Ar> extends true
+    ? IndexOfTuple<readonly [...Ar, 0]> | NegativeIndexOfTuple<Ar>
+    : SizeType.ArgArrWithNegative;
+
+// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length
+// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/String/length
+// Max array length : 2^32 - 1
+// Max string length : 2^53 - 1
+
+export namespace SizeType {
+  export type Arr = Uint32;
+
+  export type TypedArray = SafeUint;
+
+  export type Str = SafeUint;
+
+  export type ArrSearchResult = Arr | -1;
+
+  export type TypedArraySearchResult = TypedArray | -1;
+
+  export type StrSearchResult = Str | -1;
+
+  export type ArgArr = WithSmallInt<Arr>;
+
+  export type ArgTypedArray = WithSmallInt<TypedArray>;
+
+  export type ArgStr = WithSmallInt<Str>;
+
+  export type ArgArrWithNegative = WithSmallInt<
+    NormalizeBrandUnion<NegativeInt32 | Arr>
+  >;
+
+  export type ArgTypedArrayWithNegative = WithSmallInt<SafeInt>;
+
+  export type ArgStrWithNegative = WithSmallInt<SafeInt>;
+
+  export type ArgArrPositive = WithSmallInt<
+    IntersectBrand<PositiveNumber, Arr>
+  >;
+
+  export type ArgTypedArrayPositive = WithSmallInt<
+    IntersectBrand<PositiveNumber, TypedArray>
+  >;
+
+  export type ArgStrPositive = WithSmallInt<
+    IntersectBrand<PositiveNumber, Str>
+  >;
+}
+
+// #region Optional
+/**
+ * Represents the 'Some' variant of an Optional, containing a value.
+ *
+ * @template S The type of the contained value.
+ */
+export type Some<S> = Readonly<{
+  /** @internal Discriminant property for the 'Some' type. */
+  $$tag: 'ts-data-forge::Optional.some';
+
+  /** The contained value. */
+  value: S;
+}>;
+
+/**
+ * Represents the 'None' variant of an Optional, indicating the absence
+ * of a value.
+ */
+export type None = Readonly<{
+  /** @internal Discriminant property for the 'None' type. */
+  $$tag: 'ts-data-forge::Optional.none';
+}>;
+
+// #endregion Optional
+
+// #region Result
+
+/**
+ * Represents a `Result` that is a success, containing a value.
+ *
+ * @template S The type of the success value.
+ */
+export type Ok<S> = Readonly<{
+  /** @internal Discriminant property for the 'Ok' type. */
+  $$tag: 'ts-data-forge::Result.ok';
+
+  /** The success value. */
+  value: S;
+}>;
+
+/**
+ * Represents a `Result` that is an error, containing an error value.
+ *
+ * @template E The type of the error value.
+ */
+export type Err<E> = Readonly<{
+  /** @internal Discriminant property for the 'Err' type. */
+  $$tag: 'ts-data-forge::Result.err';
+
+  /** The error value. */
+  value: E;
+}>;
+
+// #endregion Result