@ditojs/admin 2.92.0 → 2.94.1

package/types/tests/component-section.test-d.ts

@@ -1,174 +0,0 @@
-import { expectTypeOf, assertType, describe, it } from 'vitest'
-import type { Components, Form } from '../index.d.ts'
-import type { Address, Entry, Parent, ParentWithAddress } from './fixtures.ts'
-
-type ParentWithSection = Parent & {
-  details: never
-}
-
-describe('Section components', () => {
-  it('accepts section with nested components', () => {
-    assertType<Components<ParentWithSection>>({
-      details: {
-        type: 'section',
-        components: {
-          title: { type: 'text' }
-        }
-      }
-    })
-  })
-
-  it('provides typed item in section callbacks', () => {
-    assertType<Components<ParentWithSection>>({
-      details: {
-        type: 'section',
-        label({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.title).toBeString()
-          expectTypeOf(item.entries).toEqualTypeOf<Entry[]>()
-          expectTypeOf(item).not.toHaveProperty('details')
-          return item.title
-        }
-      }
-    })
-  })
-
-  it('rejects invalid component keys in section', () => {
-    assertType<Components<ParentWithSection>>({
-      details: {
-        type: 'section',
-        components: {
-          title: { type: 'text' },
-          // @ts-expect-error 'nonExistent' is not a key of ParentWithSection
-          nonExistent: { type: 'text' }
-        }
-      }
-    })
-  })
-
-  it('accepts section with form prop', () => {
-    const sectionForm: Form<ParentWithSection> = {
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      }
-    }
-
-    assertType<Components<ParentWithSection>>({
-      details: {
-        type: 'section',
-        form: sectionForm
-      }
-    })
-  })
-})
-
-describe('Section tabs', () => {
-  it('accepts tabs on a non-nested section', () => {
-    assertType<Components<ParentWithSection>>({
-      details: {
-        type: 'section',
-        tabs: {
-          general: {
-            type: 'tab',
-            components: {
-              title: { type: 'text' }
-            }
-          }
-        }
-      }
-    })
-  })
-
-  it('accepts tabs on a nested section typed against nested data', () => {
-    assertType<Components<ParentWithAddress>>({
-      address: {
-        type: 'section',
-        nested: true,
-        tabs: {
-          main: {
-            type: 'tab',
-            components: {
-              street: { type: 'text' },
-              city: { type: 'text' }
-            }
-          }
-        }
-      }
-    })
-  })
-})
-
-describe('Nested sections', () => {
-  it('types nested section components against the value type', () => {
-    assertType<Components<ParentWithAddress>>({
-      address: {
-        type: 'section',
-        nested: true,
-        components: {
-          street: { type: 'text' },
-          city: { type: 'text' }
-        }
-      }
-    })
-  })
-
-  it('rejects invalid keys in nested section components', () => {
-    assertType<Components<ParentWithAddress>>({
-      address: {
-        type: 'section',
-        nested: true,
-        components: {
-          street: { type: 'text' },
-          // @ts-expect-error 'zipCode' is not a key of Address
-          zipCode: { type: 'text' }
-        }
-      }
-    })
-  })
-
-  it('types item as Address in nested section callbacks', () => {
-    assertType<Components<ParentWithAddress>>({
-      address: {
-        type: 'section',
-        nested: true,
-        components: {
-          street: {
-            type: 'text',
-            onChange({ item }) {
-              expectTypeOf(item).not.toBeAny()
-              expectTypeOf(item).toEqualTypeOf<Address>()
-            }
-          }
-        }
-      }
-    })
-  })
-
-  it('types nested section form against the value type', () => {
-    assertType<Components<ParentWithAddress>>({
-      address: {
-        type: 'section',
-        nested: true,
-        form: {
-          type: 'form',
-          components: {
-            street: { type: 'text' },
-            city: { type: 'text' }
-          }
-        } satisfies Form<Address>
-      }
-    })
-  })
-
-  it('non-nested section on data key accepts parent item keys', () => {
-    assertType<Components<ParentWithAddress>>({
-      address: {
-        type: 'section',
-        components: {
-          title: { type: 'text' }
-        }
-      }
-    })
-  })
-})

package/types/tests/component-select.test-d.ts

@@ -1,107 +0,0 @@
-import { expectTypeOf, assertType, describe, it } from 'vitest'
-import type { SelectSchema, MultiselectSchema } from '../index.d.ts'
-import type { Entry } from './fixtures.ts'
-
-describe('SelectSchema', () => {
-  it('accepts simple string array options', () => {
-    assertType<SelectSchema<Entry>>({
-      type: 'select',
-      options: ['draft', 'published', 'archived']
-    })
-  })
-
-  it('accepts label/value object options', () => {
-    assertType<SelectSchema<Entry>>({
-      type: 'select',
-      options: [
-        { label: 'Draft', value: 'draft' },
-        { label: 'Published', value: 'published' }
-      ]
-    })
-  })
-
-  it('accepts options with data callback', () => {
-    assertType<SelectSchema<Entry>>({
-      type: 'select',
-      options: {
-        data({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item).toMatchTypeOf<Entry>()
-          return [
-            { label: 'Option A', value: 1 },
-            { label: 'Option B', value: 2 }
-          ]
-        },
-        label: 'label',
-        value: 'value'
-      }
-    })
-  })
-
-  it('accepts relate and relateBy', () => {
-    assertType<SelectSchema<Entry>>({
-      type: 'select',
-      relate: true,
-      relateBy: 'id'
-    })
-  })
-})
-
-describe('MultiselectSchema', () => {
-  it('accepts multiple, searchable, taggable', () => {
-    assertType<MultiselectSchema<Entry>>({
-      type: 'multiselect',
-      multiple: true,
-      searchable: true,
-      taggable: true,
-      stayOpen: true
-    })
-  })
-
-  it('accepts typed $Option with search callback', () => {
-    type Tag = { id: number; name: string }
-
-    assertType<MultiselectSchema<Entry, Tag>>({
-      type: 'multiselect',
-      searchable: true,
-      search({ item, query }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item).toMatchTypeOf<Entry>()
-        expectTypeOf(query).not.toBeAny()
-        expectTypeOf(query).toBeString()
-        return [] as Tag[]
-      },
-      options: {
-        data: [] as Tag[],
-        label: 'name',
-        value: 'id'
-      }
-    })
-  })
-
-  it('accepts label/value as accessor callbacks with typed option', () => {
-    type Tag = { id: number; name: string }
-
-    assertType<MultiselectSchema<Entry, Tag>>({
-      type: 'multiselect',
-      options: {
-        data: [] as Tag[],
-        label({ option }) {
-          expectTypeOf(option).not.toBeAny()
-          return option.name
-        },
-        value({ option }) {
-          expectTypeOf(option).not.toBeAny()
-          return option.id
-        }
-      }
-    })
-  })
-
-  it('rejects invalid type', () => {
-    assertType<MultiselectSchema<Entry>>({
-      // @ts-expect-error 'radio' is not assignable to 'multiselect'
-      type: 'radio'
-    })
-  })
-})

package/types/tests/components.test-d.ts

@@ -1,81 +0,0 @@
-import { expectTypeOf, assertType, describe, it } from 'vitest'
-import type { Component, Components, Form } from '../index.d.ts'
-import type { Entry, Parent, ParentWithMarkers } from './fixtures.ts'
-
-describe('Components', () => {
-  it('accepts data-only components', () => {
-    assertType<Components<Parent>>({
-      title: { type: 'text' }
-    })
-  })
-
-  it('infers array element type for list components', () => {
-    assertType<Components<Parent>>({
-      entries: {
-        type: 'list',
-        form: {
-          type: 'form',
-          components: {
-            title: { type: 'text' }
-          }
-        } satisfies Form<Entry>
-      }
-    })
-  })
-
-  it('accepts UI-only keys for non-data components', () => {
-    assertType<Components<ParentWithMarkers>>({
-      viewButton: {
-        type: 'button',
-        text: 'View',
-        events: {
-          click({ item }) {
-            expectTypeOf(item).not.toBeAny()
-            expectTypeOf(item).toHaveProperty('title')
-            expectTypeOf(item).toHaveProperty('entries')
-            expectTypeOf(item).not.toHaveProperty('viewButton')
-            expectTypeOf(item).not.toHaveProperty('spacer')
-          }
-        }
-      }
-    })
-  })
-
-  it('provides typed item in callbacks for data keys', () => {
-    assertType<Components<Parent>>({
-      title: {
-        type: 'text',
-        format({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.title).toBeString()
-          expectTypeOf(item.entries).toEqualTypeOf<Entry[]>()
-        }
-      }
-    })
-  })
-})
-
-describe('Components negative tests', () => {
-  it('rejects unknown keys', () => {
-    assertType<Components<Parent>>({
-      title: { type: 'text' },
-      // @ts-expect-error 'nonExistent' is not a key of Parent
-      nonExistent: { type: 'text' }
-    })
-  })
-})
-
-describe('Components<any> compatibility', () => {
-  it('Components<Specific> is assignable to Components<any>', () => {
-    const specific: Components<Parent> = {
-      title: { type: 'text' }
-    }
-    assertType<Components<any>>(specific)
-  })
-
-  it('Component<Specific> is assignable to Component<any>', () => {
-    const specific: Component<Parent> = { type: 'text' }
-    assertType<Component<any>>(specific)
-    assertType<Component>(specific)
-  })
-})

package/types/tests/context.test-d.ts

@@ -1,31 +0,0 @@
-import { expectTypeOf, assertType, describe, it } from 'vitest'
-import type { DitoContext, OrItemAccessor } from '../index.d.ts'
-import type { Entry, ParentWithMarkers } from './fixtures.ts'
-
-describe('DitoContext', () => {
-  it('item strips never keys', () => {
-    type Ctx = DitoContext<ParentWithMarkers>
-    expectTypeOf<Ctx['item']>().not.toBeAny()
-    expectTypeOf<Ctx['item']>().toHaveProperty('id')
-    expectTypeOf<Ctx['item']>().toHaveProperty('title')
-    expectTypeOf<Ctx['item']>().toHaveProperty('entries')
-    expectTypeOf<Ctx['item']>().not.toHaveProperty('viewButton')
-    expectTypeOf<Ctx['item']>().not.toHaveProperty('spacer')
-  })
-
-  it('item preserves data keys', () => {
-    type Ctx = DitoContext<Entry>
-    expectTypeOf<Ctx['item']>().not.toBeAny()
-    expectTypeOf<Ctx['item']>().toEqualTypeOf<{
-      id: number
-      title: string
-    }>()
-  })
-
-  it('OrItemAccessor accepts value or callback', () => {
-    assertType<OrItemAccessor<Entry, {}, string>>('hello')
-    assertType<OrItemAccessor<Entry, {}, string>>(
-      (ctx: DitoContext<Entry>) => ctx.item.title
-    )
-  })
-})

package/types/tests/fixtures.ts

@@ -1,24 +0,0 @@
-export type Entry = {
-  id: number
-  title: string
-}
-
-export type Parent = {
-  id: number
-  title: string
-  entries: Entry[]
-}
-
-export type ParentWithMarkers = Parent & {
-  viewButton: never
-  spacer: never
-}
-
-export type Address = {
-  street: string
-  city: string
-}
-
-export type ParentWithAddress = Parent & {
-  address: Address
-}

package/types/tests/form.test-d.ts

@@ -1,109 +0,0 @@
-import { expectTypeOf, assertType, describe, it } from 'vitest'
-import type { Form, ResolvableForm } from '../index.d.ts'
-import type { Entry, Parent } from './fixtures.ts'
-
-describe('Form assignability', () => {
-  it('Form<Specific> is assignable to Form<any>', () => {
-    const specific: Form<Entry> = {
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      }
-    }
-    assertType<Form<any>>(specific)
-  })
-
-  it('Form<Specific> is assignable to ResolvableForm', () => {
-    const specific: Form<Entry> = {
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      }
-    }
-    assertType<ResolvableForm>(specific)
-  })
-
-  it('Record<string, Form<$Item>> is assignable to ResolvableForm<$Item>', () => {
-    const module: Record<string, Form<Entry>> = {
-      entryForm: { type: 'form', components: {} }
-    }
-    assertType<ResolvableForm<Entry>>(module)
-  })
-
-  it('Record<string, Form<WrongType>> is not assignable to ResolvableForm<$Item>', () => {
-    const module: Record<string, Form<Parent>> = {
-      parentForm: { type: 'form', components: {} }
-    }
-    // @ts-expect-error Form<Parent> should not be assignable to ResolvableForm<Entry>
-    assertType<ResolvableForm<Entry>>(module)
-  })
-
-  it('() => import() pattern is assignable to ResolvableForm', () => {
-    const importForm = () =>
-      Promise.resolve({
-        default: { type: 'form', components: {} } as Form<Entry>
-      })
-    assertType<ResolvableForm<Entry>>(importForm)
-  })
-
-  it('accepts event callbacks with typed item', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      events: {
-        create({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.title).toBeString()
-        },
-        submit({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.id).toBeNumber()
-        },
-        error({ item, error }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.title).toBeString()
-          expectTypeOf(error).not.toBeAny()
-          expectTypeOf(error).toEqualTypeOf<Error>()
-        }
-      }
-    })
-  })
-
-  it('accepts onCreate/onSubmit/onError top-level callbacks', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      onCreate({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-      },
-      onSubmit({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.id).toBeNumber()
-      },
-      onError({ item, error }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(error).not.toBeAny()
-        expectTypeOf(error).toEqualTypeOf<Error>()
-      }
-    })
-  })
-
-  it('typed Form variable used as form prop in list component', () => {
-    const childForm: Form<Entry> = {
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      }
-    }
-
-    const parentForm: Form<Parent> = {
-      type: 'form',
-      components: {
-        title: { type: 'text' },
-        entries: {
-          type: 'list',
-          form: childForm
-        }
-      }
-    }
-  })
-})

package/types/tests/instance.test-d.ts

@@ -1,20 +0,0 @@
-import { expectTypeOf, describe, it } from 'vitest'
-import type { DitoFormInstance, DitoContext } from '../index.d.ts'
-import type { Entry } from './fixtures.ts'
-
-describe('DitoComponentInstanceBase and DitoFormInstance', () => {
-  it('DitoFormInstance extends base with item and form properties', () => {
-    type Instance = DitoFormInstance<Entry>
-    expectTypeOf<Instance['item']>().not.toBeAny()
-    expectTypeOf<Instance['item']['title']>().toBeString()
-    expectTypeOf<Instance['isCreating']>().toBeBoolean()
-    expectTypeOf<Instance['submit']>().returns.toEqualTypeOf<Promise<boolean>>()
-  })
-
-  it('context is typed with item type', () => {
-    type Instance = DitoFormInstance<Entry>
-    expectTypeOf<Instance['context']>().not.toBeAny()
-    expectTypeOf<Instance['context']>()
-      .toEqualTypeOf<DitoContext<Entry>>()
-  })
-})