@ditojs/admin 2.85.2 → 2.87.0

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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,20 @@
+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>>()
+  })
+})