@object-ui/fields 17.3.0 → 17.6.0

package/src/__tests__/cell-truncation.test.tsx

@@ -1,96 +0,0 @@
-/**
- * Regression for objectstack-ai/objectui#3466: single-line cell renderers
- * emitted a BARE INLINE `span.truncate`. An inline box has no width box, so
- * `overflow:hidden` / `text-overflow:ellipsis` never engage — the value
- * rendered at full content width and its tail was silently clipped by
- * whatever ancestor happened to clip (the record-detail card edge), with no
- * ellipsis and no way to read the full text (the detail row's `title` is the
- * inline-edit hint, not the value). Same mechanism as the JSON cell fix in
- * objectui#2578.
- *
- * Pin: every single-line value renderer emits a BLOCK-level, `max-w-full`
- * truncating span that carries the full text in `title` (so hovering the
- * value shows the full text, taking precedence over any ancestor `title`).
- */
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import React from 'react';
-
-import {
-  TextCellRenderer,
-  LookupCellRenderer,
-  UserCellRenderer,
-  FileCellRenderer,
-  SelectCellRenderer,
-} from '../index';
-import { SchemaRendererProvider } from '@object-ui/react';
-
-const LONG =
-  'A remarkably long referenced-record title that a detail card column can never fit on a single line without an ellipsis';
-
-/** The block-level truncation contract every single-line value span must meet. */
-function expectTruncating(el: HTMLElement, fullText: string) {
-  expect(el).toHaveClass('block', 'max-w-full', 'truncate');
-  expect(el).toHaveAttribute('title', fullText);
-}
-
-describe('cell renderers truncate for real and expose the full text (issue #3466)', () => {
-  it('TextCellRenderer: block-level truncating span with title fallback', () => {
-    render(<TextCellRenderer value={LONG} field={{ type: 'text' } as any} />);
-    expectTruncating(screen.getByText(LONG), LONG);
-  });
-
-  it('LookupCellRenderer: expanded record object', () => {
-    const ds = { find: vi.fn(), findOne: vi.fn() } as any;
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={{ id: 'rec1', name: LONG }}
-          field={{ type: 'lookup', reference_to: 'obj_a' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    expectTruncating(screen.getByText(LONG), LONG);
-  });
-
-  it('LookupCellRenderer: primitive non-opaque value', () => {
-    const ds = { find: vi.fn(), findOne: vi.fn() } as any;
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer value={LONG} field={{ type: 'lookup' } as any} />
-      </SchemaRendererProvider>,
-    );
-    expectTruncating(screen.getByText(LONG), LONG);
-  });
-
-  it('UserCellRenderer: display name beside the avatar', () => {
-    render(<UserCellRenderer value={{ name: LONG }} field={{ type: 'user' } as any} />);
-    expectTruncating(screen.getByText(LONG), LONG);
-  });
-
-  it('FileCellRenderer: single file name', () => {
-    render(<FileCellRenderer value={{ name: LONG }} field={{ type: 'file' } as any} />);
-    expectTruncating(screen.getByText(LONG), LONG);
-  });
-
-  it('SelectCellRenderer (dot): bounded container with title, shrinkable label', () => {
-    render(
-      <SelectCellRenderer
-        value="opt1"
-        field={{
-          type: 'select',
-          appearance: 'dot',
-          options: [{ value: 'opt1', label: LONG }],
-        } as any}
-      />,
-    );
-    const label = screen.getByText(LONG);
-    // The label shrinks inside the dot row; the row itself is width-bounded
-    // and carries the full text on hover.
-    expect(label).toHaveClass('min-w-0', 'truncate');
-    const row = label.parentElement!;
-    expect(row).toHaveClass('max-w-full');
-    expect(row).toHaveAttribute('title', LONG);
-  });
-});

package/src/__tests__/field-carrier-sdui.test.tsx

@@ -1,169 +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 SDUI path delivers field metadata on ONE key — objectui#3233.
- *
- * `SchemaRenderer` hands every registered component the authored node as
- * `schema`. That key is the universal SDUI contract (`element:*`, `page:*`,
- * `object-grid`, `ReportRenderer` …) and is NOT retired. What was retired is
- * `schema` on the *field-widget* contract: a widget used to receive the node
- * under `schema` here and the metadata under `field` from the form renderer,
- * which is why ~30 widgets resolved their config as `field || schema`.
- *
- * The translation now happens once, at the registration seam
- * (`withFieldCarrier`), so downstream `field` is the only carrier. That is only
- * correct if the node reaches the widget UNCHANGED — "swap the key, don't drop
- * the cargo". The first test proves it by OBJECT IDENTITY: a spy sits where the
- * registry entry sits, records the object `SchemaRenderer` passed as `schema`,
- * and the widget's `field` must be that exact object. (Identity against the
- * authored literal would be wrong to assert — `SchemaRenderer` shallow-copies
- * the node while evaluating expressions, so the object it delivers is its own.)
- *
- * The last test pins that the REAL registration path goes through the adapter
- * at all: an adapter nobody applied would leave every SDUI-hosted widget
- * reading `undefined`, which is exactly the silent failure this convergence is
- * accused of risking.
- *
- * The sibling half of the invariant — the form path through
- * `renderFieldComponent` — is pinned in `packages/components/src/renderers/
- * form/__tests__/form-field-carrier.test.tsx`.
- */
-
-import React, { Suspense } from 'react';
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { render, screen, cleanup } from '@testing-library/react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer } from '@object-ui/react';
-
-import { withFieldCarrier } from '../withFieldCarrier';
-import { registerField } from '../index';
-// Module scope, not a hook: `registerField('boolean')` registers
-// `React.lazy(() => import('./widgets/BooleanField'))`, and under a saturated
-// transform pipeline a first `import()` can outlive RTL's 1000ms budget. The
-// specifier matches `fieldWidgetMap`'s exactly, so ESM's cache makes that
-// factory resolve immediately (AGENTS.md 测试纪律 / objectui#3010).
-import '../widgets/BooleanField';
-
-/**
- * Capture holder, not bare module variables: `react-hooks/globals` forbids
- * REASSIGNING an outer binding from a component body, which is what a probe
- * has to do. Mutating a property of a stable object is the repo's usual shape
- * for this (see plugin-detail's `RelatedList` probes).
- */
-const captured: { props: Record<string, any> | null; node: unknown } = {
-  props: null,
-  node: null,
-};
-
-function CarrierProbe(props: any) {
-  captured.props = props;
-  return <div data-testid="carrier-probe">{props.field?.label ?? 'NO FIELD'}</div>;
-}
-
-const AdaptedProbe = withFieldCarrier(CarrierProbe);
-
-/**
- * Sits exactly where the registry entry sits, so it sees the host's props
- * verbatim, then forwards them to the adapter under test. This is what makes
- * the identity assertion possible: `captured.node` and the widget's `field`
- * are observed within a single render pass.
- */
-function CarrierSpy(props: any) {
-  captured.node = props.schema;
-  return <AdaptedProbe {...props} />;
-}
-
-beforeEach(() => {
-  captured.props = null;
-  captured.node = null;
-  ComponentRegistry.register('carrierprobe', CarrierSpy, {
-    namespace: 'field',
-    skipFallback: true,
-  });
-});
-
-afterEach(() => {
-  cleanup();
-  vi.restoreAllMocks();
-});
-
-describe('SDUI path — the authored node arrives as `field` (objectui#3233)', () => {
-  it('hands the widget the very object it used to read through `schema`', () => {
-    const node = {
-      type: 'field:carrierprobe',
-      name: 'city',
-      label: 'City',
-      placeholder: 'Where?',
-      options: [{ label: 'Beijing', value: 'bj' }],
-    };
-
-    render(<SchemaRenderer schema={node as any} />);
-
-    expect(screen.getByTestId('carrier-probe')).toHaveTextContent('City');
-    expect(captured.props).not.toBeNull();
-    expect(captured.node).toBeTruthy();
-    // The payload-equivalence proof: same object, by reference. A
-    // reconstruction would still render "City" while quietly dropping whatever
-    // the copy did not know to carry.
-    expect(captured.props!.field).toBe(captured.node);
-    // …and it really is the whole authored node, not a narrowed projection.
-    expect(captured.props!.field.name).toBe('city');
-    expect(captured.props!.field.placeholder).toBe('Where?');
-    expect(captured.props!.field.options).toEqual([{ label: 'Beijing', value: 'bj' }]);
-  });
-
-  it('consumes `schema` rather than forwarding it to the widget', () => {
-    // Key ABSENCE, not `undefined`. Two reasons it must not be forwarded: a
-    // widget could resolve `field || schema` again (the second contract
-    // survives in practice while the type claims it is gone), and widgets
-    // spread their leftover props onto DOM nodes, where an object-valued
-    // `schema` attribute is a React warning.
-    render(
-      <SchemaRenderer schema={{ type: 'field:carrierprobe', name: 'city', label: 'City' } as any} />,
-    );
-
-    expect(captured.props).not.toBeNull();
-    expect('schema' in captured.props!).toBe(false);
-  });
-
-  it('lets an explicit `field` win when a host supplies both', () => {
-    // The form renderer passes `field` (resolved metadata) and never `schema`.
-    // If some host ever passed both, the resolved metadata is the better
-    // answer — the raw node is the fallback, not the override.
-    const node = { type: 'field:carrierprobe', name: 'from-node', label: 'From node' };
-    const metadata = { name: 'from-field', label: 'From field' };
-
-    render(<AdaptedProbe schema={node} field={metadata} />);
-
-    expect(captured.props!.field).toBe(metadata);
-  });
-
-  it('applies the adapter on the REAL registration path (`registerField`)', async () => {
-    // The seam is only worth anything if `registerField` goes through it.
-    // `BooleanField` reads `widget` / `name` off its metadata carrier and
-    // nowhere else: `widget: 'checkbox'` selects the Checkbox over the Switch,
-    // and `name` becomes the control's id. Both are node keys, so seeing them
-    // honoured here proves the node reached `field` end to end — through the
-    // real registry entry, the real SchemaRenderer, and the real widget.
-    registerField('boolean');
-
-    render(
-      <Suspense fallback={<div>loading</div>}>
-        <SchemaRenderer
-          schema={
-            { type: 'field:boolean', name: 'is_active', label: 'Active', widget: 'checkbox' } as any
-          }
-        />
-      </Suspense>,
-    );
-
-    const control = await screen.findByRole('checkbox');
-    expect(control).toHaveAttribute('id', 'is_active');
-  });
-});

package/src/__tests__/lookupCellDisplayField.test.tsx

@@ -1,107 +0,0 @@
-/**
- * [framework#2926 ⑧] LookupCellRenderer must honor the target object's
- * configured display field. ObjectGrid forwards `display_field` on the
- * column meta (RELATIONAL_META_KEYS) exactly like `reference`, but the read
- * cell used to ignore it and always ran the hardcoded heuristics — `name`
- * first — so a target object whose displayNameField is a localized/label
- * field still rendered the raw API `name`.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import React from 'react';
-
-import { LookupCellRenderer } from '../index';
-import { SchemaRendererProvider } from '@object-ui/react';
-
-const ID_A = '01ARZ3NDEKTSV4RRFFQ69G5FAA';
-const ID_B = '01ARZ3NDEKTSV4RRFFQ69G5FAB';
-
-function makeDataSource() {
-  const findOne = vi.fn(async (object: string, id: string) => {
-    if (object === 'showcase_category') {
-      // Record carries BOTH the raw API name and a localized label field.
-      if (id === ID_A) return { id, name: 'cat_hardware', label_zh: '硬件' };
-      if (id === ID_B) return { id, name: 'cat_software', label_zh: '软件' };
-    }
-    return null;
-  });
-  return { findOne, find: vi.fn() } as any;
-}
-
-describe('LookupCellRenderer — display_field resolution', () => {
-  it('prefers the configured display_field over the heuristic `name`', async () => {
-    const ds = makeDataSource();
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={ID_A}
-          field={{ type: 'lookup', reference: 'showcase_category', display_field: 'label_zh' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('硬件')).toBeInTheDocument();
-    });
-    expect(screen.queryByText('cat_hardware')).not.toBeInTheDocument();
-  });
-
-  it('keeps the heuristic (`name` first) when no display_field is configured', async () => {
-    const ds = makeDataSource();
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={ID_A}
-          field={{ type: 'lookup', reference: 'showcase_category' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('cat_hardware')).toBeInTheDocument();
-    });
-  });
-
-  it('uses display_field on server-expanded nested objects (no fetch path)', () => {
-    const ds = makeDataSource();
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={{ id: ID_A, name: 'cat_hardware', label_zh: '硬件' } as any}
-          field={{ type: 'lookup', reference: 'showcase_category', display_field: 'label_zh' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    expect(screen.getByText('硬件')).toBeInTheDocument();
-    expect(ds.findOne).not.toHaveBeenCalled();
-  });
-
-  it('does not serve a cached heuristic name to a display_field column (cache key isolation)', async () => {
-    const ds = makeDataSource();
-    // First: a column WITHOUT display_field resolves and caches the heuristic name.
-    const first = render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={ID_B}
-          field={{ type: 'lookup', reference: 'showcase_category' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('cat_software')).toBeInTheDocument();
-    });
-    first.unmount();
-    // Then: a column WITH display_field for the same record must show the
-    // configured field, not the previously cached heuristic name.
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={ID_B}
-          field={{ type: 'lookup', reference: 'showcase_category', display_field: 'label_zh' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('软件')).toBeInTheDocument();
-    });
-  });
-});

package/src/__tests__/lookupCellDisplayName.test.tsx

@@ -1,119 +0,0 @@
-/**
- * Regression for objectstack-ai/objectui#2357: the lookup chip
- * (LookupCellRenderer — record header highlight + detail sections) resolved
- * display names via the local key heuristic (`pickRecordDisplayName`), whose
- * `_number`/`_code` suffix scan surfaced an autonumber (`0001`) over the
- * record's real name whenever the referenced object declared its title in
- * `nameField`/`titleFormat`. The picker (LookupField) already resolved via the
- * unified ADR-0079 resolver, so the two surfaces disagreed.
- *
- * The chip must now resolve through the referenced object's schema
- * (`dataSource.getObjectSchema`) with the precedence
- * `displayField → nameField/titleFormat → type-aware derivation`, keeping the
- * key heuristic only as the no-schema fallback.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import React from 'react';
-
-import { LookupCellRenderer } from '../index';
-import { SchemaRendererProvider } from '@object-ui/react';
-
-// The expanded record: the autonumber (`req_number`) precedes the real name
-// (`req_name`) in key order, so the OLD heuristic-only path rendered "0001".
-const EXPANDED = { id: 'rec1', req_number: '0001', req_name: 'Annual Maintenance' };
-
-function makeDataSource(objectName: string, schema: any, record?: any) {
-  return {
-    find: vi.fn(),
-    findOne: vi.fn(async (object: string, id: string) =>
-      object === objectName && record && id === record.id ? record : null,
-    ),
-    getObjectSchema: vi.fn(async (object: string) =>
-      object === objectName ? schema : null,
-    ),
-  } as any;
-}
-
-describe('LookupCellRenderer — schema-aware display name (issue #2357)', () => {
-  it('expanded object: nameField beats the autonumber suffix heuristic', async () => {
-    const ds = makeDataSource('mtc_request_a', { nameField: 'req_name' });
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={EXPANDED}
-          field={{ type: 'lookup', reference_to: 'mtc_request_a' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('Annual Maintenance')).toBeInTheDocument();
-    });
-    expect(screen.queryByText('0001')).not.toBeInTheDocument();
-  });
-
-  it('expanded object: titleFormat template resolves when no nameField', async () => {
-    const ds = makeDataSource('mtc_request_b', { titleFormat: '{req_name} - {req_number}' });
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={{ ...EXPANDED }}
-          field={{ type: 'lookup', reference_to: 'mtc_request_b' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('Annual Maintenance - 0001')).toBeInTheDocument();
-    });
-  });
-
-  it('explicit displayField wins over the schema nameField', async () => {
-    const ds = makeDataSource('mtc_request_c', { nameField: 'req_name' });
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={{ ...EXPANDED }}
-          field={{ type: 'lookup', reference_to: 'mtc_request_c', display_field: 'req_number' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    // Author explicitly asked for the number — honour it (also the documented
-    // workaround in the issue).
-    expect(await screen.findByText('0001')).toBeInTheDocument();
-  });
-
-  it('fetch-on-demand primitive id resolves via the schema nameField too', async () => {
-    // Opaque ULID-ish id so the old path would have resolved the fetched
-    // record through the heuristic and shown its autonumber.
-    const id = '01ARZ3NDEKTSV4RRFFQ69G5FBB';
-    const record = { id, req_number: '0007', req_name: 'Pump Overhaul' };
-    const ds = makeDataSource('mtc_request_d', { nameField: 'req_name' }, record);
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={id}
-          field={{ type: 'lookup', reference_to: 'mtc_request_d' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    await waitFor(() => {
-      expect(screen.getByText('Pump Overhaul')).toBeInTheDocument();
-    });
-    expect(screen.queryByText('0007')).not.toBeInTheDocument();
-    expect(ds.getObjectSchema).toHaveBeenCalledWith('mtc_request_d');
-  });
-
-  it('falls back to the key heuristic when the data source has no schema API', () => {
-    const ds = { find: vi.fn(), findOne: vi.fn() } as any; // no getObjectSchema
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={{ id: 'rec2', framework_name: 'SOX' }}
-          field={{ type: 'lookup', reference_to: 'mtc_request_e' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-    expect(screen.getByText('SOX')).toBeInTheDocument();
-  });
-});

package/src/__tests__/lookupCellReferenceKey.test.tsx

@@ -1,57 +0,0 @@
-/**
- * Regression: LookupCellRenderer must resolve a bare foreign-key id to a
- * display name when the field metadata carries the ObjectStack `reference`
- * key (as produced by `Field.lookup('...')` in @objectstack/spec) — not only
- * the objectui `reference_to` alias.
- *
- * Real-world symptom (framework app-showcase): inline-edit a lookup cell, pick
- * a record, click another row → the cell showed a muted "—" forever because
- * the just-picked opaque id could not be resolved. Every other reader in the
- * codebase (LookupField, UserField, DetailSection, RelatedList, …) already
- * accepts `reference_to || reference`; this read cell used to read only
- * `reference_to`.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import React from 'react';
-
-import { LookupCellRenderer } from '../index';
-import { SchemaRendererProvider } from '@object-ui/react';
-
-// A ULID-style id: `isLikelyOpaqueId` returns true for it, so the OLD code
-// (which failed to resolve) would fall back to the muted "—" placeholder.
-const OPAQUE_ID = '01ARZ3NDEKTSV4RRFFQ69G5FAV';
-
-function makeDataSource() {
-  const findOne = vi.fn(async (object: string, id: string) => {
-    if (object === 'showcase_account' && id === OPAQUE_ID) {
-      return { id, name: 'Globex' };
-    }
-    return null;
-  });
-  return { findOne, find: vi.fn() } as any;
-}
-
-describe('LookupCellRenderer — reference key resolution', () => {
-  it('resolves an opaque id to a name via the `reference` key (not just reference_to)', async () => {
-    const ds = makeDataSource();
-    render(
-      <SchemaRendererProvider dataSource={ds}>
-        <LookupCellRenderer
-          value={OPAQUE_ID}
-          // ObjectStack convention: the lookup target lives under `reference`.
-          field={{ type: 'lookup', reference: 'showcase_account' } as any}
-        />
-      </SchemaRendererProvider>,
-    );
-
-    // The related record's display name must appear…
-    await waitFor(() => {
-      expect(screen.getByText('Globex')).toBeInTheDocument();
-    });
-    // …and the muted placeholder must NOT be what the user sees.
-    expect(screen.queryByText('—')).not.toBeInTheDocument();
-    expect(ds.findOne).toHaveBeenCalledWith('showcase_account', OPAQUE_ID);
-  });
-});

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();
-  });
-});