@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/entries/TextEntry.test.ts

@@ -1,394 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { resolveSchema, _resetResolverRegistry } from '../schema/resolveSchema.js'
-import { TextEntry, type TextEntryMeta } from './TextEntry.js'
-import { Entry, isEntry, type EntryMeta } from './Entry.js'
-import {
-  registerRichTextRenderer,
-  _resetRichTextRegistryForTests,
-} from '../richtext/registry.js'
-
-beforeEach(() => _resetResolverRegistry())
-
-describe('Entry base', () => {
-  it('extends Element', () => {
-    const e = TextEntry.make('email')
-    assert.equal(e.getType(), 'entry')
-    assert.equal(e instanceof Entry, true)
-    assert.equal(isEntry(e), true)
-  })
-
-  it('derives label from camelCase name', async () => {
-    const out = await resolveSchema([TextEntry.make('publishedAt')], { record: { publishedAt: '2026-01-01' } })
-    assert.equal((out[0] as EntryMeta).label, 'Published At')
-  })
-
-  it('derives label from snake_case name', async () => {
-    const out = await resolveSchema([TextEntry.make('first_name')], { record: { first_name: 'Ada' } })
-    assert.equal((out[0] as EntryMeta).label, 'First name')
-  })
-
-  it('derives label from kebab-case name', async () => {
-    const out = await resolveSchema([TextEntry.make('first-name')], { record: { 'first-name': 'Ada' } })
-    assert.equal((out[0] as EntryMeta).label, 'First name')
-  })
-
-  it('label() override wins', async () => {
-    const out = await resolveSchema([TextEntry.make('email').label('Contact')], { record: { email: 'a@b.c' } })
-    assert.equal((out[0] as EntryMeta).label, 'Contact')
-  })
-})
-
-describe('TextEntry — state resolution', () => {
-  it('reads from ctx.record', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('email')],
-      { record: { email: 'foo@bar.com' } },
-    )
-    const meta = out[0] as EntryMeta
-    assert.equal(meta.type, 'entry')
-    assert.equal(meta.entryType, 'text')
-    assert.equal(meta.name, 'email')
-    assert.equal(meta.value, 'foo@bar.com')
-  })
-
-  it('value undefined when no record', async () => {
-    const out = await resolveSchema([TextEntry.make('email')])
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-
-  it('value undefined when record is missing the attribute', async () => {
-    const out = await resolveSchema([TextEntry.make('email')], { record: { name: 'Ada' } })
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-})
-
-describe('Entry.state() — nested-path / accessor override', () => {
-  it('string dotted path reads from a nested record', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('authorName').state('author.name')],
-      { record: { author: { name: 'Ada Lovelace' } } },
-    )
-    assert.equal((out[0] as EntryMeta).value, 'Ada Lovelace')
-  })
-
-  it('string path with array index', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('firstTag').state('tags.0.label')],
-      { record: { tags: [{ label: 'physics' }, { label: 'math' }] } },
-    )
-    assert.equal((out[0] as EntryMeta).value, 'physics')
-  })
-
-  it('missing intermediate resolves to undefined (no throw)', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('authorName').state('author.name')],
-      { record: { author: null } },
-    )
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-
-  it('missing leaf resolves to undefined', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('authorName').state('author.name')],
-      { record: { author: { email: 'x@y.z' } } },
-    )
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-
-  it('function accessor receives full record', async () => {
-    const out = await resolveSchema(
-      [
-        TextEntry.make('total').state(
-          (r) => Number((r as { subtotal: number }).subtotal) + Number((r as { tax: number }).tax),
-        ),
-      ],
-      { record: { subtotal: 100, tax: 7 } },
-    )
-    assert.equal((out[0] as EntryMeta).value, 107)
-  })
-
-  it('throwing accessor fails soft (value=undefined, no crash)', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('x').state(() => { throw new Error('boom') })],
-      { record: { x: 1 } },
-    )
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-
-  it('label still derives from name, not the path', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('authorName').state('author.name')],
-      { record: { author: { name: 'Ada' } } },
-    )
-    assert.equal((out[0] as EntryMeta).label, 'Author Name')
-  })
-
-  it('state() override wins over the implicit record[name] lookup', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('email').state(() => 'overridden@x.y')],
-      { record: { email: 'shadowed@x.y' } },
-    )
-    assert.equal((out[0] as EntryMeta).value, 'overridden@x.y')
-  })
-
-  it('state() composes with formatStateUsing — formatter receives resolved value', async () => {
-    const out = await resolveSchema(
-      [
-        TextEntry.make('authorName')
-          .state('author.name')
-          .formatStateUsing((v) => String(v).toUpperCase()),
-      ],
-      { record: { author: { name: 'ada' } } },
-    )
-    assert.equal((out[0] as EntryMeta)._formatted, 'ADA')
-  })
-
-  it('numeric path segment against non-array yields undefined', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('x').state('a.0')],
-      { record: { a: { name: 'oops' } } },
-    )
-    // descends into `a` (an object), then asks for key '0' — yields undefined
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-
-  it('non-integer path segment against array yields undefined', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('x').state('a.foo')],
-      { record: { a: [1, 2, 3] } },
-    )
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-
-  it('walking past a primitive yields undefined', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('x').state('a.b')],
-      { record: { a: 'string' } },
-    )
-    assert.equal((out[0] as EntryMeta).value, undefined)
-  })
-})
-
-describe('TextEntry — chrome', () => {
-  it('inlineLabel / default / helperText / tooltip', async () => {
-    const out = await resolveSchema(
-      [
-        TextEntry.make('amount')
-          .inlineLabel()
-          .default('—')
-          .helperText('USD per unit')
-          .tooltip('Pre-tax'),
-      ],
-      { record: { amount: 12 } },
-    )
-    const m = out[0] as EntryMeta
-    assert.equal(m.inlineLabel, true)
-    assert.equal(m.default,    '—')
-    assert.equal(m.helperText, 'USD per unit')
-    assert.equal(m.tooltip,    'Pre-tax')
-  })
-
-  it('placeholder() is an alias for default()', async () => {
-    const out = await resolveSchema([TextEntry.make('x').placeholder('n/a')], { record: { x: null } })
-    assert.equal((out[0] as EntryMeta).default, 'n/a')
-  })
-
-  it('weight / color / size', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('title').weight('semibold').color('primary').size('lg')],
-      { record: { title: 'Hello' } },
-    )
-    const m = out[0] as EntryMeta
-    assert.equal(m.weight, 'semibold')
-    assert.equal(m.color,  'primary')
-    assert.equal(m.size,   'lg')
-  })
-
-  it('lineClamp / wrap', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('body').lineClamp(2), TextEntry.make('body').wrap()],
-      { record: { body: 'long' } },
-    )
-    assert.equal((out[0] as EntryMeta).lineClamp, 2)
-    assert.equal((out[1] as EntryMeta).wrap,      true)
-  })
-
-  it('chrome flags omitted when not set', async () => {
-    const out = await resolveSchema([TextEntry.make('x')], { record: { x: 1 } })
-    const m = out[0] as EntryMeta
-    assert.equal(m.inlineLabel, undefined)
-    assert.equal(m.default,     undefined)
-    assert.equal(m.helperText,  undefined)
-    assert.equal(m.tooltip,     undefined)
-    assert.equal(m.weight,      undefined)
-    assert.equal(m.color,       undefined)
-    assert.equal(m.size,        undefined)
-    assert.equal(m.format,      undefined)
-    assert.equal(m.copyable,    undefined)
-    assert.equal(m.lineClamp,   undefined)
-    assert.equal(m.wrap,        undefined)
-    assert.equal(m._formatted,  undefined)
-  })
-})
-
-describe('TextEntry — built-in formatters', () => {
-  it('since()', async () => {
-    const out = await resolveSchema([TextEntry.make('createdAt').since()], { record: { createdAt: '2026-01-01' } })
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'since' })
-  })
-
-  it('dateTime() — no pattern', async () => {
-    const out = await resolveSchema([TextEntry.make('createdAt').dateTime()], { record: { createdAt: '2026-01-01' } })
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'dateTime' })
-  })
-
-  it('dateTime("Y-m-d") — with pattern', async () => {
-    const out = await resolveSchema([TextEntry.make('createdAt').dateTime('Y-m-d')], { record: { createdAt: '2026-01-01' } })
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'dateTime', pattern: 'Y-m-d' })
-  })
-
-  it('money(USD)', async () => {
-    const out = await resolveSchema([TextEntry.make('amount').money('USD')], { record: { amount: 100 } })
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'money', currency: 'USD' })
-  })
-
-  it('money(EUR, "de-DE")', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('amount').money('EUR', 'de-DE')],
-      { record: { amount: 100 } },
-    )
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'money', currency: 'EUR', locale: 'de-DE' })
-  })
-
-  it('numeric({ decimals: 2 })', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('amount').numeric({ decimals: 2 })],
-      { record: { amount: 1.5 } },
-    )
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'numeric', decimals: 2 })
-  })
-
-  it('limit(20)', async () => {
-    const out = await resolveSchema([TextEntry.make('body').limit(20)], { record: { body: 'a' } })
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'limit', chars: 20 })
-  })
-
-  it('the last formatter wins', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('createdAt').since().dateTime('Y-m-d')],
-      { record: { createdAt: '2026-01-01' } },
-    )
-    assert.deepEqual((out[0] as EntryMeta).format, { kind: 'dateTime', pattern: 'Y-m-d' })
-  })
-})
-
-describe('TextEntry — formatStateUsing', () => {
-  it('runs at resolve and stamps _formatted', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('amount').formatStateUsing((v, r) => `${v} (id=${(r as { id?: number }).id})`)],
-      { record: { id: 7, amount: 42 } },
-    )
-    assert.equal((out[0] as EntryMeta)._formatted, '42 (id=7)')
-  })
-
-  it('throwing handler fails soft (no _formatted, no crash)', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('amount').formatStateUsing(() => { throw new Error('boom') })],
-      { record: { amount: 42 } },
-    )
-    assert.equal((out[0] as EntryMeta)._formatted, undefined)
-  })
-})
-
-describe('TextEntry — copyable', () => {
-  it('bare copyable() emits empty object', async () => {
-    const out = await resolveSchema([TextEntry.make('email').copyable()], { record: { email: 'a@b.c' } })
-    assert.deepEqual((out[0] as EntryMeta).copyable, {})
-  })
-
-  it('copyable("Copy email") carries the label', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('email').copyable('Copy email')],
-      { record: { email: 'a@b.c' } },
-    )
-    assert.deepEqual((out[0] as EntryMeta).copyable, { label: 'Copy email' })
-  })
-})
-
-describe('TextEntry — richtext auto-render', () => {
-  beforeEach(() => _resetRichTextRegistryForTests())
-
-  it('no-ops without a registered renderer', async () => {
-    const doc = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'x' }] }] }
-    const out = await resolveSchema([TextEntry.make('body')], { record: { body: doc } })
-    const meta = out[0] as TextEntryMeta
-    assert.equal(meta._formatted, undefined)
-    assert.equal(meta.richtext, undefined)
-  })
-
-  it('stamps _formatted + richtext: true when a renderer is registered and the value matches', async () => {
-    registerRichTextRenderer(
-      () => '<p>rendered</p>',
-      (v) => typeof v === 'object' && v !== null && (v as { type?: unknown }).type === 'doc',
-    )
-    const doc = { type: 'doc', content: [] }
-    const out = await resolveSchema([TextEntry.make('body')], { record: { body: doc } })
-    const meta = out[0] as TextEntryMeta
-    assert.equal(meta._formatted, '<p>rendered</p>')
-    assert.equal(meta.richtext, true)
-  })
-
-  it('skips auto-render when formatStateUsing is set (user formatter wins)', async () => {
-    registerRichTextRenderer(() => '<p>rendered</p>', () => true)
-    const doc = { type: 'doc', content: [] }
-    const out = await resolveSchema(
-      [TextEntry.make('body').formatStateUsing(() => 'plain')],
-      { record: { body: doc } },
-    )
-    const meta = out[0] as TextEntryMeta
-    assert.equal(meta._formatted, 'plain')
-    assert.equal(meta.richtext, undefined)
-  })
-
-  it('skips auto-render when format is set (built-in formatter wins)', async () => {
-    registerRichTextRenderer(() => '<p>rendered</p>', () => true)
-    const out = await resolveSchema(
-      [TextEntry.make('publishedAt').dateTime()],
-      { record: { publishedAt: '2026-01-01T00:00:00Z' } },
-    )
-    const meta = out[0] as TextEntryMeta
-    assert.equal(meta.richtext, undefined)
-    assert.ok(meta.format)
-  })
-
-  it('skips auto-render when value does not match the detector', async () => {
-    registerRichTextRenderer(
-      () => '<p>rendered</p>',
-      (v) => typeof v === 'object' && v !== null && (v as { type?: unknown }).type === 'doc',
-    )
-    const out = await resolveSchema([TextEntry.make('body')], { record: { body: 'plain text' } })
-    const meta = out[0] as TextEntryMeta
-    assert.equal(meta._formatted, undefined)
-    assert.equal(meta.richtext, undefined)
-  })
-})
-
-describe('TextEntry — layout-level integration', () => {
-  it('honors visible(false)', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('email').visible(false)],
-      { record: { email: 'a@b.c' } },
-    )
-    assert.equal(out.length, 0)
-  })
-
-  it('honors columnSpan() under a parent grid', async () => {
-    const out = await resolveSchema(
-      [TextEntry.make('email').columnSpan(2)],
-      { record: { email: 'a@b.c' } },
-    )
-    assert.deepEqual((out[0] as EntryMeta)._layout, { columnSpan: 2 })
-  })
-})

package/src/entries/TextEntry.ts

@@ -1,60 +0,0 @@
-import { tryRenderRichText } from '../richtext/registry.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-import { Entry, type EntryMeta } from './Entry.js'
-
-export interface TextEntryMeta extends EntryMeta {
-  /** True when the value was auto-rendered from Tiptap rich-text content;
-   *  the renderer should inject the value via `dangerouslySetInnerHTML`
-   *  rather than escape it as plain text. */
-  richtext?: true
-}
-
-/**
- * The default infolist entry. Renders a label-value pair with the value
- * as plain text; honors all the inherited chrome (`color / weight / size
- * / lineClamp / wrap / tooltip / copyable`) and built-in formatters
- * (`since / dateTime / money / numeric / limit`).
- *
- * **Rich-text auto-render:** when an adapter package has registered a
- * renderer (`@pilotiq/tiptap` does this on `registerTiptap()`) and the
- * resolved value is recognizably Tiptap content, `TextEntry` ships
- * finished HTML in `_formatted` and flips `richtext: true` so the client
- * renders the markup. No-op when no renderer is registered or the value
- * is plain text.
- *
- * @example
- * Resource.detail(record) {
- *   return [
- *     TextEntry.make('email').copyable(),
- *     TextEntry.make('publishedAt').since(),
- *     TextEntry.make('amount').money('USD').weight('semibold'),
- *     TextEntry.make('body'),                       // auto-renders Tiptap JSON
- *   ]
- * }
- */
-export class TextEntry extends Entry {
-  private constructor(name: string) {
-    super(name)
-  }
-
-  static make(name: string): TextEntry {
-    return new TextEntry(name)
-  }
-
-  protected override getEntryType(): string { return 'text' }
-
-  override toMeta(ctx?: RenderContext): TextEntryMeta {
-    // Parent runs `formatStateUsing` first — it wins over auto-render so a
-    // user-supplied formatter can opt out of HTML even when a richtext
-    // renderer is registered.
-    const meta = super.toMeta(ctx) as TextEntryMeta
-    if (meta._formatted !== undefined || meta.format !== undefined) return meta
-
-    const html = tryRenderRichText(meta.value)
-    if (html === null) return meta
-
-    meta._formatted = html
-    meta.richtext   = true
-    return meta
-  }
-}

package/src/entries/index.ts

@@ -1,12 +0,0 @@
-// Entry runtime registry — opt-in component registration for
-// `ComponentEntry` elements. Imported by panel `bootstrap/providers.ts`,
-// not by `AdminPanel.ts` (which is re-imported on the client via the Vite
-// plugin's `_components.ts` manifest — same constraint as
-// `@pilotiq/pilotiq/uploads` / `@pilotiq/pilotiq/widgets`, per
-// `feedback_pilotiq_panel_module_client_safe.md`).
-export {
-  registerEntryComponents,
-  getEntryComponent,
-  type EntryComponent,
-  type EntryComponentProps,
-} from './registry.js'