ts-fortress 4.0.0 → 4.1.1

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 { valueof } from './record/valueof.mjs';
 export { createAssertFn } from './utils/create-assert-fn.mjs';
 export { createCastFn } from './utils/create-cast-fn.mjs';
 export { createIsFn } from './utils/create-is-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 { valueof } from './record/valueof.mjs';
 import 'ts-data-forge';
 export { createAssertFn } from './utils/create-assert-fn.mjs';
 export { createCastFn } from './utils/create-cast-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,4 +5,5 @@ export * from './optional.mjs';
 export * from './partial.mjs';
 export * from './pick.mjs';
 export * from './record.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"}
+{"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"}

package/dist/record/index.mjs

@@ -5,4 +5,5 @@ export { isOptionalProperty, optional } from './optional.mjs';
 export { partial } from './partial.mjs';
 export { pick } from './pick.mjs';
 export { record, strictRecord } from './record.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/record.d.mts

@@ -1,4 +1,4 @@
-import { type RecordType, type TsFortressInternal, type Type } from '../type.mjs';
+import { type RecordType, type Type } from '../type.mjs';
 export declare const record: <const R extends ReadonlyRecord<string, Type<unknown>>>(shape: R, options?: Partial<Readonly<{
     typeName: string;
     /** @default true */
@@ -27,5 +27,5 @@ export declare const record: <const R extends ReadonlyRecord<string, Type<unknow
  */
 export declare const strictRecord: <const R extends ReadonlyRecord<string, Type<unknown>>>(source: R, options?: Partial<Readonly<{
     typeName: string;
-}>>) => Type<TsFortressInternal.RecordTypeValue<R>>;
+}>>) => RecordType<R>;
 //# sourceMappingURL=record.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"record.d.mts","sourceRoot":"","sources":["../../src/record/record.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,IAAI,EACV,MAAM,aAAa,CAAC;AAWrB,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC1E,OAAO,CAAC,EACR,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IAEjB,oBAAoB;IACpB,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC,CACH,KACA,UAAU,CAAC,CAAC,CAyGd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAErD,QAAQ,CAAC,EACT,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CACH,KACA,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC,CAAC,CACiB,CAAC"}
+{"version":3,"file":"record.d.mts","sourceRoot":"","sources":["../../src/record/record.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,IAAI,EACV,MAAM,aAAa,CAAC;AAWrB,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC1E,OAAO,CAAC,EACR,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IAEjB,oBAAoB;IACpB,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC,CACH,KACA,UAAU,CAAC,CAAC,CAyGd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAErD,QAAQ,CAAC,EACT,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CACH,KACA,UAAU,CAAC,CAAC,CAC+C,CAAC"}

package/dist/record/valueof.d.mts

@@ -0,0 +1,8 @@
+import { type RecordType, type Type } from '../type.mjs';
+export declare const valueof: <const R extends ReadonlyRecord<string, Type<unknown>>>(recordType: RecordType<R>, options?: Partial<Readonly<{
+    typeName: string;
+}>>) => ValueOfType<R>;
+type ValueofTypeSub<R extends ReadonlyRecord<string, Type<unknown>>> = Type<R[keyof R]['defaultValue']>;
+type ValueOfType<R extends ReadonlyRecord<string, Type<unknown>>> = IsNever<keyof R> extends true ? Type<undefined> : ValueofTypeSub<R>;
+export {};
+//# sourceMappingURL=valueof.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueof.d.mts","sourceRoot":"","sources":["../../src/record/valueof.mts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,OAAO,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,EAC3E,YAAY,UAAU,CAAC,CAAC,CAAC,EACzB,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CACH,KACA,WAAW,CAAC,CAAC,CAiBf,CAAC;AAEF,KAAK,cAAc,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,CACzE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,CAC3B,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,IAC9D,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC"}

package/dist/record/valueof.mjs

@@ -0,0 +1,23 @@
+import { Arr } from 'ts-data-forge';
+import { union } from '../compose/union.mjs';
+import { undefinedType } from '../primitives/undefined.mjs';
+
+const valueof = (recordType, options) => {
+    const types = Object.values(recordType.shape);
+    if (Arr.isArrayAtLeastLength(types, 2)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return union(types, {
+            typeName: options?.typeName ?? `ValueOf<${recordType.typeName}>`,
+        });
+    }
+    if (Arr.isNonEmpty(types)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return types[0];
+    }
+    // types is empty
+    return undefinedType;
+};
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+export { valueof };
+//# sourceMappingURL=valueof.mjs.map

package/dist/record/valueof.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueof.mjs","sources":["../../src/record/valueof.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;MAKa,OAAO,GAAG,CACrB,UAAyB,EACzB,OAIC,KACiB;IAClB,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC;IAE7C,IAAI,GAAG,CAAC,oBAAoB,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE;;QAEtC,OAAO,KAAK,CAAC,KAAK,EAAE;YAClB,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,CAAA,QAAA,EAAW,UAAU,CAAC,QAAQ,CAAA,CAAA,CAAG;AACjE,SAAA,CAA+C;;AAGlD,IAAA,IAAI,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;;AAEzB,QAAA,OAAO,KAAK,CAAC,CAAC,CAA+C;;;AAI/D,IAAA,OAAO,aAAsC;AAC/C;AASA;;;;"}

package/package.json

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

package/src/record/index.mts

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

package/src/record/record.mts

@@ -161,5 +161,5 @@ export const strictRecord = <
       typeName: string;
     }>
   >,
-): Type<TsFortressInternal.RecordTypeValue<R>> =>
+): RecordType<R> =>
   record(source, { ...options, allowExcessProperties: false });

package/src/record/valueof.mts

@@ -0,0 +1,57 @@
+import { Arr, expectType } from 'ts-data-forge';
+import { union } from '../compose/index.mjs';
+import { undefinedType } from '../primitives/index.mjs';
+import { type RecordType, type Type } from '../type.mjs';
+
+export const valueof = <const R extends ReadonlyRecord<string, Type<unknown>>>(
+  recordType: RecordType<R>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
+): ValueOfType<R> => {
+  const types = Object.values(recordType.shape);
+
+  if (Arr.isArrayAtLeastLength(types, 2)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return union(types, {
+      typeName: options?.typeName ?? `ValueOf<${recordType.typeName}>`,
+    }) satisfies ValueofTypeSub<R> as ValueOfType<R>;
+  }
+
+  if (Arr.isNonEmpty(types)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return types[0] satisfies ValueofTypeSub<R> as ValueOfType<R>;
+  }
+
+  // types is empty
+  return undefinedType satisfies ValueOfType<R>;
+};
+
+type ValueofTypeSub<R extends ReadonlyRecord<string, Type<unknown>>> = Type<
+  R[keyof R]['defaultValue']
+>;
+
+type ValueOfType<R extends ReadonlyRecord<string, Type<unknown>>> =
+  IsNever<keyof R> extends true ? Type<undefined> : ValueofTypeSub<R>;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+expectType<ValueOfType<{}>, Type<undefined>>('=');
+
+expectType<
+  ValueOfType<{ a: Type<0>; b: Type<1>; c: Type<2> }>,
+  Type<0 | 1 | 2>
+>('=');
+
+expectType<
+  ValueOfType<{ x: Type<string>; y: Type<number>; z: Type<boolean> }>,
+  Type<string | number | boolean>
+>('=');
+
+expectType<
+  ValueOfType<{ same: Type<string>; value: Type<string> }>,
+  Type<string>
+>('=');
+
+expectType<ValueOfType<{ never: Type<never> }>, Type<never>>('=');

package/src/record/valueof.test.mts

@@ -0,0 +1,178 @@
+import { expectType, Result } from 'ts-data-forge';
+import { number, string } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
+import { record } from './record.mjs';
+import { valueof } from './valueof.mjs';
+
+describe('valueof', () => {
+  const ymdValue = valueof(
+    record({
+      year: number(1900),
+      month: number(1),
+      date: number(1),
+    }),
+  );
+
+  expectType<typeof ymdValue, Type<number>>('=');
+
+  type YmdValue = TypeOf<typeof ymdValue>;
+
+  expectType<YmdValue, number>('=');
+
+  expectType<typeof ymdValue.defaultValue, YmdValue>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: unknown = 2000;
+
+      if (ymdValue.is(x)) {
+        expectType<typeof x, number>('=');
+      } else {
+        expectType<typeof x, unknown>('=');
+      }
+
+      expect(ymdValue.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: unknown = 'not-a-number';
+
+      if (ymdValue.is(x)) {
+        expectType<typeof x, number>('=');
+      } else {
+        expectType<typeof x, unknown>('=');
+      }
+
+      expect(ymdValue.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('truthy case', () => {
+      const x: unknown = 2000;
+
+      const result = ymdValue.validate(x);
+      expect(Result.isOk(result)).toBe(true);
+
+      if (Result.isOk(result)) {
+        expectType<typeof result.value, YmdValue>('=');
+        expect(result.value).toBe(2000);
+      }
+    });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = 2000;
+      const result = ymdValue.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
+    test('falsy case', () => {
+      const x: unknown = 'not-a-number';
+
+      const result = ymdValue.validate(x);
+      expect(Result.isErr(result)).toBe(true);
+
+      if (Result.isErr(result)) {
+        expect(result.value).toStrictEqual([
+          {
+            path: [],
+            actualValue: 'not-a-number',
+            expectedType:
+              'ValueOf<{ year: number, month: number, date: number }>',
+            typeName: 'ValueOf<{ year: number, month: number, date: number }>',
+            message:
+              'The type of value is expected to be one of the elements contained in { number, number, number }',
+          },
+        ]);
+        expect(validationErrorsToMessages(result.value)).toStrictEqual([
+          'The type of value is expected to be one of the elements contained in { number, number, number }',
+        ]);
+      }
+    });
+  });
+
+  describe('fill', () => {
+    test('from external value', () => {
+      const x: unknown = 'not-a-number';
+
+      expect(ymdValue.fill(x)).toBe(1900);
+    });
+
+    test('from valid number', () => {
+      const x = 2000;
+
+      expect(ymdValue.fill(x)).toBe(2000);
+    });
+  });
+
+  describe('mixed types', () => {
+    const mixedValue = valueof(
+      record({
+        name: string('John'),
+        age: number(25),
+      }),
+    );
+
+    expectType<typeof mixedValue, Type<string | number>>('=');
+
+    type MixedValue = TypeOf<typeof mixedValue>;
+
+    expectType<MixedValue, string | number>('=');
+
+    test('accepts string', () => {
+      const x: unknown = 'Alice';
+      expect(mixedValue.is(x)).toBe(true);
+    });
+
+    test('accepts number', () => {
+      const x: unknown = 30;
+      expect(mixedValue.is(x)).toBe(true);
+    });
+
+    test('rejects boolean', () => {
+      const x: unknown = true;
+      expect(mixedValue.is(x)).toBe(false);
+    });
+
+    test('validate mixed values', () => {
+      const stringResult = mixedValue.validate('Alice');
+      expect(Result.isOk(stringResult)).toBe(true);
+      if (Result.isOk(stringResult)) {
+        expect(stringResult.value).toBe('Alice');
+      }
+
+      const numberResult = mixedValue.validate(30);
+      expect(Result.isOk(numberResult)).toBe(true);
+      if (Result.isOk(numberResult)) {
+        expect(numberResult.value).toBe(30);
+      }
+    });
+
+    test('fill from invalid value uses first type default', () => {
+      expect(mixedValue.fill(true)).toBe('John');
+    });
+  });
+
+  describe('same type values', () => {
+    const sameTypeValue = valueof(
+      record({
+        first: string('hello'),
+        second: string('world'),
+      }),
+    );
+
+    expectType<typeof sameTypeValue, Type<string>>('=');
+
+    test('accepts any string', () => {
+      expect(sameTypeValue.is('test')).toBe(true);
+    });
+
+    test('rejects non-string', () => {
+      expect(sameTypeValue.is(123)).toBe(false);
+    });
+  });
+});