ts-fortress 1.0.0

package/src/compose/merge-records.mts

@@ -0,0 +1,218 @@
+import { expectType, isRecord, Result } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+export const mergeRecords = <
+  const Types extends NonEmptyArray<Type<UnknownRecord>>,
+>(
+  types: Types,
+  options?: Partial<
+    Readonly<{
+      defaultType: IntersectionType<Types>;
+      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
+      : (options?.defaultType?.fill(a) ??
+        mergeRecordValues(
+          isRecord(a)
+            ? [...types.map((t) => t.fill(a)), a]
+            : types.map((t) => t.fill(a)),
+        ));
+
+  const defaultValue: Type<T>['defaultValue'] =
+    options?.defaultType?.defaultValue ??
+    mergeRecordValues(types.map((t) => t.defaultValue));
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type IntersectionType<Types extends NonEmptyArray<Type<UnknownRecord>>> = Type<
+  IntersectionTypeValue<Types>
+>;
+
+type IntersectionTypeValue<Types extends NonEmptyArray<Type<UnknownRecord>>> =
+  Intersection<TsFortressInternal.UnwrapTypeList<Types>>;
+
+namespace TsFortressInternal {
+  export type UnwrapTypeList<Types extends readonly Type<UnknownRecord>[]> =
+    UnwrapTypeImpl<Types>;
+
+  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<UnknownRecord>] ? T : never;
+}
+
+expectType<
+  IntersectionType<
+    [
+      Type<{
+        a: 0;
+        b: 0;
+      }>,
+      Type<{
+        b: 0;
+        c: 0;
+      }>,
+    ]
+  >,
+  Type<{
+    a: 0;
+    b: 0;
+    c: 0;
+  }>
+>('=');
+
+expectType<
+  TypeOf<
+    Type<{
+      a: 0;
+      b: 0;
+    }>
+  >,
+  {
+    a: 0;
+    b: 0;
+  }
+>('=');
+
+expectType<
+  TsFortressInternal.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
+>('=');
+
+const mergeRecordValues = <Rs extends readonly UnknownRecord[]>(
+  recs: Rs,
+): Intersection<Rs> =>
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  recs.reduce((acc, curr) => ({ ...acc, ...curr }), {}) as Intersection<Rs>;

package/src/compose/merge-records.test.mts

@@ -0,0 +1,90 @@
+import { expectType } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { record } from '../record/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import { mergeRecords } from './merge-records.mjs';
+
+describe('mergeRecords', () => {
+  // @ts-expect-error should pass record type
+  mergeRecords([record({ x: number(), y: number() }), number()]);
+
+  const targetType = mergeRecords([
+    record({ x: number(), y: number() }),
+    record({ 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 });
+    });
+  });
+});

package/src/compose/union.mts

@@ -0,0 +1,77 @@
+import { Result, expectType } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+export const union = <const Types extends NonEmptyArray<Type<unknown>>>(
+  types: Types,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+      defaultType: UnionType<Types>;
+    }>
+  >,
+): UnionType<Types> => {
+  type T = UnionTypeValue<Types>;
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const defaultType = options?.defaultType ?? (types[0] as UnionType<Types>);
+
+  const typeNameFilled: string =
+    options?.typeName ?? `Union<${types.map((a) => a.typeName).join(', ')}>`;
+
+  const validate: Type<T>['validate'] = (a) =>
+    types.some((t) => t.is(a))
+      ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        Result.ok(a as T)
+      : Result.err([
+          validationErrorMessage(
+            a,
+            `The type of value is expected to be one of the elements contained in { ${types
+              .map((t) => t.typeName)
+              .join(', ')} }`,
+          ),
+        ]);
+
+  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 UnionType<Types extends NonEmptyArray<Type<unknown>>> = Type<
+  UnionTypeValue<Types>
+>;
+
+type UnionTypeValue<Types extends NonEmptyArray<Type<unknown>>> =
+  TsFortressInternal.UnionTypeValueImpl<Types>;
+
+namespace TsFortressInternal {
+  export type UnionTypeValueImpl<Types extends NonEmptyArray<Type<unknown>>> =
+    UnwrapUnion<ArrayElement<Types>>;
+
+  type UnwrapUnion<T extends Type<unknown>> = T extends T ? TypeOf<T> : never;
+}
+
+expectType<
+  UnionType<[Type<{ a: 0; b: 0 }>, Type<{ b: 0; c: 0 }>]>,
+  Type<{ a: 0; b: 0 } | { b: 0; c: 0 }>
+>('=');
+
+expectType<
+  UnionType<[Type<{ a: 0; b: 0 }>, Type<{ b: 0; c: 0 }>, Type<{ e: 0; f: 0 }>]>,
+  Type<{ a: 0; b: 0 } | { b: 0; c: 0 } | { e: 0; f: 0 }>
+>('=');

package/src/compose/union.test.mts

@@ -0,0 +1,92 @@
+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 { union } from './union.mjs';
+
+describe('union', () => {
+  const targetType = union(
+    [
+      record({ x: number(0), y: number(0) }),
+      numberLiteral(3),
+      stringLiteral('2'),
+    ],
+    {
+      defaultType: numberLiteral(3),
+    },
+  );
+
+  type TargetType = TypeOf<typeof targetType>;
+
+  expectType<
+    TargetType,
+    | Readonly<{
+        x: number;
+        y: number;
+      }>
+    | '2'
+    | 3
+  >('=');
+
+  expectType<typeof targetType.defaultValue, TargetType>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: unknown = Math.random() >= 0 ? 3 : '0'; // the value is always 1
+
+      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: 1, y: 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 = Math.random() >= 0 ? 5 : '0'; // the value is always 5
+
+      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(5).value).toStrictEqual([
+        "The type of value is expected to be one of the elements contained in { { x: number, y: number }, numberLiteral(3), stringLiteral(2) }, but it is actually '5'.",
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('noop', () => {
+      const x: unknown = { x: 3, y: 4 };
+
+      expect(targetType.fill(x)).toStrictEqual({ x: 3, y: 4 });
+    });
+
+    test('fill with the default value', () => {
+      const x = 5;
+
+      expect(targetType.fill(x)).toBe(3);
+    });
+  });
+});

package/src/enum/enum.mts

@@ -0,0 +1,53 @@
+import { ISet, Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+export const enumType = <const Values extends NonEmptyArray<Primitive>>(
+  values: Values,
+  options?: Readonly<{
+    typeName?: string;
+    defaultValue?: ArrayElement<Values>;
+  }>,
+): Type<ArrayElement<Values>> => {
+  type T = ArrayElement<Values>;
+
+  const valueSet = ISet.create(values);
+
+  const defaultValueFilled =
+    options?.defaultValue ??
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    (values[0] as ArrayElement<Values>);
+
+  const validate: Type<T>['validate'] = (a) =>
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    valueSet.has(a as Primitive)
+      ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        Result.ok(a as T)
+      : Result.err([
+          validationErrorMessage(
+            a,
+            `The value is expected to be one of the elements contained in { ${values.join(
+              ', ',
+            )} }`,
+          ),
+        ]);
+
+  const is = createIsFn<T>(validate);
+
+  const fill: Type<T>['fill'] = (a) => (is(a) ? a : defaultValueFilled);
+
+  return {
+    typeName: options?.typeName ?? 'enum',
+    defaultValue: defaultValueFilled,
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/enum/enum.test.mts

@@ -0,0 +1,63 @@
+import { expectType } from 'ts-data-forge';
+import { type TypeOf } from '../type.mjs';
+import { enumType } from './enum.mjs';
+
+describe('enumType', () => {
+  const targetType = enumType([3, '2', 'a'], {
+    defaultValue: 3,
+  });
+
+  type TargetType = TypeOf<typeof targetType>;
+
+  expectType<TargetType, '2' | 'a' | 3>('=');
+
+  expectType<typeof targetType.defaultValue, TargetType>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: number | string = Math.random() >= 0 ? 3 : '0'; // the value is always 1
+
+      if (targetType.is(x)) {
+        expectType<typeof x, TargetType>('=');
+      } else {
+        expectType<typeof x, number | string>('=');
+      }
+
+      expect(targetType.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: number | string = Math.random() >= 0 ? 5 : '0'; // the value is always 5
+
+      if (targetType.is(x)) {
+        expectType<typeof x, TargetType>('=');
+      } else {
+        expectType<typeof x, number | string>('=');
+      }
+
+      expect(targetType.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      expect(targetType.validate(5).value).toStrictEqual([
+        "The value is expected to be one of the elements contained in { 3, 2, a }, but it is actually '5'.",
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('noop', () => {
+      const x: number = (() => 3)();
+
+      expect(targetType.fill(x)).toBe(3);
+    });
+
+    test('fill with the default value', () => {
+      const x: number = (() => 5)();
+
+      expect(targetType.fill(x)).toBe(3);
+    });
+  });
+});

package/src/enum/index.mts

@@ -0,0 +1,2 @@
+export * from './enum.mjs';
+export * from './uint-range.mjs';

package/src/enum/uint-range.mts

@@ -0,0 +1,63 @@
+import { isNumber, Json, Num, Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
+
+export const uintRange = <
+  Start extends Uint8,
+  End extends Exclude<Uint8, Start>,
+>({
+  start,
+  end,
+  ...options
+}: Readonly<{
+  typeName?: string;
+  start: Start;
+  end: End;
+  defaultValue?: UintRange<Start, End>;
+}>): Type<UintRange<Start, End>> => {
+  type T = UintRange<Start, End>;
+
+  const typeNameFilled = options.typeName ?? `uintRange(${start}, ${end})`;
+
+  const defaultValue: T =
+    options.defaultValue ??
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    (start as T);
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!(isNumber(a) && Number.isInteger(a) && Num.isInRange(start, end)(a))) {
+      const stringifyResult = Json.stringify(a);
+
+      const prefix = `The value is expected to be an integer between ${start} and ${
+        end - 1
+      }`;
+
+      if (Result.isErr(stringifyResult)) {
+        return Result.err([
+          `${prefix}, but it isn't (stringification failed).`,
+        ]);
+      }
+
+      const str = stringifyResult.value;
+
+      return Result.err([`${prefix}, but it is actually '${str}'.`]);
+    }
+
+    // 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 : defaultValue);
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};