@handsontable/angular-wrapper 0.0.0-next-7e304b5-20250401

package/esm2022/lib/models/column-settings.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLXNldHRpbmdzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaG90LXRhYmxlL3NyYy9saWIvbW9kZWxzL2NvbHVtbi1zZXR0aW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50UmVmLCBFbnZpcm9ubWVudEluamVjdG9yLCBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgSGFuZHNvbnRhYmxlIGZyb20gJ2hhbmRzb250YWJsZSc7XG5pbXBvcnQgeyBIb3RDZWxsUmVuZGVyZXJDb21wb25lbnQgfSBmcm9tICcuLi9yZW5kZXJlci9ob3QtY2VsbC1yZW5kZXJlci5jb21wb25lbnQnO1xuaW1wb3J0IHsgSG90Q2VsbEVkaXRvckNvbXBvbmVudCB9IGZyb20gJy4uL2VkaXRvci9ob3QtY2VsbC1lZGl0b3IuY29tcG9uZW50JztcblxuZXhwb3J0IHR5cGUgQ3VzdG9tVmFsaWRhdG9yRm48VD4gPSAodmFsdWU6IFQpID0+IGJvb2xlYW47XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29sdW1uU2V0dGluZ3NcbiAgZXh0ZW5kcyBIYW5kc29udGFibGUuQ29sdW1uU2V0dGluZ3MsXG4gICAgQ3VzdG9tQ29sdW1uUHJvcGVydGllcyB7fVxuXG5leHBvcnQgaW50ZXJmYWNlIEN1c3RvbUNvbHVtblByb3BlcnRpZXMge1xuICByZW5kZXJlckNvbXBvbmVudD86IFR5cGU8SG90Q2VsbFJlbmRlcmVyQ29tcG9uZW50PjtcbiAgcmVuZGVyZXJDb21wb25lbnRQcm9wcz86IGFueTtcbiAgY3VzdG9tRWRpdG9yPzogVHlwZTxIb3RDZWxsRWRpdG9yQ29tcG9uZW50PGFueT4+O1xuICBjdXN0b21WYWxpZGF0b3I/OiBDdXN0b21WYWxpZGF0b3JGbjxhbnk+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEVkaXRvclJlZmVyZW5jZUludGVybmFsIHtcbiAgX2VkaXRvckNvbXBvbmVudFJlZmVyZW5jZT86IENvbXBvbmVudFJlZjxIb3RDZWxsRWRpdG9yQ29tcG9uZW50PGFueT4+O1xuICBfZW52aXJvbm1lbnRJbmplY3Rvcj86IEVudmlyb25tZW50SW5qZWN0b3I7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29sdW1uU2V0dGluZ3NJbnRlcm5hbFxuICBleHRlbmRzIE9taXQ8Q29sdW1uU2V0dGluZ3MsICdjdXN0b21WYWxpZGF0b3InPixcbiAgICBFZGl0b3JSZWZlcmVuY2VJbnRlcm5hbCxcbiAgICBDdXN0b21Db2x1bW5Qcm9wZXJ0aWVzIHt9XG4iXX0=

package/esm2022/lib/models/grid-settings.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JpZC1zZXR0aW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2hvdC10YWJsZS9zcmMvbGliL21vZGVscy9ncmlkLXNldHRpbmdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgSGFuZHNvbnRhYmxlIGZyb20gJ2hhbmRzb250YWJsZSc7XG5pbXBvcnQgeyBDb2x1bW5TZXR0aW5ncywgQ29sdW1uU2V0dGluZ3NJbnRlcm5hbCB9IGZyb20gJy4vY29sdW1uLXNldHRpbmdzJztcblxuZXhwb3J0IGludGVyZmFjZSBHcmlkU2V0dGluZ3MgZXh0ZW5kcyBIYW5kc29udGFibGUuR3JpZFNldHRpbmdzIHtcbiAgY29sdW1ucz86IENvbHVtblNldHRpbmdzW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgR3JpZFNldHRpbmdzSW50ZXJuYWwgZXh0ZW5kcyBPbWl0PEdyaWRTZXR0aW5ncywgJ2NvbHVtbnMnPiB7XG4gIGNvbHVtbnM/OlxuICAgIHwgQ29sdW1uU2V0dGluZ3NJbnRlcm5hbFtdXG4gICAgfCAoKGluZGV4OiBudW1iZXIpID0+IENvbHVtblNldHRpbmdzSW50ZXJuYWwpO1xufVxuIl19

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

@@ -0,0 +1,55 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Abstract base component for creating 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 HotCellRendererComponent {
+    static RENDERER_MARKER = Symbol('HotCellRendererComponent');
+    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: HotCellRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: HotCellRendererComponent, selector: "hot-cell-renderer", 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: HotCellRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'hot-cell-renderer',
+                    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG90LWNlbGwtcmVuZGVyZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaG90LXRhYmxlL3NyYy9saWIvcmVuZGVyZXIvaG90LWNlbGwtcmVuZGVyZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxTQUFTLEVBQUUsS0FBSyxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQUUvQzs7Ozs7OztHQU9HO0FBS0gsTUFBTSxPQUFnQix3QkFBd0I7SUFDNUMsTUFBTSxDQUFVLGVBQWUsR0FBRyxNQUFNLENBQUMsMEJBQTBCLENBQUMsQ0FBQztJQUU1RCxLQUFLLEdBQVcsRUFBWSxDQUFDO0lBRTdCLFFBQVEsQ0FBZTtJQUN2QixFQUFFLENBQXVCO0lBQ3pCLEdBQUcsQ0FBUztJQUNaLEdBQUcsQ0FBUztJQUNaLElBQUksQ0FBUztJQUV0Qjs7T0FFRztJQUNNLGNBQWMsQ0FBMkQ7SUFFbEY7Ozs7T0FJRztJQUNJLFFBQVE7UUFDYixPQUFPLElBQUksQ0FBQyxjQUFjLEVBQUUsYUFBYSxJQUFLLEVBQWEsQ0FBQztJQUM5RCxDQUFDO3dHQXZCbUIsd0JBQXdCOzRGQUF4Qix3QkFBd0IsNkxBRmxDLDhGQUE4Rjs7NEZBRXBGLHdCQUF3QjtrQkFKN0MsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsbUJBQW1CO29CQUM3QixRQUFRLEVBQUUsOEZBQThGO2lCQUN6Rzs4QkFJVSxLQUFLO3NCQUFiLEtBQUs7Z0JBRUcsUUFBUTtzQkFBaEIsS0FBSztnQkFDRyxFQUFFO3NCQUFWLEtBQUs7Z0JBQ0csR0FBRztzQkFBWCxLQUFLO2dCQUNHLEdBQUc7c0JBQVgsS0FBSztnQkFDRyxJQUFJO3NCQUFaLEtBQUs7Z0JBS0csY0FBYztzQkFBdEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBIYW5kc29udGFibGUgZnJvbSAnaGFuZHNvbnRhYmxlL2Jhc2UnO1xuaW1wb3J0IHtDb21wb25lbnQsIElucHV0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBBYnN0cmFjdCBiYXNlIGNvbXBvbmVudCBmb3IgY3JlYXRpbmcgY3VzdG9tIGNlbGwgcmVuZGVyZXIgY29tcG9uZW50cyBmb3IgSGFuZHNvbnRhYmxlLlxuICpcbiAqIFRoaXMgY2xhc3MgcHJvdmlkZXMgYSBjb21tb24gaW50ZXJmYWNlIGFuZCBwcm9wZXJ0aWVzIHJlcXVpcmVkIGJ5IGFueSBjdXN0b20gY2VsbCByZW5kZXJlci5cbiAqXG4gKiBAdGVtcGxhdGUgVFZhbHVlIC0gVGhlIHR5cGUgb2YgdGhlIGNvbXBvbmVudCByZW5kZXJlci5cbiAqIEB0ZW1wbGF0ZSBUUHJvcHMgLSBUaGUgdHlwZSBvZiBhZGRpdGlvbmFsIHJlbmRlcmVyIHByb3BlcnRpZXMuXG4gKi9cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2hvdC1jZWxsLXJlbmRlcmVyJyxcbiAgdGVtcGxhdGU6IGA8IS0tIFRoaXMgaXMgYW4gYWJzdHJhY3QgY29tcG9uZW50LiBFeHRlbmQgdGhpcyBjb21wb25lbnQgYW5kIHByb3ZpZGUgeW91ciBvd24gdGVtcGxhdGUuIC0tPmBcbn0pXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgSG90Q2VsbFJlbmRlcmVyQ29tcG9uZW50PFRWYWx1ZSBleHRlbmRzIHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4gPSBzdHJpbmcsIFRQcm9wcyBleHRlbmRzIHt9ID0gYW55PiB7XG4gIHN0YXRpYyByZWFkb25seSBSRU5ERVJFUl9NQVJLRVIgPSBTeW1ib2woJ0hvdENlbGxSZW5kZXJlckNvbXBvbmVudCcpO1xuXG4gIEBJbnB1dCgpIHZhbHVlOiBUVmFsdWUgPSAnJyBhcyBUVmFsdWU7XG5cbiAgQElucHV0KCkgaW5zdGFuY2U6IEhhbmRzb250YWJsZTtcbiAgQElucHV0KCkgdGQ6IEhUTUxUYWJsZUNlbGxFbGVtZW50O1xuICBASW5wdXQoKSByb3c6IG51bWJlcjtcbiAgQElucHV0KCkgY29sOiBudW1iZXI7XG4gIEBJbnB1dCgpIHByb3A6IHN0cmluZztcblxuICAvKipcbiAgICogVGhlIGNlbGwgcHJvcGVydGllcyBwcm92aWRlZCBieSBIYW5kc29udGFibGUsIGV4dGVuZGVkIHdpdGggb3B0aW9uYWwgcmVuZGVyZXItc3BlY2lmaWMgcHJvcGVydGllcy5cbiAgICovXG4gIEBJbnB1dCgpIGNlbGxQcm9wZXJ0aWVzOiBIYW5kc29udGFibGUuQ2VsbFByb3BlcnRpZXMgJiB7IHJlbmRlcmVyUHJvcHM/OiBUUHJvcHMgfTtcblxuICAvKipcbiAgICogUmV0cmlldmVzIHRoZSByZW5kZXJlci1zcGVjaWZpYyBwcm9wZXJ0aWVzIGZyb20gdGhlIGNlbGwgcHJvcGVydGllcy5cbiAgICpcbiAgICogQHJldHVybnMgVGhlIGFkZGl0aW9uYWwgcHJvcGVydGllcyBmb3IgdGhlIHJlbmRlcmVyLlxuICAgKi9cbiAgcHVibGljIGdldFByb3BzKCk6IFRQcm9wcyB7XG4gICAgcmV0dXJuIHRoaXMuY2VsbFByb3BlcnRpZXM/LnJlbmRlcmVyUHJvcHMgPz8gKHt9IGFzIFRQcm9wcyk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,151 @@
+import { createComponent, Injectable } from '@angular/core';
+import { baseRenderer } from 'handsontable/renderers';
+import Handsontable from 'handsontable';
+import { HotCellRendererComponent } from './hot-cell-renderer.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.';
+/**
+ * Type guard that checks if the given object is a TemplateRef.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is a TemplateRef; otherwise, false.
+ */
+export function isTemplateRef(obj) {
+    return obj && typeof obj.createEmbeddedView === 'function';
+}
+/**
+ * Type guard to check if an object is an instance of HotCellRendererComponent.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is a HotCellRendererComponent, false otherwise.
+ */
+export function isHotCellRendererComponent(obj) {
+    return obj?.RENDERER_MARKER === HotCellRendererComponent.RENDERER_MARKER;
+}
+/**
+ * Service for dynamically creating Angular components or templates as custom renderers for Handsontable.
+ *
+ * This service allows you to create a renderer function that wraps a given Angular component or TemplateRef
+ * so that it can be used as a Handsontable renderer.
+ *
+ * @example
+ * const customRenderer = dynamicComponentService.createRendererFromComponent(MyRendererComponent, { someProp: value });
+ * // Use customRenderer in your Handsontable configuration
+ */
+export class DynamicComponentService {
+    appRef;
+    environmentInjector;
+    constructor(appRef, environmentInjector) {
+        this.appRef = appRef;
+        this.environmentInjector = environmentInjector;
+    }
+    /**
+     * Creates a custom renderer function for Handsontable from an Angular component or TemplateRef.
+     * The generated renderer function will be used by Handsontable to render cell content.
+     *
+     * @param component - The Angular component type or TemplateRef 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.
+     */
+    createRendererFromComponent(component, componentProps = {}, register = false) {
+        return (instance, td, row, col, prop, value, cellProperties) => {
+            const properties = {
+                value, instance, td, row, col, prop, cellProperties
+            };
+            if (componentProps) {
+                Object.assign(cellProperties, { rendererProps: componentProps });
+            }
+            const rendererParameters = [
+                instance, td, row, col, prop, value, cellProperties
+            ];
+            baseRenderer.apply(this, rendererParameters);
+            td.innerHTML = '';
+            if (isTemplateRef(component)) {
+                this.attachTemplateToElement(component, td, properties);
+            }
+            else if (isHotCellRendererComponent(component)) {
+                const componentRef = this.createComponent(component, properties);
+                this.attachComponentToElement(componentRef, td);
+            }
+            else {
+                console.warn(INVALID_RENDERER_WARNING);
+            }
+            if (register && isHotCellRendererComponent(component)) {
+                Handsontable.renderers.registerRenderer(component.constructor.name, component);
+            }
+            return td;
+        };
+    }
+    /**
+     * Attaches an embedded view created from a TemplateRef to a given DOM element.
+     *
+     * @param template - The TemplateRef to create an embedded view from.
+     * @param tdEl - The target DOM element (a table cell) to which the view will be appended.
+     * @param properties - Context object providing properties to be used within the template.
+     */
+    attachTemplateToElement(template, tdEl, properties) {
+        const embeddedView = template.createEmbeddedView({
+            $implicit: properties.value,
+            ...properties,
+        });
+        embeddedView.detectChanges();
+        embeddedView.rootNodes.forEach((node) => {
+            tdEl.appendChild(node);
+        });
+    }
+    /**
+     * Dynamically creates an Angular component of the given type.
+     *
+     * @param component - The Angular component type to be created.
+     * @param rendererParameters - An object containing input properties to assign to the component instance.
+     * @returns The ComponentRef of the dynamically created component.
+     */
+    createComponent(component, rendererParameters) {
+        const componentRef = createComponent(component, {
+            environmentInjector: this.environmentInjector
+        });
+        Object.keys(rendererParameters).forEach(key => {
+            if (rendererParameters.hasOwnProperty(key)) {
+                componentRef.setInput(key, rendererParameters[key]);
+            }
+            else {
+                console.warn(`Input property "${key}" does not exist on component instance: ${component?.name}.`);
+            }
+        });
+        componentRef.changeDetectorRef.detectChanges();
+        this.appRef.attachView(componentRef.hostView);
+        return componentRef;
+    }
+    /**
+     * Attaches a dynamically created component's view to a specified DOM container element.
+     *
+     * @param componentRef - The reference to the dynamically created component.
+     * @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];
+        container.appendChild(domElem);
+    }
+    /**
+     * Destroys a dynamically created component and detaches its view from the Angular application.
+     *
+     * @param componentRef - The reference to the component to be destroyed.
+     */
+    destroyComponent(componentRef) {
+        this.appRef.detachView(componentRef.hostView);
+        componentRef.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicComponentService, deps: [{ token: i0.ApplicationRef }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicComponentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicComponentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    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';\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"]}

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

@@ -0,0 +1,97 @@
+import { Injectable, InjectionToken, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * A constant representing the non-commercial and evaluation license.
+ * */
+export const NON_COMMERCIAL_LICENSE = 'non-commercial-and-evaluation';
+/**
+ * Injection token for providing a global default configuration.
+ */
+export const HOT_GLOBAL_CONFIG = new InjectionToken('HOT_GLOBAL_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({})
+});
+/**
+ * Service for configuring Handsontable settings.
+ * This service allows setting and retrieving global configuration.
+ */
+export class HotConfigService {
+    /**
+     * The default configuration object for Handsontable.
+     *
+     * This object is used as the initial value for the configuration BehaviorSubject.
+     * It can be overridden by a global configuration provided through the
+     * {@link HOT_GLOBAL_CONFIG} injection token.
+     *
+     * @private
+     * @type {HotConfig}
+     */
+    defaultConfig = {
+        license: undefined,
+        themeName: ''
+    };
+    /**
+     * A BehaviorSubject that holds the current Handsontable configuration.
+     *
+     * New configuration values can be emitted by calling next() on this subject.
+     * This allows subscribers to react to configuration changes dynamically.
+     *
+     * @private
+     * @type {BehaviorSubject<HotConfig>}
+     */
+    configSubject = new BehaviorSubject(this.defaultConfig);
+    /**
+     * An Observable stream of the current Handsontable configuration.
+     *
+     * Components can subscribe to this observable to receive updates whenever the configuration changes.
+     *
+     * @returns The configuration as an observable stream.
+     */
+    get config$() {
+        return this.configSubject.asObservable();
+    }
+    constructor(globalConfig) {
+        // Merge global configuration (if provided) into defaultConfig immutably.
+        this.defaultConfig = { ...this.defaultConfig, ...globalConfig };
+        this.configSubject.next(this.defaultConfig);
+    }
+    /**
+     * Sets the configuration for Handsontable.
+     *
+     * @param config - An object containing configuration options.
+     *                 If a some parameter is provided, it will override the current settings.
+     */
+    setConfig(config) {
+        const currentConfig = this.configSubject.value;
+        const newConfig = { ...currentConfig, ...config };
+        this.configSubject.next(newConfig);
+    }
+    /**
+     * Retrieves the current Handsontable configuration.
+     *
+     * @returns An object with the current settings.
+     */
+    getConfig() {
+        return this.configSubject.value;
+    }
+    /**
+     * Resets the configuration to the default settings.
+     * This method updates the configuration BehaviorSubject with the default configuration.
+     */
+    resetConfig() {
+        this.configSubject.next({ ...this.defaultConfig });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotConfigService, deps: [{ token: HOT_GLOBAL_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HOT_GLOBAL_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,74 @@
+import { createComponent, Injectable, } from '@angular/core';
+import { BaseEditorAdapter } from '../editor/base-editor-adapter';
+import * as i0 from "@angular/core";
+import * as i1 from "../renderer/hot-dynamic-renderer-component.service";
+/**
+ * Service to resolve and apply custom settings for Handsontable settings object.
+ */
+export class HotSettingsResolver {
+    dynamicComponentService;
+    environmentInjector;
+    constructor(dynamicComponentService, environmentInjector) {
+        this.dynamicComponentService = dynamicComponentService;
+        this.environmentInjector = environmentInjector;
+    }
+    /**
+     * Applies custom settings to the provided GridSettings.
+     * @param settings The original grid settings.
+     * @returns The merged grid settings with custom settings applied.
+     */
+    applyCustomSettings(settings) {
+        const mergedSettings = settings;
+        this.updateColumnRendererForGivenCustomRenderer(mergedSettings);
+        this.updateColumnEditorForGivenCustomEditor(mergedSettings);
+        this.updateColumnValidatorForGivenCustomValidator(mergedSettings);
+        return mergedSettings ?? {};
+    }
+    /**
+     * Updates the column renderer for columns with a custom renderer.
+     * @param mergedSettings The merged grid settings.
+     */
+    updateColumnRendererForGivenCustomRenderer(mergedSettings) {
+        mergedSettings?.columns
+            ?.filter((settings) => settings.componentRenderer)
+            ?.forEach((cellSettings) => {
+            const props = cellSettings.componentRendererProps ?? {};
+            cellSettings.renderer =
+                this.dynamicComponentService.createRendererFromComponent(cellSettings.componentRenderer, props);
+        });
+    }
+    /**
+     * Updates the column editor for columns with a custom editor.
+     * @param mergedSettings The merged grid settings.
+     */
+    updateColumnEditorForGivenCustomEditor(mergedSettings) {
+        mergedSettings?.columns
+            ?.filter((settings) => settings.customEditor)
+            ?.forEach((cellSettings) => {
+            cellSettings.editor = BaseEditorAdapter;
+            cellSettings._editorComponentReference = createComponent(cellSettings.customEditor, {
+                environmentInjector: this.environmentInjector,
+            });
+            cellSettings._environmentInjector = this.environmentInjector;
+        });
+    }
+    /**
+     * Updates the column validator for columns with a custom validator.
+     * @param mergedSettings The merged grid settings.
+     */
+    updateColumnValidatorForGivenCustomValidator(mergedSettings) {
+        mergedSettings?.columns
+            ?.filter((settings) => settings.customValidator)
+            ?.forEach((cellSettings) => {
+            cellSettings.validator = (value, callback) => {
+                callback(cellSettings.customValidator(value));
+            };
+        });
+    }
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG90LXNldHRpbmdzLXJlc29sdmVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ob3QtdGFibGUvc3JjL2xpYi9zZXJ2aWNlcy9ob3Qtc2V0dGluZ3MtcmVzb2x2ZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUVmLFVBQVUsR0FDWCxNQUFNLGVBQWUsQ0FBQztBQUV2QixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7O0FBT2xFOztHQUVHO0FBRUgsTUFBTSxPQUFPLG1CQUFtQjtJQUVwQjtJQUNTO0lBRm5CLFlBQ1UsdUJBQWdELEVBQ3ZDLG1CQUF3QztRQURqRCw0QkFBdUIsR0FBdkIsdUJBQXVCLENBQXlCO1FBQ3ZDLHdCQUFtQixHQUFuQixtQkFBbUIsQ0FBcUI7SUFDeEQsQ0FBQztJQUVKOzs7O09BSUc7SUFDSCxtQkFBbUIsQ0FBQyxRQUFzQjtRQUN4QyxNQUFNLGNBQWMsR0FBeUIsUUFBUSxDQUFDO1FBRXRELElBQUksQ0FBQywwQ0FBMEMsQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUNoRSxJQUFJLENBQUMsc0NBQXNDLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLDRDQUE0QyxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBRWxFLE9BQU8sY0FBYyxJQUFJLEVBQUUsQ0FBQztJQUM5QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ssMENBQTBDLENBQ2hELGNBQW9DO1FBRW5DLGNBQWMsRUFBRSxPQUFvQztZQUNuRCxFQUFFLE1BQU0sQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDO1lBQ2xELEVBQUUsT0FBTyxDQUFDLENBQUMsWUFBWSxFQUFFLEVBQUU7WUFDekIsTUFBTSxLQUFLLEdBQVEsWUFBWSxDQUFDLHNCQUFzQixJQUFJLEVBQUUsQ0FBQztZQUM3RCxZQUFZLENBQUMsUUFBUTtnQkFDbkIsSUFBSSxDQUFDLHVCQUF1QixDQUFDLDJCQUEyQixDQUN0RCxZQUFZLENBQUMsaUJBQWlCLEVBQzlCLEtBQUssQ0FDTixDQUFDO1FBQ04sQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ssc0NBQXNDLENBQzVDLGNBQW9DO1FBRW5DLGNBQWMsRUFBRSxPQUE0QjtZQUMzQyxFQUFFLE1BQU0sQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQztZQUM3QyxFQUFFLE9BQU8sQ0FBQyxDQUFDLFlBQVksRUFBRSxFQUFFO1lBQ3pCLFlBQVksQ0FBQyxNQUFNLEdBQUcsaUJBQWlCLENBQUM7WUFDeEMsWUFBWSxDQUFDLHlCQUF5QixHQUFHLGVBQWUsQ0FDdEQsWUFBWSxDQUFDLFlBQVksRUFDekI7Z0JBQ0UsbUJBQW1CLEVBQUUsSUFBSSxDQUFDLG1CQUFtQjthQUM5QyxDQUNGLENBQUM7WUFDRixZQUFZLENBQUMsb0JBQW9CLEdBQUcsSUFBSSxDQUFDLG1CQUFtQixDQUFDO1FBQy9ELENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVEOzs7T0FHRztJQUNLLDRDQUE0QyxDQUNsRCxjQUFvQztRQUVuQyxjQUFjLEVBQUUsT0FBb0M7WUFDbkQsRUFBRSxNQUFNLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7WUFDaEQsRUFBRSxPQUFPLENBQUMsQ0FBQyxZQUFZLEVBQUUsRUFBRTtZQUN6QixZQUFZLENBQUMsU0FBUyxHQUFHLENBQ3ZCLEtBQVUsRUFDVixRQUFtQyxFQUNuQyxFQUFFO2dCQUNGLFFBQVEsQ0FBQyxZQUFZLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7WUFDaEQsQ0FBQyxDQUFDO1FBQ0osQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO3dHQTlFVSxtQkFBbUI7NEdBQW5CLG1CQUFtQjs7NEZBQW5CLG1CQUFtQjtrQkFEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIGNyZWF0ZUNvbXBvbmVudCxcbiAgRW52aXJvbm1lbnRJbmplY3RvcixcbiAgSW5qZWN0YWJsZSxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEeW5hbWljQ29tcG9uZW50U2VydmljZSB9IGZyb20gJy4uL3JlbmRlcmVyL2hvdC1keW5hbWljLXJlbmRlcmVyLWNvbXBvbmVudC5zZXJ2aWNlJztcbmltcG9ydCB7IEJhc2VFZGl0b3JBZGFwdGVyIH0gZnJvbSAnLi4vZWRpdG9yL2Jhc2UtZWRpdG9yLWFkYXB0ZXInO1xuaW1wb3J0IHsgR3JpZFNldHRpbmdzLCBHcmlkU2V0dGluZ3NJbnRlcm5hbCB9IGZyb20gJy4uL21vZGVscy9ncmlkLXNldHRpbmdzJztcbmltcG9ydCB7XG4gIENvbHVtblNldHRpbmdzLFxuICBDb2x1bW5TZXR0aW5nc0ludGVybmFsLFxufSBmcm9tICcuLi9tb2RlbHMvY29sdW1uLXNldHRpbmdzJztcblxuLyoqXG4gKiBTZXJ2aWNlIHRvIHJlc29sdmUgYW5kIGFwcGx5IGN1c3RvbSBzZXR0aW5ncyBmb3IgSGFuZHNvbnRhYmxlIHNldHRpbmdzIG9iamVjdC5cbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEhvdFNldHRpbmdzUmVzb2x2ZXIge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIGR5bmFtaWNDb21wb25lbnRTZXJ2aWNlOiBEeW5hbWljQ29tcG9uZW50U2VydmljZSxcbiAgICBwcml2YXRlIHJlYWRvbmx5IGVudmlyb25tZW50SW5qZWN0b3I6IEVudmlyb25tZW50SW5qZWN0b3JcbiAgKSB7fVxuXG4gIC8qKlxuICAgKiBBcHBsaWVzIGN1c3RvbSBzZXR0aW5ncyB0byB0aGUgcHJvdmlkZWQgR3JpZFNldHRpbmdzLlxuICAgKiBAcGFyYW0gc2V0dGluZ3MgVGhlIG9yaWdpbmFsIGdyaWQgc2V0dGluZ3MuXG4gICAqIEByZXR1cm5zIFRoZSBtZXJnZWQgZ3JpZCBzZXR0aW5ncyB3aXRoIGN1c3RvbSBzZXR0aW5ncyBhcHBsaWVkLlxuICAgKi9cbiAgYXBwbHlDdXN0b21TZXR0aW5ncyhzZXR0aW5nczogR3JpZFNldHRpbmdzKTogR3JpZFNldHRpbmdzSW50ZXJuYWwge1xuICAgIGNvbnN0IG1lcmdlZFNldHRpbmdzOiBHcmlkU2V0dGluZ3NJbnRlcm5hbCA9IHNldHRpbmdzO1xuXG4gICAgdGhpcy51cGRhdGVDb2x1bW5SZW5kZXJlckZvckdpdmVuQ3VzdG9tUmVuZGVyZXIobWVyZ2VkU2V0dGluZ3MpO1xuICAgIHRoaXMudXBkYXRlQ29sdW1uRWRpdG9yRm9yR2l2ZW5DdXN0b21FZGl0b3IobWVyZ2VkU2V0dGluZ3MpO1xuICAgIHRoaXMudXBkYXRlQ29sdW1uVmFsaWRhdG9yRm9yR2l2ZW5DdXN0b21WYWxpZGF0b3IobWVyZ2VkU2V0dGluZ3MpO1xuXG4gICAgcmV0dXJuIG1lcmdlZFNldHRpbmdzID8/IHt9O1xuICB9XG5cbiAgLyoqXG4gICAqIFVwZGF0ZXMgdGhlIGNvbHVtbiByZW5kZXJlciBmb3IgY29sdW1ucyB3aXRoIGEgY3VzdG9tIHJlbmRlcmVyLlxuICAgKiBAcGFyYW0gbWVyZ2VkU2V0dGluZ3MgVGhlIG1lcmdlZCBncmlkIHNldHRpbmdzLlxuICAgKi9cbiAgcHJpdmF0ZSB1cGRhdGVDb2x1bW5SZW5kZXJlckZvckdpdmVuQ3VzdG9tUmVuZGVyZXIoXG4gICAgbWVyZ2VkU2V0dGluZ3M6IEdyaWRTZXR0aW5nc0ludGVybmFsXG4gICk6IHZvaWQge1xuICAgIChtZXJnZWRTZXR0aW5ncz8uY29sdW1ucyBhcyBDb2x1bW5TZXR0aW5nc0ludGVybmFsW10pXG4gICAgICA/LmZpbHRlcigoc2V0dGluZ3MpID0+IHNldHRpbmdzLmNvbXBvbmVudFJlbmRlcmVyKVxuICAgICAgPy5mb3JFYWNoKChjZWxsU2V0dGluZ3MpID0+IHtcbiAgICAgICAgY29uc3QgcHJvcHM6IGFueSA9IGNlbGxTZXR0aW5ncy5jb21wb25lbnRSZW5kZXJlclByb3BzID8/IHt9O1xuICAgICAgICBjZWxsU2V0dGluZ3MucmVuZGVyZXIgPVxuICAgICAgICAgIHRoaXMuZHluYW1pY0NvbXBvbmVudFNlcnZpY2UuY3JlYXRlUmVuZGVyZXJGcm9tQ29tcG9uZW50KFxuICAgICAgICAgICAgY2VsbFNldHRpbmdzLmNvbXBvbmVudFJlbmRlcmVyLFxuICAgICAgICAgICAgcHJvcHNcbiAgICAgICAgICApO1xuICAgICAgfSk7XG4gIH1cblxuICAvKipcbiAgICogVXBkYXRlcyB0aGUgY29sdW1uIGVkaXRvciBmb3IgY29sdW1ucyB3aXRoIGEgY3VzdG9tIGVkaXRvci5cbiAgICogQHBhcmFtIG1lcmdlZFNldHRpbmdzIFRoZSBtZXJnZWQgZ3JpZCBzZXR0aW5ncy5cbiAgICovXG4gIHByaXZhdGUgdXBkYXRlQ29sdW1uRWRpdG9yRm9yR2l2ZW5DdXN0b21FZGl0b3IoXG4gICAgbWVyZ2VkU2V0dGluZ3M6IEdyaWRTZXR0aW5nc0ludGVybmFsXG4gICk6IHZvaWQge1xuICAgIChtZXJnZWRTZXR0aW5ncz8uY29sdW1ucyBhcyBDb2x1bW5TZXR0aW5nc1tdKVxuICAgICAgPy5maWx0ZXIoKHNldHRpbmdzKSA9PiBzZXR0aW5ncy5jdXN0b21FZGl0b3IpXG4gICAgICA/LmZvckVhY2goKGNlbGxTZXR0aW5ncykgPT4ge1xuICAgICAgICBjZWxsU2V0dGluZ3MuZWRpdG9yID0gQmFzZUVkaXRvckFkYXB0ZXI7XG4gICAgICAgIGNlbGxTZXR0aW5ncy5fZWRpdG9yQ29tcG9uZW50UmVmZXJlbmNlID0gY3JlYXRlQ29tcG9uZW50KFxuICAgICAgICAgIGNlbGxTZXR0aW5ncy5jdXN0b21FZGl0b3IsXG4gICAgICAgICAge1xuICAgICAgICAgICAgZW52aXJvbm1lbnRJbmplY3RvcjogdGhpcy5lbnZpcm9ubWVudEluamVjdG9yLFxuICAgICAgICAgIH1cbiAgICAgICAgKTtcbiAgICAgICAgY2VsbFNldHRpbmdzLl9lbnZpcm9ubWVudEluamVjdG9yID0gdGhpcy5lbnZpcm9ubWVudEluamVjdG9yO1xuICAgICAgfSk7XG4gIH1cblxuICAvKipcbiAgICogVXBkYXRlcyB0aGUgY29sdW1uIHZhbGlkYXRvciBmb3IgY29sdW1ucyB3aXRoIGEgY3VzdG9tIHZhbGlkYXRvci5cbiAgICogQHBhcmFtIG1lcmdlZFNldHRpbmdzIFRoZSBtZXJnZWQgZ3JpZCBzZXR0aW5ncy5cbiAgICovXG4gIHByaXZhdGUgdXBkYXRlQ29sdW1uVmFsaWRhdG9yRm9yR2l2ZW5DdXN0b21WYWxpZGF0b3IoXG4gICAgbWVyZ2VkU2V0dGluZ3M6IEdyaWRTZXR0aW5nc0ludGVybmFsXG4gICk6IHZvaWQge1xuICAgIChtZXJnZWRTZXR0aW5ncz8uY29sdW1ucyBhcyBDb2x1bW5TZXR0aW5nc0ludGVybmFsW10pXG4gICAgICA/LmZpbHRlcigoc2V0dGluZ3MpID0+IHNldHRpbmdzLmN1c3RvbVZhbGlkYXRvcilcbiAgICAgID8uZm9yRWFjaCgoY2VsbFNldHRpbmdzKSA9PiB7XG4gICAgICAgIGNlbGxTZXR0aW5ncy52YWxpZGF0b3IgPSAoXG4gICAgICAgICAgdmFsdWU6IGFueSxcbiAgICAgICAgICBjYWxsYmFjazogKHJlc3VsdDogYm9vbGVhbikgPT4gdm9pZFxuICAgICAgICApID0+IHtcbiAgICAgICAgICBjYWxsYmFjayhjZWxsU2V0dGluZ3MuY3VzdG9tVmFsaWRhdG9yKHZhbHVlKSk7XG4gICAgICAgIH07XG4gICAgICB9KTtcbiAgfVxufVxuIl19

package/esm2022/public-api.mjs

@@ -0,0 +1,11 @@
+/*
+ * Public API Surface of hot-table
+ */
+export * from './lib/hot-table.component';
+export * from './lib/services/hot-settings-resolver.service';
+export * from './lib/hot-table.module';
+export * from './lib/services/hot-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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2hvdC10YWJsZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsd0NBQXdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGhvdC10YWJsZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2hvdC10YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvaG90LXNldHRpbmdzLXJlc29sdmVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaG90LXRhYmxlLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9ob3QtY29uZmlnLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmVuZGVyZXIvaG90LWR5bmFtaWMtcmVuZGVyZXItY29tcG9uZW50LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmVuZGVyZXIvaG90LWNlbGwtcmVuZGVyZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2VkaXRvci9ob3QtY2VsbC1lZGl0b3IuY29tcG9uZW50JztcbmV4cG9ydCB7IEdyaWRTZXR0aW5ncyB9IGZyb20gJy4vbGliL21vZGVscy9ncmlkLXNldHRpbmdzJztcbmV4cG9ydCB7XG4gIENvbHVtblNldHRpbmdzLFxuICBDdXN0b21WYWxpZGF0b3JGbixcbiAgQ3VzdG9tQ29sdW1uUHJvcGVydGllcyxcbn0gZnJvbSAnLi9saWIvbW9kZWxzL2NvbHVtbi1zZXR0aW5ncyc7XG4iXX0=