@genesislcap/foundation-layout 14.354.1 → 14.354.2-FUI-2341-3.2

package/dist/esm/main/layout-main.js

@@ -8,6 +8,7 @@ import { FoundationElement } from '@microsoft/fast-foundation';
 import { globalDraggingStyles, glVisualConfig, LAYOUT_ICONS, layoutStyles } from '../styles';
 import { AUTOSAVE_KEY, componentType, DEFAULT_RELOAD_BUFFER, getMissingArrayItems, instanceContainer, LAYOUT_POPOUT_CONTAINER_CLASS, LAYOUT_POPOUT_CONTROL_KEY, LayoutEmitEvents, LayoutReceiveEvents, regionConveter, } from '../utils/';
 import { LayoutRegistrationError, LayoutUsageError } from '../utils/error';
+import { getFactory } from '../utils/factory-registry';
 import { logger } from '../utils/logger';
 export { layoutStyles } from '../styles';
 /*
@@ -248,6 +249,11 @@ export class FoundationLayout extends FoundationElement {
                 return;
             const orderedStates = [...items].map((item) => { var _b; return (_b = item.getCurrentState) === null || _b === void 0 ? void 0 : _b.call(item); });
             const componentInstanceContainer = items[0][instanceContainer];
+            // Add safety check for factory-based components
+            if (!componentInstanceContainer) {
+                logger.warn('Component instance container not found for items:', items);
+                return;
+            }
             // known use of deprecated API, but there is no other way of implementing it and we control
             // the underlying library anyway
             componentInstanceContainer.container.setState({
@@ -528,28 +534,70 @@ export class FoundationLayout extends FoundationElement {
     }
     /**
      * @public
-     * Register a collection of `Element` and associate them with an `ID` with the layout system for later use.
+     * Register a collection of `Element` or a factory function and associate them with an `ID` with the layout system for later use.
      * @remarks
-     * You would use this to register elements that you later want to load when using {@link FoundationLayout.loadLayout}.
+     * You can register either an array of elements or a factory function.
+     *
+     * **Element registration**: Use this to register elements that you later want to load when using {@link FoundationLayout.loadLayout}.
      * Use {@link FoundationLayout.layoutRequiredRegistrations} to see what components need to be registered for a certain config
      * and then register them using this function before calling {@link FoundationLayout.loadLayout}.
+     * When registering an element it is moved by reference into the internals of the layout, so if you pass elements already in the DOM then they will disappear.
+     * If you want to avoid this you can pass copies using `element.cloneNode(true)`.
      *
-     * When registering an element it is moved by reference into the internals of the layout, so if you pass elements already in the DOM then they will disappear. If you want to avoid this you can pass copies using `element.cloneNode(true)`.
+     * **Factory registration**: This is the recommended approach for framework-rendered components (React, Angular, Vue, etc.)
+     * because it allows each layout instance to create a fresh component rather than cloning existing
+     * DOM elements (which loses event listeners and framework bindings).
+     * The factory function will be called each time a new instance of the component is needed. It receives
+     * a container element and should render the component into it. Optionally, it can return a cleanup
+     * function that will be called when the component is removed from the layout.
      *
      * @param registration - string of the registration ID
-     * @param elements - Elements[] containing the reference to the elements to register for later usage
+     * @param elementsOrFactory - Either Elements[] containing the reference to the elements to register, or a ComponentFactory function
      * @throws {@link LayoutUsageError} if you attempt to add an item before the layout has been initialised.
      * @throws {@link LayoutRegistrationError} if you attempt to use a `registration` name which is already in use (declarative html API and JavaScript API registrations use the same "pool" of registration names).
      * @returns - string defining the name of the registered item with the layout system (config.id if set).
+     *
+     * @example
+     * Element registration:
+     * ```typescript
+     * const div = document.createElement('div');
+     * div.innerHTML = '<h1>Hello</h1>';
+     * layout.registerItem('my-element', [div]);
+     * ```
+     *
+     * @example
+     * Factory registration (React):
+     * ```typescript
+     * layout.registerItem('text-field', (container) => {
+     *   const root = createRoot(container);
+     *   root.render(<TextFieldComponent />);
+     *   return () => root.unmount();
+     * });
+     * ```
      */
-    registerItem(registration, elements) {
+    registerItem(registration, elementsOrFactory) {
         if (!this.layout.isInitialised) {
             throw new LayoutUsageError('Cannot add item via JS API until initialised');
         }
-        return this.cacheElementsAndRegister({
-            elements: elements,
-            id: registration,
-        });
+        // Check if a factory is already registered with this name
+        const existingFactory = getFactory(registration);
+        if (existingFactory) {
+            throw new LayoutRegistrationError(`Registration "${registration}" already has a factory registered via registerFactory(). ` +
+                `Cannot register the same name via the JavaScript API. ` +
+                `Use a different registration name or unregister the factory first.`);
+        }
+        if (typeof elementsOrFactory === 'function') {
+            return this.cacheElementsAndRegister({
+                factory: elementsOrFactory,
+                id: registration,
+            });
+        }
+        else {
+            return this.cacheElementsAndRegister({
+                elements: elementsOrFactory,
+                id: registration,
+            });
+        }
     }
     /**
      * Internal APIs
@@ -610,12 +658,13 @@ export class FoundationLayout extends FoundationElement {
     /**
      * Registers a function with golden layout to create a pane
      * @param elements - Elements[] to add to new new pane
+     * @param factory - ComponentFactory function to create component instances
      * @param id - optional string which is used to register the new function with golden layout. Defaults to sequentially setting the IDs for default items
      * @returns - string which is the registered ID
      * @throws - {@link LayoutRegistrationError} if the id is already in use
      * @internal
      */
-    cacheElementsAndRegister({ elements, id }) {
+    cacheElementsAndRegister({ elements, factory, id }) {
         const reg = id || `${(this.registeredComponents += 1)}`;
         if (this.layout.getRegisteredComponentTypeNames().includes(reg)) {
             throw new LayoutRegistrationError(`Cannot register item with already registered name: '${reg}'`);
@@ -632,45 +681,93 @@ export class FoundationLayout extends FoundationElement {
          *
          * As part of creating each instance we attach a reference to the instance container which is used
          * to be able to optionally save state, and any state which has been saved we apply to the component.
+         *
+         * For factory functions:
+         * The factory is called for each new instance instead of cloning. This preserves event listeners
+         * and framework bindings that would be lost during cloning.
          */
         const registrationFunction = (() => {
-            // Use appendChild to consume the elements and save them in the master copy
-            const masterCopy = document.createDocumentFragment();
-            masterCopy[layoutCacheDocument] = true;
-            elements.forEach((e) => masterCopy.appendChild(e));
-            const instances = new Map();
-            return (container, state) => {
-                var _b;
-                // If this is a new instance then assign it uuid instance
-                if (!(state === null || state === void 0 ? void 0 : state['instance'])) {
-                    state['instance'] = this.uuid.createId();
-                }
-                container.state['instance'] = state['instance'];
-                container.state['originalTitle'] = (_b = state['originalTitle']) !== null && _b !== void 0 ? _b : container.title;
-                // If this is a new instance then copy the master copy into the instances map
-                // this is then the instance that is recalled for this version each time
-                // the key point is "cloneNode" which makes a copy at this point
-                if (!instances.has(state === null || state === void 0 ? void 0 : state['instance'])) {
-                    const instanceCopy = document.createDocumentFragment();
-                    Array.from(masterCopy.children).forEach((e) => {
-                        instanceCopy.appendChild(e.cloneNode(true));
+            if (factory) {
+                // Factory-based registration for framework components
+                const instances = new Map();
+                const cleanupFunctions = new Map();
+                return (container, state) => {
+                    var _b;
+                    // If this is a new instance then assign it uuid instance
+                    if (!(state === null || state === void 0 ? void 0 : state['instance'])) {
+                        state['instance'] = this.uuid.createId();
+                    }
+                    container.state['instance'] = state['instance'];
+                    container.state['originalTitle'] = (_b = state['originalTitle']) !== null && _b !== void 0 ? _b : container.title;
+                    // Store instance container reference for state management FIRST
+                    const componentInstanceContainer = {
+                        container,
+                        instance: state['instance'],
+                        registration: reg,
+                    };
+                    // If this is a new instance, call the factory to create it
+                    if (!instances.has(state === null || state === void 0 ? void 0 : state['instance'])) {
+                        const componentContainer = document.createElement('div');
+                        componentContainer.style.width = '100%';
+                        componentContainer.style.height = '100%';
+                        componentContainer[instanceContainer] = componentInstanceContainer;
+                        const cleanup = factory(componentContainer);
+                        instances.set(state['instance'], componentContainer);
+                        if (cleanup) {
+                            cleanupFunctions.set(state['instance'], cleanup);
+                        }
+                    }
+                    // Append the instance container to the layout container
+                    const componentContainer = instances.get(state['instance']);
+                    if (!componentContainer) {
+                        logger.error(`Failed to get component container for instance ${state['instance']}`);
+                        return;
+                    }
+                    // Ensure the property is set (in case it was lost)
+                    componentContainer[instanceContainer] = componentInstanceContainer;
+                    container.element.appendChild(componentContainer);
+                    this.setupLayoutReceiveEvents(container, state);
+                };
+            }
+            else {
+                // Element-based registration (existing behavior)
+                const masterCopy = document.createDocumentFragment();
+                masterCopy[layoutCacheDocument] = true;
+                elements.forEach((e) => masterCopy.appendChild(e));
+                const instances = new Map();
+                return (container, state) => {
+                    var _b;
+                    // If this is a new instance then assign it uuid instance
+                    if (!(state === null || state === void 0 ? void 0 : state['instance'])) {
+                        state['instance'] = this.uuid.createId();
+                    }
+                    container.state['instance'] = state['instance'];
+                    container.state['originalTitle'] = (_b = state['originalTitle']) !== null && _b !== void 0 ? _b : container.title;
+                    // If this is a new instance then copy the master copy into the instances map
+                    // this is then the instance that is recalled for this version each time
+                    // the key point is "cloneNode" which makes a copy at this point
+                    if (!instances.has(state === null || state === void 0 ? void 0 : state['instance'])) {
+                        const instanceCopy = document.createDocumentFragment();
+                        Array.from(masterCopy.children).forEach((e) => {
+                            instanceCopy.appendChild(e.cloneNode(true));
+                        });
+                        instances.set(state['instance'], [...instanceCopy.children]);
+                    }
+                    // provide each component with a reference to the instance container
+                    // so they can optionally save and load their own state
+                    const componentInstanceContainer = {
+                        container,
+                        instance: state['instance'],
+                        registration: reg,
+                    };
+                    // get the instance from the map and append it to the container
+                    instances.get(state['instance']).forEach((component) => {
+                        container.element.appendChild(component);
+                        component[instanceContainer] = componentInstanceContainer;
                     });
-                    instances.set(state['instance'], [...instanceCopy.children]);
-                }
-                // provide each component with a reference to the instance container
-                // so they can optionally save and load their own state
-                const componentInstanceContainer = {
-                    container,
-                    instance: state['instance'],
-                    registration: reg,
+                    this.setupLayoutReceiveEvents(container, state);
                 };
-                // get the instance from the map and append it to the container
-                instances.get(state['instance']).forEach((component) => {
-                    container.element.appendChild(component);
-                    component[instanceContainer] = componentInstanceContainer;
-                });
-                this.setupLayoutReceiveEvents(container, state);
-            };
+            }
         })();
         this.layout.registerComponentFactoryFunction(reg, registrationFunction);
         return reg;

package/dist/esm/utils/factory-registry.js

@@ -0,0 +1,88 @@
+import { logger } from './logger';
+/**
+ * Global registry for component factories.
+ * Maps factory keys (strings) to factory functions.
+ * @internal
+ */
+const factoryRegistry = new Map();
+/**
+ * Registers a factory function with a unique key.
+ * This allows framework components to be used in the declarative layout API
+ * without needing to pass function references through HTML attributes.
+ *
+ * @param key - Unique identifier for the factory. Should be descriptive and unique across the application.
+ * @param factory - The factory function that creates the component.
+ *
+ * @example
+ * ```typescript
+ * // React example
+ * import { registerFactory } from '@genesislcap/foundation-layout';
+ * import { reactFactory } from './utils/react-layout-factory';
+ * import { MyComponent } from './components/MyComponent';
+ *
+ * registerFactory('my-component', reactFactory(MyComponent, { someProp: 'value' }));
+ * ```
+ *
+ * Then in your JSX:
+ * ```tsx
+ * <rapid-layout-item
+ *   registration="my-item"
+ *   title="My Component"
+ *   factory-key="my-component"
+ * />
+ * ```
+ *
+ * @public
+ */
+export function registerFactory(key, factory) {
+    if (factoryRegistry.has(key)) {
+        logger.warn(`Factory with key "${key}" is already registered. It will be overwritten.`);
+    }
+    factoryRegistry.set(key, factory);
+    logger.debug(`Factory registered with key: ${key}`);
+}
+/**
+ * Retrieves a factory function by its key.
+ *
+ * @param key - The unique identifier for the factory.
+ * @returns The factory function, or undefined if not found.
+ *
+ * @public
+ */
+export function getFactory(key) {
+    return factoryRegistry.get(key);
+}
+/**
+ * Removes a factory from the registry.
+ * This is useful for cleanup when a component is unmounted or no longer needed.
+ *
+ * @param key - The unique identifier for the factory to remove.
+ * @returns True if the factory was found and removed, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * unregisterFactory('my-component');
+ * ```
+ *
+ * @public
+ */
+export function unregisterFactory(key) {
+    const deleted = factoryRegistry.delete(key);
+    if (deleted) {
+        logger.debug(`Factory unregistered with key: ${key}`);
+    }
+    else {
+        logger.warn(`Attempted to unregister factory with key "${key}", but it was not found.`);
+    }
+    return deleted;
+}
+/**
+ * Clears all registered factories from the registry.
+ * This is primarily useful for testing purposes.
+ *
+ * @internal
+ */
+export function clearFactoryRegistry() {
+    factoryRegistry.clear();
+    logger.debug('Factory registry cleared');
+}

package/dist/esm/utils/index.js

@@ -1,6 +1,7 @@
 export * from './constants';
 export * from './error';
 export * from './events';
+export * from './factory-registry';
 export * from './misc';
 export * from './templates';
 export * from './types';

package/dist/foundation-layout.api.json

@@ -184,6 +184,41 @@
       "name": "",
       "preserveMemberOrder": false,
       "members": [
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@genesislcap/foundation-layout!ComponentFactory:type",
+          "docComment": "/**\n * Factory function for creating component instances in the layout.\n *\n * @remarks\n *\n * This is the recommended approach for framework-rendered components (React, Angular, Vue, etc.) because it allows each layout instance to create a fresh component rather than cloning existing DOM elements (which loses event listeners and framework bindings).\n *\n * The factory function receives a container element and should render the component into it. Optionally, it can return a cleanup function that will be called when the component is removed from the layout.\n *\n * @param container - The HTMLElement container where the component should be rendered\n *\n * @returns Optional cleanup function to be called when the component is removed\n *\n * @example\n *\n * React example:\n * ```typescript\n * layout.registerItem('my-component', (container) => {\n *   const root = createRoot(container);\n *   root.render(<MyComponent />);\n *   return () => root.unmount();\n * });\n * ```\n *\n * @example\n *\n * Angular example:\n * ```typescript\n * layout.registerItem('my-component', (container) => {\n *   const componentRef = createComponent(MyComponent, {\n *     environmentInjector: this.injector,\n *     hostElement: container\n *   });\n *   return () => componentRef.destroy();\n * });\n * ```\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type ComponentFactory = "
+            },
+            {
+              "kind": "Content",
+              "text": "(container: "
+            },
+            {
+              "kind": "Reference",
+              "text": "HTMLElement",
+              "canonicalReference": "!HTMLElement:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ") => void | (() => void)"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/utils/types.ts",
+          "releaseTag": "Public",
+          "name": "ComponentFactory",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@genesislcap/foundation-layout!CustomButton:type",
@@ -871,7 +906,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/foundation-layout!FoundationLayout#registerItem:member(1)",
-              "docComment": "/**\n * Register a collection of `Element` and associate them with an `ID` with the layout system for later use.\n *\n * @remarks\n *\n * You would use this to register elements that you later want to load when using {@link FoundationLayout.loadLayout}. Use {@link FoundationLayout.layoutRequiredRegistrations} to see what components need to be registered for a certain config and then register them using this function before calling {@link FoundationLayout.loadLayout}.\n *\n * When registering an element it is moved by reference into the internals of the layout, so if you pass elements already in the DOM then they will disappear. If you want to avoid this you can pass copies using `element.cloneNode(true)`.\n *\n * @param registration - string of the registration ID\n *\n * @param elements - Elements[] containing the reference to the elements to register for later usage\n *\n * @returns - string defining the name of the registered item with the layout system (config.id if set).\n *\n * @throws\n *\n * {@link LayoutUsageError} if you attempt to add an item before the layout has been initialised.\n *\n * @throws\n *\n * {@link LayoutRegistrationError} if you attempt to use a `registration` name which is already in use (declarative html API and JavaScript API registrations use the same \"pool\" of registration names).\n *\n * @public\n */\n",
+              "docComment": "/**\n * Register a collection of `Element` or a factory function and associate them with an `ID` with the layout system for later use.\n *\n * @remarks\n *\n * You can register either an array of elements or a factory function.\n *\n * **Element registration**: Use this to register elements that you later want to load when using {@link FoundationLayout.loadLayout}. Use {@link FoundationLayout.layoutRequiredRegistrations} to see what components need to be registered for a certain config and then register them using this function before calling {@link FoundationLayout.loadLayout}. When registering an element it is moved by reference into the internals of the layout, so if you pass elements already in the DOM then they will disappear. If you want to avoid this you can pass copies using `element.cloneNode(true)`.\n *\n * **Factory registration**: This is the recommended approach for framework-rendered components (React, Angular, Vue, etc.) because it allows each layout instance to create a fresh component rather than cloning existing DOM elements (which loses event listeners and framework bindings). The factory function will be called each time a new instance of the component is needed. It receives a container element and should render the component into it. Optionally, it can return a cleanup function that will be called when the component is removed from the layout.\n *\n * @param registration - string of the registration ID\n *\n * @param elementsOrFactory - Either Elements[] containing the reference to the elements to register, or a ComponentFactory function\n *\n * @returns - string defining the name of the registered item with the layout system (config.id if set).\n *\n * @throws\n *\n * {@link LayoutUsageError} if you attempt to add an item before the layout has been initialised.\n *\n * @throws\n *\n * {@link LayoutRegistrationError} if you attempt to use a `registration` name which is already in use (declarative html API and JavaScript API registrations use the same \"pool\" of registration names).\n *\n * @example\n *\n * Element registration:\n * ```typescript\n * const div = document.createElement('div');\n * div.innerHTML = '<h1>Hello</h1>';\n * layout.registerItem('my-element', [div]);\n * ```\n *\n * @example\n *\n * Factory registration (React):\n * ```typescript\n * layout.registerItem('text-field', (container) => {\n *   const root = createRoot(container);\n *   root.render(<TextFieldComponent />);\n *   return () => root.unmount();\n * });\n * ```\n *\n * @public\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -883,7 +918,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": ", elements: "
+                  "text": ", elementsOrFactory: "
                 },
                 {
                   "kind": "Reference",
@@ -892,7 +927,12 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "[]"
+                  "text": "[] | "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ComponentFactory",
+                  "canonicalReference": "@genesislcap/foundation-layout!ComponentFactory:type"
                 },
                 {
                   "kind": "Content",
@@ -909,8 +949,8 @@
               ],
               "isStatic": false,
               "returnTypeTokenRange": {
-                "startIndex": 6,
-                "endIndex": 7
+                "startIndex": 7,
+                "endIndex": 8
               },
               "releaseTag": "Public",
               "isProtected": false,
@@ -925,10 +965,10 @@
                   "isOptional": false
                 },
                 {
-                  "parameterName": "elements",
+                  "parameterName": "elementsOrFactory",
                   "parameterTypeTokenRange": {
                     "startIndex": 3,
-                    "endIndex": 5
+                    "endIndex": 6
                   },
                   "isOptional": false
                 }
@@ -1311,7 +1351,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/foundation-layout!FoundationLayoutItem:class",
-          "docComment": "/**\n * `FoundationLayoutItem` is a custom element that represents an item in the layout.\n *\n * @remarks\n *\n * This element is used to wrap html elements and configure their layout settings as part of the layout system.\n *\n * This is a simple component which is only used to define the layout splits; any JavaScript API interactions or custom styling is used via {@link FoundationLayout}.\n *\n * @tagname\n *\n * %%prefix%%-layout-item\n *\n * @public\n */\n",
+          "docComment": "/**\n * `FoundationLayoutItem` is a custom element that represents an item in the layout.\n *\n * @remarks\n *\n * This element is used to wrap html elements and configure their layout settings as part of the layout system.\n *\n * This is a simple component which is only used to define the layout splits; any JavaScript API interactions or custom styling is used via {@link FoundationLayout}.\n *\n * The item can either use slotted content or a factory function registered via {@link registerFactory}. When a factory is registered with the same name as the registration attribute, it takes precedence over slotted content.\n *\n * @tagname\n *\n * %%prefix%%-layout-item\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -1375,7 +1415,7 @@
             {
               "kind": "Property",
               "canonicalReference": "@genesislcap/foundation-layout!FoundationLayoutItem#registration:member",
-              "docComment": "/**\n * Sets the registration name for the item, which can be used later to add the item via the JavaScript API using {@link FoundationLayout.addItem}.\n *\n * @remarks\n *\n * Items added via the JavaScript API and HTML API share the same pool of registration names. Using a duplicate registration name is a runtime error. This registration name defaults to the number of the window it is. It is highly recommended if you are using the JavaScript API that you set a registration name here manually.\n *\n * @public\n */\n",
+              "docComment": "/**\n * Sets the registration name for the item, which can be used later to add the item via the JavaScript API using {@link FoundationLayout.addItem}.\n *\n * @remarks\n *\n * Items added via the JavaScript API and HTML API share the same pool of registration names. Using a duplicate registration name is a runtime error. This registration name defaults to the number of the window it is. It is highly recommended if you are using the JavaScript API that you set a registration name here manually.\n *\n * When using the declarative API with framework components, register a factory function via {@link registerFactory} using the same name as this registration attribute.\n *\n * @example\n * ```typescript\n * import { registerFactory } from '@genesislcap/foundation-layout';\n * import { reactFactory } from './utils/react-layout-factory';\n *\n * // Register factory with the same name as the registration\n * registerFactory('my-component', reactFactory(MyComponent));\n * ```\n *\n * Then in JSX/HTML:\n * ```tsx\n * <rapid-layout-item registration=\"my-component\" title=\"My Component\" />\n * ```\n *\n * @public\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -1581,6 +1621,56 @@
             }
           ]
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@genesislcap/foundation-layout!getFactory:function(1)",
+          "docComment": "/**\n * Retrieves a factory function by its key.\n *\n * @param key - The unique identifier for the factory.\n *\n * @returns The factory function, or undefined if not found.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function getFactory(key: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Reference",
+              "text": "ComponentFactory",
+              "canonicalReference": "@genesislcap/foundation-layout!ComponentFactory:type"
+            },
+            {
+              "kind": "Content",
+              "text": " | undefined"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/utils/factory-registry.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 5
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "key",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "getFactory"
+        },
         {
           "kind": "Variable",
           "canonicalReference": "@genesislcap/foundation-layout!LAYOUT_ICONS:var",
@@ -2227,6 +2317,68 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@genesislcap/foundation-layout!registerFactory:function(1)",
+          "docComment": "/**\n * Registers a factory function with a unique key. This allows framework components to be used in the declarative layout API without needing to pass function references through HTML attributes.\n *\n * @param key - Unique identifier for the factory. Should be descriptive and unique across the application.\n *\n * @param factory - The factory function that creates the component.\n *\n * @example\n * ```typescript\n * // React example\n * import { registerFactory } from '@genesislcap/foundation-layout';\n * import { reactFactory } from './utils/react-layout-factory';\n * import { MyComponent } from './components/MyComponent';\n *\n * registerFactory('my-component', reactFactory(MyComponent, { someProp: 'value' }));\n * ```\n *\n * Then in your JSX:\n * ```tsx\n * <rapid-layout-item\n *   registration=\"my-item\"\n *   title=\"My Component\"\n *   factory-key=\"my-component\"\n * />\n * ```\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function registerFactory(key: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ", factory: "
+            },
+            {
+              "kind": "Reference",
+              "text": "ComponentFactory",
+              "canonicalReference": "@genesislcap/foundation-layout!ComponentFactory:type"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "void"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/utils/factory-registry.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 5,
+            "endIndex": 6
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "key",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "factory",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "registerFactory"
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@genesislcap/foundation-layout!SerialisedLayout:type",
@@ -2261,6 +2413,51 @@
             "startIndex": 1,
             "endIndex": 4
           }
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@genesislcap/foundation-layout!unregisterFactory:function(1)",
+          "docComment": "/**\n * Removes a factory from the registry. This is useful for cleanup when a component is unmounted or no longer needed.\n *\n * @param key - The unique identifier for the factory to remove.\n *\n * @returns True if the factory was found and removed, false otherwise.\n *\n * @example\n * ```typescript\n * unregisterFactory('my-component');\n * ```\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function unregisterFactory(key: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "boolean"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/utils/factory-registry.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "key",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "unregisterFactory"
         }
       ]
     }