@object-ui/fields 17.5.0 → 17.6.0

package/src/__tests__/percent-tie-halfup-4590.test.ts

@@ -1,224 +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.
- */
-
-/**
- * objectui#4590 — `formatPercent` rounds a tie the wrong way, because it renders
- * a value that is ALREADY in percentage points through `Intl`'s
- * `style: 'percent'`, which wants a FRACTION.
- *
- * The old body divided by 100 so `Intl` could multiply straight back:
- *
- *     formatDisplayNumber(displayValue / 100, { style: 'percent', … })
- *
- * That round trip is not value-preserving. `Intl` formats from the SHORTEST
- * decimal representation of the double it is handed, and `displayValue / 100`
- * has a different shortest representation from `displayValue`: `1.005` is
- * `1.005`, but `1.005 / 100` is `0.010049999999999999`, which percent-scales to
- * `1.0049999999999999` and rounds DOWN. The DIVISION loses the digit, not the
- * rounding. It is therefore a numeral defect and not a convention one — it
- * reproduces identically in every locale, in Arabic-Indic digits too.
- *
- * The fix is the option #4576 / PR #4589 put in `@object-ui/core` for exactly
- * this: `style: 'percentPoints'` formats the points DIRECTLY (`Intl`'s
- * `style: 'unit'` / `unit: 'percent'` / `unitDisplay: 'narrow'`), which was
- * measured to give a byte-identical percent affix to `style: 'percent'` across
- * all 171 locale tags tested.
- *
- * ── PREDICTIONS, written before the run ─────────────────────────────────────
- * Runner measured: node v22.22.2, ICU 78.2, machine locale en-US.
- *
- *   RED before the fix — the numerals:
- *     formatPercent(1.005, 2, 'en-US')   `1.00%`  → `1.01%`
- *     formatPercent(1.025, 2, 'en-US')   `1.02%`  → `1.03%`
- *     formatPercent(1.45,  1, 'en-US')   `1.4%`   → `1.5%`
- *     formatPercent(1.055, 2, 'en-US')   `1.05%`  → `1.06%`
- *     formatPercent(99999.995, 2, 'en')  `99,999.99%` → `100,000.00%`
- *     MAX_SAFE_INTEGER p0   `9,007,199,254,740,990%` → `…991%`
- *     1e23            p0    `99,999,999,999,999,990,000,000%`
- *                           → `100,000,000,000,000,000,000,000%`
- *     the same four ties in de-DE / tr-TR / ar-EG — the locale-independence
- *     claim, red in every one of them
- *
- *   GREEN ON BOTH SIDES — the must-not-change set, and the STOP condition if
- *   any of it moves (this card is NUMERAL-only; a convention move is a defect
- *   in the fix, not a pin to update):
- *     the percent CONVENTION of all ten locales at 1234.5 p1 — de/fr/ru/sv's
- *     no-break space, tr's PREFIX sign, ar's U+066A + U+061C, en/ja/zh's bare
- *     suffix, fr's U+202F group separator, bn's Bengali digits
- *     the sign position and glyph on negatives (sv-SE's U+2212 included)
- *     the affix parity check against `Intl`'s own `style: 'percent'`
- *     `percentDisplayValue`'s fraction/whole scaling — upstream of the render
- *     and deliberately untouched by this card
- *
- * MEASURED, this call shape, old route vs new: 10 locales x 18 values x 4
- * precisions = 720 combinations — 0 convention diffs, 130 numeral diffs (13 per
- * locale, the SAME 13 in every locale). On the wide en-US grid the issue
- * quantified (0.005 steps to 2000, precisions 0/1/2) 27,577 of 1,200,003 forms
- * move. Every one is a last-digit-off-by-one.
- *
- * Every non-ASCII byte below is written as a `\u` escape, never pasted.
- */
-
-import { describe, it, expect } from 'vitest';
-import { formatPercent } from '../index';
-
-/** U+00A0 NO-BREAK SPACE — de/fr/ru/sv put one before the percent sign. */
-const NBSP = '\u00a0';
-/** U+202F NARROW NO-BREAK SPACE — fr's group separator. */
-const NNBSP = '\u202f';
-/** U+066A ARABIC PERCENT SIGN, U+061C ARABIC LETTER MARK. */
-const ARABIC_PERCENT = '\u066a';
-const ALM = '\u061c';
-
-describe('formatPercent rounds a tie half-up on the authored decimal (#4590)', () => {
-  /**
-   * MOVING PINS — the issue's measured table, verbatim. Each was the artefact
-   * of the `/ 100` round trip; the right-hand column is half-up on the decimal
-   * the author actually wrote.
-   */
-  it.each([
-    [1.005, 2, '1.01%', '1.00%'],
-    [1.025, 2, '1.03%', '1.02%'],
-    [1.45, 1, '1.5%', '1.4%'],
-    [1.055, 2, '1.06%', '1.05%'],
-  ])('formatPercent(%s, %s) is %s (was %s)', (value, precision, expected) => {
-    expect(formatPercent(value, precision, 'en-US')).toBe(expected);
-  });
-
-  /**
-   * A tie that carries into a new digit COLUMN rather than just flipping the
-   * last one — the round trip lost the carry as well as the digit.
-   */
-  it('carries across the grouping boundary: 99999.995 to 2 decimals', () => {
-    // was `99,999.99%`
-    expect(formatPercent(99999.995, 2, 'en-US')).toBe('100,000.00%');
-  });
-
-  /**
-   * The defect is in the VALUE, not the convention, so it must reproduce in
-   * every locale — including one that writes the sign in front and one that
-   * uses neither ASCII digits nor an ASCII sign.
-   */
-  it('the same ties move in every locale — this is a numeral defect', () => {
-    expect(formatPercent(1.005, 2, 'de-DE')).toBe(`1,01${NBSP}%`); // was `1,00 %`
-    expect(formatPercent(1.45, 1, 'de-DE')).toBe(`1,5${NBSP}%`); // was `1,4 %`
-    expect(formatPercent(1.005, 2, 'tr-TR')).toBe('%1,01'); // was `%1,00`
-    // U+0661 U+066B U+0660 U+0661 — Arabic-Indic `1`, decimal separator, `0`, `1`
-    expect(formatPercent(1.005, 2, 'ar-EG')).toBe(
-      `\u0661\u066b\u0660\u0661${ARABIC_PERCENT}${ALM}`,
-    ); // was `\u0661\u066b\u0660\u0660` + the same affix
-  });
-});
-
-describe('formatPercent keeps every digit at the top of the double range (#4590)', () => {
-  /**
-   * MOVING PINS, before/after verbatim. `Number.MAX_SAFE_INTEGER` percentage
-   * points used to render with its last digit replaced by a zero, and 1e23 used
-   * to render as a number that is not 1e23 at all. Both are the same artefact
-   * as the ties, at the other end of the range: divide by 100 and the shortest
-   * representation of the quotient no longer round-trips.
-   */
-  it('MAX_SAFE_INTEGER keeps its last digit', () => {
-    // was `9,007,199,254,740,990%` — a 1 turned into a 0
-    expect(formatPercent(Number.MAX_SAFE_INTEGER, 0, 'en-US')).toBe('9,007,199,254,740,991%');
-  });
-
-  it('1e23 renders as 1e23', () => {
-    // was `99,999,999,999,999,990,000,000%`
-    expect(formatPercent(1e23, 0, 'en-US')).toBe('100,000,000,000,000,000,000,000%');
-  });
-});
-
-describe('MUST NOT CHANGE: the locale percent CONVENTION (#4590 is numeral-only)', () => {
-  /**
-   * The affix is what `style: 'percentPoints'` promises to preserve, so this is
-   * the half that proves the fix did not become a convention change. Byte-exact
-   * strings, chosen at a magnitude and precision where no tie is in play — they
-   * are GREEN on both sides of the fix, and a diff here is a STOP condition.
-   */
-  it.each([
-    ['en-US', '1,234.5%'],
-    ['de-DE', `1.234,5${NBSP}%`],
-    ['fr-FR', `1${NNBSP}234,5${NBSP}%`],
-    ['tr-TR', '%1.234,5'], // sign in FRONT
-    ['ar-EG', `\u0661\u066c\u0662\u0663\u0664\u066b\u0665${ARABIC_PERCENT}${ALM}`],
-    ['ja-JP', '1,234.5%'],
-    ['zh-CN', '1,234.5%'],
-    ['ru-RU', `1${NBSP}234,5${NBSP}%`],
-    ['sv-SE', `1${NBSP}234,5${NBSP}%`],
-    ['bn-IN', `\u09e7,\u09e8\u09e9\u09ea.\u09eb%`],
-  ])('%s renders its own percent convention, unchanged', (locale, expected) => {
-    expect(formatPercent(1234.5, 1, locale)).toBe(expected);
-  });
-
-  /**
-   * Sign POSITION and sign GLYPH are convention too — Turkish puts the minus
-   * outside its prefixed percent sign, Arabic leads with U+061C, and Swedish
-   * uses U+2212 MINUS SIGN rather than ASCII hyphen-minus. None of it moves.
-   */
-  it.each([
-    ['en-US', '-45.5%'],
-    ['de-DE', `-45,5${NBSP}%`],
-    ['tr-TR', '-%45,5'],
-    ['ar-EG', `${ALM}-\u0664\u0665\u066b\u0665${ARABIC_PERCENT}${ALM}`],
-    ['sv-SE', `\u221245,5${NBSP}%`],
-  ])('%s keeps its negative-sign convention', (locale, expected) => {
-    expect(formatPercent(-45.5, 1, locale)).toBe(expected);
-  });
-
-  /**
-   * The parity claim asserted rather than trusted: the affix `formatPercent`
-   * now produces must be the one `Intl`'s OWN `style: 'percent'` produces for
-   * the same locale. Comparing the affix alone (digits stripped) is deliberate
-   * — the numerals are exactly what this card moves, so a whole-string compare
-   * would re-assert the defect.
-   */
-  it('the affix is byte-identical to Intl style:percent, for every locale here', () => {
-    const affix = (rendered: string) => rendered.replace(/[\p{Nd}]/gu, '');
-    for (const locale of ['en-US', 'de-DE', 'fr-FR', 'tr-TR', 'ar-EG', 'ja-JP',
-                          'zh-CN', 'ru-RU', 'sv-SE', 'bn-IN']) {
-      const cell = formatPercent(1234.5, 1, locale);
-      const intl = new Intl.NumberFormat(locale, {
-        style: 'percent',
-        minimumFractionDigits: 1,
-        maximumFractionDigits: 1,
-      }).format(12.345);
-      expect(affix(cell), `percent affix for ${locale}`).toBe(affix(intl));
-    }
-  });
-});
-
-describe('MUST NOT CHANGE: percent SCALING is upstream of the render (#4590)', () => {
-  /**
-   * `percentDisplayValue` (a stored fraction below 1 scales by 100, a value at
-   * or above 1 passes through) decides WHICH number gets rendered; this card
-   * changes only HOW that number is rendered. Pinned unmoved so a future reader
-   * cannot mistake the two halves for one.
-   */
-  it('a stored fraction still scales, a stored whole number still does not', () => {
-    expect(formatPercent(0.8, 0, 'en-US')).toBe('80%');
-    expect(formatPercent(0.5, 0, 'en-US')).toBe('50%');
-    expect(formatPercent(0.075, 1, 'en-US')).toBe('7.5%');
-    expect(formatPercent(80, 0, 'en-US')).toBe('80%');
-    expect(formatPercent(100, 0, 'en-US')).toBe('100%');
-    // The boundary itself: 1 is NOT a fraction, so it stays 1%.
-    expect(formatPercent(1, 0, 'en-US')).toBe('1%');
-    // …which is why the tie cases above are authored just above 1.
-    expect(formatPercent(0.9999, 0, 'en-US')).toBe('100%');
-  });
-
-  it('a malformed locale tag still falls back instead of throwing', () => {
-    expect(() => formatPercent(80, 0, 'not a locale')).not.toThrow();
-    expect(formatPercent(80, 0, 'not a locale')).toContain('80');
-  });
-
-  it('is still callable with no locale and no precision', () => {
-    expect(formatPercent(80)).toBe('80%');
-    expect(formatPercent(80, 0)).toBe('80%');
-  });
-});

package/src/__tests__/registry-collision.test.ts

@@ -1,91 +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.
- */
-
-/**
- * Registry collision guard.
- *
- * `@object-ui/components` registers display widgets (`text`, `image`,
- * `avatar`, `html`, `grid`) under their bare names. `@object-ui/fields`
- * registers form-input widgets that — by name — collide with those.
- *
- * The fix: field registrations for these 5 types pass `skipFallback: true`,
- * so the bare lookup keeps returning the display widget while the field
- * input is still reachable via the `field:<type>` namespace.
- *
- * Regression contract:
- *   1. `FIELD_TYPES_SKIP_FALLBACK` must contain every colliding name.
- *   2. After `registerAllFields()`, bare lookups must NOT resolve to a
- *      field renderer for any of those names.
- *   3. The `field:<type>` namespaced lookup must still work, so form
- *      schemas using `{ type: 'text' }` still find an input renderer
- *      when explicitly requested.
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { ComponentRegistry } from '@object-ui/core';
-
-// Importing the fields entry runs `registerAllFields()` at module load.
-// Importing the components entry runs display-widget registration the
-// same way. Both must be loaded before we inspect the registry.
-import '@object-ui/components';
-import { registerAllFields } from '../index';
-
-const COLLIDING_TYPES = ['text', 'html', 'image', 'avatar', 'grid'] as const;
-
-describe('registry collision (fields ↔ components)', () => {
-  beforeAll(() => {
-    // Defensive: in case the auto-register at import time hasn't run yet
-    // under the test runner's module isolation.
-    registerAllFields();
-  });
-
-  it.each(COLLIDING_TYPES)(
-    'bare "%s" lookup is NOT clobbered by the field renderer',
-    (type) => {
-      // The bare lookup must resolve, and it must resolve to a display widget
-      // (or a FallbackComponent / null) — never to the lazy field renderer.
-      // The field renderer is a React.lazy() result; the display widget is a
-      // plain function component. We don't pin to a specific identity, but we
-      // DO pin that whatever the bare lookup returns, the namespaced
-      // `field:<type>` lookup returns something different.
-      const bare = ComponentRegistry.get(type);
-      const namespaced = ComponentRegistry.get(`field:${type}`);
-
-      // Namespaced field renderer must exist for every colliding type —
-      // that's the whole point of keeping the field accessible.
-      expect(
-        namespaced,
-        `field:${type} must be registered so forms can still use it`,
-      ).toBeTruthy();
-
-      // The bare and namespaced renderers must NOT be identical. If they
-      // are, it means the field renderer wrote to the bare fallback and
-      // would render an empty <input> instead of the display widget.
-      expect(
-        bare,
-        `bare "${type}" must not be the same component as field:${type}`,
-      ).not.toBe(namespaced);
-    },
-  );
-
-  it('non-colliding field types DO populate the bare fallback', () => {
-    // Sanity check: a field type with no display-widget collision (e.g.
-    // `email`, `password`, `number`) must still register both at the
-    // namespaced AND bare keys, otherwise we'd silently break forms.
-    for (const type of ['email', 'password', 'number', 'date', 'select']) {
-      expect(
-        ComponentRegistry.get(`field:${type}`),
-        `field:${type} must be registered`,
-      ).toBeTruthy();
-      expect(
-        ComponentRegistry.get(type),
-        `bare "${type}" must also be reachable (no collision)`,
-      ).toBeTruthy();
-    }
-  });
-});

package/src/__tests__/resolveFieldCurrency.test.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { resolveFieldCurrency } from '../index';
-
-describe('resolveFieldCurrency', () => {
-  it('prefers the field explicit currency over everything', () => {
-    expect(resolveFieldCurrency({ currency: 'JPY', currencyConfig: { defaultCurrency: 'EUR' } }, 'USD')).toBe('JPY');
-  });
-  it('falls back to currencyConfig.defaultCurrency, then legacy defaultCurrency', () => {
-    expect(resolveFieldCurrency({ currencyConfig: { defaultCurrency: 'EUR' } }, 'USD')).toBe('EUR');
-    expect(resolveFieldCurrency({ defaultCurrency: 'GBP' } as any, 'USD')).toBe('GBP');
-  });
-  it('falls back to the tenant default when the field omits its own', () => {
-    expect(resolveFieldCurrency({}, 'CNY')).toBe('CNY');
-    expect(resolveFieldCurrency(null, 'CNY')).toBe('CNY');
-  });
-  it('returns undefined when nothing is known (→ renderer shows a plain number)', () => {
-    expect(resolveFieldCurrency({})).toBeUndefined();
-    expect(resolveFieldCurrency(undefined, undefined)).toBeUndefined();
-  });
-});

package/src/__tests__/select-label-association-e2e.test.tsx

@@ -1,199 +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.
- */
-
-/**
- * End-to-end: BOTH select paths associate the form's visible label with the
- * control the user operates (objectui#3976, the built-in half of #3306).
- *
- * There are two `select` paths through the form renderer and they do not share
- * an implementation:
- *
- *  - **registered widget** — `type: 'field:select'` (what `mapFieldTypeToFormType`
- *    emits for object-driven forms) resolves to this package's `SelectField`.
- *    objectui#3306 moved its DOM pass-through from Radix's `Select.Root` — which
- *    renders no element and silently drops what it does not recognise — onto
- *    `SelectTrigger`, the focusable `<button role="combobox">`.
- *  - **built-in branch** — a hand-written `type: 'select'` never reaches the
- *    registry at all (`'select'` is a `BUILTIN_FIELD_TYPES` member), so the form
- *    renderer's own `Select` branch renders it. That branch kept spreading onto
- *    Root until objectui#3976: the visible label pointed at an id no element
- *    carried, `getByLabelText` found nothing, and `aria-describedby` /
- *    `aria-invalid` / `aria-required` never reached the DOM either.
- *
- * The paths are pinned side by side, in one file, precisely because the fork is
- * what caused the bug: #3306 fixed one half and the other silently kept the
- * defect for as long as nobody wrote a bare `type: 'select'` into a test. The
- * registered half here is a POSITIVE CONTROL — it must stay green through any
- * change to the built-in branch.
- *
- * The widget is registered raw rather than through `registerAllFields()`, which
- * wraps every loader in `React.lazy`: an unbounded module load inside a bounded
- * `findBy`/`waitFor` window is the repo's known flake generator (AGENTS.md
- * 测试纪律, objectui#3010). Same component, no Suspense boundary.
- */
-
-import { describe, it, expect, beforeAll, beforeEach, afterEach, vi } from 'vitest';
-import { render, screen, fireEvent, waitFor, cleanup } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { ComponentRegistry } from '@object-ui/core';
-// Module scope: pulls in the form renderer's registration side effect.
-import '@object-ui/components';
-
-import { SelectField } from '../widgets/SelectField';
-
-const OPTIONS = [
-  { label: 'Alpha', value: 'alpha' },
-  { label: 'Beta', value: 'beta' },
-];
-
-beforeAll(() => {
-  ComponentRegistry.register('select', SelectField as any, {
-    namespace: 'field',
-    skipFallback: true,
-  });
-}, 30000);
-
-beforeEach(() => {
-  if (!(Element.prototype as any).scrollIntoView) {
-    (Element.prototype as any).scrollIntoView = () => {};
-  }
-});
-
-afterEach(() => {
-  cleanup();
-  vi.restoreAllMocks();
-});
-
-/** The real form renderer hosting one field. */
-function renderForm(field: any, defaultValue: unknown = undefined) {
-  const Form = ComponentRegistry.get('form')!;
-  return render(
-    <Form
-      schema={{
-        type: 'form',
-        mode: 'create',
-        showSubmit: true,
-        showCancel: false,
-        submitLabel: 'Create',
-        defaultValues: { [field.name]: defaultValue },
-        fields: [field],
-        onSubmit: () => {},
-      }}
-    />,
-  );
-}
-
-/** Every `<label for=…>` in the document, paired with its resolved target. */
-function labelTargets(): Array<{ text: string; forId: string; resolves: boolean }> {
-  return Array.from(document.querySelectorAll('label'))
-    .map((el) => ({
-      text: (el.textContent ?? '').trim(),
-      forId: el.getAttribute('for') ?? '',
-      resolves: !!el.getAttribute('for') && !!document.getElementById(el.getAttribute('for')!),
-    }))
-    .filter((l) => l.forId !== '');
-}
-
-/** The trigger button, by role — fails loudly if it stops being a combobox. */
-function trigger(name: string): Element {
-  const el = document.querySelector(`[data-field="${name}"] [role="combobox"]`);
-  if (!el) throw new Error(`no select trigger rendered for field "${name}"`);
-  return el;
-}
-
-const submit = () => fireEvent.click(screen.getByRole('button', { name: /create/i }));
-
-/**
- * The guarantees a select must give whichever path rendered it. Run twice, so
- * neither path can drift away from the other again.
- */
-const PATHS = [
-  ['built-in branch (bare `type: select`, objectui#3976)', 'select'],
-  ['registered widget (`field:select`, objectui#3306 — positive control)', 'field:select'],
-] as const;
-
-describe.each(PATHS)('%s', (_label, type) => {
-  const field = { name: 'choice', label: 'Choice', type, options: OPTIONS };
-
-  it('emits no label pointing at an id nothing carries', () => {
-    renderForm(field);
-
-    const labels = labelTargets();
-    expect(labels.length).toBeGreaterThan(0);
-    expect(labels.filter((l) => !l.resolves)).toEqual([]);
-  });
-
-  it('resolves the visible label to the trigger button', () => {
-    renderForm(field);
-
-    // `getAllByLabelText` walks `for`→id, so it guards the association itself:
-    // on the built-in path this used to find NOTHING at all.
-    const labelled = screen.getAllByLabelText('Choice');
-    expect(labelled).toHaveLength(1);
-    expect(labelled[0]).toBe(trigger('choice'));
-    expect(labelled[0].tagName).toBe('BUTTON');
-  });
-
-  it('gives the combobox the label as its accessible name', () => {
-    renderForm(field);
-
-    expect(screen.getByRole('combobox', { name: 'Choice' })).toBe(trigger('choice'));
-  });
-
-  it('carries the required state on the trigger', () => {
-    renderForm({ ...field, required: true });
-
-    expect(trigger('choice')).toHaveAttribute('aria-required', 'true');
-  });
-
-  it('announces invalid on the trigger and links the message', async () => {
-    renderForm({ ...field, required: true }, null);
-
-    // A valid field SAYS it is valid rather than staying mute (#3222/#3306).
-    expect(trigger('choice')).toHaveAttribute('aria-invalid', 'false');
-
-    submit();
-
-    const message = await screen.findByText('Choice is required');
-    await waitFor(() => expect(trigger('choice')).toHaveAttribute('aria-invalid', 'true'));
-    expect(message.id).not.toBe('');
-    const describedBy = trigger('choice').getAttribute('aria-describedby') ?? '';
-    expect(describedBy.split(/\s+/)).toContain(message.id);
-  });
-
-  it('keeps `name` on Root, where the submitted hidden select is', () => {
-    // The whitelist both paths share: `name` is the ONE key Root consumes — it
-    // forwards it to the hidden native `<select>` that takes part in form
-    // submission. On the trigger it would sit uselessly on a non-submitter.
-    renderForm(field);
-
-    expect(document.querySelector('[data-field="choice"] select[aria-hidden="true"]')).toHaveAttribute(
-      'name',
-      'choice',
-    );
-    expect(trigger('choice')).not.toHaveAttribute('name');
-  });
-});
-
-describe('the fork itself (objectui#3976 / #3231)', () => {
-  it('a bare `type: select` renders the BUILT-IN branch even though field:select resolves', () => {
-    // Measured, not inferred — this is the fact that made #3976 a built-in-side
-    // bug rather than a duplicate of #3306: `renderFieldComponent` skips the
-    // registry entirely for a `BUILTIN_FIELD_TYPES` member, so `SelectField` is
-    // NOT what renders a hand-written `type: 'select'`, even here where the real
-    // widget is registered under `field:select`.
-    expect(ComponentRegistry.get('field:select')).toBe(SelectField);
-
-    renderForm({ name: 'choice', label: 'Choice', type: 'select', options: OPTIONS });
-
-    // `SelectField` stamps this locator on the trigger it renders; the built-in
-    // branch does not. Same role, different implementation.
-    expect(document.querySelector('[data-testid="select-trigger-choice"]')).toBeNull();
-    expect(trigger('choice')).toBeInTheDocument();
-  });
-});

package/src/__tests__/spec-symbol-batch7.test.ts

@@ -1,126 +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.
- */
-
-/**
- * `@object-ui/fields` ↔ `@objectstack/spec` symbol-collision guards
- * (objectui#3161, objectstack#4115 ledger batch 7).
- *
- * Two symbols, two different verdicts:
- *
- *  - `isFileIdToken` was a character-for-character copy of the spec's function
- *    under the spec's own name. It is a re-export now, and the gate below is
- *    REFERENCE IDENTITY — not behaviour. A faithful copy passes every behaviour
- *    test ever written for it (objectui#3003, re-proved on
- *    `isAggregatedViewContainer` in objectui#3169), so `toBe` is the only
- *    assertion that can tell a re-export from a fork.
- *
- *  - `FieldWidgetProps` is now `FieldWidgetComponentProps`. The spec owns that
- *    name for the DECLARED widget-plugin props contract; this package's is the
- *    React interface its widgets implement. The pins record what still makes
- *    re-exporting impossible (`field` is the far richer `FieldMetadata` here)
- *    and, since objectui#3222, what no longer does: the validation slot is the
- *    spec's `error` on both sides.
- *
- * The other direction — "the spec must not start owning the NEW names" — is not
- * asserted here because `scripts/check-spec-symbol-derivation.mjs` already
- * answers it on every CI run, for every name in the package rather than the
- * handful a test would remember to list.
- */
-
-import { describe, it, expect } from 'vitest';
-import { isFileIdToken as specIsFileIdToken } from '@objectstack/spec/data';
-import type { FieldWidgetProps as SpecFieldWidgetProps } from '@objectstack/spec/ui';
-
-import { isFileIdToken, fileIdOf } from '../widgets/file-value';
-import type { FieldWidgetComponentProps } from '../widgets/types';
-
-describe('isFileIdToken IS the spec function', () => {
-  it('is the same function object, not an equivalent one', () => {
-    // The whole point. Every value/behaviour assertion below this line would
-    // also pass against a re-forked copy; this one would not.
-    expect(isFileIdToken).toBe(specIsFileIdToken);
-  });
-
-  it('is the arbiter the rest of the module routes through', () => {
-    // `fileIdOf` must keep agreeing with the shared predicate, so a future
-    // "small local tweak" to the id shape cannot be reintroduced one caller at
-    // a time.
-    for (const value of ['abc123', 'AbC-_9', 'x'.repeat(64)]) {
-      expect(specIsFileIdToken(value)).toBe(true);
-      expect(fileIdOf(value)).toBe(value);
-    }
-    for (const value of ['https://example.com/f.png', '/api/v1/storage/files/1', 'a.b', 'x'.repeat(65)]) {
-      expect(specIsFileIdToken(value)).toBe(false);
-      expect(fileIdOf(value)).toBeUndefined();
-    }
-  });
-});
-
-/* -------------------------------------------------------------------------- */
-/* Compile-time pins. A violation is a `tsc` error, not a runtime failure.     */
-/* This package's tsconfig.json includes its tests, so `type-check` compiles   */
-/* them (scripts/check-type-check-coverage.mjs keeps that true).              */
-/* -------------------------------------------------------------------------- */
-
-type Assert<T extends true> = T;
-type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-type Extends<A, B> = [A] extends [B] ? true : false;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type HasKey<T, K extends string> = K extends keyof T ? true : false;
-
-describe('FieldWidgetComponentProps is the RENDERED layer of the spec contract', () => {
-  it('is pinned at compile time', () => {
-    // The import above is itself half the tripwire: the day the spec stops
-    // exporting `FieldWidgetProps`, this file stops compiling and the rename's
-    // reason is up for re-triage (the plain name could come back).
-    type _SpecIsReal = Assert<Equal<IsAny<SpecFieldWidgetProps>, false>>;
-
-    // The validation-message slot no longer diverges. objectui#3161 could only
-    // RECORD that the declared contract called it `error` while every widget
-    // here read `errorMessage`; objectui#3222 resolved it in the direction the
-    // contract points — this package adopted `error`, and the form renderer
-    // started producing it, so the name and the delivery landed together.
-    // Both sides are pinned: the spec still owns the name, and this package
-    // still spells it the same way.
-    type _SpecNamesItError = Assert<HasKey<SpecFieldWidgetProps, 'error'>>;
-    type _LocalNamesItErrorToo = Assert<HasKey<FieldWidgetComponentProps, 'error'>>;
-    type _SameOptionalStringSlot = Assert<
-      Equal<FieldWidgetComponentProps['error'], SpecFieldWidgetProps['error']>
-    >;
-    // The old name is gone, not kept as an alias. An alias would be exactly the
-    // lenient second dialect AGENTS.md #0.1 forbids — and the reason a missed
-    // call site would have gone quiet again.
-    type _OldNameRetired = Assert<Equal<HasKey<FieldWidgetComponentProps, 'errorMessage'>, false>>;
-
-    // …and the reason nobody noticed used to sit right here: three pins
-    // asserting that `[key: string]: any` was still present, and that
-    // `props.required` / `props.error` therefore read as `any`. objectui#3221
-    // removed that index signature, so those pins have gone red on purpose and
-    // are gone with it. What replaces them is the inverse claim — the type is
-    // now CLOSED, so a key the spec declares and this one does not can finally
-    // be reported as missing. That is what made objectui#3222's rename
-    // decidable by the compiler instead of by a symbol guard.
-    type _NoStringIndexSignature = Assert<Equal<Extends<string, keyof FieldWidgetComponentProps>, false>>;
-    // `required` is the one key that stayed behind, and deliberately so
-    // (objectui#3222): the required marker has a single author — the form
-    // renderer's `<FormLabel>` — and lowering the flag into widget props gives
-    // it a second, i.e. the double-display failure that also keeps the
-    // validation TEXT out of the widget. The a11y state a widget could
-    // legitimately carry is `aria-required`, and `AriaAttributes` already
-    // supplies that key with no contract change at all.
-    type _RequiredIsAbsent = Assert<Equal<HasKey<FieldWidgetComponentProps, 'required'>, false>>;
-
-    // `data-*` stays open (it is open in HTML too), but as a template-literal
-    // key — the distinction that keeps `keyof` finite above. A pin, because
-    // widening it back to `[key: string]` would silently restore the defect
-    // while every assertion here still read as "closed".
-    type _DataAttributesStayOpen = Assert<Extends<'data-testid', keyof FieldWidgetComponentProps>>;
-
-    expect(true).toBe(true);
-  });
-});