@object-ui/fields 17.5.0 → 17.6.0

package/src/widgets/__tests__/TextAreaField.mobileFullscreen.test.tsx

@@ -1,175 +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.
- */
-
-/**
- * `TextAreaField`'s fullscreen affordance has ONE source (objectui#3232).
- *
- * It used to be read from four places with a `??` chain — a `mobileFullscreen`
- * (camelCase) prop, `field.mobile_fullscreen`, a `mobile_fullscreen` prop, and
- * `schema.mobile_fullscreen`. Only the field-metadata flag was ever produced:
- * `ObjectForm` stamps it on long-text fields from
- * `ObjectFormSchema.mobile.fullscreenLongText`. The camelCase prop had no
- * producer anywhere in the repo, and the snake_case prop could not arrive
- * because `stripRegisteredFieldProps` (components/src/renderers/form/form.tsx)
- * removes it from what registered widgets are forwarded.
- *
- * So this file pins both halves of that convergence:
- *
- *  1. **The live path still works.** The metadata flag drives the affordance
- *     end to end — button, dialog, and the committed edit. Deleting the dead
- *     reads must not have cost the working behaviour, and this is the test
- *     that fails if a future refactor drops the real read too.
- *  2. **The retired prop spellings are gone**, at compile time (they are not
- *     on the closed `FieldWidgetComponentProps`, objectui#3221) and at runtime
- *     (a host that passes one anyway gets no affordance). Convergence means a
- *     misspelled flag is now inert and loud, not silently absorbed.
- *
- * Note the built-in (unregistered) `textarea` branch in `form.tsx` reads
- * `mobile_fullscreen || fullscreen` off the form-field props and renders its
- * own `FullscreenTextarea`. That is a separate, live path and is untouched
- * here — this file is about the registered `field:textarea` widget only.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen, fireEvent } from '@testing-library/react';
-import '@testing-library/jest-dom';
-
-import { TextAreaField } from '../TextAreaField';
-import type { FieldWidgetComponentProps } from '../types';
-import type { FieldMetadata } from '@object-ui/types';
-
-const fieldMeta = (extra: Record<string, unknown> = {}) =>
-  ({
-    name: 'description',
-    label: 'Description',
-    type: 'textarea',
-    ...extra,
-  }) as unknown as FieldMetadata;
-
-describe('TextAreaField mobile fullscreen — the metadata flag is the only source', () => {
-  it('renders the expand affordance when the field metadata sets mobile_fullscreen', () => {
-    render(
-      <TextAreaField
-        value="hello"
-        onChange={() => {}}
-        field={fieldMeta({ mobile_fullscreen: true })}
-      />,
-    );
-
-    expect(screen.getByTestId('textarea-fullscreen-toggle')).toBeInTheDocument();
-  });
-
-  it('opens the fullscreen dialog and commits the edited draft', () => {
-    const onChange = vi.fn();
-    render(
-      <TextAreaField
-        value="hello"
-        onChange={onChange}
-        field={fieldMeta({ mobile_fullscreen: true })}
-      />,
-    );
-
-    // Closed until the affordance is used — the dialog is not just mounted.
-    expect(screen.queryByTestId('textarea-fullscreen-dialog')).not.toBeInTheDocument();
-
-    fireEvent.click(screen.getByTestId('textarea-fullscreen-toggle'));
-    expect(screen.getByTestId('textarea-fullscreen-dialog')).toBeInTheDocument();
-
-    const dialogInput = screen.getByTestId('textarea-fullscreen-input');
-    expect(dialogInput).toHaveValue('hello');
-
-    fireEvent.change(dialogInput, { target: { value: 'hello from fullscreen' } });
-    // The draft is local until "Done" — the host is not notified per keystroke.
-    expect(onChange).not.toHaveBeenCalled();
-
-    fireEvent.click(screen.getByTestId('textarea-fullscreen-save'));
-    expect(onChange).toHaveBeenCalledWith('hello from fullscreen');
-  });
-
-  it('no longer reads the flag off a `schema` prop (objectui#3233)', () => {
-    // This used to be the second carrier: `SchemaRenderer` passed the authored
-    // node as `schema` and the widget resolved `field || schema`. v17 converged
-    // that at the producer — the registry adapter (`withFieldCarrier`) maps the
-    // SDUI node onto `field` before any widget sees it, so the widget has one
-    // read. A host that still passes `schema` is now inert AND loud: a compile
-    // error on the closed props type, and no affordance at runtime.
-    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
-    try {
-      const legacyHostProps = {
-        schema: fieldMeta({ mobile_fullscreen: true }),
-      } as unknown as Partial<FieldWidgetComponentProps<string>>;
-
-      render(
-        <TextAreaField
-          value=""
-          onChange={() => {}}
-          field={fieldMeta()}
-          {...legacyHostProps}
-        />,
-      );
-
-      expect(screen.queryByTestId('textarea-fullscreen-toggle')).not.toBeInTheDocument();
-    } finally {
-      consoleError.mockRestore();
-    }
-  });
-
-  it('renders no affordance when the metadata does not opt in', () => {
-    render(<TextAreaField value="hello" onChange={() => {}} field={fieldMeta()} />);
-
-    expect(screen.queryByTestId('textarea-fullscreen-toggle')).not.toBeInTheDocument();
-    expect(screen.queryByTestId('textarea-fullscreen-dialog')).not.toBeInTheDocument();
-  });
-});
-
-describe('TextAreaField mobile fullscreen — the retired prop spellings', () => {
-  it('does not declare them on the widget contract', () => {
-    const props = {} as FieldWidgetComponentProps<string>;
-
-    // Both were read by the widget and written by no host. With the closed
-    // props type (objectui#3221) they are now compile errors, so a future
-    // author reaches for the metadata flag instead of a silently ignored prop.
-    // @ts-expect-error `mobileFullscreen` is not part of this contract
-    void props.mobileFullscreen;
-    // @ts-expect-error `mobile_fullscreen` is a metadata key, not a widget prop
-    void props.mobile_fullscreen;
-    // …and the retired second METADATA carrier (objectui#3233). The flag has
-    // one source and that source now has one carrier.
-    // @ts-expect-error `schema` was retired from the widget contract in v17
-    void props.schema;
-
-    expect(true).toBe(true);
-  });
-
-  it('ignores them at runtime when a host passes them anyway', () => {
-    // Untyped hosts (plain JS, `as any` spreads) can still get these onto the
-    // element. They must not resurrect the affordance: the metadata flag is
-    // the contract. Unknown props land on the DOM spread, so React's unknown
-    // -attribute warnings are expected noise here and are suppressed.
-    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
-    try {
-      const hostProps = {
-        mobileFullscreen: true,
-        mobile_fullscreen: true,
-      } as unknown as Partial<FieldWidgetComponentProps<string>>;
-
-      render(
-        <TextAreaField
-          value="hello"
-          onChange={() => {}}
-          field={fieldMeta()}
-          {...hostProps}
-        />,
-      );
-
-      expect(screen.queryByTestId('textarea-fullscreen-toggle')).not.toBeInTheDocument();
-    } finally {
-      consoleError.mockRestore();
-    }
-  });
-});

package/src/widgets/_cell-renderer-bridge.ts

@@ -1,19 +0,0 @@
-/**
- * Internal bridge module to break the circular dependency between
- * index.tsx (defines getCellRenderer) and RecordPickerDialog.tsx
- * (consumes it).
- *
- * index.tsx registers the resolver via setCellRendererResolver().
- * LookupField reads it via getCellRendererResolver() to pass as a prop.
- */
-import type { CellRendererResolver } from './RecordPickerDialog';
-
-let _resolver: CellRendererResolver | undefined;
-
-export function setCellRendererResolver(resolver: CellRendererResolver): void {
-  _resolver = resolver;
-}
-
-export function getCellRendererResolver(): CellRendererResolver | undefined {
-  return _resolver;
-}

package/src/widgets/address-format.ts

@@ -1,120 +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 address value shape, and the ONE formatting rule every address surface
- * renders it with.
- *
- * This module exists because the rule had exactly one implementation and only
- * one consumer could reach it (objectui#4037). `AddressField`'s readonly branch
- * collapsed a stored address to a formatted line, while the display (read)
- * registry the detail page uses mapped `address` straight to `JsonCellRenderer`
- * — so the same stored value rendered as `Street, City, State ZIP, Country` in
- * a readonly form and as `{"street":"…","city":"…"}` on the detail page.
- *
- * The fix keeps ONE definition rather than a second copy next to the renderer:
- * a duplicated rule is a rule that drifts, and two spellings of the same
- * address on two surfaces of one app is the very failure the issue reports.
- *
- * Deliberately pure — no React, no component imports — so the eager
- * `@object-ui/fields` barrel can use it for cell rendering without pulling
- * `AddressField` (and its inputs) out of the lazily-loaded widget chunk.
- */
-
-import type { AddressValue } from '@objectstack/spec/data';
-
-/**
- * Address data structure — `z.input` of `@objectstack/spec`'s
- * `AddressValueSchema`, which is what the platform stores and what
- * `/api/v1/data/**` serves back.
- *
- * The postal code is spelled `postalCode` (objectstack#5143). `AddressField`
- * used to read and write `zipCode`, a key that appears nowhere in the spec, so
- * the stored postal code never reached the input — and whatever the user then
- * typed into that apparently-empty box was written under a key
- * `AddressValueSchema` strips: lost outright on a new record, and on an
- * existing one silently discarded while the stale stored value survived. (A
- * postal code nobody touched did survive an unrelated edit, because the write
- * spread the whole stored object through; the issue's account of that half is
- * corrected in `AddressField.postalCode.test.tsx`.) One name, on both sides:
- * the contract's.
- *
- * IMPORTED rather than declared since objectui#4167. rc.6 publishes
- * `AddressValue` under this exact name, and the local copy — whose own comment
- * already claimed to be "the part names of `AddressSchema`" — declared five of
- * the seven parts. `countryCode` and `formatted` were missing, which is
- * objectstack#4115's failure class precisely: a canonical CLAIM over a narrower
- * shape, believed by the next reader. The claim is now the code.
- *
- * `AddressField` still renders five inputs and {@link formatAddress} still
- * composes five parts, and that is a deliberate split rather than an omission:
- * `formatted` is a derived one-line rendering of the parts (what this module
- * computes) and `countryCode` is the ISO pair for `country`, neither of which a
- * human types into a part box. Binding the type does not publish them as
- * inputs — it stops the type from asserting the platform cannot store them, and
- * it means a write from the widget no longer looks type-clean while dropping a
- * key the contract carries: the `{ ...address }` spread in `handleFieldChange`
- * preserves both, and now says so.
- *
- * The declaration moved here (objectui#4037) so the display cell renderer and
- * the widget share one definition; the SOURCE of that definition is the spec.
- */
-export type { AddressValue };
-
-/**
- * The shape written by builds up to and including 17.0.0-rc.1, whose postal
- * code landed under `zipCode` (objectstack#5143). Read-time compatibility ONLY,
- * and deliberately not part of {@link AddressValue}: authoring code must not be
- * able to spell `zipCode`, and nothing here ever writes it back — the first
- * edit of any part normalizes the record onto `postalCode` (see
- * `AddressField`'s `handleFieldChange`). This is not a producer alias to be
- * honoured forever; it exists to carry data THIS widget mis-wrote, and can go
- * once no such data remains.
- */
-export type LegacyAddressValue = AddressValue & { zipCode?: string };
-
-/** Postal code of a stored address, preferring the canonical key. */
-export function readPostalCode(addr: AddressValue): string | undefined {
-  return addr.postalCode ?? (addr as LegacyAddressValue).zipCode;
-}
-
-/**
- * One address part, normalized for joining: absent, non-string and
- * whitespace-only parts all collapse to `''` so the caller's `filter(Boolean)`
- * drops them. This is what keeps a partial address free of dangling separators
- * and of the string `undefined`.
- */
-function part(value: unknown): string {
-  if (value == null) return '';
-  return String(value).trim();
-}
-
-/**
- * Formats a stored address as a single line: `Street, City, State ZIP, Country`.
- *
- * Ordering and separators are NOT invented here — they are the rule
- * `AddressField` already applied in its readonly branch, and the sub-field set
- * its inputs expose (street / city / state / postalCode / country). Missing
- * parts are dropped rather than spaced over, so a street-only address is
- * `"中策路 1 号"` and never `", , ,"`.
- *
- * Returns `''` when no part is usable — callers decide what an empty address
- * looks like (an `EmptyValue` placeholder for the cell renderer), and a value
- * carrying no recognized part at all is NOT silently blanked: see
- * `AddressCellRenderer`, which falls back to JSON so unknown data stays visible.
- */
-export function formatAddress(addr: AddressValue): string {
-  // State and postal code share one comma-delimited group, space-separated
-  // inside it ("CA 94102"); either one alone occupies the group by itself.
-  const stateAndPostal = [part(addr.state), part(readPostalCode(addr))]
-    .filter(Boolean)
-    .join(' ');
-  return [part(addr.street), part(addr.city), stateAndPostal, part(addr.country)]
-    .filter(Boolean)
-    .join(', ');
-}

package/src/widgets/deriveLookupColumns.test.ts

@@ -1,112 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { deriveLookupColumns } from './deriveLookupColumns';
-
-const accountSchema = {
-  name: 'showcase_account',
-  fields: {
-    created_at: { type: 'datetime', label: 'Created At' },
-    updated_at: { type: 'datetime', label: 'Last Modified At' },
-    name: { type: 'text', label: 'Account Name' },
-    industry: { type: 'select', label: 'Industry' },
-    annual_revenue: { type: 'currency', label: 'Annual Revenue' },
-    website: { type: 'url', label: 'Website' },
-    hq: { type: 'location', label: 'Headquarters' },
-    status: { type: 'select', label: 'Lifecycle' },
-    support_config: { type: 'json', label: 'Support Config' },
-    owner_id: { type: 'lookup', label: 'Owner' },
-    organization_id: { type: 'lookup', label: 'Organization' },
-  },
-};
-
-describe('deriveLookupColumns', () => {
-  it('returns [] when no schema/fields are available', () => {
-    expect(deriveLookupColumns(undefined, { displayField: 'name' })).toEqual([]);
-    expect(deriveLookupColumns({ fields: {} }, { displayField: 'name' })).toEqual([]);
-  });
-
-  it('leads with the display field and adds business fields in declaration order', () => {
-    const cols = deriveLookupColumns(accountSchema, { displayField: 'name', max: 4 });
-    expect(cols.map((c) => c.field)).toEqual(['name', 'industry', 'annual_revenue', 'website']);
-  });
-
-  it('carries field label and type onto each column for type-aware rendering', () => {
-    const cols = deriveLookupColumns(accountSchema, { displayField: 'name', max: 3 });
-    expect(cols[0]).toEqual({ field: 'name', label: 'Account Name', type: 'text' });
-    expect(cols[2]).toEqual({ field: 'annual_revenue', label: 'Annual Revenue', type: 'currency' });
-  });
-
-  it('skips system/audit fields and heavy non-tabular types', () => {
-    const cols = deriveLookupColumns(accountSchema, { displayField: 'name', max: 10 });
-    const names = cols.map((c) => c.field);
-    expect(names).not.toContain('created_at');
-    expect(names).not.toContain('updated_at');
-    expect(names).not.toContain('owner_id');
-    expect(names).not.toContain('organization_id');
-    expect(names).not.toContain('support_config'); // json
-    expect(names).not.toContain('hq'); // location
-  });
-
-  it('respects the max column cap', () => {
-    expect(deriveLookupColumns(accountSchema, { displayField: 'name', max: 2 })).toHaveLength(2);
-  });
-
-  it('skips fields flagged `system: true` even when the name is not a known audit column', () => {
-    const schema = {
-      fields: {
-        name: { type: 'text', label: 'Name' },
-        // Non-canonical name, but stamped system by the framework — must be skipped.
-        custom_ref: { type: 'lookup', label: 'Custom Ref', system: true } as any,
-        code: { type: 'text', label: 'Code' },
-      },
-    };
-    const cols = deriveLookupColumns(schema, { displayField: 'name', max: 10 });
-    expect(cols.map((c) => c.field)).toEqual(['name', 'code']);
-  });
-
-  it('honours an object-level displayFields list, with the display field first', () => {
-    const schema = {
-      fields: {
-        name: { type: 'text', label: 'Name' },
-        code: { type: 'text', label: 'Code' },
-        region: { type: 'select', label: 'Region' },
-      },
-      displayFields: ['code', 'region'],
-    };
-    const cols = deriveLookupColumns(schema, { displayField: 'name', max: 4 });
-    expect(cols.map((c) => c.field)).toEqual(['name', 'code', 'region']);
-  });
-
-  it('does not duplicate the display field when it also appears in displayFields', () => {
-    const schema = {
-      fields: { name: { type: 'text' }, region: { type: 'select' } },
-      displayFields: ['name', 'region'],
-    };
-    const cols = deriveLookupColumns(schema, { displayField: 'name' });
-    expect(cols.map((c) => c.field)).toEqual(['name', 'region']);
-  });
-
-  it('prefers ADR-0085 highlightFields over the declaration-order walk', () => {
-    const schema = {
-      fields: {
-        name: { type: 'text', label: 'Name' },
-        code: { type: 'text', label: 'Code' },
-        region: { type: 'select', label: 'Region' },
-        notes: { type: 'text', label: 'Notes' },
-      },
-      highlightFields: ['region', 'code'],
-    };
-    const cols = deriveLookupColumns(schema, { displayField: 'name', max: 4 });
-    // Display field leads, then highlightFields in order — not the raw field walk.
-    expect(cols.map((c) => c.field)).toEqual(['name', 'region', 'code']);
-  });
-
-  it('lets highlightFields win over legacy displayFields when both are present', () => {
-    const schema = {
-      fields: { name: { type: 'text' }, code: { type: 'text' }, region: { type: 'select' } },
-      highlightFields: ['region'],
-      displayFields: ['code'],
-    };
-    const cols = deriveLookupColumns(schema, { displayField: 'name' });
-    expect(cols.map((c) => c.field)).toEqual(['name', 'region']);
-  });
-});

package/src/widgets/deriveLookupColumns.ts

@@ -1,108 +0,0 @@
-import type { LookupColumnDef } from '@object-ui/types';
-import { isSystemManagedField } from '@object-ui/types';
-
-/**
- * Field types that don't render usefully as a compact picker column (large
- * blobs, media, geometry, free-form text). Kept out of auto-derived columns.
- */
-const NON_TABULAR_TYPES = new Set<string>([
-  'json', 'object', 'grid', 'html', 'richtext', 'markdown', 'code',
-  'image', 'file', 'avatar', 'vector', 'location', 'geometry',
-  'textarea', 'secret', 'password', 'encrypted',
-]);
-
-export interface DeriveColumnsOptions {
-  /** Primary display field — always the leading column. */
-  displayField: string;
-  /** Maximum number of columns to derive (including the display field). */
-  max?: number;
-}
-
-interface ObjectSchemaLike {
-  fields?: Record<string, { type?: string; label?: string; hidden?: boolean; system?: boolean }>;
-  /**
-   * ADR-0085 semantic role: the object's most important fields. The single
-   * source for "how to list this object" — shared with the detail-page related
-   * list — so a lookup picker and a related list of the same object agree on
-   * columns with zero per-surface config.
-   */
-  highlightFields?: unknown;
-  /** Object-level "fields to display in search result cards" (legacy spec metadata). */
-  displayFields?: unknown;
-}
-
-function dedupe(names: string[]): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const n of names) {
-    if (!seen.has(n)) {
-      seen.add(n);
-      out.push(n);
-    }
-  }
-  return out;
-}
-
-/**
- * Derive sensible Record Picker columns from a referenced object's schema when
- * a lookup field declares no explicit `lookup_columns`.
- *
- * Priority:
- *   1. The referenced object's ADR-0085 `highlightFields` — the canonical
- *      "how to list this object" set, shared with the detail-page related list.
- *   2. Else the object's legacy `displayFields` search-card shape.
- *   3. Otherwise the display field plus the next few business fields in
- *      declaration order, skipping system/audit fields and heavy non-tabular
- *      types.
- *
- * The result gives every lookup a multi-column, disambiguating picker with zero
- * field-level configuration. Column `type` is carried through so the picker can
- * render currency / select / date cells via the shared cell renderer.
- *
- * Returns an empty array when no usable schema is available, in which case the
- * caller should fall back to the single display-field column.
- */
-export function deriveLookupColumns(
-  objectSchema: ObjectSchemaLike | null | undefined,
-  { displayField, max = 4 }: DeriveColumnsOptions,
-): LookupColumnDef[] {
-  const fields = objectSchema?.fields ?? {};
-  const fieldDef = (name: string) => fields[name] ?? {};
-  const toCol = (name: string): LookupColumnDef => {
-    const f = fieldDef(name);
-    return { field: name, ...(f.label ? { label: f.label } : {}), ...(f.type ? { type: f.type } : {}) };
-  };
-
-  if (Object.keys(fields).length === 0) return [];
-
-  // 1 & 2. Honour a declared column list — `highlightFields` (ADR-0085
-  // canonical, shared with the related list) first, then the legacy
-  // `displayFields` search-card list. The display field always leads.
-  const fromDeclaredList = (list: unknown): LookupColumnDef[] | null => {
-    if (!Array.isArray(list) || list.length === 0) return null;
-    const names = (list as unknown[]).filter(
-      (n): n is string => typeof n === 'string' && n.length > 0,
-    );
-    const ordered = dedupe([displayField, ...names.filter((n) => n !== displayField)]);
-    return ordered.slice(0, max).map(toCol);
-  };
-  const fromHighlights = fromDeclaredList(objectSchema?.highlightFields);
-  if (fromHighlights) return fromHighlights;
-  const fromDisplay = fromDeclaredList(objectSchema?.displayFields);
-  if (fromDisplay) return fromDisplay;
-
-  // 3. Derive from the field set in declaration order.
-  const candidates = Object.keys(fields).filter((name) => {
-    if (name === displayField) return false;
-    const f = fieldDef(name);
-    // Skip framework-managed system/audit/ownership columns (incl. owner_id) —
-    // they carry no disambiguating value in a record picker.
-    if (isSystemManagedField(name, f)) return false;
-    if (f.hidden) return false;
-    if (f.type && NON_TABULAR_TYPES.has(f.type)) return false;
-    return true;
-  });
-
-  const ordered = dedupe([displayField, ...candidates]);
-  return ordered.slice(0, max).map(toCol);
-}

package/src/widgets/file-size-guard.ts

@@ -1,55 +0,0 @@
-/**
- * The client-side `maxSize` guard shared by the file and image widgets
- * (objectui#4141).
- *
- * Why this is shared rather than mirrored per widget: the guard is the only
- * thing standing between a declared `maxSize` and a real `presigned → PUT →
- * complete` round trip, and `paramToField` copies `maxSize` onto the field
- * config for **every** param type regardless of which widget ends up rendering
- * it. So a widget that re-derives the check drifts silently — the image param
- * shipped receiving the constraint and never reading it, while the file param
- * rejected the identical pick, and nothing failed until QA drove the two side by
- * side. One exported function makes the difference visible: a widget either
- * calls it or conspicuously does not.
- *
- * Both widgets deliberately share the `fields.file.exceedsMaxSize` key too. The
- * sentence names a file and a limit and says nothing file-widget-specific, it is
- * already translated in all 11 built-in locales, and a parallel `fields.image.*`
- * twin would be the same sentence maintained twice — drifting the moment one
- * translator rewords one of them.
- */
-
-/**
- * Minimal shape of the i18next `t` this module needs, matching the established
- * `TranslateFn` pattern in `app-shell/src/providers/writeWarningToast`.
- */
-export type TranslateFn = (key: string, options?: Record<string, unknown>) => string;
-
-/** Divisor for rendering a byte limit as MB, matching the widgets' size display. */
-const BYTES_PER_MB = 1024 * 1024;
-
-/**
- * The rejection message for a pick that exceeds `maxSize`, or `null` when the
- * pick is within the limit — so a caller reads it as `if (err) reject`.
- *
- * A falsy `maxSize` (undeclared, or an explicit `0`) means **unrestricted**,
- * preserving the `if (maxSize && …)` semantics the file widget has always
- * applied: an undeclared limit must never turn into a 0-byte one.
- *
- * Takes `name` and `size` separately instead of a `File` because the image
- * widget's crop path validates a re-encoded `Blob`, which carries no name of its
- * own — that name comes from the cropper's output.
- */
-export function maxSizeError(
-  t: TranslateFn,
-  pick: { name: string; size: number },
-  maxSize: number | undefined,
-): string | null {
-  if (!maxSize || pick.size <= maxSize) return null;
-  const maxMB = (maxSize / BYTES_PER_MB).toFixed(1);
-  return t('fields.file.exceedsMaxSize', {
-    defaultValue: `"${pick.name}" exceeds max size (${maxMB} MB)`,
-    name: pick.name,
-    max: maxMB,
-  });
-}