@strictly/react-form 0.0.1 → 0.0.2

package/types/specs/merge_validators.tests.ts

@@ -0,0 +1,267 @@
+import {
+  type AnnotatedValidator,
+  annotations,
+  type FunctionalValidator,
+  validate,
+  type Validator,
+} from '@strictly/define'
+import {
+  type MergedOfValidators,
+  mergeValidators,
+} from 'types/merge_validators'
+import {
+  type Mock,
+  type Mocked,
+} from 'vitest'
+import {
+  mock,
+  mockReset,
+} from 'vitest-mock-extended'
+
+describe('MergedOfValidators', function () {
+  describe('empty validators 1', function () {
+    type Validators1 = {
+      readonly a: Validator<string, 'error a', 'a', null>,
+      readonly b: Validator<number, 'error b', 'b', null>,
+    }
+    type Validators2 = {}
+
+    type Validators = MergedOfValidators<Validators1, Validators2>
+
+    it('equals the expected type', function () {
+      expectTypeOf<Validators>().toEqualTypeOf<Validators1>()
+    })
+  })
+
+  describe('empty validators 2', function () {
+    type Validators1 = {}
+    type Validators2 = {
+      readonly a: Validator<string, 'error a', 'a', null>,
+      readonly b: Validator<number, 'error b', 'b', null>,
+    }
+
+    type Validators = MergedOfValidators<Validators1, Validators2>
+
+    it('equals the expected type', function () {
+      expectTypeOf<Validators>().toEqualTypeOf<Validators2>()
+    })
+  })
+
+  describe('merged validators with different keys', function () {
+    type Validators1 = {
+      a: Validator<string, 'error a', 'a', null>,
+    }
+    type Validators2 = {
+      b: Validator<number, 'error b', 'b', null>,
+    }
+
+    type Validators = MergedOfValidators<Validators1, Validators2>
+
+    it('equals the expected type', function () {
+      expectTypeOf<Validators>().toEqualTypeOf<{
+        readonly a: Validator<string, 'error a', 'a', null>,
+        readonly b: Validator<number, 'error b', 'b', null>,
+      }>()
+    })
+  })
+
+  describe('merged validators with same key', function () {
+    type Validators1 = {
+      a: Validator<string, 'error a', 'a', null>,
+    }
+    type Validators2 = {
+      a: Validator<string, 'error b', 'a', null>,
+    }
+
+    type Validators = MergedOfValidators<Validators1, Validators2>
+
+    it('equals the expected type', function () {
+      expectTypeOf<Validators>().toEqualTypeOf<{
+        readonly a: Validator<string, 'error a' | 'error b', 'a', null>,
+      }>()
+    })
+  })
+})
+
+describe('mergeValidators', function () {
+  describe('functional validators', function () {
+    const validatorA1: Mock<FunctionalValidator<string, 'error a1', 'a', null>> = vi.fn()
+    const validatorA2: Mock<FunctionalValidator<string, 'error a2', 'a', null>> = vi.fn()
+    const validatorB: Mock<FunctionalValidator<boolean, 'error b', 'b', null>> = vi.fn()
+    describe('produces expected type', function () {
+      describe('empty validators 1', function () {
+        const validators1 = {
+          a: validatorA1,
+          b: validatorB,
+        } as const
+        const validators2 = {} as const
+        const validators = mergeValidators(validators1, validators2)
+        it('equals expected value', function () {
+          expect(validators).toEqual(validators1)
+        })
+      })
+
+      describe('empty validators 2', function () {
+        const validators1 = {} as const
+        const validators2 = {
+          a: validatorA1,
+          b: validatorB,
+        } as const
+        const validators = mergeValidators(validators1, validators2)
+        it('equals expected value', function () {
+          expect(validators).toEqual(validators2)
+        })
+      })
+
+      describe('merged validators with different keys', function () {
+        const validators1 = {
+          a: validatorA1,
+        } as const
+        const validators2 = {
+          b: validatorB,
+        } as const
+        const validators = mergeValidators(validators1, validators2)
+        it('equals expected value', function () {
+          expect(validators).toEqual({
+            a: validatorA1,
+            b: validatorB,
+          })
+        })
+      })
+
+      describe('merged validators with same key', function () {
+        const validators1 = {
+          a: validatorA1,
+        } as const
+        const validators2 = {
+          a: validatorA2,
+        } as const
+        const validators = mergeValidators(validators1, validators2)
+        it('has the expected keys', function () {
+          expect(Array.from(Object.keys(validators))).toEqual(['a'])
+        })
+
+        it('reports no error when validators report no error', function () {
+          const result = validate(validators.a, 'x', 'a', null)
+          expect(result).toBeUndefined()
+        })
+
+        it('reports an error from first validator', function () {
+          validatorA1.mockReturnValueOnce('error a1')
+
+          const result = validate(validators.a, 'x', 'a', null)
+          expect(result).toEqual('error a1')
+        })
+
+        it('reports an error from second validator', function () {
+          validatorA2.mockReturnValueOnce('error a2')
+
+          const result = validate(validators.a, 'x', 'a', null)
+          expect(result).toEqual('error a2')
+        })
+      })
+    })
+  })
+
+  describe('annotated validators', function () {
+    const validatorA1: Mocked<AnnotatedValidator<string, 'error a1', 'a', null>> = mock()
+    const validatorA2: Mocked<AnnotatedValidator<string, 'error a2', 'a', null>> = mock()
+
+    beforeEach(function () {
+      mockReset(validatorA1)
+      mockReset(validatorA2)
+    })
+
+    const validators1 = {
+      a: validatorA1,
+    } as const
+    const validators2 = {
+      a: validatorA2,
+    } as const
+    const validators = mergeValidators(validators1, validators2)
+
+    describe.each([
+      [
+        false,
+        false,
+        false,
+      ],
+      [
+        false,
+        true,
+        true,
+      ],
+      [
+        true,
+        false,
+        true,
+      ],
+      [
+        true,
+        true,
+        true,
+      ],
+    ] as const)('required', function (required1, required2, required) {
+      beforeEach(function () {
+        validatorA1.validate.mockReturnValue('error a1')
+        validatorA1.annotations.mockReturnValue({
+          required: required1,
+          readonly: false,
+        })
+        validatorA2.annotations.mockReturnValue({
+          required: required2,
+          readonly: false,
+        })
+      })
+
+      it('has the expected required value', function () {
+        expect(annotations(validators.a, 'a', null)).toEqual({
+          required,
+          readonly: false,
+        })
+      })
+    })
+
+    describe.each([
+      [
+        false,
+        false,
+        false,
+      ],
+      [
+        false,
+        true,
+        true,
+      ],
+      [
+        true,
+        false,
+        true,
+      ],
+      [
+        true,
+        true,
+        true,
+      ],
+    ] as const)('required', function (readonly1, readonly2, readonly) {
+      beforeEach(function () {
+        validatorA1.validate.mockReturnValue('error a1')
+        validatorA1.annotations.mockReturnValue({
+          required: false,
+          readonly: readonly1,
+        })
+        validatorA2.annotations.mockReturnValue({
+          required: false,
+          readonly: readonly2,
+        })
+      })
+
+      it('has the expected required value', function () {
+        expect(annotations(validators.a, 'a', null)).toEqual({
+          required: false,
+          readonly,
+        })
+      })
+    })
+  })
+})

package/util/partial.tsx

@@ -1,3 +1,4 @@
+import { type FriendlyExhaustiveArrayOfUnion } from '@strictly/base'
 import { observer } from 'mobx-react'
 import {
   type ComponentProps,
@@ -60,28 +61,79 @@ export function createSimplePartialComponent<
   ) as PartialComponent<Component, CurriedProps>
 }
 
+export function createPartialComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+>(
+  Component: Component,
+  curriedPropsSource: () => CurriedProps,
+): PartialComponent<Component, CurriedProps, {}>
+export function createPartialComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+  AdditionalProps,
+  AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[],
+>(
+  Component: Component,
+  curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>,
+): PartialComponent<Component, CurriedProps, AdditionalProps>
 export function createPartialComponent<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Component extends ComponentType<any>,
   CurriedProps extends Partial<ComponentProps<Component>>,
-  AdditionalProps = {},
+  AdditionalProps,
 >(
   Component: Component,
   curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  additionalPropKeys: readonly (keyof AdditionalProps)[] = [],
 ): PartialComponent<Component, CurriedProps, AdditionalProps> {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return forwardRef(
     function (
-      exposedProps: PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>,
+      props: PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>,
       ref: ForwardedRef<typeof Component>,
     ) {
       // forward ref types are really difficult to work with
       // still needs a cast as `extends ComponentType<any>` != `ComponentType<any>`
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion
       const C = Component as ComponentType<any>
+      const [
+        additionalProps,
+        exposedProps,
+      ] = additionalPropKeys.reduce<[AdditionalProps, RemainingComponentProps<Component, CurriedProps>]>(
+        function (
+          [
+            additionalProps,
+            exposedProps,
+          ],
+          key,
+        ) {
+          const value = props[
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            key as keyof PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>
+          ]
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          delete exposedProps[key as keyof RemainingComponentProps<Component, CurriedProps>]
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+          additionalProps[key] = value as any
+          return [
+            additionalProps,
+            exposedProps,
+          ]
+        },
+        [
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          {} as AdditionalProps,
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          { ...props } as RemainingComponentProps<Component, CurriedProps>,
+        ],
+      )
+
       // TODO is there any way we can memoize this transformation?
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const curriedProps = curriedPropsSource(exposedProps as AdditionalProps)
+      const curriedProps = curriedPropsSource(additionalProps)
 
       return (
         <C
@@ -94,69 +146,173 @@ export function createPartialComponent<
   ) as PartialComponent<Component, CurriedProps, AdditionalProps>
 }
 
+export function usePartialComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+>(
+  curriedPropsSource: () => CurriedProps,
+  deps: DependencyList,
+  Component: Component,
+): PartialComponent<Component, CurriedProps, {}>
+export function usePartialComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+  AdditionalProps,
+  AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[],
+>(
+  curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  deps: DependencyList,
+  Component: Component,
+  additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>,
+): PartialComponent<Component, CurriedProps, AdditionalProps>
 export function usePartialComponent<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Component extends ComponentType<any>,
   CurriedProps extends Partial<ComponentProps<Component>>,
-  AdditionalProps = {},
+  AdditionalProps,
 >(
   // has to be first so eslint react-hooks/exhaustive-deps can find the callback
   // has to be a function so eslint react-hooks/exhaustive-deps can reason about it :(
-  createCurriedProps: (additionalProps: AdditionalProps) => CurriedProps,
+  curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
   // has to be next so eslint react-hooks/exhaustive-deps can find the deps
   deps: DependencyList,
   Component: Component,
+  additionalPropKeys: readonly (keyof AdditionalProps)[] = [],
 ): PartialComponent<Component, CurriedProps, AdditionalProps> {
   return useMemo(
     function () {
-      return createPartialComponent<Component, CurriedProps, AdditionalProps>(Component, createCurriedProps)
+      return createPartialComponent(
+        Component,
+        curriedPropsSource,
+        additionalPropKeys,
+      )
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
       // eslint-disable-next-line react-hooks/exhaustive-deps
       ...deps,
       Component,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      ...additionalPropKeys,
     ],
   )
 }
 
+export function createPartialObserverComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+>(
+  Component: Component,
+  curriedPropsSource: () => CurriedProps,
+): PartialComponent<Component, CurriedProps, {}>
+export function createPartialObserverComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+  AdditionalProps,
+  AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[],
+>(
+  Component: Component,
+  curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>,
+): PartialComponent<Component, CurriedProps, AdditionalProps>
 export function createPartialObserverComponent<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Component extends ComponentType<any>,
   CurriedProps extends Partial<ComponentProps<Component>>,
-  AdditionalProps = {},
+  AdditionalProps,
 >(
   Component: Component,
   curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  additionalPropKeys: readonly (keyof AdditionalProps)[] = [],
 ): PartialComponent<Component, CurriedProps, AdditionalProps> {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return createUnsafePartialObserverComponent(Component, curriedPropsSource) as PartialComponent<Component,
-    CurriedProps, AdditionalProps>
+  return createUnsafePartialObserverComponent(
+    Component,
+    curriedPropsSource,
+    additionalPropKeys,
+  ) as PartialComponent<Component, CurriedProps, AdditionalProps>
 }
 
 export function createUnsafePartialObserverComponent<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Component extends ComponentType<any>,
   CurriedProps,
-  AdditionalProps = {},
+>(
+  Component: Component,
+  curriedPropsSource: () => CurriedProps,
+): UnsafePartialComponent<Component, CurriedProps, {}>
+export function createUnsafePartialObserverComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+  AdditionalProps,
+  AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[],
 >(
   Component: Component,
   curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>,
+): UnsafePartialComponent<Component, CurriedProps, AdditionalProps>
+export function createUnsafePartialObserverComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+  AdditionalProps = {},
+>(
+  Component: Component,
+  curriedPropsSource: (additionalProps?: AdditionalProps) => CurriedProps,
+  additionalPropKeys: readonly (keyof AdditionalProps)[] = [],
 ): UnsafePartialComponent<Component, CurriedProps, AdditionalProps> {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return observer(
     forwardRef(
       function (
-        exposedProps: PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>,
+        props: PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>,
         ref: ForwardedRef<typeof Component>,
       ) {
         // forward ref types are really difficult to work with
         // still needs a cast as `extends ComponentType<any>` != `ComponentType<any>`
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-assertion
         const C = Component as ComponentType<any>
+        // remove the additional props from the exposed props that get passed in to the component
+        // as this generates react warnings
+        const [
+          additionalProps,
+          exposedProps,
+        ] = additionalPropKeys.reduce<[AdditionalProps, RemainingComponentProps<Component, CurriedProps>]>(
+          function (
+            [
+              additionalProps,
+              exposedProps,
+            ],
+            key,
+          ) {
+            const value = props[
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              key as keyof PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>
+            ]
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            delete exposedProps[key as keyof RemainingComponentProps<Component, CurriedProps>]
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+            additionalProps[key] = value as any
+            return [
+              additionalProps,
+              exposedProps,
+            ]
+          },
+          [
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            {} as AdditionalProps,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            { ...props } as RemainingComponentProps<Component, CurriedProps>,
+          ],
+        )
+
         // TODO is there any way we can memoize this transformation?
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const curriedProps = curriedPropsSource(exposedProps as AdditionalProps)
+        const curriedProps = curriedPropsSource(additionalProps)
 
         return (
           <C
@@ -170,6 +326,27 @@ export function createUnsafePartialObserverComponent<
   ) as UnsafePartialComponent<Component, CurriedProps, AdditionalProps>
 }
 
+export function usePartialObserverComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+>(
+  curriedPropsSource: () => CurriedProps,
+  deps: DependencyList,
+  Component: Component,
+): PartialComponent<Component, CurriedProps, {}>
+export function usePartialObserverComponent<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Component extends ComponentType<any>,
+  CurriedProps,
+  AdditionalProps,
+  AllAdditionalPropKeys extends readonly (keyof AdditionalProps)[],
+>(
+  curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps,
+  deps: DependencyList,
+  Component: Component,
+  additionalPropKeys: FriendlyExhaustiveArrayOfUnion<keyof AdditionalProps, AllAdditionalPropKeys>,
+): PartialComponent<Component, CurriedProps, AdditionalProps>
 export function usePartialObserverComponent<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Component extends ComponentType<any>,
@@ -181,16 +358,23 @@ export function usePartialObserverComponent<
   // has to be next so eslint react-hooks/exhaustive-deps can find the deps
   deps: DependencyList,
   Component: Component,
-) {
+  additionalPropKeys: readonly (keyof AdditionalProps)[] = [],
+): PartialComponent<Component, CurriedProps, AdditionalProps> {
   return useMemo(
     function () {
-      return createPartialObserverComponent(Component, curriedPropsSource)
+      return createPartialObserverComponent(
+        Component,
+        curriedPropsSource,
+        additionalPropKeys,
+      )
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
       // eslint-disable-next-line react-hooks/exhaustive-deps
       ...deps,
       Component,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      ...additionalPropKeys,
     ],
   )
 }

package/.out/core/mobx/flattened_list_type_defs_of.d.ts

@@ -1,8 +0,0 @@
-import { type FlattenedTypeDefsOf, type ListTypeDef, type Type } from '@strictly/define';
-import { type SimplifyDeep } from 'type-fest';
-export type ListJsonPathsOf<T extends Type> = keyof FlattenedListTypeDefsOf<T>;
-export type FlattenedListTypeDefsOf<T extends Type> = FlattenedListTypeDefsOfFlattened<SimplifyDeep<FlattenedTypeDefsOf<T, null>>>;
-type FlattenedListTypeDefsOfFlattened<T extends Readonly<Record<string, Type>>> = {
-    [K in keyof T as T[K]['definition'] extends ListTypeDef ? K : never]: T[K];
-};
-export {};

package/.out/field_validators/minimum_string_length_field_validator.d.ts

@@ -1,2 +0,0 @@
-import { type FieldValidator } from 'types/field_validator';
-export declare function minimumStringLengthFieldValidatorFactory<E, ValuePath extends string, Context>(minimumLength: number, error: E): FieldValidator<string, E, ValuePath, Context>;

package/.out/field_validators/minimum_string_length_field_validator.js

@@ -1,8 +0,0 @@
-export function minimumStringLengthFieldValidatorFactory(minimumLength, error) {
-    return function (value) {
-        if (value.length < minimumLength) {
-            return error;
-        }
-        return null;
-    };
-}

package/.out/types/error_type_of_field.d.ts

@@ -1,2 +0,0 @@
-import { type Field } from './field';
-export type ErrorTypeOfField<F extends Field> = F extends Field<infer _V, infer E> ? E : never;

package/.out/types/field_validator.d.ts

@@ -1,3 +0,0 @@
-export type FieldValidator<V, E, ValuePath extends string, Context> = {
-    (value: V, valuePath: ValuePath, context: Context): E | null;
-};

package/.out/types/flattened_form_fields_of.d.ts

@@ -1,9 +0,0 @@
-import { type PrintableOf } from '@strictly/base';
-import { type ValueOf } from 'type-fest';
-import { type Field } from './field';
-/**
- * Maps type paths to value paths for
- */
-export type FlattenedFormFieldsOf<JsonPaths extends Record<string, string>, TypePathsToFormFields extends Partial<Readonly<Record<ValueOf<JsonPaths>, Field>>>> = keyof TypePathsToFormFields extends ValueOf<JsonPaths> ? {
-    readonly [K in keyof JsonPaths as unknown extends TypePathsToFormFields[JsonPaths[K]] ? never : K]: TypePathsToFormFields[JsonPaths[K]];
-} : `fields missing paths: ${PrintableOf<Exclude<keyof TypePathsToFormFields, ValueOf<JsonPaths>>>}`;

package/.out/types/specs/flattened_form_fields_of.tests.js

@@ -1,13 +0,0 @@
-describe('FlattenedFormFieldsOf', function () {
-    describe('subset', function () {
-        it('equals expected type', function () {
-            expectTypeOf().toEqualTypeOf();
-        });
-    });
-    describe('overlap', function () {
-        it('errors to callee', function () {
-            expectTypeOf().toEqualTypeOf();
-        });
-    });
-});
-export {};

package/core/mobx/flattened_list_type_defs_of.ts

@@ -1,17 +0,0 @@
-import {
-  type FlattenedTypeDefsOf,
-  type ListTypeDef,
-  type Type,
-} from '@strictly/define'
-import { type SimplifyDeep } from 'type-fest'
-
-export type ListJsonPathsOf<T extends Type> = keyof FlattenedListTypeDefsOf<T>
-
-export type FlattenedListTypeDefsOf<T extends Type> = FlattenedListTypeDefsOfFlattened<
-  // SimplifyDeep is necessary here otherwise FlattenedListTypeDefsOfFlattened will complain about infinite depth
-  SimplifyDeep<FlattenedTypeDefsOf<T, null>>
->
-
-type FlattenedListTypeDefsOfFlattened<T extends Readonly<Record<string, Type>>> = {
-  [K in keyof T as T[K]['definition'] extends ListTypeDef ? K : never]: T[K]
-}