ts-fortress 1.0.0

package/src/enum/uint-range.test.mts

@@ -0,0 +1,66 @@
+import { expectType } from 'ts-data-forge';
+import { type TypeOf } from '../type.mjs';
+import { uintRange } from './uint-range.mjs';
+
+describe('uintRange', () => {
+  const month = uintRange({
+    start: 1,
+    end: 13,
+    defaultValue: 1,
+    typeName: 'month',
+  });
+
+  type Month = TypeOf<typeof month>;
+
+  expectType<Month, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>('=');
+
+  expectType<typeof month.defaultValue, Month>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: number = Math.random() >= 0 ? 1 : 0; // the value is always 1
+
+      if (month.is(x)) {
+        expectType<typeof x, Month>('=');
+      } else {
+        expectType<typeof x, number>('=');
+      }
+
+      expect(month.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: number = Math.random() >= 0 ? 13 : 0; // the value is always 13
+
+      if (month.is(x)) {
+        expectType<typeof x, Month>('=');
+      } else {
+        expectType<typeof x, number>('=');
+      }
+
+      expect(month.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      expect(month.validate(13).value).toStrictEqual([
+        "The value is expected to be an integer between 1 and 12, but it is actually '13'.",
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('noop', () => {
+      const x: number = (() => 5)();
+
+      expect(month.fill(x)).toBe(5);
+    });
+
+    test('fill with the default value', () => {
+      const x: number = (() => 123)();
+
+      expect(month.fill(x)).toBe(1);
+    });
+  });
+});

package/src/globals.d.mts

@@ -0,0 +1,3 @@
+/* eslint-disable import/unambiguous */
+
+/// <reference types="ts-type-forge" />

package/src/index.mts

@@ -0,0 +1,9 @@
+export * from './array/index.mjs';
+export * from './branded/index.mjs';
+export * from './compose/index.mjs';
+export * from './enum/index.mjs';
+export * from './primitives/index.mjs';
+export * from './record/index.mjs';
+export * from './type.mjs';
+export * from './unknown.mjs';
+export * from './utils/index.mjs';

package/src/primitives/bigint.mts

@@ -0,0 +1,13 @@
+import { isBigint } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const bigint = (defaultValue: bigint = 0n): Type<bigint> =>
+  createPrimitiveType({ typeName: 'bigint', defaultValue, is: isBigint });
+
+export const bigintLiteral = <L extends bigint>(literal: L): Type<L> =>
+  createPrimitiveType({
+    typeName: `bigintLiteral(${literal})`,
+    defaultValue: literal,
+    is: (value: unknown): value is L => value === literal,
+  });

package/src/primitives/boolean.mts

@@ -0,0 +1,13 @@
+import { isBoolean } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const boolean = (defaultValue: boolean = false): Type<boolean> =>
+  createPrimitiveType({ typeName: 'boolean', defaultValue, is: isBoolean });
+
+export const booleanLiteral = <L extends boolean>(literal: L): Type<L> =>
+  createPrimitiveType({
+    typeName: `booleanLiteral(${String(literal)})`,
+    defaultValue: literal,
+    is: (value: unknown): value is L => value === literal,
+  });

package/src/primitives/index.mts

@@ -0,0 +1,7 @@
+export * from './bigint.mjs';
+export * from './boolean.mjs';
+export * from './null.mjs';
+export * from './number.mjs';
+export * from './string.mjs';
+export * from './symbol.mjs';
+export * from './undefined.mjs';

package/src/primitives/null.mts

@@ -0,0 +1,9 @@
+import { isNull } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const nullType: Type<null> = createPrimitiveType({
+  typeName: 'null',
+  defaultValue: null,
+  is: isNull,
+});

package/src/primitives/number.mts

@@ -0,0 +1,13 @@
+import { isNumber } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const number = (defaultValue: number = 0): Type<number> =>
+  createPrimitiveType({ typeName: 'number', defaultValue, is: isNumber });
+
+export const numberLiteral = <L extends number>(literal: L): Type<L> =>
+  createPrimitiveType({
+    typeName: `numberLiteral(${literal})`,
+    defaultValue: literal,
+    is: (value: unknown): value is L => value === literal,
+  });

package/src/primitives/string.mts

@@ -0,0 +1,13 @@
+import { isString } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const string = (defaultValue: string = ''): Type<string> =>
+  createPrimitiveType({ typeName: 'string', defaultValue, is: isString });
+
+export const stringLiteral = <L extends string>(literal: L): Type<L> =>
+  createPrimitiveType({
+    typeName: `stringLiteral(${literal})`,
+    defaultValue: literal,
+    is: (value: unknown): value is L => value === literal,
+  });

package/src/primitives/symbol.mts

@@ -0,0 +1,10 @@
+import { isSymbol } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const symbol = (defaultValue: symbol): Type<symbol> =>
+  createPrimitiveType({
+    typeName: 'symbol',
+    defaultValue,
+    is: isSymbol,
+  });

package/src/primitives/undefined.mts

@@ -0,0 +1,9 @@
+import { isUndefined } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createPrimitiveType } from '../utils/index.mjs';
+
+export const undefinedType: Type<undefined> = createPrimitiveType({
+  typeName: 'undefined',
+  defaultValue: undefined,
+  is: isUndefined,
+});

package/src/record/index.mts

@@ -0,0 +1,7 @@
+export * from './key-value-record.mjs';
+export * from './keyof.mjs';
+export * from './omit.mjs';
+export * from './optional.mjs';
+export * from './partial.mjs';
+export * from './pick.mjs';
+export * from './record.mjs';

package/src/record/key-value-record.mts

@@ -0,0 +1,84 @@
+import { isRecord, Result } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+type RecordResultType<K extends Type<string>, V extends Type<unknown>> = Record<
+  TypeOf<K>,
+  TypeOf<V>
+>;
+
+export const keyValueRecord = <K extends Type<string>, V extends Type<unknown>>(
+  keyType: K,
+  valueType: V,
+  options?: Readonly<{ typeName?: string }>,
+): Type<RecordResultType<K, V>> => {
+  type T = RecordResultType<K, V>;
+
+  const typeName = options?.typeName ?? 'key-value-record';
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/consistent-type-assertions
+  const defaultValue = {} as T;
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!isRecord(a)) {
+      return Result.err([
+        validationErrorMessage(a, 'The value is expected to be a record'),
+      ]);
+    }
+
+    for (const [k, v] of Object.entries(a)) {
+      {
+        const res = keyType.validate(k);
+
+        if (Result.isErr(res)) {
+          const message = validationErrorMessage(
+            k,
+            `The key of the record is expected to be <${keyType.typeName}>`,
+          );
+
+          return Result.err([message, ...res.value]);
+        }
+      }
+      {
+        const res = valueType.validate(v);
+
+        if (Result.isErr(res)) {
+          const message = validationErrorMessage(
+            v,
+            `The value of the record is expected to be <${valueType.typeName}>`,
+          );
+
+          return Result.err([message, ...res.value]);
+        }
+      }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Result.ok(a as T);
+  };
+
+  const fill: Type<T>['fill'] = (a) =>
+    isRecord(a)
+      ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        (Object.fromEntries(
+          Object.entries(a).filter(
+            ([k, v]) => keyType.is(k) && valueType.is(v),
+          ),
+        ) as T)
+      : defaultValue;
+
+  return {
+    typeName,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/record/key-value-record.test.mts

@@ -0,0 +1,96 @@
+import { expectType } from 'ts-data-forge';
+import { number, string } from '../primitives/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import { keyValueRecord } from './key-value-record.mjs';
+
+describe('keyValueRecord', () => {
+  const strNumRecord = keyValueRecord(string(''), number(0));
+
+  type StrNumRecord = TypeOf<typeof strNumRecord>;
+
+  expectType<StrNumRecord, Record<string, number>>('=');
+
+  expectType<typeof strNumRecord.defaultValue, StrNumRecord>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        date: 12,
+      };
+
+      if (strNumRecord.is(x)) {
+        expectType<typeof x, StrNumRecord>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(strNumRecord.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+        date: 'cd',
+      };
+
+      if (strNumRecord.is(x)) {
+        expectType<typeof x, StrNumRecord>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(strNumRecord.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+        date: 'cd',
+      };
+
+      expect(strNumRecord.validate(x).value).toStrictEqual([
+        `The value of the record is expected to be <number>, but it is actually '"ab"'.`,
+        `The value is expected to be <number>, but it is actually '"ab"'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('from an empty record', () => {
+      const x: UnknownRecord = {};
+
+      expect(strNumRecord.fill(x)).toStrictEqual({});
+    });
+
+    test('from a filled record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 999,
+        date: 999,
+      };
+
+      expect(strNumRecord.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 999,
+        date: 999,
+      });
+    });
+
+    test('from a record with wrong value', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: '12',
+      };
+
+      expect(strNumRecord.fill(x)).toStrictEqual({
+        year: 2000,
+      });
+    });
+  });
+});

package/src/record/keyof.mts

@@ -0,0 +1,31 @@
+import { Arr, expectType, pipe } from 'ts-data-forge';
+import { enumType } from '../enum/index.mjs';
+import { undefinedType } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+
+export const keyof = <const R extends Type<UnknownRecord>>(
+  recordType: R,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
+): KeyofType<R> =>
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  pipe(Object.keys(recordType.defaultValue)).map((keys) =>
+    Arr.isNonEmpty(keys)
+      ? enumType(keys, {
+          typeName: options?.typeName ?? `keyof ${recordType.typeName}`,
+        })
+      : undefinedType,
+  ).value as KeyofType<R>;
+
+type KeyofType<R extends Type<UnknownRecord>> = Type<keyof TypeOf<R>>;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+expectType<KeyofType<Type<{}>>, Type<never>>('=');
+
+expectType<
+  KeyofType<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>,
+  Type<'a' | 'b' | 'c'>
+>('=');

package/src/record/keyof.test.mts

@@ -0,0 +1,73 @@
+import { expectType } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { keyof } from './keyof.mjs';
+import { record } from './record.mjs';
+
+describe('keyof', () => {
+  const ymdKey = keyof(
+    record({
+      year: number(1900),
+      month: number(1),
+      date: number(1),
+    }),
+  );
+
+  expectType<typeof ymdKey, Type<'year' | 'month' | 'date'>>('=');
+
+  type Ymd = TypeOf<typeof ymdKey>;
+
+  expectType<Ymd, 'year' | 'month' | 'date'>('=');
+
+  expectType<typeof ymdKey.defaultValue, Ymd>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: unknown = 'year';
+
+      if (ymdKey.is(x)) {
+        expectType<typeof x, 'year' | 'month' | 'date'>('=');
+      } else {
+        expectType<typeof x, unknown>('=');
+      }
+
+      expect(ymdKey.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: unknown = 'minutes';
+
+      if (ymdKey.is(x)) {
+        expectType<typeof x, 'year' | 'month' | 'date'>('=');
+      } else {
+        expectType<typeof x, unknown>('=');
+      }
+
+      expect(ymdKey.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: unknown = 'minutes';
+
+      expect(ymdKey.validate(x).value).toStrictEqual([
+        `The value is expected to be one of the elements contained in { year, month, date }, but it is actually '"minutes"'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('from external value', () => {
+      const x: unknown = 'minutes';
+
+      expect(ymdKey.fill(x)).toBe('year');
+    });
+
+    test('from key', () => {
+      const x = 'month';
+
+      expect(ymdKey.fill(x)).toBe('month');
+    });
+  });
+});

package/src/record/omit.mts

@@ -0,0 +1,94 @@
+import { expectType, isRecord, Obj, Result } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+/** Creates a record type with keys omitted. */
+export const omit = <
+  const R extends Type<UnknownRecord>,
+  const KeysToOmit extends readonly (keyof TypeOf<R> & string)[],
+>(
+  recordType: R,
+  keysToOmit: KeysToOmit,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
+): OmittedType<R, KeysToOmit> => {
+  type V = Omit<TypeOf<R>, ArrayElement<KeysToOmit>>;
+
+  const typeNameFilled: string =
+    options?.typeName ??
+    `Omit<${recordType.typeName}, ${keysToOmit.join('|')}>`;
+
+  const defaultValue: V = Obj.omit(recordType.defaultValue, keysToOmit);
+
+  const validate: Type<V>['validate'] = (a) => {
+    if (!isRecord(a)) {
+      return Result.err([
+        validationErrorMessage(a, 'The value is expected to be a record'),
+      ]);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const objectFilled = {
+      ...Obj.pick(recordType.fill(a), keysToOmit),
+      ...a,
+    } as TypeOf<R>;
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return recordType.validate(objectFilled) as ReturnType<Type<V>['validate']>;
+  };
+
+  const fill: Type<V>['fill'] = (a) => Obj.omit(recordType.fill(a), keysToOmit);
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type OmittedType<
+  R extends Type<UnknownRecord>,
+  KeysToOmit extends readonly (keyof TypeOf<R>)[],
+> = Type<Omit<TypeOf<R>, ArrayElement<KeysToOmit>>>;
+
+expectType<
+  Omit<TypeOf<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>, 'a' | 'b'>,
+  {
+    c: Type<0>;
+  }
+>('=');
+
+expectType<
+  Type<Omit<TypeOf<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>, 'a' | 'b'>>,
+  Type<{
+    c: Type<0>;
+  }>
+>('=');
+
+expectType<
+  OmittedType<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>, ['a', 'b']>,
+  Type<{
+    c: Type<0>;
+  }>
+>('=');
+
+expectType<
+  OmittedType<
+    Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>,
+    // @ts-expect-error key "d" doesn't exist
+    ['a', 'd']
+  >,
+  0
+>('!=');

package/src/record/omit.test.mts

@@ -0,0 +1,116 @@
+import { expectType } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { omit } from './omit.mjs';
+import { record } from './record.mjs';
+
+describe('omit', () => {
+  const ym = omit(
+    record({
+      year: number(1900),
+      month: number(1),
+      date: number(1),
+    }),
+    ['date'],
+  );
+
+  expectType<typeof ym, Type<Readonly<{ year: number; month: number }>>>('=');
+
+  type Ym = TypeOf<typeof ym>;
+
+  expectType<Ym, Readonly<{ year: number; month: number }>>('=');
+
+  expectType<typeof ym.defaultValue, Ym>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+      };
+
+      if (ym.is(x)) {
+        expectType<typeof x, Ym>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ym.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+      };
+
+      if (ym.is(x)) {
+        expectType<typeof x, Ym>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ym.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+      };
+
+      expect(ym.validate(x).value).toStrictEqual([
+        `The value at record key "month" is expected to be <number>, but it is actually '"ab"'.`,
+        `The value is expected to be <number>, but it is actually '"ab"'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('from an empty record', () => {
+      const x: UnknownRecord = {};
+
+      expect(ym.fill(x)).toStrictEqual({
+        year: 1900,
+        month: 1,
+      });
+    });
+
+    test('from a filled record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 999,
+      };
+
+      expect(ym.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 999,
+      });
+    });
+
+    test('from a partial record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+      };
+
+      expect(ym.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 1,
+      });
+    });
+
+    test('from a partial record with excess property', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        aaaaa: 9999,
+      };
+
+      expect(ym.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 1,
+      });
+    });
+  });
+});