@object-ui/react 17.5.0 → 17.7.0

package/dist/element-data-source/ElementDataSourceGate.js

@@ -51,6 +51,27 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * designer emits for an unconfigured column list, and supplying the columns is
  * exactly why a view was named.
  *
+ * The row cap answers "did the component author one?" the same way, and for the
+ * same reason (objectui#9899). A cap the contract REFUSES — `pageSize: 0`,
+ * a negative, a fraction — is not a cap this relay may treat as the author's
+ * intent, so it does not suppress the one the bound view supplies. Deciding
+ * that question by PRESENCE is how a view's legitimate cap was dropped in
+ * favour of the consuming renderer's own default: measured end to end on
+ * `list-view` before the repair, a component carrying `pagination.pageSize: 0`
+ * under a view supplying `7` put `$top: 100` on the wire — the view's cap never
+ * reached it, so the read was WIDER than the view asked for.
+ *
+ * The VIEW's own cap can be refused too, and `@object-ui/core` drops it before
+ * it reaches this relay (objectui#9928). The drop is right, but it left the
+ * consuming renderer nothing to refuse, so it went silent — and this relay
+ * reports the view's refusal instead (objectui#10015). See
+ * {@link describeRefusedViewRowLimit} for when that message applies.
+ *
+ * The BINDING's own cap follows the same rule (objectui#10016): a `limit` the
+ * contract refuses is not authored, so `@object-ui/core` lets the view's cap
+ * through in its place, and that cap is a baseline here like any other
+ * view-sourced value. See {@link describeRefusedBindingRowLimit}.
+ *
  * ## What a mapping may NOT do
  *
  * {@link ElementDataSourceMapping} names only keys the target block genuinely
@@ -60,6 +81,17 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * therefore leaves `limit` unmapped rather than parking it somewhere plausible,
  * and the gap is recorded at the call site instead of being papered over here.
  *
+ * ## A block with no ADAPTER fails loudly too (objectui#5378)
+ *
+ * The section below is about an unresolvable view NAME. The coarser failure —
+ * no runtime adapter reached the block at all — used to render an empty shell
+ * in exactly the same silence, and that is what `requiresDataSource` +
+ * {@link NoDataSourcePanel} now report. Measured on the published
+ * getting-started guide: all five of its blocks resolved no adapter, fetched
+ * nothing, and said nothing. The two panels are deliberately the same shape;
+ * they answer "which view?" and "which data source?", and an author who sees
+ * either one is being told where to look.
+ *
  * ## An unresolvable `view` fails loudly
  *
  * When the named view does not exist the gate renders a configuration error
@@ -69,8 +101,135 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * like it works.
  */
 import * as React from 'react';
-import { isElementDataSourceConfig, mergeFilterNodes, } from '@object-ui/core';
-import { useElementDataSource, } from '../hooks/useElementDataSource';
+import { elementDataSourceRefusedLimitMessage, filterRefusalSubject, isElementDataSourceConfig, mergeFilterNodes, toFilterNodeSafely, } from '@object-ui/core';
+import { useObjectTranslation } from '@object-ui/i18n';
+import { useElementDataSource, } from '../hooks/useElementDataSource.js';
+import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
+/**
+ * What the contract admits as a row cap (objectui#9899).
+ *
+ * `@objectstack/spec` has already answered what `0` means for the keys this
+ * branch writes. Its view pagination config declares `pageSize` a positive
+ * integer with a default; every component row cap its component props map
+ * declares is `z.number().int().positive()`; and that flat `limit` is the key a
+ * view's `pagination.pageSize` is LOWERED INTO for the blocks that read it. So
+ * `0`, a negative and a fraction are not spellings this relay may assign a
+ * meaning to — they are values the contract refuses.
+ *
+ * ⚠️ Said precisely, because it is easy to overstate: the `object-grid` props
+ * face declares its OWN `pagination` key `z.unknown()`, so a save gate does not
+ * refuse a component-level `pagination.pageSize: 0` on that face, and the flat
+ * `pageSize` shorthand beside it is a bare `z.number()`. The refusal rests on
+ * the pagination CONFIG contract and on the `limit` the value is lowered into —
+ * the same ground objectui#9853, objectui#9897 and objectui#9925 already stood
+ * on at the renderer sites.
+ *
+ * ⛔ Deliberately a LOCAL restatement of the predicate objectui#9925 landed at
+ * the renderer sites, not an import and not a shared helper: hoisting it would
+ * be a cross-package extraction this card may not make. The cost is stated
+ * rather than hidden — one rule now has a spelling at every site that enforces
+ * it, and `git grep 'isUsableRowLimit\|isUsablePageSize'` is what enumerates
+ * them; the day one is meant to change, all of them are.
+ */
+function isUsableRowLimit(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+/**
+ * The loud half, and the reason a RELAY owes one at all.
+ *
+ * A relay that merely declines to treat a value as authored could reasonably
+ * say nothing — the renderer it forwards to has its own refusal and its own
+ * message. Measured rather than assumed: BEFORE this repair, a `list-view`
+ * carrying `pagination.pageSize: 0` under a bound view was told about it, once,
+ * by `ListView`'s own diagnostic. AFTER it, the gate writes the view's usable
+ * cap, that renderer sees a value it accepts, and its message correctly goes
+ * silent — so the repair REMOVES the only place the author was being told.
+ * This restores that one message at the layer that now makes the decision.
+ *
+ * ⛔ NOT a second guard: the predicate lives once, in {@link isUsableRowLimit},
+ * and this reads it. `null` means "nothing to say" — an absent cap is not a
+ * mistake and a usable one is not either, which is what keeps this from
+ * becoming an always-on marker that states nothing.
+ */
+const describeDisplacedRowLimit = (authored, key, used, componentType, objectName) => {
+    if (authored === undefined || authored === null)
+        return null;
+    if (isUsableRowLimit(authored))
+        return null;
+    const type = typeof componentType === 'string' && componentType ? componentType : 'component';
+    const where = typeof objectName === 'string' && objectName ? `${type} on ${objectName}` : type;
+    return (`[ObjectUI] ElementDataSourceGate row cap: ${where} declared ${key}: ${String(authored)}, `
+        + 'which is not a positive integer. A row cap must be a positive integer '
+        + '(the spec refuses zero and negative values), so it was ignored and the cap '
+        + `from this component's bound data source (${used}) was used instead.`);
+};
+/**
+ * The loud half for a cap the SAVED VIEW declared and the contract refuses
+ * (objectui#10015).
+ *
+ * `@object-ui/core` drops such a cap while composing, so `composed.limit`
+ * never carries it and the renderer below never sees it. Its own diagnostic
+ * treats an absent key as "not a mistake", so after that drop nothing said
+ * anything. The wording is the core builder's, not this file's: it is the one
+ * sentence both consumers of the composed binding use, and `ViewDataProvider`
+ * already reports it on the path with no renderer. The builder is pure because
+ * the composer runs inside a `useMemo`; this relay reports its result from an
+ * effect, the same way it reports {@link describeDisplacedRowLimit}.
+ *
+ * It speaks only when the refusal CHANGED what this block receives — when a
+ * usable view cap would have been written here:
+ *
+ *  - the binding declared no usable `limit` of its own (if it did, the
+ *    binding's cap is what the block gets whatever the view carries). The
+ *    builder applies this condition itself, because `ViewDataProvider` needs
+ *    it too (objectui#10016), so this relay hands it the binding; and
+ *  - the component's own cap is not a usable one (a usable one wins over any
+ *    view cap).
+ *
+ * In both of those excluded cases the builder's sentence — the block falls
+ * back to its own default — would not be true, so silence is the honest
+ * answer, not a gap. The caller adds the third condition: the block reads a
+ * row cap at all.
+ *
+ * ## Never together with {@link describeDisplacedRowLimit}
+ *
+ * That message needs a usable cap to have been WRITTEN. With a refused view
+ * cap, the only usable cap left is a binding's usable `limit`, and that is
+ * excluded above. So the two are exclusive by construction. When the component
+ * AND the view both carry a refused cap, this message names the view and the
+ * renderer names the component: two declarations, one message each.
+ */
+const describeRefusedViewRowLimit = (view, config, authored) => {
+    if (!config)
+        return null;
+    if (isUsableRowLimit(authored))
+        return null;
+    return elementDataSourceRefusedLimitMessage(view, config.view, config.object, config);
+};
+/**
+ * The loud half for a cap the BINDING declared and the contract refuses
+ * (objectui#10016), in the core builder's words for that operand.
+ *
+ * `@object-ui/core` treats such a cap as not authored: it lets the view's
+ * usable cap through in its place, or none. Nothing downstream can see the
+ * refused value any more, so this relay reports it, from an effect, the same
+ * way it reports the view's refusal.
+ *
+ * It needs no condition beyond the caller's (the block reads a row cap at
+ * all). A usable binding cap is written whatever the component or the view
+ * carries, so a refused one is always a cap this block did not get.
+ *
+ * It can fire beside the other two, and that is one message per declaration,
+ * not two per mistake: beside {@link describeRefusedViewRowLimit} when the view
+ * ALSO carries a refused cap, and beside {@link describeDisplacedRowLimit} when
+ * the component ALSO carries a refused cap and the view's usable one displaced
+ * it.
+ */
+const describeRefusedBindingRowLimit = (view, config) => {
+    if (!config)
+        return null;
+    return elementDataSourceRefusedLimitMessage(view, config.view, config.object, config, 'binding');
+};
 const readLimit = (base, key) => {
     if (key === 'pagination.pageSize')
         return base.pagination?.pageSize;
@@ -110,10 +269,16 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
     const { object: objectKey = 'objectName', columns, filter, sort, limit, viewType } = mapping;
     const mapped = React.useMemo(() => {
         const composed = binding.composed;
+        // BY REFERENCE when there is nothing to apply — a fresh object every render
+        // would remount the block and refetch. The wrapper is memoised alongside it,
+        // so the identity this carries is the one the caller sees.
         if (!composed)
-            return schema;
+            return { schema, capMessage: null, viewCapMessage: null, bindingCapMessage: null };
         const base = (schema ?? {});
         const next = { ...base };
+        let capMessage = null;
+        let viewCapMessage = null;
+        let bindingCapMessage = null;
         if (objectKey !== false)
             next[objectKey] = composed.object;
         if (columns) {
@@ -127,7 +292,23 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
             // Component filter AND (view filter AND binding filter). `composed.filter`
             // already carries the latter pair; a single surviving source comes back
             // unwrapped, so the common "only the view filters" case stays flat.
-            const merged = mergeFilterNodes(base.filter, composed.filter);
+            //
+            // ⚠️ Each source is lowered through `toFilterNodeSafely` first, the way
+            // `RelatedList` and `LineItemsPanel` lower their own filter before they
+            // merge it — objectui#10789. This is a RENDER-time `useMemo`, and the
+            // lowering refuses malformed authored shapes with a `FilterOperatorError`:
+            // uncaught, that was a render error, thrown BEFORE the wrapped block
+            // reached its own safe lowering and its malformed-filter state. The
+            // refusal is returned as a VALUE and the block is not rendered at all —
+            // never merged as "no filter", which would run it unconstrained. The
+            // merge below then only re-reads nodes the lowering already produced.
+            const own = toFilterNodeSafely(base.filter);
+            if (!own.ok)
+                return { schema, capMessage: null, viewCapMessage: null, bindingCapMessage: null, filterRefusal: own.refusal };
+            const bound = toFilterNodeSafely(composed.filter);
+            if (!bound.ok)
+                return { schema, capMessage: null, viewCapMessage: null, bindingCapMessage: null, filterRefusal: bound.refusal };
+            const merged = mergeFilterNodes(own.node, bound.node);
             if (merged !== undefined)
                 next.filter = merged;
             else
@@ -141,22 +322,65 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
                 next.sort = composed.sort;
         }
         if (limit && composed.limit !== undefined) {
-            const fromView = binding.config?.limit === undefined;
-            if (!fromView || readLimit(base, limit) === undefined) {
+            // For the row cap, "declared one" means a cap the contract admits
+            // (objectui#10016): a refused binding `limit` is not authored, so the
+            // composer let the view's cap through in its place, and that cap is a
+            // baseline the component's usable cap still wins over.
+            const fromView = !isUsableRowLimit(binding.config?.limit);
+            // PRESENCE is not authorship (objectui#9899) — the same question the
+            // `columns` branch above answers by CONTENT, answered the same way here.
+            const authored = readLimit(base, limit);
+            if (!fromView || !isUsableRowLimit(authored)) {
                 writeLimit(next, base, limit, composed.limit);
+                capMessage = describeDisplacedRowLimit(authored, limit, composed.limit, base.type, composed.object);
             }
         }
+        // Outside the branch above on purpose: a refused cap never reaches
+        // `composed.limit`, so that branch does not run for it (objectui#10015,
+        // and objectui#10016 for the binding's).
+        if (limit) {
+            viewCapMessage = describeRefusedViewRowLimit(binding.view, binding.config, readLimit(base, limit));
+            bindingCapMessage = describeRefusedBindingRowLimit(binding.view, binding.config);
+        }
         if (viewType && composed.viewType !== undefined && base.viewType === undefined) {
             next.viewType = composed.viewType;
         }
-        return next;
-    }, [schema, binding.composed, binding.config, objectKey, columns, filter, sort, limit, viewType]);
-    return React.useMemo(() => ({
-        status: binding.status,
-        schema: mapped,
-        config: binding.config,
-        error: binding.error,
-    }), [binding.status, binding.config, binding.error, mapped]);
+        return { schema: next, capMessage, viewCapMessage, bindingCapMessage };
+    }, [schema, binding.composed, binding.config, binding.view, objectKey, columns, filter, sort, limit, viewType]);
+    // Keyed on the MESSAGE, so it is one warning per declaration rather than one
+    // per render — and it fires from an effect, never from render, which is the
+    // same shape the renderer sites use for "you declared it, we dropped it".
+    // One effect per message, so a change to one never re-emits another.
+    const { schema: boundSchema, capMessage, viewCapMessage, bindingCapMessage, filterRefusal: mergeRefusal } = mapped;
+    React.useEffect(() => {
+        if (capMessage)
+            console.warn(capMessage);
+    }, [capMessage]);
+    React.useEffect(() => {
+        if (viewCapMessage)
+            console.warn(viewCapMessage);
+    }, [viewCapMessage]);
+    React.useEffect(() => {
+        if (bindingCapMessage)
+            console.warn(bindingCapMessage);
+    }, [bindingCapMessage]);
+    // A refused filter — from either merge — is `missing`, the one state every
+    // caller already answers by withholding the block (objectui#10789).
+    const filterRefusal = binding.filterRefusal ?? mergeRefusal;
+    return React.useMemo(() => filterRefusal
+        ? {
+            status: 'missing',
+            schema: boundSchema,
+            config: binding.config,
+            error: filterRefusal.message,
+            filterRefusal,
+        }
+        : {
+            status: binding.status,
+            schema: boundSchema,
+            config: binding.config,
+            error: binding.error,
+        }, [binding.status, binding.config, binding.error, boundSchema, filterRefusal]);
 }
 /**
  * The "named view does not resolve" panel. Same posture (and shape) as
@@ -166,6 +390,41 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
 export function ElementDataSourceErrorPanel({ testId, title = 'This component’s data source could not be resolved', message, }) {
     return (_jsxs("div", { className: "p-4 border border-red-500 rounded text-red-500 bg-red-50 my-2", role: "alert", "data-testid": `${testId}-datasource-error`, children: [_jsx("p", { className: "font-medium", children: title }), message ? _jsx("p", { className: "text-sm mt-1", children: message }) : null] }));
 }
+/**
+ * The malformed-filter notice, drawn IN PLACE OF the block when a filter the
+ * gate had to merge is refused (objectui#10789).
+ *
+ * It is the notice the wrapped blocks draw themselves (objectui#9050 step 2 —
+ * `record:related_list`, the line-items panel, `object-grid`): the same
+ * sentence (`view.malformedFilter`), naming the refused operator or field in a
+ * separately addressable headline, with the refusal's own message beneath it.
+ * The gate draws it because its merge refuses FIRST — before the block's own
+ * safe lowering ever runs — so without it the author would get the error
+ * boundary's "failed to render" instead of the sentence those blocks give.
+ *
+ * ⚠️ A separate component, so `useObjectTranslation` runs only on this path:
+ * the gate wraps every object-bound block, and a translation hook in the
+ * gate's own body would run for all of them, including under the many suites
+ * that mock `@object-ui/i18n` by hand.
+ *
+ * The provider-less default is the sentence itself, written the way the
+ * sibling blocks carry it: a LITERAL copy of the `en` pack's value, never a
+ * read of the pack object. The siblings keep theirs in a module-scope
+ * `createSafeTranslation` table, which this module cannot have: it is
+ * re-exported from the package entry, so a factory call at module scope would
+ * run on import for every consumer (`NonGridRowCeilingNote` records that
+ * hazard). So the copy sits in the call's inline `defaultValue`, where
+ * `pnpm check:i18n-keys` holds it byte-identical to the pack, as the siblings'
+ * tables are held. With an `I18nProvider` the pack's value wins, and without
+ * one this literal is interpolated (objectui#6219).
+ */
+function ElementDataSourceMalformedFilterPanel({ testId, refusal, }) {
+    const { t } = useObjectTranslation();
+    return (_jsxs("div", { role: "alert", className: "rounded-md border border-amber-300 bg-amber-50 p-3 my-2 text-sm text-amber-800", "data-testid": `${testId}-malformed-filter`, children: [_jsx("p", { className: "font-medium", "data-testid": `${testId}-malformed-filter-subject`, children: t('view.malformedFilter', {
+                    subject: filterRefusalSubject(refusal) ?? '',
+                    defaultValue: 'This view’s filter is malformed, so no records are shown: the {{subject}} condition cannot be applied.',
+                }) }), _jsx("p", { className: "mt-1 text-xs opacity-80", children: refusal.message })] }));
+}
 /**
  * The "saved views are still being fetched" placeholder. Distinct from the error
  * panel because a component that treated "not resolved yet" as "does not exist"
@@ -174,6 +433,124 @@ export function ElementDataSourceErrorPanel({ testId, title = 'This component’
 export function ElementDataSourceLoadingPanel({ testId, }) {
     return (_jsx("div", { className: "p-2 text-sm text-muted-foreground animate-pulse", role: "status", "aria-live": "polite", "data-testid": `${testId}-resolving-view`, children: "Loading view\u2026" }));
 }
+/**
+ * The adapter this block would use, resolved the one way every block in the
+ * family resolves it: an explicit value first, the `SchemaRendererProvider`
+ * context second.
+ *
+ * The `isElementDataSourceConfig` guard is the same one
+ * {@link useElementDataSourceSchema} applies — a host handing us the spec
+ * BINDING under this name is handing us metadata, not an adapter, and counting
+ * it as one is how "no data source" reads as "resolved".
+ *
+ * `T` is what the CALLER expects to have been injected, and the assertion is
+ * the caller's, not this hook's: an adapter arrives here as a `dataSource` prop
+ * or a context value that nothing in this package can narrow, so the type has
+ * to be declared by whoever knows which interface their block consumes. Leave
+ * it off and you get `unknown`, which is the honest default.
+ */
+export function useResolvedDataSource(explicit) {
+    // Read AS DECLARED (objectui#7209): the only cast in this hook is the
+    // caller's `T` on the way out, never one erasing the context on the way in.
+    // Pinned by `useResolvedDataSource.schemaRendererContextRead-7209.test.ts`.
+    const context = React.useContext(SchemaRendererContext);
+    const named = isElementDataSourceConfig(explicit) ? undefined : explicit;
+    return (named ?? context?.dataSource ?? undefined);
+}
+/**
+ * The author-facing sentence a block with no adapter says out loud.
+ *
+ * One wording for the whole object-bound family, because the reader's mistake
+ * is the same one every time and the fix is the same one every time: the
+ * adapter is injected by an ANCESTOR (`SchemaRendererProvider`), so nothing
+ * written on the block itself can supply it. Naming the block and the object
+ * it was about to read is what turns "nothing happened" into an address.
+ */
+export function noDataSourceMessage(blockKey, objectName) {
+    const target = typeof objectName === 'string' && objectName.trim().length > 0
+        ? `“${objectName}”`
+        : 'its object';
+    return (`“${blockKey}” has no data source, so it cannot read ${target}. ` +
+        `Inject one from an ancestor — <SchemaRendererProvider dataSource={…}> from ` +
+        `@object-ui/react — or hand this block a dataSource of its own.`);
+}
+/**
+ * The "this block resolved no adapter" panel — objectui#5378 item 2, and the
+ * #5349 shape it belongs to.
+ *
+ * Until this existed, a block that resolved no adapter rendered an EMPTY SHELL:
+ * `object-grid` painted a header-only table, `object-form` a field-less card,
+ * `detail-view` nothing at all — no error, no warning, no empty state that
+ * explained itself. Measured on the published getting-started guide
+ * (`content/docs/guide/building-crud-app.md`), every one of its five blocks was
+ * in that state and the page reported success while fetching nothing.
+ *
+ * The empty shell is the defect, not a side effect of it: it is indistinguishable
+ * from "the query ran and matched no rows", which is the reading an author (very
+ * often an AI author) takes, and it points at the DATA when the fault is in the
+ * WIRING one level up. Same posture as {@link ElementDataSourceErrorPanel}: the
+ * metadata is answerable, so the answer is rendered where the author can see it.
+ */
+export function NoDataSourcePanel({ testId, title = 'No data source resolved', message, }) {
+    return (_jsxs("div", { className: "p-4 border border-red-500 rounded text-red-500 bg-red-50 my-2", role: "alert", "data-testid": `${testId}-no-data-source`, children: [_jsx("p", { className: "font-medium", children: title }), message ? _jsx("p", { className: "text-sm mt-1", children: message }) : null] }));
+}
+/**
+ * The wrapping seam — mark `renderer` as one that wraps {@link
+ * ElementDataSourceGate}, so its registrations DECLARE the `dataSource` key this
+ * gate READS (objectui#6678).
+ *
+ * ```tsx
+ * export const ObjectMapRenderer = elementDataSourceBlock<React.FC<any>>(({ schema }) => (
+ *   <ElementDataSourceGate schema={schema} testId="object-map" …>
+ *     {(bound) => <ObjectMap schema={bound} />}
+ *   </ElementDataSourceGate>
+ * ));
+ * ```
+ *
+ * ## What this closes
+ *
+ * `PageComponentSchema.dataSource` is the one spelling that resolves a saved
+ * view for an object-bound block. It works — and because no registration
+ * declared it, `sdui-parser`'s `validateTree` reported it with the SAME
+ * `unknown-prop` warning it gives the spellings that do nothing. On the tier
+ * built to accept AI-authored pages the diagnostic IS the contract, so the
+ * tier's only signal pointed away from the one key that works.
+ *
+ * ## Why a seam and not nine declarations
+ *
+ * Maintainer ruling, 2026-08-29: option B **in the injection form**. Nine
+ * hand-written copies across nine packages is the shape that ruling refused —
+ * they drift, and the tenth block forgets. Passing through here is the only
+ * thing a block does; `Registry.register` emits the declaration
+ * (`withElementDataSourceInput`), and `ELEMENT_DATA_SOURCE_INPUT` in
+ * `@object-ui/core` is its single copy, beside the binding's own semantics.
+ *
+ * ## And it cannot be forgotten
+ *
+ * `scripts/check-element-data-source-declaration.mjs` fails any source that
+ * renders `ElementDataSourceGate` for a registration without passing that
+ * registration's renderer through this function. That is the mechanical half of
+ * "a tenth block gets it automatically"; this function is the seam it enforces.
+ *
+ * Returns the renderer UNCHANGED (the mark is held in a `WeakSet`), so it is safe
+ * over a `React.forwardRef` object, over `React.memo`, and over a component that
+ * something else already re-exports by reference.
+ *
+ * ⚠️ Re-exported from `@object-ui/core` — where the marker and the declaration
+ * live — rather than wrapped here: ONE function under ONE name. This export
+ * exists for DISCOVERABILITY, so the seam is findable beside the gate it is
+ * about; **call sites must import it from `@object-ui/core`**, and
+ * `check:element-data-source-declaration` enforces that.
+ *
+ * The rule is measured, not stylistic. A registration runs at MODULE SCOPE, 101
+ * suites in this repo partially mock `@object-ui/react` by hand-listing the
+ * exports they return, and a module-scope read of a name absent from such a list
+ * throws at COLLECTION time — the importing test file dies before running one
+ * assertion. Taking the seam from here reddened 17 files across all four CI
+ * shards with zero failed assertions among them. Nothing mocks `@object-ui/core`,
+ * and every registration module already imports `ComponentRegistry` from it.
+ */
+export { elementDataSourceBlock } from '@object-ui/core';
 /**
  * Wrap an object-bound block so its `dataSource` binding reaches the keys it
  * reads, and so the two non-final resolution states render once, the same way,
@@ -183,8 +560,23 @@ export function ElementDataSourceLoadingPanel({ testId, }) {
  * against a half-resolved query is how a page shows a wider answer than the one
  * that was authored.
  */
-export function ElementDataSourceGate({ schema, mapping, dataSource, testId, errorTitle, children, }) {
+export function ElementDataSourceGate({ schema, mapping, dataSource, testId, errorTitle, requiresDataSource, noDataSourceMessage: noDataSourceText, children, }) {
     const bound = useElementDataSourceSchema(schema, mapping, dataSource);
+    const adapter = useResolvedDataSource(dataSource);
+    // Reported BEFORE the view state, because with no adapter every downstream
+    // answer is a symptom of this one: `useElementDataSource` cannot list the
+    // object's saved views either, so a block carrying a `view` would otherwise
+    // report "this data source cannot list the saved views" — true, and pointing
+    // at the view name instead of at the missing injection.
+    if (requiresDataSource && adapter == null) {
+        return _jsx(NoDataSourcePanel, { testId: testId, message: noDataSourceText });
+    }
+    // A refused filter is `missing` too, but it gets the malformed-filter notice
+    // rather than the "could not be resolved" panel: the binding resolved, and
+    // what the author has to fix is a filter condition (objectui#10789).
+    if (bound.filterRefusal) {
+        return _jsx(ElementDataSourceMalformedFilterPanel, { testId: testId, refusal: bound.filterRefusal });
+    }
     if (bound.status === 'missing') {
         return _jsx(ElementDataSourceErrorPanel, { testId: testId, title: errorTitle, message: bound.error });
     }

package/dist/hooks/index.d.ts

@@ -5,38 +5,40 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export * from './useExpression';
-export * from './useFilterScope';
-export * from './useActionRunner';
-export * from './useNavigationOverlay';
-export * from './usePageVariables';
-export * from './usePageVariableActionBridge';
-export * from './useViewData';
-export * from './useElementDataSource';
-export * from './useDynamicApp';
-export * from './useDiscovery';
-export * from './useFocusTrap';
-export * from './useFocusManagement';
-export * from './useKeyboardShortcuts';
-export * from './useCrudShortcuts';
-export * from './useReducedMotion';
-export * from './useAnimation';
-export * from './useDensityMode';
-export * from './useViewSharing';
-export * from './useClientNotifications';
-export * from './useOffline';
-export * from './usePerformance';
-export * from './usePerformanceBudget';
-export * from './usePageTransition';
-export * from './useViewTransition';
-export * from './useETagCache';
-export * from './useSchemaPersistence';
-export * from './useGlobalUndo';
-export * from './useDebugMode';
-export * from './useActionEngine';
-export * from './useActionTextLocalizer';
-export * from './useCapabilityGate';
-export * from './useDatasetDimensionLabels';
-export * from './useDataRefresh';
-export * from './usePageAssignment';
-export * from './useRecordSearch';
+export * from './useExpression.js';
+export * from './useFilterScope.js';
+export * from './useResolvedFilter.js';
+export * from './useActionRunner.js';
+export * from './useNavigationOverlay.js';
+export * from './usePageVariables.js';
+export * from './usePageVariableActionBridge.js';
+export * from './useViewData.js';
+export * from './useElementDataSource.js';
+export * from './useDynamicApp.js';
+export * from './useDiscovery.js';
+export * from './useFocusTrap.js';
+export * from './useFocusManagement.js';
+export * from './useKeyboardShortcuts.js';
+export * from './useCrudShortcuts.js';
+export * from './useReducedMotion.js';
+export * from './useAnimation.js';
+export * from './useDensityMode.js';
+export * from './useViewSharing.js';
+export * from './useOffline.js';
+export * from './usePerformance.js';
+export * from './usePerformanceBudget.js';
+export * from './usePageTransition.js';
+export * from './useViewTransition.js';
+export * from './useETagCache.js';
+export * from './useSchemaPersistence.js';
+export * from './useGlobalUndo.js';
+export * from './useDebugMode.js';
+export * from './useActionEngine.js';
+export * from './useActionTextLocalizer.js';
+export * from './useCapabilityGate.js';
+export * from './useConfigBagEvaluator.js';
+export * from './useDatasetDimensionLabels.js';
+export * from './useDataRefresh.js';
+export * from './usePageAssignment.js';
+export * from './useRecordSearch.js';
+export * from './useSettledSchema.js';