@object-ui/react 4.3.0 → 4.5.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @object-ui/react
 
+## 4.5.0
+
+### Patch Changes
+
+- Updated dependencies [ab5e281]
+- Updated dependencies [22fa558]
+  - @object-ui/types@4.5.0
+  - @object-ui/i18n@4.5.0
+  - @object-ui/core@4.5.0
+  - @object-ui/data-objectstack@4.5.0
+
+## 4.4.0
+
+### Patch Changes
+
+- @object-ui/types@4.4.0
+- @object-ui/core@4.4.0
+- @object-ui/i18n@4.4.0
+- @object-ui/data-objectstack@4.4.0
+
+## 4.3.1
+
+### Patch Changes
+
+- Updated dependencies [5f4ac6e]
+  - @object-ui/i18n@4.3.1
+  - @object-ui/types@4.3.1
+  - @object-ui/core@4.3.1
+  - @object-ui/data-objectstack@4.3.1
+
 ## 4.3.0
 
 ### Patch Changes

package/dist/SchemaRenderer.js

@@ -90,9 +90,27 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         // Shallow copy
         const newSchema = { ...schema };
         // COMPAT: Hoist 'properties' up to schema level
-        // This allows support for strict configs that wrap all props in 'properties'
+        // This allows support for strict configs that wrap all props in 'properties'.
+        // IMPORTANT: never let inner `properties.type` / `properties.id` shadow the
+        // outer component descriptor — those identify which renderer to dispatch to
+        // (e.g. 'page:tabs'), whereas inner `type` may be a renderer-specific prop
+        // (e.g. tab visual style: 'line' | 'card' | 'pill'). Keep `properties`
+        // intact on the schema so renderers can still read these collision-prone
+        // keys via `schema.properties.<key>`.
         if (newSchema.properties) {
-            Object.assign(newSchema, newSchema.properties);
+            const outerType = newSchema.type;
+            const outerId = newSchema.id;
+            const props = newSchema.properties;
+            for (const [k, v] of Object.entries(props)) {
+                if (k === 'type' || k === 'id')
+                    continue;
+                newSchema[k] = v;
+            }
+            if (outerType !== undefined)
+                newSchema.type = outerType;
+            if (outerId !== undefined)
+                newSchema.id = outerId;
+            newSchema.properties = props;
         }
         // Evaluate 'content' (common in Text, Button)
         if (typeof newSchema.content === 'string') {

package/dist/context/RecordContext.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ *
+ * RecordContext — shared record state for `record:*` namespace renderers
+ * inside a `PageSchema` (type='record'). The page host (e.g. RecordDetailView)
+ * mounts <RecordContextProvider> once; each `record:details / record:related_list
+ * / record:highlights / record:activity / record:chatter / record:path` renderer
+ * inside the page consumes data via `useRecordContext()` instead of having to
+ * receive props from the schema tree.
+ */
+import React from 'react';
+export interface RecordContextValue<TData = any, TObjectSchema = any> {
+    /** Object machine name, e.g. "crm_opportunity". */
+    objectName: string;
+    /** Primary key value of the record being displayed. */
+    recordId: string | number | null | undefined;
+    /** Optional datasource id; mirrors the page-level datasource override. */
+    dataSource?: string;
+    /** Loaded record data (flat record map). Undefined while loading. */
+    data?: TData;
+    /** Resolved object metadata schema (fields, label, etc.). */
+    objectSchema?: TObjectSchema;
+    /** True while the record is fetching. */
+    loading?: boolean;
+    /** Last fetch error, if any. */
+    error?: Error | null;
+    /** Re-fetch the record from the source. */
+    refresh?: () => void | Promise<void>;
+}
+export interface RecordContextProviderProps extends RecordContextValue {
+    children: React.ReactNode;
+}
+export declare const RecordContextProvider: React.FC<RecordContextProviderProps>;
+/**
+ * Read the current record context. Returns `null` when called outside a
+ * <RecordContextProvider> — record:* renderers should treat that as "no
+ * record bound" rather than throwing, so they can still render statically
+ * inside the Studio designer/palette.
+ */
+export declare function useRecordContext<TData = any, TObjectSchema = any>(): RecordContextValue<TData, TObjectSchema> | null;

package/dist/context/RecordContext.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * 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.
+ *
+ * RecordContext — shared record state for `record:*` namespace renderers
+ * inside a `PageSchema` (type='record'). The page host (e.g. RecordDetailView)
+ * mounts <RecordContextProvider> once; each `record:details / record:related_list
+ * / record:highlights / record:activity / record:chatter / record:path` renderer
+ * inside the page consumes data via `useRecordContext()` instead of having to
+ * receive props from the schema tree.
+ */
+import React from 'react';
+const RecordContext = React.createContext(null);
+export const RecordContextProvider = ({ children, ...value }) => {
+    // Memoize so consumers that rely on referential equality don't re-render
+    // on unrelated parent renders.
+    const memo = React.useMemo(() => value, [
+        value.objectName,
+        value.recordId,
+        value.dataSource,
+        value.data,
+        value.objectSchema,
+        value.loading,
+        value.error,
+        value.refresh,
+    ]);
+    return _jsx(RecordContext.Provider, { value: memo, children: children });
+};
+/**
+ * Read the current record context. Returns `null` when called outside a
+ * <RecordContextProvider> — record:* renderers should treat that as "no
+ * record bound" rather than throwing, so they can still render statically
+ * inside the Studio designer/palette.
+ */
+export function useRecordContext() {
+    return React.useContext(RecordContext);
+}

package/dist/context/index.d.ts

@@ -4,3 +4,4 @@ export * from './ThemeContext';
 export * from './NotificationContext';
 export * from './DndContext';
 export * from './AppShellContext';
+export * from './RecordContext';

package/dist/context/index.js

@@ -4,3 +4,4 @@ export * from './ThemeContext';
 export * from './NotificationContext';
 export * from './DndContext';
 export * from './AppShellContext';
+export * from './RecordContext';

package/dist/hooks/index.d.ts

@@ -33,3 +33,4 @@ export * from './useGlobalUndo';
 export * from './useDebugMode';
 export * from './useActionEngine';
 export * from './useDataRefresh';
+export * from './usePageAssignment';

package/dist/hooks/index.js

@@ -33,3 +33,4 @@ export * from './useGlobalUndo';
 export * from './useDebugMode';
 export * from './useActionEngine';
 export * from './useDataRefresh';
+export * from './usePageAssignment';

package/dist/hooks/usePageAssignment.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ *
+ * `usePageAssignment` — resolve the record PageSchema that should be rendered
+ * for a given object. Walks the metadata cache exposed by `<MetadataProvider>`
+ * and returns the first PageSchema whose `pageType === 'record'` and `object`
+ * matches the requested name.
+ *
+ * Future work (deferred): recordType / profile / app / formFactor filtering
+ * and priority-based selection. For now we return the first match so that
+ * callers can deterministically fall back to the auto-generated DetailView
+ * when no record Page is authored.
+ */
+export interface PageAssignmentOptions {
+    /** Salesforce-style record type filter (reserved for future use). */
+    recordType?: string;
+    /** User profile filter (reserved for future use). */
+    profile?: string;
+    /** Owning app filter (reserved for future use). */
+    app?: string;
+    /** Form factor filter (reserved for future use). */
+    formFactor?: 'desktop' | 'tablet' | 'phone';
+    /** Optional explicit page name override; bypasses object-based lookup. */
+    pageName?: string;
+}
+export interface PageAssignmentResult {
+    /** Resolved PageSchema, or null if no record Page is available. */
+    page: any | null;
+    /** True while the metadata cache is still loading the `page` type. */
+    loading: boolean;
+    /** Loader error, if any. */
+    error: Error | null;
+}
+/**
+ * Resolve the record PageSchema for the given object name. Returns `null`
+ * when no record Page is configured, signalling the caller to fall back
+ * to the auto-generated detail view.
+ */
+export declare function usePageAssignment(objectName: string | undefined | null, opts?: PageAssignmentOptions): PageAssignmentResult;
+export default usePageAssignment;

package/dist/hooks/usePageAssignment.js

@@ -0,0 +1,91 @@
+/**
+ * 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.
+ *
+ * `usePageAssignment` — resolve the record PageSchema that should be rendered
+ * for a given object. Walks the metadata cache exposed by `<MetadataProvider>`
+ * and returns the first PageSchema whose `pageType === 'record'` and `object`
+ * matches the requested name.
+ *
+ * Future work (deferred): recordType / profile / app / formFactor filtering
+ * and priority-based selection. For now we return the first match so that
+ * callers can deterministically fall back to the auto-generated DetailView
+ * when no record Page is authored.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { useMetadata } from '../context/AppShellContext';
+function matchesAssignment(_page, _opts) {
+    // Placeholder — every page matches until rules-based assignment lands.
+    return true;
+}
+/**
+ * Resolve the record PageSchema for the given object name. Returns `null`
+ * when no record Page is configured, signalling the caller to fall back
+ * to the auto-generated detail view.
+ */
+export function usePageAssignment(objectName, opts = {}) {
+    const meta = useMetadata();
+    const [ensured, setEnsured] = useState(false);
+    const [ensureError, setEnsureError] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        if (!meta.ensureType) {
+            setEnsured(true);
+            return;
+        }
+        meta
+            .ensureType('page')
+            .then(() => {
+            if (!cancelled) {
+                setEnsured(true);
+                setEnsureError(null);
+            }
+        })
+            .catch(err => {
+            if (!cancelled) {
+                setEnsureError(err instanceof Error ? err : new Error(String(err)));
+                setEnsured(true);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [meta]);
+    const page = useMemo(() => {
+        if (!objectName && !opts.pageName)
+            return null;
+        const pages = Array.isArray(meta.pages) ? meta.pages : [];
+        if (!pages.length)
+            return null;
+        // Explicit page name override wins.
+        if (opts.pageName) {
+            return pages.find(p => p?.name === opts.pageName) ?? null;
+        }
+        const candidates = pages.filter(p => {
+            if (!p)
+                return false;
+            const pageType = p.pageType ?? p.type === 'record' ? p.pageType : p.pageType;
+            const isRecord = (p.pageType ?? (p.type === 'record' ? 'record' : undefined)) === 'record';
+            if (!isRecord)
+                return false;
+            if (p.object !== objectName)
+                return false;
+            return matchesAssignment(p, opts);
+        });
+        if (!candidates.length)
+            return null;
+        // Stable ordering: respect explicit `priority` if present (higher wins),
+        // otherwise fall back to declaration order.
+        candidates.sort((a, b) => (b?.priority ?? 0) - (a?.priority ?? 0));
+        return candidates[0];
+    }, [meta.pages, objectName, opts.pageName, opts.recordType, opts.profile, opts.app, opts.formFactor]);
+    return {
+        page,
+        loading: meta.loading || !ensured,
+        error: ensureError ?? meta.error ?? null,
+    };
+}
+export default usePageAssignment;

package/dist/spec-bridge/bridges/list-view.d.ts

@@ -49,6 +49,7 @@ interface ListViewSpec {
     timeline?: ListViewTimelineConfig;
     rowActions?: string[];
     bulkActions?: string[];
+    bulkActionDefs?: any[];
     virtualScroll?: boolean;
     conditionalFormatting?: Array<{
         condition: string;
@@ -63,6 +64,8 @@ interface ListViewSpec {
     };
     userActions?: any;
     appearance?: any;
+    /** UX-only hint: collapse appearance/grouping cluster into a single popover. */
+    compactToolbar?: boolean;
     tabs?: any[];
     addRecord?: any;
     showRecordCount?: boolean;

package/dist/spec-bridge/bridges/list-view.js

@@ -108,6 +108,8 @@ export const bridgeListView = (spec, _context) => {
         node.rowActions = spec.rowActions;
     if (spec.bulkActions)
         node.bulkActions = spec.bulkActions;
+    if (spec.bulkActionDefs)
+        node.bulkActionDefs = spec.bulkActionDefs;
     if (spec.virtualScroll != null)
         node.virtualScroll = spec.virtualScroll;
     if (spec.conditionalFormatting)
@@ -122,6 +124,8 @@ export const bridgeListView = (spec, _context) => {
         node.userActions = spec.userActions;
     if (spec.appearance)
         node.appearance = spec.appearance;
+    if (spec.compactToolbar != null)
+        node.compactToolbar = spec.compactToolbar;
     if (spec.tabs)
         node.tabs = spec.tabs;
     if (spec.addRecord)

package/dist/spec-bridge/bridges/page.js

@@ -15,7 +15,17 @@ function mapComponent(component) {
     if (component.className)
         node.className = component.className;
     if (component.properties) {
-        Object.assign(node, component.properties);
+        // Avoid overwriting the component dispatch keys (`type`/`id`) with inner
+        // renderer-specific props. E.g. PageTabsProps.properties.type is the tab
+        // visual style ('line'|'card'|'pill'), NOT the component type.
+        for (const [k, v] of Object.entries(component.properties)) {
+            if (k === 'type' || k === 'id')
+                continue;
+            node[k] = v;
+        }
+        // Preserve the original `properties` bag so renderers can still read
+        // collision-prone keys via `schema.properties.<key>`.
+        node.properties = component.properties;
     }
     if (component.events)
         node.events = component.events;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/react",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "type": "module",
   "license": "MIT",
   "description": "React bindings and SchemaRenderer component for Object UI",
@@ -26,10 +26,10 @@
   "dependencies": {
     "@objectstack/spec": "^4.0.5",
     "react-hook-form": "^7.76.0",
-    "@object-ui/core": "4.3.0",
-    "@object-ui/data-objectstack": "4.3.0",
-    "@object-ui/i18n": "4.3.0",
-    "@object-ui/types": "4.3.0"
+    "@object-ui/core": "4.5.0",
+    "@object-ui/data-objectstack": "4.5.0",
+    "@object-ui/i18n": "4.5.0",
+    "@object-ui/types": "4.5.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",