@object-ui/react 6.2.1 → 6.2.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @object-ui/react
 
+## 6.2.2
+
+### Patch Changes
+
+- a66f788: fix(react): preserve `data-obj-schema-invalid` flag across re-renders
+
+  `SchemaRenderer` runs a post-mount `forceUpdate` to pick up lazy plugin
+  registrations. The dev-mode validator was deduping via a `WeakSet` that
+  always returned `valid: true` on the second call, which stripped the
+  `data-obj-schema-invalid` attribute on the immediate re-render. The
+  result and the "warn-once" tracking are now stored separately: a
+  `WeakMap` caches the validation outcome (so the visual flag is stable),
+  while a `WeakSet` continues to dedupe `console.warn` output.
+  - @object-ui/types@6.2.2
+  - @object-ui/core@6.2.2
+  - @object-ui/i18n@6.2.2
+  - @object-ui/data-objectstack@6.2.2
+
 ## 6.2.1
 
 ### Patch Changes

package/dist/SchemaRenderer.js

@@ -31,33 +31,44 @@ const __DEV__ = (() => {
         return true;
     }
 })();
-const _validatedSchemas = typeof WeakSet !== 'undefined' ? new WeakSet() : { add() { }, has() { return false; } };
+const _validationCache = typeof WeakMap !== 'undefined'
+    ? new WeakMap()
+    : { set() { }, get() { return undefined; }, has() { return false; } };
+const _warnedSchemas = typeof WeakSet !== 'undefined' ? new WeakSet() : { add() { }, has() { return false; } };
 function validateSchemaOnce(schema) {
     if (!__DEV__ || !schema || typeof schema !== 'object') {
         return { valid: true, messages: [] };
     }
-    if (_validatedSchemas.has(schema)) {
-        // We don't cache the result intentionally — once a schema object has
-        // been logged, we don't re-log on every re-render. Visual invalid flag
-        // still derives from the structural presence of required fields below.
-        return { valid: true, messages: [] };
+    // Return cached result so re-renders (and the post-mount forceUpdate that
+    // runs to pick up lazy plugin registrations) preserve the invalid flag.
+    // Dedup of the console.warn is handled separately via _warnedSchemas.
+    const cached = _validationCache.get(schema);
+    if (cached) {
+        return cached;
     }
-    _validatedSchemas.add(schema);
+    let entry = { valid: true, messages: [] };
     try {
         const result = validateSchema(schema);
         if (!result.valid) {
             const msgs = result.errors.map(e => `${e.path}: ${e.message}`);
-            // eslint-disable-next-line no-console
-            console.warn('[ObjectUI] Invalid schema detected:\n' + msgs.join('\n'), schema);
-            return { valid: false, messages: msgs };
+            entry = { valid: false, messages: msgs };
+            if (!_warnedSchemas.has(schema)) {
+                _warnedSchemas.add(schema);
+                // eslint-disable-next-line no-console
+                console.warn('[ObjectUI] Invalid schema detected:\n' + msgs.join('\n'), schema);
+            }
         }
     }
     catch (err) {
         // Validator itself failed — surface but don't crash render.
-        // eslint-disable-next-line no-console
-        console.warn('[ObjectUI] Schema validator threw:', err);
+        if (!_warnedSchemas.has(schema)) {
+            _warnedSchemas.add(schema);
+            // eslint-disable-next-line no-console
+            console.warn('[ObjectUI] Schema validator threw:', err);
+        }
     }
-    return { valid: true, messages: [] };
+    _validationCache.set(schema, entry);
+    return entry;
 }
 /**
  * Extract AriaPropsSchema properties from a schema node and convert
@@ -129,7 +140,16 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // Re-render trigger when the global ComponentRegistry mutates (e.g. a
     // lazy-loaded plugin finishes registering its components).
     const [, forceUpdate] = useReducer((n) => n + 1, 0);
-    useEffect(() => ComponentRegistry.subscribe(forceUpdate), []);
+    useEffect(() => {
+        const unsubscribe = ComponentRegistry.subscribe(forceUpdate);
+        // Recheck after mount: if the lazy plugin finished registering between
+        // the first render and this effect (e.g. its module was already cached so
+        // notify() fired synchronously before subscribe()), we'd otherwise stay
+        // stuck on the "Loading…" fallback forever. A one-shot forceUpdate gives
+        // the next render a fresh look at the registry.
+        forceUpdate();
+        return unsubscribe;
+    }, []);
     const [lazyError, setLazyError] = useState(null);
     // Evaluate schema expressions against the data source
     const evaluatedSchema = useMemo(() => {

package/package.json

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