@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/fields/TagsInputField.test.ts

@@ -1,154 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { TagsInputField, TagsInput } from './TagsInputField.js'
-
-describe('TagsInputField', () => {
-  it('emits fieldType "tagsInput"', async () => {
-    const meta = await TagsInputField.make('tags').toMeta()
-    assert.equal(meta.fieldType, 'tagsInput')
-  })
-
-  it('exports an alias `TagsInput`', () => {
-    assert.equal(TagsInput, TagsInputField)
-  })
-
-  it('default suggestions is an empty array', async () => {
-    const meta = await TagsInputField.make('tags').toMeta()
-    assert.deepEqual(meta['suggestions'], [])
-  })
-
-  it('omits separator/splitKeys/reorderable/maxTags by default', async () => {
-    const meta = await TagsInputField.make('tags').toMeta()
-    assert.equal('separator'   in meta, false)
-    assert.equal('splitKeys'   in meta, false)
-    assert.equal('reorderable' in meta, false)
-    assert.equal('maxTags'     in meta, false)
-  })
-
-  describe('suggestions(static array)', () => {
-    it('emits suggestions verbatim', async () => {
-      const meta = await TagsInputField.make('tags')
-        .suggestions(['react', 'vue', 'svelte'])
-        .toMeta()
-      assert.deepEqual(meta['suggestions'], ['react', 'vue', 'svelte'])
-    })
-
-    it('hasDynamicSuggestions is false for static arrays', () => {
-      const f = TagsInputField.make('tags').suggestions(['a'])
-      assert.equal(f.hasDynamicSuggestions(), false)
-      assert.deepEqual(f.getSuggestions(), ['a'])
-    })
-  })
-
-  describe('suggestions(resolver function)', () => {
-    it('runs the resolver against ctx', async () => {
-      const f = TagsInputField.make('tags').suggestions(({ $get }) => {
-        const stack = $get?.('stack') as string | undefined
-        if (stack === 'fe') return ['react', 'vue']
-        return ['node', 'rails']
-      })
-      assert.equal(f.hasDynamicSuggestions(), true)
-      const meta = await f.toMeta({
-        values: { stack: 'fe' },
-        $get:   (n) => ({ stack: 'fe' } as Record<string, unknown>)[n],
-      })
-      assert.deepEqual(meta['suggestions'], ['react', 'vue'])
-    })
-
-    it('async resolver is awaited', async () => {
-      const f = TagsInputField.make('tags').suggestions(async () => {
-        await new Promise(r => setTimeout(r, 1))
-        return ['async']
-      })
-      const meta = await f.toMeta()
-      assert.deepEqual(meta['suggestions'], ['async'])
-    })
-
-    it('thrown resolver returns empty suggestions + console.warn', async () => {
-      const original = console.warn
-      const calls: unknown[] = []
-      console.warn = (...args: unknown[]) => { calls.push(args) }
-      try {
-        const f = TagsInputField.make('broken').suggestions(() => { throw new Error('boom') })
-        const meta = await f.toMeta()
-        assert.deepEqual(meta['suggestions'], [])
-        assert.equal(calls.length, 1)
-      } finally {
-        console.warn = original
-      }
-    })
-  })
-
-  describe('separator', () => {
-    it('emits when set to a non-default char', async () => {
-      const meta = await TagsInputField.make('tags').separator(';').toMeta()
-      assert.equal(meta['separator'], ';')
-    })
-
-    it('emits null when explicitly disabled', async () => {
-      const meta = await TagsInputField.make('tags').separator(null).toMeta()
-      assert.equal(meta['separator'], null)
-    })
-
-    it('omits when left at the default ","', async () => {
-      const meta = await TagsInputField.make('tags').separator(',').toMeta()
-      assert.equal('separator' in meta, false)
-    })
-  })
-
-  describe('splitKeys', () => {
-    it('emits when overridden', async () => {
-      const meta = await TagsInputField.make('tags').splitKeys(['Enter', 'Tab']).toMeta()
-      assert.deepEqual(meta['splitKeys'], ['Enter', 'Tab'])
-    })
-
-    it('omits when left at the default ["Enter"]', async () => {
-      const meta = await TagsInputField.make('tags').splitKeys(['Enter']).toMeta()
-      assert.equal('splitKeys' in meta, false)
-    })
-  })
-
-  describe('reorderable', () => {
-    it('emits true when enabled', async () => {
-      const meta = await TagsInputField.make('tags').reorderable().toMeta()
-      assert.equal(meta['reorderable'], true)
-    })
-
-    it('omits when explicitly disabled', async () => {
-      const meta = await TagsInputField.make('tags').reorderable(false).toMeta()
-      assert.equal('reorderable' in meta, false)
-    })
-  })
-
-  describe('maxTags', () => {
-    it('emits when set', async () => {
-      const meta = await TagsInputField.make('tags').maxTags(5).toMeta()
-      assert.equal(meta['maxTags'], 5)
-    })
-
-    it('clamps to >= 1 and floors fractional values', () => {
-      const a = TagsInputField.make('a').maxTags(0)
-      const b = TagsInputField.make('b').maxTags(3.7)
-      assert.equal(a.getMaxTags(), 1)
-      assert.equal(b.getMaxTags(), 3)
-    })
-  })
-
-  it('participates in cross-field plumbing (default / required / live / helperText)', async () => {
-    const f = TagsInputField.make('tags')
-      .label('Tags')
-      .required()
-      .default(['draft'])
-      .helperText('Press Enter to add')
-      .live()
-      .suggestions(['draft', 'published'])
-    const meta = await f.toMeta()
-    assert.equal(meta.fieldType,        'tagsInput')
-    assert.equal(meta.required,         true)
-    assert.equal(meta.label,            'Tags')
-    assert.equal(meta['helperText'],    'Press Enter to add')
-    assert.equal(meta['live'],          true)
-    assert.deepEqual(meta['defaultValue'], ['draft'])
-  })
-})

package/src/fields/TagsInputField.ts

@@ -1,133 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Suggestions resolver. Simpler shape than `OptionsResolver` because
- * a tag is its own label — the suggestion list is `string[]`, not
- * `{value,label}[]`. Layer SelectOption-shaped suggestions later if
- * a real consumer needs label / value to diverge.
- */
-export type TagsSuggestionsResolver = (ctx: {
-  $get?:   (name: string) => unknown
-  values?: Record<string, unknown>
-  record?: unknown
-  user?:   unknown
-}) => string[] | Promise<string[]>
-
-async function resolveSuggestions(
-  source:    string[] | TagsSuggestionsResolver,
-  ctx:       RenderContext | undefined,
-  fieldName: string,
-): Promise<string[]> {
-  if (Array.isArray(source)) return source
-  try {
-    return await source({
-      ...(ctx?.$get   ? { $get:   ctx.$get   } : {}),
-      ...(ctx?.values ? { values: ctx.values } : {}),
-      ...(ctx?.record !== undefined ? { record: ctx.record } : {}),
-      ...(ctx?.user   !== undefined ? { user:   ctx.user   } : {}),
-    })
-  } catch (err) {
-    console.warn(`[pilotiq] suggestions() resolver for "${fieldName}" threw:`, err)
-    return []
-  }
-}
-
-/**
- * Free-text multi-tag input. Value is `string[]`. The client renders
- * pill-shaped chips per committed tag plus a single inline text input;
- * pressing Enter (or any of `splitKeys`) commits the current draft to
- * the chip set. Pasting a string containing `separator` splits into
- * multiple chips at once. Backspace on an empty draft removes the last
- * chip.
- *
- * Wire format mirrors `KeyValue` — the client serializes the chip set
- * as a JSON string in a single hidden input and `coerceFormValues`
- * parses it back into `string[]`. Avoids the multi-input-with-same-name
- * footguns across `application/x-www-form-urlencoded` and
- * `multipart/form-data` bodies.
- */
-export class TagsInputField extends Field {
-  private _suggestions: string[] | TagsSuggestionsResolver = []
-  private _separator:   string | null = ','
-  private _splitKeys:   string[] = ['Enter']
-  private _reorderable = false
-  private _maxTags:     number | null = null
-
-  private constructor(name: string) {
-    super(name, 'tagsInput')
-  }
-
-  static make(name: string): TagsInputField {
-    return new TagsInputField(name)
-  }
-
-  suggestions(opts: string[] | TagsSuggestionsResolver): this {
-    this._suggestions = opts
-    return this
-  }
-
-  /**
-   * Single character that splits a pasted string into multiple tags.
-   * Pass `null` to disable paste-splitting; only `splitKeys` then
-   * commits a draft.
-   */
-  separator(char: string | null): this {
-    this._separator = char
-    return this
-  }
-
-  /**
-   * Keys that commit the current draft to the chip set. Defaults to
-   * `['Enter']`. Common addition: `['Enter', 'Tab', ',']`. The
-   * separator char is automatically treated as a split key as well.
-   */
-  splitKeys(keys: string[]): this {
-    this._splitKeys = keys
-    return this
-  }
-
-  /** Allow chip reorder via native HTML5 drag-and-drop. Off by default — most
-   * tag sets are insertion-ordered or alphabetized, and the chip strip is small
-   * enough that drag affordances are noisy when unused. */
-  reorderable(value: boolean = true): this {
-    this._reorderable = value
-    return this
-  }
-
-  /** Cap the chip count. Surfaces to validation-renderer + client guard. */
-  maxTags(n: number): this {
-    this._maxTags = Math.max(1, Math.floor(n))
-    return this
-  }
-
-  hasDynamicSuggestions(): boolean {
-    return typeof this._suggestions === 'function'
-  }
-
-  getSuggestions(): string[] {
-    return Array.isArray(this._suggestions) ? this._suggestions : []
-  }
-
-  getSeparator(): string | null { return this._separator }
-  getSplitKeys(): string[]      { return this._splitKeys }
-  isReorderable(): boolean      { return this._reorderable }
-  getMaxTags(): number | null   { return this._maxTags }
-
-  override async toMeta(ctx?: RenderContext): Promise<FieldMeta> {
-    const base        = this.buildMeta(ctx)
-    const suggestions = await resolveSuggestions(this._suggestions, ctx, this.name)
-    return {
-      ...base,
-      suggestions,
-      ...(this._separator !== ',' ? { separator: this._separator } : {}),
-      ...(this._splitKeys.length !== 1 || this._splitKeys[0] !== 'Enter'
-            ? { splitKeys: this._splitKeys }
-            : {}),
-      ...(this._reorderable ? { reorderable: true } : {}),
-      ...(this._maxTags     ? { maxTags: this._maxTags } : {}),
-    }
-  }
-}
-
-export const TagsInput = TagsInputField

package/src/fields/TextField.test.ts

@@ -1,213 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { TextField } from './TextField.js'
-import { Action } from '../actions/Action.js'
-import { resolveSchema } from '../schema/resolveSchema.js'
-import { coerceFormValues } from '../elements/dispatchForm.js'
-import { formatWithMask } from '../react/fields/textInputControls.js'
-
-describe('TextField rich affordances (audit gap #3)', () => {
-  describe('password / revealable', () => {
-    it('emits password + revealable flags only when set', () => {
-      const a = TextField.make('p').password().revealable().toMeta()
-      assert.equal(a['password'],   true)
-      assert.equal(a['revealable'], true)
-
-      const b = TextField.make('p').toMeta()
-      assert.equal(b['password'],   undefined)
-      assert.equal(b['revealable'], undefined)
-    })
-
-    it('disarms with explicit false', () => {
-      const a = TextField.make('p').password(false).toMeta()
-      assert.equal(a['password'], undefined)
-    })
-  })
-
-  describe('copyable', () => {
-    it('flag emits and message defaults are sparse', () => {
-      const a = TextField.make('x').copyable().toMeta()
-      assert.equal(a['copyable'],     true)
-      assert.equal(a['copyMessage'],  undefined)
-
-      const b = TextField.make('x').copyable('Got it').toMeta()
-      assert.equal(b['copyable'],     true)
-      assert.equal(b['copyMessage'],  'Got it')
-    })
-  })
-
-  describe('mask', () => {
-    it('emits the pattern verbatim', () => {
-      const a = TextField.make('phone').mask('(999) 999-9999').toMeta()
-      assert.equal(a['mask'], '(999) 999-9999')
-    })
-  })
-
-  describe('datalist', () => {
-    it('emits a defensive copy of the values array', () => {
-      const values = ['gmail.com', 'outlook.com']
-      const a = TextField.make('email').datalist(values).toMeta()
-      const out = a['datalist'] as string[]
-      assert.deepEqual(out, values)
-      // Mutating the original after the fact must not leak in.
-      values.push('yahoo.com')
-      assert.deepEqual(a['datalist'], ['gmail.com', 'outlook.com'])
-    })
-  })
-
-  describe('stripCharacters', () => {
-    it('accepts a string of single chars', () => {
-      const a = TextField.make('phone').stripCharacters('()- ').toMeta()
-      assert.deepEqual(a['stripCharacters'], ['(', ')', '-', ' '])
-    })
-
-    it('accepts an explicit array', () => {
-      const a = TextField.make('phone').stripCharacters(['(', ')']).toMeta()
-      assert.deepEqual(a['stripCharacters'], ['(', ')'])
-    })
-
-    it('omits when empty', () => {
-      const a = TextField.make('x').stripCharacters('').toMeta()
-      assert.equal(a['stripCharacters'], undefined)
-    })
-
-    it('strips configured chars during coerce', () => {
-      const f = TextField.make('phone').stripCharacters('()- ')
-      const out = coerceFormValues([f], { phone: '(415) 555-1212' })
-      assert.equal(out['phone'], '4155551212')
-    })
-
-    it('coerce no-ops when not configured', () => {
-      const f = TextField.make('plain')
-      const out = coerceFormValues([f], { plain: 'a-b-c' })
-      assert.equal(out['plain'], 'a-b-c')
-    })
-
-    it('coerce skips non-string values', () => {
-      const f = TextField.make('plain').stripCharacters('-')
-      const out = coerceFormValues([f], { plain: 42 as unknown as string })
-      assert.equal(out['plain'], 42)
-    })
-  })
-
-  describe('trim', () => {
-    it('emits the flag only when set', () => {
-      const a = TextField.make('x').trim().toMeta()
-      assert.equal(a['trim'], true)
-
-      const b = TextField.make('x').toMeta()
-      assert.equal(b['trim'], undefined)
-    })
-
-    it('disarms with explicit false', () => {
-      const a = TextField.make('x').trim(false).toMeta()
-      assert.equal(a['trim'], undefined)
-    })
-
-    it('strips leading and trailing whitespace during coerce', () => {
-      const f = TextField.make('email').trim()
-      const out = coerceFormValues([f], { email: '   user@example.com\n' })
-      assert.equal(out['email'], 'user@example.com')
-    })
-
-    it('coerce no-ops when not configured', () => {
-      const f = TextField.make('plain')
-      const out = coerceFormValues([f], { plain: '  spaced  ' })
-      assert.equal(out['plain'], '  spaced  ')
-    })
-
-    it('coerce skips non-string values', () => {
-      const f = TextField.make('x').trim()
-      const out = coerceFormValues([f], { x: 42 as unknown as string })
-      assert.equal(out['x'], 42)
-    })
-
-    it('runs before stripCharacters when both are set', () => {
-      const f = TextField.make('phone').trim().stripCharacters('()- ')
-      const out = coerceFormValues([f], { phone: '  (415) 555-1212  ' })
-      assert.equal(out['phone'], '4155551212')
-    })
-
-    it('preserves empty strings', () => {
-      const f = TextField.make('x').trim()
-      const out = coerceFormValues([f], { x: '   ' })
-      assert.equal(out['x'], '')
-    })
-  })
-
-  describe('inputMode + autocapitalize', () => {
-    it('emits each attribute when set', () => {
-      const a = TextField.make('q').inputMode('search').autocapitalize('off').toMeta()
-      assert.equal(a['inputMode'],      'search')
-      assert.equal(a['autocapitalize'], 'off')
-    })
-
-    it('omits each attribute when unset', () => {
-      const a = TextField.make('q').toMeta()
-      assert.equal(a['inputMode'],      undefined)
-      assert.equal(a['autocapitalize'], undefined)
-    })
-  })
-
-  describe('prefixAction / suffixAction', () => {
-    it('resolves bound Actions through resolveSchema as ActionMetas', async () => {
-      const result = await resolveSchema([
-        TextField.make('apiKey')
-          .prefixAction(Action.make('generate').icon('plus'))
-          .suffixAction(Action.make('rotate').icon('refresh')),
-      ])
-      const meta = result[0]!
-      const pre = meta['prefixAction'] as Record<string, unknown> | undefined
-      const suf = meta['suffixAction'] as Record<string, unknown> | undefined
-      assert.equal(pre?.['type'], 'action')
-      assert.equal(pre?.['name'], 'generate')
-      assert.equal(suf?.['type'], 'action')
-      assert.equal(suf?.['name'], 'rotate')
-    })
-
-    it('drops a hidden Action from the slot', async () => {
-      const result = await resolveSchema([
-        TextField.make('q').prefixAction(Action.make('hide').visible(false)),
-      ])
-      assert.equal(result[0]!['prefixAction'], undefined)
-    })
-
-    it('omits the slots when not configured', async () => {
-      const result = await resolveSchema([TextField.make('q')])
-      assert.equal(result[0]!['prefixAction'], undefined)
-      assert.equal(result[0]!['suffixAction'], undefined)
-    })
-  })
-})
-
-describe('formatWithMask (client mask helper)', () => {
-  it('formats a US phone via the documented alphabet', () => {
-    assert.equal(formatWithMask('4155551212', '(999) 999-9999'), '(415) 555-1212')
-  })
-
-  it('emits literals even with no remaining input', () => {
-    assert.equal(formatWithMask('415', '(999) 999-9999'), '(415) ')
-  })
-
-  it('skips characters that do not match the token kind', () => {
-    assert.equal(formatWithMask('a4b1c5', '999'), '415')
-  })
-
-  it('handles alpha tokens', () => {
-    assert.equal(formatWithMask('xy12', 'aa-99'), 'xy-12')
-  })
-
-  it('any-token (*) accepts any character', () => {
-    assert.equal(formatWithMask('a1b2', '****'), 'a1b2')
-  })
-
-  it('does NOT double-emit literals already typed by the user', () => {
-    assert.equal(formatWithMask('(415)5551212', '(999) 999-9999'), '(415) 555-1212')
-  })
-
-  it('returns input unchanged when mask is empty', () => {
-    assert.equal(formatWithMask('hello', ''), '')
-  })
-})
-

package/src/fields/TextField.ts

@@ -1,177 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-import type { Action } from '../actions/Action.js'
-
-/**
- * HTML5 `inputmode` values — drive the on-screen keyboard mobile browsers
- * pop up. `'text'` is the default; the others map 1:1 to spec values.
- */
-export type TextInputMode =
-  | 'none' | 'text' | 'numeric' | 'tel' | 'email' | 'decimal' | 'search' | 'url'
-
-/**
- * HTML5 `autocapitalize` values — control which characters mobile virtual
- * keyboards capitalize automatically. `'off'` and `'none'` are aliases per
- * spec; we surface only `'off'` for clarity.
- */
-export type TextAutocapitalize = 'off' | 'sentences' | 'words' | 'characters'
-
-/**
- * Mask alphabet documented for `mask(pattern)`:
- *   `9` — digit (0-9)
- *   `a` — alpha (A-Za-z)
- *   `*` — alphanumeric or any character
- *   anything else — literal (rendered verbatim, skipped on input)
- *
- * Examples: `'(999) 999-9999'` (US phone), `'9999-9999-9999-9999'` (card),
- * `'aaa-9999'` (custom). The renderer formats values keystroke-by-keystroke
- * and strips literals from the submitted value so the persisted column
- * stores the raw digits/letters.
- */
-
-export class TextField extends Field {
-  private _maxLength?: number
-  private _password   = false
-  private _revealable = false
-  private _copyable   = false
-  private _copyMessage?: string
-  private _mask?:        string
-  private _datalist?:    string[]
-  private _stripCharacters?: string[]
-  private _trim              = false
-  private _inputMode?:        TextInputMode
-  private _autocapitalize?:   TextAutocapitalize
-  private _prefixAction?: Action
-  private _suffixAction?: Action
-
-  private constructor(name: string) {
-    super(name, 'text')
-  }
-
-  static make(name: string): TextField {
-    return new TextField(name)
-  }
-
-  maxLength(n: number): this { this._maxLength = n; return this }
-  getMaxLength(): number | undefined { return this._maxLength }
-
-  /**
-   * Render the input as `type="password"`. Pair with `revealable()` to
-   * surface an eye-icon toggle. Pure presentation — the column type +
-   * value handling stays string-shaped.
-   */
-  password(v: boolean = true): this { this._password = v; return this }
-
-  /**
-   * Mount an eye-icon toggle in the suffix slot that flips the input
-   * type between `password` and `text`. No-op when the field is not in
-   * `password()` mode (the toggle hides itself client-side so a stray
-   * `revealable()` on a non-password input doesn't render a useless
-   * button).
-   */
-  revealable(v: boolean = true): this { this._revealable = v; return this }
-
-  /**
-   * Mount a copy button in the suffix slot that writes the current input
-   * value to the clipboard. The optional message overrides the default
-   * `'Copied!'` toast text — same convention as
-   * `Column.copyMessage()`.
-   */
-  copyable(message?: string): this {
-    this._copyable     = true
-    if (message !== undefined) this._copyMessage = message
-    return this
-  }
-
-  /**
-   * Format the input keystroke-by-keystroke against the supplied mask
-   * pattern. See `TextField` doc-block for the alphabet (`9` = digit,
-   * `a` = alpha, `*` = any, literals passthrough). Submitted values are
-   * stripped of literal characters before the form body lands on the
-   * server — the persisted column stores the raw chars only.
-   */
-  mask(pattern: string): this { this._mask = pattern; return this }
-
-  /**
-   * Suggest values via a native HTML5 `<datalist>` attached to the
-   * input. Browsers render an autocomplete dropdown; users can still
-   * type a value not on the list. Useful for canonical-but-not-exclusive
-   * sets (countries, departments, common email domains).
-   */
-  datalist(values: string[]): this { this._datalist = values.slice(); return this }
-
-  /**
-   * Strip the listed characters from the submitted value before
-   * validation runs. Pass a single string (each char becomes a strip
-   * token) or an array of strings. Useful for input-mask-style fields
-   * where the persisted column should not carry the mask literals
-   * (`'(' / ')' / '-' / ' '` for phone numbers, `' '` for credit cards).
-   * The strip applies on both create and edit — server-side authority,
-   * so a tampered client still gets cleaned values.
-   */
-  stripCharacters(chars: string | string[]): this {
-    const list = typeof chars === 'string' ? Array.from(chars) : [...chars]
-    if (list.length === 0) delete this._stripCharacters
-    else this._stripCharacters = list
-    return this
-  }
-
-  getStripCharacters(): string[] | undefined { return this._stripCharacters }
-
-  /**
-   * Strip leading and trailing whitespace from the submitted value
-   * before validation runs. Mirrors Laravel's `TrimStrings` middleware
-   * — server-side authority, so a tampered client still gets trimmed
-   * values. Composes with `stripCharacters()` (trim runs first). Empty
-   * strings remain empty; non-string values pass through.
-   */
-  trim(v: boolean = true): this { this._trim = v; return this }
-
-  getTrim(): boolean { return this._trim }
-
-  /**
-   * Set the HTML `inputmode` attribute — drives the virtual-keyboard
-   * layout on mobile. Distinct from `type=` (a `text` field with
-   * `inputMode('numeric')` still accepts non-digit pastes; for strict
-   * numeric-only, use `NumberField` instead).
-   */
-  inputMode(mode: TextInputMode): this { this._inputMode = mode; return this }
-
-  /** Set the HTML `autocapitalize` attribute. */
-  autocapitalize(mode: TextAutocapitalize): this { this._autocapitalize = mode; return this }
-
-  /**
-   * Mount a clickable Action button in the prefix slot of the input
-   * shell. Distinct from the passive `prefix()` decoration (which is a
-   * string or icon descriptor only). Use this for an in-input affordance
-   * — e.g. an OAuth-style "Generate" button next to an API key field.
-   * The Action retains its full chrome (`.icon() / .color() / .visible()
-   * / .modal*()`); visibility rules evaluate through the standard schema
-   * walker the same way they do anywhere else.
-   */
-  prefixAction(action: Action): this { this._prefixAction = action; return this }
-
-  /** Suffix-slot variant of `prefixAction`. Same semantics. */
-  suffixAction(action: Action): this { this._suffixAction = action; return this }
-
-  /** Read-only access for the resolver. */
-  getPrefixAction(): Action | undefined { return this._prefixAction }
-  getSuffixAction(): Action | undefined { return this._suffixAction }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return {
-      ...this.buildMeta(ctx),
-      ...(this._maxLength      !== undefined ? { maxLength:      this._maxLength      } : {}),
-      ...(this._password                       ? { password:       true                  } : {}),
-      ...(this._revealable                     ? { revealable:     true                  } : {}),
-      ...(this._copyable                       ? { copyable:       true                  } : {}),
-      ...(this._copyMessage    !== undefined ? { copyMessage:    this._copyMessage    } : {}),
-      ...(this._mask           !== undefined ? { mask:           this._mask           } : {}),
-      ...(this._datalist       !== undefined ? { datalist:       this._datalist       } : {}),
-      ...(this._stripCharacters!== undefined ? { stripCharacters:this._stripCharacters} : {}),
-      ...(this._trim                           ? { trim:            true                  } : {}),
-      ...(this._inputMode      !== undefined ? { inputMode:      this._inputMode      } : {}),
-      ...(this._autocapitalize !== undefined ? { autocapitalize: this._autocapitalize } : {}),
-    }
-  }
-}