@genesislcap/foundation-layout 14.366.2-alpha-11da8b5.0 → 14.367.1-FUI-2341-3.2

package/dist/foundation-layout.d.ts

@@ -8,6 +8,45 @@ import { ResolvedLayoutConfig } from '@genesis-community/golden-layout';
 import { RootItemConfig } from '@genesis-community/golden-layout';
 import { ViewTemplate } from '@microsoft/fast-element';
 
+/**
+ * @public
+ * Factory function for creating component instances in the layout.
+ * @remarks
+ * 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 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 container - The HTMLElement container where the component should be rendered
+ * @returns Optional cleanup function to be called when the component is removed
+ *
+ * @example
+ * React example:
+ * ```typescript
+ * layout.registerItem('my-component', (container) => {
+ *   const root = createRoot(container);
+ *   root.render(<MyComponent />);
+ *   return () => root.unmount();
+ * });
+ * ```
+ *
+ * @example
+ * Angular example:
+ * ```typescript
+ * layout.registerItem('my-component', (container) => {
+ *   const componentRef = createComponent(MyComponent, {
+ *     environmentInjector: this.injector,
+ *     hostElement: container
+ *   });
+ *   return () => componentRef.destroy();
+ * });
+ * ```
+ */
+export declare type ComponentFactory = (container: HTMLElement) => void | (() => void);
+
 /**
  * Used to key what type of LayoutComponent an object is
  * @internal
@@ -276,21 +315,48 @@ export declare class FoundationLayout extends FoundationElement implements Layou
       removeItems(registration: string, force?: boolean): number;
       /**
        * @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: string, elements: Element[]): string;
+           registerItem(registration: string, elementsOrFactory: Element[] | ComponentFactory): string;
            /**
             * Internal APIs
             */
@@ -319,12 +385,13 @@ export declare class FoundationLayout extends FoundationElement implements Layou
             /**
              * 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 }: RegistrationConfig): string;
+            cacheElementsAndRegister(config: RegistrationConfig): string;
             /**
              * Sets up the event listeners for the layout receive events
              * @internal
@@ -443,6 +510,9 @@ export declare class FoundationLayout extends FoundationElement implements Layou
             * This element is used to wrap html elements and configure their layout settings as part of the layout system.
             *
             * 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}.
+            *
+            * 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.
             * @tagname %%prefix%%-layout-item
             */
            export declare class FoundationLayoutItem extends FoundationElement implements LayoutComponent {
@@ -471,6 +541,23 @@ export declare class FoundationLayout extends FoundationElement implements Layou
                 * 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.
+                *
+                * When using the declarative API with framework components, register a factory function via {@link registerFactory}
+                * using the same name as this registration attribute.
+                *
+                * @example
+                * ```typescript
+                * import { registerFactory } from '@genesislcap/foundation-layout';
+                * import { reactFactory } from './utils/react-layout-factory';
+                *
+                * // Register factory with the same name as the registration
+                * registerFactory('my-component', reactFactory(MyComponent));
+                * ```
+                *
+                * Then in JSX/HTML:
+                * ```tsx
+                * <rapid-layout-item registration="my-component" title="My Component" />
+                * ```
                 * @public
                 */
                registration: string;
@@ -539,6 +626,16 @@ export declare class FoundationLayout extends FoundationElement implements Layou
                cacheElementsAndRegister(config: RegistrationConfig): string;
            }
 
+           /**
+            * 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 declare function getFactory(key: string): ComponentFactory | undefined;
+
            /**
             * A collection of SVG icons in base64 format.
             * @remarks
@@ -764,11 +861,46 @@ export declare class FoundationLayout extends FoundationElement implements Layou
                showMaximiseButton?: boolean;
            }
 
+           /**
+            * 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.
+            * @throws {Error} If a factory with the same key is already registered.
+            *
+            * @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 declare function registerFactory(key: string, factory: ComponentFactory): void;
+
            /** @internal */
-           export declare interface RegistrationConfig {
-               elements: Element[];
+           export declare type RegistrationConfig = {
                id?: string;
-           }
+           } & ({
+               elements: Element[];
+           } | {
+               factory: ComponentFactory;
+           });
 
            /**
             * @public
@@ -786,4 +918,20 @@ export declare class FoundationLayout extends FoundationElement implements Layou
                c: ResolvedLayoutConfig;
            };
 
+           /**
+            * 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 declare function unregisterFactory(key: string): boolean;
+
            export { }