ts-fortress 3.2.0 → 4.0.0

package/dist/utils/index.d.mts

@@ -3,5 +3,6 @@ export * from './create-cast-fn.mjs';
 export * from './create-is-fn.mjs';
 export * from './create-primitive-type.mjs';
 export * from './create-type.mjs';
+export * from './to-union-string.mjs';
 export * from './validation-error.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/utils/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/utils/index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/utils/index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/dist/utils/index.mjs

@@ -3,5 +3,6 @@ export { createCastFn } from './create-cast-fn.mjs';
 export { createIsFn } from './create-is-fn.mjs';
 export { createPrimitiveType } from './create-primitive-type.mjs';
 export { createType } from './create-type.mjs';
+export { toUnionString } from './to-union-string.mjs';
 export { createPrimitiveValidationError, prependIndexToValidationErrors, prependPathToValidationErrors, validationErrorToMessage, validationErrorsToMessages } from './validation-error.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/utils/to-union-string.d.mts

@@ -0,0 +1,2 @@
+export declare const toUnionString: (members: readonly string[]) => string;
+//# sourceMappingURL=to-union-string.d.mts.map

package/dist/utils/to-union-string.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-union-string.d.mts","sourceRoot":"","sources":["../../src/utils/to-union-string.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,MACjB,CAAC"}

package/dist/utils/to-union-string.mjs

@@ -0,0 +1,4 @@
+const toUnionString = (members) => members.map((k) => `"${k}"`).join(' | ');
+
+export { toUnionString };
+//# sourceMappingURL=to-union-string.mjs.map

package/dist/utils/to-union-string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-union-string.mjs","sources":["../../src/utils/to-union-string.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,aAAa,GAAG,CAAC,OAA0B,KACtD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAA,CAAA,EAAI,CAAC,CAAA,CAAA,CAAG,CAAC,CAAC,IAAI,CAAC,KAAK;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fortress",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/record/keyof.mts

@@ -1,10 +1,10 @@
 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';
+import { type RecordType, type Type } from '../type.mjs';
 
-export const keyof = <const R extends Type<UnknownRecord>>(
-  recordType: R,
+export const keyof = <const R extends ReadonlyRecord<string, Type<unknown>>>(
+  recordType: RecordType<R>,
   options?: Partial<
     Readonly<{
       typeName: string;
@@ -12,25 +12,47 @@ export const keyof = <const R extends Type<UnknownRecord>>(
   >,
 ): KeyofType<R> =>
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-  pipe(Object.keys(recordType.defaultValue)).map((keys) =>
+  pipe(getKeys(recordType)).map((keys) =>
     Arr.isNonEmpty(keys)
-      ? enumType(keys, {
+      ? (enumType(keys, {
           typeName: options?.typeName ?? `keyof ${recordType.typeName}`,
-        })
-      : undefinedType,
+        }) satisfies KeyofTypeSub<R>)
+      : (undefinedType satisfies Type<undefined>),
   ).value as KeyofType<R>;
 
-type KeyofType<R extends Type<UnknownRecord>> = Type<ToString<keyof TypeOf<R>>>;
+const getKeys = <const R extends ReadonlyRecord<string, Type<unknown>>>(
+  recordType: RecordType<R>,
+): readonly ToString<keyof R>[] =>
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  Object.keys(recordType.shape) satisfies string[] as ToString<keyof R>[];
+
+type KeyofTypeSub<R extends ReadonlyRecord<string, Type<unknown>>> = Type<
+  ToString<keyof R>
+>;
+
+type KeyofType<R extends ReadonlyRecord<string, Type<unknown>>> =
+  IsNever<keyof R> extends true ? Type<undefined> : KeyofTypeSub<R>;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+expectType<keyof {}, never>('=');
+expectType<ToString<keyof { 1: 1; 2: 2; 3: 3 }>, '1' | '2' | '3'>('=');
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-expectType<KeyofType<Type<{}>>, Type<never>>('=');
+expectType<KeyofType<{}>, Type<undefined>>('=');
 
 expectType<
-  KeyofType<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>,
+  KeyofType<{ a: Type<0>; b: Type<1>; c: Type<2> }>,
   Type<'a' | 'b' | 'c'>
 >('=');
 
 expectType<
-  KeyofType<Type<{ 1: Type<0>; 2: Type<0>; 3: Type<0> }>>,
-  Type<'1' | '2' | '3'>
+  KeyofType<{ x: Type<string>; y: Type<number>; z: Type<boolean> }>,
+  Type<'x' | 'y' | 'z'>
 >('=');
+
+expectType<
+  KeyofType<{ same: Type<string>; value: Type<string> }>,
+  Type<'same' | 'value'>
+>('=');
+
+expectType<KeyofType<{ never: Type<never> }>, Type<'never'>>('=');

package/src/record/omit.mts

@@ -1,98 +1,65 @@
-import { expectType, isRecord, Obj, Result } from 'ts-data-forge';
-import { type Type, type TypeOf } from '../type.mjs';
-import {
-  createAssertFn,
-  createCastFn,
-  createIsFn,
-  createPrimitiveValidationError,
-} from '../utils/index.mjs';
+import { expectType, Obj } from 'ts-data-forge';
+import { type RecordType, type Type } from '../type.mjs';
+import { toUnionString } from '../utils/index.mjs';
+import { record } from './record.mjs';
 
 /** Creates a record type with keys omitted. */
 export const omit = <
-  const R extends Type<UnknownRecord>,
-  const KeysToOmit extends readonly (keyof TypeOf<R> & string)[],
+  const R extends ReadonlyRecord<string, Type<unknown>>,
+  const KeysToOmit extends readonly (keyof R & string)[],
 >(
-  recordType: R,
+  recordType: RecordType<R>,
   keysToOmit: KeysToOmit,
   options?: Partial<
     Readonly<{
       typeName: string;
+
+      /** @default true */
+      allowExcessProperties: boolean;
     }>
   >,
-): 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([
-        createPrimitiveValidationError({
-          actualValue: a,
-          expectedType: 'record',
-          typeName: typeNameFilled,
-        }),
-      ]);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const objectFilled = {
-      ...Obj.pick(recordType.fill(a), keysToOmit),
-      ...a,
-    } as TypeOf<R>;
-
-    const baseValidationResult = recordType.validate(objectFilled);
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return Result.map(baseValidationResult, () => a as V);
-  };
+): OmittedType<R, KeysToOmit> =>
+  record(Obj.omit(recordType.shape, keysToOmit), {
+    typeName:
+      options?.typeName ??
+      `Omit<${recordType.typeName}, ${toUnionString(keysToOmit)}>`,
+    allowExcessProperties:
+      options?.allowExcessProperties ?? recordType.allowExcessProperties,
+  });
 
-  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>>>;
+export type OmittedType<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  KeysToOmit extends readonly (keyof R)[],
+> = RecordType<Omit<R, ArrayElement<KeysToOmit>>>;
 
 expectType<
-  Omit<TypeOf<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>, 'a' | 'b'>,
+  Omit<{ a: Type<0>; b: Type<1>; c: Type<2> }, 'a' | 'b'>,
   {
-    c: Type<0>;
+    c: Type<2>;
   }
 >('=');
 
 expectType<
-  Type<Omit<TypeOf<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>>, 'a' | 'b'>>,
-  Type<{
-    c: Type<0>;
-  }>
+  RecordType<Omit<{ a: Type<0>; b: Type<1>; c: Type<2> }, 'a' | 'b'>>,
+  Type<Readonly<{ c: 2 }>> &
+    Readonly<{
+      shape: { c: Type<2> };
+      allowExcessProperties: boolean;
+    }>
 >('=');
 
 expectType<
-  OmittedType<Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>, ['a', 'b']>,
-  Type<{
-    c: Type<0>;
-  }>
+  OmittedType<{ a: Type<0>; b: Type<1>; c: Type<2> }, ['a', 'b']>,
+  Type<Readonly<{ c: 2 }>> &
+    Readonly<{
+      shape: { c: Type<2> };
+      allowExcessProperties: boolean;
+    }>
 >('=');
 
 expectType<
   OmittedType<
-    Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>,
+    { a: Type<0>; b: Type<1>; c: Type<2> },
     // @ts-expect-error key "d" doesn't exist
     ['a', 'd']
   >,

package/src/record/omit.test.mts

@@ -14,7 +14,14 @@ describe('omit', () => {
 
   const ym = omit(ymd, ['date']);
 
-  expectType<typeof ym, Type<Readonly<{ year: number; month: number }>>>('=');
+  expectType<
+    typeof ym,
+    Type<Readonly<{ year: number; month: number }>> &
+      Readonly<{
+        shape: Readonly<{ year: Type<number>; month: Type<number> }>;
+        allowExcessProperties: boolean;
+      }>
+  >('=');
 
   type Ym = TypeOf<typeof ym>;
 

package/src/record/partial.mts

@@ -1,190 +1,199 @@
-import { expectType, ISet, isRecord, Obj, Result } from 'ts-data-forge';
-import { type Type, type TypeOf } from '../type.mjs';
-import {
-  createAssertFn,
-  createCastFn,
-  createIsFn,
-  createPrimitiveValidationError,
-} from '../utils/index.mjs';
+import { expectType } from 'ts-data-forge';
+import { type RecordType, type Type } from '../type.mjs';
+import { toUnionString } from '../utils/index.mjs';
+import { optional, type OptionalPropertyType } from './optional.mjs';
+import { record } from './record.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>,
+  const R extends ReadonlyRecord<string, Type<unknown>>,
+  const KeysToBeOptional extends NonEmptyArray<keyof R & string>,
 >(
-  recordType: R,
+  recordType: RecordType<R>,
   options?: Partial<
     Readonly<{
       keysToBeOptional: KeysToBeOptional;
       typeName: string;
+
+      /** @default true */
+      allowExcessProperties: boolean;
     }>
   >,
 ): 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([
-        createPrimitiveValidationError({
-          actualValue: a,
-          expectedType: 'record',
-          typeName: typeNameFilled,
-        }),
-      ]);
-    }
-
-    // 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>;
-
-    const validationResult = recordType.validate(objectFilled);
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return Result.map(validationResult, () => a as V);
-  };
-
-  const fill: Type<V>['fill'] = (a) => {
-    if (!isRecord(a)) {
-      return defaultValue;
-    }
+      : `PartiallyPartial<${recordType.typeName}, ${toUnionString(options.keysToBeOptional)}>`);
 
-    const inputKeys = ISet.create(Object.keys(a));
+  const keysToBeOptional: ReadonlySet<string> = new Set(
+    options?.keysToBeOptional ?? Object.keys(recordType.shape),
+  );
 
+  const partialShape =
     // 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),
+    Object.fromEntries(
+      Object.entries(recordType.shape).map(
+        ([k, v]) => [k, keysToBeOptional.has(k) ? optional(v) : v] as const,
       ),
-    ) as unknown as V;
-  };
+    ) satisfies ReadonlyRecord<string, Type<unknown>> as PartialTypeShape<
+      R,
+      KeysToBeOptional
+    >;
 
-  return {
+  return record(partialShape, {
     typeName: typeNameFilled,
-    defaultValue,
-    fill,
-    validate,
-    is: createIsFn(validate),
-    assertIs: createAssertFn(validate),
-    cast: createCastFn(validate),
-  };
+    allowExcessProperties:
+      options?.allowExcessProperties ?? recordType.allowExcessProperties,
+  });
 };
 
-type PartialTypeValue<
-  R extends Type<UnknownRecord>,
-  KeysToBeOptional extends NonEmptyArray<keyof TypeOf<R> & string> | undefined,
+type PartialTypeShape<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  KeysToBeOptional extends NonEmptyArray<keyof 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>;
-//     }>
-//   >
-// >('=');
+    ? FullyOptionalType<R>
+    : PartiallyOptionalType<R, ArrayElement<KeysToBeOptional>>;
+
+type FullyOptionalType<R extends ReadonlyRecord<string, Type<unknown>>> = {
+  readonly [P in keyof R]: OptionalPropertyType<R[P]>;
+};
+
+type PartiallyOptionalType<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  K extends keyof R,
+> = {
+  readonly [P in keyof R]: P extends K ? OptionalPropertyType<R[P]> : R[P];
+};
+
+export type PartialType<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  KeysToBeOptional extends NonEmptyArray<keyof R & string> | undefined,
+> = RecordType<PartialTypeShape<R, KeysToBeOptional>>;
+
+expectType<
+  PartialTypeShape<{ a: Type<0>; b: Type<1>; c: Type<2> }, ['a']>,
+  Readonly<{
+    a: OptionalPropertyType<Type<0>>;
+    b: Type<1>;
+    c: Type<2>;
+  }>
+>('=');
+
+expectType<
+  RecordType<
+    Readonly<{
+      a: Type<0>;
+      b: Type<1>;
+      c: Type<2>;
+    }>
+  >,
+  Type<
+    Readonly<{
+      a: 0;
+      b: 1;
+      c: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: Type<0>;
+        b: Type<1>;
+        c: Type<2>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('~=');
+
+expectType<
+  RecordType<
+    Readonly<{
+      a: OptionalPropertyType<Type<0>>;
+      b: Type<1>;
+      c: Type<2>;
+    }>
+  >,
+  Type<
+    Readonly<{
+      a?: 0;
+      b: 1;
+      c: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: OptionalPropertyType<Type<0>>;
+        b: Type<1>;
+        c: Type<2>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  PartialType<{ a: Type<0>; b: Type<1>; c: Type<2> }, ['a']>,
+  Type<
+    Readonly<{
+      a?: 0;
+      b: 1;
+      c: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: OptionalPropertyType<Type<0>>;
+        b: Type<1>;
+        c: Type<2>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  PartialType<{ a: Type<0>; b: Type<1>; c: Type<2> }, ['a', 'b']>,
+  Type<
+    Readonly<{
+      a?: 0;
+      b?: 1;
+      c: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: OptionalPropertyType<Type<0>>;
+        b: OptionalPropertyType<Type<1>>;
+        c: Type<2>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  PartialType<{ a: Type<0>; b: Type<1>; c: Type<2> }, undefined>,
+  Type<
+    Readonly<{
+      a?: 0;
+      b?: 1;
+      c?: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: OptionalPropertyType<Type<0>>;
+        b: OptionalPropertyType<Type<1>>;
+        c: OptionalPropertyType<Type<2>>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
 
 expectType<
   PartialType<
-    Type<{ a: Type<0>; b: Type<0>; c: Type<0> }>,
+    { a: Type<0>; b: Type<1>; c: Type<2> },
     // @ts-expect-error key "d" doesn't exist
     ['a', 'd']
   >,