ts-fortress 2.2.2 → 2.3.0

package/dist/compose/index.d.mts

@@ -1,4 +1,5 @@
 export * from './intersection.mjs';
 export * from './merge-records.mjs';
+export * from './recursion.mjs';
 export * from './union.mjs';
 //# sourceMappingURL=index.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/compose/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/compose/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/compose/index.mjs

@@ -1,4 +1,5 @@
 export { intersection } from './intersection.mjs';
 export { mergeRecords } from './merge-records.mjs';
+export { recursion } from './recursion.mjs';
 export { union } from './union.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/compose/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/compose/recursion.d.mts

@@ -0,0 +1,5 @@
+import { type Type } from '../type.mjs';
+export declare const recursion: <A>(typeName: string, definition: () => Type<A>, options?: Partial<Readonly<{
+    defaultValue: A;
+}>>) => Type<A>;
+//# sourceMappingURL=recursion.d.mts.map

package/dist/compose/recursion.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursion.d.mts","sourceRoot":"","sources":["../../src/compose/recursion.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAGxC,eAAO,MAAM,SAAS,GAAI,CAAC,EACzB,UAAU,MAAM,EAChB,YAAY,MAAM,IAAI,CAAC,CAAC,CAAC,EACzB,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,YAAY,EAAE,CAAC,CAAC;CACjB,CAAC,CACH,KACA,IAAI,CAAC,CAAC,CAqCR,CAAC"}

package/dist/compose/recursion.mjs

@@ -0,0 +1,38 @@
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+import 'ts-data-forge';
+
+const recursion = (typeName, definition, options) => {
+    const cache = {
+        innerType: undefined,
+        computedDefaultValue: undefined,
+    };
+    const getInnerType = () => {
+        // eslint-disable-next-line functional/immutable-data
+        cache.innerType ??= definition();
+        return cache.innerType;
+    };
+    const validate = (a) => getInnerType().validate(a);
+    const is = createIsFn(validate);
+    const fill = (a) => getInnerType().fill(a);
+    return {
+        typeName,
+        get defaultValue() {
+            if (options?.defaultValue !== undefined) {
+                return options.defaultValue;
+            }
+            // eslint-disable-next-line functional/immutable-data
+            cache.computedDefaultValue ??= getInnerType().defaultValue;
+            return cache.computedDefaultValue;
+        },
+        fill,
+        validate,
+        is,
+        assertIs: createAssertFn(validate),
+        cast: createCastFn(validate),
+    };
+};
+
+export { recursion };
+//# sourceMappingURL=recursion.mjs.map

package/dist/compose/recursion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursion.mjs","sources":["../../src/compose/recursion.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAGO,MAAM,SAAS,GAAG,CACvB,QAAgB,EAChB,UAAyB,EACzB,OAIC,KACU;AACX,IAAA,MAAM,KAAK,GAGP;AACF,QAAA,SAAS,EAAE,SAAgC;AAC3C,QAAA,oBAAoB,EAAE,SAA0B;KACjD;IAED,MAAM,YAAY,GAAG,MAAc;;AAEjC,QAAA,KAAK,CAAC,SAAS,KAAK,UAAU,EAAE;QAChC,OAAO,KAAK,CAAC,SAAS;AACxB,IAAA,CAAC;AAED,IAAA,MAAM,QAAQ,GAAwB,CAAC,CAAC,KAAK,YAAY,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvE,IAAA,MAAM,EAAE,GAAG,UAAU,CAAI,QAAQ,CAAC;AAElC,IAAA,MAAM,IAAI,GAAoB,CAAC,CAAC,KAAK,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAE3D,OAAO;QACL,QAAQ;AACR,QAAA,IAAI,YAAY,GAAA;AACd,YAAA,IAAI,OAAO,EAAE,YAAY,KAAK,SAAS,EAAE;gBACvC,OAAO,OAAO,CAAC,YAAY;YAC7B;;AAEA,YAAA,KAAK,CAAC,oBAAoB,KAAK,YAAY,EAAE,CAAC,YAAY;YAC1D,OAAO,KAAK,CAAC,oBAAoB;QACnC,CAAC;QACD,IAAI;QACJ,QAAQ;QACR,EAAE;AACF,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;AAClC,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;KAC7B;AACH;;;;"}

package/dist/index.mjs

@@ -23,6 +23,7 @@ export { simpleBrandedNumber } from './branded/simple-branded-number.mjs';
 export { simpleBrandedString } from './branded/simple-branded-string.mjs';
 export { intersection } from './compose/intersection.mjs';
 export { mergeRecords } from './compose/merge-records.mjs';
+export { recursion } from './compose/recursion.mjs';
 export { union } from './compose/union.mjs';
 export { enumType } from './enum/enum.mjs';
 export { uintRange } from './enum/uint-range.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/package.json

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

package/src/compose/index.mts

@@ -1,3 +1,4 @@
 export * from './intersection.mjs';
 export * from './merge-records.mjs';
+export * from './recursion.mjs';
 export * from './union.mjs';

package/src/compose/recursion.mts

@@ -0,0 +1,49 @@
+import { type Type } from '../type.mjs';
+import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
+
+export const recursion = <A,>(
+  typeName: string,
+  definition: () => Type<A>,
+  options?: Partial<
+    Readonly<{
+      defaultValue: A;
+    }>
+  >,
+): Type<A> => {
+  const cache: {
+    innerType: Type<A> | undefined;
+    computedDefaultValue: A | undefined;
+  } = {
+    innerType: undefined as Type<A> | undefined,
+    computedDefaultValue: undefined as A | undefined,
+  };
+
+  const getInnerType = (): Type<A> => {
+    // eslint-disable-next-line functional/immutable-data
+    cache.innerType ??= definition();
+    return cache.innerType;
+  };
+
+  const validate: Type<A>['validate'] = (a) => getInnerType().validate(a);
+
+  const is = createIsFn<A>(validate);
+
+  const fill: Type<A>['fill'] = (a) => getInnerType().fill(a);
+
+  return {
+    typeName,
+    get defaultValue(): A {
+      if (options?.defaultValue !== undefined) {
+        return options.defaultValue;
+      }
+      // eslint-disable-next-line functional/immutable-data
+      cache.computedDefaultValue ??= getInnerType().defaultValue;
+      return cache.computedDefaultValue;
+    },
+    fill,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/compose/recursion.test.mts

@@ -0,0 +1,234 @@
+import { expectType } from 'ts-data-forge';
+import { array } from '../array/index.mjs';
+import { boolean, nullType, number, string } from '../primitives/index.mjs';
+import { keyValueRecord, record } from '../record/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { recursion } from './recursion.mjs';
+import { union } from './union.mjs';
+
+describe('recursive', () => {
+  // Define JsonPrimitive type
+  const JsonPrimitive = union([nullType, number(), string(), boolean()]);
+
+  type JsonPrimitive = TypeOf<typeof JsonPrimitive>;
+
+  test('JsonPrimitive.defaultValue', () => {
+    expectType<JsonPrimitive, null | boolean | number | string>('=');
+
+    expect(JsonPrimitive.defaultValue).toBeNull();
+  });
+
+  // Define recursive JsonValue type
+  type JsonValue =
+    | JsonPrimitive
+    | Readonly<{
+        [k: string]: JsonValue;
+      }>
+    | readonly JsonValue[];
+
+  const JsonValue: Type<JsonValue> = recursion('JsonValue', () =>
+    union([
+      JsonPrimitive,
+      keyValueRecord(string(), JsonValue),
+      array(JsonValue),
+    ]),
+  );
+
+  test('JsonValue.defaultValue', () => {
+    expectType<TypeOf<typeof JsonValue>, JsonValue>('=');
+
+    expect(JsonValue.defaultValue).toBeNull();
+  });
+
+  test('JsonValue - primitive values', () => {
+    expect(JsonValue.is(true)).toBe(true);
+    expect(JsonValue.is(false)).toBe(true);
+    expect(JsonValue.is(42)).toBe(true);
+    expect(JsonValue.is(3.14)).toBe(true);
+    expect(JsonValue.is('hello')).toBe(true);
+    expect(JsonValue.is(null)).toBe(true);
+    expect(JsonValue.is(undefined)).toBe(false);
+  });
+
+  test('JsonValue - arrays', () => {
+    expect(JsonValue.is([])).toBe(true);
+    expect(JsonValue.is([1, 2, 3])).toBe(true);
+    expect(JsonValue.is(['a', 'b', 'c'])).toBe(true);
+    expect(JsonValue.is([true, false, null])).toBe(true);
+    expect(JsonValue.is([1, 'a', true, null])).toBe(true);
+  });
+
+  test('JsonValue - objects', () => {
+    expect(JsonValue.is({})).toBe(true);
+    expect(JsonValue.is({ a: 1 })).toBe(true);
+    expect(JsonValue.is({ a: 1, b: 'hello' })).toBe(true);
+    expect(JsonValue.is({ a: 1, b: [1, 2, 3] })).toBe(true);
+  });
+
+  test('JsonValue - nested structures', () => {
+    const nestedData = {
+      name: 'John',
+      age: 30,
+      active: true,
+      address: {
+        street: '123 Main St',
+        city: 'New York',
+        coordinates: {
+          lat: 40.7128,
+          lon: -74.006,
+        },
+      },
+      hobbies: ['reading', 'coding', 'gaming'],
+      scores: [95, 87, 92],
+      metadata: null,
+      tags: [],
+      settings: {
+        theme: 'dark',
+        notifications: {
+          email: true,
+          push: false,
+        },
+      },
+    };
+
+    expect(JsonValue.is(nestedData)).toBe(true);
+  });
+
+  test('JsonValue - deeply nested arrays', () => {
+    const deepArray = [
+      [
+        [1, 2, 3],
+        [4, 5, 6],
+      ],
+      [
+        [7, 8, 9],
+        [10, 11, 12],
+      ],
+    ];
+
+    expect(JsonValue.is(deepArray)).toBe(true);
+  });
+
+  test('JsonValue - mixed nested structure', () => {
+    const mixedData = {
+      users: [
+        {
+          id: 1,
+          name: 'Alice',
+          tasks: [
+            { id: 'task1', completed: true },
+            { id: 'task2', completed: false },
+          ],
+        },
+        {
+          id: 2,
+          name: 'Bob',
+          tasks: [],
+        },
+      ],
+      config: {
+        version: '1.0.0',
+        features: ['feature1', 'feature2'],
+        settings: {
+          debug: false,
+          timeout: 5000,
+        },
+      },
+    };
+
+    expect(JsonValue.is(mixedData)).toBe(true);
+  });
+
+  test('JsonValue - invalid values', () => {
+    expect(JsonValue.is(undefined)).toBe(false);
+    expect(JsonValue.is(Symbol('test'))).toBe(false);
+    expect(JsonValue.is(() => 'function')).toBe(false);
+
+    // Note: keyValueRecord accepts any object with string keys, including Date/Set/Map
+    // This is expected behavior for keyValueRecord, which doesn't distinguish
+    // between plain objects and other object instances
+  });
+
+  test('JsonValue - cast function', () => {
+    const result = JsonValue.cast({ a: 1, b: [2, 3], c: { d: 'hello' } });
+    expect(result).toStrictEqual({ a: 1, b: [2, 3], c: { d: 'hello' } });
+  });
+
+  test('JsonValue - fill function', () => {
+    const result = JsonValue.fill({ a: 1, b: [2, 3] });
+    expect(result).toStrictEqual({ a: 1, b: [2, 3] });
+
+    // Fill with default value for invalid input
+    const defaultResult = JsonValue.fill(undefined);
+    expect(JsonValue.is(defaultResult)).toBe(true);
+  });
+
+  // Test other recursive structures
+  test('Linked list structure', () => {
+    type LinkedList<T> = { value: T; next: LinkedList<T> | null };
+
+    const LinkedListNumber: Type<LinkedList<number>> = recursion(
+      'LinkedList<number>',
+      () =>
+        record({
+          value: number(0),
+          next: union([nullType, LinkedListNumber]),
+        }),
+      { defaultValue: { value: 0, next: null } },
+    );
+
+    const list: LinkedList<number> = {
+      value: 1,
+      next: {
+        value: 2,
+        next: {
+          value: 3,
+          next: null,
+        },
+      },
+    };
+
+    expect(LinkedListNumber.is(list)).toBe(true);
+    expect(LinkedListNumber.is({ value: 1, next: null })).toBe(true);
+    expect(LinkedListNumber.is({ value: 'not a number', next: null })).toBe(
+      false,
+    );
+  });
+
+  test('Tree structure', () => {
+    type TreeNode<T> = Readonly<{
+      value: T;
+      children: readonly TreeNode<T>[];
+    }>;
+
+    const TreeNodeString: Type<TreeNode<string>> = recursion(
+      'TreeNode<string>',
+      () =>
+        record({
+          value: string(),
+          children: array(TreeNodeString),
+        }),
+    );
+
+    const tree: TreeNode<string> = {
+      value: 'root',
+      children: [
+        {
+          value: 'branch1',
+          children: [
+            { value: 'leaf1', children: [] },
+            { value: 'leaf2', children: [] },
+          ],
+        },
+        {
+          value: 'branch2',
+          children: [{ value: 'leaf3', children: [] }],
+        },
+      ],
+    };
+
+    expect(TreeNodeString.is(tree)).toBe(true);
+    expect(TreeNodeString.is({ value: 'node', children: [] })).toBe(true);
+    expect(TreeNodeString.is({ value: 123, children: [] })).toBe(false);
+  });
+});