@object-ui/react 3.0.2 → 3.1.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @object-ui/react@3.0.2 build /home/runner/work/objectui/objectui/packages/react
+> @object-ui/react@3.1.0 build /home/runner/work/objectui/objectui/packages/react
 > tsc
 

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @object-ui/react
 
+## 3.0.3
+
+### Patch Changes
+
+- @object-ui/types@3.0.3
+- @object-ui/core@3.0.3
+- @object-ui/i18n@3.0.3
+
 ## 3.0.2
 
 ### Patch Changes

package/dist/SchemaRenderer.js

@@ -7,7 +7,7 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
  * LICENSE file in the root directory of this source tree.
  */
 import React, { forwardRef, useContext, useMemo, Component } from 'react';
-import { ComponentRegistry, ExpressionEvaluator, isObjectUIError, ERROR_CODES, debugLog, debugTime, debugTimeEnd, } from '@object-ui/core';
+import { ComponentRegistry, ExpressionEvaluator, isObjectUIError, ERROR_CODES, debugLog, debugTime, debugTimeEnd, DebugCollector, } from '@object-ui/core';
 import { SchemaRendererContext } from './context/SchemaRendererContext';
 import { resolveI18nLabel } from './utils/i18n';
 /**
@@ -90,10 +90,45 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             }
             newSchema.props = newProps;
         }
+        // Evaluate visibility: visible / visibleOn / hidden / hiddenOn
+        const shouldHide = (() => {
+            if (newSchema.visible !== undefined) {
+                return !evaluator.evaluateCondition(newSchema.visible);
+            }
+            if (newSchema.visibleOn !== undefined) {
+                return !evaluator.evaluateCondition(newSchema.visibleOn);
+            }
+            if (newSchema.hidden !== undefined) {
+                return evaluator.evaluateCondition(newSchema.hidden);
+            }
+            if (newSchema.hiddenOn !== undefined) {
+                return evaluator.evaluateCondition(newSchema.hiddenOn);
+            }
+            return false;
+        })();
+        if (shouldHide) {
+            newSchema._hidden = true;
+        }
+        // Evaluate disabled: disabled / disabledOn
+        const isDisabled = (() => {
+            if (newSchema.disabled !== undefined) {
+                return evaluator.evaluateCondition(newSchema.disabled);
+            }
+            if (newSchema.disabledOn !== undefined) {
+                return evaluator.evaluateCondition(newSchema.disabledOn);
+            }
+            return false;
+        })();
+        if (isDisabled) {
+            newSchema._disabled = true;
+        }
         return newSchema;
     }, [schema, dataSource]);
     if (!evaluatedSchema)
         return null;
+    // Handle visibility: if evaluated schema is hidden, render nothing
+    if (evaluatedSchema?._hidden)
+        return null;
     // If schema is just a string, render it as text
     if (typeof evaluatedSchema === 'string')
         return _jsx(_Fragment, { children: evaluatedSchema });
@@ -107,21 +142,45 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // Note: We don't forward the ref to the Component because components in the registry
     // may not support refs. The SchemaRenderer itself can still receive refs for its own use.
     // Extract schema metadata properties that should NOT be passed as React props
-    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleOn: _visibleOn, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, ...componentProps } = evaluatedSchema;
+    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleOn: _visibleOn, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, _hidden: __hidden, // stripped: internal visibility flag
+    _disabled: __disabled, // stripped: internal disabled flag
+    ...componentProps } = evaluatedSchema;
     // Extract AriaPropsSchema properties for accessibility
     const ariaProps = resolveAriaProps(evaluatedSchema);
+    // Debug-mode enhancements: extra data attributes + perf tracking
+    const isDebug = context?.debug || context?.debugFlags?.enabled;
+    const debugAttrs = {};
+    if (isDebug) {
+        debugAttrs['data-debug-type'] = evaluatedSchema.type;
+        if (evaluatedSchema.id) {
+            debugAttrs['data-debug-id'] = evaluatedSchema.id;
+        }
+    }
     debugTime(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
+    const renderStart = isDebug ? performance.now() : 0;
     const rendered = (_jsx(SchemaErrorBoundary, { componentType: evaluatedSchema.type, children: React.createElement(Component, {
             schema: evaluatedSchema,
             ...componentProps, // Spread non-metadata schema properties as props
             ...(evaluatedSchema.props || {}), // Override with explicit props if provided
             ...ariaProps, // Inject ARIA attributes from AriaPropsSchema
+            ...debugAttrs, // Debug-mode data attributes
+            disabled: __disabled || undefined,
             className: evaluatedSchema.className,
             'data-obj-id': evaluatedSchema.id,
             'data-obj-type': evaluatedSchema.type,
             ...props
         }) }));
     debugTimeEnd(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
+    // Report render perf to DebugCollector when debug mode is active
+    if (isDebug && renderStart) {
+        const durationMs = performance.now() - renderStart;
+        DebugCollector.getInstance().addPerf({
+            type: evaluatedSchema.type,
+            id: evaluatedSchema.id,
+            durationMs,
+            timestamp: Date.now(),
+        });
+    }
     return rendered;
 });
 SchemaRenderer.displayName = 'SchemaRenderer';

package/dist/context/SchemaRendererContext.d.ts

@@ -1,14 +1,17 @@
 import React from 'react';
+import type { DebugFlags } from '@object-ui/core';
 interface SchemaRendererContextType {
     dataSource: any;
     debug?: boolean;
+    debugFlags?: DebugFlags;
 }
 declare const SchemaRendererContext: React.Context<SchemaRendererContextType | null>;
 export { SchemaRendererContext };
-export declare const SchemaRendererProvider: ({ children, dataSource, debug }: {
+export declare const SchemaRendererProvider: ({ children, dataSource, debug, debugFlags, }: {
     children: React.ReactNode;
     dataSource: any;
     debug?: boolean;
+    debugFlags?: DebugFlags;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const useSchemaContext: () => SchemaRendererContextType;
 export declare const useDataScope: (path?: string) => any;

package/dist/context/SchemaRendererContext.js

@@ -2,8 +2,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo } from 'react';
 const SchemaRendererContext = createContext(null);
 export { SchemaRendererContext };
-export const SchemaRendererProvider = ({ children, dataSource, debug }) => {
-    const value = useMemo(() => ({ dataSource, debug }), [dataSource, debug]);
+export const SchemaRendererProvider = ({ children, dataSource, debug, debugFlags, }) => {
+    const value = useMemo(() => ({ dataSource, debug, debugFlags }), [dataSource, debug, debugFlags]);
     return (_jsx(SchemaRendererContext.Provider, { value: value, children: children }));
 };
 export const useSchemaContext = () => {
@@ -16,8 +16,10 @@ export const useSchemaContext = () => {
 export const useDataScope = (path) => {
     const context = useContext(SchemaRendererContext);
     const dataSource = context?.dataSource;
-    if (!dataSource || !path)
-        return dataSource;
+    if (!path)
+        return undefined;
+    if (!dataSource)
+        return undefined;
     // Simple path resolution for now. In real app might be more complex
     return path.split('.').reduce((acc, part) => acc && acc[part], dataSource);
 };

package/dist/hooks/index.d.ts

@@ -29,3 +29,6 @@ export * from './usePageTransition';
 export * from './useViewTransition';
 export * from './useETagCache';
 export * from './useSchemaPersistence';
+export * from './useGlobalUndo';
+export * from './useDebugMode';
+export * from './useActionEngine';

package/dist/hooks/index.js

@@ -29,3 +29,6 @@ export * from './usePageTransition';
 export * from './useViewTransition';
 export * from './useETagCache';
 export * from './useSchemaPersistence';
+export * from './useGlobalUndo';
+export * from './useDebugMode';
+export * from './useActionEngine';

package/dist/hooks/useActionEngine.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+import { ActionEngine, type ActionLocation, type ActionDef, type ActionContext, type ActionResult } from '@object-ui/core';
+export interface UseActionEngineOptions {
+    /** Action definitions to register */
+    actions?: ActionDef[];
+    /** Action context (record, user, etc.) */
+    context?: ActionContext;
+}
+export interface UseActionEngineReturn {
+    /** Get actions available at a specific location, sorted by priority */
+    getActionsForLocation: (location: ActionLocation) => ActionDef[];
+    /** Get actions that support bulk operations */
+    getBulkActions: () => ActionDef[];
+    /** Execute an action by name */
+    executeAction: (name: string, contextOverride?: Partial<ActionContext>) => Promise<ActionResult>;
+    /** Handle a keyboard shortcut */
+    handleShortcut: (keys: string) => Promise<ActionResult | null>;
+    /** The underlying ActionEngine instance */
+    engine: ActionEngine;
+}
+export declare function useActionEngine(options?: UseActionEngineOptions): UseActionEngineReturn;

package/dist/hooks/useActionEngine.js

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+/**
+ * useActionEngine — React hook wrapping ActionEngine for location-based action management.
+ *
+ * Provides declarative access to the ActionEngine's location filtering, bulk operations,
+ * keyboard shortcut handling, and execution pipeline from React components.
+ *
+ * @example
+ * ```tsx
+ * const { getActionsForLocation, executeAction } = useActionEngine({
+ *   actions: schema.actions,
+ *   context: { record, user },
+ * });
+ *
+ * const toolbarActions = getActionsForLocation('list_toolbar');
+ * ```
+ */
+import { useCallback, useMemo } from 'react';
+import { ActionEngine, } from '@object-ui/core';
+export function useActionEngine(options = {}) {
+    const { actions = [], context = {} } = options;
+    const engine = useMemo(() => {
+        const e = new ActionEngine(context);
+        e.registerActions(actions);
+        return e;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [JSON.stringify(actions), JSON.stringify(context)]);
+    const getActionsForLocation = useCallback((location) => engine.getActionsForLocation(location), [engine]);
+    const getBulkActions = useCallback(() => engine.getBulkActions(), [engine]);
+    const executeAction = useCallback((name, contextOverride) => engine.executeAction(name, contextOverride), [engine]);
+    const handleShortcut = useCallback((keys) => engine.handleShortcut(keys), [engine]);
+    return { getActionsForLocation, getBulkActions, executeAction, handleShortcut, engine };
+}

package/dist/hooks/useDebugMode.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+import { type DebugFlags } from '@object-ui/core';
+/**
+ * Result returned by {@link useDebugMode}.
+ */
+export interface UseDebugModeResult {
+    /** Whether debug mode is currently enabled */
+    enabled: boolean;
+    /** Fine-grained debug flags parsed from the URL */
+    flags: DebugFlags;
+    /** Toggle debug mode on/off */
+    toggle: () => void;
+    /** Explicitly set debug mode */
+    setEnabled: (value: boolean) => void;
+}
+/**
+ * Hook for managing debug mode.
+ *
+ * Automatically detects `?__debug` (and sub-flags like `?__debug_schema`)
+ * from the URL. Supports manual toggle and Ctrl+Shift+D keyboard shortcut.
+ *
+ * SSR-safe — returns disabled state when `window` is unavailable.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const debug = useDebugMode();
+ *   return (
+ *     <>
+ *       {debug.enabled && <DebugPanel flags={debug.flags} />}
+ *       <button onClick={debug.toggle}>Toggle Debug</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useDebugMode(): UseDebugModeResult;

package/dist/hooks/useDebugMode.js

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { parseDebugFlags } from '@object-ui/core';
+/**
+ * Hook for managing debug mode.
+ *
+ * Automatically detects `?__debug` (and sub-flags like `?__debug_schema`)
+ * from the URL. Supports manual toggle and Ctrl+Shift+D keyboard shortcut.
+ *
+ * SSR-safe — returns disabled state when `window` is unavailable.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const debug = useDebugMode();
+ *   return (
+ *     <>
+ *       {debug.enabled && <DebugPanel flags={debug.flags} />}
+ *       <button onClick={debug.toggle}>Toggle Debug</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export function useDebugMode() {
+    const urlFlags = useMemo(() => {
+        try {
+            return typeof window !== 'undefined'
+                ? parseDebugFlags(window.location.search)
+                : { enabled: false };
+        }
+        catch {
+            return { enabled: false };
+        }
+    }, []);
+    const [manualEnabled, setManualEnabled] = useState(null);
+    // Effective enabled: manual override wins, then URL flags
+    const enabled = manualEnabled !== null ? manualEnabled : urlFlags.enabled;
+    // Flags reflect URL-parsed flags plus effective enabled state
+    const flags = useMemo(() => ({ ...urlFlags, enabled }), [urlFlags, enabled]);
+    const toggle = useCallback(() => {
+        setManualEnabled((prev) => {
+            if (prev === null)
+                return !urlFlags.enabled;
+            return !prev;
+        });
+    }, [urlFlags.enabled]);
+    const setEnabled = useCallback((value) => {
+        setManualEnabled(value);
+    }, []);
+    // Ctrl+Shift+D keyboard shortcut
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handler = (e) => {
+            if (e.ctrlKey && e.shiftKey && e.key === 'D') {
+                e.preventDefault();
+                toggle();
+            }
+        };
+        document.addEventListener('keydown', handler);
+        return () => document.removeEventListener('keydown', handler);
+    }, [toggle]);
+    return { enabled, flags, toggle, setEnabled };
+}

package/dist/hooks/useGlobalUndo.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+import { type UndoableOperation } from '@object-ui/core';
+export interface UseGlobalUndoOptions {
+    /** DataSource to execute undo/redo operations. */
+    dataSource?: {
+        create(objectName: string, data: Record<string, unknown>): Promise<unknown>;
+        update(objectName: string, recordId: string, data: Record<string, unknown>): Promise<unknown>;
+        delete(objectName: string, recordId: string): Promise<unknown>;
+    };
+    /** Callback after successful undo. */
+    onUndo?: (op: UndoableOperation) => void;
+    /** Callback after successful redo. */
+    onRedo?: (op: UndoableOperation) => void;
+}
+/**
+ * React hook that wraps the global UndoManager for use in console components.
+ *
+ * Provides reactive undo/redo state, executes data operations through the
+ * supplied dataSource, and registers Ctrl+Z / Ctrl+Shift+Z keyboard shortcuts.
+ */
+export declare function useGlobalUndo(options?: UseGlobalUndoOptions): {
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+    canUndo: boolean;
+    canRedo: boolean;
+    undoDescription: string | undefined;
+    redoDescription: string | undefined;
+    history: UndoableOperation[];
+};

package/dist/hooks/useGlobalUndo.js

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */
+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { globalUndoManager } from '@object-ui/core';
+function getSnapshot() {
+    return {
+        canUndo: globalUndoManager.canUndo,
+        canRedo: globalUndoManager.canRedo,
+        undoDescription: globalUndoManager.peekUndo()?.description,
+        redoDescription: globalUndoManager.peekRedo()?.description,
+        history: globalUndoManager.getHistory(),
+    };
+}
+function getServerSnapshot() {
+    return { canUndo: false, canRedo: false, undoDescription: undefined, redoDescription: undefined, history: [] };
+}
+// Cache reference to avoid re-renders when nothing changed
+let cachedSnapshot = getSnapshot();
+function subscribe(callback) {
+    return globalUndoManager.subscribe(() => {
+        cachedSnapshot = getSnapshot();
+        callback();
+    });
+}
+function getCachedSnapshot() { return cachedSnapshot; }
+/**
+ * React hook that wraps the global UndoManager for use in console components.
+ *
+ * Provides reactive undo/redo state, executes data operations through the
+ * supplied dataSource, and registers Ctrl+Z / Ctrl+Shift+Z keyboard shortcuts.
+ */
+export function useGlobalUndo(options = {}) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const state = useSyncExternalStore(subscribe, getCachedSnapshot, getServerSnapshot);
+    const executeOp = useCallback(async (op, data, mode) => {
+        const ds = optionsRef.current.dataSource;
+        if (!ds)
+            return;
+        const action = mode === 'undo'
+            ? { create: 'delete', update: 'update', delete: 'create' }[op.type]
+            : op.type;
+        if (action === 'delete')
+            await ds.delete(op.objectName, op.recordId);
+        else if (action === 'update')
+            await ds.update(op.objectName, op.recordId, data);
+        else
+            await ds.create(op.objectName, data);
+    }, []);
+    const undo = useCallback(async () => {
+        const op = globalUndoManager.popUndo();
+        if (!op)
+            return;
+        await executeOp(op, op.undoData, 'undo');
+        optionsRef.current.onUndo?.(op);
+    }, [executeOp]);
+    const redo = useCallback(async () => {
+        const op = globalUndoManager.popRedo();
+        if (!op)
+            return;
+        await executeOp(op, op.redoData, 'redo');
+        optionsRef.current.onRedo?.(op);
+    }, [executeOp]);
+    // Keyboard shortcuts: Ctrl+Z (undo), Ctrl+Shift+Z (redo)
+    useEffect(() => {
+        const handler = (e) => {
+            if (!(e.ctrlKey || e.metaKey) || e.key.toLowerCase() !== 'z')
+                return;
+            e.preventDefault();
+            if (e.shiftKey) {
+                void redo();
+            }
+            else {
+                void undo();
+            }
+        };
+        window.addEventListener('keydown', handler);
+        return () => window.removeEventListener('keydown', handler);
+    }, [undo, redo]);
+    return useMemo(() => ({ ...state, undo, redo }), [state, undo, redo]);
+}

package/dist/hooks/useNavigationOverlay.d.ts

@@ -47,6 +47,8 @@ export interface NavigationOverlayState {
     width: string | number | undefined;
     /** Whether navigation is an overlay mode (drawer/modal/split/popover) */
     isOverlay: boolean;
+    /** The target view/form name from NavigationConfig */
+    view: string | undefined;
 }
 /**
  * Hook for NavigationConfig-driven navigation overlay.

package/dist/hooks/useNavigationOverlay.js

@@ -49,6 +49,7 @@ export function useNavigationOverlay(options) {
     const [selectedRecord, setSelectedRecord] = useState(null);
     const mode = navigation?.mode ?? 'page';
     const width = navigation?.width;
+    const view = navigation?.view;
     const isOverlay = mode === 'drawer' || mode === 'modal' || mode === 'split' || mode === 'popover';
     const close = useCallback(() => {
         setIsOpen(false);
@@ -68,7 +69,7 @@ export function useNavigationOverlay(options) {
         if (!navigation) {
             const recordId = record._id || record.id;
             if (onNavigate && recordId != null) {
-                onNavigate(recordId, 'view');
+                onNavigate(recordId, view ?? 'view');
             }
             return;
         }
@@ -76,10 +77,15 @@ export function useNavigationOverlay(options) {
         if (mode === 'none' || navigation.preventNavigation) {
             return;
         }
-        // new_window / openNewTab — open in new browser tab
+        // new_window / openNewTab — delegate to onNavigate when available, else open directly
         if (mode === 'new_window' || navigation.openNewTab) {
             const recordId = record._id || record.id;
-            const url = objectName ? `/${objectName}/${recordId}` : `/${recordId}`;
+            if (onNavigate && recordId != null) {
+                onNavigate(recordId, 'new_window');
+                return;
+            }
+            const viewPath = view ? `/${view}` : '';
+            const url = objectName ? `/${objectName}/${recordId}${viewPath}` : `/${recordId}${viewPath}`;
             window.open(url, '_blank');
             return;
         }
@@ -87,7 +93,7 @@ export function useNavigationOverlay(options) {
         if (mode === 'page') {
             const recordId = record._id || record.id;
             if (onNavigate && recordId != null) {
-                onNavigate(recordId, 'view');
+                onNavigate(recordId, view ?? 'view');
             }
             return;
         }
@@ -107,6 +113,7 @@ export function useNavigationOverlay(options) {
         setIsOpen,
         handleClick,
         width,
+        view,
         isOverlay,
-    }), [isOpen, selectedRecord, mode, close, open, handleClick, width, isOverlay]);
+    }), [isOpen, selectedRecord, mode, close, open, handleClick, width, view, isOverlay]);
 }

package/dist/index.d.ts

@@ -10,4 +10,6 @@ export * from './hooks';
 export * from './context';
 export * from './components/form';
 export * from './LazyPluginLoader';
-export { I18nProvider, useObjectTranslation, useI18nContext, createI18n, getDirection, getAvailableLanguages, formatDate, formatDateTime, formatRelativeTime, formatCurrency, formatNumber, type I18nConfig, type I18nProviderProps, type TranslationKeys, type DateFormatOptions, type CurrencyFormatOptions, type NumberFormatOptions, } from '@object-ui/i18n';
+export * from './spec-bridge';
+export { resolveI18nLabel } from './utils/i18n';
+export { I18nProvider, useObjectTranslation, useObjectLabel, useSafeFieldLabel, useI18nContext, createI18n, getDirection, getAvailableLanguages, formatDate, formatDateTime, formatRelativeTime, formatCurrency, formatNumber, type I18nConfig, type I18nProviderProps, type TranslationKeys, type DateFormatOptions, type CurrencyFormatOptions, type NumberFormatOptions, } from '@object-ui/i18n';

package/dist/index.js

@@ -10,5 +10,8 @@ export * from './hooks'; // will be empty for now
 export * from './context'; // will be empty for now
 export * from './components/form';
 export * from './LazyPluginLoader';
+export * from './spec-bridge';
+// i18n utilities
+export { resolveI18nLabel } from './utils/i18n';
 // Built-in i18n support
-export { I18nProvider, useObjectTranslation, useI18nContext, createI18n, getDirection, getAvailableLanguages, formatDate, formatDateTime, formatRelativeTime, formatCurrency, formatNumber, } from '@object-ui/i18n';
+export { I18nProvider, useObjectTranslation, useObjectLabel, useSafeFieldLabel, useI18nContext, createI18n, getDirection, getAvailableLanguages, formatDate, formatDateTime, formatRelativeTime, formatCurrency, formatNumber, } from '@object-ui/i18n';

package/dist/spec-bridge/SpecBridge.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+import type { SchemaNode } from '@object-ui/core';
+import type { BridgeContext, BridgeFn } from './types';
+export declare class SpecBridge {
+    private bridges;
+    private context;
+    constructor(context?: BridgeContext);
+    register(specType: string, bridge: BridgeFn): void;
+    /** Transform a spec schema into a SchemaNode tree */
+    transform(specType: string, spec: any): SchemaNode;
+    /** Transform a ListView spec */
+    transformListView(spec: any): SchemaNode;
+    /** Transform a FormView spec */
+    transformFormView(spec: any): SchemaNode;
+    /** Transform a Page spec */
+    transformPage(spec: any): SchemaNode;
+    /** Transform a Dashboard spec */
+    transformDashboard(spec: any): SchemaNode;
+    updateContext(ctx: Partial<BridgeContext>): void;
+}

package/dist/spec-bridge/SpecBridge.js

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+import { bridgeListView } from './bridges/list-view';
+import { bridgeFormView } from './bridges/form-view';
+import { bridgePage } from './bridges/page';
+import { bridgeDashboard } from './bridges/dashboard';
+export class SpecBridge {
+    constructor(context = {}) {
+        Object.defineProperty(this, "bridges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.register('list', bridgeListView);
+        this.register('form', bridgeFormView);
+        this.register('page', bridgePage);
+        this.register('dashboard', bridgeDashboard);
+    }
+    register(specType, bridge) {
+        this.bridges.set(specType, bridge);
+    }
+    /** Transform a spec schema into a SchemaNode tree */
+    transform(specType, spec) {
+        const bridge = this.bridges.get(specType);
+        if (!bridge) {
+            throw new Error(`No bridge registered for spec type: ${specType}`);
+        }
+        return bridge(spec, this.context);
+    }
+    /** Transform a ListView spec */
+    transformListView(spec) {
+        return this.transform('list', spec);
+    }
+    /** Transform a FormView spec */
+    transformFormView(spec) {
+        return this.transform('form', spec);
+    }
+    /** Transform a Page spec */
+    transformPage(spec) {
+        return this.transform('page', spec);
+    }
+    /** Transform a Dashboard spec */
+    transformDashboard(spec) {
+        return this.transform('dashboard', spec);
+    }
+    updateContext(ctx) {
+        this.context = { ...this.context, ...ctx };
+    }
+}