ts-fortress 4.2.1 → 4.3.0

package/dist/entry-point.mjs

@@ -52,6 +52,7 @@ export { isOptionalProperty, optional } from './record/optional.mjs';
 export { partial } from './record/partial.mjs';
 export { pick } from './record/pick.mjs';
 export { record, strictRecord } from './record/record.mjs';
+export { required } from './record/required.mjs';
 export { valueof } from './record/valueof.mjs';
 export { createAssertFn } from './utils/create-assert-fn.mjs';
 export { createCastFn } from './utils/create-cast-fn.mjs';

package/dist/entry-point.mjs.map

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

package/dist/index.mjs

@@ -51,6 +51,7 @@ export { isOptionalProperty, optional } from './record/optional.mjs';
 export { partial } from './record/partial.mjs';
 export { pick } from './record/pick.mjs';
 export { record, strictRecord } from './record/record.mjs';
+export { required } from './record/required.mjs';
 export { valueof } from './record/valueof.mjs';
 import 'ts-data-forge';
 export { createAssertFn } from './utils/create-assert-fn.mjs';

package/dist/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/record/index.d.mts

@@ -5,5 +5,6 @@ export * from './optional.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
 export * from './record.mjs';
+export * from './required.mjs';
 export * from './valueof.mjs';
 //# sourceMappingURL=index.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/record/index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/record/index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC"}

package/dist/record/index.mjs

@@ -5,5 +5,6 @@ export { isOptionalProperty, optional } from './optional.mjs';
 export { partial } from './partial.mjs';
 export { pick } from './pick.mjs';
 export { record, strictRecord } from './record.mjs';
+export { required } from './required.mjs';
 export { valueof } from './valueof.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/record/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/record/optional.d.mts

@@ -1,5 +1,6 @@
 import { type Type } from '../type.mjs';
 export type OptionalPropertyType<T extends Type<unknown>> = T & PartiallyRequired<T, 'optional'>;
+export type RequiredPropertyType<T extends Type<unknown>> = PartiallyOptional<T, 'optional'>;
 export declare const optional: <T extends Type<unknown>>(t: T) => OptionalPropertyType<T>;
 export declare const isOptionalProperty: <T extends Type<unknown>>(t: T) => t is OptionalPropertyType<T>;
 //# sourceMappingURL=optional.d.mts.map

package/dist/record/optional.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional.d.mts","sourceRoot":"","sources":["../../src/record/optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAC3D,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAEnC,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EAC9C,GAAG,CAAC,KACH,oBAAoB,CAAC,CAAC,CAGvB,CAAC;AAEH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EACxD,GAAG,CAAC,KACH,CAAC,IAAI,oBAAoB,CAAC,CAAC,CACuB,CAAC"}
+{"version":3,"file":"optional.d.mts","sourceRoot":"","sources":["../../src/record/optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAC3D,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAEnC,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,iBAAiB,CAC3E,CAAC,EACD,UAAU,CACX,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EAC9C,GAAG,CAAC,KACH,oBAAoB,CAAC,CAAC,CAGvB,CAAC;AAEH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EACxD,GAAG,CAAC,KACH,CAAC,IAAI,oBAAoB,CAAC,CAAC,CACuB,CAAC"}

package/dist/record/optional.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional.mjs","sources":["../../src/record/optional.mts"],"sourcesContent":[null],"names":[],"mappings":"MAKa,QAAQ,GAAG,CACtB,CAAI,MACyB;AAC7B,IAAA,GAAG,CAAC;AACJ,IAAA,QAAQ,EAAE,IAAI;AACf,CAAA;MAEY,kBAAkB,GAAG,CAChC,CAAI,KAEJ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK;;;;"}
+{"version":3,"file":"optional.mjs","sources":["../../src/record/optional.mts"],"sourcesContent":[null],"names":[],"mappings":"MAUa,QAAQ,GAAG,CACtB,CAAI,MACyB;AAC7B,IAAA,GAAG,CAAC;AACJ,IAAA,QAAQ,EAAE,IAAI;AACf,CAAA;MAEY,kBAAkB,GAAG,CAChC,CAAI,KAEJ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK;;;;"}

package/dist/record/required.d.mts

@@ -0,0 +1,22 @@
+import { type RecordType, type Type } from '../type.mjs';
+import { type RequiredPropertyType } from './optional.mjs';
+/**
+ * Creates a Required type. If keysToBeRequired is set, only those keys are
+ * made required, otherwise, all properties are made required.
+ */
+export declare const required: <const R extends ReadonlyRecord<string, Type<unknown>>, const KeysToBeRequired extends NonEmptyArray<keyof R & string>>(recordType: RecordType<R>, options?: PartialReadonly<{
+    keysToBeRequired: KeysToBeRequired;
+    typeName: string;
+    /** @default true */
+    allowExcessProperties: boolean;
+}>) => RequiredType<R, KeysToBeRequired>;
+type RequiredTypeShape<R extends ReadonlyRecord<string, Type<unknown>>, KeysToBeRequired extends NonEmptyArray<keyof R & string> | undefined> = TypeEq<KeysToBeRequired, undefined> extends true ? FullyRequiredType<R> : PartiallyRequiredType<R, ArrayElement<KeysToBeRequired>>;
+type FullyRequiredType<R extends ReadonlyRecord<string, Type<unknown>>> = {
+    readonly [P in keyof R]: RequiredPropertyType<R[P]>;
+};
+type PartiallyRequiredType<R extends ReadonlyRecord<string, Type<unknown>>, K extends keyof R> = {
+    readonly [P in keyof R]: P extends K ? RequiredPropertyType<R[P]> : R[P];
+};
+export type RequiredType<R extends ReadonlyRecord<string, Type<unknown>>, KeysToBeRequired extends NonEmptyArray<keyof R & string> | undefined> = RecordType<RequiredTypeShape<R, KeysToBeRequired>>;
+export {};
+//# sourceMappingURL=required.d.mts.map

package/dist/record/required.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.d.mts","sourceRoot":"","sources":["../../src/record/required.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,QAAQ,GACnB,KAAK,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EACrD,KAAK,CAAC,gBAAgB,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAE9D,YAAY,UAAU,CAAC,CAAC,CAAC,EACzB,UAAU,eAAe,CAAC;IACxB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IAEjB,oBAAoB;IACpB,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC,KACD,YAAY,CAAC,CAAC,EAAE,gBAAgB,CA2BlC,CAAC;AAaF,KAAK,iBAAiB,CACpB,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC/C,gBAAgB,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,SAAS,IAEpE,MAAM,CAAC,gBAAgB,EAAE,SAAS,CAAC,SAAS,IAAI,GAC5C,iBAAiB,CAAC,CAAC,CAAC,GACpB,qBAAqB,CAAC,CAAC,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAE/D,KAAK,iBAAiB,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI;IACxE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACpD,CAAC;AAEF,KAAK,qBAAqB,CACxB,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC/C,CAAC,SAAS,MAAM,CAAC,IACf;IACF,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,YAAY,CACtB,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC/C,gBAAgB,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,SAAS,IAClE,UAAU,CAAC,iBAAiB,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC"}

package/dist/record/required.mjs

@@ -0,0 +1,33 @@
+import { Obj } from 'ts-data-forge';
+import { toUnionKeyString } from '../utils/to-union-string.mjs';
+import { isOptionalProperty } from './optional.mjs';
+import { record } from './record.mjs';
+
+/**
+ * Creates a Required type. If keysToBeRequired is set, only those keys are
+ * made required, otherwise, all properties are made required.
+ */
+const required = (recordType, options) => {
+    const typeNameFilled = options?.typeName ??
+        (options?.keysToBeRequired === undefined
+            ? `Required<${recordType.typeName}>`
+            : `PartiallyRequired<${recordType.typeName}, ${toUnionKeyString(options.keysToBeRequired)}>`);
+    const keysToBeRequired = new Set(options?.keysToBeRequired ?? Object.keys(recordType.shape));
+    const requiredShape = 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    Object.fromEntries(Object.entries(recordType.shape).map(([k, v]) => [k, keysToBeRequired.has(k) ? makeRequired(v) : v]));
+    return record(requiredShape, {
+        typeName: typeNameFilled,
+        allowExcessProperties: options?.allowExcessProperties ?? recordType.allowExcessProperties,
+    });
+};
+/**
+ * Makes an optional property required by removing the optional flag.
+ */
+const makeRequired = (t) => isOptionalProperty(t)
+    ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        Obj.omit(t, ['optional'])
+    : t;
+
+export { required };
+//# sourceMappingURL=required.mjs.map

package/dist/record/required.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.mjs","sources":["../../src/record/required.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;AAGG;MACU,QAAQ,GAAG,CAItB,UAAyB,EACzB,OAME,KACmC;AACrC,IAAA,MAAM,cAAc,GAClB,OAAO,EAAE,QAAQ;AACjB,SAAC,OAAO,EAAE,gBAAgB,KAAK;AAC7B,cAAE,CAAA,SAAA,EAAY,UAAU,CAAC,QAAQ,CAAA,CAAA;AACjC,cAAE,CAAA,kBAAA,EAAqB,UAAU,CAAC,QAAQ,CAAA,EAAA,EAAK,gBAAgB,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAA,CAAA,CAAG,CAAC;AAEjG,IAAA,MAAM,gBAAgB,GAAwB,IAAI,GAAG,CACnD,OAAO,EAAE,gBAAgB,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAC3D;AAED,IAAA,MAAM,aAAa;;IAEjB,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,GAAG,CAClC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAU,CACxE,CAIF;IAEH,OAAO,MAAM,CAAC,aAAa,EAAE;AAC3B,QAAA,QAAQ,EAAE,cAAc;AACxB,QAAA,qBAAqB,EACnB,OAAO,EAAE,qBAAqB,IAAI,UAAU,CAAC,qBAAqB;AACrE,KAAA,CAAC;AACJ;AAEA;;AAEG;AACH,MAAM,YAAY,GAAG,CACnB,CAAI,KAEJ,kBAAkB,CAAC,CAAC;AAClB;QACG,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC;MACzB,CAAC;;;;"}

package/package.json

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

package/src/record/index.mts

@@ -5,4 +5,5 @@ export * from './optional.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
 export * from './record.mjs';
+export * from './required.mjs';
 export * from './valueof.mjs';

package/src/record/optional.mts

@@ -3,6 +3,11 @@ import { type Type } from '../type.mjs';
 export type OptionalPropertyType<T extends Type<unknown>> = T &
   PartiallyRequired<T, 'optional'>;
 
+export type RequiredPropertyType<T extends Type<unknown>> = PartiallyOptional<
+  T,
+  'optional'
+>;
+
 export const optional = <T extends Type<unknown>>(
   t: T,
 ): OptionalPropertyType<T> => ({

package/src/record/partial.mts

@@ -105,7 +105,7 @@ expectType<
       }>;
       allowExcessProperties: boolean;
     }>
->('~=');
+>('=');
 
 expectType<
   RecordType<

package/src/record/required.mts

@@ -0,0 +1,246 @@
+import { expectType, Obj } from 'ts-data-forge';
+import { type RecordType, type Type } from '../type.mjs';
+import { toUnionKeyString } from '../utils/index.mjs';
+import {
+  isOptionalProperty,
+  type OptionalPropertyType,
+  type RequiredPropertyType,
+} from './optional.mjs';
+import { record } from './record.mjs';
+
+/**
+ * Creates a Required type. If keysToBeRequired is set, only those keys are
+ * made required, otherwise, all properties are made required.
+ */
+export const required = <
+  const R extends ReadonlyRecord<string, Type<unknown>>,
+  const KeysToBeRequired extends NonEmptyArray<keyof R & string>,
+>(
+  recordType: RecordType<R>,
+  options?: PartialReadonly<{
+    keysToBeRequired: KeysToBeRequired;
+    typeName: string;
+
+    /** @default true */
+    allowExcessProperties: boolean;
+  }>,
+): RequiredType<R, KeysToBeRequired> => {
+  const typeNameFilled: string =
+    options?.typeName ??
+    (options?.keysToBeRequired === undefined
+      ? `Required<${recordType.typeName}>`
+      : `PartiallyRequired<${recordType.typeName}, ${toUnionKeyString(options.keysToBeRequired)}>`);
+
+  const keysToBeRequired: ReadonlySet<string> = new Set(
+    options?.keysToBeRequired ?? Object.keys(recordType.shape),
+  );
+
+  const requiredShape =
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    Object.fromEntries(
+      Object.entries(recordType.shape).map(
+        ([k, v]) => [k, keysToBeRequired.has(k) ? makeRequired(v) : v] as const,
+      ),
+    ) satisfies ReadonlyRecord<string, Type<unknown>> as RequiredTypeShape<
+      R,
+      KeysToBeRequired
+    >;
+
+  return record(requiredShape, {
+    typeName: typeNameFilled,
+    allowExcessProperties:
+      options?.allowExcessProperties ?? recordType.allowExcessProperties,
+  });
+};
+
+/**
+ * Makes an optional property required by removing the optional flag.
+ */
+const makeRequired = <T extends Type<unknown>>(
+  t: T,
+): RequiredPropertyType<T> =>
+  isOptionalProperty(t)
+    ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      (Obj.omit(t, ['optional']) as RequiredPropertyType<T>)
+    : t;
+
+type RequiredTypeShape<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  KeysToBeRequired extends NonEmptyArray<keyof R & string> | undefined,
+> =
+  TypeEq<KeysToBeRequired, undefined> extends true
+    ? FullyRequiredType<R>
+    : PartiallyRequiredType<R, ArrayElement<KeysToBeRequired>>;
+
+type FullyRequiredType<R extends ReadonlyRecord<string, Type<unknown>>> = {
+  readonly [P in keyof R]: RequiredPropertyType<R[P]>;
+};
+
+type PartiallyRequiredType<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  K extends keyof R,
+> = {
+  readonly [P in keyof R]: P extends K ? RequiredPropertyType<R[P]> : R[P];
+};
+
+export type RequiredType<
+  R extends ReadonlyRecord<string, Type<unknown>>,
+  KeysToBeRequired extends NonEmptyArray<keyof R & string> | undefined,
+> = RecordType<RequiredTypeShape<R, KeysToBeRequired>>;
+
+expectType<
+  RequiredTypeShape<
+    {
+      a: OptionalPropertyType<Type<0>>;
+      b: Type<1>;
+      c: OptionalPropertyType<Type<2>>;
+    },
+    ['a']
+  >,
+  Readonly<{
+    a: Type<0>;
+    b: Type<1>;
+    c: OptionalPropertyType<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: Type<0>;
+      b: Type<1>;
+      c: OptionalPropertyType<Type<2>>;
+    }>
+  >,
+  Type<
+    Readonly<{
+      a: 0;
+      b: 1;
+      c?: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: Type<0>;
+        b: Type<1>;
+        c: OptionalPropertyType<Type<2>>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  RequiredType<
+    {
+      a: OptionalPropertyType<Type<0>>;
+      b: Type<1>;
+      c: OptionalPropertyType<Type<2>>;
+    },
+    ['a']
+  >,
+  Type<
+    Readonly<{
+      a: 0;
+      b: 1;
+      c?: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: Type<0>;
+        b: Type<1>;
+        c: OptionalPropertyType<Type<2>>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  RequiredType<
+    {
+      a: OptionalPropertyType<Type<0>>;
+      b: OptionalPropertyType<Type<1>>;
+      c: Type<2>;
+    },
+    ['a', 'b']
+  >,
+  Type<
+    Readonly<{
+      a: 0;
+      b: 1;
+      c: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: Type<0>;
+        b: Type<1>;
+        c: Type<2>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  RequiredType<
+    {
+      a: OptionalPropertyType<Type<0>>;
+      b: OptionalPropertyType<Type<1>>;
+      c: OptionalPropertyType<Type<2>>;
+    },
+    undefined
+  >,
+  Type<
+    Readonly<{
+      a: 0;
+      b: 1;
+      c: 2;
+    }>
+  > &
+    Readonly<{
+      shape: Readonly<{
+        a: Type<0>;
+        b: Type<1>;
+        c: Type<2>;
+      }>;
+      allowExcessProperties: boolean;
+    }>
+>('=');
+
+expectType<
+  RequiredType<
+    {
+      a: OptionalPropertyType<Type<0>>;
+      b: Type<1>;
+      c: OptionalPropertyType<Type<2>>;
+    },
+    // @ts-expect-error key "d" doesn't exist
+    ['a', 'd']
+  >,
+  0
+>('!=');

package/src/record/required.test.mts

@@ -0,0 +1,600 @@
+import { expectType, Result } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  type ValidationError,
+  validationErrorsToMessages,
+} from '../utils/index.mjs';
+import { optional, type OptionalPropertyType } from './optional.mjs';
+import { record } from './record.mjs';
+import { required, type RequiredType } from './required.mjs';
+
+describe('required', () => {
+  describe('fully required', () => {
+    const ymdBase = record({
+      year: optional(number(1900)),
+      month: optional(number(1)),
+      date: optional(number(1)),
+    });
+
+    const ymd = required(ymdBase);
+
+    expectType<
+      typeof ymd,
+      RequiredType<
+        Readonly<{
+          year: OptionalPropertyType<Type<number>>;
+          month: OptionalPropertyType<Type<number>>;
+          date: OptionalPropertyType<Type<number>>;
+        }>,
+        undefined
+      >
+    >('=');
+
+    expectType<
+      typeof ymd,
+      Type<
+        Readonly<{
+          year: number;
+          month: number;
+          date: number;
+        }>
+      > &
+        Readonly<{
+          shape: Readonly<{
+            year: Type<number>;
+            month: Type<number>;
+            date: Type<number>;
+          }>;
+          allowExcessProperties: boolean;
+        }>
+    >('=');
+
+    type Ymd = TypeOf<typeof ymd>;
+
+    expectType<
+      Ymd,
+      Required<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 - missing required property', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          // missing date - this should fail since date is now required
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(false);
+      });
+
+      test('falsy case - wrong type', () => {
+        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('truthy case', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+        };
+
+        const result = ymd.validate(x);
+        expectType<typeof result, Result<Ymd, readonly ValidationError[]>>('=');
+        expect(Result.isOk(result)).toBe(true);
+
+        if (Result.isOk(result)) {
+          expect(result.value).toStrictEqual({
+            year: 2000,
+            month: 12,
+            date: 25,
+          });
+        }
+      });
+
+      test('validate returns input as-is for OK cases', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
+      test('falsy case - missing required property', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          // missing date - this should fail since date is now required
+        };
+
+        const result = ymd.validate(x);
+        expect(Result.isErr(result)).toBe(true);
+
+        if (Result.isErr(result)) {
+          expect(result.value).toStrictEqual([
+            {
+              path: ['date'],
+              actualValue: { year: 2000, month: 12 },
+              expectedType:
+                'Required<{ year: number, month: number, date: number }>',
+              typeName:
+                'Required<{ year: number, month: number, date: number }>',
+              message: 'Missing required key "date"',
+            },
+          ]);
+          expect(validationErrorsToMessages(result.value)).toStrictEqual([
+            'Missing required key "date" at date',
+          ]);
+        }
+      });
+
+      test('truthy case with additional keys', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+          aaa: 999,
+        };
+
+        const result = ymd.validate(x);
+        expectType<typeof result, Result<Ymd, readonly ValidationError[]>>('=');
+        expect(Result.isOk(result)).toBe(true);
+
+        if (Result.isOk(result)) {
+          expect(result.value).toStrictEqual({
+            year: 2000,
+            month: 12,
+            date: 25,
+            aaa: 999,
+          });
+        }
+      });
+
+      test('validate returns input as-is for OK cases with additional keys', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+          aaa: 999,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
+      test('falsy case - wrong type', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 'cd',
+        };
+
+        const result = ymd.validate(x);
+        expect(Result.isErr(result)).toBe(true);
+
+        if (Result.isErr(result)) {
+          expect(result.value).toStrictEqual([
+            {
+              path: ['month'],
+              actualValue: 'ab',
+              expectedType: 'number',
+              typeName: 'number',
+              message: undefined,
+            },
+            {
+              path: ['date'],
+              actualValue: 'cd',
+              expectedType: 'number',
+              typeName: 'number',
+              message: undefined,
+            },
+          ]);
+          expect(validationErrorsToMessages(result.value)).toStrictEqual([
+            'Expected <number> at month, got <string> type value "ab".',
+            'Expected <number> at date, got <string> type value "cd".',
+          ]);
+        }
+      });
+
+      test('falsy case - single wrong type', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 12,
+        };
+
+        const result = ymd.validate(x);
+        expect(Result.isErr(result)).toBe(true);
+
+        if (Result.isErr(result)) {
+          expect(result.value).toStrictEqual([
+            {
+              path: ['month'],
+              actualValue: 'ab',
+              expectedType: 'number',
+              typeName: 'number',
+              message: undefined,
+            },
+          ]);
+          expect(validationErrorsToMessages(result.value)).toStrictEqual([
+            'Expected <number> at month, got <string> type value "ab".',
+          ]);
+        }
+      });
+    });
+
+    describe('fill', () => {
+      test('from an empty record', () => {
+        const x: UnknownRecord = {};
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 1900,
+          month: 1,
+          date: 1,
+        });
+      });
+
+      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,
+          month: 1,
+          date: 1,
+        });
+      });
+
+      test('from a partial record with excess property', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          aaaaa: 9999,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+          month: 1,
+          date: 1,
+        });
+      });
+    });
+  });
+
+  describe('partially required', () => {
+    const ymdBase = record({
+      year: optional(number(1900)),
+      month: optional(number(1)),
+      date: optional(number(1)),
+    });
+
+    const ymd = required(ymdBase, { keysToBeRequired: ['year', 'month'] });
+
+    type Ymd = TypeOf<typeof ymd>;
+
+    expectType<Ymd, Readonly<{ year: number; month: number; date?: number }>>(
+      '=',
+    );
+
+    expectType<typeof ymd.defaultValue, Ymd>('=');
+
+    describe('is', () => {
+      test('truthy case - required fields only', () => {
+        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('truthy case - with optional field', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 15,
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(true);
+      });
+
+      test('falsy case - missing required field', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          // missing month
+          date: 15,
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(false);
+      });
+
+      test('falsy case - wrong type in required field', () => {
+        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 - wrong type in optional field', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 'cd',
+        };
+
+        if (ymd.is(x)) {
+          expectType<typeof x, Ymd>('=');
+        } else {
+          expectType<typeof x, UnknownRecord>('=');
+        }
+
+        expect(ymd.is(x)).toBe(false);
+      });
+    });
+
+    describe('validate', () => {
+      test('truthy case - required fields only', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+        };
+
+        const result = ymd.validate(x);
+        expectType<typeof result, Result<Ymd, readonly ValidationError[]>>('=');
+        expect(Result.isOk(result)).toBe(true);
+
+        if (Result.isOk(result)) {
+          expect(result.value).toStrictEqual({
+            year: 2000,
+            month: 12,
+          });
+        }
+      });
+
+      test('partiallyRequiredType validate returns input as-is for OK cases', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
+      test('truthy case - with optional field', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 15,
+        };
+
+        const result = ymd.validate(x);
+        expect(Result.isOk(result)).toBe(true);
+
+        if (Result.isOk(result)) {
+          expect(result.value).toStrictEqual({
+            year: 2000,
+            month: 12,
+            date: 15,
+          });
+        }
+      });
+
+      test('falsy case - missing required field', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          // missing month
+          date: 15,
+        };
+
+        const result = ymd.validate(x);
+        expect(Result.isErr(result)).toBe(true);
+
+        if (Result.isErr(result)) {
+          expect(result.value).toStrictEqual([
+            {
+              path: ['month'],
+              actualValue: { year: 2000, date: 15 },
+              expectedType:
+                'PartiallyRequired<{ year: number, month: number, date: number }, "year" | "month">',
+              typeName:
+                'PartiallyRequired<{ year: number, month: number, date: number }, "year" | "month">',
+              message: 'Missing required key "month"',
+            },
+          ]);
+          expect(validationErrorsToMessages(result.value)).toStrictEqual([
+            'Missing required key "month" at month',
+          ]);
+        }
+      });
+
+      test('falsy case - wrong types', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 'ab',
+          date: 'cd',
+        };
+
+        const result = ymd.validate(x);
+        expect(Result.isErr(result)).toBe(true);
+
+        if (Result.isErr(result)) {
+          expect(result.value).toStrictEqual([
+            {
+              path: ['month'],
+              actualValue: 'ab',
+              expectedType: 'number',
+              typeName: 'number',
+              message: undefined,
+            },
+            {
+              path: ['date'],
+              actualValue: 'cd',
+              expectedType: 'number',
+              typeName: 'number',
+              message: undefined,
+            },
+          ]);
+          expect(validationErrorsToMessages(result.value)).toStrictEqual([
+            'Expected <number> at month, got <string> type value "ab".',
+            'Expected <number> at date, got <string> type value "cd".',
+          ]);
+        }
+      });
+    });
+
+    describe('fill', () => {
+      test('from an empty record', () => {
+        const x: UnknownRecord = {};
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 1900,
+          month: 1,
+          date: 1,
+        });
+      });
+
+      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 - required fields only', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+          month: 12,
+          date: 1,
+        });
+      });
+
+      test('from a partial record - missing required field', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          // missing month - fill should provide default
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+          month: 1,
+          date: 1,
+        });
+      });
+
+      test('from a partial record with excess property', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          aaaaa: 9999,
+        };
+
+        expect(ymd.fill(x)).toStrictEqual({
+          year: 2000,
+          month: 12,
+          date: 1,
+        });
+      });
+    });
+  });
+});