ts-fortress 1.0.0

package/src/combination.test.mts

@@ -0,0 +1,287 @@
+import { asInt, expectType, Result } from 'ts-data-forge';
+import { array } from './array/index.mjs';
+import { int } from './branded/index.mjs';
+import { uintRange } from './enum/index.mjs';
+import { number } from './primitives/index.mjs';
+import { optional, pick, record } from './record/index.mjs';
+import { type TypeOf } from './type.mjs';
+import { unknown } from './unknown.mjs';
+
+describe('nested record', () => {
+  const nestedRecord = record({
+    xs: array(int(asInt(2))),
+    rec: pick(
+      record({
+        a: uintRange({ start: 0, end: 11, defaultValue: 0 }),
+        b: uintRange({ start: 0, end: 11, defaultValue: 0 }),
+        c: optional(uintRange({ start: 3, end: 6, defaultValue: 3 })),
+        d: unknown(),
+      }),
+      ['a', 'b', 'c'],
+    ),
+    meta: number(100),
+    u: unknown(),
+  });
+
+  type NestedRecord = TypeOf<typeof nestedRecord>;
+
+  expectType<
+    NestedRecord,
+    Readonly<{
+      xs: readonly Int[];
+      rec: Readonly<{
+        a: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+        b: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+        c?: 3 | 4 | 5;
+      }>;
+      meta: number;
+      u: unknown;
+    }>
+  >('=');
+
+  expectType<typeof nestedRecord.defaultValue, NestedRecord>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: UnknownRecord = {
+        xs: [1, 2, 3],
+        rec: {
+          a: 1,
+          b: 2,
+          c: 3,
+        },
+        meta: 3,
+        u: undefined,
+      };
+
+      if (nestedRecord.is(x)) {
+        expectType<typeof x, NestedRecord>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(nestedRecord.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        xs: [-1, 2.2, 3.3],
+        rec: {
+          a: 123,
+          b: 234,
+          c: 3,
+        },
+        meta: 345,
+        u: undefined,
+      };
+
+      if (nestedRecord.is(x)) {
+        expectType<typeof x, NestedRecord>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(nestedRecord.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        xs: [-1, 2.2, 3.3],
+        rec: {
+          a: 123,
+          b: 234,
+          c: 3,
+        },
+        meta: 345,
+        u: undefined,
+      };
+
+      expect(nestedRecord.validate(x).value).toStrictEqual([
+        `The value at record key "xs" is expected to be <(Finite & Int & not(NaNValue))[]>, but it is actually '[-1,2.2,3.3]'.`,
+        `The array element is expected to be <Finite & Int & not(NaNValue)>, but the actual value at index 1 is '2.2'.`,
+        `The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & not(NaNValue)>, but it is actually '2.2'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('from an empty record', () => {
+      const x: UnknownRecord = {};
+
+      expect(nestedRecord.fill(x)).toStrictEqual({
+        xs: [],
+        rec: {
+          a: 0,
+          b: 0,
+          c: 3,
+        },
+        meta: 100,
+        u: undefined,
+      });
+    });
+
+    test('from a filled record', () => {
+      const x: UnknownRecord = {
+        xs: [-1, 2.2, 3.3],
+        rec: {
+          a: 123,
+          b: 234,
+          c: 3,
+        },
+        meta: 345,
+        u: undefined,
+      };
+
+      expect(nestedRecord.fill(x)).toStrictEqual({
+        xs: [-1, 2, 2],
+        rec: {
+          a: 0,
+          b: 0,
+          c: 3,
+        },
+        meta: 345,
+        u: undefined,
+      });
+    });
+
+    test('from a partial record', () => {
+      const x: UnknownRecord = {
+        xs: [11, 22],
+        rec: {
+          a: 3,
+        },
+      };
+
+      expect(nestedRecord.fill(x)).toStrictEqual({
+        xs: [11, 22],
+        rec: {
+          a: 3,
+          b: 0,
+          c: 3,
+        },
+        meta: 100,
+        u: undefined,
+      });
+    });
+
+    test('from a partial record with excess property', () => {
+      const x: UnknownRecord = {
+        xs: [11, 22],
+        rec: {
+          a: 3,
+          d: 9988,
+        },
+        u: undefined,
+        aaaaa: [9999],
+      };
+
+      expect(nestedRecord.fill(x)).toStrictEqual({
+        xs: [11, 22],
+        rec: {
+          a: 3,
+          b: 0,
+          c: 3,
+        },
+        meta: 100,
+        u: undefined,
+      });
+    });
+  });
+});
+
+describe('ymd', () => {
+  const ymd = record({
+    year: number(1900),
+    month: number(1),
+    date: number(1),
+  });
+
+  test('is', () => {
+    const x = {
+      year: 2000,
+    };
+
+    expect(ymd.is(x)).toBe(false);
+  });
+
+  test('fill', () => {
+    const x = {
+      year: 2000,
+    };
+
+    expect(ymd.fill(x)).toStrictEqual({
+      year: 2000,
+      month: 1,
+      date: 1,
+    });
+  });
+
+  test('assertion function', () => {
+    type YMD = TypeOf<typeof ymd>;
+
+    const assertIsYmd: (a: unknown) => asserts a is YMD = ymd.assertIs;
+
+    const x = {
+      year: 2000,
+    };
+
+    const f = (): void => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      x.month;
+
+      assertIsYmd(x); // throws an error
+
+      expectType<typeof x.month, number>('='); // no type error
+    };
+
+    expect(f).toThrow('The record is expected to have the key "month".');
+  });
+
+  test('validation function', () => {
+    const x = {
+      year: 2000,
+    };
+
+    const result = ymd.validate(x);
+
+    expect(Result.isErr(result)).toBe(true);
+
+    expect(result.value).toStrictEqual([
+      'The record is expected to have the key "month".',
+    ]);
+  });
+});
+
+describe('ymd2', () => {
+  const ymd2 = record({
+    year: int(asInt(1900)),
+    month: uintRange({
+      defaultValue: 1,
+      start: 1,
+      end: 13,
+    }),
+    date: uintRange({
+      defaultValue: 1,
+      start: 1,
+      end: 32,
+    }),
+  });
+
+  type YMD2 = TypeOf<typeof ymd2>;
+
+  expectType<YMD2['month'], 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>(
+    '=',
+  );
+
+  test('is', () => {
+    const x = {
+      year: 2000,
+    };
+
+    expect(ymd2.is(x)).toBe(false);
+  });
+});

package/src/compose/index.mts

@@ -0,0 +1,3 @@
+export * from './intersection.mjs';
+export * from './merge-records.mjs';
+export * from './union.mjs';

package/src/compose/intersection.mts

@@ -0,0 +1,206 @@
+import { expectType, Result } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+export const intersection = <const Types extends NonEmptyArray<Type<unknown>>>(
+  types: Types,
+  defaultType: IntersectionType<Types>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
+): IntersectionType<Types> => {
+  type T = IntersectionTypeValue<Types>;
+
+  const typeNameFilled: string =
+    options?.typeName ??
+    `Intersection<${types.map((a) => a.typeName).join(', ')}>`;
+
+  const validate: Type<T>['validate'] = (a) => {
+    for (const type of types) {
+      const r = type.validate(a);
+
+      if (Result.isErr(r))
+        return Result.err([
+          validationErrorMessage(
+            a,
+            `The type of value is expected to match all types of { ${types
+              .map((t) => t.typeName)
+              .join(', ')} }`,
+          ),
+          ...r.value,
+        ]);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Result.ok(a as T);
+  };
+
+  const is = createIsFn<T>(validate);
+
+  const fill: Type<T>['fill'] = (a) => (is(a) ? a : defaultType.fill(a));
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue: defaultType.defaultValue,
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type IntersectionType<Types extends NonEmptyArray<Type<unknown>>> = Type<
+  IntersectionTypeValue<Types>
+>;
+
+type IntersectionTypeValue<Types extends NonEmptyArray<Type<unknown>>> =
+  TsFortressInternal.IntersectionTypeValueImpl<Types>;
+
+namespace TsFortressInternal {
+  export type IntersectionTypeValueImpl<
+    Types extends NonEmptyArray<Type<unknown>>,
+  > = Intersection<Cast0<UnwrapTypeList<Types>>>;
+
+  type Cast0<T> = [T] extends [NonEmptyArray<unknown>] ? T : never;
+}
+
+expectType<
+  IntersectionType<
+    [
+      Type<{
+        a: 0;
+        b: 0;
+      }>,
+      Type<{
+        b: 0;
+        c: 0;
+      }>,
+    ]
+  >,
+  Type<{
+    a: 0;
+    b: 0;
+    c: 0;
+  }>
+>('=');
+
+type UnwrapTypeList<Types extends readonly Type<unknown>[]> =
+  TsFortressInternal.UnwrapTypeImpl<Types>;
+
+namespace TsFortressInternal {
+  export type UnwrapTypeImpl<Types extends readonly unknown[]> =
+    Types extends readonly []
+      ? []
+      : Types extends readonly [infer Head, ...infer Tail]
+        ? readonly [TypeOf<Cast1<Head>>, ...UnwrapTypeImpl<Tail>]
+        : never;
+
+  type Cast1<T> = [T] extends [Type<unknown>] ? T : never;
+}
+
+expectType<
+  TypeOf<
+    Type<{
+      a: 0;
+      b: 0;
+    }>
+  >,
+  {
+    a: 0;
+    b: 0;
+  }
+>('=');
+
+expectType<
+  UnwrapTypeList<
+    [
+      Type<{
+        a: 0;
+        b: 0;
+      }>,
+      Type<{
+        b: 0;
+        c: 0;
+      }>,
+    ]
+  >,
+  readonly [
+    {
+      a: 0;
+      b: 0;
+    },
+    {
+      b: 0;
+      c: 0;
+    },
+  ]
+>('=');
+
+expectType<
+  Intersection<
+    [
+      {
+        a: 0;
+        b: 0;
+      },
+      {
+        b: 0;
+        c: 0;
+      },
+    ]
+  >,
+  {
+    a: 0;
+    b: 0;
+    c: 0;
+  }
+>('=');
+
+expectType<
+  Intersection<
+    [
+      {
+        a: 0;
+        b: 0;
+      },
+      {
+        b: 0;
+        c: 0;
+      },
+      {
+        c: 0;
+        d: 0;
+      },
+    ]
+  >,
+  {
+    a: 0;
+    b: 0;
+    c: 0;
+    d: 0;
+  }
+>('=');
+
+expectType<
+  Intersection<
+    [
+      {
+        a: 0;
+        b: 0;
+      },
+      {
+        b: 1;
+        c: 0;
+      },
+    ]
+  >,
+  never
+>('=');

package/src/compose/intersection.test.mts

@@ -0,0 +1,231 @@
+import { expectType } from 'ts-data-forge';
+import { uintRange } from '../enum/index.mjs';
+import { number } from '../primitives/index.mjs';
+import { record } from '../record/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import { intersection } from './intersection.mjs';
+
+describe('intersection', () => {
+  describe('merge records', () => {
+    const targetType = intersection(
+      [
+        record({ x: number(), y: number() }),
+        record({ z: number(), w: number() }),
+      ],
+      record({
+        x: number(),
+        y: number(),
+        z: number(),
+        w: number(),
+      }),
+    );
+
+    type TargetType = TypeOf<typeof targetType>;
+
+    expectType<
+      TargetType,
+      Readonly<{
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+      }>
+    >('=');
+
+    expectType<typeof targetType.defaultValue, TargetType>('=');
+
+    describe('is', () => {
+      test('truthy case', () => {
+        const x: unknown = { x: 0, y: 1, z: 2, w: 3 };
+
+        if (targetType.is(x)) {
+          expectType<typeof x, TargetType>('=');
+        } else {
+          expectType<typeof x, unknown>('=');
+        }
+
+        expect(targetType.is(x)).toBe(true);
+      });
+
+      test('truthy case 2', () => {
+        const x: unknown = { x: 0, y: 1, z: 2, w: 3, a: 0, b: 0 };
+
+        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: 0, y: 1 };
+
+        if (targetType.is(x)) {
+          expectType<typeof x, TargetType>('=');
+        } else {
+          expectType<typeof x, unknown>('=');
+        }
+
+        expect(targetType.is(x)).toBe(false);
+      });
+    });
+
+    describe('validate', () => {
+      test('falsy case', () => {
+        expect(targetType.validate({ x: 0, y: 1 }).value).toStrictEqual([
+          'The type of value is expected to match all types of { { x: number, y: number }, { z: number, w: number } }, but it is actually \'{"x":0,"y":1}\'.',
+          'The record is expected to have the key "z".',
+        ]);
+      });
+    });
+
+    describe('fill', () => {
+      test('noop', () => {
+        const x: unknown = { x: 0, y: 1, z: 2, w: 3 };
+
+        expect(targetType.fill(x)).toStrictEqual({ x: 0, y: 1, z: 2, w: 3 });
+      });
+
+      test('fill with the default value', () => {
+        const x = { x: 0, y: 1, z: 2 };
+
+        expect(targetType.fill(x)).toStrictEqual({ x: 0, y: 1, z: 2, w: 0 });
+      });
+    });
+  });
+
+  describe('merge primitives', () => {
+    const targetType = intersection([number(1), number(2)], number());
+
+    type TargetType = TypeOf<typeof targetType>;
+
+    expectType<TargetType, number>('=');
+
+    expectType<typeof targetType.defaultValue, TargetType>('=');
+
+    describe('is', () => {
+      test('truthy case', () => {
+        const x: unknown = 0;
+
+        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 = '3';
+
+        if (targetType.is(x)) {
+          expectType<typeof x, TargetType>('=');
+        } else {
+          expectType<typeof x, unknown>('=');
+        }
+
+        expect(targetType.is(x)).toBe(false);
+      });
+    });
+
+    describe('validate', () => {
+      test('falsy case', () => {
+        expect(targetType.validate('aaa').value).toStrictEqual([
+          'The type of value is expected to match all types of { number, number }, but it is actually \'"aaa"\'.',
+          'The value is expected to be <number>, but it is actually \'"aaa"\'.',
+        ]);
+      });
+    });
+
+    describe('fill', () => {
+      test('noop', () => {
+        const x: unknown = 3;
+
+        expect(targetType.fill(x)).toBe(3);
+      });
+
+      test('fill with the default value', () => {
+        const x = { x: 0, y: 1, z: 2 };
+
+        expect(targetType.fill(x)).toBe(0);
+      });
+    });
+  });
+
+  describe('merge unions', () => {
+    const targetType = intersection(
+      [uintRange({ start: 0, end: 5 }), uintRange({ start: 1, end: 7 })],
+      uintRange({ start: 1, end: 4 }),
+    );
+
+    type TargetType = TypeOf<typeof targetType>;
+
+    expectType<TargetType, 1 | 2 | 3 | 4>('=');
+
+    expectType<typeof targetType.defaultValue, TargetType>('=');
+
+    describe('is', () => {
+      test('truthy case', () => {
+        const x: unknown = 3;
+
+        if (targetType.is(x)) {
+          expectType<typeof x, TargetType>('=');
+        } else {
+          expectType<typeof x, unknown>('=');
+        }
+
+        expect(targetType.is(x)).toBe(true);
+      });
+
+      test('falsy case 1', () => {
+        const x: unknown = '3';
+
+        if (targetType.is(x)) {
+          expectType<typeof x, TargetType>('=');
+        } else {
+          expectType<typeof x, unknown>('=');
+        }
+
+        expect(targetType.is(x)).toBe(false);
+      });
+
+      test('falsy case 2', () => {
+        const x: unknown = 7;
+
+        if (targetType.is(x)) {
+          expectType<typeof x, TargetType>('=');
+        } else {
+          expectType<typeof x, unknown>('=');
+        }
+
+        expect(targetType.is(x)).toBe(false);
+      });
+    });
+
+    describe('validate', () => {
+      test('falsy case', () => {
+        expect(targetType.validate(7).value).toStrictEqual([
+          "The type of value is expected to match all types of { uintRange(0, 5), uintRange(1, 7) }, but it is actually '7'.",
+          "The value is expected to be an integer between 0 and 4, but it is actually '7'.",
+        ]);
+      });
+    });
+
+    describe('fill', () => {
+      test('noop', () => {
+        const x: unknown = 3;
+
+        expect(targetType.fill(x)).toBe(3);
+      });
+
+      test('fill with the default value', () => {
+        const x = 9;
+
+        expect(targetType.fill(x)).toBe(1);
+      });
+    });
+  });
+});