@object-ui/core 3.3.1 → 3.3.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @object-ui/core
 
+## 3.3.2
+
+### Patch Changes
+
+- @object-ui/types@3.3.2
+
 ## 3.3.1
 
 ### Patch Changes

package/dist/registry/Registry.d.ts

@@ -55,8 +55,23 @@ export type ComponentConfig<T = any> = ComponentMeta & {
     type: string;
     component: ComponentRenderer<T>;
 };
+/**
+ * Lazy loader function used by `Registry.registerLazy`. The loader is invoked
+ * the first time a missing component type is requested through `getAsync`/the
+ * SchemaRenderer fallback path, and is expected to perform a dynamic
+ * `import()` of a plugin module whose top-level side-effects call
+ * `register()` for that type.
+ */
+export type LazyComponentLoader = () => Promise<unknown>;
 export declare class Registry<T = any> {
     private components;
+    private lazyEntries;
+    /**
+     * Notifies subscribers that the registry has changed (new components
+     * registered). Used by SchemaRenderer to re-render after a lazy plugin
+     * load completes.
+     */
+    private listeners;
     /**
      * Register a component with optional namespace support.
      * If namespace is provided in meta, the component will be registered as "namespace:type".
@@ -76,6 +91,38 @@ export declare class Registry<T = any> {
      * // Accessible as 'button'
      */
     register(type: string, component: ComponentRenderer<T>, meta?: ComponentMeta): void;
+    /**
+     * Register a lazy-loaded component. The `loader` is a function returning a
+     * dynamic `import()` whose target module performs `register()` calls for
+     * the given `type` as a top-level side effect.
+     *
+     * The loader will be invoked the first time `loadLazy(type)` is called (or
+     * the first time the SchemaRenderer encounters an unknown component that
+     * matches a registered lazy type). Subsequent registrations are idempotent.
+     *
+     * @example
+     * ComponentRegistry.registerLazy('object-map', () => import('@object-ui/plugin-map'), { namespace: 'plugin-map' });
+     */
+    registerLazy(type: string, loader: LazyComponentLoader, meta?: ComponentMeta): void;
+    /**
+     * Returns true if `type` (or its namespaced form) has a registered lazy
+     * loader awaiting first use.
+     */
+    hasLazy(type: string, namespace?: string): boolean;
+    /**
+     * Trigger the lazy loader for `type`, if any. Resolves once the loader
+     * completes (whether or not the loaded module actually registered the
+     * expected type — caller should re-check the registry afterwards).
+     * Returns `undefined` if no lazy entry matches.
+     */
+    loadLazy(type: string, namespace?: string): Promise<unknown> | undefined;
+    /**
+     * Subscribe to registry changes (component registrations). Returns an
+     * unsubscribe function. Used by React renderers to re-render when a
+     * lazy-loaded plugin finishes registering its components.
+     */
+    subscribe(listener: () => void): () => void;
+    private notify;
     /**
      * Get a component by type. Supports both namespaced and non-namespaced lookups.
      *

package/dist/registry/Registry.js

@@ -13,6 +13,23 @@ export class Registry {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "lazyEntries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /**
+         * Notifies subscribers that the registry has changed (new components
+         * registered). Used by SchemaRenderer to re-render after a lazy plugin
+         * load completes.
+         */
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
     }
     /**
      * Register a component with optional namespace support.
@@ -65,6 +82,81 @@ export class Registry {
                 ...meta
             });
         }
+        // A real component is now available — clear any matching lazy stub so we
+        // don't keep holding the loader reference, and notify subscribers.
+        this.lazyEntries.delete(fullType);
+        this.lazyEntries.delete(type);
+        this.notify();
+    }
+    /**
+     * Register a lazy-loaded component. The `loader` is a function returning a
+     * dynamic `import()` whose target module performs `register()` calls for
+     * the given `type` as a top-level side effect.
+     *
+     * The loader will be invoked the first time `loadLazy(type)` is called (or
+     * the first time the SchemaRenderer encounters an unknown component that
+     * matches a registered lazy type). Subsequent registrations are idempotent.
+     *
+     * @example
+     * ComponentRegistry.registerLazy('object-map', () => import('@object-ui/plugin-map'), { namespace: 'plugin-map' });
+     */
+    registerLazy(type, loader, meta) {
+        const fullType = meta?.namespace ? `${meta.namespace}:${type}` : type;
+        const entry = { loader, meta };
+        this.lazyEntries.set(fullType, entry);
+        if (meta?.namespace && !meta?.skipFallback) {
+            this.lazyEntries.set(type, entry);
+        }
+    }
+    /**
+     * Returns true if `type` (or its namespaced form) has a registered lazy
+     * loader awaiting first use.
+     */
+    hasLazy(type, namespace) {
+        if (namespace)
+            return this.lazyEntries.has(`${namespace}:${type}`);
+        return this.lazyEntries.has(type);
+    }
+    /**
+     * Trigger the lazy loader for `type`, if any. Resolves once the loader
+     * completes (whether or not the loaded module actually registered the
+     * expected type — caller should re-check the registry afterwards).
+     * Returns `undefined` if no lazy entry matches.
+     */
+    loadLazy(type, namespace) {
+        const key = namespace ? `${namespace}:${type}` : type;
+        const entry = this.lazyEntries.get(key);
+        if (!entry)
+            return undefined;
+        if (!entry.pending) {
+            entry.pending = entry.loader().catch((err) => {
+                // Allow retries on failure by clearing the cached promise.
+                entry.pending = undefined;
+                throw err;
+            });
+        }
+        return entry.pending;
+    }
+    /**
+     * Subscribe to registry changes (component registrations). Returns an
+     * unsubscribe function. Used by React renderers to re-render when a
+     * lazy-loaded plugin finishes registering its components.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            try {
+                listener();
+            }
+            catch (err) {
+                console.error('[Registry] listener error', err);
+            }
+        }
     }
     /**
      * Get a component by type. Supports both namespaced and non-namespaced lookups.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/core",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -28,7 +28,7 @@
     "@objectstack/spec": "^4.0.4",
     "lodash": "^4.18.1",
     "zod": "^4.4.3",
-    "@object-ui/types": "3.3.1"
+    "@object-ui/types": "3.3.2"
   },
   "devDependencies": {
     "typescript": "^6.0.3",