@pilotiq/pilotiq 0.23.1 → 0.24.2

package/src/fields/CheckboxField.test.ts

@@ -1,44 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { CheckboxField, Checkbox } from './CheckboxField.js'
-import { coerceFormValues } from '../elements/dispatchForm.js'
-
-describe('CheckboxField', () => {
-  it('emits fieldType "checkbox" — distinct from toggle', () => {
-    const meta = CheckboxField.make('agreed').toMeta()
-    assert.equal(meta.fieldType, 'checkbox')
-  })
-
-  it('exports an alias `Checkbox`', () => {
-    assert.equal(Checkbox, CheckboxField)
-  })
-
-  it('default(true) emits defaultValue', () => {
-    const meta = CheckboxField.make('opt-in').default(true).toMeta()
-    assert.equal(meta.defaultValue, true)
-  })
-
-  describe('coerceFormValues', () => {
-    it('coerces "true" → true', () => {
-      const out = coerceFormValues([CheckboxField.make('agreed')], { agreed: 'true' })
-      assert.equal(out['agreed'], true)
-    })
-
-    it('coerces missing key → false', () => {
-      const out = coerceFormValues([CheckboxField.make('agreed')], {})
-      assert.equal(out['agreed'], false)
-    })
-
-    it('coerces "false" / "0" / "" → false', () => {
-      assert.equal(coerceFormValues([CheckboxField.make('a')], { a: 'false' })['a'], false)
-      assert.equal(coerceFormValues([CheckboxField.make('a')], { a: '0' })['a'],     false)
-      assert.equal(coerceFormValues([CheckboxField.make('a')], { a: '' })['a'],      false)
-    })
-
-    it('coerces "on" or any other truthy string → true', () => {
-      assert.equal(coerceFormValues([CheckboxField.make('a')], { a: 'on' })['a'],  true)
-      assert.equal(coerceFormValues([CheckboxField.make('a')], { a: 'yes' })['a'], true)
-    })
-  })
-})

package/src/fields/CheckboxField.ts

@@ -1,27 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Single boolean field rendered as a square checkbox + side label.
- * Distinct from `ToggleField` — Toggle is a pill-style switch and
- * conventionally signals an active/inactive state, while Checkbox
- * conventionally signals an opt-in or accept-terms-style choice.
- *
- * Both produce the same shape of body value. `coerceFormValues`
- * normalizes either to `true | false` via the same branch.
- */
-export class CheckboxField extends Field {
-  private constructor(name: string) {
-    super(name, 'checkbox')
-  }
-
-  static make(name: string): CheckboxField {
-    return new CheckboxField(name)
-  }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return this.buildMeta(ctx)
-  }
-}
-
-export const Checkbox = CheckboxField

package/src/fields/CheckboxListField.test.ts

@@ -1,99 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { CheckboxListField, CheckboxList } from './CheckboxListField.js'
-import { coerceFormValues } from '../elements/dispatchForm.js'
-
-describe('CheckboxListField', () => {
-  it('emits fieldType "checkboxList"', async () => {
-    const meta = await CheckboxListField.make('cats').toMeta()
-    assert.equal(meta.fieldType, 'checkboxList')
-  })
-
-  it('exports an alias `CheckboxList`', () => {
-    assert.equal(CheckboxList, CheckboxListField)
-  })
-
-  it('emits options array', async () => {
-    const meta = await CheckboxListField.make('cats').options([
-      { value: 'a', label: 'A' },
-      { value: 'b', label: 'B' },
-    ]).toMeta()
-    assert.deepEqual(meta['options'], [
-      { value: 'a', label: 'A' },
-      { value: 'b', label: 'B' },
-    ])
-  })
-
-  it('emits columns when > 1', async () => {
-    const meta = await CheckboxListField.make('x').columns(2).toMeta()
-    assert.equal(meta['columns'], 2)
-  })
-
-  it('omits columns when default (1)', async () => {
-    const meta = await CheckboxListField.make('x').toMeta()
-    assert.equal('columns' in meta, false)
-  })
-
-  it('clamps columns to >= 1', () => {
-    const f = CheckboxListField.make('x').columns(0)
-    assert.equal(f.getColumns(), 1)
-  })
-
-  describe('coerceFormValues', () => {
-    it('array body → string[]', () => {
-      const out = coerceFormValues(
-        [CheckboxListField.make('cats')],
-        { cats: ['news', 'guides'] },
-      )
-      assert.deepEqual(out['cats'], ['news', 'guides'])
-    })
-
-    it('single string body → [string]', () => {
-      const out = coerceFormValues(
-        [CheckboxListField.make('cats')],
-        { cats: 'news' },
-      )
-      assert.deepEqual(out['cats'], ['news'])
-    })
-
-    it('missing body key → empty array', () => {
-      const out = coerceFormValues([CheckboxListField.make('cats')], {})
-      assert.deepEqual(out['cats'], [])
-    })
-
-    it('null body → empty array', () => {
-      const out = coerceFormValues(
-        [CheckboxListField.make('cats')],
-        { cats: null },
-      )
-      assert.deepEqual(out['cats'], [])
-    })
-
-    it('non-string array values are stringified', () => {
-      const out = coerceFormValues(
-        [CheckboxListField.make('ids')],
-        { ids: [1, 2, 3] },
-      )
-      assert.deepEqual(out['ids'], ['1', '2', '3'])
-    })
-  })
-
-  describe('async resolver', () => {
-    it('runs the resolver against ctx', async () => {
-      const f = CheckboxListField.make('opts').options(({ $get }) => {
-        return $get?.('mode') === 'pro'
-          ? [{ value: 'a', label: 'A' }, { value: 'b', label: 'B' }]
-          : [{ value: 'a', label: 'A' }]
-      })
-      const meta = await f.toMeta({
-        values: { mode: 'pro' },
-        $get:   (n) => ({ mode: 'pro' } as Record<string, unknown>)[n],
-      })
-      assert.deepEqual(meta['options'], [
-        { value: 'a', label: 'A' },
-        { value: 'b', label: 'B' },
-      ])
-    })
-  })
-})

package/src/fields/CheckboxListField.ts

@@ -1,66 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import {
-  resolveOptions,
-  disableOptionsTakenInSiblings,
-  type OptionsResolver,
-  type SelectOption,
-} from './optionsResolver.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Multi-choice field. Value is `string[]`. Same `OptionsResolver`
- * shape as `SelectField` / `RadioField` so dependent options work
- * everywhere identically.
- *
- * `columns(n)` lays the checkboxes out in an `n`-wide grid; default
- * 1 (vertical stack).
- */
-export class CheckboxListField extends Field {
-  private _options: SelectOption[] | OptionsResolver = []
-  private _columns = 1
-
-  private constructor(name: string) {
-    super(name, 'checkboxList')
-  }
-
-  static make(name: string): CheckboxListField {
-    return new CheckboxListField(name)
-  }
-
-  options(opts: SelectOption[] | OptionsResolver): this {
-    this._options = opts
-    return this
-  }
-
-  columns(n: number): this {
-    this._columns = Math.max(1, Math.floor(n))
-    return this
-  }
-
-  getOptions(): SelectOption[] {
-    return Array.isArray(this._options) ? this._options : []
-  }
-
-  hasDynamicOptions(): boolean {
-    return typeof this._options === 'function'
-  }
-
-  getColumns(): number { return this._columns }
-
-  override async toMeta(ctx?: RenderContext): Promise<FieldMeta> {
-    const base    = this.buildMeta(ctx)
-    const options = disableOptionsTakenInSiblings(
-      await resolveOptions(this._options, ctx, this.name),
-      this.shouldDisableOptionsTakenInSiblings(),
-      this.name,
-      ctx,
-    )
-    return {
-      ...base,
-      options,
-      ...(this._columns !== 1 ? { columns: this._columns } : {}),
-    }
-  }
-}
-
-export const CheckboxList = CheckboxListField

package/src/fields/ColorPickerField.test.ts

@@ -1,33 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ColorPickerField, ColorPicker } from './ColorPickerField.js'
-import { coerceFormValues } from '../elements/dispatchForm.js'
-
-describe('ColorPickerField', () => {
-  it('emits fieldType "color"', () => {
-    const meta = ColorPickerField.make('accent').toMeta()
-    assert.equal(meta.fieldType, 'color')
-  })
-
-  it('exports an alias `ColorPicker`', () => {
-    assert.equal(ColorPicker, ColorPickerField)
-  })
-
-  it('default(value) emits defaultValue', () => {
-    const meta = ColorPickerField.make('accent').default('#d97757').toMeta()
-    assert.equal(meta.defaultValue, '#d97757')
-  })
-
-  describe('coerceFormValues', () => {
-    it('passes hex string through', () => {
-      const out = coerceFormValues([ColorPickerField.make('c')], { c: '#ff0000' })
-      assert.equal(out['c'], '#ff0000')
-    })
-
-    it('empty string → null', () => {
-      const out = coerceFormValues([ColorPickerField.make('c')], { c: '' })
-      assert.equal(out['c'], null)
-    })
-  })
-})

package/src/fields/ColorPickerField.ts

@@ -1,25 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Hex color input. UI is a native `<input type="color">` plus a text
- * mirror so users can paste literal hex codes. Value persisted as
- * `#rrggbb`.
- *
- * v1: no swatches preset, no alpha channel.
- */
-export class ColorPickerField extends Field {
-  private constructor(name: string) {
-    super(name, 'color')
-  }
-
-  static make(name: string): ColorPickerField {
-    return new ColorPickerField(name)
-  }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return this.buildMeta(ctx)
-  }
-}
-
-export const ColorPicker = ColorPickerField

package/src/fields/DateField.ts

@@ -1,54 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-export class DateField extends Field {
-  protected _withTime = false
-
-  protected constructor(name: string, fieldType: string = 'date') {
-    super(name, fieldType)
-  }
-
-  static make(name: string): DateField {
-    return new DateField(name)
-  }
-
-  /**
-   * Include a time picker alongside the date picker. Coerces the
-   * combined `YYYY-MM-DDTHH:mm` body value into a `Date` on submit
-   * (the renderer reads `withTime` off the meta to pick the right
-   * input). Equivalent to using `DateTimePicker.make()` directly,
-   * which constructs with the `'dateTime'` fieldType discriminator
-   * for renderer dispatch.
-   */
-  withTime(value: boolean = true): this {
-    this._withTime = value
-    return this
-  }
-
-  hasTime(): boolean { return this._withTime }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return {
-      ...this.buildMeta(ctx),
-      ...(this._withTime ? { withTime: true } : {}),
-    }
-  }
-}
-
-/**
- * `DateField` with `.withTime()` baked in. Same class, different
- * default — for users who'd rather declare intent through the type
- * than chain a setter.
- */
-export class DateTimePickerField extends DateField {
-  private constructor(name: string) {
-    super(name, 'dateTime')
-    this._withTime = true
-  }
-
-  static make(name: string): DateTimePickerField {
-    return new DateTimePickerField(name)
-  }
-}
-
-export const DateTimePicker = DateTimePickerField

package/src/fields/DateTimeField.test.ts

@@ -1,55 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { DateField, DateTimePickerField, DateTimePicker } from './DateField.js'
-import { coerceFormValues } from '../elements/dispatchForm.js'
-
-describe('DateField.withTime() (Plan #6)', () => {
-  it('default DateField has no withTime flag', () => {
-    const meta = DateField.make('publishedAt').toMeta()
-    assert.equal('withTime' in meta, false)
-    assert.equal(meta.fieldType, 'date')
-  })
-
-  it('withTime() sets the meta flag', () => {
-    const f = DateField.make('publishedAt').withTime()
-    assert.equal(f.hasTime(), true)
-    const meta = f.toMeta()
-    assert.equal(meta['withTime'], true)
-  })
-
-  it('withTime(false) clears the flag', () => {
-    const meta = DateField.make('x').withTime().withTime(false).toMeta()
-    assert.equal('withTime' in meta, false)
-  })
-})
-
-describe('DateTimePickerField', () => {
-  it('emits fieldType "dateTime" by default', () => {
-    const meta = DateTimePickerField.make('scheduledAt').toMeta()
-    assert.equal(meta.fieldType, 'dateTime')
-    assert.equal(meta['withTime'], true)
-  })
-
-  it('exports an alias `DateTimePicker`', () => {
-    assert.equal(DateTimePicker, DateTimePickerField)
-  })
-
-  it('coerces YYYY-MM-DDTHH:mm string → Date', () => {
-    const out = coerceFormValues(
-      [DateTimePickerField.make('at')],
-      { at: '2026-05-01T14:30' },
-    )
-    assert.ok(out['at'] instanceof Date)
-    const d = out['at'] as Date
-    assert.equal(d.getUTCFullYear(), 2026)
-  })
-
-  it('empty string → null', () => {
-    const out = coerceFormValues(
-      [DateTimePickerField.make('at')],
-      { at: '' },
-    )
-    assert.equal(out['at'], null)
-  })
-})

package/src/fields/EmailField.ts

@@ -1,16 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-export class EmailField extends Field {
-  private constructor(name: string) {
-    super(name, 'email')
-  }
-
-  static make(name: string): EmailField {
-    return new EmailField(name)
-  }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return this.buildMeta(ctx)
-  }
-}