@object-ui/react 13.2.0 → 14.0.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @object-ui/react
 
+## 14.0.0
+
+### Minor Changes
+
+- 86c69c3: ADR-0089: read the canonical `visibleWhen` conditional-visibility predicate in the form + page renderers.
+
+  `@objectstack/spec` now unifies conditional visibility under a single canonical key, `visibleWhen`, and folds the deprecated `visibleOn` (view form) / `visibility` (page component) aliases into it at parse. This updates ObjectUI to read the canonical key:
+
+  - **Page renderer** (`SchemaRenderer`) — evaluates `visibleWhen` first (show-when-truthy), then the deprecated `visibleOn` / `visibility` as a defensive read for raw / un-normalized metadata. `visibleWhen` is stripped from DOM props.
+  - **Spec→node bridges** — the page bridge maps a component's `visibleWhen ?? visibility` onto the node's canonical `visibleWhen`; the form-view bridge maps a field's `visibleWhen ?? visibleOn` onto the ObjectForm view-level predicate slot.
+  - **Form renderers** — the `@object-ui/react` `FormRenderer` prefers `visibleWhen` over the `visibleOn` alias. (`ObjectForm`/`form.tsx` already evaluated `visibleWhen`.)
+  - **Types** — the component base schema (`BaseSchema` / `base.zod`) gains the canonical `visibleWhen`; `visibleOn` is marked `@deprecated`.
+
+  Fully back-compat: existing `visibleOn` / `visibility` metadata keeps working through the alias reads.
+
+### Patch Changes
+
+- Updated dependencies [443360a]
+- Updated dependencies [c70bca7]
+- Updated dependencies [86c69c3]
+- Updated dependencies [05e56ca]
+- Updated dependencies [5971cc4]
+- Updated dependencies [6a74160]
+  - @object-ui/core@14.0.0
+  - @object-ui/i18n@14.0.0
+  - @object-ui/types@14.0.0
+  - @object-ui/data-objectstack@14.0.0
+
 ## 13.2.0
 
 ### Patch Changes

package/dist/SchemaRenderer.js

@@ -216,18 +216,25 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             }
             newSchema.props = newProps;
         }
-        // Evaluate visibility: visible / visibleOn / visibility / hidden / hiddenOn
+        // Evaluate visibility: visible / visibleWhen / visibleOn / visibility / hidden / hiddenOn
         const shouldHide = (() => {
             if (newSchema.visible !== undefined) {
                 return !evaluator.evaluateCondition(newSchema.visible);
             }
+            // `visibleWhen` is the single canonical conditional-visibility predicate
+            // across every layer since ADR-0089 (show-when-truthy). The spec folds the
+            // deprecated `visibleOn` (view) / `visibility` (page) aliases into it at
+            // parse, so it is checked FIRST; the aliases below remain as a defensive
+            // read for any raw / un-normalized metadata reaching the renderer.
+            if (newSchema.visibleWhen !== undefined) {
+                return !evaluator.evaluateCondition(newSchema.visibleWhen);
+            }
+            // @deprecated ADR-0089 → `visibleWhen`.
             if (newSchema.visibleOn !== undefined) {
                 return !evaluator.evaluateCondition(newSchema.visibleOn);
             }
-            // `visibility` is the spec-canonical predicate (PageComponentSchema.visibility,
-            // an ExpressionInput) — show-when-truthy, same semantics as `visibleOn`. The
-            // spec→node bridge preserves it verbatim on the node, so this is where it
-            // finally gates rendering (previously it was inert and leaked as a DOM prop).
+            // @deprecated ADR-0089 → `visibleWhen` (was PageComponentSchema.visibility,
+            // an ExpressionInput) — show-when-truthy, same semantics as `visibleOn`.
             if (newSchema.visibility !== undefined) {
                 return !evaluator.evaluateCondition(newSchema.visibility);
             }
@@ -291,7 +298,7 @@ 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, visibility: _visibility, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, _hidden: __hidden, // stripped: internal visibility flag
+    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleWhen: _visibleWhen, visibleOn: _visibleOn, visibility: _visibility, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, _hidden: __hidden, // stripped: internal visibility flag
     _disabled: __disabled, // stripped: internal disabled flag
     responsiveStyles: _responsiveStyles, // stripped: compiled to scoped CSS, not a DOM prop
     ...componentProps } = evaluatedSchema;

package/dist/components/form/FormRenderer.js

@@ -69,11 +69,14 @@ function evaluateFieldVisibility(fieldConfig, formValues) {
     if (fieldConfig.hidden) {
         return false;
     }
-    // Evaluate visibleOn expression
-    if (fieldConfig.visibleOn) {
+    // Evaluate the conditional-visibility predicate. `visibleWhen` is canonical
+    // (ADR-0089); `visibleOn` is the deprecated alias, kept as a fallback for raw
+    // / un-normalized metadata.
+    const visiblePredicate = fieldConfig.visibleWhen ?? fieldConfig.visibleOn;
+    if (visiblePredicate) {
         try {
             const evaluator = new ExpressionEvaluator({ data: formValues, form: formValues });
-            return evaluator.evaluateCondition(fieldConfig.visibleOn);
+            return evaluator.evaluateCondition(visiblePredicate);
         }
         catch {
             // On error, default to visible
@@ -99,7 +102,7 @@ const FormSectionRenderer = ({ section, methods, disabled = false, }) => {
         return section.fields.some((field) => {
             if (typeof field === 'string')
                 return false;
-            return !!field.dependsOn || !!field.visibleOn;
+            return !!field.dependsOn || !!field.visibleWhen || !!field.visibleOn;
         });
     }, [section.fields]);
     // Watch form values for conditional field evaluation

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

@@ -17,6 +17,9 @@ interface FormField {
     colSpan?: number;
     widget?: string;
     dependsOn?: string[];
+    /** Canonical conditional-visibility predicate (ADR-0089). */
+    visibleWhen?: string;
+    /** @deprecated ADR-0089 → `visibleWhen`. */
     visibleOn?: string;
 }
 interface FormSection {

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

@@ -26,8 +26,13 @@ function mapField(field) {
         mapped.widget = field.widget;
     if (field.dependsOn)
         mapped.dependsOn = field.dependsOn;
-    if (field.visibleOn)
-        mapped.visibleOn = field.visibleOn;
+    // ADR-0089: `visibleWhen` is the canonical view-form-field visibility predicate
+    // (the spec folds the deprecated `visibleOn` into it at parse). Prefer it and
+    // fall back to `visibleOn` for raw / un-normalized metadata. The ObjectForm
+    // renderer reads this view-level predicate from the node's `visibleOn` slot.
+    const visiblePredicate = field.visibleWhen ?? field.visibleOn;
+    if (visiblePredicate)
+        mapped.visibleOn = visiblePredicate;
     return mapped;
 }
 function mapSection(section) {

package/dist/spec-bridge/bridges/page.d.ts

@@ -15,6 +15,9 @@ interface PageComponent {
     style?: Record<string, any>;
     responsiveStyles?: Record<string, any>;
     className?: string;
+    /** Canonical conditional-visibility predicate (ADR-0089). */
+    visibleWhen?: string;
+    /** @deprecated ADR-0089 → `visibleWhen`. */
     visibility?: string;
     dataSource?: any;
     responsive?: any;

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

@@ -38,8 +38,13 @@ function mapComponent(component) {
     }
     if (component.events)
         node.events = component.events;
-    if (component.visibility)
-        node.visibility = component.visibility;
+    // ADR-0089: `visibleWhen` is the canonical conditional-visibility predicate;
+    // the spec folds the deprecated `visibility` alias into it at parse, so prefer
+    // it and fall back to `visibility` for raw / un-normalized metadata. SchemaRenderer
+    // reads `visibleWhen` first (show-when-truthy).
+    const visiblePredicate = component.visibleWhen ?? component.visibility;
+    if (visiblePredicate)
+        node.visibleWhen = visiblePredicate;
     if (component.dataSource)
         node.dataSource = component.dataSource;
     if (component.responsive)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/react",
-  "version": "13.2.0",
+  "version": "14.0.0",
   "type": "module",
   "license": "MIT",
   "description": "React bindings and SchemaRenderer component for Object UI",
@@ -24,12 +24,12 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "^14.3.0",
+    "@objectstack/spec": "^14.6.0",
     "react-hook-form": "^7.81.0",
-    "@object-ui/core": "13.2.0",
-    "@object-ui/data-objectstack": "13.2.0",
-    "@object-ui/i18n": "13.2.0",
-    "@object-ui/types": "13.2.0"
+    "@object-ui/core": "14.0.0",
+    "@object-ui/data-objectstack": "14.0.0",
+    "@object-ui/i18n": "14.0.0",
+    "@object-ui/types": "14.0.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",