@object-ui/fields 14.0.0 → 15.0.0

package/dist/widgets/FileField.d.ts

@@ -6,3 +6,25 @@ import { FieldWidgetProps } from './types';
  * L2: File size validation, per-file progress indicators, error messages.
  */
 export declare function FileField({ value, onChange, field, readonly, ...props }: FieldWidgetProps<any>): React.JSX.Element;
+/**
+ * FileCell — compact upload control for a line-item grid cell (objectui#2360).
+ *
+ * Same value shape and upload pipeline as {@link FileField}, sized for a 32px
+ * grid row: existing files render as removable chips (image thumbnail / file
+ * icon + name) and a small button opens the native file picker. No
+ * drag-and-drop zone — a grid cell has no room for one; the per-row expand
+ * form still offers the full-size FileField.
+ */
+export declare function FileCell({ value, onChange, disabled, multiple, accept, maxSize, 'aria-label': ariaLabel, 'data-cell': dataCell, }: {
+    value: any;
+    onChange: (value: any) => void;
+    disabled?: boolean;
+    multiple?: boolean;
+    /** Comma-joined accept list for the native picker (e.g. `"image/*,.pdf"`). */
+    accept?: string;
+    /** Max file size in bytes (oversize picks are rejected with an inline error). */
+    maxSize?: number;
+    'aria-label'?: string;
+    /** Focus-grid coordinate (see GridField keyboard navigation). */
+    'data-cell'?: string;
+}): React.JSX.Element;

package/dist/widgets/GridField.d.ts

@@ -11,7 +11,7 @@ import { FieldWidgetProps } from './types';
  *
  * Column config (a subset of `GridColumnDefinition`):
  *   { field, label?, type?, options?, width?, required?, prefix?, step? }
- *   type ∈ 'text' | 'number' | 'currency' | 'date' | 'select'
+ *   type ∈ 'text' | 'number' | 'currency' | 'date' | 'select' | 'lookup' | 'file'
  *
  * Field-level config (from `GridFieldMetadata`):
  *   columns, min_rows, max_rows, allow_add, allow_delete, total_field
@@ -19,7 +19,7 @@ import { FieldWidgetProps } from './types';
 export interface GridColumn {
     field: string;
     label?: string;
-    type?: 'text' | 'number' | 'currency' | 'date' | 'select' | 'lookup';
+    type?: 'text' | 'number' | 'currency' | 'date' | 'select' | 'lookup' | 'file';
     options?: Array<{
         label: string;
         value: string;
@@ -32,7 +32,11 @@ export interface GridColumn {
     reference?: string;
     displayField?: string;
     idField?: string;
+    /** Multi-value column: multi-record lookup, or multi-file upload cell. */
     multiple?: boolean;
+    /** For `type: 'file'` — accepted MIME types / extensions for the picker
+     *  (e.g. `['image/*', '.pdf']`). Omit to accept anything. */
+    accept?: string[];
     /**
      * Hidden from the grid by default but revealable via the column chooser.
      * Set by `deriveColumns` for fields beyond the default-visible budget — the

package/dist/widgets/SelectField.d.ts

@@ -6,7 +6,7 @@ import { FieldWidgetProps } from './types';
  * Supports cascading / role-gated options (#2284): each option may carry a
  * `visibleWhen` CEL predicate, evaluated against the live form record +
  * `current_user`, so the offered set narrows as a controlling field changes
- * (`record.country == 'cn'`) or by role (`'admin' in current_user.roles`). A
+ * (`record.country == 'cn'`) or by role (`'admin' in current_user.positions`). A
  * field declares which sibling fields drive its list via `dependsOn`; while any
  * of those is empty the control is gated with a "select the parent first" hint,
  * mirroring the dependent-lookup UX.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/fields",
-  "version": "14.0.0",
+  "version": "15.0.0",
   "description": "Field renderers and registry for Object UI",
   "license": "MIT",
   "type": "module",
@@ -30,12 +30,12 @@
     "rehype-sanitize": "^6.0.0",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.6.0",
-    "@object-ui/components": "14.0.0",
-    "@object-ui/core": "14.0.0",
-    "@object-ui/i18n": "14.0.0",
-    "@object-ui/providers": "14.0.0",
-    "@object-ui/react": "14.0.0",
-    "@object-ui/types": "14.0.0"
+    "@object-ui/components": "15.0.0",
+    "@object-ui/core": "15.0.0",
+    "@object-ui/i18n": "15.0.0",
+    "@object-ui/providers": "15.0.0",
+    "@object-ui/react": "15.0.0",
+    "@object-ui/types": "15.0.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",

package/src/__tests__/DateCellRenderer.test.tsx

@@ -23,16 +23,39 @@ describe('formatRelativeDate', () => {
     expect(formatRelativeDate(daysAgo(3), { dueLike: true })).toBe('Overdue 3d');
   });
 
-  it('renders neutral "Nd ago" for a past date that is not due-like', () => {
-    expect(formatRelativeDate(daysAgo(3))).toBe('3d ago');
-    expect(formatRelativeDate(daysAgo(3), { dueLike: false })).toBe('3d ago');
+  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');
   });
 });
 
 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('6d ago')).toBeInTheDocument();
+    expect(screen.getByText('6 days ago')).toBeInTheDocument();
     expect(screen.queryByText(/Overdue/)).not.toBeInTheDocument();
   });
 

package/src/__tests__/lookupCellDisplayField.test.tsx

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

package/src/__tests__/lookupCellDisplayName.test.tsx

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