@ditojs/admin 2.93.0 → 2.95.0

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>>()
-  })
-})

package/types/tests/schema-features.test-d.ts

@@ -1,402 +0,0 @@
-import { expectTypeOf, assertType, describe, it } from 'vitest'
-import type {
-  Form,
-  Components,
-  PanelSchema,
-  UploadSchema,
-  DitoComponentInstance,
-  HiddenSchema
-} from '../index.d.ts'
-import type { Entry, Parent } from './fixtures.ts'
-
-describe('SchemaFields: methods', () => {
-  it('methods have `this` typed as component instance', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      methods: {
-        greet() {
-          expectTypeOf(this).not.toBeAny()
-          expectTypeOf(this).toEqualTypeOf<DitoComponentInstance<Entry>>()
-          expectTypeOf(this.item).not.toBeAny()
-          expectTypeOf(this.item.title).toBeString()
-          expectTypeOf(this.item.id).toBeNumber()
-        },
-        getTitle() {
-          return this.item.title
-        }
-      }
-    })
-  })
-})
-
-describe('SchemaFields: computed', () => {
-  it('computed getter uses `this` typing', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      computed: {
-        upperTitle() {
-          expectTypeOf(this).not.toBeAny()
-          expectTypeOf(this.item).not.toBeAny()
-          expectTypeOf(this.item.title).toBeString()
-          return this.item.title.toUpperCase()
-        }
-      }
-    })
-  })
-
-  it('computed getter/setter object uses `this` typing', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      computed: {
-        upperTitle: {
-          get() {
-            expectTypeOf(this).not.toBeAny()
-            expectTypeOf(this.item).not.toBeAny()
-            expectTypeOf(this.item.title).toBeString()
-            return this.item.title.toUpperCase()
-          },
-          set(_value) {
-            expectTypeOf(this).not.toBeAny()
-            expectTypeOf(this.item.id).toBeNumber()
-          }
-        }
-      }
-    })
-  })
-})
-
-describe('SchemaFields: watch', () => {
-  it('watch with plain handler function', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      watch: {
-        title(value, oldValue) {
-          expectTypeOf(this).not.toBeAny()
-          expectTypeOf(this.item).not.toBeAny()
-          expectTypeOf(this.item.title).toBeString()
-          expectTypeOf(value).toBeAny()
-          expectTypeOf(oldValue).toBeAny()
-        }
-      }
-    })
-  })
-
-  it('watch with object containing deep and immediate', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      watch: {
-        title: {
-          handler(value, oldValue) {
-            expectTypeOf(this).not.toBeAny()
-            expectTypeOf(this.item).not.toBeAny()
-            expectTypeOf(this.item.title).toBeString()
-            expectTypeOf(value).toBeAny()
-            expectTypeOf(oldValue).toBeAny()
-          },
-          deep: true,
-          immediate: true
-        }
-      }
-    })
-  })
-
-  it('watch as factory function returning handlers', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      watch() {
-        expectTypeOf(this).not.toBeAny()
-        expectTypeOf(this.item).not.toBeAny()
-        expectTypeOf(this.item.title).toBeString()
-        return {
-          title(value) {
-            expectTypeOf(this).not.toBeAny()
-            expectTypeOf(this.item).not.toBeAny()
-            expectTypeOf(this.item.id).toBeNumber()
-          }
-        }
-      }
-    })
-  })
-})
-
-describe('SchemaFields: panels', () => {
-  it('form with panels containing components and buttons', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      panels: {
-        sidebar: {
-          type: 'panel',
-          label: 'Sidebar',
-          components: {
-            id: { type: 'number' }
-          },
-          buttons: {
-            save: { text: 'Save' }
-          },
-          panelButtons: {
-            refresh: { text: 'Refresh' }
-          }
-        }
-      }
-    })
-  })
-})
-
-describe('SchemaFields: lifecycle callbacks', () => {
-  it('onInitialize and onChange receive typed context', () => {
-    assertType<Form<Entry>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      onInitialize({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-        expectTypeOf(item.id).toBeNumber()
-      },
-      onChange({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-      }
-    })
-  })
-})
-
-describe('SchemaTypeMixin: parse and process callbacks', () => {
-  it('parse callback receives typed item', () => {
-    assertType<Components<Parent>>({
-      title: {
-        type: 'text',
-        parse({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.title).toBeString()
-          expectTypeOf(item.entries).toEqualTypeOf<Entry[]>()
-        }
-      }
-    })
-  })
-
-  it('process callback receives typed item', () => {
-    assertType<Components<Parent>>({
-      title: {
-        type: 'text',
-        process({ item }) {
-          expectTypeOf(item).not.toBeAny()
-          expectTypeOf(item.title).toBeString()
-          return item.title.trim()
-        }
-      }
-    })
-  })
-})
-
-describe('SchemaDataMixin: data callback', () => {
-  it('data callback receives typed item on HiddenSchema', () => {
-    assertType<HiddenSchema<Entry>>({
-      type: 'hidden',
-      data({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-        expectTypeOf(item.id).toBeNumber()
-        return { computed: item.title }
-      }
-    })
-  })
-})
-
-describe('UploadSchema', () => {
-  it('accepts multiple, extensions, accept, and maxSize', () => {
-    assertType<Components<Parent>>({
-      entries: {
-        type: 'upload',
-        multiple: true,
-        extensions: ['jpg', 'png', 'gif'],
-        accept: ['image/png', 'image/jpeg'],
-        maxSize: '5mb'
-      }
-    })
-  })
-
-  it('accepts extensions as regex', () => {
-    assertType<Components<Parent>>({
-      entries: {
-        type: 'upload',
-        extensions: /\.(gif|jpe?g|png)$/i
-      }
-    })
-  })
-
-  it('accepts thumbnails and downloadUrl as callbacks', () => {
-    assertType<UploadSchema<Entry>>({
-      type: 'upload',
-      thumbnails({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-        return true
-      },
-      downloadUrl({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.id).toBeNumber()
-        return `/files/${item.id}`
-      }
-    })
-  })
-
-  it('accepts thumbnailUrl and render as callbacks', () => {
-    assertType<UploadSchema<Entry>>({
-      type: 'upload',
-      thumbnailUrl({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-        return `/thumbs/${item.id}`
-      },
-      render({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        return item.title
-      }
-    })
-  })
-
-  it('accepts draggable and deletable as callbacks', () => {
-    assertType<UploadSchema<Entry>>({
-      type: 'upload',
-      draggable({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.id).toBeNumber()
-        return true
-      },
-      deletable({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.title).toBeString()
-        return false
-      }
-    })
-  })
-})
-
-describe('PanelSchema', () => {
-  it('constrains component keys to item properties', () => {
-    assertType<PanelSchema<Entry>>({
-      type: 'panel',
-      components: {
-        id: { type: 'number' },
-        title: { type: 'text' }
-      }
-    })
-  })
-
-  it('rejects unknown component keys', () => {
-    assertType<PanelSchema<Entry>>({
-      type: 'panel',
-      components: {
-        // @ts-expect-error — 'extra' is not a key of Entry
-        extra: { type: 'text' }
-      }
-    })
-  })
-
-  it('accepts buttons and panelButtons', () => {
-    assertType<PanelSchema<Entry>>({
-      type: 'panel',
-      buttons: {
-        save: {
-          text: 'Save',
-          events: {
-            click({ item }) {
-              expectTypeOf(item).not.toBeAny()
-              expectTypeOf(item.title).toBeString()
-            }
-          }
-        }
-      },
-      panelButtons: {
-        refresh: { text: 'Refresh' }
-      }
-    })
-  })
-
-  it('accepts sticky as callback', () => {
-    assertType<PanelSchema<Entry>>({
-      type: 'panel',
-      sticky({ item }) {
-        expectTypeOf(item).not.toBeAny()
-        expectTypeOf(item.id).toBeNumber()
-        return true
-      }
-    })
-  })
-
-  it('component callbacks in panels receive typed item', () => {
-    assertType<PanelSchema<Parent>>({
-      type: 'panel',
-      components: {
-        title: {
-          type: 'text',
-          format({ item }) {
-            expectTypeOf(item).not.toBeAny()
-            expectTypeOf(item.title).toBeString()
-            expectTypeOf(item.entries)
-              .toEqualTypeOf<Entry[]>()
-            return ''
-          }
-        }
-      }
-    })
-  })
-
-  it('panels on Form inherit item type', () => {
-    assertType<Form<Parent>>({
-      type: 'form',
-      components: {
-        title: { type: 'text' }
-      },
-      panels: {
-        info: {
-          type: 'panel',
-          components: {
-            title: {
-              type: 'text',
-              format({ item }) {
-                expectTypeOf(item).not.toBeAny()
-                expectTypeOf(item.title).toBeString()
-                return ''
-              }
-            }
-          },
-          buttons: {
-            save: {
-              text: 'Save',
-              events: {
-                click({ item }) {
-                  expectTypeOf(item).not.toBeAny()
-                  expectTypeOf(item.id).toBeNumber()
-                }
-              }
-            }
-          }
-        }
-      }
-    })
-  })
-})