@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/fields/MarkdownField.test.ts

@@ -1,167 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  MarkdownField,
-  DEFAULT_MARKDOWN_TOOLBAR,
-} from './MarkdownField.js'
-
-describe('MarkdownField', () => {
-  it('emits fieldType "markdown"', () => {
-    const meta = MarkdownField.make('body').toMeta()
-    assert.equal(meta.fieldType, 'markdown')
-  })
-
-  it('defaults to the full toolbar', () => {
-    const meta = MarkdownField.make('body').toMeta({ hasUploadAdapter: true })
-    assert.deepEqual(
-      meta['toolbarButtons'],
-      [...DEFAULT_MARKDOWN_TOOLBAR],
-    )
-  })
-
-  it('omits minHeight/maxHeight/fileAttachments* by default', () => {
-    const meta = MarkdownField.make('body').toMeta()
-    assert.equal('minHeight' in meta, false)
-    assert.equal('maxHeight' in meta, false)
-    assert.equal('fileAttachmentsDirectory'  in meta, false)
-    assert.equal('fileAttachmentsVisibility' in meta, false)
-  })
-
-  describe('toolbarButtons()', () => {
-    it('replaces the toolbar entirely with the given list', () => {
-      const meta = MarkdownField.make('body')
-        .toolbarButtons(['bold', 'italic', 'link'])
-        .toMeta({ hasUploadAdapter: true })
-      assert.deepEqual(meta['toolbarButtons'], ['bold', 'italic', 'link'])
-    })
-
-    it('preserves order from the user-supplied list', () => {
-      const meta = MarkdownField.make('body')
-        .toolbarButtons(['link', 'codeBlock', 'bold'])
-        .toMeta({ hasUploadAdapter: true })
-      assert.deepEqual(meta['toolbarButtons'], ['link', 'codeBlock', 'bold'])
-    })
-
-    it('empty array ships a chrome-less editor', () => {
-      const meta = MarkdownField.make('body').toolbarButtons([]).toMeta()
-      assert.deepEqual(meta['toolbarButtons'], [])
-    })
-  })
-
-  describe('disableToolbarButtons()', () => {
-    it('drops listed buttons from the default toolbar', () => {
-      const meta = MarkdownField.make('body')
-        .disableToolbarButtons(['attachFiles', 'codeBlock'])
-        .toMeta({ hasUploadAdapter: true })
-      assert.equal((meta['toolbarButtons'] as string[]).includes('attachFiles'), false)
-      assert.equal((meta['toolbarButtons'] as string[]).includes('codeBlock'),   false)
-      assert.equal((meta['toolbarButtons'] as string[]).includes('bold'),        true)
-    })
-
-    it('chains with toolbarButtons() — drops from the most-recently-set list', () => {
-      const meta = MarkdownField.make('body')
-        .toolbarButtons(['bold', 'italic', 'link'])
-        .disableToolbarButtons(['italic'])
-        .toMeta({ hasUploadAdapter: true })
-      assert.deepEqual(meta['toolbarButtons'], ['bold', 'link'])
-    })
-
-    it('no-ops on buttons that are not in the current list', () => {
-      const meta = MarkdownField.make('body')
-        .toolbarButtons(['bold'])
-        .disableToolbarButtons(['attachFiles'])
-        .toMeta({ hasUploadAdapter: true })
-      assert.deepEqual(meta['toolbarButtons'], ['bold'])
-    })
-  })
-
-  describe('attachFiles strip', () => {
-    it('strips attachFiles from toolbar when no upload adapter is configured', () => {
-      const meta = MarkdownField.make('body').toMeta()
-      const toolbar = meta['toolbarButtons'] as string[]
-      assert.equal(toolbar.includes('attachFiles'), false)
-      // every other default button survives
-      assert.equal(toolbar.length, DEFAULT_MARKDOWN_TOOLBAR.length - 1)
-    })
-
-    it('keeps attachFiles when ctx.hasUploadAdapter is true', () => {
-      const meta = MarkdownField.make('body').toMeta({ hasUploadAdapter: true })
-      const toolbar = meta['toolbarButtons'] as string[]
-      assert.equal(toolbar.includes('attachFiles'), true)
-    })
-
-    it('strips attachFiles when uploadUrl is set but adapter flag is not', () => {
-      // Mirrors the "URL stamped but no adapter" failure mode that
-      // should hide the optional affordance.
-      const meta = MarkdownField.make('body').toMeta({ uploadUrl: '/admin/_uploads' })
-      const toolbar = meta['toolbarButtons'] as string[]
-      assert.equal(toolbar.includes('attachFiles'), false)
-      // uploadUrl is also withheld so the renderer can't accidentally
-      // try to POST to a route that has no adapter wired up.
-      assert.equal('uploadUrl' in meta, false)
-    })
-
-    it('emits uploadUrl on meta only when both ctx fields are present', () => {
-      const meta = MarkdownField.make('body').toMeta({
-        uploadUrl:        '/admin/_uploads',
-        hasUploadAdapter: true,
-      })
-      assert.equal(meta['uploadUrl'], '/admin/_uploads')
-    })
-  })
-
-  describe('minHeight / maxHeight', () => {
-    it('emits minHeight when set', () => {
-      const meta = MarkdownField.make('body').minHeight('200px').toMeta()
-      assert.equal(meta['minHeight'], '200px')
-    })
-
-    it('emits maxHeight when set', () => {
-      const meta = MarkdownField.make('body').maxHeight('600px').toMeta()
-      assert.equal(meta['maxHeight'], '600px')
-    })
-  })
-
-  describe('fileAttachmentsDirectory / fileAttachmentsVisibility', () => {
-    it('forwards directory + visibility to meta', () => {
-      const meta = MarkdownField.make('body')
-        .fileAttachmentsDirectory('articles')
-        .fileAttachmentsVisibility('public')
-        .toMeta()
-      assert.equal(meta['fileAttachmentsDirectory'], 'articles')
-      assert.equal(meta['fileAttachmentsVisibility'], 'public')
-    })
-  })
-
-  describe('cross-field plumbing (Plan #6 inheritance)', () => {
-    it('placeholder / required / helperText / default flow through buildMeta', () => {
-      const meta = MarkdownField.make('body')
-        .placeholder('Write in markdown…')
-        .required()
-        .helperText('Markdown formatting supported')
-        .default('# Hello')
-        .toMeta()
-      assert.equal(meta.placeholder, 'Write in markdown…')
-      assert.equal(meta.required, true)
-      assert.equal(meta['helperText'], 'Markdown formatting supported')
-      assert.equal(meta['defaultValue'], '# Hello')
-    })
-  })
-
-  describe('getters', () => {
-    it('expose internal config for tests / introspection', () => {
-      const f = MarkdownField.make('body')
-        .toolbarButtons(['bold', 'italic'])
-        .minHeight('100px')
-        .maxHeight('500px')
-        .fileAttachmentsDirectory('articles')
-        .fileAttachmentsVisibility('private')
-      assert.deepEqual([...f.getToolbarButtons()], ['bold', 'italic'])
-      assert.equal(f.getMinHeight(), '100px')
-      assert.equal(f.getMaxHeight(), '500px')
-      assert.equal(f.getFileAttachmentsDirectory(),  'articles')
-      assert.equal(f.getFileAttachmentsVisibility(), 'private')
-    })
-  })
-})

package/src/fields/MarkdownField.ts

@@ -1,162 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Recognized toolbar buttons. The renderer maps each id to a click handler
- * that splices markdown into the textarea around the current selection.
- * `attachFiles` is special-cased — it requires a panel-level UploadAdapter
- * (`Pilotiq.uploads({ adapter })`) and is stripped server-side from the
- * resolved meta when none is registered.
- */
-export type MarkdownToolbarButton =
-  | 'bold'
-  | 'italic'
-  | 'strike'
-  | 'link'
-  | 'heading'
-  | 'bulletList'
-  | 'orderedList'
-  | 'blockquote'
-  | 'codeBlock'
-  | 'attachFiles'
-
-export type MarkdownAttachmentVisibility = 'public' | 'private'
-
-export const DEFAULT_MARKDOWN_TOOLBAR: readonly MarkdownToolbarButton[] = [
-  'bold',
-  'italic',
-  'strike',
-  'link',
-  'heading',
-  'bulletList',
-  'orderedList',
-  'blockquote',
-  'codeBlock',
-  'attachFiles',
-] as const
-
-/**
- * Markdown editor. The wire format is a plain markdown string under the
- * field name — same shape as `TextareaField`, so no new coerce branch
- * is needed.
- *
- * **Renderer is pluggable.** When `@pilotiq/tiptap` is installed, its
- * `registerTiptap()` hook wires a WYSIWYG editor that parses the
- * markdown into a Tiptap document, exposes a rich-text toolbar, and
- * serializes back to markdown on every change via `tiptap-markdown`.
- * Editor / Source / Preview tabs let users switch between the WYSIWYG
- * view, raw markdown, and a rendered preview without leaving the form.
- * Collab is automatic — when a `<RecordCollabRoom>` is mounted up-tree
- * the editor binds to the shared `Y.XmlFragment` and all peers see live
- * edits, the same way `RichTextField` does. Without `@pilotiq/tiptap`,
- * `MarkdownInput` falls back to a textarea with a formatting toolbar +
- * a preview tab — works fine for panels that don't install the adapter.
- *
- * The toolbar is configurable via `toolbarButtons([…])` /
- * `disableToolbarButtons([…])`; pass `[]` to hide the toolbar entirely.
- *
- * `attachFiles` integrates with the panel's `UploadAdapter` (the same
- * one `FileUpload` uses) — the toolbar button uploads the file via
- * `POST {base}/_uploads` and inserts an `![alt](url)` image (or a
- * `[name](url)` link for non-images). When no adapter is registered,
- * the button is stripped server-side so apps without uploads never see
- * a broken affordance.
- *
- * @example
- * ```ts
- * MarkdownField.make('body')
- *   .label('Article body')
- *   .placeholder('Write in markdown…')
- *   .minHeight('200px')
- *   .maxHeight('600px')
- *   .fileAttachmentsDirectory('articles')
- * ```
- */
-export class MarkdownField extends Field {
-  private _toolbarButtons: MarkdownToolbarButton[] = [...DEFAULT_MARKDOWN_TOOLBAR]
-  private _minHeight?: string
-  private _maxHeight?: string
-  private _fileAttachmentsDirectory?: string
-  private _fileAttachmentsVisibility?: MarkdownAttachmentVisibility
-
-  private constructor(name: string) {
-    super(name, 'markdown')
-  }
-
-  static make(name: string): MarkdownField {
-    return new MarkdownField(name)
-  }
-
-  /**
-   * Replace the toolbar entirely with the given list. Order is preserved.
-   * Pass `[]` for a toolbar-less editor (preview tab still mounts).
-   */
-  toolbarButtons(buttons: MarkdownToolbarButton[]): this {
-    this._toolbarButtons = [...buttons]
-    return this
-  }
-
-  /**
-   * Sugar — drop the listed buttons from the current toolbar without
-   * having to re-spell every survivor. Operates on whatever the current
-   * toolbar list is (the default, or whatever the last `toolbarButtons()`
-   * call set).
-   */
-  disableToolbarButtons(buttons: MarkdownToolbarButton[]): this {
-    const drop = new Set(buttons)
-    this._toolbarButtons = this._toolbarButtons.filter(b => !drop.has(b))
-    return this
-  }
-
-  /** CSS height for the textarea's collapsed state — any valid CSS length. */
-  minHeight(value: string): this { this._minHeight = value; return this }
-
-  /** Cap the textarea's grown height — defaults to no cap. */
-  maxHeight(value: string): this { this._maxHeight = value; return this }
-
-  /**
-   * Sub-directory hint forwarded to the upload adapter alongside the
-   * pasted-image / attached-file payload. Adapters honor it differently
-   * (`localUpload` writes to `<root>/<directory>/...`, S3 prepends to
-   * the key, etc.).
-   */
-  fileAttachmentsDirectory(d: string): this {
-    this._fileAttachmentsDirectory = d
-    return this
-  }
-
-  /** Adapter-defined visibility hint — `'public'` or `'private'`. */
-  fileAttachmentsVisibility(v: MarkdownAttachmentVisibility): this {
-    this._fileAttachmentsVisibility = v
-    return this
-  }
-
-  getToolbarButtons(): readonly MarkdownToolbarButton[] { return this._toolbarButtons }
-  getMinHeight(): string | undefined { return this._minHeight }
-  getMaxHeight(): string | undefined { return this._maxHeight }
-  getFileAttachmentsDirectory(): string | undefined { return this._fileAttachmentsDirectory }
-  getFileAttachmentsVisibility(): MarkdownAttachmentVisibility | undefined { return this._fileAttachmentsVisibility }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    const base = this.buildMeta(ctx)
-    // Strip `attachFiles` server-side when the panel hasn't registered an
-    // upload adapter. Apps without uploads see a clean toolbar with no
-    // broken affordance — distinct from `uploadUrl`, which is always
-    // stamped so `FileUpload` can surface a clear error.
-    const toolbarButtons = ctx?.hasUploadAdapter
-      ? this._toolbarButtons
-      : this._toolbarButtons.filter(b => b !== 'attachFiles')
-    return {
-      ...base,
-      toolbarButtons,
-      ...(this._minHeight !== undefined ? { minHeight: this._minHeight } : {}),
-      ...(this._maxHeight !== undefined ? { maxHeight: this._maxHeight } : {}),
-      ...(this._fileAttachmentsDirectory !== undefined
-            ? { fileAttachmentsDirectory: this._fileAttachmentsDirectory } : {}),
-      ...(this._fileAttachmentsVisibility !== undefined
-            ? { fileAttachmentsVisibility: this._fileAttachmentsVisibility } : {}),
-      ...(ctx?.uploadUrl && ctx?.hasUploadAdapter ? { uploadUrl: ctx.uploadUrl } : {}),
-    }
-  }
-}
-

package/src/fields/NumberField.ts

@@ -1,33 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-export class NumberField extends Field {
-  private _min?: number
-  private _max?: number
-  private _step?: number
-
-  private constructor(name: string) {
-    super(name, 'number')
-  }
-
-  static make(name: string): NumberField {
-    return new NumberField(name)
-  }
-
-  min(n: number): this { this._min = n; return this }
-  max(n: number): this { this._max = n; return this }
-  step(n: number): this { this._step = n; return this }
-
-  getMin(): number | undefined { return this._min }
-  getMax(): number | undefined { return this._max }
-  getStep(): number | undefined { return this._step }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return {
-      ...this.buildMeta(ctx),
-      ...(this._min  !== undefined ? { min:  this._min  } : {}),
-      ...(this._max  !== undefined ? { max:  this._max  } : {}),
-      ...(this._step !== undefined ? { step: this._step } : {}),
-    }
-  }
-}

package/src/fields/RadioField.test.ts

@@ -1,94 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { RadioField, Radio } from './RadioField.js'
-
-describe('RadioField', () => {
-  it('emits fieldType "radio"', async () => {
-    const meta = await RadioField.make('plan').toMeta()
-    assert.equal(meta.fieldType, 'radio')
-  })
-
-  it('exports an alias `Radio`', () => {
-    assert.equal(Radio, RadioField)
-  })
-
-  describe('options(static array)', () => {
-    it('emits options array verbatim', async () => {
-      const meta = await RadioField.make('plan').options([
-        { value: 'free', label: 'Free' },
-        { value: 'pro',  label: 'Pro' },
-      ]).toMeta()
-      assert.deepEqual(meta['options'], [
-        { value: 'free', label: 'Free' },
-        { value: 'pro',  label: 'Pro' },
-      ])
-    })
-
-    it('hasDynamicOptions is false for static arrays', () => {
-      const f = RadioField.make('plan').options([{ value: 'a', label: 'A' }])
-      assert.equal(f.hasDynamicOptions(), false)
-    })
-
-    it('getOptions returns the array', () => {
-      const f = RadioField.make('plan').options([{ value: 'a', label: 'A' }])
-      assert.deepEqual(f.getOptions(), [{ value: 'a', label: 'A' }])
-    })
-  })
-
-  describe('inline()', () => {
-    it('default is vertical (no inline flag emitted)', async () => {
-      const meta = await RadioField.make('x').toMeta()
-      assert.equal('inline' in meta, false)
-    })
-
-    it('inline() emits inline:true', async () => {
-      const meta = await RadioField.make('x').inline().toMeta()
-      assert.equal(meta['inline'], true)
-    })
-
-    it('inline(false) does not emit the flag', async () => {
-      const meta = await RadioField.make('x').inline(false).toMeta()
-      assert.equal('inline' in meta, false)
-    })
-  })
-
-  describe('options(resolver function)', () => {
-    it('runs the resolver against ctx', async () => {
-      const f = RadioField.make('state').options(({ $get }) => {
-        const country = $get?.('country') as string | undefined
-        if (country === 'US') return [{ value: 'CA', label: 'California' }]
-        return [{ value: 'NA', label: 'N/A' }]
-      })
-      assert.equal(f.hasDynamicOptions(), true)
-      const us = await f.toMeta({
-        values: { country: 'US' },
-        $get:   (n) => ({ country: 'US' } as Record<string, unknown>)[n],
-      })
-      assert.deepEqual(us['options'], [{ value: 'CA', label: 'California' }])
-    })
-
-    it('async resolver is awaited', async () => {
-      const f = RadioField.make('items').options(async () => {
-        await new Promise(r => setTimeout(r, 1))
-        return [{ value: 'a', label: 'A' }]
-      })
-      const meta = await f.toMeta()
-      assert.deepEqual(meta['options'], [{ value: 'a', label: 'A' }])
-    })
-
-    it('thrown resolver returns empty options + console.warn', async () => {
-      const original = console.warn
-      const calls: unknown[] = []
-      console.warn = (...args: unknown[]) => { calls.push(args) }
-      try {
-        const f = RadioField.make('broken').options(() => { throw new Error('boom') })
-        const meta = await f.toMeta()
-        assert.deepEqual(meta['options'], [])
-        assert.equal(calls.length, 1)
-      } finally {
-        console.warn = original
-      }
-    })
-  })
-})

package/src/fields/RadioField.ts

@@ -1,67 +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'
-
-/**
- * Single-choice field rendered as a stack of `<input type="radio">`
- * + label rows. Reuses the same `OptionsResolver` shape as
- * `SelectField` so dependent options work the same way: pass an
- * array for static, or a function for `({ $get }) => …`.
- *
- * `inline()` switches the layout from vertical to a horizontal row
- * — convenient for short lists (≤4 options).
- */
-export class RadioField extends Field {
-  private _options: SelectOption[] | OptionsResolver = []
-  private _inline = false
-
-  private constructor(name: string) {
-    super(name, 'radio')
-  }
-
-  static make(name: string): RadioField {
-    return new RadioField(name)
-  }
-
-  options(opts: SelectOption[] | OptionsResolver): this {
-    this._options = opts
-    return this
-  }
-
-  inline(value: boolean = true): this {
-    this._inline = value
-    return this
-  }
-
-  getOptions(): SelectOption[] {
-    return Array.isArray(this._options) ? this._options : []
-  }
-
-  hasDynamicOptions(): boolean {
-    return typeof this._options === 'function'
-  }
-
-  isInline(): boolean { return this._inline }
-
-  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._inline ? { inline: true } : {}),
-    }
-  }
-}
-
-export const Radio = RadioField