ts-fortress 6.2.2 → 6.2.4

package/src/compose/union-records.test.mts

@@ -23,14 +23,16 @@ describe('union - records only', () => {
 
   expectType<
     TargetType,
-    | Readonly<{
-        kind: string;
-        value: number;
-      }>
-    | Readonly<{
-        type: string;
-        data: string;
-      }>
+    Readonly<
+      | {
+          kind: string;
+          value: number;
+        }
+      | {
+          type: string;
+          data: string;
+        }
+    >
   >('=');
 
   expectType<typeof targetType.defaultValue, TargetType>('=');

package/src/compose/union.mts

@@ -10,10 +10,12 @@ import {
 
 export const union = <const Types extends NonEmptyArray<Type<unknown>>>(
   types: Types,
-  options?: PartialReadonly<{
-    typeName: string;
-    defaultType: UnionType<Types>;
-  }>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+      defaultType: UnionType<Types>;
+    }>
+  >,
 ): UnionType<Types> => {
   type T = UnionTypeValue<Types>;
 
@@ -70,11 +72,19 @@ namespace TsFortressInternal {
 }
 
 expectType<
-  UnionType<[Type<{ a: 0; b: 0 }>, Type<{ b: 0; c: 0 }>]>,
-  Type<{ a: 0; b: 0 } | { b: 0; c: 0 }>
+  UnionType<
+    readonly [Type<Readonly<{ a: 0; b: 0 }>>, Type<Readonly<{ b: 0; c: 0 }>>]
+  >,
+  Type<Readonly<{ a: 0; b: 0 } | { b: 0; c: 0 }>>
 >('=');
 
 expectType<
-  UnionType<[Type<{ a: 0; b: 0 }>, Type<{ b: 0; c: 0 }>, Type<{ e: 0; f: 0 }>]>,
-  Type<{ a: 0; b: 0 } | { b: 0; c: 0 } | { e: 0; f: 0 }>
+  UnionType<
+    readonly [
+      Type<Readonly<{ a: 0; b: 0 }>>,
+      Type<Readonly<{ b: 0; c: 0 }>>,
+      Type<Readonly<{ e: 0; f: 0 }>>,
+    ]
+  >,
+  Type<Readonly<{ a: 0; b: 0 } | { b: 0; c: 0 } | { e: 0; f: 0 }>>
 >('=');

package/src/enum/enum.mts

@@ -9,10 +9,12 @@ import {
 
 export const enumType = <const Values extends NonEmptyArray<Primitive>>(
   values: Values,
-  options?: PartialReadonly<{
-    typeName: string;
-    defaultValue: ArrayElement<Values>;
-  }>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+      defaultValue: ArrayElement<Values>;
+    }>
+  >,
 ): Type<ArrayElement<Values>> => {
   type T = ArrayElement<Values>;
 

package/src/globals.d.mts

@@ -1,7 +1,5 @@
 /// <reference types="ts-type-forge" />
 
-type PartialReadonly<T> = Partial<Readonly<T>>;
-
 type Iso8601 = Brand<string, 'Iso8601'>;
 
 type Email = Brand<string, 'Email'>;

package/src/other-types/map.mts

@@ -20,9 +20,11 @@ type MapResultType<
 export const MapType = <K extends Type<unknown>, V extends Type<unknown>>(
   keyType: K,
   valueType: V,
-  options?: PartialReadonly<{
-    typeName: string;
-  }>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
 ): Type<MapResultType<K, V>> => {
   type M = MapResultType<K, V>;
 

package/src/other-types/recursion.mts

@@ -4,11 +4,13 @@ import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
 export const recursion = <A,>(
   typeName: string,
   definition: () => Type<A>,
-  options?: PartialReadonly<{
-    defaultValue: A;
-  }>,
+  options?: Partial<
+    Readonly<{
+      defaultValue: A;
+    }>
+  >,
 ): Type<A> => {
-  const cache: {
+  const mut_cache: {
     innerType: Type<A> | undefined;
     computedDefaultValue: A | undefined;
   } = {
@@ -17,10 +19,9 @@ export const recursion = <A,>(
   };
 
   const getInnerType = (): Type<A> => {
-    // eslint-disable-next-line functional/immutable-data
-    cache.innerType ??= definition();
+    mut_cache.innerType ??= definition();
 
-    return cache.innerType;
+    return mut_cache.innerType;
   };
 
   const validate: Type<A>['validate'] = (a) => getInnerType().validate(a);
@@ -36,10 +37,9 @@ export const recursion = <A,>(
         return options.defaultValue;
       }
 
-      // eslint-disable-next-line functional/immutable-data
-      cache.computedDefaultValue ??= getInnerType().defaultValue;
+      mut_cache.computedDefaultValue ??= getInnerType().defaultValue;
 
-      return cache.computedDefaultValue;
+      return mut_cache.computedDefaultValue;
     },
     fill,
     validate,

package/src/other-types/recursion.test.mts

@@ -183,7 +183,7 @@ describe('recursive', () => {
 
   // Test other recursive structures
   test('Linked list structure', () => {
-    type LinkedList<T> = { value: T; next: LinkedList<T> | null };
+    type LinkedList<T> = Readonly<{ value: T; next: LinkedList<T> | null }>;
 
     const LinkedListNumber: Type<LinkedList<number>> = recursion(
       'LinkedList<number>',

package/src/other-types/set.mts

@@ -15,9 +15,11 @@ type SetResultType<T extends Type<unknown>> = ReadonlySet<TypeOf<T>>;
 
 export const SetType = <T extends Type<unknown>>(
   elementType: T,
-  options?: PartialReadonly<{
-    typeName: string;
-  }>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
 ): Type<SetResultType<T>> => {
   type S = SetResultType<T>;
 

package/src/predefined/brand/string/email.mts

@@ -5,9 +5,11 @@ import { type Type } from '../../../type.mjs';
  * @link https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
  */
 export const email = (
-  options?: PartialReadonly<{
-    defaultValue: string;
-  }>,
+  options?: Partial<
+    Readonly<{
+      defaultValue: string;
+    }>
+  >,
 ): Type<Email> =>
   brandedString({
     is: (s): s is Email => regexpEmailAddress.test(s),

package/src/predefined/brand/string/json-string.mts

@@ -6,9 +6,11 @@ import { type Type } from '../../../type.mjs';
  * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
  */
 export const jsonString = (
-  options?: PartialReadonly<{
-    defaultValue: string;
-  }>,
+  options?: Partial<
+    Readonly<{
+      defaultValue: string;
+    }>
+  >,
 ): Type<JsonString> =>
   brandedString({
     is: isJsonString,

package/src/predefined/brand/string/uuid.mts

@@ -64,15 +64,17 @@ export const uuidV7 = (defaultValue?: string): Type<Uuid7> =>
   });
 
 type UuidValidatorOption<V extends UuidVersion | UuidVersionAdditionalOption> =
-  PartialReadonly<{
-    /**
-     * @param version One of 1-8, 'nil', 'max', 'all' or 'loose'. The 'loose' option checks if the string is a UUID-like string with hexadecimal values, ignoring RFC9562.
-     */
-    version: V;
+  Partial<
+    Readonly<{
+      /**
+       * @param version One of 1-8, 'nil', 'max', 'all' or 'loose'. The 'loose' option checks if the string is a UUID-like string with hexadecimal values, ignoring RFC9562.
+       */
+      version: V;
 
-    typeName: string;
-    defaultValue: string;
-  }>;
+      typeName: string;
+      defaultValue: string;
+    }>
+  >;
 
 const nilUuid = '00000000-0000-0000-0000-000000000000' satisfies UuidBaseString;
 

package/src/primitives/bigint.mts

@@ -126,20 +126,22 @@ export function bigint<C extends Constraints>(
   });
 }
 
-type Constraints = PartialReadonly<{
-  gt: bigint;
-  gte: bigint;
-  min: bigint;
-  lt: bigint;
-  lte: bigint;
-  max: bigint;
-  negative: boolean;
-  nonNegative: boolean;
-  positive: boolean;
-  nonPositive: boolean;
-  multipleOf: bigint;
-  step: bigint;
-}>;
+type Constraints = Partial<
+  Readonly<{
+    gt: bigint;
+    gte: bigint;
+    min: bigint;
+    lt: bigint;
+    lte: bigint;
+    max: bigint;
+    negative: boolean;
+    nonNegative: boolean;
+    positive: boolean;
+    nonPositive: boolean;
+    multipleOf: bigint;
+    step: bigint;
+  }>
+>;
 
 type DefaultValueType<
   B extends bigint,
@@ -149,25 +151,17 @@ type DefaultValueType<
   DefaultValueWhenPositiveIsOn<B, R> &
   DefaultValueWhenNonPositiveIsOn<B, R>;
 
-type DefaultValueWhenNegativeIsOn<
-  B extends bigint,
-  R extends Constraints,
-> = R extends { negative: true } ? NegativeBigint<B> : bigint;
+type DefaultValueWhenNegativeIsOn<B extends bigint, R extends Constraints> =
+  R extends Readonly<{ negative: true }> ? NegativeBigint<B> : bigint;
 
-type DefaultValueWhenNonNegativeIsOn<
-  B extends bigint,
-  R extends Constraints,
-> = R extends { nonNegative: true } ? NonNegativeBigint<B> : bigint;
+type DefaultValueWhenNonNegativeIsOn<B extends bigint, R extends Constraints> =
+  R extends Readonly<{ nonNegative: true }> ? NonNegativeBigint<B> : bigint;
 
-type DefaultValueWhenPositiveIsOn<
-  B extends bigint,
-  R extends Constraints,
-> = R extends { positive: true } ? PositiveBigint<B> : bigint;
+type DefaultValueWhenPositiveIsOn<B extends bigint, R extends Constraints> =
+  R extends Readonly<{ positive: true }> ? PositiveBigint<B> : bigint;
 
-type DefaultValueWhenNonPositiveIsOn<
-  B extends bigint,
-  R extends Constraints,
-> = R extends { nonPositive: true } ? NonPositiveBigint<B> : bigint;
+type DefaultValueWhenNonPositiveIsOn<B extends bigint, R extends Constraints> =
+  R extends Readonly<{ nonPositive: true }> ? NonPositiveBigint<B> : bigint;
 
 type NegativeBigint<B extends bigint> = bigint extends B
   ? bigint

package/src/primitives/number.mts

@@ -109,20 +109,22 @@ export function number<C extends Constraints>(
   });
 }
 
-type Constraints = PartialReadonly<{
-  gt: number;
-  gte: number;
-  min: number;
-  lt: number;
-  lte: number;
-  max: number;
-  negative: boolean;
-  nonNegative: boolean;
-  positive: boolean;
-  nonPositive: boolean;
-  multipleOf: number;
-  step: number;
-}>;
+type Constraints = Partial<
+  Readonly<{
+    gt: number;
+    gte: number;
+    min: number;
+    lt: number;
+    lte: number;
+    max: number;
+    negative: boolean;
+    nonNegative: boolean;
+    positive: boolean;
+    nonPositive: boolean;
+    multipleOf: number;
+    step: number;
+  }>
+>;
 
 type DefaultValueType<
   N extends number,
@@ -132,25 +134,17 @@ type DefaultValueType<
   DefaultValueWhenPositiveIsOn<N, R> &
   DefaultValueWhenNonPositiveIsOn<N, R>;
 
-type DefaultValueWhenNegativeIsOn<
-  N extends number,
-  R extends Constraints,
-> = R extends { negative: true } ? NegativeNumber<N> : number;
+type DefaultValueWhenNegativeIsOn<N extends number, R extends Constraints> =
+  R extends Readonly<{ negative: true }> ? NegativeNumber<N> : number;
 
-type DefaultValueWhenNonNegativeIsOn<
-  N extends number,
-  R extends Constraints,
-> = R extends { nonNegative: true } ? NonNegativeNumber<N> : number;
+type DefaultValueWhenNonNegativeIsOn<N extends number, R extends Constraints> =
+  R extends Readonly<{ nonNegative: true }> ? NonNegativeNumber<N> : number;
 
-type DefaultValueWhenPositiveIsOn<
-  N extends number,
-  R extends Constraints,
-> = R extends { positive: true } ? PositiveNumber<N> : number;
+type DefaultValueWhenPositiveIsOn<N extends number, R extends Constraints> =
+  R extends Readonly<{ positive: true }> ? PositiveNumber<N> : number;
 
-type DefaultValueWhenNonPositiveIsOn<
-  N extends number,
-  R extends Constraints,
-> = R extends { nonPositive: true } ? NonPositiveNumber<N> : number;
+type DefaultValueWhenNonPositiveIsOn<N extends number, R extends Constraints> =
+  R extends Readonly<{ nonPositive: true }> ? NonPositiveNumber<N> : number;
 
 type NegativeNumber<N extends number> = number extends N
   ? number

package/src/primitives/string.mts

@@ -112,17 +112,19 @@ export function string<C extends Constraints>(
   });
 }
 
-type Constraints = PartialReadonly<{
-  startsWith: string;
-  endsWith: string;
-  includes: string;
-  uppercase: boolean;
-  lowercase: boolean;
-  nonempty: boolean;
-  minLength: number;
-  maxLength: number;
-  regex: DeepReadonly<RegExp>;
-}>;
+type Constraints = Partial<
+  Readonly<{
+    startsWith: string;
+    endsWith: string;
+    includes: string;
+    uppercase: boolean;
+    lowercase: boolean;
+    nonempty: boolean;
+    minLength: number;
+    maxLength: number;
+    regex: DeepReadonly<RegExp>;
+  }>
+>;
 
 type DefaultValueType<
   S extends string,
@@ -141,56 +143,49 @@ type ConstraintsResultType<R extends Constraints> =
     DefaultValueWhenEndsWithIsOn<R> &
     DefaultValueWhenIncludesIsOn<R>;
 
-type DefaultValueWhenStartsWithIsOn<R extends Constraints> = R extends {
-  startsWith: infer S extends string;
-}
-  ? `${S}${string}`
-  : string;
-
-type DefaultValueWhenEndsWithIsOn<R extends Constraints> = R extends {
-  endsWith: infer E extends string;
-}
-  ? `${string}${E}`
-  : string;
-
-type DefaultValueWhenIncludesIsOn<R extends Constraints> = R extends {
-  includes: infer M extends string;
-}
-  ? `${string}${M}${string}`
-  : string;
-
-type DefaultValueWhenUppercaseIsOn<
-  S extends string,
-  R extends Constraints,
-> = R extends { uppercase: true } ? CastUppercase<S> : string;
-
-type DefaultValueWhenLowercaseIsOn<
-  S extends string,
-  R extends Constraints,
-> = R extends { lowercase: true } ? CastLowercase<S> : string;
+type DefaultValueWhenStartsWithIsOn<R extends Constraints> =
+  R extends Readonly<{
+    startsWith: infer S extends string;
+  }>
+    ? `${S}${string}`
+    : string;
+
+type DefaultValueWhenEndsWithIsOn<R extends Constraints> =
+  R extends Readonly<{
+    endsWith: infer E extends string;
+  }>
+    ? `${string}${E}`
+    : string;
+
+type DefaultValueWhenIncludesIsOn<R extends Constraints> =
+  R extends Readonly<{
+    includes: infer M extends string;
+  }>
+    ? `${string}${M}${string}`
+    : string;
+
+type DefaultValueWhenUppercaseIsOn<S extends string, R extends Constraints> =
+  R extends Readonly<{ uppercase: true }> ? CastUppercase<S> : string;
+
+type DefaultValueWhenLowercaseIsOn<S extends string, R extends Constraints> =
+  R extends Readonly<{ lowercase: true }> ? CastLowercase<S> : string;
 
 type CastLowercase<S extends string> = S extends Lowercase<S> ? S : never;
 
 type CastUppercase<S extends string> = S extends Uppercase<S> ? S : never;
 
-type DefaultValueWhenNonemptyIsOn<
-  S extends string,
-  R extends Constraints,
-> = R extends { nonempty: true } ? NonEmptyString<S> : string;
+type DefaultValueWhenNonemptyIsOn<S extends string, R extends Constraints> =
+  R extends Readonly<{ nonempty: true }> ? NonEmptyString<S> : string;
 
-type DefaultValueWhenMinLengthIsOn<
-  S extends string,
-  R extends Constraints,
-> = R extends { minLength: infer M extends number }
-  ? StringWithMinLength<S, M>
-  : string;
+type DefaultValueWhenMinLengthIsOn<S extends string, R extends Constraints> =
+  R extends Readonly<{ minLength: infer M extends number }>
+    ? StringWithMinLength<S, M>
+    : string;
 
-type DefaultValueWhenMaxLengthIsOn<
-  S extends string,
-  R extends Constraints,
-> = R extends { maxLength: infer M extends number }
-  ? StringWithMaxLength<S, M>
-  : string;
+type DefaultValueWhenMaxLengthIsOn<S extends string, R extends Constraints> =
+  R extends Readonly<{ maxLength: infer M extends number }>
+    ? StringWithMaxLength<S, M>
+    : string;
 
 type NonEmptyString<S extends string> = string extends S
   ? string
@@ -207,7 +202,7 @@ type StringWithMaxLength<S extends string, N extends number> =
 type HasLengthAtLeast<
   S extends string,
   N extends number,
-  Acc extends unknown[] = [],
+  Acc extends readonly unknown[] = readonly [],
 > = string extends S
   ? true
   : IsNegative<N> extends true
@@ -217,13 +212,13 @@ type HasLengthAtLeast<
       : S extends ''
         ? false
         : S extends `${infer _}${infer Rest}`
-          ? HasLengthAtLeast<Rest, N, [...Acc, unknown]>
+          ? HasLengthAtLeast<Rest, N, readonly [...Acc, unknown]>
           : false;
 
 type HasLengthAtMost<
   S extends string,
   N extends number,
-  Acc extends unknown[] = [],
+  Acc extends readonly unknown[] = readonly [],
 > = string extends S
   ? true
   : IsNegative<N> extends true
@@ -233,7 +228,7 @@ type HasLengthAtMost<
       : Acc['length'] extends N
         ? false
         : S extends `${infer _}${infer Rest}`
-          ? HasLengthAtMost<Rest, N, [...Acc, unknown]>
+          ? HasLengthAtMost<Rest, N, readonly [...Acc, unknown]>
           : false;
 
 type IsNegative<N extends number> = `${N}` extends `-${string}` ? true : false;

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

@@ -17,9 +17,11 @@ type RecordResultType<
 export const keyValueRecord = <K extends Type<string>, V extends Type<unknown>>(
   keyType: K,
   valueType: V,
-  options?: PartialReadonly<{
-    typeName: string;
-  }>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
 ): Type<RecordResultType<K, V>> => {
   type T = RecordResultType<K, V>;
 

package/src/record/keyof.mts

@@ -5,9 +5,11 @@ import { type RecordType, type Type } from '../type.mjs';
 
 export const keyof = <const R extends ReadonlyRecord<string, Type<unknown>>>(
   recordType: RecordType<R>,
-  options?: PartialReadonly<{
-    typeName: string;
-  }>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
 ): KeyofType<R> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   pipe(getKeys(recordType)).map((keys) =>
@@ -22,7 +24,11 @@ const getKeys = <const R extends ReadonlyRecord<string, Type<unknown>>>(
   recordType: RecordType<R>,
 ): readonly ToString<keyof R>[] =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  Object.keys(recordType.shape) satisfies string[] as ToString<keyof R>[];
+  Object.keys(
+    recordType.shape,
+  ) satisfies readonly string[] as readonly string[] as readonly ToString<
+    keyof R
+  >[];
 
 type KeyofTypeSub<R extends ReadonlyRecord<string, Type<unknown>>> = Type<
   ToString<keyof R>
@@ -34,24 +40,26 @@ type KeyofType<R extends ReadonlyRecord<string, Type<unknown>>> =
 // 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'>('=');
+expectType<ToString<keyof Readonly<{ 1: 1; 2: 2; 3: 3 }>>, '1' | '2' | '3'>(
+  '=',
+);
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 expectType<KeyofType<{}>, Type<undefined>>('=');
 
 expectType<
-  KeyofType<{ a: Type<0>; b: Type<1>; c: Type<2> }>,
+  KeyofType<Readonly<{ a: Type<0>; b: Type<1>; c: Type<2> }>>,
   Type<'a' | 'b' | 'c'>
 >('=');
 
 expectType<
-  KeyofType<{ x: Type<string>; y: Type<number>; z: Type<boolean> }>,
+  KeyofType<Readonly<{ x: Type<string>; y: Type<number>; z: Type<boolean> }>>,
   Type<'x' | 'y' | 'z'>
 >('=');
 
 expectType<
-  KeyofType<{ same: Type<string>; value: Type<string> }>,
+  KeyofType<Readonly<{ same: Type<string>; value: Type<string> }>>,
   Type<'same' | 'value'>
 >('=');
 
-expectType<KeyofType<{ never: Type<never> }>, Type<'never'>>('=');
+expectType<KeyofType<Readonly<{ never: Type<never> }>>, Type<'never'>>('=');