ts-fortress 1.0.0

package/src/array/tuple.test.mts

@@ -0,0 +1,122 @@
+import { expectType } from 'ts-data-forge';
+import { number, numberLiteral, stringLiteral } from '../primitives/index.mjs';
+import { record } from '../record/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import { tuple } from './tuple.mjs';
+
+describe('tuple', () => {
+  describe('arg patterns', () => {
+    test('without explicit default value', () => {
+      expect(
+        tuple([numberLiteral(1), numberLiteral(2), numberLiteral(3)])
+          .defaultValue,
+      ).toStrictEqual([1, 2, 3]);
+    });
+
+    test('with explicit default value', () => {
+      expect(
+        tuple([numberLiteral(1), numberLiteral(2), numberLiteral(3)], {
+          typeName: 'tpl',
+        }).typeName,
+      ).toBe('tpl');
+    });
+  });
+
+  const targetType = tuple([
+    record({ x: number(0), y: number(0) }),
+    numberLiteral(3),
+    stringLiteral('2'),
+  ]);
+
+  type TargetType = TypeOf<typeof targetType>;
+
+  expectType<
+    TargetType,
+    readonly [
+      Readonly<{
+        x: number;
+        y: number;
+      }>,
+      3,
+      '2',
+    ]
+  >('=');
+
+  expectType<typeof targetType.defaultValue, TargetType>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: unknown = [{ x: 1, y: 2 }, 3, '2'];
+
+      if (targetType.is(x)) {
+        expectType<typeof x, TargetType>('=');
+      } else {
+        expectType<typeof x, unknown>('=');
+      }
+
+      expect(targetType.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: unknown = [{ x: 'str', y: 'str' }, 3, '2'];
+
+      if (targetType.is(x)) {
+        expectType<typeof x, TargetType>('=');
+      } else {
+        expectType<typeof x, unknown>('=');
+      }
+
+      expect(targetType.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: unknown = [{ x: 'str', y: 'str' }, 3, '2'];
+
+      expect(targetType.validate(x).value).toStrictEqual([
+        `The tuple element at 0 is expected to be <{ x: number, y: number }>, but it is actually '{"x":"str","y":"str"}'.`,
+        `The value at record key "x" is expected to be <number>, but it is actually '"str"'.`,
+        `The value is expected to be <number>, but it is actually '"str"'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('noop', () => {
+      const x: unknown = [{ x: 1, y: 2 }, 3, '2'];
+
+      expect(targetType.fill(x)).toStrictEqual([{ x: 1, y: 2 }, 3, '2']);
+    });
+
+    test('fill with the default value', () => {
+      const x: unknown = 5;
+
+      expect(targetType.fill(x)).toStrictEqual([{ x: 0, y: 0 }, 3, '2']);
+    });
+
+    test('fill only the first element with the default value, case 1', () => {
+      const x: unknown = [123, 3, '2'];
+
+      expect(targetType.fill(x)).toStrictEqual([{ x: 0, y: 0 }, 3, '2']);
+    });
+
+    test('fill only the first element with the default value, case 2', () => {
+      const x: unknown = [{ z: 5 }, 3, '2'];
+
+      expect(targetType.fill(x)).toStrictEqual([{ x: 0, y: 0 }, 3, '2']);
+    });
+
+    test('fill only the second element with the default value', () => {
+      const x: unknown = [{ x: 1, y: 2 }, 0, '2'];
+
+      expect(targetType.fill(x)).toStrictEqual([{ x: 1, y: 2 }, 3, '2']);
+    });
+
+    test('fill only the third element with the default value', () => {
+      const x: unknown = [{ x: 1, y: 2 }, 3, 999];
+
+      expect(targetType.fill(x)).toStrictEqual([{ x: 1, y: 2 }, 3, '2']);
+    });
+  });
+});

package/src/branded/brand.mts

@@ -0,0 +1,70 @@
+import { pipe, Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createType, validationErrorMessage } from '../utils/index.mjs';
+
+type ArrayToUnion<A extends readonly unknown[]> = A extends readonly []
+  ? never
+  : A[number];
+
+export const brand = <
+  const A extends Primitive,
+  const BrandTrueKeys extends readonly string[],
+  const BrandFalseKeys extends readonly string[] = [],
+>({
+  codec,
+  is,
+  brandKeys,
+  brandFalseKeys,
+  defaultValue,
+}: Readonly<{
+  codec: Type<A>;
+  is: (
+    a: A,
+  ) => a is Brand<A, ArrayToUnion<BrandTrueKeys>, ArrayToUnion<BrandFalseKeys>>;
+  brandKeys: BrandTrueKeys;
+  brandFalseKeys?: BrandFalseKeys;
+  defaultValue: Brand<
+    A,
+    ArrayToUnion<BrandTrueKeys>,
+    ArrayToUnion<BrandFalseKeys>
+  >;
+}>): Type<
+  Brand<A, ArrayToUnion<BrandTrueKeys>, ArrayToUnion<BrandFalseKeys>>
+> => {
+  type T = Brand<A, ArrayToUnion<BrandTrueKeys>, ArrayToUnion<BrandFalseKeys>>;
+
+  const brandKeysStr = [
+    ...brandKeys,
+    ...(brandFalseKeys?.map((s) => `not(${s})`) ?? []),
+  ].join(' & ');
+
+  const validate: Type<T>['validate'] = (a) =>
+    pipe(a)
+      .map(codec.validate)
+      .map(
+        (v): Result<T, readonly string[]> =>
+          Result.isErr(v)
+            ? v
+            : is(v.value)
+              ? Result.ok(v.value)
+              : Result.err([
+                  validationErrorMessage(
+                    v.value,
+                    `The value must satisfy the constraint corresponding to the brand keys: <${brandKeysStr}>`,
+                  ),
+                ]),
+      ).value;
+
+  const fill: Type<T>['fill'] = (a) =>
+    Result.unwrapOkOr(
+      validate(a) satisfies Result<T, unknown>,
+      defaultValue satisfies T,
+    ) satisfies T;
+
+  return createType({
+    typeName: brandKeysStr,
+    defaultValue,
+    validate,
+    fill,
+  });
+};

package/src/branded/index.mts

@@ -0,0 +1,4 @@
+export * from './brand.mjs';
+export * from './number/index.mjs';
+export * from './simple-branded-number.mjs';
+export * from './simple-branded-string.mjs';

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

@@ -0,0 +1,15 @@
+import { asFiniteNumber, FiniteNumber } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const finiteNumber = (
+  defaultValue: FiniteNumber = asFiniteNumber(0),
+): Type<FiniteNumber> =>
+  brand({
+    codec: number(defaultValue),
+    is: FiniteNumber.is,
+    defaultValue,
+    brandKeys: ['Finite'],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/index.mts

@@ -0,0 +1,16 @@
+export * from './finite-number.mjs';
+export * from './int.mjs';
+export * from './int16.mjs';
+export * from './int32.mjs';
+export * from './non-negative-finite-number.mjs';
+export * from './non-zero-finite-number.mjs';
+export * from './non-zero-int.mjs';
+export * from './non-zero-safe-int.mjs';
+export * from './positive-finite-number.mjs';
+export * from './positive-int.mjs';
+export * from './positive-safe-int.mjs';
+export * from './safe-int.mjs';
+export * from './safe-uint.mjs';
+export * from './uint.mjs';
+export * from './uint16.mjs';
+export * from './uint32.mjs';

package/src/branded/number/int.mts

@@ -0,0 +1,13 @@
+import { asInt, Int } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const int = (defaultValue: Int = asInt(0)): Type<Int> =>
+  brand({
+    codec: number(defaultValue),
+    is: Int.is,
+    defaultValue,
+    brandKeys: ['Finite', 'Int'],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/int16.mts

@@ -0,0 +1,25 @@
+import { asInt16, isInt16 } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const int16 = (defaultValue: Int16 = asInt16(0)): Type<Int16> =>
+  brand({
+    codec: number(defaultValue),
+    is: isInt16,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      'SafeInt',
+      '> -2^32',
+      '>= -2^31',
+      '< 2^32',
+      '< 2^31',
+      '< 2^15',
+      '< 2^16',
+      '> -2^16',
+      '>= -2^15',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/int32.mts

@@ -0,0 +1,21 @@
+import { asInt32, isInt32 } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const int32 = (defaultValue: Int32 = asInt32(0)): Type<Int32> =>
+  brand({
+    codec: number(defaultValue),
+    is: isInt32,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      'SafeInt',
+      '> -2^32',
+      '>= -2^31',
+      '< 2^32',
+      '< 2^31',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/non-negative-finite-number.mts

@@ -0,0 +1,18 @@
+import {
+  asNonNegativeFiniteNumber,
+  isNonNegativeFiniteNumber,
+} from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const nonNegativeFiniteNumber = (
+  defaultValue: NonNegativeFiniteNumber = asNonNegativeFiniteNumber(0),
+): Type<NonNegativeFiniteNumber> =>
+  brand({
+    codec: number(defaultValue),
+    is: isNonNegativeFiniteNumber,
+    defaultValue,
+    brandKeys: ['>=0', '> -2^16', '> -2^32', '>= -2^15', '>= -2^31', 'Finite'],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/non-zero-finite-number.mts

@@ -0,0 +1,15 @@
+import { isNonZeroFiniteNumber } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const nonZeroFiniteNumber = (
+  defaultValue: NonZeroFiniteNumber,
+): Type<NonZeroFiniteNumber> =>
+  brand({
+    codec: number(defaultValue),
+    is: isNonZeroFiniteNumber,
+    defaultValue,
+    brandKeys: ['!=0', 'Finite'],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,15 @@
+import { asNonZeroInt, isNonZeroInt } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const nonZeroInt = (
+  defaultValue: NonZeroInt = asNonZeroInt(0),
+): Type<NonZeroInt> =>
+  brand({
+    codec: number(defaultValue),
+    is: isNonZeroInt,
+    defaultValue,
+    brandKeys: ['Finite', 'Int', '!=0'],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,15 @@
+import { isNonZeroSafeInt } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const nonZeroSafeInt = (
+  defaultValue: NonZeroSafeInt,
+): Type<NonZeroSafeInt> =>
+  brand({
+    codec: number(defaultValue),
+    is: isNonZeroSafeInt,
+    defaultValue,
+    brandKeys: ['Finite', 'Int', 'SafeInt', '!=0'],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,23 @@
+import { isPositiveFiniteNumber } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const positiveFiniteNumber = (
+  defaultValue: PositiveFiniteNumber,
+): Type<PositiveFiniteNumber> =>
+  brand({
+    codec: number(defaultValue),
+    is: isPositiveFiniteNumber,
+    defaultValue,
+    brandKeys: [
+      '>=0',
+      '> -2^16',
+      '> -2^32',
+      '>= -2^15',
+      '>= -2^31',
+      'Finite',
+      '!=0',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,24 @@
+import { asPositiveInt, isPositiveInt } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const positiveInt = (
+  defaultValue: PositiveInt = asPositiveInt(1),
+): Type<PositiveInt> =>
+  brand({
+    codec: number(defaultValue),
+    is: isPositiveInt,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      '> -2^32',
+      '>= -2^31',
+      '> -2^16',
+      '>= -2^15',
+      '>=0',
+      '!=0',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,25 @@
+import { asPositiveSafeInt, isPositiveSafeInt } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const positiveSafeInt = (
+  defaultValue: PositiveSafeInt = asPositiveSafeInt(1),
+): Type<PositiveSafeInt> =>
+  brand({
+    codec: number(defaultValue),
+    is: isPositiveSafeInt,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      'SafeInt',
+      '> -2^32',
+      '>= -2^31',
+      '> -2^16',
+      '>= -2^15',
+      '>=0',
+      '!=0',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,13 @@
+import { asSafeInt, SafeInt } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const safeInt = (defaultValue: SafeInt = asSafeInt(0)): Type<SafeInt> =>
+  brand({
+    codec: number(defaultValue),
+    is: SafeInt.is,
+    defaultValue,
+    brandKeys: ['Finite', 'Int', 'SafeInt'],
+    brandFalseKeys: ['NaNValue'],
+  });

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

@@ -0,0 +1,24 @@
+import { asSafeUint, isSafeUint } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const safeUint = (
+  defaultValue: SafeUint = asSafeUint(0),
+): Type<SafeUint> =>
+  brand({
+    codec: number(defaultValue),
+    is: isSafeUint,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      'SafeInt',
+      '> -2^16',
+      '> -2^32',
+      '>= -2^15',
+      '>= -2^31',
+      '>=0',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/uint.mts

@@ -0,0 +1,21 @@
+import { asUint, isUint } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const uint = (defaultValue: Uint = asUint(0)): Type<Uint> =>
+  brand({
+    codec: number(defaultValue),
+    is: isUint,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      '> -2^32',
+      '>= -2^31',
+      '> -2^16',
+      '>= -2^15',
+      '>=0',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/uint16.mts

@@ -0,0 +1,25 @@
+import { asUint16, isUint16 } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const uint16 = (defaultValue: Uint16 = asUint16(0)): Type<Uint16> =>
+  brand({
+    codec: number(defaultValue),
+    is: isUint16,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      'SafeInt',
+      '> -2^16',
+      '> -2^32',
+      '>= -2^15',
+      '>= -2^31',
+      '>=0',
+      '< 2^32',
+      '< 2^16',
+      '< 2^31',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/number/uint32.mts

@@ -0,0 +1,23 @@
+import { asUint32, isUint32 } from 'ts-data-forge';
+import { number } from '../../primitives/index.mjs';
+import { type Type } from '../../type.mjs';
+import { brand } from '../brand.mjs';
+
+export const uint32 = (defaultValue: Uint32 = asUint32(0)): Type<Uint32> =>
+  brand({
+    codec: number(defaultValue),
+    is: isUint32,
+    defaultValue,
+    brandKeys: [
+      'Finite',
+      'Int',
+      'SafeInt',
+      '> -2^16',
+      '> -2^32',
+      '>= -2^15',
+      '>= -2^31',
+      '>=0',
+      '< 2^32',
+    ],
+    brandFalseKeys: ['NaNValue'],
+  });

package/src/branded/simple-branded-number.mts

@@ -0,0 +1,18 @@
+import { number } from '../primitives/index.mjs';
+import { type Type } from '../type.mjs';
+import { brand } from './brand.mjs';
+
+export const simpleBrandedNumber = <S extends string>(
+  typeName: S,
+  defaultValue: number = 0,
+): Type<Brand<number, S>> =>
+  brand({
+    codec: number(defaultValue),
+
+    defaultValue:
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      defaultValue as Brand<number, S>,
+
+    is: (_id: number): _id is Brand<number, S> => true,
+    brandKeys: [typeName],
+  });

package/src/branded/simple-branded-string.mts

@@ -0,0 +1,18 @@
+import { string } from '../primitives/index.mjs';
+import { type Type } from '../type.mjs';
+import { brand } from './brand.mjs';
+
+export const simpleBrandedString = <S extends string>(
+  typeName: S,
+  defaultValue: string = '',
+): Type<Brand<string, S>> =>
+  brand({
+    codec: string(defaultValue),
+
+    defaultValue:
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      defaultValue as Brand<string, S>,
+
+    is: (_id: string): _id is Brand<string, S> => true,
+    brandKeys: [typeName],
+  });