@object-ui/fields 16.1.0 → 17.1.0

package/src/widgets/RecipientPickerField.tsx

@@ -2,6 +2,7 @@ import React from 'react';
 import { Combobox, EmptyValue, cn } from '@object-ui/components';
 import { SchemaRendererContext } from '@object-ui/react';
 import type { FieldWidgetProps } from './types';
+import { useFieldTranslation } from './useFieldTranslation';
 
 /**
  * RecipientPickerField — dependent record picker for a polymorphic recipient
@@ -31,14 +32,20 @@ interface RecipientMapping {
   storeField: 'id' | 'name';
   /** Candidate display-label fields, in preference order. */
   labelFields: string[];
+  /**
+   * i18n key for the "choose one" placeholder. Keyed per type rather than
+   * interpolating the enum value into an English sentence — "Select a
+   * business unit" and "选择业务单元" share no structure (objectstack#3821).
+   */
+  placeholderKey: string;
 }
 
 const TYPE_TO_OBJECT: Record<string, RecipientMapping> = {
-  user: { object: 'sys_user', storeField: 'id', labelFields: ['name', 'full_name', 'email'] },
-  team: { object: 'sys_team', storeField: 'id', labelFields: ['name', 'label'] },
-  business_unit: { object: 'sys_business_unit', storeField: 'id', labelFields: ['name', 'label'] },
-  unit_and_subordinates: { object: 'sys_business_unit', storeField: 'id', labelFields: ['name', 'label'] },
-  position: { object: 'sys_position', storeField: 'name', labelFields: ['label', 'name'] },
+  user: { object: 'sys_user', storeField: 'id', labelFields: ['name', 'full_name', 'email'], placeholderKey: 'fields.recipient.selectUser' },
+  team: { object: 'sys_team', storeField: 'id', labelFields: ['name', 'label'], placeholderKey: 'fields.recipient.selectTeam' },
+  business_unit: { object: 'sys_business_unit', storeField: 'id', labelFields: ['name', 'label'], placeholderKey: 'fields.recipient.selectBusinessUnit' },
+  unit_and_subordinates: { object: 'sys_business_unit', storeField: 'id', labelFields: ['name', 'label'], placeholderKey: 'fields.recipient.selectUnitAndSubordinates' },
+  position: { object: 'sys_position', storeField: 'name', labelFields: ['label', 'name'], placeholderKey: 'fields.recipient.selectPosition' },
 };
 
 export function RecipientPickerField({
@@ -49,6 +56,7 @@ export function RecipientPickerField({
   ...props
 }: FieldWidgetProps<string>) {
   const ctx = React.useContext(SchemaRendererContext);
+  const { t } = useFieldTranslation();
   const dataSource: any = (props as any).dataSource ?? (ctx as any)?.dataSource ?? null;
   const disabled = (props as any).disabled as boolean | undefined;
   const dependentValues: Record<string, any> = (props as any).dependentValues ?? {};
@@ -57,12 +65,18 @@ export function RecipientPickerField({
 
   const [records, setRecords] = React.useState<any[] | null>(null);
 
-  // Reset the stored recipient when the type changes AFTER mount (an id for a
-  // user is not a valid team/business-unit id). The ref starts null so the
-  // initial render of an existing rule never clears its value.
-  const prevType = React.useRef<string | null>(null);
+  // Reset the stored recipient when the admin PICKS a different type (an id for
+  // a user is not a valid team/business-unit id).
+  //
+  // "Different type" means one non-empty type replacing another. The empty
+  // string is not a type — it is the edit form before the record has hydrated,
+  // and treating `'' → 'user'` as a change wiped the saved recipient the moment
+  // an existing rule was opened for editing (objectstack#3821): the picker went
+  // blank, and saving persisted the blank. Only a non-empty predecessor can
+  // invalidate the stored id.
+  const prevType = React.useRef<string>('');
   React.useEffect(() => {
-    if (prevType.current !== null && prevType.current !== recipientType && value) {
+    if (prevType.current && recipientType && prevType.current !== recipientType && value) {
       onChange('' as any);
     }
     prevType.current = recipientType;
@@ -75,7 +89,11 @@ export function RecipientPickerField({
     let cancelled = false;
     (async () => {
       try {
-        const res = await dataSource.find(mapping.object, { $top: 500, $orderby: 'name asc' });
+        // Object form, not the 'name asc' clause string: the clause string is
+        // supported again (objectstack#3821 fixed ApiDataSource walking it
+        // character by character), but the structured form can't regress that
+        // way for any data source.
+        const res = await dataSource.find(mapping.object, { $top: 500, $orderby: { name: 'asc' } });
         const list: any[] = res?.data ?? res?.records ?? (Array.isArray(res) ? res : []);
         if (!cancelled) setRecords(Array.isArray(list) ? list : []);
       } catch {
@@ -105,7 +123,7 @@ export function RecipientPickerField({
   if (!recipientType) {
     return (
       <p className={cn('text-sm text-muted-foreground', className)}>
-        Select a recipient type first.
+        {t('fields.recipient.selectTypeFirst')}
       </p>
     );
   }
@@ -137,12 +155,14 @@ export function RecipientPickerField({
       value={value ?? ''}
       onValueChange={(v) => onChange(v as any)}
       placeholder={
-        records === null ? 'Loading…' : `Select a ${recipientType.replace(/_/g, ' ')}`
+        records === null
+          ? t('fields.recipient.loading')
+          : t(mapping.placeholderKey ?? 'fields.recipient.select')
       }
-      searchPlaceholder="Search…"
-      emptyText={records === null ? 'Loading…' : 'No matches'}
+      searchPlaceholder={t('fields.recipient.search')}
+      emptyText={records === null ? t('fields.recipient.loading') : t('fields.recipient.empty')}
       disabled={disabled}
-      className={className}
+      className={cn('w-full', className)}
     />
   );
 }

package/src/widgets/TextAreaField.tsx

@@ -36,7 +36,10 @@ export function TextAreaField({ value, onChange, field, readonly, errorMessage,
 
   const textareaField = (field || (props as any).schema) as any;
   const rows = textareaField?.rows || 4;
-  const maxLength = textareaField?.max_length;
+  // Spec FieldSchema declares camelCase `maxLength`; `max_length` is the legacy
+  // objectui spelling. Dual-read (framework#1878 §3 recheck) — without this a
+  // spec-authored maxLength gave neither the textarea cap nor the counter.
+  const maxLength = textareaField?.maxLength ?? textareaField?.max_length;
   // Mobile fullscreen flag may arrive on the field metadata, on the form-field
   // schema (when called via the form renderer where `field` is the ObjectQL
   // metadata sub-object), or as an explicit widget prop.

package/src/widgets/__tests__/FilterConditionField.matchAll.test.ts

@@ -0,0 +1,66 @@
+/**
+ * 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.
+ */
+
+/**
+ * Empty-criteria guard for the sharing-rule criteria builder
+ * (objectstack#3896).
+ *
+ * This widget used to tell an admin that an empty criteria meant "All
+ * records" — the most dangerous thing it could say, because it was describing
+ * a bug as a feature. A sharing rule with no predicate was stored as
+ * `criteria_json: null` and then evaluated as `find(object, { filter: {} })`,
+ * i.e. every record of the object granted to the recipient. `SharingRuleSchema`
+ * had always forbidden that shape ("never seeded as a permissive match-all",
+ * ADR-0049); the REST and data-API entries just never checked.
+ *
+ * The server now refuses to save such a rule and shares nothing for one
+ * already stored. These tests pin the client-side mirror of that predicate, so
+ * the widget warns while the admin is still looking at the empty builder
+ * rather than after a rejected save.
+ */
+import { describe, it, expect } from 'vitest';
+import { isMatchAllCriteria } from '../FilterConditionField';
+
+describe('isMatchAllCriteria — shapes that would share every record', () => {
+  it('flags the empty and vacuous shapes', () => {
+    for (const shape of [
+      undefined,
+      null,
+      {},           // what a blank builder / blank textarea parses to
+      [],
+      true,
+      42,
+      { $and: [] },
+      { $or: [] },
+      { $and: [{}] },
+      { $or: [{ stage: 'won' }, {}] }, // one unconstrained branch opens the OR
+    ]) {
+      expect(isMatchAllCriteria(shape), `${JSON.stringify(shape) ?? String(shape)}`).toBe(true);
+    }
+  });
+
+  it('passes anything that actually narrows the result set', () => {
+    for (const shape of [
+      { stage: 'won' },
+      { amount: { $gte: 100000 } },
+      [{ stage: 'won' }],
+      { $and: [{ stage: 'won' }] },
+      { $or: [{ a: 1 }, { b: 2 }] },
+      { health: 'red', budget: { $gt: 1 } },
+    ]) {
+      expect(isMatchAllCriteria(shape), JSON.stringify(shape)).toBe(false);
+    }
+  });
+
+  it('agrees with the server on the reported case: a rule saved with no criteria', () => {
+    // The builder emits '' for an empty group, which the widget parses to {}.
+    expect(isMatchAllCriteria({})).toBe(true);
+    // …and one real condition is enough to clear the gate.
+    expect(isMatchAllCriteria({ health: 'red' })).toBe(false);
+  });
+});

package/src/widgets/__tests__/FilterConditionField.operators.test.ts

@@ -0,0 +1,142 @@
+/**
+ * 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.
+ */
+
+/**
+ * Operator spelling guard for the sharing-rule criteria builder (#2901).
+ *
+ * `condToMongo` emitted `$ncontains` — a token that appears nowhere in
+ * `@objectstack/spec` and that objectui's own `convertFiltersToAST` throws on,
+ * naming the correct spelling (`$notContains`) in its error message. So every
+ * "does not contain" rule authored here validated in the UI and was then
+ * rejected downstream. Nothing caught it because the builder's operator list is
+ * hand-written and never compared against the spec vocabulary.
+ *
+ * These tests pin the emitted spellings against `FieldOperatorsSchema`'s keys
+ * and pin the round-trip, including the pre-fix spelling that stored criteria
+ * still carry.
+ */
+import { describe, it, expect } from 'vitest';
+import { FieldOperatorsSchema } from '@objectstack/spec/data';
+import { condToMongo, kvToCondition } from '../FilterConditionField';
+
+/**
+ * The `$`-prefixed operator keys of the spec's `FieldOperatorsSchema` —
+ * DERIVED from the schema (#2942), so a 16th operator landing in the spec
+ * fails the reachability test below instead of drifting unnoticed.
+ */
+const SPEC_OPERATORS = new Set(
+  Object.keys((FieldOperatorsSchema as unknown as { shape?: Record<string, unknown> }).shape ?? {}),
+);
+
+const noTypes = () => undefined;
+
+/** Pull the operator keys out of a `{ field: { $op: v } }` fragment. */
+function operatorsOf(frag: Record<string, any> | null): string[] {
+  if (!frag) return [];
+  return Object.values(frag).flatMap((v) =>
+    v !== null && typeof v === 'object' && !Array.isArray(v) ? Object.keys(v) : [],
+  );
+}
+
+describe('condToMongo emits only spec operator spellings', () => {
+  const builderOperators = [
+    'equals', 'notEquals', 'contains', 'notContains', 'isEmpty', 'isNotEmpty',
+    'greaterThan', 'lessThan', 'greaterOrEqual', 'lessOrEqual', 'in', 'notIn',
+    'before', 'after',
+    'startsWith', 'endsWith', 'isNull', 'isNotNull', 'exists', 'notExists',
+  ];
+
+  it.each(builderOperators)('%s emits a spec-defined operator', (operator) => {
+    const frag = condToMongo(
+      { id: 'c1', field: 'name', operator, value: operator === 'in' || operator === 'notIn' ? ['a'] : 'a' } as any,
+      noTypes,
+    );
+    const unknown = operatorsOf(frag).filter((op) => !SPEC_OPERATORS.has(op));
+    expect(unknown, `${operator} emits an operator @objectstack/spec does not define`).toEqual([]);
+  });
+
+  it('notContains emits $notContains, not the pre-fix $ncontains', () => {
+    const frag = condToMongo({ id: 'c1', field: 'name', operator: 'notContains', value: 'x' } as any, noTypes);
+    expect(frag).toEqual({ name: { $notContains: 'x' } });
+  });
+
+  it('between emits a range the spec defines', () => {
+    const frag = condToMongo({ id: 'c1', field: 'age', operator: 'between', value: [1, 5] } as any, noTypes);
+    expect(operatorsOf(frag).every((op) => SPEC_OPERATORS.has(op))).toBe(true);
+  });
+});
+
+describe('every spec field operator is reachable from the builder (#2942)', () => {
+  it('reads a non-empty operator vocabulary from the spec', () => {
+    expect([...SPEC_OPERATORS].length, 'could not read FieldOperatorsSchema.shape').toBeGreaterThan(0);
+  });
+
+  it('some builder operator emits every spec $-token', () => {
+    const builderOperators = [
+      'equals', 'notEquals', 'contains', 'notContains', 'isEmpty', 'isNotEmpty',
+      'greaterThan', 'lessThan', 'greaterOrEqual', 'lessOrEqual', 'in', 'notIn',
+      'before', 'after', 'between',
+      'startsWith', 'endsWith', 'isNull', 'isNotNull', 'exists', 'notExists',
+    ];
+    const emitted = new Set<string>();
+    for (const operator of builderOperators) {
+      const value = operator === 'in' || operator === 'notIn' ? ['a'] : operator === 'between' ? [1, 5] : 'a';
+      const frag = condToMongo({ id: 'c1', field: 'f', operator, value } as any, noTypes);
+      for (const op of operatorsOf(frag)) emitted.add(op);
+    }
+    // `$eq` is the spec's IMPLICIT equality form — `equals` deliberately
+    // emits the bare `{ field: value }` shape, never an explicit `$eq`.
+    // `$between` stays covered by the `$gte`+`$lte` pair `between` emits
+    // (kvToCondition reads that pair back as `between`).
+    const unreachable = [...SPEC_OPERATORS].filter(
+      (op) => op !== '$eq' && op !== '$between' && !emitted.has(op),
+    );
+    expect(
+      unreachable,
+      'FieldOperatorsSchema accepts these but no builder operator can author them',
+    ).toEqual([]);
+  });
+});
+
+describe('kvToCondition round-trips what condToMongo writes', () => {
+  const cases: Array<[string, unknown]> = [
+    ['notEquals', 'a'],
+    ['contains', 'a'],
+    ['notContains', 'a'],
+    ['greaterThan', 1],
+    ['lessThan', 1],
+    ['greaterOrEqual', 1],
+    ['lessOrEqual', 1],
+    ['startsWith', 'a'],
+    ['endsWith', 'a'],
+    ['isNull', ''],
+    ['isNotNull', ''],
+    ['exists', ''],
+    ['notExists', ''],
+  ];
+
+  it.each(cases)('%s survives the round trip', (operator, value) => {
+    const frag = condToMongo({ id: 'c1', field: 'f', operator, value } as any, noTypes)!;
+    const [[field, v]] = Object.entries(frag);
+    expect(kvToCondition(field, v, 0)).toMatchObject({ field: 'f', operator });
+  });
+
+  it('still reads the pre-fix $ncontains so stored criteria keep loading', () => {
+    // Dropping this would make rules saved before the fix fail to load entirely
+    // ("criteria can't be represented") rather than migrate.
+    expect(kvToCondition('name', { $ncontains: 'x' }, 0)).toMatchObject({
+      field: 'name',
+      operator: 'notContains',
+      value: 'x',
+    });
+  });
+
+  it('rejects an operator it cannot represent rather than guessing', () => {
+    expect(kvToCondition('name', { $nope: 'x' }, 0)).toBeNull();
+  });
+});

package/src/widgets/file-value.test.ts

@@ -0,0 +1,230 @@
+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);
+  });
+});