@object-ui/react 6.0.4 → 6.2.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @object-ui/react
 
+## 6.2.0
+
+### Patch Changes
+
+- Updated dependencies [fe3c1d3]
+- Updated dependencies [ec8dcde]
+  - @object-ui/data-objectstack@6.2.0
+  - @object-ui/types@6.2.0
+  - @object-ui/core@6.2.0
+  - @object-ui/i18n@6.2.0
+
+## 6.1.0
+
+### Patch Changes
+
+- Updated dependencies [991b62d]
+  - @object-ui/core@6.1.0
+  - @object-ui/types@6.1.0
+  - @object-ui/data-objectstack@6.1.0
+  - @object-ui/i18n@6.1.0
+
 ## 6.0.4
 
 ### Patch Changes

package/dist/hooks/useExpression.d.ts

@@ -5,6 +5,25 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+import { type ReactNode } from 'react';
+/**
+ * Provider for the global predicate scope. Wraps children so any
+ * descendant `useCondition` / `useExpression` call has access to
+ * top-level variables (e.g. `features.multiOrgEnabled`).
+ *
+ * Most consumers should not use this directly — the app-shell's
+ * `ExpressionProvider` already feeds it. It's exported for hosts that
+ * want a custom shell.
+ */
+export declare function PredicateScopeProvider({ scope, children, }: {
+    scope: Record<string, any>;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<Record<string, any>>>;
+/**
+ * Read the current global predicate scope. Returns an empty object when
+ * no provider is mounted.
+ */
+export declare function usePredicateScope(): Record<string, any>;
 /**
  * Normalize a schema-supplied predicate (`visible` / `enabled` / `disabled` /
  * `hidden`) into the `${expr}` template form expected by `useCondition`.

package/dist/hooks/useExpression.js

@@ -5,8 +5,39 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { useMemo } from 'react';
+import { createContext, createElement, useContext, useMemo } from 'react';
 import { ExpressionEvaluator } from '@object-ui/core';
+/**
+ * Global predicate scope — populated by host shells (e.g. app-shell's
+ * `ExpressionProvider`) so renderers like action buttons can resolve
+ * deployment-level flags (`features`, `user`, `app`, …) without needing
+ * to import the host shell directly.
+ *
+ * `useCondition` / `useExpression` merge this scope under the
+ * locally-passed `context`, so per-row `record` overrides still win.
+ * Defaults to an empty object so components used outside a provider
+ * keep behaving exactly as before.
+ */
+const PredicateScopeContext = createContext({});
+/**
+ * Provider for the global predicate scope. Wraps children so any
+ * descendant `useCondition` / `useExpression` call has access to
+ * top-level variables (e.g. `features.multiOrgEnabled`).
+ *
+ * Most consumers should not use this directly — the app-shell's
+ * `ExpressionProvider` already feeds it. It's exported for hosts that
+ * want a custom shell.
+ */
+export function PredicateScopeProvider({ scope, children, }) {
+    return createElement(PredicateScopeContext.Provider, { value: scope }, children);
+}
+/**
+ * Read the current global predicate scope. Returns an empty object when
+ * no provider is mounted.
+ */
+export function usePredicateScope() {
+    return useContext(PredicateScopeContext);
+}
 /**
  * Normalize a schema-supplied predicate (`visible` / `enabled` / `disabled` /
  * `hidden`) into the `${expr}` template form expected by `useCondition`.
@@ -46,11 +77,14 @@ export function toPredicateInput(value) {
  * ```
  */
 export function useExpression(expression, context = {}) {
+    const scope = usePredicateScope();
     // We evaluate directly without caching the evaluator to avoid issues with context changes
     return useMemo(() => {
-        const evaluator = new ExpressionEvaluator(context);
+        // Merge global scope under the local context — local wins so per-row
+        // `record` overrides still take precedence over `features` etc.
+        const evaluator = new ExpressionEvaluator({ ...scope, ...context });
         return evaluator.evaluate(expression);
-    }, [expression, context]);
+    }, [expression, context, scope]);
 }
 /**
  * Hook for evaluating conditional expressions
@@ -62,9 +96,10 @@ export function useExpression(expression, context = {}) {
  * ```
  */
 export function useCondition(condition, context = {}) {
+    const scope = usePredicateScope();
     // We evaluate directly without caching the evaluator to avoid issues with context changes
     return useMemo(() => {
-        const evaluator = new ExpressionEvaluator(context);
+        const evaluator = new ExpressionEvaluator({ ...scope, ...context });
         return evaluator.evaluateCondition(condition);
-    }, [condition, context]);
+    }, [condition, context, scope]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/react",
-  "version": "6.0.4",
+  "version": "6.2.0",
   "type": "module",
   "license": "MIT",
   "description": "React bindings and SchemaRenderer component for Object UI",
@@ -24,19 +24,19 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "^5.2.0",
+    "@objectstack/spec": "^6.7.1",
     "react-hook-form": "^7.76.1",
-    "@object-ui/core": "6.0.4",
-    "@object-ui/data-objectstack": "6.0.4",
-    "@object-ui/i18n": "6.0.4",
-    "@object-ui/types": "6.0.4"
+    "@object-ui/core": "6.2.0",
+    "@object-ui/data-objectstack": "6.2.0",
+    "@object-ui/i18n": "6.2.0",
+    "@object-ui/types": "6.2.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
-    "@types/react": "19.2.14",
+    "@types/react": "19.2.15",
     "@types/react-dom": "19.2.3",
     "typescript": "^6.0.3"
   },