@handsontable/angular-wrapper 16.2.0 → 17.0.0-rc3

package/esm2022/lib/renderer/hot-cell-renderer-advanced.component.mjs

@@ -0,0 +1,55 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base component for creating advanced custom cell renderer components for Handsontable.
+ *
+ * This class provides a common interface and properties required by any custom cell renderer.
+ *
+ * @template TValue - The type of the component renderer.
+ * @template TProps - The type of additional renderer properties.
+ */
+export class HotCellRendererAdvancedComponent {
+    static RENDERER_MARKER = Symbol('HotCellRendererAdvancedComponent');
+    value = '';
+    instance;
+    td;
+    row;
+    col;
+    prop;
+    /**
+     * The cell properties provided by Handsontable, extended with optional renderer-specific properties.
+     */
+    cellProperties;
+    /**
+     * Retrieves the renderer-specific properties from the cell properties.
+     *
+     * @returns The additional properties for the renderer.
+     */
+    getProps() {
+        return this.cellProperties?.rendererProps ?? {};
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotCellRendererAdvancedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: HotCellRendererAdvancedComponent, selector: "hot-cell-renderer-advanced", inputs: { value: "value", instance: "instance", td: "td", row: "row", col: "col", prop: "prop", cellProperties: "cellProperties" }, ngImport: i0, template: `<!-- This is an abstract component. Extend this component and provide your own template. -->`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotCellRendererAdvancedComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'hot-cell-renderer-advanced',
+                    template: `<!-- This is an abstract component. Extend this component and provide your own template. -->`,
+                }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], instance: [{
+                type: Input
+            }], td: [{
+                type: Input
+            }], row: [{
+                type: Input
+            }], col: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], cellProperties: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/renderer/hot-dynamic-renderer-component.service.mjs

@@ -1,11 +1,15 @@
 import { createComponent, Injectable } from '@angular/core';
-import { baseRenderer } from 'handsontable/renderers';
+import { baseRenderer, registerRenderer, rendererFactory } from 'handsontable/renderers';
 import Handsontable from 'handsontable/base';
 import { HotCellRendererComponent } from './hot-cell-renderer.component';
+import { HotCellRendererAdvancedComponent } from './hot-cell-renderer-advanced.component';
 import * as i0 from "@angular/core";
 export const INVALID_RENDERER_WARNING = 'The provided renderer component was not recognized as a valid custom renderer. ' +
     'It must either extend HotCellRendererComponent or be a valid TemplateRef. ' +
     'Please ensure that your custom renderer is implemented correctly and imported from the proper source.';
+export const INVALID_ADVANCED_RENDERER_WARNING = 'The provided renderer component was not recognized as a valid custom renderer. ' +
+    'It must either extend HotCellRendererAdvancedComponent. ' +
+    'Please ensure that your custom renderer is implemented correctly and imported from the proper source.';
 /**
  * Type guard that checks if the given object is a TemplateRef.
  *
@@ -24,6 +28,15 @@ export function isTemplateRef(obj) {
 export function isHotCellRendererComponent(obj) {
     return obj?.RENDERER_MARKER === HotCellRendererComponent.RENDERER_MARKER;
 }
+/**
+ * Type guard to check if an object is an instance of HotCellRendererAdvancedComponent.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is a HotCellRendererAdvancedComponent, false otherwise.
+ */
+export function isAdvancedHotCellRendererComponent(obj) {
+    return obj?.RENDERER_MARKER === HotCellRendererAdvancedComponent.RENDERER_MARKER;
+}
 /**
  * Service for dynamically creating Angular components or templates as custom renderers for Handsontable.
  *
@@ -53,14 +66,18 @@ export class DynamicComponentService {
     createRendererFromComponent(component, componentProps = {}, register = false) {
         return (instance, td, row, col, prop, value, cellProperties) => {
             const properties = {
-                value, instance, td, row, col, prop, cellProperties
+                value,
+                instance,
+                td,
+                row,
+                col,
+                prop,
+                cellProperties,
             };
             if (componentProps) {
                 Object.assign(cellProperties, { rendererProps: componentProps });
             }
-            const rendererParameters = [
-                instance, td, row, col, prop, value, cellProperties
-            ];
+            const rendererParameters = [instance, td, row, col, prop, value, cellProperties];
             baseRenderer.apply(this, rendererParameters);
             td.innerHTML = '';
             if (isTemplateRef(component)) {
@@ -79,6 +96,42 @@ export class DynamicComponentService {
             return td;
         };
     }
+    /**
+     * Creates a custom renderer function using rendererFactory from Handsontable.
+     * This is an alternative implementation that uses the factory pattern.
+     *
+     * @param component - The Angular component type to use as renderer.
+     * @param componentProps - An object containing additional properties to use by the renderer.
+     * @param register - If true, registers the renderer with Handsontable using the component's name.
+     * @returns A renderer function that can be used in Handsontable's configuration.
+     */
+    createRendererWithFactory(component, componentProps = {}, register = false) {
+        return rendererFactory(({ instance, td, row, column, prop, value, cellProperties }) => {
+            const properties = {
+                value,
+                instance,
+                td,
+                row,
+                col: column,
+                prop,
+                cellProperties,
+            };
+            if (componentProps) {
+                Object.assign(cellProperties, { rendererProps: componentProps });
+            }
+            td.innerHTML = '';
+            if (isAdvancedHotCellRendererComponent(component)) {
+                const componentRef = this.createComponent(component, properties);
+                this.attachComponentToElement(componentRef, td);
+            }
+            else {
+                console.warn(INVALID_ADVANCED_RENDERER_WARNING);
+            }
+            if (register && isAdvancedHotCellRendererComponent(component)) {
+                registerRenderer(component.constructor.name, component);
+            }
+        });
+    }
     /**
      * Attaches an embedded view created from a TemplateRef to a given DOM element.
      *
@@ -105,9 +158,9 @@ export class DynamicComponentService {
      */
     createComponent(component, rendererParameters) {
         const componentRef = createComponent(component, {
-            environmentInjector: this.environmentInjector
+            environmentInjector: this.environmentInjector,
         });
-        Object.keys(rendererParameters).forEach(key => {
+        Object.keys(rendererParameters).forEach((key) => {
             if (rendererParameters.hasOwnProperty(key)) {
                 componentRef.setInput(key, rendererParameters[key]);
             }
@@ -126,8 +179,7 @@ export class DynamicComponentService {
      * @param container - The target DOM element to which the component's root node will be appended.
      */
     attachComponentToElement(componentRef, container) {
-        const domElem = componentRef.hostView
-            .rootNodes[0];
+        const domElem = componentRef.hostView.rootNodes[0];
         container.appendChild(domElem);
     }
     /**
@@ -148,4 +200,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i0.ApplicationRef }, { type: i0.EnvironmentInjector }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hot-dynamic-renderer-component.service.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/renderer/hot-dynamic-renderer-component.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef, ComponentRef, createComponent,\n  EmbeddedViewRef, EnvironmentInjector, Injectable,\n  TemplateRef, Type\n} from '@angular/core';\nimport {baseRenderer, BaseRenderer} from 'handsontable/renderers';\nimport Handsontable from 'handsontable/base';\nimport {HotCellRendererComponent} from './hot-cell-renderer.component';\n\ntype BaseRendererParameters = Parameters<BaseRenderer>;\n\nexport const INVALID_RENDERER_WARNING =\n  'The provided renderer component was not recognized as a valid custom renderer. ' +\n  'It must either extend HotCellRendererComponent or be a valid TemplateRef. ' +\n  'Please ensure that your custom renderer is implemented correctly and imported from the proper source.';\n\n/**\n * An object representing the parameters passed to a Handsontable renderer.\n */\ninterface BaseRendererParametersObject {\n  instance: Handsontable.Core;\n  td: HTMLTableCellElement;\n  row: number;\n  col: number;\n  prop: string | number;\n  value: any;\n  cellProperties: Handsontable.CellProperties;\n}\n\n/**\n * Type guard that checks if the given object is a TemplateRef.\n *\n * @param obj - The object to check.\n * @returns True if the object is a TemplateRef; otherwise, false.\n */\nexport function isTemplateRef<T>(obj: any): obj is TemplateRef<T> {\n  return obj && typeof obj.createEmbeddedView === 'function';\n}\n\n/**\n * Type guard to check if an object is an instance of HotCellRendererComponent.\n *\n * @param obj - The object to check.\n * @returns True if the object is a HotCellRendererComponent, false otherwise.\n */\nexport function isHotCellRendererComponent(obj: any): obj is Type<HotCellRendererComponent> {\n  return obj?.RENDERER_MARKER === HotCellRendererComponent.RENDERER_MARKER;\n}\n\n/**\n * Service for dynamically creating Angular components or templates as custom renderers for Handsontable.\n *\n * This service allows you to create a renderer function that wraps a given Angular component or TemplateRef\n * so that it can be used as a Handsontable renderer.\n *\n * @example\n * const customRenderer = dynamicComponentService.createRendererFromComponent(MyRendererComponent, { someProp: value });\n * // Use customRenderer in your Handsontable configuration\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class DynamicComponentService {\n  constructor(\n    private appRef: ApplicationRef,\n    private environmentInjector: EnvironmentInjector\n  ) {}\n\n  /**\n   * Creates a custom renderer function for Handsontable from an Angular component or TemplateRef.\n   * The generated renderer function will be used by Handsontable to render cell content.\n   *\n   * @param component - The Angular component type or TemplateRef to use as renderer.\n   * @param componentProps - An object containing additional properties to use by the renderer.\n   * @param register - If true, registers the renderer with Handsontable using the component's name.\n   * @returns A renderer function that can be used in Handsontable's configuration.\n   */\n  createRendererFromComponent(\n    component: Type<HotCellRendererComponent> | TemplateRef<any>,\n    componentProps: Record<string, any> = {},\n    register: boolean = false\n  ) {\n    return (\n      instance: Handsontable.Core,\n      td: HTMLTableCellElement,\n      row: number,\n      col: number,\n      prop: string | number,\n      value: any,\n      cellProperties: Handsontable.CellProperties\n    ) => {\n      const properties: BaseRendererParametersObject = {\n        value, instance, td, row, col, prop, cellProperties\n      };\n\n      if (componentProps) {\n        Object.assign(cellProperties, {rendererProps: componentProps});\n      }\n\n      const rendererParameters: BaseRendererParameters = [\n        instance, td, row, col, prop, value, cellProperties\n      ];\n\n      baseRenderer.apply(this, rendererParameters);\n\n      td.innerHTML = '';\n\n      if (isTemplateRef(component)) {\n        this.attachTemplateToElement(component, td, properties);\n      } else if (isHotCellRendererComponent(component)){\n        const componentRef = this.createComponent(component, properties);\n        this.attachComponentToElement(componentRef, td);\n      } else {\n        console.warn(INVALID_RENDERER_WARNING)\n      }\n\n      if (register && isHotCellRendererComponent(component)) {\n        Handsontable.renderers.registerRenderer(\n          component.constructor.name,\n          component as any as BaseRenderer\n        );\n      }\n\n      return td;\n    };\n  }\n\n  /**\n   * Attaches an embedded view created from a TemplateRef to a given DOM element.\n   *\n   * @param template - The TemplateRef to create an embedded view from.\n   * @param tdEl - The target DOM element (a table cell) to which the view will be appended.\n   * @param properties - Context object providing properties to be used within the template.\n   */\n  private attachTemplateToElement(\n    template: TemplateRef<any>,\n    tdEl: HTMLTableCellElement,\n    properties: BaseRendererParametersObject\n  ) {\n    const embeddedView: EmbeddedViewRef<any> = template.createEmbeddedView({\n      $implicit: properties.value,\n      ...properties,\n    });\n    embeddedView.detectChanges();\n\n    embeddedView.rootNodes.forEach((node) => {\n      tdEl.appendChild(node);\n    });\n  }\n\n  /**\n   * Dynamically creates an Angular component of the given type.\n   *\n   * @param component - The Angular component type to be created.\n   * @param rendererParameters - An object containing input properties to assign to the component instance.\n   * @returns The ComponentRef of the dynamically created component.\n   */\n  private createComponent<T extends HotCellRendererComponent>(\n    component: Type<T>,\n    rendererParameters: BaseRendererParametersObject\n  ): ComponentRef<T> {\n    const componentRef = createComponent(component, {\n      environmentInjector: this.environmentInjector\n    });\n\n    Object.keys(rendererParameters).forEach(key => {\n      if (rendererParameters.hasOwnProperty(key)) {\n        componentRef.setInput(key, rendererParameters[key])\n      } else {\n        console.warn(`Input property \"${key}\" does not exist on component instance: ${component?.name}.`);\n      }\n    })\n    componentRef.changeDetectorRef.detectChanges();\n\n    this.appRef.attachView(componentRef.hostView);\n\n    return componentRef;\n  }\n\n  /**\n   * Attaches a dynamically created component's view to a specified DOM container element.\n   *\n   * @param componentRef - The reference to the dynamically created component.\n   * @param container - The target DOM element to which the component's root node will be appended.\n   */\n  private attachComponentToElement<T>(\n    componentRef: ComponentRef<T>,\n    container: HTMLElement\n  ): void {\n    const domElem = (componentRef.hostView as EmbeddedViewRef<T>)\n      .rootNodes[0] as HTMLElement;\n    container.appendChild(domElem);\n  }\n\n  /**\n   * Destroys a dynamically created component and detaches its view from the Angular application.\n   *\n   * @param componentRef - The reference to the component to be destroyed.\n   */\n  destroyComponent<T>(componentRef: ComponentRef<T>): void {\n    this.appRef.detachView(componentRef.hostView);\n    componentRef.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hot-dynamic-renderer-component.service.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/renderer/hot-dynamic-renderer-component.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef,\n  ComponentRef,\n  createComponent,\n  EmbeddedViewRef,\n  EnvironmentInjector,\n  Injectable,\n  TemplateRef,\n  Type\n} from '@angular/core';\nimport { baseRenderer, BaseRenderer, registerRenderer, rendererFactory } from 'handsontable/renderers';\nimport Handsontable from 'handsontable/base';\nimport { HotCellRendererComponent } from './hot-cell-renderer.component';\nimport { HotCellRendererAdvancedComponent } from './hot-cell-renderer-advanced.component';\n\ntype BaseRendererParameters = Parameters<BaseRenderer>;\n\nexport const INVALID_RENDERER_WARNING =\n  'The provided renderer component was not recognized as a valid custom renderer. ' +\n  'It must either extend HotCellRendererComponent or be a valid TemplateRef. ' +\n  'Please ensure that your custom renderer is implemented correctly and imported from the proper source.';\n\nexport const INVALID_ADVANCED_RENDERER_WARNING =\n  'The provided renderer component was not recognized as a valid custom renderer. ' +\n  'It must either extend HotCellRendererAdvancedComponent. ' +\n  'Please ensure that your custom renderer is implemented correctly and imported from the proper source.';\n\n/**\n * An object representing the parameters passed to a Handsontable renderer.\n */\ninterface BaseRendererParametersObject {\n  instance: Handsontable.Core;\n  td: HTMLTableCellElement;\n  row: number;\n  col: number;\n  prop: string | number;\n  value: any;\n  cellProperties: Handsontable.CellProperties;\n}\n\n/**\n * Type guard that checks if the given object is a TemplateRef.\n *\n * @param obj - The object to check.\n * @returns True if the object is a TemplateRef; otherwise, false.\n */\nexport function isTemplateRef<T>(obj: any): obj is TemplateRef<T> {\n  return obj && typeof obj.createEmbeddedView === 'function';\n}\n\n/**\n * Type guard to check if an object is an instance of HotCellRendererComponent.\n *\n * @param obj - The object to check.\n * @returns True if the object is a HotCellRendererComponent, false otherwise.\n */\nexport function isHotCellRendererComponent(obj: any): obj is Type<HotCellRendererComponent> {\n  return obj?.RENDERER_MARKER === HotCellRendererComponent.RENDERER_MARKER;\n}\n\n/**\n * Type guard to check if an object is an instance of HotCellRendererAdvancedComponent.\n *\n * @param obj - The object to check.\n * @returns True if the object is a HotCellRendererAdvancedComponent, false otherwise.\n */\nexport function isAdvancedHotCellRendererComponent(obj: any): obj is Type<HotCellRendererAdvancedComponent> {\n  return obj?.RENDERER_MARKER === HotCellRendererAdvancedComponent.RENDERER_MARKER;\n}\n\n/**\n * Service for dynamically creating Angular components or templates as custom renderers for Handsontable.\n *\n * This service allows you to create a renderer function that wraps a given Angular component or TemplateRef\n * so that it can be used as a Handsontable renderer.\n *\n * @example\n * const customRenderer = dynamicComponentService.createRendererFromComponent(MyRendererComponent, { someProp: value });\n * // Use customRenderer in your Handsontable configuration\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class DynamicComponentService {\n  constructor(private appRef: ApplicationRef, private environmentInjector: EnvironmentInjector) {}\n\n  /**\n   * Creates a custom renderer function for Handsontable from an Angular component or TemplateRef.\n   * The generated renderer function will be used by Handsontable to render cell content.\n   *\n   * @param component - The Angular component type or TemplateRef to use as renderer.\n   * @param componentProps - An object containing additional properties to use by the renderer.\n   * @param register - If true, registers the renderer with Handsontable using the component's name.\n   * @returns A renderer function that can be used in Handsontable's configuration.\n   */\n  createRendererFromComponent(\n    component: Type<HotCellRendererComponent> | TemplateRef<any>,\n    componentProps: Record<string, any> = {},\n    register: boolean = false\n  ) {\n    return (\n      instance: Handsontable.Core,\n      td: HTMLTableCellElement,\n      row: number,\n      col: number,\n      prop: string | number,\n      value: any,\n      cellProperties: Handsontable.CellProperties\n    ) => {\n      const properties: BaseRendererParametersObject = {\n        value,\n        instance,\n        td,\n        row,\n        col,\n        prop,\n        cellProperties,\n      };\n\n      if (componentProps) {\n        Object.assign(cellProperties, { rendererProps: componentProps });\n      }\n\n      const rendererParameters: BaseRendererParameters = [instance, td, row, col, prop, value, cellProperties];\n\n      baseRenderer.apply(this, rendererParameters);\n\n      td.innerHTML = '';\n\n      if (isTemplateRef(component)) {\n        this.attachTemplateToElement(component, td, properties);\n      } else if (isHotCellRendererComponent(component)) {\n        const componentRef = this.createComponent(component, properties);\n        this.attachComponentToElement(componentRef, td);\n      } else {\n        console.warn(INVALID_RENDERER_WARNING);\n      }\n\n      if (register && isHotCellRendererComponent(component)) {\n        Handsontable.renderers.registerRenderer(component.constructor.name, component as any as BaseRenderer);\n      }\n\n      return td;\n    };\n  }\n\n  /**\n   * Creates a custom renderer function using rendererFactory from Handsontable.\n   * This is an alternative implementation that uses the factory pattern.\n   *\n   * @param component - The Angular component type to use as renderer.\n   * @param componentProps - An object containing additional properties to use by the renderer.\n   * @param register - If true, registers the renderer with Handsontable using the component's name.\n   * @returns A renderer function that can be used in Handsontable's configuration.\n   */\n  createRendererWithFactory(\n    component: Type<HotCellRendererAdvancedComponent>,\n    componentProps: Record<string, any> = {},\n    register: boolean = false\n  ) {\n    return rendererFactory(({\n      instance,\n      td,\n      row,\n      column,\n      prop,\n      value,\n      cellProperties\n    }) => {\n      const properties: BaseRendererParametersObject = {\n        value,\n        instance,\n        td,\n        row,\n        col: column,\n        prop,\n        cellProperties,\n      };\n\n      if (componentProps) {\n        Object.assign(cellProperties, { rendererProps: componentProps });\n      }\n\n      td.innerHTML = '';\n\n      if (isAdvancedHotCellRendererComponent(component)) {\n        const componentRef = this.createComponent(component, properties);\n        this.attachComponentToElement(componentRef, td);\n      } else {\n        console.warn(INVALID_ADVANCED_RENDERER_WARNING);\n      }\n\n      if (register && isAdvancedHotCellRendererComponent(component)) {\n        registerRenderer(component.constructor.name, component as any as BaseRenderer);\n      }\n    });\n  }\n\n  /**\n   * Attaches an embedded view created from a TemplateRef to a given DOM element.\n   *\n   * @param template - The TemplateRef to create an embedded view from.\n   * @param tdEl - The target DOM element (a table cell) to which the view will be appended.\n   * @param properties - Context object providing properties to be used within the template.\n   */\n  private attachTemplateToElement(template: TemplateRef<any>, tdEl: HTMLTableCellElement, properties: BaseRendererParametersObject) {\n    const embeddedView: EmbeddedViewRef<any> = template.createEmbeddedView({\n      $implicit: properties.value,\n      ...properties,\n    });\n    embeddedView.detectChanges();\n\n    embeddedView.rootNodes.forEach((node) => {\n      tdEl.appendChild(node);\n    });\n  }\n\n  /**\n   * Dynamically creates an Angular component of the given type.\n   *\n   * @param component - The Angular component type to be created.\n   * @param rendererParameters - An object containing input properties to assign to the component instance.\n   * @returns The ComponentRef of the dynamically created component.\n   */\n  private createComponent<T extends HotCellRendererComponent>(\n    component: Type<T>,\n    rendererParameters: BaseRendererParametersObject\n  ): ComponentRef<T> {\n    const componentRef = createComponent(component, {\n      environmentInjector: this.environmentInjector,\n    });\n\n    Object.keys(rendererParameters).forEach((key) => {\n      if (rendererParameters.hasOwnProperty(key)) {\n        componentRef.setInput(key, rendererParameters[key]);\n      } else {\n        console.warn(`Input property \"${key}\" does not exist on component instance: ${component?.name}.`);\n      }\n    });\n    componentRef.changeDetectorRef.detectChanges();\n\n    this.appRef.attachView(componentRef.hostView);\n\n    return componentRef;\n  }\n\n  /**\n   * Attaches a dynamically created component's view to a specified DOM container element.\n   *\n   * @param componentRef - The reference to the dynamically created component.\n   * @param container - The target DOM element to which the component's root node will be appended.\n   */\n  private attachComponentToElement<T>(componentRef: ComponentRef<T>, container: HTMLElement): void {\n    const domElem = (componentRef.hostView as EmbeddedViewRef<T>).rootNodes[0] as HTMLElement;\n    container.appendChild(domElem);\n  }\n\n  /**\n   * Destroys a dynamically created component and detaches its view from the Angular application.\n   *\n   * @param componentRef - The reference to the component to be destroyed.\n   */\n  destroyComponent<T>(componentRef: ComponentRef<T>): void {\n    this.appRef.detachView(componentRef.hostView);\n    componentRef.destroy();\n  }\n}\n"]}

package/esm2022/lib/services/hot-global-config.service.mjs

@@ -42,7 +42,6 @@ export class HotGlobalConfigService {
      */
     defaultConfig = {
         license: undefined,
-        themeName: ''
     };
     /**
      * A BehaviorSubject that holds the current Handsontable configuration.
@@ -105,4 +104,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     type: Inject,
                     args: [HOT_GLOBAL_CONFIG]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hot-global-config.service.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/services/hot-global-config.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,cAAc,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AACjE,OAAO,EAAC,eAAe,EAAa,MAAM,MAAM,CAAC;;AAEjD;;KAEK;AACL,MAAM,CAAC,MAAM,sBAAsB,GAAG,+BAA+B,CAAC;AAEtE;;;GAGG;AACH,MAAM,CAAN,IAAY,eAOX;AAPD,WAAY,eAAe;IACzB,yCAAsB,CAAA;IACtB,kDAA+B,CAAA;IAC/B,2DAAwC,CAAA;IACxC,+CAA4B,CAAA;IAC5B,wDAAqC,CAAA;IACrC,iEAA8C,CAAA;AAChD,CAAC,EAPW,eAAe,KAAf,eAAe,QAO1B;AAuCD;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,EAAE;IACxF,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;CACpB,CAAC,CAAC;AAEH;;;GAGG;AAIH,MAAM,OAAO,sBAAsB;IAEjC;;;;;;;;;OASG;IACK,aAAa,GAAoB;QACvC,OAAO,EAAE,SAAS;KACnB,CAAC;IAEF;;;;;;;;OAQG;IACK,aAAa,GAAG,IAAI,eAAe,CAAkB,IAAI,CAAC,aAAa,CAAC,CAAC;IAEjF;;;;;;OAMG;IACH,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;IAC3C,CAAC;IAED,YAC6B,YAA6B;QAExD,yEAAyE;QACzE,IAAI,CAAC,aAAa,GAAG,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,GAAG,YAAY,EAAE,CAAC;QAChE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,MAAuB;QAC/B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IACrD,CAAC;wGAvEU,sBAAsB,kBAuCvB,iBAAiB;4GAvChB,sBAAsB,cAFrB,MAAM;;4FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAwCI,MAAM;2BAAC,iBAAiB","sourcesContent":["import {Injectable, InjectionToken, Inject} from '@angular/core';\nimport {BehaviorSubject, Observable} from 'rxjs';\n\n/**\n * A constant representing the non-commercial and evaluation license.\n * */\nexport const NON_COMMERCIAL_LICENSE = 'non-commercial-and-evaluation';\n\n/**\n * Type representing a theme name.\n * Possible values include predefined themes and any custom string.\n */\nexport enum PredefinedTheme {\n  Main = 'ht-theme-main',\n  MainDark = 'ht-theme-main-dark',\n  MainDarkAuto = 'ht-theme-main-dark-auto',\n  Horizon = 'ht-theme-horizon',\n  HorizonDark = 'ht-theme-horizon-dark',\n  HorizonDarkAuto = 'ht-theme-horizon-dark-auto'\n}\n\nexport type ThemeName = PredefinedTheme | string;\n\n/**\n * Interface for the Handsontable global configuration.\n */\nexport interface HotGlobalConfig {\n  /**\n   * The license key for Handsontable.\n   */\n  license?: string;\n\n  /**\n   * The name of the theme to be used.\n   */\n  themeName?: ThemeName;\n\n  /**\n   * The theme to be used (ThemeBuilder instance or theme name string).\n   * When set, takes precedence over `themeName` for Handsontable 17+.\n   */\n  theme?: object | string;\n\n  /**\n   * The language code to be used for localization.\n   * For example, 'en-US', 'pl-PL', etc.\n   * **Note:** The language must be chosen from the languages supported by Handsontable and registered in the application.\n   */\n  language?: string;\n\n  /**\n   * The layout direction for the Handsontable instance.\n   * This property defines whether the layout should be left-to-right ('ltr'), right-to-left ('rtl'),\n   * or inherit the direction from the parent element ('inherit').\n   */\n  layoutDirection?: 'ltr' | 'rtl' | 'inherit';\n}\n\n/**\n * Injection token for providing a global default configuration.\n */\nexport const HOT_GLOBAL_CONFIG = new InjectionToken<HotGlobalConfig>('HOT_GLOBAL_CONFIG', {\n  providedIn: 'root',\n  factory: () => ({})\n});\n\n/**\n * Service for configuring Handsontable settings.\n * This service allows setting and retrieving global configuration.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class HotGlobalConfigService {\n\n  /**\n   * The default configuration object for Handsontable.\n   *\n   * This object is used as the initial value for the configuration BehaviorSubject.\n   * It can be overridden by a global configuration provided through the\n   * {@link HOT_GLOBAL_CONFIG} injection token.\n   *\n   * @private\n   * @type {HotGlobalConfig}\n   */\n  private defaultConfig: HotGlobalConfig = {\n    license: undefined,\n  };\n\n  /**\n   * A BehaviorSubject that holds the current Handsontable configuration.\n   *\n   * New configuration values can be emitted by calling next() on this subject.\n   * This allows subscribers to react to configuration changes dynamically.\n   *\n   * @private\n   * @type {BehaviorSubject<HotGlobalConfig>}\n   */\n  private configSubject = new BehaviorSubject<HotGlobalConfig>(this.defaultConfig);\n\n  /**\n   * An Observable stream of the current Handsontable configuration.\n   *\n   * Components can subscribe to this observable to receive updates whenever the configuration changes.\n   *\n   * @returns The configuration as an observable stream.\n   */\n  get config$(): Observable<HotGlobalConfig> {\n    return this.configSubject.asObservable();\n  }\n\n  constructor(\n    @Inject(HOT_GLOBAL_CONFIG) globalConfig: HotGlobalConfig\n  ) {\n    // Merge global configuration (if provided) into defaultConfig immutably.\n    this.defaultConfig = { ...this.defaultConfig, ...globalConfig };\n    this.configSubject.next(this.defaultConfig);\n  }\n\n  /**\n   * Sets the global configuration for Handsontable.\n   *\n   * @param config - An object containing configuration options.\n   *                 Each Handsontable instance can override this configuration by providing its own settings.\n   */\n  setConfig(config: HotGlobalConfig) {\n    this.configSubject.next({ ...this.defaultConfig, ...config });\n  }\n\n  /**\n   * Retrieves the current Handsontable configuration.\n   *\n   * @returns An object with the current settings.\n   */\n  getConfig(): HotGlobalConfig {\n    return this.configSubject.value;\n  }\n\n  /**\n   * Resets the configuration to the default settings.\n   * This method updates the configuration BehaviorSubject with the default configuration.\n   */\n  resetConfig(): void {\n    this.configSubject.next({ ...this.defaultConfig });\n  }\n}\n"]}

package/esm2022/lib/services/hot-settings-resolver.service.mjs

@@ -1,6 +1,11 @@
 import { createComponent, Injectable } from '@angular/core';
 import { BaseEditorAdapter } from '../editor/base-editor-adapter';
+import { HotCellRendererComponent } from '../renderer/hot-cell-renderer.component';
+import { HotCellEditorComponent } from '../editor/hot-cell-editor.component';
 import Handsontable from 'handsontable/base';
+import { FactoryEditorAdapter } from '../editor/editor-factory-adapter';
+import { HotCellRendererAdvancedComponent } from '../renderer/hot-cell-renderer-advanced.component';
+import { HotCellEditorAdvancedComponent } from '../editor/hot-cell-editor-advanced.component';
 import * as i0 from "@angular/core";
 import * as i1 from "../renderer/hot-dynamic-renderer-component.service";
 const AVAILABLE_OPTIONS = Object.keys(Handsontable.DefaultSettings);
@@ -37,7 +42,7 @@ export class HotSettingsResolver {
      */
     wrapHooksInNgZone(settings, ngZone) {
         const options = AVAILABLE_HOOKS.concat(AVAILABLE_OPTIONS);
-        options.forEach(key => {
+        options.forEach((key) => {
             const isHook = AVAILABLE_HOOKS.indexOf(key) > -1;
             let option;
             if (isHook) {
@@ -46,7 +51,7 @@ export class HotSettingsResolver {
             if (option === void 0) {
                 return;
             }
-            else if (!!ngZone && (typeof option === 'function' && isHook)) {
+            else if (!!ngZone && typeof option === 'function' && isHook) {
                 settings[key] = function (...args) {
                     return ngZone.run(() => option.apply(this, args));
                 };
@@ -65,13 +70,16 @@ export class HotSettingsResolver {
             return;
         }
         mergedSettings?.columns
-            ?.filter((settings) => this.isRendererComponentRefType(settings.renderer) || this.isTemplateRef(settings.renderer))
+            ?.filter((settings) => this.isCustomRenderer(settings.renderer))
             ?.forEach((cellSettings) => {
-            const renderer = this.isTemplateRef(cellSettings.renderer)
-                ? cellSettings.renderer
-                : cellSettings.renderer;
+            const renderer = cellSettings.renderer;
             const props = cellSettings.rendererProps ?? {};
-            cellSettings.renderer = this.dynamicComponentService.createRendererFromComponent(renderer, props);
+            if (this.isAdvancedRendererComponentRefType(renderer)) {
+                cellSettings.renderer = this.dynamicComponentService.createRendererWithFactory(renderer, props);
+            }
+            else if (this.isRendererComponentRefType(renderer) || this.isTemplateRef(renderer)) {
+                cellSettings.renderer = this.dynamicComponentService.createRendererFromComponent(renderer, props);
+            }
         });
     }
     /**
@@ -83,14 +91,22 @@ export class HotSettingsResolver {
             return;
         }
         mergedSettings?.columns
-            ?.filter((settings) => this.isEditorComponentRefType(settings.editor))
+            ?.filter((settings) => this.isEditorComponentRefType(settings.editor) || this.isAdvancedEditorComponentRefType(settings.editor))
             ?.forEach((cellSettings) => {
-            const customEditor = cellSettings.editor;
-            cellSettings['_editorComponentReference'] = createComponent(customEditor, {
-                environmentInjector: this.environmentInjector,
-            });
-            cellSettings['_environmentInjector'] = this.environmentInjector;
-            cellSettings.editor = BaseEditorAdapter;
+            if (this.isAdvancedEditorComponentRefType(cellSettings.editor)) {
+                const component = createComponent(cellSettings.editor, {
+                    environmentInjector: this.environmentInjector,
+                });
+                cellSettings.editor = FactoryEditorAdapter(component);
+            }
+            else {
+                const component = createComponent(cellSettings.editor, {
+                    environmentInjector: this.environmentInjector,
+                });
+                cellSettings['_editorComponentReference'] = component;
+                cellSettings['_environmentInjector'] = this.environmentInjector;
+                cellSettings.editor = BaseEditorAdapter;
+            }
         });
     }
     /**
@@ -115,19 +131,40 @@ export class HotSettingsResolver {
     }
     isEditorComponentRefType(editor) {
         // ecmp - we need it to check if the editor is a component
-        return typeof editor === 'function' && !!editor?.ɵcmp;
+        return typeof editor === 'function' &&
+            !!editor?.ɵcmp &&
+            editor?.EDITOR_MARKER === HotCellEditorComponent.EDITOR_MARKER;
+    }
+    isAdvancedEditorComponentRefType(editor) {
+        // ecmp - we need it to check if the editor is a component
+        return typeof editor === 'function' &&
+            !!editor?.ɵcmp &&
+            editor?.EDITOR_MARKER === HotCellEditorAdvancedComponent.EDITOR_MARKER;
     }
     isRendererComponentRefType(renderer) {
         // ecmp - we need it to check if the renderer is a component
-        return typeof renderer === 'function' && !!renderer?.ɵcmp;
+        return typeof renderer === 'function' &&
+            !!renderer?.ɵcmp &&
+            renderer?.RENDERER_MARKER === HotCellRendererComponent.RENDERER_MARKER;
+    }
+    isAdvancedRendererComponentRefType(renderer) {
+        // ecmp - we need it to check if the renderer is a component
+        return typeof renderer === 'function' &&
+            !!renderer?.ɵcmp &&
+            renderer?.RENDERER_MARKER === HotCellRendererAdvancedComponent.RENDERER_MARKER;
     }
     isTemplateRef(renderer) {
         return renderer && typeof renderer.createEmbeddedView === 'function';
     }
+    isCustomRenderer(renderer) {
+        return this.isRendererComponentRefType(renderer) ||
+            this.isTemplateRef(renderer) ||
+            this.isAdvancedRendererComponentRefType(renderer);
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotSettingsResolver, deps: [{ token: i1.DynamicComponentService }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotSettingsResolver });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotSettingsResolver, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.DynamicComponentService }, { type: i0.EnvironmentInjector }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hot-settings-resolver.service.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/services/hot-settings-resolver.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {createComponent, EnvironmentInjector, Injectable, NgZone, TemplateRef, Type} from '@angular/core';\nimport { DynamicComponentService } from '../renderer/hot-dynamic-renderer-component.service';\nimport { BaseEditorAdapter } from '../editor/base-editor-adapter';\nimport { GridSettings, GridSettingsInternal } from '../models/grid-settings';\nimport { CustomValidatorFn, ColumnSettings } from '../models/column-settings';\nimport { HotCellRendererComponent } from '../renderer/hot-cell-renderer.component';\nimport { HotCellEditorComponent } from '../editor/hot-cell-editor.component';\nimport Handsontable from 'handsontable/base';\n\nconst AVAILABLE_OPTIONS: string[] = Object.keys(Handsontable.DefaultSettings);\nconst AVAILABLE_HOOKS: string[] = Handsontable.hooks.getRegistered();\n\n/**\n * Service to resolve and apply custom settings for Handsontable settings object.\n */\n@Injectable()\nexport class HotSettingsResolver {\n  constructor(private dynamicComponentService: DynamicComponentService, private readonly environmentInjector: EnvironmentInjector) {}\n\n  /**\n   * Applies custom settings to the provided GridSettings.\n   * @param settings The original grid settings.\n   * @param ngZone The NgZone instance to run hooks inside the zone context.\n   * @returns The merged grid settings with custom settings applied.\n   */\n  applyCustomSettings(settings: GridSettings, ngZone: NgZone): GridSettingsInternal {\n    const mergedSettings: GridSettings = settings;\n\n    this.updateColumnRendererForGivenCustomRenderer(mergedSettings);\n    this.updateColumnEditorForGivenCustomEditor(mergedSettings);\n    this.updateColumnValidatorForGivenCustomValidator(mergedSettings);\n\n    this.wrapHooksInNgZone(mergedSettings, ngZone);\n\n    return (mergedSettings as GridSettingsInternal) ?? {};\n  }\n\n  /**\n   * Ensures that hook callbacks in the provided grid settings run inside Angular's zone.\n   *\n   * @param settings The original grid settings.\n   * @param ngZone The NgZone instance to run hooks inside the zone context.\n   */\n  private wrapHooksInNgZone(settings: GridSettings, ngZone: NgZone) {\n    const options = AVAILABLE_HOOKS.concat(AVAILABLE_OPTIONS);\n\n    options.forEach(key => {\n      const isHook = AVAILABLE_HOOKS.indexOf(key) > -1;\n      let option;\n\n      if (isHook) {\n        option = settings[key];\n      }\n\n      if (option === void 0) {\n        return;\n\n      } else if (!!ngZone && (typeof option === 'function' && isHook)) {\n        settings[key] = function(...args: any) {\n          return ngZone.run(() => option.apply(this, args));\n        };\n\n      } else {\n        settings[key] = option;\n      }\n    });\n  }\n\n  /**\n   * Updates the column renderer for columns with a custom renderer.\n   * @param mergedSettings The merged grid settings.\n   */\n  private updateColumnRendererForGivenCustomRenderer(mergedSettings: GridSettings): void {\n    if (!Array.isArray(mergedSettings?.columns)) {\n      return;\n    }\n\n    (mergedSettings?.columns as ColumnSettings[])\n      ?.filter((settings) => this.isRendererComponentRefType(settings.renderer) || this.isTemplateRef(settings.renderer))\n      ?.forEach((cellSettings) => {\n        const renderer = this.isTemplateRef(cellSettings.renderer)\n          ? (cellSettings.renderer as TemplateRef<any>)\n          : (cellSettings.renderer as Type<HotCellRendererComponent<any, any>>);\n        const props: any = cellSettings.rendererProps ?? {};\n        cellSettings.renderer = this.dynamicComponentService.createRendererFromComponent(renderer, props);\n      });\n  }\n\n  /**\n   * Updates the column editor for columns with a custom editor.\n   * @param mergedSettings The merged grid settings.\n   */\n  private updateColumnEditorForGivenCustomEditor(mergedSettings: GridSettings): void {\n    if (!Array.isArray(mergedSettings?.columns)) {\n      return;\n    }\n\n    (mergedSettings?.columns as ColumnSettings[])\n      ?.filter((settings) => this.isEditorComponentRefType(settings.editor))\n      ?.forEach((cellSettings) => {\n        const customEditor = cellSettings.editor as Type<HotCellEditorComponent<any>>;\n        cellSettings['_editorComponentReference'] = createComponent(customEditor, {\n          environmentInjector: this.environmentInjector,\n        });\n        cellSettings['_environmentInjector'] = this.environmentInjector;\n        cellSettings.editor = BaseEditorAdapter;\n      });\n  }\n\n  /**\n   * Updates the column validator for columns with a custom validator.\n   * @param mergedSettings The merged grid settings.\n   */\n  private updateColumnValidatorForGivenCustomValidator(mergedSettings: GridSettings): void {\n    if (!Array.isArray(mergedSettings?.columns)) {\n      return;\n    }\n\n    (mergedSettings?.columns as ColumnSettings[])\n      ?.filter((settings) => this.isCustomValidatorFn(settings.validator))\n      ?.forEach((cellSettings) => {\n        const customValidatorFn = cellSettings.validator as CustomValidatorFn<any>;\n\n        cellSettings.validator = (value: any, callback: (result: boolean) => void) => {\n          callback(customValidatorFn(value));\n        };\n      });\n  }\n\n  private isCustomValidatorFn(validator: unknown): validator is CustomValidatorFn<any> {\n    return typeof validator === 'function' && validator.length === 1;\n  }\n\n  private isEditorComponentRefType(editor: any): editor is Type<HotCellEditorComponent<any>> {\n    // ecmp - we need it to check if the editor is a component\n    return typeof editor === 'function' && !!(editor as any)?.ɵcmp;\n  }\n\n  private isRendererComponentRefType(renderer: any): renderer is Type<HotCellRendererComponent<any, any>> {\n    // ecmp - we need it to check if the renderer is a component\n    return typeof renderer === 'function' && !!(renderer as any)?.ɵcmp;\n  }\n\n  private isTemplateRef(renderer: any): renderer is TemplateRef<any> {\n    return renderer && typeof renderer.createEmbeddedView === 'function';\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hot-settings-resolver.service.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/services/hot-settings-resolver.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { createComponent, EnvironmentInjector, Injectable, NgZone, TemplateRef, Type } from '@angular/core';\nimport { DynamicComponentService } from '../renderer/hot-dynamic-renderer-component.service';\nimport { BaseEditorAdapter } from '../editor/base-editor-adapter';\nimport { GridSettings, GridSettingsInternal } from '../models/grid-settings';\nimport { CustomValidatorFn, ColumnSettings } from '../models/column-settings';\nimport { HotCellRendererComponent } from '../renderer/hot-cell-renderer.component';\nimport { HotCellEditorComponent } from '../editor/hot-cell-editor.component';\nimport Handsontable from 'handsontable/base';\nimport { FactoryEditorAdapter } from '../editor/editor-factory-adapter';\nimport { HotCellRendererAdvancedComponent } from '../renderer/hot-cell-renderer-advanced.component';\nimport { HotCellEditorAdvancedComponent } from '../editor/hot-cell-editor-advanced.component';\n\nconst AVAILABLE_OPTIONS: string[] = Object.keys(Handsontable.DefaultSettings);\nconst AVAILABLE_HOOKS: string[] = Handsontable.hooks.getRegistered();\n\n/**\n * Service to resolve and apply custom settings for Handsontable settings object.\n */\n@Injectable()\nexport class HotSettingsResolver {\n  constructor(private dynamicComponentService: DynamicComponentService, private readonly environmentInjector: EnvironmentInjector) {}\n\n  /**\n   * Applies custom settings to the provided GridSettings.\n   * @param settings The original grid settings.\n   * @param ngZone The NgZone instance to run hooks inside the zone context.\n   * @returns The merged grid settings with custom settings applied.\n   */\n  applyCustomSettings(settings: GridSettings, ngZone: NgZone): GridSettingsInternal {\n    const mergedSettings: GridSettings = settings;\n\n    this.updateColumnRendererForGivenCustomRenderer(mergedSettings);\n    this.updateColumnEditorForGivenCustomEditor(mergedSettings);\n    this.updateColumnValidatorForGivenCustomValidator(mergedSettings);\n\n    this.wrapHooksInNgZone(mergedSettings, ngZone);\n\n    return (mergedSettings as GridSettingsInternal) ?? {};\n  }\n\n  /**\n   * Ensures that hook callbacks in the provided grid settings run inside Angular's zone.\n   *\n   * @param settings The original grid settings.\n   * @param ngZone The NgZone instance to run hooks inside the zone context.\n   */\n  private wrapHooksInNgZone(settings: GridSettings, ngZone: NgZone) {\n    const options = AVAILABLE_HOOKS.concat(AVAILABLE_OPTIONS);\n\n    options.forEach((key) => {\n      const isHook = AVAILABLE_HOOKS.indexOf(key) > -1;\n      let option;\n\n      if (isHook) {\n        option = settings[key];\n      }\n\n      if (option === void 0) {\n        return;\n      } else if (!!ngZone && typeof option === 'function' && isHook) {\n        settings[key] = function (...args: any) {\n          return ngZone.run(() => option.apply(this, args));\n        };\n      } else {\n        settings[key] = option;\n      }\n    });\n  }\n\n  /**\n   * Updates the column renderer for columns with a custom renderer.\n   * @param mergedSettings The merged grid settings.\n   */\n  private updateColumnRendererForGivenCustomRenderer(mergedSettings: GridSettings): void {\n    if (!Array.isArray(mergedSettings?.columns)) {\n      return;\n    }\n\n    (mergedSettings?.columns as ColumnSettings[])\n      ?.filter((settings) => this.isCustomRenderer(settings.renderer))\n      ?.forEach((cellSettings) => {\n        const renderer = cellSettings.renderer;\n        const props: any = cellSettings.rendererProps ?? {};\n\n        if (this.isAdvancedRendererComponentRefType(renderer)) {\n          cellSettings.renderer = this.dynamicComponentService.createRendererWithFactory(renderer, props);\n        } else if (this.isRendererComponentRefType(renderer) || this.isTemplateRef(renderer)) {\n          cellSettings.renderer = this.dynamicComponentService.createRendererFromComponent(renderer, props);\n        }\n      });\n  }\n\n  /**\n   * Updates the column editor for columns with a custom editor.\n   * @param mergedSettings The merged grid settings.\n   */\n  private updateColumnEditorForGivenCustomEditor(mergedSettings: GridSettings): void {\n    if (!Array.isArray(mergedSettings?.columns)) {\n      return;\n    }\n\n    (mergedSettings?.columns as ColumnSettings[])\n      ?.filter((settings) => this.isEditorComponentRefType(settings.editor) || this.isAdvancedEditorComponentRefType(settings.editor))\n      ?.forEach((cellSettings) => {\n        if (this.isAdvancedEditorComponentRefType(cellSettings.editor)) {\n          const component = createComponent(cellSettings.editor, {\n            environmentInjector: this.environmentInjector,\n          });\n          cellSettings.editor = FactoryEditorAdapter(component);\n        } else {\n          const component = createComponent(cellSettings.editor as Type<HotCellEditorComponent<any>>, {\n            environmentInjector: this.environmentInjector,\n          });\n          cellSettings['_editorComponentReference'] = component;\n          cellSettings['_environmentInjector'] = this.environmentInjector;\n          cellSettings.editor = BaseEditorAdapter;\n        }\n      });\n  }\n\n  /**\n   * Updates the column validator for columns with a custom validator.\n   * @param mergedSettings The merged grid settings.\n   */\n  private updateColumnValidatorForGivenCustomValidator(mergedSettings: GridSettings): void {\n    if (!Array.isArray(mergedSettings?.columns)) {\n      return;\n    }\n\n    (mergedSettings?.columns as ColumnSettings[])\n      ?.filter((settings) => this.isCustomValidatorFn(settings.validator))\n      ?.forEach((cellSettings) => {\n        const customValidatorFn = cellSettings.validator as CustomValidatorFn<any>;\n\n        cellSettings.validator = (value: any, callback: (result: boolean) => void) => {\n          callback(customValidatorFn(value));\n        };\n      });\n  }\n\n  private isCustomValidatorFn(validator: unknown): validator is CustomValidatorFn<any> {\n    return typeof validator === 'function' && validator.length === 1;\n  }\n\n  private isEditorComponentRefType(editor: any): editor is Type<HotCellEditorComponent<any>> {\n    // ecmp - we need it to check if the editor is a component\n    return typeof editor === 'function' &&\n      !!(editor as any)?.ɵcmp &&\n      (editor as any)?.EDITOR_MARKER === HotCellEditorComponent.EDITOR_MARKER;\n  }\n\n  private isAdvancedEditorComponentRefType(editor: any): editor is Type<HotCellEditorAdvancedComponent<any>> {\n    // ecmp - we need it to check if the editor is a component\n    return typeof editor === 'function' &&\n      !!(editor as any)?.ɵcmp &&\n      (editor as any)?.EDITOR_MARKER === HotCellEditorAdvancedComponent.EDITOR_MARKER;\n  }\n\n  private isRendererComponentRefType(renderer: any): renderer is Type<HotCellRendererComponent<any, any>> {\n    // ecmp - we need it to check if the renderer is a component\n    return typeof renderer === 'function' &&\n      !!(renderer as any)?.ɵcmp &&\n      (renderer as any)?.RENDERER_MARKER === HotCellRendererComponent.RENDERER_MARKER;\n  }\n\n  private isAdvancedRendererComponentRefType(renderer: any): renderer is Type<HotCellRendererAdvancedComponent<any, any>> {\n    // ecmp - we need it to check if the renderer is a component\n    return typeof renderer === 'function' &&\n      !!(renderer as any)?.ɵcmp &&\n      (renderer as any)?.RENDERER_MARKER === HotCellRendererAdvancedComponent.RENDERER_MARKER;\n  }\n\n  private isTemplateRef(renderer: any): renderer is TemplateRef<any> {\n    return renderer && typeof renderer.createEmbeddedView === 'function';\n  }\n\n  private isCustomRenderer(renderer: any): renderer is Type<HotCellRendererComponent<any, any>> |\n    TemplateRef<any> |\n    Type<HotCellRendererAdvancedComponent<any, any>> {\n    return this.isRendererComponentRefType(renderer) ||\n      this.isTemplateRef(renderer) ||\n      this.isAdvancedRendererComponentRefType(renderer);\n  }\n}\n"]}

package/esm2022/public-api.mjs

@@ -8,4 +8,7 @@ export * from './lib/services/hot-global-config.service';
 export * from './lib/renderer/hot-dynamic-renderer-component.service';
 export * from './lib/renderer/hot-cell-renderer.component';
 export * from './lib/editor/hot-cell-editor.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2hvdC10YWJsZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsd0NBQXdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGhvdC10YWJsZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2hvdC10YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvaG90LXNldHRpbmdzLXJlc29sdmVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaG90LXRhYmxlLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9ob3QtZ2xvYmFsLWNvbmZpZy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlbmRlcmVyL2hvdC1keW5hbWljLXJlbmRlcmVyLWNvbXBvbmVudC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlbmRlcmVyL2hvdC1jZWxsLXJlbmRlcmVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9lZGl0b3IvaG90LWNlbGwtZWRpdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgeyBHcmlkU2V0dGluZ3MgfSBmcm9tICcuL2xpYi9tb2RlbHMvZ3JpZC1zZXR0aW5ncyc7XG5leHBvcnQgeyBDb2x1bW5TZXR0aW5ncywgQ3VzdG9tVmFsaWRhdG9yRm4gfSBmcm9tICcuL2xpYi9tb2RlbHMvY29sdW1uLXNldHRpbmdzJztcbiJdfQ==
+export * from './lib/renderer/hot-cell-renderer-advanced.component';
+export * from './lib/editor/hot-cell-editor-advanced.component';
+export * from './lib/editor/models/keyboard-shortcut-config';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2hvdC10YWJsZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsOENBQThDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGhvdC10YWJsZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2hvdC10YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvaG90LXNldHRpbmdzLXJlc29sdmVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaG90LXRhYmxlLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9ob3QtZ2xvYmFsLWNvbmZpZy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlbmRlcmVyL2hvdC1keW5hbWljLXJlbmRlcmVyLWNvbXBvbmVudC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlbmRlcmVyL2hvdC1jZWxsLXJlbmRlcmVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9lZGl0b3IvaG90LWNlbGwtZWRpdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZW5kZXJlci9ob3QtY2VsbC1yZW5kZXJlci1hZHZhbmNlZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZWRpdG9yL2hvdC1jZWxsLWVkaXRvci1hZHZhbmNlZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZWRpdG9yL21vZGVscy9rZXlib2FyZC1zaG9ydGN1dC1jb25maWcnO1xuZXhwb3J0IHsgR3JpZFNldHRpbmdzIH0gZnJvbSAnLi9saWIvbW9kZWxzL2dyaWQtc2V0dGluZ3MnO1xuZXhwb3J0IHsgQ29sdW1uU2V0dGluZ3MsIEN1c3RvbVZhbGlkYXRvckZuIH0gZnJvbSAnLi9saWIvbW9kZWxzL2NvbHVtbi1zZXR0aW5ncyc7XG4iXX0=