@handsontable/angular-wrapper
Version:
Best Data Grid for Angular with Spreadsheet Look and Feel.
150 lines • 21.1 kB
JavaScript
import { createComponent, Injectable } from '@angular/core';
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
];
Handsontable.renderers.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} 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      Handsontable.renderers.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"]}