ts-fortress 1.0.0

package/src/record/optional.mts

@@ -0,0 +1,16 @@
+import { type Type } from '../type.mjs';
+
+export type OptionalPropertyType<T extends Type<unknown>> = T &
+  PartiallyRequired<T, 'optional'>;
+
+export const optional = <T extends Type<unknown>>(
+  t: T,
+): OptionalPropertyType<T> => ({
+  ...t,
+  optional: true,
+});
+
+export const isOptionalProperty = <T extends Type<unknown>>(
+  t: T,
+): t is OptionalPropertyType<T> =>
+  Object.hasOwn(t, 'optional') && t.optional === true;

package/src/record/partial.mts

@@ -0,0 +1,186 @@
+import { expectType, ISet, 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 Partial type. If keysToBeOptional is set, only those keys are
+ * optional, otherwise, all properties are optional.
+ */
+export const partial = <
+  const R extends Type<UnknownRecord>,
+  const KeysToBeOptional extends NonEmptyArray<keyof TypeOf<R> & string>,
+>(
+  recordType: R,
+  options?: Partial<
+    Readonly<{
+      keysToBeOptional: KeysToBeOptional;
+      typeName: string;
+    }>
+  >,
+): PartialType<R, KeysToBeOptional> => {
+  type V = PartialTypeValue<R, KeysToBeOptional>;
+
+  const typeNameFilled: string =
+    options?.typeName ??
+    (options?.keysToBeOptional === undefined
+      ? `Partial<${recordType.typeName}>`
+      : `PartiallyPartial<${recordType.typeName}, ${options.keysToBeOptional.join('|')}>`);
+
+  const keysToBeOptional =
+    options?.keysToBeOptional ?? Object.keys(recordType.defaultValue);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const defaultValue: V = Obj.omit(
+    recordType.defaultValue,
+    keysToBeOptional,
+  ) as V;
+
+  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 = {
+      // fill optional properties to skip check by recordType.validate
+      ...Obj.pick(recordType.defaultValue, keysToBeOptional),
+      // overwrite with `a`
+      ...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) => {
+    if (!isRecord(a)) {
+      return defaultValue;
+    }
+
+    const inputKeys = ISet.create(Object.keys(a));
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Obj.omit(
+      // First, create a recursively filled object with all properties required.
+      recordType.fill(a),
+      // Then, Omit optional properties not present in `a`.
+      keysToBeOptional.filter(
+        (k) =>
+          // avoid removing properties from `a`
+          !inputKeys.has(k),
+      ),
+    ) as unknown as V;
+  };
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type PartialTypeValue<
+  R extends Type<UnknownRecord>,
+  KeysToBeOptional extends NonEmptyArray<keyof TypeOf<R> & string> | undefined,
+> =
+  TypeEq<KeysToBeOptional, undefined> extends true
+    ? Partial<TypeOf<R>>
+    : PartiallyPartial<TypeOf<R>, ArrayElement<KeysToBeOptional>>;
+
+type PartialType<
+  R extends Type<UnknownRecord>,
+  KeysToBeOptional extends NonEmptyArray<keyof TypeOf<R> & string> | undefined,
+> = Type<PartialTypeValue<R, KeysToBeOptional>>;
+
+// expectType<TsFortressInternal.SetOptional<Type<0>>, OptionalType<0>>('=');
+
+// expectType<
+//   TsFortressInternal.SetOptionalForAllKey<{
+//     a: Type<0>;
+//   }>,
+//   Readonly<{
+//     a: OptionalType<0>;
+//   }>
+// >('=');
+
+// expectType<
+//   TsFortressInternal.SetOptionalForAllKey<{
+//     a: Type<0>;
+//     b: OptionalType<0>;
+//   }>,
+//   Readonly<{
+//     a: OptionalType<0>;
+//     b: OptionalType<0>;
+//   }>
+// >('=');
+
+// expectType<
+//   TsFortressInternal.SetOptionalForAllKey<
+//     RecordType<{
+//       a: OptionalType<0>;
+//       b: OptionalType<0>;
+//       c: Type<0>;
+//     }>['source']
+//   >,
+//   Readonly<{
+//     a: OptionalType<0>;
+//     b: OptionalType<0>;
+//     c: OptionalType<0>;
+//   }>
+// >('=');
+
+// expectType<
+//   PartialType<
+//     RecordType<{
+//       a: OptionalType<0>;
+//       b: OptionalType<0>;
+//       c: Type<0>;
+//     }>,
+//     undefined
+//   >,
+//   RecordType<
+//     Readonly<{
+//       a: OptionalType<0>;
+//       b: OptionalType<0>;
+//       c: OptionalType<0>;
+//     }>
+//   >
+// >('=');
+
+// expectType<
+//   PartialType<
+//     Type<{
+//       a: OptionalType<0>;
+//       b: Type<0>;
+//       c: Type<0>;
+//     }>,
+//     ['b']
+//   >,
+//   RecordType<
+//     Readonly<{
+//       a: OptionalType<0>;
+//       b: OptionalType<0>;
+//       c: Type<0>;
+//     }>
+//   >
+// >('=');
+
+expectType<
+  PartialType<
+    Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>,
+    // @ts-expect-error key "d" doesn't exist
+    ['a', 'd']
+  >,
+  0
+>('!=');

package/src/record/partial.test.mts

@@ -0,0 +1,261 @@
+import { expectType } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { optional } from './optional.mjs';
+import { partial } from './partial.mjs';
+import { record } from './record.mjs';
+
+describe('partial', () => {
+  describe('fully partial', () => {
+    const ymdBase = record({
+      year: number(1900),
+      month: optional(number(1)),
+      date: optional(number(1)),
+    });
+
+    const ymd = partial(ymdBase);
+
+    expectType<
+      typeof ymd,
+      Type<Partial<Readonly<{ year: number; month: number; date: number }>>>
+    >('=');
+
+    type Ymd = TypeOf<typeof ymd>;
+
+    expectType<
+      Ymd,
+      Partial<Readonly<{ year: number; month: number; date: number }>>
+    >('=');
+
+    expectType<typeof ymd.defaultValue, Ymd>('=');
+
+    describe('is', () => {
+      test('truthy case', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 12,
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(true);
+      });
+
+      test('falsy case', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 'cd',
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(false);
+      });
+    });
+
+    describe('validate', () => {
+      test('falsy case 1', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 'cd',
+        };
+
+        expect(ymd.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"'.`,
+        ]);
+      });
+
+      test('falsy case 2', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+        };
+
+        expect(ymd.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(ymd.fill(x)).toStrictEqual({});
+      });
+
+      test('from a filled record', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 999,
+          date: 999,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+          month: 999,
+          date: 999,
+        });
+      });
+
+      test('from a partial record', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+        });
+      });
+
+      test('from a partial record with excess property', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          aaaaa: 9999,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+        });
+      });
+    });
+  });
+
+  describe('partially partial', () => {
+    const ymdBase = record({
+      year: number(1900),
+      month: number(1),
+      date: number(1),
+    });
+
+    const ymd = partial(ymdBase, { keysToBeOptional: ['month', 'date'] });
+
+    type Ymd = TypeOf<typeof ymd>;
+
+    expectType<Ymd, Readonly<{ year: number; month?: number; date?: number }>>(
+      '=',
+    );
+
+    expectType<typeof ymd.defaultValue, Ymd>('=');
+
+    describe('is', () => {
+      test('truthy case', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(true);
+      });
+
+      test('falsy case 1', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 'cd',
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(false);
+      });
+
+      test('falsy case 2', () => {
+        const x: UnknownRecord = {
+          date: 'cd',
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(false);
+      });
+    });
+
+    describe('validate', () => {
+      test('falsy case', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 'cd',
+        };
+
+        expect(ymd.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(ymd.fill(x)).toStrictEqual({
+          year: 1900,
+        });
+      });
+
+      test('from a filled record', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 999,
+          date: 999,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+          month: 999,
+          date: 999,
+        });
+      });
+
+      test('from a partial record', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+        });
+      });
+
+      test('from a partial record with excess property', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          aaaaa: 9999,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+        });
+      });
+    });
+  });
+});

package/src/record/pick.mts

@@ -0,0 +1,98 @@
+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 picked. */
+export const pick = <
+  const R extends Type<UnknownRecord>,
+  const KeysToPick extends readonly (keyof TypeOf<R> & string)[],
+>(
+  recordType: R,
+  keysToPick: KeysToPick,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
+): PickedType<R, KeysToPick> => {
+  type V = Pick<TypeOf<R>, ArrayElement<KeysToPick>>;
+
+  const typeNameFilled: string =
+    options?.typeName ??
+    `Pick<${recordType.typeName}, ${keysToPick.join('|')}>`;
+
+  const defaultValue: V = Obj.pick(recordType.defaultValue, keysToPick) as V;
+
+  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.omit(recordType.fill(a), keysToPick),
+      ...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.pick(recordType.fill(a), keysToPick) as V;
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type PickedType<
+  R extends Type<UnknownRecord>,
+  KeysToPick extends readonly (keyof TypeOf<R>)[],
+> = Type<Pick<TypeOf<R>, ArrayElement<KeysToPick>>>;
+
+expectType<
+  Pick<TypeOf<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>, 'a' | 'b'>,
+  {
+    a: Type<0>;
+    b: Type<0>;
+  }
+>('=');
+
+expectType<
+  Type<Pick<TypeOf<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>, 'a' | 'b'>>,
+  Type<{
+    a: Type<0>;
+    b: Type<0>;
+  }>
+>('=');
+
+expectType<
+  PickedType<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>, ['a', 'b']>,
+  Type<{
+    a: Type<0>;
+    b: Type<0>;
+  }>
+>('=');
+
+expectType<
+  PickedType<
+    Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>,
+    // @ts-expect-error key "d" doesn't exist
+    ['a', 'd']
+  >,
+  0
+>('!=');

package/src/record/pick.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 { pick } from './pick.mjs';
+import { record } from './record.mjs';
+
+describe('pick', () => {
+  const ym = pick(
+    record({
+      year: number(1900),
+      month: number(1),
+      date: number(1),
+    }),
+    ['year', 'month'],
+  );
+
+  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,
+      });
+    });
+  });
+});