@object-ui/fields 16.0.0 → 17.1.0

package/src/widgets/useCascadingOptions.ts

@@ -0,0 +1,46 @@
+import { useContext, useMemo } from 'react';
+import {
+  resolveCascadingOptions,
+  type CascadingOptions,
+  type OptionLike,
+  type DependsOnInput,
+} from '@object-ui/core';
+import { SchemaRendererContext, usePredicateScope } from '@object-ui/react';
+
+/**
+ * Shared per-option cascading / role-gating resolution for the option widgets
+ * (`SelectField` single, `MultiSelectField`, `RadioField`) — the client half of
+ * ADR-0058 (#2284). Each option may carry a `visibleWhen` CEL predicate; the
+ * offered set narrows against the live form record (`record.country == 'cn'`) +
+ * the global predicate scope (`'admin' in current_user.positions`). A field
+ * declares which sibling fields drive its list via `dependsOn`; while any is
+ * empty the list is *gated* — callers surface a "select the parent first" hint
+ * rather than an unfiltered set, mirroring the dependent-lookup UX.
+ *
+ * This is the React wrapper that sources `record` (the live form values) and the
+ * predicate scope from context; the actual resolution is the pure
+ * {@link resolveCascadingOptions} in `@object-ui/core`, shared with the form
+ * renderer so gating/filtering can never drift between them (#2715).
+ */
+export type CascadingOptionsResult<T extends OptionLike> = CascadingOptions<T>;
+
+export function useCascadingOptions<T extends OptionLike>(
+  rawOptions: readonly T[],
+  dependsOn: DependsOnInput,
+  dependentValues: Record<string, unknown> | undefined,
+): CascadingOptionsResult<T> {
+  // Live form values for cascading options — injected by the form renderer as
+  // `dependentValues` (same channel dependent lookups use), falling back to the
+  // record on SchemaRendererContext. `current_user` etc. come from the global
+  // predicate scope so role/context predicates resolve too.
+  const ctx = useContext(SchemaRendererContext) as any;
+  const record = useMemo<Record<string, unknown>>(() => {
+    return (dependentValues ?? ctx?.formValues ?? ctx?.data ?? {}) as Record<string, unknown>;
+  }, [dependentValues, ctx?.formValues, ctx?.data]);
+  const predicateScope = usePredicateScope();
+
+  return useMemo(
+    () => resolveCascadingOptions(rawOptions, record, dependsOn, predicateScope),
+    [rawOptions, record, dependsOn, predicateScope],
+  );
+}

package/src/widgets/useFieldTranslation.ts

@@ -39,6 +39,36 @@ const FIELD_DEFAULTS: Record<string, string> = {
   'lookup.nextPage': 'Next page',
   'lookup.jumpToPage': 'Jump to page',
   'lookup.retry': 'Retry',
+  // objectstack#3821 — sharing-rule authoring widgets (object-ref /
+  // recipient-picker / filter-condition). The recipient placeholder is keyed
+  // PER TYPE rather than interpolating the enum value into an English
+  // sentence, which no locale could translate.
+  'fields.objectRef.loading': 'Loading objects…',
+  'fields.objectRef.placeholder': 'Select an object',
+  'fields.objectRef.search': 'Search objects…',
+  'fields.objectRef.empty': 'No objects found',
+  'fields.recipient.selectTypeFirst': 'Select a recipient type first.',
+  'fields.recipient.loading': 'Loading…',
+  'fields.recipient.search': 'Search…',
+  'fields.recipient.empty': 'No matches',
+  'fields.recipient.select': 'Select a recipient',
+  'fields.recipient.selectUser': 'Select a user',
+  'fields.recipient.selectTeam': 'Select a team',
+  'fields.recipient.selectBusinessUnit': 'Select a business unit',
+  'fields.recipient.selectPosition': 'Select a position',
+  'fields.recipient.selectUnitAndSubordinates': 'Select a business unit',
+  'fields.filterCondition.selectObjectFirst': 'Select an object first.',
+  // objectstack#3896 — this used to be 'All records'. An empty criteria never
+  // meant "share everything"; it meant the predicate was missing, and the
+  // sharing evaluator failed open on it. Such a rule is now refused on save
+  // and shares nothing, so say that rather than advertise the old bug.
+  'fields.filterCondition.noCriteria': 'No criteria — this rule shares nothing',
+  'fields.filterCondition.criteriaRequired':
+    'Add at least one condition. A rule with no criteria would share every record, so it cannot be saved.',
+  'fields.filterCondition.invalidJson': 'Invalid JSON — the rule will match no records until fixed.',
+  'fields.filterCondition.jsonOnly': 'This criteria can only be edited as JSON',
+  'fields.filterCondition.editAsJson': 'Edit as JSON',
+  'fields.filterCondition.useVisualBuilder': 'Use visual builder',
   // objectui#2600 B5 — capability picker scope group headers.
   'capability.group.platform': 'Platform',
   'capability.group.org': 'Organization',

package/src/widgets/useUploadingSignal.test.tsx

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useUploadingSignal } from './useUploadingSignal';
+
+/**
+ * useUploadingSignal — surfaces an upload widget's in-progress flips to a host
+ * (ActionParamDialog blocks Confirm while a file/image param uploads). It must
+ * fire only when `uploading` changes and always call the latest callback.
+ */
+describe('useUploadingSignal', () => {
+  it('fires with the initial value on mount', () => {
+    const cb = vi.fn();
+    renderHook(() => useUploadingSignal(false, cb));
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(cb).toHaveBeenLastCalledWith(false);
+  });
+
+  it('fires again only when `uploading` changes', () => {
+    const cb = vi.fn();
+    const { rerender } = renderHook(({ u }) => useUploadingSignal(u, cb), {
+      initialProps: { u: false },
+    });
+    cb.mockClear();
+
+    rerender({ u: true });
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(cb).toHaveBeenLastCalledWith(true);
+
+    // Same value → no extra fire.
+    rerender({ u: true });
+    expect(cb).toHaveBeenCalledTimes(1);
+
+    rerender({ u: false });
+    expect(cb).toHaveBeenCalledTimes(2);
+    expect(cb).toHaveBeenLastCalledWith(false);
+  });
+
+  it('always invokes the latest callback (no stale closure)', () => {
+    const first = vi.fn();
+    const second = vi.fn();
+    const { rerender } = renderHook(
+      ({ cb, u }) => useUploadingSignal(u, cb),
+      { initialProps: { cb: first, u: false } },
+    );
+    // Swap the callback without changing `uploading` → no fire yet.
+    rerender({ cb: second, u: false });
+    expect(second).not.toHaveBeenCalled();
+    // Now flip `uploading` → the NEW callback fires, not the old one.
+    rerender({ cb: second, u: true });
+    expect(second).toHaveBeenCalledWith(true);
+    expect(first).not.toHaveBeenCalledWith(true);
+  });
+
+  it('is a no-op when no callback is provided', () => {
+    expect(() => {
+      const { rerender } = renderHook(({ u }) => useUploadingSignal(u), {
+        initialProps: { u: false },
+      });
+      rerender({ u: true });
+    }).not.toThrow();
+  });
+});

package/src/widgets/useUploadingSignal.ts

@@ -0,0 +1,20 @@
+import { useEffect, useRef } from 'react';
+
+/**
+ * Notify a parent whenever an upload widget's in-progress state flips. Used by
+ * hosts that must block a submit until the presigned upload resolves — e.g.
+ * `ActionParamDialog` disables Confirm so a `file`/`image` param can't be
+ * submitted mid-upload (the value only becomes the fileId once the upload
+ * settles). Fires with the latest callback and only when `uploading` actually
+ * changes, so an inline arrow prop doesn't thrash the parent every render.
+ */
+export function useUploadingSignal(
+  uploading: boolean,
+  onUploadingChange?: (uploading: boolean) => void,
+): void {
+  const ref = useRef(onUploadingChange);
+  ref.current = onUploadingChange;
+  useEffect(() => {
+    ref.current?.(uploading);
+  }, [uploading]);
+}