@object-ui/fields 17.5.0 → 17.7.0

package/src/currency.ts

@@ -1,144 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * Licensed under the MIT license found in the LICENSE file.
- */
-
-/**
- * `resolveFieldCurrency` now lives in `@object-ui/i18n` (co-located with
- * `useLocalization`, which supplies the tenant default). This module re-exports
- * it so the long-standing `@object-ui/fields` import path keeps working for
- * every field/cell renderer that already depends on it.
- */
-export { resolveFieldCurrency } from '@object-ui/i18n';
-
-/**
- * Fallback width for a currency whose digit count cannot be resolved: the
- * literal both call sites used unconditionally before objectui#4361. It is
- * reached only when there is no ISO code to ask about (an invalid code, or a
- * runtime with no currency data at all), never as a policy.
- */
-const DEFAULT_FRACTION_DIGITS = 2;
-
-/**
- * ISO 4217 minor-unit width, memoized per currency code.
- *
- * The probe is deliberately made with NO locale. Measured across
- * en-US / de-DE / ja-JP / ar-KW / zh-CN / fr-FR / pl-PL / es-ES and the runtime
- * default, every locale answers the same digit count for the same code (USD 2,
- * JPY 0, KWD 3, BHD 3, CLP 0, ISK 0) — the count comes from CLDR's
- * `currencyData`, which is keyed by the currency, not by who is reading it.
- * Dropping the locale from the probe therefore loses nothing and removes a
- * failure mode: a malformed locale tag makes `Intl.NumberFormat` throw
- * `RangeError: Incorrect locale information provided`, which would turn a bad
- * LOCALE into a wrong CURRENCY width. It also makes the code the whole cache
- * key.
- */
-const fractionDigitsByCurrency = new Map<string, number>();
-
-/**
- * The number of fraction digits ISO 4217 gives `currency` — 0 for JPY/KRW/CLP,
- * 2 for USD/EUR/CNY, 3 for KWD/BHD/OMR/TND — as ICU reports it.
- *
- * Returns {@link DEFAULT_FRACTION_DIGITS} when the code is not a currency code
- * at all: `Intl` throws `RangeError: Invalid currency code` for those, and the
- * throw must not escape, or a bad code would change the width used by the
- * callers' own bad-currency fallbacks (objectui#4332 pinned those strings). A
- * code that is well-formed but unknown to CLDR (e.g. `ZZZ`) does not throw —
- * ICU answers 2 for anything outside its table, which is the same default.
- *
- * Memoized because the currency cell renderer runs once per grid cell: measured
- * at 24.3us per uncached probe against 0.02us cached (200k iterations, node 22),
- * so a 500-row grid pays ~12ms per render pass for a value that cannot change.
- */
-export function currencyFractionDigits(currency: string): number {
-  const cached = fractionDigitsByCurrency.get(currency);
-  if (cached !== undefined) return cached;
-  let digits = DEFAULT_FRACTION_DIGITS;
-  try {
-    // `maximumFractionDigits` is typed `number | undefined` on
-    // `ResolvedNumberFormatOptions` — it is absent when a format resolves with
-    // significant-digit rounding instead of fraction-digit rounding, which a
-    // bare `style: 'currency'` never does. Coalesced rather than asserted so
-    // the value is a number by construction and not by claim.
-    digits =
-      new Intl.NumberFormat(undefined, { style: 'currency', currency }).resolvedOptions()
-        .maximumFractionDigits ?? DEFAULT_FRACTION_DIGITS;
-  } catch {
-    // Not a currency code — keep the historical width and let the caller's own
-    // formatting attempt surface the bad code.
-  }
-  fractionDigitsByCurrency.set(currency, digits);
-  return digits;
-}
-
-/**
- * Display symbols, memoized per **(locale, currency)** pair.
- *
- * The pair, not the code — and this is the one place this helper deliberately
- * parts company with {@link currencyFractionDigits} above. The digit count is
- * locale-independent (measured across eight locales, see that map's note), so
- * its probe drops the locale and keys the cache on the code alone. The SYMBOL
- * is genuinely locale-dependent, measured on the same runtime:
- *
- *   - `USD` → `$` at `en` / `en-US` / `de-DE` / `ja-JP`, `US$` at `en-GB` and
- *     `zh-CN`, `$US` at `fr-FR`;
- *   - `JPY` → U+00A5 at `en`, the FULLWIDTH U+FFE5 at `ja-JP`, `JP¥` at
- *     `en-GB`, and the bare code `JPY` at `fr-FR`.
- *
- * Copying the code-only cache key would therefore let whichever locale asked
- * first answer for every locale after it, for the life of the process — a
- * silent wrong answer rather than a crash, so it is pinned by test.
- *
- * `|` is safe as the key separator: it appears in neither a BCP-47 tag nor an
- * ISO 4217 code, so no two distinct pairs can collide on one key.
- */
-const symbolByLocaleAndCurrency = new Map<string, string>();
-
-/**
- * The string ICU renders in place of `currency` for a reader in `locale` — `$`
- * for USD at `en`, `€` for EUR, U+00A5 for JPY — taken from the `currency` part
- * of the very format the display path already uses.
- *
- * This is the ONE channel for the symbol (objectui#4414). It is not an
- * independent opinion about how a currency should look: it is the same
- * `Intl.NumberFormat(locale, { style: 'currency', currency })` that
- * `formatDisplayNumber` formats amounts with, read one part at a time. So a
- * widget that renders an amount in one mode and a bare symbol in another cannot
- * disagree with itself — which is exactly what the hand-written
- * `currency === 'USD' ? '$' : currency` ternary did, showing `JPY` beside a
- * readonly `¥1,235`.
- *
- * Falls back to `currency` itself — the code as given — in the three cases
- * where ICU cannot answer, because a bare code is a legitimate adornment (it is
- * what ICU itself returns for KWD/BHD/CHF/ISK, and what
- * `formatAmount`'s own bad-code branch renders beside it):
- *
- *  1. an invalid currency code — `Intl` throws `RangeError: Invalid currency
- *     code`;
- *  2. a malformed locale tag (`en_US` with an underscore, say) — `Intl` throws
- *     `RangeError: Incorrect locale information provided`. `currencyFractionDigits`
- *     dodged this failure mode by dropping the locale from its probe; this
- *     helper needs the locale, so it catches instead. Neither throw may escape:
- *     this runs during render, so an escaped `RangeError` is a blank widget.
- *  3. no `currency` part in the output at all — not observed for
- *     `style: 'currency'`, but coalesced rather than asserted.
- */
-export function currencySymbol(currency: string, locale: string): string {
-  const key = `${locale}|${currency}`;
-  const cached = symbolByLocaleAndCurrency.get(key);
-  if (cached !== undefined) return cached;
-  let symbol = currency;
-  try {
-    // The formatted value is irrelevant — only the `currency` part is read — so
-    // the cheapest deterministic input is used.
-    const parts = new Intl.NumberFormat(locale, { style: 'currency', currency }).formatToParts(0);
-    symbol = parts.find((part) => part.type === 'currency')?.value ?? currency;
-  } catch {
-    // Bad code or bad locale — keep the code, and let the caller's own
-    // formatting attempt surface the real problem.
-  }
-  symbolByLocaleAndCurrency.set(key, symbol);
-  return symbol;
-}

package/src/datetime-widgets.test.tsx

@@ -1,185 +0,0 @@
-import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
-import { describe, it, expect, vi } from 'vitest';
-import { DateField } from './widgets/DateField';
-import { DateTimeField } from './widgets/DateTimeField';
-import { TimeField } from './widgets/TimeField';
-import type { FieldWidgetComponentProps } from './widgets/types';
-
-const mockField = {
-  name: 'test_field',
-  label: 'Test Field',
-  type: 'date',
-} as any;
-
-const baseProps: FieldWidgetComponentProps<string> = {
-  field: mockField,
-  value: '',
-  onChange: vi.fn(),
-  readonly: false,
-};
-
-describe('Date/Time Widgets', () => {
-    describe('DateField', () => {
-        it('renders date input in edit mode', () => {
-            const { container } = render(<DateField {...baseProps} />);
-            const dateInput = container.querySelector('input[type="date"]');
-            expect(dateInput).toBeInTheDocument();
-        });
-
-        it('calls onChange when value changes', () => {
-            const { container } = render(<DateField {...baseProps} />);
-            const input = container.querySelector('input[type="date"]') as HTMLInputElement;
-            fireEvent.change(input, { target: { value: '2023-01-01' } });
-            expect(baseProps.onChange).toHaveBeenCalledWith('2023-01-01');
-        });
-
-        it('renders formatted date in readonly mode', () => {
-            render(<DateField {...baseProps} readonly value="2023-01-01" />);
-            const date = new Date('2023-01-01');
-            expect(screen.getByText(date.toLocaleDateString())).toBeInTheDocument();
-            expect(document.querySelector('input')).not.toBeInTheDocument();
-        });
-
-        it('renders dash for empty readonly value', () => {
-            render(<DateField {...baseProps} readonly value={''} />);
-            expect(screen.getByText('—')).toBeInTheDocument();
-        });
-    });
-
-    describe('DateTimeField', () => {
-        it('renders datetime-local input in edit mode', () => {
-            const { container } = render(<DateTimeField {...baseProps} />);
-            const input = container.querySelector('input[type="datetime-local"]');
-            expect(input).toBeInTheDocument();
-        });
-
-        it('calls onChange when value changes', () => {
-            const onChange = vi.fn();
-            const { container } = render(<DateTimeField {...baseProps} onChange={onChange} />);
-            const input = container.querySelector('input[type="datetime-local"]') as HTMLInputElement;
-            fireEvent.change(input, { target: { value: '2023-01-01T12:00' } });
-            // The control speaks zone-less local wall clock; form state holds
-            // ISO, the shape the API hands back and `toDateTimeInputValue`
-            // reads (objectui#3127). Storing the naive string instead would put
-            // read and write on different timezone bases.
-            expect(onChange).toHaveBeenCalledWith(new Date('2023-01-01T12:00').toISOString());
-        });
-
-        it('renders formatted datetime in readonly mode', () => {
-            const val = '2023-01-01T12:00:00.000Z';
-            render(<DateTimeField {...baseProps} readonly value={val} />);
-            const date = new Date(val);
-            const span = screen.getByText((content) => {
-                return content.includes(date.toLocaleDateString());
-            });
-            expect(span).toBeInTheDocument();
-        });
-    });
-
-    /**
-     * objectui#3127 — the record's stored ISO value reached the native control
-     * verbatim, and `<input type="date">` / `<input type="datetime-local">`
-     * reject anything but their one exact shape SILENTLY: the attribute lands
-     * in the DOM, `.value` reads back `''`, and the user sees an empty box on a
-     * field that has a value. `.value` (not `getAttribute('value')`) is
-     * therefore the only assertion that can see this bug at all.
-     */
-    describe('existing values round-trip through the native controls (#3127)', () => {
-        // The seeded showcase value. Whole minutes and no sub-second part, so
-        // the control (which has minute resolution) can represent it exactly
-        // and the round trip below is lossless in every timezone.
-        const storedIso = '2026-06-17T14:30:00.000Z';
-
-        it('DateTimeField shows a stored ISO instant instead of an empty box', () => {
-            const { container } = render(<DateTimeField {...baseProps} value={storedIso} />);
-            const input = container.querySelector('input[type="datetime-local"]') as HTMLInputElement;
-
-            expect(input.value).not.toBe('');
-            expect(input.value).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/);
-            // The shown wall clock denotes the SAME instant as the record —
-            // asserted this way so the test holds in every timezone, which a
-            // hardcoded "2026-06-17T22:30" would not.
-            expect(new Date(input.value).getTime()).toBe(new Date(storedIso).getTime());
-        });
-
-        it('DateTimeField writes back on the same basis it reads', () => {
-            // Read and write must share one timezone basis. Displaying local
-            // while storing the naive local string is the worse bug: the value
-            // would silently drift by the viewer's offset on every edit.
-            const onChange = vi.fn();
-            const { container } = render(
-                <DateTimeField {...baseProps} onChange={onChange} value={storedIso} />
-            );
-            const input = container.querySelector('input[type="datetime-local"]') as HTMLInputElement;
-
-            fireEvent.change(input, { target: { value: '2026-06-18T09:15' } });
-
-            const written = onChange.mock.calls[0][0];
-            // Zone-QUALIFIED, which the control's own output is not. Storing
-            // the raw `2026-06-18T09:15` is what puts the write on a different
-            // basis from the read: the server has no way to know whose 09:15
-            // it is, and resolves it to a different instant than the one the
-            // user picked.
-            expect(written).toMatch(/(Z|[+-]\d{2}:\d{2})$/);
-            expect(new Date(written).getTime()).toBe(new Date('2026-06-18T09:15').getTime());
-        });
-
-        it('DateTimeField returning to the shown minute restores the exact stored value', () => {
-            // Guards the drift this fix could otherwise introduce: if the two
-            // conversions disagreed by the viewer's UTC offset, navigating away
-            // from a value and back would land somewhere else, and every open →
-            // fiddle → undo would quietly move the record.
-            // Held in real state, because a `vi.fn()` onChange would leave the
-            // control pinned to its initial prop and React would swallow the
-            // second edit as a no-op — the test would pass without exercising
-            // anything.
-            const seen: string[] = [];
-            const Host = () => {
-                const [v, setV] = React.useState<string>(storedIso);
-                seen.push(v);
-                return <DateTimeField {...baseProps} value={v} onChange={setV as any} />;
-            };
-            const { container } = render(<Host />);
-            const input = container.querySelector('input[type="datetime-local"]') as HTMLInputElement;
-            const shown = input.value;
-
-            fireEvent.change(input, { target: { value: '2026-06-18T09:15' } });
-            fireEvent.change(input, { target: { value: shown } });
-
-            expect(seen[seen.length - 1]).toBe(storedIso);
-        });
-
-        it('DateField shows the stored calendar day, ISO-shaped or not', () => {
-            // Both spellings the API may hand back for a `date` field. The day
-            // must survive verbatim — re-parsing the bare form as UTC midnight
-            // would move it to the 16th west of Greenwich.
-            for (const stored of ['2026-06-17', '2026-06-17T00:00:00.000Z']) {
-                const { container, unmount } = render(<DateField {...baseProps} value={stored} />);
-                const input = container.querySelector('input[type="date"]') as HTMLInputElement;
-                expect(input.value).toBe('2026-06-17');
-                unmount();
-            }
-        });
-    });
-
-    describe('TimeField', () => {
-        it('renders time input in edit mode', () => {
-            const { container } = render(<TimeField {...baseProps} />);
-            const input = container.querySelector('input[type="time"]');
-            expect(input).toBeInTheDocument();
-        });
-
-        it('calls onChange when value changes', () => {
-            const { container } = render(<TimeField {...baseProps} />);
-            const input = container.querySelector('input[type="time"]') as HTMLInputElement;
-            fireEvent.change(input, { target: { value: '14:30' } });
-            expect(baseProps.onChange).toHaveBeenCalledWith('14:30');
-        });
-
-        it('renders value directly in readonly mode', () => {
-            render(<TimeField {...baseProps} readonly value="14:30" />);
-            expect(screen.getByText('14:30')).toBeInTheDocument();
-        });
-    });
-});

package/src/field-type-alias.multiple.test.ts

@@ -1,81 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * The widget id is a function of the (type, `multiple`) PAIR, not of the type
- * string alone (objectui#3986).
- *
- * `mapFieldTypeToFormType` mapped `select` to `field:select` unconditionally,
- * while `SelectField` delegated to `MultiSelectField` whenever the metadata said
- * `multiple`. Three correct pieces, one gap between them: the component that
- * RENDERED was `MultiSelectField`, but everything keyed on the widget id — above
- * all the label-association declaration (`ComponentMeta.labelling`, resolved via
- * `getMeta('select')`) — was still answering for the single-value combobox. The
- * host label of a normal `{ type: 'select', multiple: true }` picklist therefore
- * emitted a `for` at the chip row's wrapper `div`, where a `for` is inert.
- *
- * `select` cannot simply be declared `labelling: 'group'` instead: the
- * single-value trigger IS labelable, and a bare `select` is a builtin the form
- * renderer resolves without the registry at all (pinned in
- * `form-group-label-association.test.ts`). The producer has to name the widget
- * that renders, which is what this file pins.
- *
- * Metadata only — nothing renders here, so no widget module is loaded.
- */
-
-import { describe, it, expect } from 'vitest';
-import { mapFieldTypeToFormType } from './field-type-alias';
-
-describe('select carries its arity in the widget id (objectui#3986)', () => {
-  it('maps select + multiple to the multi-value widget', () => {
-    // The one assertion that was `field:select` before this change.
-    expect(mapFieldTypeToFormType('select', { multiple: true })).toBe('field:multiselect');
-  });
-
-  it('keeps the single-value widget without multiple, and for multiple: false', () => {
-    // The guard direction: single-select must not move. Its trigger is a
-    // labelable `button[role=combobox]` and its `for` association works — taking
-    // that away would break a field that is fine to fix one that is not.
-    expect(mapFieldTypeToFormType('select')).toBe('field:select');
-    expect(mapFieldTypeToFormType('select', {})).toBe('field:select');
-    expect(mapFieldTypeToFormType('select', { multiple: false })).toBe('field:select');
-    expect(mapFieldTypeToFormType('select', { multiple: null })).toBe('field:select');
-  });
-
-  it('is idempotent for the type that is already inherently multi', () => {
-    // `multiselect` is a type in its own right; the arity override must not turn
-    // it into something else, whichever way the flag is set.
-    expect(mapFieldTypeToFormType('multiselect')).toBe('field:multiselect');
-    expect(mapFieldTypeToFormType('multiselect', { multiple: true })).toBe('field:multiselect');
-  });
-
-  /**
-   * The spec's multi-capable set is larger than the widget-moving set, and the
-   * difference is the whole reason this override is table-driven rather than a
-   * `config.multiple` branch sprinkled per type:
-   *
-   *   `MULTI_CAPABLE_TYPES` = select / lookup / file / image (+ `radio` on the
-   *   select branch, `user` storing like `lookup`)
-   *
-   * Every member except `select` renders BOTH arities inside one widget —
-   * `LookupField`, `FileField`, `ImageField` each read `multiple` themselves — so
-   * their widget id, and with it their `labelling` declaration, is correct for
-   * either arity. Moving them would point at widgets that do not exist.
-   */
-  const UNMOVED_MULTI_CAPABLE = ['lookup', 'master_detail', 'user', 'owner', 'file', 'image', 'radio'] as const;
-
-  it.each(UNMOVED_MULTI_CAPABLE)('%s resolves identically with and without multiple', (type) => {
-    expect(mapFieldTypeToFormType(type, { multiple: true })).toBe(mapFieldTypeToFormType(type));
-  });
-
-  it('does not invent a widget for an unknown type flagged multiple', () => {
-    // The fallback is unchanged: an unknown type is `field:text` at either arity,
-    // never `field:text-multiple`-anything.
-    expect(mapFieldTypeToFormType('something-unknown', { multiple: true })).toBe('field:text');
-  });
-});

package/src/field-type-alias.ts

@@ -1,156 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * The slice of a field definition the widget decision reads beyond `type`.
- *
- * Structural (not the spec `Field`) for the same reason the spec's own
- * `ValueShapeFieldDef` is: every caller — object-schema metadata, a spec
- * `FormFieldSchema` override, an action param def — can pass its own trimmed
- * shape verbatim. `multiple` is the only key read; nothing else here is
- * consulted, so a caller that has the whole metadata object may hand it over
- * as-is.
- */
-export interface FieldTypeMappingConfig {
-  /** `FieldSchema.multiple` — the field holds zero-or-more values. */
-  multiple?: boolean | null;
-}
-
-/**
- * Field types whose `multiple: true` form is a DIFFERENT registered widget,
- * rather than the same widget in another mode (objectui#3986).
- *
- * `select` is the only member, and the narrowness is measured, not assumed. The
- * spec's `MULTI_CAPABLE_TYPES` is larger — select / lookup / file / image, with
- * `radio` on the select branch and `user` storing like `lookup` — but every
- * other member renders both arities INSIDE one widget: `LookupField`,
- * `FileField` and `ImageField` each branch on `multiple` themselves, so their
- * registry id, and with it their `labelling` declaration, is the same either
- * way. A `select` declared `multiple: true` renders `MultiSelectField` instead:
- * a different component, whose labelled surface is a chip row's container that
- * a `<label for>` cannot address (it must be named by IDREF, which is what
- * `field:multiselect`'s `labelling: 'group'` declares — objectui#3975/#3961).
- *
- * So the widget id has to carry the arity. When it did not, the host label was
- * associated by the declaration registered under `select` — a single-value
- * combobox that was NOT rendering — and the visible label of a normal
- * `{ type: 'select', multiple: true }` picklist named nothing at all. One place
- * decides which widget renders, so the declaration and the render cannot
- * disagree again.
- */
-const MULTI_VALUE_FORM_TYPES: Record<string, string> = {
-  select: 'field:multiselect',
-};
-
-/**
- * Map field type to form component type
- *
- * @param fieldType - The ObjectQL field type identifier to convert
- * (for example: `"text"`, `"number"`, `"date"`, `"lookup"`).
- * @param config - The rest of the field definition, for the types whose widget
- * identity depends on more than the type string. Only `multiple` is read; see
- * {@link MULTI_VALUE_FORM_TYPES}. Omitting it maps the single-value form, which
- * is what every non-multi-capable type resolves to anyway.
- * @returns The normalized form field type string used in the form schema
- * (for example: `"input"`, `"textarea"`, `"date-picker"`, `"select"`).
- */
-export function mapFieldTypeToFormType(
-  fieldType: string,
-  config?: FieldTypeMappingConfig,
-): string {
-  const typeMap: Record<string, string> = {
-    // Text-based fields
-    text: 'field:text',
-    textarea: 'field:textarea',
-    markdown: 'field:markdown', // Markdown editor (fallback to textarea)
-    html: 'field:html', // Rich text editor (fallback to textarea)
-    richtext: 'field:richtext', // WYSIWYG rich-text editor
-    secret: 'field:password', // encrypted-at-rest value — mask input like a password
-
-    // Numeric fields
-    number: 'field:number',
-    currency: 'field:currency',
-    percent: 'field:percent',
-    slider: 'field:slider',
-    progress: 'field:slider', // bounded 0..100 progress — edit via slider
-    rating: 'field:rating',
-
-    // Date/Time fields
-    date: 'field:date',
-    datetime: 'field:datetime',
-    time: 'field:time',
-
-    // Boolean
-    boolean: 'field:boolean',
-    toggle: 'field:boolean', // toggle is a boolean rendered as a switch
-
-    // Selection fields
-    select: 'field:select',
-    multiselect: 'field:multiselect',
-    radio: 'field:radio',
-    checkboxes: 'field:checkboxes',
-    tags: 'field:tags',
-    lookup: 'field:lookup',
-    master_detail: 'field:master_detail',
-    tree: 'field:lookup', // hierarchical reference — pick the parent via a lookup
-    // `user` is a lookup specialized to sys_user; `owner` mirrors it (record
-    // ownership). Both render via the UserField person-picker (delegates to the
-    // lookup picker). Without these they would fall through to `field:text`.
-    user: 'field:user',
-    owner: 'field:owner',
-
-    // Contact fields
-    email: 'field:email',
-    phone: 'field:phone',
-    url: 'field:url',
-
-    // File / media fields
-    file: 'field:file',
-    image: 'field:image',
-    avatar: 'field:avatar',
-    video: 'field:file', // uploads as a file
-    audio: 'field:file', // uploads as a file
-    signature: 'field:signature',
-
-    // Special / enhanced fields
-    password: 'field:password',
-    location: 'field:location', // Location/map field (fallback to input)
-    geolocation: 'field:geolocation',
-    address: 'field:address',
-    color: 'field:color',
-    code: 'field:code',
-    json: 'field:code', // JSON edited in the code editor
-    qrcode: 'field:qrcode',
-    vector: 'field:vector',
-
-    // Embedded structured values (stored as JSON on the row)
-    object: 'field:object',
-    composite: 'field:object', // embedded object
-    record: 'field:object', // name-keyed map
-    repeater: 'field:grid', // embedded array of rows
-
-    // Auto-generated/computed fields (typically read-only)
-    formula: 'field:formula',
-    summary: 'field:summary',
-    // `@objectstack/spec` spells this `autonumber`; the widget map key is
-    // `auto_number`. Map both spellings so a spec-typed field/param doesn't
-    // fall through to the plain text input.
-    autonumber: 'field:auto_number',
-    auto_number: 'field:auto_number',
-  };
-
-  // The arity override comes FIRST and is table-driven: only a type listed in
-  // `MULTI_VALUE_FORM_TYPES` has a second widget to move to, so `multiple` on
-  // any other type (a multi `lookup`, a multi `file`) resolves exactly as
-  // before and keeps reaching the widget that handles both arities itself.
-  if (config?.multiple && MULTI_VALUE_FORM_TYPES[fieldType]) {
-    return MULTI_VALUE_FORM_TYPES[fieldType];
-  }
-
-  return typeMap[fieldType] || 'field:text';
-}

package/src/field-type-coverage.test.ts

@@ -1,67 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * Regression guard for the field-type → renderer registries. These mappings
- * regressed once already: ~25 specialized field types silently fell back to a
- * plain text input (form) and the raw text cell renderer (read), because the
- * mapping tables were incomplete. This test locks them in so a dropped entry
- * fails CI instead of shipping a broken widget.
- */
-import { describe, it, expect } from 'vitest';
-import { mapFieldTypeToFormType, getCellRenderer, TextCellRenderer } from './index';
-
-/**
- * Field types that MUST resolve to a dedicated form widget — never the
- * `field:text` fallback. (Plain text-ish types like text/textarea are
- * intentionally excluded.)
- */
-const FORM_WIDGET_TYPES = [
-  'textarea', 'email', 'url', 'phone', 'password', 'secret',
-  'markdown', 'html', 'richtext',
-  'number', 'currency', 'percent', 'slider', 'progress', 'rating',
-  'date', 'datetime', 'time',
-  'boolean', 'toggle',
-  'select', 'multiselect', 'radio', 'checkboxes', 'tags',
-  'lookup', 'master_detail', 'tree',
-  'file', 'image', 'avatar', 'video', 'audio', 'signature',
-  'location', 'geolocation', 'address', 'color', 'code', 'json', 'qrcode', 'vector',
-  'object', 'composite', 'record', 'repeater',
-  // `autonumber` is the spec `FieldType` spelling; `auto_number` is the widget
-  // map key. Both must resolve to the AutoNumber widget, not text.
-  'formula', 'summary', 'auto_number', 'autonumber',
-];
-
-/**
- * Field types that MUST resolve to a dedicated read/cell renderer — never the
- * generic text cell renderer. (markdown/html/richtext render formatted;
- * code/qrcode/time legitimately stay textual and are excluded.)
- */
-const CELL_RENDERER_TYPES = [
-  'email', 'url', 'phone', 'number', 'currency', 'percent', 'progress',
-  'boolean', 'toggle', 'date', 'datetime',
-  'select', 'multiselect', 'radio', 'checkboxes', 'tags',
-  'lookup', 'master_detail', 'tree',
-  'file', 'video', 'audio', 'image', 'avatar', 'signature',
-  'markdown', 'html', 'richtext',
-  'location', 'geolocation', 'address', 'color', 'json',
-  'formula', 'summary', 'user', 'owner',
-];
-
-describe('field-type renderer coverage (regression guard)', () => {
-  it.each(FORM_WIDGET_TYPES)('maps "%s" to a dedicated form widget (not field:text)', (type) => {
-    const widget = mapFieldTypeToFormType(type);
-    expect(widget).toMatch(/^field:/);
-    expect(widget).not.toBe('field:text');
-  });
-
-  it.each(CELL_RENDERER_TYPES)('resolves "%s" to a dedicated cell renderer (not TextCellRenderer)', (type) => {
-    const renderer = getCellRenderer(type);
-    expect(renderer).toBeTypeOf('function');
-    expect(renderer).not.toBe(TextCellRenderer);
-  });
-
-  it('falls back to field:text for unknown types', () => {
-    expect(mapFieldTypeToFormType('something-unknown')).toBe('field:text');
-  });
-});