@object-ui/fields 17.3.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/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-value.test.ts

@@ -1,230 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  isFileIdToken,
-  fileIdOf,
-  readFileValue,
-  readFileValues,
-  isImageValue,
-  fileValueForSubmit,
-  uploadResultView,
-  withRecentUploads,
-} from './file-value';
-
-const uploadResult = (over: Record<string, unknown> = {}) => ({
-  url: 'https://app.example.com/api/v1/storage/files/file_a',
-  name: 'a.png',
-  size: 1024,
-  mimeType: 'image/png',
-  ...over,
-});
-
-describe('isFileIdToken', () => {
-  it.each(['file_a', 'abc123', '0e2f4c1a-9b7d-4e3f-8a1b-2c3d4e5f6a7b', 'A-_9'])(
-    'accepts the minted id %s',
-    (v) => expect(isFileIdToken(v)).toBe(true),
-  );
-
-  it.each([
-    'https://cdn.example.com/a.png',
-    '/api/v1/storage/files/file_a',
-    'data:image/png;base64,aGk=',
-    'blob:http://localhost/abc',
-    'a.png',
-    '',
-  ])('rejects the URL-shaped or dotted value %s', (v) => expect(isFileIdToken(v)).toBe(false));
-
-  it('rejects non-strings and over-long values', () => {
-    expect(isFileIdToken(null)).toBe(false);
-    expect(isFileIdToken(42)).toBe(false);
-    expect(isFileIdToken('a'.repeat(65))).toBe(false);
-  });
-});
-
-describe('fileIdOf', () => {
-  it('reads a bare reference', () => {
-    expect(fileIdOf('file_a')).toBe('file_a');
-  });
-
-  it('prefers file_id, then id', () => {
-    expect(fileIdOf({ file_id: 'legacy', id: 'expanded' })).toBe('legacy');
-    expect(fileIdOf({ id: 'expanded' })).toBe('expanded');
-  });
-
-  it('returns undefined when there is no id to read', () => {
-    expect(fileIdOf({ url: 'https://cdn.example.com/a.png', name: 'a.png' })).toBeUndefined();
-    expect(fileIdOf('https://cdn.example.com/a.png')).toBeUndefined();
-    expect(fileIdOf(null)).toBeUndefined();
-  });
-});
-
-describe('readFileValue', () => {
-  /**
-   * The casing split is the reason this module exists: the platform's expanded
-   * form is camelCase `mimeType`, the legacy inline blob is snake_case
-   * `mime_type`. A widget reading only one silently stops recognising images
-   * the moment the backend switches form.
-   */
-  it('reads the expanded form (camelCase mimeType)', () => {
-    const view = readFileValue({
-      id: 'file_a',
-      name: 'a.png',
-      size: 1024,
-      mimeType: 'image/png',
-      url: '/api/v1/storage/files/file_a',
-    });
-
-    expect(view).toMatchObject({
-      id: 'file_a',
-      name: 'a.png',
-      size: 1024,
-      mimeType: 'image/png',
-      url: '/api/v1/storage/files/file_a',
-    });
-    expect(isImageValue(view)).toBe(true);
-  });
-
-  it('reads the legacy inline blob (snake_case mime_type)', () => {
-    const view = readFileValue({
-      file_id: 'file_a',
-      name: 'a.png',
-      original_name: 'original.png',
-      size: 1024,
-      mime_type: 'image/png',
-      url: 'https://cdn.example.com/a.png',
-    });
-
-    expect(view).toMatchObject({ id: 'file_a', name: 'a.png', mimeType: 'image/png' });
-    expect(isImageValue(view)).toBe(true);
-  });
-
-  it('falls back to original_name when name is absent', () => {
-    expect(readFileValue({ original_name: 'orig.pdf' }).name).toBe('orig.pdf');
-  });
-
-  it('derives a name from the URL when the value carries none', () => {
-    expect(readFileValue({ url: 'https://cdn.example.com/docs/report%20v2.pdf' }).name).toBe(
-      'report v2.pdf',
-    );
-    expect(readFileValue('https://cdn.example.com/a.png').name).toBe('a.png');
-  });
-
-  it('resolves a bare reference to the stable download URL', () => {
-    const view = readFileValue('file_a', 'File');
-
-    // The read path may leave a value in its bare-reference form (seen on the
-    // edit-form data path); the stable endpoint is derivable from the id, so a
-    // thumbnail still renders instead of a broken `<img src="">`.
-    expect(view).toMatchObject({ id: 'file_a', name: 'File' });
-    expect(view.url).toBe('/api/v1/storage/files/file_a');
-  });
-
-  it('derives the URL of an object that carries an id but no url', () => {
-    const view = readFileValue({ id: 'file_b', name: 'b.png' });
-    expect(view.url).toBe('/api/v1/storage/files/file_b');
-  });
-
-  it('treats a URL string as a URL, never as a reference', () => {
-    const view = readFileValue('/api/v1/storage/files/file_a');
-    expect(view.id).toBeUndefined();
-    expect(view.url).toBe('/api/v1/storage/files/file_a');
-  });
-
-  it('uses the supplied fallback name so widgets stay localised', () => {
-    expect(readFileValue({}, '文件').name).toBe('文件');
-    expect(readFileValue(null, '文件').name).toBe('文件');
-  });
-
-  it('is not an image when the MIME type says otherwise or is missing', () => {
-    expect(isImageValue(readFileValue({ mimeType: 'application/pdf' }))).toBe(false);
-    expect(isImageValue(readFileValue({ name: 'a.png' }))).toBe(false);
-  });
-});
-
-describe('readFileValues', () => {
-  it('normalises single, array and empty values', () => {
-    expect(readFileValues(null)).toEqual([]);
-    expect(readFileValues([])).toEqual([]);
-    expect(readFileValues('file_a')).toHaveLength(1);
-    expect(readFileValues(['file_a', 'file_b'])).toHaveLength(2);
-  });
-
-  it('drops null entries inside an array', () => {
-    expect(readFileValues(['file_a', null, 'file_b'])).toHaveLength(2);
-  });
-
-  it('handles a mixed-form array during the transition', () => {
-    const views = readFileValues([
-      'file_a',
-      { id: 'file_b', name: 'b.png', mimeType: 'image/png' },
-      { name: 'c.png', mime_type: 'image/png', url: 'https://cdn.example.com/c.png' },
-    ]);
-
-    expect(views.map((v) => v.id)).toEqual(['file_a', 'file_b', undefined]);
-    expect(views.map(isImageValue)).toEqual([false, true, true]);
-  });
-});
-
-describe('fileValueForSubmit', () => {
-  it('submits the bare reference when the adapter surfaced a fileId', () => {
-    expect(fileValueForSubmit(uploadResult({ meta: { fileId: 'file_a' } }), 'orig.png')).toBe(
-      'file_a',
-    );
-  });
-
-  /**
-   * Back-compat: the object-URL fallback adapter, or a backend predating
-   * file-as-reference, surfaces no fileId. The same build must keep working
-   * there, so it submits the legacy blob unchanged.
-   */
-  it('falls back to the legacy inline blob when there is no fileId', () => {
-    expect(fileValueForSubmit(uploadResult(), 'orig.png')).toEqual({
-      name: 'a.png',
-      original_name: 'orig.png',
-      size: 1024,
-      mime_type: 'image/png',
-      url: 'https://app.example.com/api/v1/storage/files/file_a',
-    });
-  });
-
-  it('ignores a meta.fileId that is not id-shaped', () => {
-    const v = fileValueForSubmit(uploadResult({ meta: { fileId: 'https://evil.example/x' } }));
-    expect(typeof v).toBe('object');
-  });
-
-  it('round-trips through readFileValue in both modes', () => {
-    const asRef = fileValueForSubmit(uploadResult({ meta: { fileId: 'file_a' } }));
-    const asBlob = fileValueForSubmit(uploadResult(), 'orig.png');
-
-    expect(readFileValue(asRef).id).toBe('file_a');
-    expect(readFileValue(asBlob).mimeType).toBe('image/png');
-  });
-});
-
-describe('withRecentUploads', () => {
-  it('fills in display details for a bare reference just uploaded', () => {
-    const view = uploadResultView(uploadResult({ meta: { fileId: 'file_a' } }), 'orig.png');
-    const merged = withRecentUploads(readFileValues('file_a'), { file_a: view });
-
-    expect(merged[0]).toMatchObject({
-      id: 'file_a',
-      name: 'a.png',
-      mimeType: 'image/png',
-      url: 'https://app.example.com/api/v1/storage/files/file_a',
-    });
-    // The raw value stays the reference — display enrichment must not change
-    // what the field submits.
-    expect(merged[0].raw).toBe('file_a');
-  });
-
-  it('leaves a value the backend already expanded alone', () => {
-    const stale = uploadResultView(uploadResult({ name: 'stale.png', meta: { fileId: 'file_a' } }));
-    const expanded = readFileValues([{ id: 'file_a', name: 'fresh.png', url: '/u', mimeType: 'image/png' }]);
-
-    expect(withRecentUploads(expanded, { file_a: stale })[0].name).toBe('fresh.png');
-  });
-
-  it('is a no-op with nothing remembered', () => {
-    const views = readFileValues('file_a');
-    expect(withRecentUploads(views, {})).toBe(views);
-  });
-});