@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/fields/optionsResolver.ts

@@ -1,95 +0,0 @@
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Shape of an option in a SelectField / Radio / CheckboxList.
- * `value` round-trips through the form body; `label` is display only.
- *
- * `disabled` greys the option out and blocks selection. Stamped server-side
- * by `disableOptionsWhenSelectedInSiblingRepeaterItems()` for options taken
- * in sibling Repeater/Builder rows; users may also set it themselves on the
- * static option list to express "this choice is permanently unavailable".
- */
-export type SelectOption = { value: string; label: string; disabled?: boolean }
-
-/**
- * Reactive options resolver. Receives the same `{ $get, $set, record,
- * user, values }` ctx that `afterStateUpdated` sees, runs every resolve
- * cycle, and may be async (for DB-backed lookups). Throws are swallowed
- * to an empty array + console.warn — the field still renders, just with
- * no choices.
- *
- * Used by SelectField, Radio, CheckboxList. Each calls `resolveOptions`
- * from inside its async `toMeta` so the resolver runs at the same point
- * in the render cycle for every dependent-options field type.
- */
-export type OptionsResolver = (ctx: {
-  $get?:    (name: string) => unknown
-  $set?:    (name: string, value: unknown) => void
-  record?:  unknown
-  user?:    unknown
-  values?:  Record<string, unknown>
-}) => SelectOption[] | Promise<SelectOption[]>
-
-/**
- * Resolve a `SelectOption[] | OptionsResolver` source against the
- * current render context. Returns the resolved option array, or `[]`
- * with a `console.warn` when the resolver throws — failure should
- * never crash a form render.
- */
-export async function resolveOptions(
-  source:    SelectOption[] | OptionsResolver,
-  ctx:       RenderContext | undefined,
-  fieldName: string,
-): Promise<SelectOption[]> {
-  if (Array.isArray(source)) return source
-  try {
-    return await source({
-      ...(ctx?.$get   ? { $get:   ctx.$get   } : {}),
-      ...(ctx?.$set   ? { $set:   ctx.$set   } : {}),
-      ...(ctx?.record !== undefined ? { record: ctx.record } : {}),
-      ...(ctx?.user   !== undefined ? { user:   ctx.user   } : {}),
-      ...(ctx?.values ? { values: ctx.values } : {}),
-    })
-  } catch (err) {
-    console.warn(`[pilotiq] options() resolver for "${fieldName}" threw:`, err)
-    return []
-  }
-}
-
-/**
- * Apply the "disable options taken in sibling Repeater/Builder rows" gate.
- * No-op outside an array-row context (no `ctx.row.siblings`) or when the
- * field hasn't opted in. Builder scoping (same-block-type only) is handled
- * by the resolver — by the time we get here, `ctx.row.siblings` already
- * reflects the right scope.
- *
- * Multi-value sibling rows (e.g. `CheckboxList` storing `string[]`) unfold
- * into individual taken values; single-value rows contribute one taken
- * entry. Empty / null / `''` sibling values are skipped (they aren't real
- * picks yet — same posture as `Field.distinct()`'s default `ignoreNulls`).
- */
-export function disableOptionsTakenInSiblings(
-  options:   SelectOption[],
-  enabled:   boolean,
-  fieldName: string,
-  ctx:       RenderContext | undefined,
-): SelectOption[] {
-  if (!enabled) return options
-  const siblings = ctx?.row?.siblings
-  if (!siblings || siblings.length === 0) return options
-  const taken = new Set<string>()
-  for (const sib of siblings) {
-    if (!sib || typeof sib !== 'object') continue
-    const v = (sib as Record<string, unknown>)[fieldName]
-    if (Array.isArray(v)) {
-      for (const x of v) {
-        if (x === undefined || x === null || x === '') continue
-        taken.add(String(x))
-      }
-    } else if (v !== undefined && v !== null && v !== '') {
-      taken.add(String(v))
-    }
-  }
-  if (taken.size === 0) return options
-  return options.map(o => (taken.has(o.value) && !o.disabled ? { ...o, disabled: true } : o))
-}

package/src/fields/resolveField.ts

@@ -1,28 +0,0 @@
-import type { Field, FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Resolve a single Field against a render context.
- *
- * Returns `null` if the field should be hidden — visibility flags
- * (`hideFromTable` / `hideFromCreate` / etc.) and condition callbacks
- * (`showWhen` / `hideWhen`) are evaluated server-side. The serialized meta
- * never includes a hidden field.
- *
- * Async because reactive Field subclasses (Plan #5 — `SelectField` with
- * a resolver-style `options(fn)`) may compute meta asynchronously.
- */
-export async function resolveField(field: Field, ctx: RenderContext = {}): Promise<FieldMeta | null> {
-  if (field.isHiddenIn(ctx)) return null
-  return await field.toMeta(ctx)
-}
-
-/**
- * Resolve an array of Fields, dropping any that are hidden for the current
- * context. Used by `Resource.form()` / `Resource.table()` paths until 1.3
- * unifies Fields under the schema-element resolver.
- */
-export async function resolveFields(fields: Field[], ctx: RenderContext = {}): Promise<FieldMeta[]> {
-  const metas = await Promise.all(fields.map(f => resolveField(f, ctx)))
-  return metas.filter((m): m is FieldMeta => m !== null)
-}

package/src/filters/BooleanFilter.ts

@@ -1,35 +0,0 @@
-import { Filter, type FilterKind, type FilterMeta } from './Filter.js'
-
-/**
- * Three-state filter: yes / no / any. Renders as a dropdown. When a
- * value is selected, contributes `where(name, true|false)` to the
- * underlying ORM query — values `'1'` and `'true'` map to `true`,
- * everything else to `false`. The empty value means "any" (no clause
- * applied).
- *
- * @example
- * BooleanFilter.make('featured').label('Featured only')
- */
-export class BooleanFilter extends Filter {
-  static make(name: string): BooleanFilter {
-    return new BooleanFilter(name)
-  }
-
-  override getKind(): FilterKind { return 'boolean' }
-
-  protected override formatActiveValue(value: string): string {
-    return coerceBooleanFilterValue(value) ? 'Yes' : 'No'
-  }
-
-  override toMeta(): FilterMeta {
-    return {
-      ...this.buildBaseMeta(),
-      placeholder: this.getPlaceholder() ?? 'Any',
-    }
-  }
-}
-
-/** Coerce a URL-string filter value to a boolean. */
-export function coerceBooleanFilterValue(value: string): boolean {
-  return value === '1' || value === 'true' || value === 'yes' || value === 'on'
-}

package/src/filters/DateRangeFilter.test.ts

@@ -1,194 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Table } from '../elements/Table.js'
-import { Column } from '../Column.js'
-import {
-  DateRangeFilter,
-  parseDateRangeValue,
-  encodeDateRangeValue,
-} from './DateRangeFilter.js'
-import { modelTableRecords } from '../orm/modelDefaults.js'
-import type { ModelLike, ModelQuery } from '../orm/modelDefaults.js'
-
-interface FakeOp { op: string; args: unknown[] }
-class FakeQuery implements ModelQuery {
-  ops: FakeOp[] = []
-  where(...args: unknown[]): ModelQuery   { this.ops.push({ op: 'where', args });   return this }
-  orWhere(...args: unknown[]): ModelQuery { this.ops.push({ op: 'orWhere', args }); return this }
-  orderBy(c: string, d: 'ASC' | 'DESC' = 'ASC'): ModelQuery { this.ops.push({ op: 'orderBy', args: [c, d] }); return this }
-  async paginate() { this.ops.push({ op: 'paginate', args: [] }); return { data: [], total: 0 } }
-}
-
-function fakeModel(): ModelLike & { name: string; model: ModelLike; lastQuery: FakeQuery | null } {
-  let lastQuery: FakeQuery | null = null
-  const M = {
-    name: 'TestResource',
-    async find() { return null },
-    async create(d: Record<string, unknown>) { return d },
-    async update(_id: string | number, d: Record<string, unknown>) { return d },
-    async delete() {},
-    query(): ModelQuery {
-      const q = new FakeQuery()
-      lastQuery = q
-      return q
-    },
-    get lastQuery() { return lastQuery },
-  } as unknown as ModelLike & { name: string; model: ModelLike; lastQuery: FakeQuery | null }
-  M.model = M
-  return M
-}
-
-describe('parseDateRangeValue', () => {
-  it('round-trips a closed range', () => {
-    assert.deepEqual(
-      parseDateRangeValue('2026-01-01..2026-12-31'),
-      { from: '2026-01-01', to: '2026-12-31' },
-    )
-  })
-
-  it('round-trips an open-from range', () => {
-    assert.deepEqual(parseDateRangeValue('2026-01-01..'), { from: '2026-01-01' })
-  })
-
-  it('round-trips an open-to range', () => {
-    assert.deepEqual(parseDateRangeValue('..2026-12-31'), { to: '2026-12-31' })
-  })
-
-  it('treats empty / `..` as the empty range', () => {
-    assert.deepEqual(parseDateRangeValue(''),    {})
-    assert.deepEqual(parseDateRangeValue('..'),  {})
-  })
-
-  it('treats a missing separator as a single from bound', () => {
-    assert.deepEqual(parseDateRangeValue('2026-01-01'), { from: '2026-01-01' })
-  })
-
-  it('trims whitespace on both sides', () => {
-    assert.deepEqual(
-      parseDateRangeValue('  2026-01-01 .. 2026-12-31  '),
-      { from: '2026-01-01', to: '2026-12-31' },
-    )
-  })
-})
-
-describe('encodeDateRangeValue', () => {
-  it('encodes a closed range', () => {
-    assert.equal(encodeDateRangeValue({ from: '2026-01-01', to: '2026-12-31' }), '2026-01-01..2026-12-31')
-  })
-  it('encodes open-from / open-to', () => {
-    assert.equal(encodeDateRangeValue({ from: '2026-01-01' }), '2026-01-01..')
-    assert.equal(encodeDateRangeValue({ to:   '2026-12-31' }), '..2026-12-31')
-  })
-  it('returns empty string when both sides are missing', () => {
-    assert.equal(encodeDateRangeValue({}),                       '')
-    assert.equal(encodeDateRangeValue({ from: '', to: '' }),     '')
-  })
-})
-
-describe('DateRangeFilter shape', () => {
-  it('toMeta emits kind:dateRange + includesTime + Any placeholder', () => {
-    const meta = DateRangeFilter.make('publishedAt').toMeta()
-    assert.equal(meta.kind,         'dateRange')
-    assert.equal(meta.includesTime, false)
-    assert.equal(meta.placeholder,  'Any')
-    assert.equal(meta.minDate,      undefined)
-    assert.equal(meta.maxDate,      undefined)
-  })
-
-  it('includesTime() flips the meta flag', () => {
-    const meta = DateRangeFilter.make('publishedAt').includesTime(true).toMeta()
-    assert.equal(meta.includesTime, true)
-  })
-
-  it('minDate / maxDate accept ISO strings + Date objects', () => {
-    const date = new Date(2026, 0, 15) // 2026-01-15 local
-    const meta = DateRangeFilter.make('publishedAt')
-      .minDate('2020-01-01')
-      .maxDate(date)
-      .toMeta()
-    assert.equal(meta.minDate, '2020-01-01')
-    assert.equal(meta.maxDate, '2026-01-15')
-  })
-
-  it('Date bounds include time when includesTime(true) was set first', () => {
-    const date = new Date(2026, 0, 15, 14, 30) // 2026-01-15 14:30 local
-    const meta = DateRangeFilter.make('publishedAt')
-      .includesTime(true)
-      .maxDate(date)
-      .toMeta()
-    assert.equal(meta.maxDate, '2026-01-15T14:30')
-  })
-
-  it('placeholder override wins over Any default', () => {
-    const meta = DateRangeFilter.make('publishedAt').placeholder('Any time').toMeta()
-    assert.equal(meta.placeholder, 'Any time')
-  })
-})
-
-describe('DateRangeFilter default query handler', () => {
-  it('closed range emits two where clauses (>=, <=)', async () => {
-    const M = fakeModel()
-    const table = Table.make()
-      .columns([Column.make('title')])
-      .filters([DateRangeFilter.make('publishedAt')])
-    const handler = modelTableRecords(M, table)
-    await handler({ filters: { publishedAt: '2026-01-01..2026-12-31' }, page: 1 })
-    const wheres = M.lastQuery!.ops.filter(o => o.op === 'where')
-    assert.deepEqual(wheres[0]!.args, ['publishedAt', '>=', '2026-01-01'])
-    assert.deepEqual(wheres[1]!.args, ['publishedAt', '<=', '2026-12-31'])
-  })
-
-  it('open-from emits a single >= clause', async () => {
-    const M = fakeModel()
-    const table = Table.make()
-      .columns([Column.make('title')])
-      .filters([DateRangeFilter.make('publishedAt')])
-    const handler = modelTableRecords(M, table)
-    await handler({ filters: { publishedAt: '2026-01-01..' }, page: 1 })
-    const wheres = M.lastQuery!.ops.filter(o => o.op === 'where')
-    assert.equal(wheres.length, 1)
-    assert.deepEqual(wheres[0]!.args, ['publishedAt', '>=', '2026-01-01'])
-  })
-
-  it('open-to emits a single <= clause', async () => {
-    const M = fakeModel()
-    const table = Table.make()
-      .columns([Column.make('title')])
-      .filters([DateRangeFilter.make('publishedAt')])
-    const handler = modelTableRecords(M, table)
-    await handler({ filters: { publishedAt: '..2026-12-31' }, page: 1 })
-    const wheres = M.lastQuery!.ops.filter(o => o.op === 'where')
-    assert.equal(wheres.length, 1)
-    assert.deepEqual(wheres[0]!.args, ['publishedAt', '<=', '2026-12-31'])
-  })
-
-  it('parseFilterValues drops `..` (no clauses)', async () => {
-    // The parser drops empty values upstream, but `..` is non-empty —
-    // the default handler itself short-circuits the no-bound case.
-    const M = fakeModel()
-    const table = Table.make()
-      .columns([Column.make('title')])
-      .filters([DateRangeFilter.make('publishedAt')])
-    const handler = modelTableRecords(M, table)
-    await handler({ filters: { publishedAt: '..' }, page: 1 })
-    const wheres = M.lastQuery!.ops.filter(o => o.op === 'where')
-    assert.equal(wheres.length, 0)
-  })
-
-  it('user .query(fn) override sees the raw encoded value', async () => {
-    const M = fakeModel()
-    let received: string | undefined
-    const table = Table.make()
-      .columns([Column.make('title')])
-      .filters([
-        DateRangeFilter.make('publishedAt').query((q, value) => {
-          received = value
-          return q
-        }),
-      ])
-    const handler = modelTableRecords(M, table)
-    await handler({ filters: { publishedAt: '2026-01-01..2026-12-31' }, page: 1 })
-    assert.equal(received, '2026-01-01..2026-12-31')
-  })
-})

package/src/filters/DateRangeFilter.ts

@@ -1,148 +0,0 @@
-import { Filter, type FilterKind, type FilterMeta } from './Filter.js'
-import type { ModelQuery } from '../orm/modelDefaults.js'
-
-/**
- * Parsed shape of a `DateRangeFilter`'s URL value. Either side may be
- * absent; `{ from, to }` are kept as raw strings so callers can decide
- * whether to coerce to `Date` or pass straight through to the ORM.
- */
-export interface DateRangeValue {
-  from?: string
-  to?:   string
-}
-
-/**
- * Round-trip a `from..to`-encoded URL value to `{ from?, to? }`. Either
- * side may be empty (`'2026-01-01..'` → `{ from: '2026-01-01' }`). The
- * empty string and `'..'` both parse to `{}`.
- *
- * Exposed as a public helper so users writing a custom `Filter.query(fn)`
- * can avoid re-parsing the encoding by hand.
- */
-export function parseDateRangeValue(value: string): DateRangeValue {
-  if (!value || value === '..') return {}
-  const idx = value.indexOf('..')
-  if (idx === -1) {
-    // No separator — treat as a single "from" bound. Rare; users are
-    // more likely to pass the encoded form.
-    const from = value.trim()
-    return from ? { from } : {}
-  }
-  const from = value.slice(0, idx).trim()
-  const to   = value.slice(idx + 2).trim()
-  const out: DateRangeValue = {}
-  if (from) out.from = from
-  if (to)   out.to   = to
-  return out
-}
-
-/**
- * Encode a `{ from?, to? }` pair as the canonical `from..to` URL value.
- * The empty / both-missing case returns `''` (caller should drop the
- * URL key entirely rather than emitting `..`).
- */
-export function encodeDateRangeValue(range: DateRangeValue): string {
-  const from = range.from?.trim() ?? ''
-  const to   = range.to?.trim()   ?? ''
-  if (!from && !to) return ''
-  return `${from}..${to}`
-}
-
-/**
- * Pair-of-date-inputs filter. Encodes the URL value as `from..to`
- * keyed off the filter name so the existing single-key `parseFilterValues`
- * contract holds:
- *
- *   `?publishedAt=2026-01-01..2026-12-31`  closed range
- *   `?publishedAt=2026-01-01..`            open-ended `>=` from
- *   `?publishedAt=..2026-12-31`            open-ended `<=` to
- *
- * Default ORM clauses:
- *
- *   from + to → `where(name,'>=',from).where(name,'<=',to)`
- *   from only → `where(name,'>=',from)`
- *   to only   → `where(name,'<=',to)`
- *
- * `to` is treated as inclusive — for `DateTime` columns with
- * `includesTime(false)`, callers wanting "all of 2026-12-31" should
- * widen the upper bound via `Filter.query(fn)`.
- *
- * @example
- * DateRangeFilter.make('publishedAt').label('Published')
- * DateRangeFilter.make('createdAt').includesTime(true).maxDate(new Date())
- */
-export class DateRangeFilter extends Filter {
-  private _includesTime = false
-  private _minDate?:    string
-  private _maxDate?:    string
-
-  static make(name: string): DateRangeFilter {
-    const f = new DateRangeFilter(name)
-    f.query((q: ModelQuery, value: string) => {
-      const { from, to } = parseDateRangeValue(value)
-      let next = q
-      if (from) next = next.where(f.name, '>=', from)
-      if (to)   next = next.where(f.name, '<=', to)
-      return next
-    })
-    return f
-  }
-
-  /** Switch the inputs to `<input type="datetime-local">` and the URL
-   *  values to ISO timestamps. Default: `false`. */
-  includesTime(value = true): this { this._includesTime = value; return this }
-
-  /** Lower bound for the input's `min` attribute. Accepts an ISO string or `Date`. */
-  minDate(value: string | Date): this {
-    this._minDate = toBoundString(value, this._includesTime)
-    return this
-  }
-
-  /** Upper bound for the input's `max` attribute. Accepts an ISO string or `Date`. */
-  maxDate(value: string | Date): this {
-    this._maxDate = toBoundString(value, this._includesTime)
-    return this
-  }
-
-  // Getters used by tests + the renderer.
-  getIncludesTime(): boolean             { return this._includesTime }
-  getMinDate():     string | undefined   { return this._minDate }
-  getMaxDate():     string | undefined   { return this._maxDate }
-
-  override getKind(): FilterKind { return 'dateRange' }
-
-  protected override formatActiveValue(value: string): string {
-    const { from, to } = parseDateRangeValue(value)
-    if (from && to) return `${from} → ${to}`
-    if (from)       return `≥ ${from}`
-    if (to)         return `≤ ${to}`
-    return value
-  }
-
-  override toMeta(): FilterMeta {
-    return {
-      ...this.buildBaseMeta(),
-      includesTime: this._includesTime,
-      ...(this._minDate !== undefined ? { minDate: this._minDate } : {}),
-      ...(this._maxDate !== undefined ? { maxDate: this._maxDate } : {}),
-      placeholder: this.getPlaceholder() ?? 'Any',
-    }
-  }
-}
-
-/** Coerce a `Date | string` bound to the canonical `YYYY-MM-DD` or
- *  `YYYY-MM-DDTHH:mm` input-friendly string. Strings pass through
- *  trimmed; the renderer's `min` / `max` attributes accept either. */
-function toBoundString(value: string | Date, includesTime: boolean): string {
-  if (typeof value === 'string') return value.trim()
-  // Use the local-time split so `<input type="date">` doesn't shift the
-  // bound a day under negative-UTC-offset clients.
-  const yyyy = value.getFullYear().toString().padStart(4, '0')
-  const mm   = (value.getMonth() + 1).toString().padStart(2, '0')
-  const dd   = value.getDate().toString().padStart(2, '0')
-  const date = `${yyyy}-${mm}-${dd}`
-  if (!includesTime) return date
-  const hh   = value.getHours().toString().padStart(2, '0')
-  const min  = value.getMinutes().toString().padStart(2, '0')
-  return `${date}T${hh}:${min}`
-}