@object-ui/fields 17.5.0 → 17.6.0

package/src/__tests__/CurrencyField.minorUnits.test.tsx

@@ -1,191 +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#4361, second path — `CurrencyField`'s `precision`.
- *
- * `formatAmount` passes the field's `precision` to BOTH `Intl` bounds, and the
- * widget defaulted that precision to a literal `2`. So a JPY field that
- * declared no precision rendered `¥1,234.50` for the same reason
- * `formatCurrency` did, one layer up.
- *
- * The PM ruling on this card (issue #4361, claim comment) splits it in two,
- * and both halves are pinned here:
- *
- *  1. **An explicitly authored `precision` WINS.** It is authored metadata and
- *     this repo's convention is that authored metadata keeps priority. A JPY
- *     field declaring `precision: 2` still renders `¥1,234.50` — whether that
- *     combination should be REJECTED at publish time is a spec question filed
- *     upstream (contract-first), not something the renderer decides by
- *     overriding the author.
- *  2. **An ABSENT `precision` derives from the currency** instead of falling
- *     back to 2.
- *
- * MEASURED, per the ruling's stop condition — is "absent" distinguishable from
- * "authored 2" by the time the renderer sees it? Yes:
- *
- *   - `CurrencyFieldMetadata.precision` is `precision?: number` in
- *     `packages/types/src/field-types.ts` — optional, no default;
- *   - the field-level key is `z.ZodOptional<z.ZodNumber>` in
- *     `@objectstack/spec` (no `.default()`), so a parsed field metadata object
- *     does NOT carry a materialized 2;
- *   - the only `.default(2)` in the spec's currency surface is on
- *     `CurrencyConfigSchema.precision` — a DIFFERENT key on a different object
- *     (the `currencyConfig` block), which this widget never reads; and
- *   - the `?? 2` itself lived in the widget, at `CurrencyField.tsx`.
- *
- * So the renderer holds an `undefined` it can act on, and this half lands.
- *
- * The derived precision is the widget's ONE precision, so it reaches the edit
- * affordances too (`step`, and the blur rounding) — pinned below. Leaving
- * those at 2 would have produced a JPY field that displays whole yen but
- * offers a 0.01 spinner step and rounds typed input to 1234.56 yen.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { LocalizationProvider } from '@object-ui/i18n';
-import { CurrencyField } from '../widgets/CurrencyField';
-
-/**
- * ICU separates a currency CODE from the amount with U+00A0 (`KWD` + NBSP +
- * `1.500`), while a SYMBOL is flush against it (`¥1,235`). `textContent` is
- * raw, so normalizing keeps these pins about the DIGIT COUNT this card is
- * about rather than about ICU's spacing. Written as an escape, never a pasted
- * byte — a raw NBSP in source is invisible to readers and unfindable by grep.
- */
-const normalizeNbsp = (s: string | null) => (s ?? '').replace(/\u00a0/g, ' ');
-
-const renderField = (
-  value: number | null,
-  field: Record<string, unknown>,
-  opts: { readonly?: boolean; locale?: string; tenantCurrency?: string; onChange?: (v: any) => void } = {},
-) =>
-  render(
-    <LocalizationProvider value={{ locale: opts.locale ?? 'en-US', currency: opts.tenantCurrency }}>
-      <CurrencyField
-        value={value as any}
-        onChange={opts.onChange ?? vi.fn()}
-        field={{ type: 'currency', ...field } as any}
-        readonly={opts.readonly}
-      />
-    </LocalizationProvider>,
-  );
-
-describe('CurrencyField — an ABSENT precision derives from the currency (objectui#4361)', () => {
-  it('a JPY field that declares no precision shows no cents', () => {
-    const { container } = renderField(1234.5, { currency: 'JPY' }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('¥1,235');
-  });
-
-  it('a KWD field that declares no precision shows all three digits', () => {
-    const { container } = renderField(1.5, { currency: 'KWD' }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('KWD 1.500');
-  });
-
-  it('the tenant default currency reaches the derivation too (ADR-0053)', () => {
-    const { container } = renderField(1234.5, {}, { readonly: true, tenantCurrency: 'JPY' });
-    expect(normalizeNbsp(container.textContent)).toBe('¥1,235');
-  });
-
-  it('`currencyConfig.defaultCurrency` reaches it as well', () => {
-    const { container } = renderField(
-      1.5,
-      { currencyConfig: { defaultCurrency: 'KWD' } },
-      { readonly: true },
-    );
-    expect(normalizeNbsp(container.textContent)).toBe('KWD 1.500');
-  });
-});
-
-describe('CurrencyField — an AUTHORED precision still wins (authored metadata keeps priority)', () => {
-  it('a JPY field declaring `precision: 2` keeps its two digits', () => {
-    // The renderer does not overrule the author. Whether publish-time
-    // validation should reject this combination is the upstream spec question
-    // filed alongside this card — deliberately NOT decided here.
-    const { container } = renderField(1234.5, { currency: 'JPY', precision: 2 }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('¥1,234.50');
-  });
-
-  it('an authored `precision: 0` on a 2-digit currency still wins', () => {
-    // The other direction, so the pin cannot be satisfied by "authored wins
-    // only when it asks for MORE digits".
-    const { container } = renderField(1234.5, { currency: 'USD', precision: 0 }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('$1,235');
-  });
-
-  it('an authored `precision: 3` on JPY wins', () => {
-    const { container } = renderField(1234.5, { currency: 'JPY', precision: 3 }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('¥1,234.500');
-  });
-});
-
-describe('CurrencyField — CONTROL: the 2-digit and no-currency cases are unchanged', () => {
-  it('a USD field with no declared precision renders exactly as before', () => {
-    // Derivation and the old literal agree at 2, which is the whole point of
-    // "byte-identical for USD".
-    const { container } = renderField(1234.5, { currency: 'USD' }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('$1,234.50');
-  });
-
-  it('a USD field declaring `precision: 2` renders exactly as before', () => {
-    const { container } = renderField(1234.56, { currency: 'USD', precision: 2 }, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('$1,234.56');
-  });
-
-  it('a field with NO currency keeps the literal 2 — nothing to derive from', () => {
-    const { container } = renderField(1234.5, {}, { readonly: true });
-    expect(normalizeNbsp(container.textContent)).toBe('1,234.50');
-  });
-
-  it('a null value is still the empty marker, not a formatted zero', () => {
-    const { container } = renderField(null, { currency: 'JPY' }, { readonly: true });
-    expect(container.textContent).not.toContain('¥');
-  });
-});
-
-describe('CurrencyField — the derived precision is the widget\'s ONE precision', () => {
-  it('a JPY field with no declared precision offers a whole-unit spinner step', () => {
-    renderField(1234, { currency: 'JPY' });
-    expect(screen.getByRole('spinbutton')).toHaveAttribute('step', '1');
-  });
-
-  it('a KWD field with no declared precision offers a three-digit step', () => {
-    renderField(1, { currency: 'KWD' });
-    expect(screen.getByRole('spinbutton')).toHaveAttribute('step', '0.001');
-  });
-
-  it('CONTROL: USD is still 0.01, authored or derived', () => {
-    const { unmount } = renderField(1, { currency: 'USD' });
-    expect(screen.getByRole('spinbutton')).toHaveAttribute('step', '0.01');
-    unmount();
-    renderField(1, { currency: 'JPY', precision: 2 });
-    expect(screen.getByRole('spinbutton')).toHaveAttribute('step', '0.01');
-  });
-
-  it('blur rounds a typed amount to the currency\'s own unit', () => {
-    const onChange = vi.fn();
-    renderField(null, { currency: 'JPY' }, { onChange });
-    const input = screen.getByRole('spinbutton');
-    fireEvent.change(input, { target: { value: '1234.56' } });
-    fireEvent.blur(input, { target: { value: '1234.56' } });
-    // Before: 1234.56 yen — a sub-unit amount the currency cannot express.
-    expect(onChange).toHaveBeenLastCalledWith(1235);
-  });
-
-  it('CONTROL: blur on a USD field still rounds to cents', () => {
-    const onChange = vi.fn();
-    renderField(null, { currency: 'USD' }, { onChange });
-    const input = screen.getByRole('spinbutton');
-    fireEvent.change(input, { target: { value: '1234.567' } });
-    fireEvent.blur(input, { target: { value: '1234.567' } });
-    expect(onChange).toHaveBeenLastCalledWith(1234.57);
-  });
-});

package/src/__tests__/CurrencyField.symbol.test.tsx

@@ -1,198 +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#4414 — the edit-mode currency adornment has ONE channel.
- *
- * Before this card `CurrencyField.tsx` carried the same one-entry fact twice: a
- * `CURRENCY_SYMBOLS` map that nothing read, and, two lines below it, the live
- * `currency === 'USD' ? '$' : currency` ternary. The PM ruling (issue #4414,
- * claim comment) says one channel survives, and that `Intl` — which already
- * carries this knowledge — is the candidate to MEASURE first.
- *
- * Measured, and it fits: `Intl.NumberFormat(locale, { style: 'currency',
- * currency }).formatToParts()` has a `currency` part, and that part is exactly
- * the string the widget's OWN readonly branch already renders, because the
- * readonly branch formats through `formatDisplayNumber(value, { locale,
- * currency })` — the same `Intl` call. So the adornment was the last hand copy,
- * and the widget disagreed with itself: at `en`, readonly JPY rendered
- * `¥1,235` while the edit adornment beside it said `JPY`.
- *
- * The one place this helper deliberately DIVERGES from its sibling
- * `currencyFractionDigits()`: the digit count is locale-independent (measured
- * across eight locales in `currency.ts`), so that probe drops the locale. The
- * SYMBOL is not — measured on node 22 / full-ICU:
- *
- *     USD -> "$" (en, en-US, de-DE, ja-JP) | "US$" (en-GB, zh-CN) | "$US" (fr-FR)
- *     JPY -> "¥" (en, de-DE) | "￥" (ja-JP) | "JP¥" (en-GB, zh-CN) | "JPY" (fr-FR)
- *
- * so `currencySymbol()` takes the display locale as a parameter and caches on
- * the PAIR. Keying the cache on the code alone would let whichever locale asked
- * first answer for every locale after it — pinned below, because that is a
- * silent wrong-answer bug and not a hypothetical.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import React from 'react';
-import { render } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { LocalizationProvider } from '@object-ui/i18n';
-import { CurrencyField } from '../widgets/CurrencyField';
-import { currencySymbol } from '../currency';
-
-/**
- * ICU separates a currency CODE from the amount with U+00A0 and sets a SYMBOL
- * flush against it; normalizing keeps the readonly-agreement pins about the
- * SYMBOL rather than about ICU's spacing. Written as an escape, never a pasted
- * byte.
- */
-const normalizeNbsp = (s: string | null) => (s ?? '').replace(/\u00a0/g, ' ');
-
-const renderField = (
-  field: Record<string, unknown>,
-  opts: { readonly?: boolean; locale?: string; tenantCurrency?: string } = {},
-) =>
-  render(
-    <LocalizationProvider value={{ locale: opts.locale ?? 'en', currency: opts.tenantCurrency }}>
-      <CurrencyField
-        value={1234.5}
-        onChange={vi.fn()}
-        field={{ type: 'currency', ...field } as any}
-        readonly={opts.readonly}
-      />
-    </LocalizationProvider>,
-  );
-
-/** The edit-mode prefix adornment: the only `span` inside the wrapper. */
-const adornment = (container: HTMLElement) =>
-  container.querySelector('div.relative > span')?.textContent ?? null;
-
-describe('CurrencyField adornment — USD is byte-identical at the display-locale default (objectui#4414)', () => {
-  it("`en` — useDisplayLocale()'s own last resort — still renders exactly `$`", () => {
-    const { container } = renderField({ currency: 'USD' });
-    expect(adornment(container)).toBe('$');
-  });
-
-  it('`en-US` still renders exactly `$`', () => {
-    const { container } = renderField({ currency: 'USD' }, { locale: 'en-US' });
-    expect(adornment(container)).toBe('$');
-  });
-
-  it('the tenant default currency reaches the adornment too (ADR-0053)', () => {
-    const { container } = renderField({}, { tenantCurrency: 'USD' });
-    expect(adornment(container)).toBe('$');
-  });
-
-  it('a field with NO currency still renders no adornment and no left padding', () => {
-    const { container } = renderField({});
-    expect(adornment(container)).toBeNull();
-    expect(container.querySelector('input')).not.toHaveClass('pl-8');
-  });
-
-  it('a field WITH a currency still gets the left padding that clears the adornment', () => {
-    const { container } = renderField({ currency: 'USD' });
-    expect(container.querySelector('input')).toHaveClass('pl-8');
-  });
-});
-
-describe('CurrencyField adornment — the DOCUMENTED non-USD change: a real symbol replaces the bare code', () => {
-  // Before #4414 every one of these rendered the three-letter ISO code, because
-  // the ternary had exactly one entry. This is the deliberate improvement the
-  // ruling allowed for, not a side effect — and it is what the widget's own
-  // readonly branch has been rendering all along.
-  it.each([
-    ['EUR', '€'],
-    ['JPY', '¥'],
-    ['GBP', '£'],
-    ['INR', '₹'],
-    ['KRW', '₩'],
-  ])('%s now renders %s instead of the code', (currency, symbol) => {
-    const { container } = renderField({ currency });
-    expect(adornment(container)).toBe(symbol);
-  });
-});
-
-describe('CurrencyField adornment — currencies CLDR has no symbol for keep the code, byte-identical', () => {
-  // ICU answers with the code itself for these, which is exactly what the
-  // ternary produced. Nothing changes, and that is worth pinning: it is the
-  // half of the ruling's "symbol-vs-code nuance" that survives the change.
-  it.each(['KWD', 'BHD', 'CHF', 'ISK', 'CLP'])('%s still renders its bare code', (currency) => {
-    const { container } = renderField({ currency });
-    expect(adornment(container)).toBe(currency);
-  });
-});
-
-describe('CurrencyField adornment — it agrees with the SAME widget\'s readonly rendering', () => {
-  // The real invariant behind this card. The readonly branch already formats
-  // through the display locale, so before #4414 the widget contradicted itself
-  // for every currency with a symbol.
-  it.each([
-    ['en', 'JPY'],
-    ['en', 'EUR'],
-    ['en-GB', 'USD'],
-    ['fr-FR', 'USD'],
-    ['ja-JP', 'JPY'],
-    ['de-DE', 'USD'],
-    ['en', 'KWD'],
-  ])('%s / %s — the readonly text contains the adornment string', (locale, currency) => {
-    const edit = renderField({ currency }, { locale });
-    const symbol = adornment(edit.container);
-    expect(symbol).toBeTruthy();
-    const view = renderField({ currency }, { locale, readonly: true });
-    expect(normalizeNbsp(view.container.textContent)).toContain(symbol as string);
-  });
-});
-
-describe('currencySymbol() — the symbol is locale-dependent, so the locale is a parameter', () => {
-  it('USD is not one string across locales', () => {
-    expect(currencySymbol('USD', 'en')).toBe('$');
-    expect(currencySymbol('USD', 'fr-FR')).toBe('$US');
-    expect(currencySymbol('USD', 'en-GB')).toBe('US$');
-  });
-
-  it('JPY at ja-JP is the FULLWIDTH yen sign, a different codepoint from `en`', () => {
-    // U+FFE5 vs U+00A5 — visually near-identical, so written as escapes.
-    expect(currencySymbol('JPY', 'en')).toBe('\u00a5');
-    expect(currencySymbol('JPY', 'ja-JP')).toBe('\uffe5');
-    expect(currencySymbol('JPY', 'ja-JP')).not.toBe(currencySymbol('JPY', 'en'));
-  });
-
-  it('the cache is keyed on the PAIR — the first locale to ask must not answer for the rest', () => {
-    // The bug this pin exists for: copying `currencyFractionDigits`' code-only
-    // cache key would make these two calls return the same string, whichever
-    // ran first, for the rest of the process.
-    const first = currencySymbol('GBP', 'en-GB');
-    const second = currencySymbol('GBP', 'ar-KW');
-    expect(first).toBe('£');
-    expect(second).toBe('UK£');
-    // …and re-asking returns the cached value, not the other locale's.
-    expect(currencySymbol('GBP', 'en-GB')).toBe('£');
-  });
-});
-
-describe('currencySymbol() — neither a bad code nor a bad locale may escape as a throw', () => {
-  it('an invalid currency code falls back to the code as given', () => {
-    // `Intl` throws `RangeError: Invalid currency code` for these. The fallback
-    // is the code itself, which is both what the ternary produced and what
-    // `formatAmount`'s own bad-code branch renders beside it.
-    expect(currencySymbol('not-a-code', 'en')).toBe('not-a-code');
-    expect(currencySymbol('USDD', 'en')).toBe('USDD');
-  });
-
-  it('a malformed locale tag falls back to the code rather than crashing the widget', () => {
-    // `Intl` throws `RangeError: Incorrect locale information provided` for
-    // `en_US` (underscore) — the failure mode `currencyFractionDigits` dodged
-    // by dropping the locale entirely, which this helper cannot do.
-    expect(currencySymbol('USD', 'en_US')).toBe('USD');
-  });
-
-  it('the widget renders the code instead of throwing when the code is junk', () => {
-    const { container } = renderField({ currency: 'not-a-code' });
-    expect(adornment(container)).toBe('not-a-code');
-  });
-});

package/src/__tests__/DateCellRenderer.test.tsx

@@ -1,82 +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.
- */
-
-import { describe, it, expect } from 'vitest';
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { DateCellRenderer, formatRelativeDate } from '../index';
-
-function daysAgo(n: number): string {
-  const d = new Date();
-  d.setDate(d.getDate() - n);
-  return d.toISOString();
-}
-
-describe('formatRelativeDate', () => {
-  it('renders "Overdue Nd" only when dueLike is set', () => {
-    expect(formatRelativeDate(daysAgo(3), { dueLike: true })).toBe('Overdue 3d');
-  });
-
-  it('renders neutral "N days ago" for a past date that is not due-like', () => {
-    expect(formatRelativeDate(daysAgo(3))).toBe('3 days ago');
-    expect(formatRelativeDate(daysAgo(3), { dueLike: false })).toBe('3 days ago');
-  });
-
-  it('localizes the near-today window per locale (framework#3040)', () => {
-    expect(formatRelativeDate(daysAgo(0), { locale: 'zh-CN' })).toBe('今天');
-    expect(formatRelativeDate(daysAgo(-1), { locale: 'zh-CN' })).toBe('明天');
-    expect(formatRelativeDate(daysAgo(1), { locale: 'zh-CN' })).toBe('昨天');
-    expect(formatRelativeDate(daysAgo(-3), { locale: 'zh-CN' })).toBe('3天后');
-    expect(formatRelativeDate(daysAgo(3), { locale: 'zh-CN' })).toBe('3天前');
-    // English output is sentence-cased.
-    expect(formatRelativeDate(daysAgo(-1))).toBe('Tomorrow');
-    expect(formatRelativeDate(daysAgo(-3))).toBe('In 3 days');
-  });
-
-  it('resolves the overdue phrase through the i18n translate fn when provided', () => {
-    const t = (key: string, params?: Record<string, unknown>) =>
-      key === 'fields.relativeDate.overdue' ? `逾期 ${params?.count} 天` : key;
-    expect(formatRelativeDate(daysAgo(3), { dueLike: true, t })).toBe('逾期 3 天');
-    // A t() that misses (returns the key) keeps the English fallback.
-    expect(formatRelativeDate(daysAgo(3), { dueLike: true, t: (k) => k })).toBe('Overdue 3d');
-  });
-
-  it('degrades to English when the locale tag is invalid', () => {
-    expect(formatRelativeDate(daysAgo(3), { locale: 'not a locale' })).toBe('3 days ago');
-  });
-});
-
-/**
- * Nothing in this file mounts an `I18nProvider`, and that is load-bearing
- * rather than incidental (objectui#4468): these cases are the pin on
- * `useDisplayLocale()`'s LAST resort — the concrete `'en'` a renderer resolves
- * to when neither a tenant locale nor an active UI language exists. The
- * session-locale cases live in `date-locale-channel.test.tsx`; mounting a
- * provider here would leave react-i18next's global instance on that language
- * and quietly turn these into assertions about test ordering.
- */
-describe('DateCellRenderer', () => {
-  it('does not label a past start_date as "Overdue" (regression: field-role-agnostic formatter)', () => {
-    render(<DateCellRenderer value={daysAgo(6)} field={{ type: 'date', name: 'start_date' } as any} />);
-    expect(screen.getByText('6 days ago')).toBeInTheDocument();
-    expect(screen.queryByText(/Overdue/)).not.toBeInTheDocument();
-  });
-
-  it('labels a past due_date as "Overdue Nd" and colors it red', () => {
-    render(<DateCellRenderer value={daysAgo(6)} field={{ type: 'date', name: 'due_date' } as any} />);
-    const el = screen.getByText('Overdue 6d');
-    expect(el).toBeInTheDocument();
-    expect(el.className).toMatch(/text-red-600/);
-  });
-
-  it('respects an explicit dueLike:true override regardless of field name', () => {
-    render(<DateCellRenderer value={daysAgo(2)} field={{ type: 'date', name: 'end_date', dueLike: true } as any} />);
-    expect(screen.getByText('Overdue 2d')).toBeInTheDocument();
-  });
-});

package/src/__tests__/NumberCellRenderer.grouping.test.tsx

@@ -1,146 +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#4033 (source thread objectstack#5067) — the number cell renderer
- * used to build `new Intl.NumberFormat('en-US', …)` with grouping left at the
- * Intl default, so a four-digit YEAR stored as `Field.number({ scale: 0 })`
- * rendered as `2,026` in every locale and no field property could turn it off.
- *
- * Two independent pins live here:
- *
- *  1. **Ordinal grouping** — a declared `scale: 0` with no currency is an
- *     integer/ordinal surface, so grouping is suppressed. Interim default; a
- *     future spec-level presentation hint overrides it.
- *  2. **Locale** — grouping and decimal marks follow the ACTIVE display locale,
- *     never a hardcoded `en-US`.
- *
- * The controls are as load-bearing as the fixes: currency keeps grouping, a
- * non-zero `scale` keeps grouping, and an UNDECLARED scale keeps grouping
- * (`scale` is optional in the spec and absent means "decimals unknown", not
- * "integer" — see the renderer's own comment).
- */
-
-import { describe, it, expect } from 'vitest';
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { LocalizationProvider } from '@object-ui/i18n';
-import { NumberCellRenderer, CurrencyCellRenderer } from '../index';
-
-const renderNumber = (
-  value: unknown,
-  field: Record<string, unknown> = {},
-  locale?: string,
-) =>
-  render(
-    <LocalizationProvider value={{ locale }}>
-      <NumberCellRenderer value={value as any} field={{ type: 'number', ...field } as any} />
-    </LocalizationProvider>,
-  );
-
-const renderCurrency = (
-  value: unknown,
-  field: Record<string, unknown> = {},
-  locale?: string,
-) =>
-  render(
-    <LocalizationProvider value={{ locale }}>
-      <CurrencyCellRenderer value={value as any} field={{ type: 'currency', ...field } as any} />
-    </LocalizationProvider>,
-  );
-
-describe('NumberCellRenderer — ordinal grouping (objectui#4033)', () => {
-  // The card's exact fixture: `year: Field.number({ scale: 0, min: 1900 })`.
-  it.each(['en-US', 'de-DE', 'zh-CN', 'fr-FR'])(
-    'renders a scale-0 year ungrouped in %s',
-    (locale) => {
-      renderNumber(2026, { scale: 0 }, locale);
-      expect(screen.getByText('2026')).toBeInTheDocument();
-    },
-  );
-
-  it('suppresses grouping for every scale-0 magnitude, not just four digits', () => {
-    renderNumber(1234567, { scale: 0 }, 'en-US');
-    expect(screen.getByText('1234567')).toBeInTheDocument();
-  });
-
-  it('CONTROL: a non-zero scale keeps grouping', () => {
-    renderNumber(1234.5, { scale: 2 }, 'en-US');
-    expect(screen.getByText('1,234.50')).toBeInTheDocument();
-  });
-
-  it('CONTROL: an UNDECLARED scale keeps grouping (absent ≠ integer)', () => {
-    renderNumber(2026, {}, 'en-US');
-    expect(screen.getByText('2,026')).toBeInTheDocument();
-  });
-});
-
-describe('NumberCellRenderer — active display locale (objectui#4033)', () => {
-  it('uses the active locale decimal + grouping marks (de-DE)', () => {
-    renderNumber(1234.5, { scale: 1 }, 'de-DE');
-    expect(screen.getByText('1.234,5')).toBeInTheDocument();
-  });
-
-  it('uses the active locale decimal + grouping marks (en-US)', () => {
-    renderNumber(1234.5, { scale: 1 }, 'en-US');
-    expect(screen.getByText('1,234.5')).toBeInTheDocument();
-  });
-
-  it('uses the active locale decimal + grouping marks (fr-FR)', () => {
-    // fr-FR groups with U+202F (NARROW NO-BREAK SPACE) and uses "," for the
-    // decimal mark — nothing an en-US formatter can produce.
-    //
-    // Asserted against raw `textContent`, NOT `getByText`: testing-library's
-    // default normalizer collapses `\s+` (which includes U+202F) down to an
-    // ASCII space, so a `getByText` assertion here can only ever prove "some
-    // whitespace" and would pass on the wrong separator. The escape sequence is
-    // written out rather than pasted — a raw U+202F in source renders as
-    // nothing and is unfindable by grep.
-    const { container } = renderNumber(1234.5, { scale: 1 }, 'fr-FR');
-    expect(container.textContent).toBe('1 234,5');
-  });
-
-  it('does not take a malformed tenant locale down with it', () => {
-    // `locale` arrives from a server response (ADR-0053); a junk tag must
-    // degrade to the runtime default, never throw out of a grid cell.
-    renderNumber(1234.5, { scale: 1 }, 'not a locale');
-    expect(screen.getByText(/1.?234.5/)).toBeInTheDocument();
-  });
-});
-
-describe('CurrencyCellRenderer — CONTROL, unaffected by the ordinal default', () => {
-  it('keeps grouping and the currency symbol for a whole amount', () => {
-    renderCurrency(5000000, { currency: 'USD' }, 'en-US');
-    expect(screen.getByText('$5,000,000')).toBeInTheDocument();
-  });
-
-  it('keeps grouping and the fractional part when the amount is not whole', () => {
-    renderCurrency(1234.5, { currency: 'USD' }, 'en-US');
-    // This control pinned the CURRENT behaviour when #4033 landed — `$1,234.5`,
-    // NOT the `$1,234.50` that `formatCurrency`'s own doc comment promises
-    // ("Salesforce convention: `$1,234.50` keeps cents"). That was a real
-    // defect, deliberately filed rather than folded in (objectui#4332) and
-    // pinned here so its fix would flip a watched test instead of silently
-    // changing an unwatched surface. #4332 is now fixed, so the expectation
-    // moves to the promised form; grouping — this control's actual subject —
-    // is unchanged, which is still what #4033 needs it to prove.
-    expect(screen.getByText('$1,234.50')).toBeInTheDocument();
-  });
-
-  it('follows the active locale for currency too', () => {
-    renderCurrency(5000000, { currency: 'EUR' }, 'de-DE');
-    // de-DE: grouped with dots and a TRAILING symbol, vs en-US's leading one.
-    expect(screen.getByText(/^5\.000\.000\s*€$/)).toBeInTheDocument();
-  });
-
-  it('a currency field with NO resolved currency still groups (money, not an ordinal)', () => {
-    renderCurrency(5000000, {}, 'en-US');
-    expect(screen.getByText('5,000,000')).toBeInTheDocument();
-  });
-});

package/src/__tests__/NumberCellRenderer.test.tsx

@@ -1,60 +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.
- */
-
-import { describe, it, expect } from 'vitest';
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { NumberCellRenderer } from '../index';
-
-const renderNumber = (value: unknown, field: Record<string, unknown> = {}) =>
-  render(<NumberCellRenderer value={value as any} field={{ type: 'number', ...field } as any} />);
-
-describe('NumberCellRenderer', () => {
-  it('does not pad trailing zeros using `precision` (total digits, not decimal places)', () => {
-    // Regression: a decimal(10, 0) column exposes precision: 10, which used to
-    // render `1` as "1.0000000000".
-    renderNumber(1, { precision: 10 });
-    expect(screen.getByText('1')).toBeInTheDocument();
-  });
-
-  it('renders an integer without decimals when no scale is declared', () => {
-    renderNumber(16);
-    expect(screen.getByText('16')).toBeInTheDocument();
-  });
-
-  it('preserves the value\'s natural decimals when no scale is declared', () => {
-    renderNumber(16.5);
-    expect(screen.getByText('16.5')).toBeInTheDocument();
-  });
-
-  it('pads to a fixed number of decimals when `scale` is declared', () => {
-    renderNumber(16, { scale: 2 });
-    expect(screen.getByText('16.00')).toBeInTheDocument();
-  });
-
-  it('honours a scale of 3 with zero padding', () => {
-    renderNumber(3.14, { scale: 3 });
-    expect(screen.getByText('3.140')).toBeInTheDocument();
-  });
-
-  it('rounds to the declared scale', () => {
-    renderNumber(3.14159, { scale: 2 });
-    expect(screen.getByText('3.14')).toBeInTheDocument();
-  });
-
-  it('treats scale: 0 as an integer display', () => {
-    renderNumber(2, { scale: 0 });
-    expect(screen.getByText('2')).toBeInTheDocument();
-  });
-
-  it('renders an empty indicator for nullish values', () => {
-    const { container } = renderNumber(null);
-    expect(container.textContent).not.toContain('0');
-  });
-});