@dotglitch/ngx-common 1.0.2

package/README.md

@@ -0,0 +1,24 @@
+# Utils
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 15.1.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project utils` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project utils`.
+> Note: Don't forget to add `--project utils` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build utils` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build utils`, go to the dist folder `cd dist/utils` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test utils` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/components/dynamic-html/dynamic-html.component.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef, SimpleChanges, OnChanges, OnDestroy, DoCheck } from '@angular/core';
+import { DynamicHTMLRenderer } from './dynamic-html.service';
+import * as i0 from "@angular/core";
+export declare class DynamicHTMLComponent implements DoCheck, OnChanges, OnDestroy {
+    private renderer;
+    private elementRef;
+    content: string;
+    private ref;
+    constructor(renderer: DynamicHTMLRenderer, elementRef: ElementRef);
+    ngOnChanges(_: SimpleChanges): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicHTMLComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicHTMLComponent, "dynamic-html", never, { "content": "content"; }, {}, never, never, true, never>;
+}

package/components/dynamic-html/dynamic-html.module.d.ts

@@ -0,0 +1,10 @@
+import { ModuleWithProviders } from '@angular/core';
+import { DynamicHTMLOptions } from './types';
+import * as i0 from "@angular/core";
+import * as i1 from "./dynamic-html.component";
+export declare class NgxDynamicHTMLModule {
+    static forRoot(config: DynamicHTMLOptions): ModuleWithProviders<NgxDynamicHTMLModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDynamicHTMLModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDynamicHTMLModule, never, [typeof i1.DynamicHTMLComponent], [typeof i1.DynamicHTMLComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxDynamicHTMLModule>;
+}

package/components/dynamic-html/dynamic-html.service.d.ts

@@ -0,0 +1,18 @@
+import { Injector, ElementRef, ComponentFactoryResolver } from '@angular/core';
+import { DynamicHTMLOptions } from './types';
+import * as i0 from "@angular/core";
+export interface DynamicHTMLRef {
+    check: () => void;
+    destroy: () => void;
+}
+export declare class DynamicHTMLRenderer {
+    private config;
+    private cfr;
+    private injector;
+    private componentFactories;
+    private componentRefs;
+    constructor(config: DynamicHTMLOptions, cfr: ComponentFactoryResolver, injector: Injector);
+    renderInnerHTML(elementRef: ElementRef, html: string): DynamicHTMLRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicHTMLRenderer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicHTMLRenderer>;
+}

package/components/dynamic-html/types.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken, Type } from '@angular/core';
+export declare abstract class OnMount {
+    abstract dynamicOnMount(attrs?: Map<string, string>, content?: string, element?: Element): void;
+}
+export interface ComponentWithSelector {
+    selector: string;
+    component: Type<any>;
+}
+export declare class DynamicHTMLOptions {
+    components: Array<ComponentWithSelector>;
+}
+export declare const NGX_DYNAMIC_CONFIG: InjectionToken<DynamicHTMLOptions>;

package/components/lazy-loader/lazy-loader.component.d.ts

@@ -0,0 +1,146 @@
+import { ViewContainerRef, ComponentRef, EventEmitter, AfterViewInit } from '@angular/core';
+import { DialogRef } from '@angular/cdk/dialog';
+import { LazyLoaderService } from './lazy-loader.service';
+import { NgxLazyLoaderConfig } from './types';
+import * as i0 from "@angular/core";
+export declare class LazyLoaderComponent implements AfterViewInit {
+    private service;
+    private viewContainerRef;
+    dialog: DialogRef;
+    dialogArguments: any;
+    targetContainer: ViewContainerRef;
+    /**
+     * ! Here be dragons.
+     * Only the bravest of Adventurers can survive the battles below,
+     * and they must be trained and ready for the gruelling journey ahead.
+     * Many a soul has tried to best these Dragons, yet only one has
+     * succeeded since our founding.
+     *
+     * TL;DR -- Don't mess with this unless you know what you're doing.
+     *     This is central to a ton of moving parts -- breaking it will
+     *     cause more collateral damage than you may realize.
+     */
+    private _id;
+    /**
+     * The id of the component that will be lazy loaded
+     */
+    set id(data: string);
+    private _group;
+    set group(data: string);
+    get group(): string;
+    private _matchGroups;
+    private _inputs;
+    /**
+     * A map of inputs to bind to the child.
+     * Supports change detection. (May fail on deep JSON changes)
+     *
+     * ```html
+     * <lazy-loader component="MyLazyComponent"
+     *       [inputs]="{
+     *          prop1: true,
+     *          prop2: false,
+     *          complex: {
+     *              a: true,
+     *              b: 0
+     *          }
+     *       }"
+     * >
+     * </lazy-loader>
+     * ```
+     */
+    set inputs(data: {
+        [key: string]: any;
+    });
+    private outputSubscriptions;
+    private _outputs;
+    /**
+     * A map of outputs to bind from the child.
+     * Should support change detection.
+     * ```html
+     * <lazy-loader component="MyLazyComponent"
+     *       [outputs]="{
+     *           prop3: onOutputFire
+     *       }"
+     * >
+     * </lazy-loader>
+     * ```
+     */
+    set outputs(data: {
+        [key: string]: Function;
+    });
+    /**
+     * Emits errors encountered when loading components
+     */
+    componentLoadError: EventEmitter<any>;
+    /**
+     * Emits when the component is fully constructed
+     * and had it's inputs and outputs bound
+     * > before `OnInit`
+     *
+     * Returns the active class instance of the lazy-loaded component
+     */
+    componentLoaded: EventEmitter<any>;
+    /**
+     * This is an instance of the component that is currently loaded.
+     */
+    instance: any;
+    /**
+     * Container that provides the component data
+     */
+    private targetModule;
+    /**
+     * Component definition
+     */
+    private targetComponentFactory;
+    /**
+     * Active component container reference
+     */
+    private targetComponentContainerRef;
+    private targetRef;
+    /**
+     * Reference to the component class instance
+     */
+    private targetComponentInstance;
+    /**
+     * Subscription with true/false state on whether the distractor should be
+     */
+    private distractorSubscription;
+    config: NgxLazyLoaderConfig;
+    private err;
+    private warn;
+    private log;
+    private loaderEmitter;
+    private clearLoader$;
+    private loaderSub;
+    showLoader: boolean;
+    isClearingLoader: boolean;
+    constructor(service: LazyLoaderService, viewContainerRef: ViewContainerRef, dialog: DialogRef, dialogArguments: any);
+    private initialized;
+    ngAfterViewInit(): Promise<void | ComponentRef<any>>;
+    ngOnDestroy(clearAll?: boolean): void;
+    /**
+     * Bind the input values to the child component.
+     */
+    private bindInputs;
+    /**
+     * Bind the output handlers to the loaded child component
+     */
+    private bindOutputs;
+    /**
+     * Load the "Default" component (404) screen normally.
+     * This is shown when the component id isn't in the
+     * registry or otherwise doesn't match
+     *
+     * This
+     */
+    private loadDefault;
+    /**
+     * Load the "Error" component.
+     * This is shown when we are able to resolve the component
+     * in the registry, but have some issue boostrapping the
+     * component into the viewContainer
+     */
+    private loadError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyLoaderComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LazyLoaderComponent, "ngx-lazy-loader", never, { "id": "component"; "group": "group"; "inputs": "inputs"; "outputs": "outputs"; }, { "componentLoadError": "componentLoadError"; "componentLoaded": "componentLoaded"; }, never, never, true, never>;
+}

package/components/lazy-loader/lazy-loader.module.d.ts

@@ -0,0 +1,10 @@
+import { ModuleWithProviders } from '@angular/core';
+import { NgxLazyLoaderConfig } from './types';
+import * as i0 from "@angular/core";
+import * as i1 from "./lazy-loader.component";
+export declare class LazyLoaderModule {
+    static forRoot(config: NgxLazyLoaderConfig): ModuleWithProviders<LazyLoaderModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LazyLoaderModule, never, [typeof i1.LazyLoaderComponent], [typeof i1.LazyLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LazyLoaderModule>;
+}

package/components/lazy-loader/lazy-loader.service.d.ts

@@ -0,0 +1,71 @@
+import { InjectionToken } from '@angular/core';
+import { CompiledComponent, CompiledModule, ComponentRegistration, ComponentResolveStrategy, DynamicRegistrationArgs, NgxLazyLoaderConfig } from './types';
+import * as i0 from "@angular/core";
+export declare const NGX_LAZY_LOADER_CONFIG: InjectionToken<Partial<{
+    entries: ComponentRegistration[];
+    notFoundTemplate: import("@angular/core").TemplateRef<any>;
+    notFoundComponent: import("@angular/cdk/portal").ComponentType<any>;
+    errorTemplate: import("@angular/core").TemplateRef<any>;
+    errorComponent: import("@angular/cdk/portal").ComponentType<any>;
+    loaderDistractorTemplate: import("@angular/core").TemplateRef<any>;
+    loaderDistractorComponent: import("@angular/cdk/portal").ComponentType<any>;
+    logger: {
+        log: (...args: any) => void;
+        warn: (...args: any) => void;
+        err: (...args: any) => void;
+    };
+    componentResolveStrategy: ComponentResolveStrategy;
+    customResolver: (registry: (CompiledComponent | CompiledModule)[]) => Object;
+}>>;
+export declare class LazyLoaderService {
+    private get err();
+    private get log();
+    private get warn();
+    private static registry;
+    static config: NgxLazyLoaderConfig;
+    constructor(config?: NgxLazyLoaderConfig);
+    private static configure;
+    private static addComponentToRegistry;
+    /**
+     * Register an Angular component
+     * @param id identifier that is used to resolve the component
+     * @param group
+     * @param component Angular Component Class constructor
+     */
+    registerComponent<T extends {
+        new (...args: any[]): InstanceType<T>;
+    }>(args: DynamicRegistrationArgs<T>): void;
+    /**
+     *
+     * @param id
+     * @param group
+     */
+    unregisterComponent(id: string, group?: string): void;
+    /**
+     * Get the registration entry for a component.
+     * Returns null if component is not in the registry.
+     */
+    resolveRegistrationEntry(value: string, group?: string): {
+        entry: ComponentRegistration;
+        matchGroups: {
+            [key: string]: string;
+        };
+    } | {
+        entry: ComponentRegistration;
+        matchGroups?: undefined;
+    };
+    /**
+     * Check if a component is currently registered
+     * Can be used to validate regex matchers and aliases.
+     */
+    isComponentRegistered(value: string, group?: string): boolean;
+    /**
+     *
+     * @param bundle
+     * @returns The component `Object` if a component was resolved, `null` if no component was found
+     * `false` if the specified strategy was an invalid selection
+     */
+    resolveComponent(id: string, group: string, modules: (CompiledComponent | CompiledModule)[]): Object | null | false;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LazyLoaderService>;
+}

package/components/lazy-loader/types.d.ts

@@ -0,0 +1,142 @@
+import { ComponentType } from '@angular/cdk/portal';
+import { TemplateRef } from '@angular/core';
+export declare enum ComponentResolveStrategy {
+    /**
+     * Match the fist component we find
+     * (best used for standalone components)
+     * @default
+     */
+    PickFirst = 0,
+    /**
+     * Perform an Exact ID to Classname of the Component
+     * case sensitive, zero tolerance.
+     */
+    MatchIdToClassName = 1,
+    /**
+     * Perform a fuzzy ID to classname match
+     * case insensitive, mutes symbols
+     * ignores "Component" and "Module" postfixes on class
+     * names
+     */
+    FuzzyIdClassName = 2,
+    /**
+     * Use a user-provided component match function
+     */
+    Custom = 3
+}
+export type NgxLazyLoaderConfig = Partial<{
+    entries: ComponentRegistration[];
+    notFoundTemplate: TemplateRef<any>;
+    notFoundComponent: ComponentType<any>;
+    errorTemplate: TemplateRef<any>;
+    errorComponent: ComponentType<any>;
+    loaderDistractorTemplate: TemplateRef<any>;
+    loaderDistractorComponent: ComponentType<any>;
+    logger: {
+        log: (...args: any) => void;
+        warn: (...args: any) => void;
+        err: (...args: any) => void;
+    };
+    /**
+     * What strategy should be used to resolve components
+     * @default ComponentResolveStrategy.FuzzyIdClassName
+     */
+    componentResolveStrategy: ComponentResolveStrategy;
+    customResolver: (registry: (CompiledComponent | CompiledModule)[]) => Object;
+}>;
+type RegistrationConfig = {
+    /**
+     * Specify a group to categorize components. If not specified,
+     * will default to the `default` group.
+     */
+    group?: string;
+    /**
+     * load: () => import('./pages/my-page/my-page.component')
+     */
+    load: () => any;
+    /**
+     * Called before a component is loaded.
+     * If it returns `false` the component will not be loaded.
+     */
+    [key: string]: any;
+};
+export type ComponentRegistration = (({
+    id: string;
+} & RegistrationConfig) | ({
+    matcher: string[] | RegExp | ((value: string) => boolean);
+} & RegistrationConfig));
+export type DynamicRegistrationArgs<T = any> = {
+    id: string;
+    group?: string;
+    matcher?: string[] | RegExp | ((val: string) => boolean);
+    component?: T;
+    load?: () => any;
+};
+/**
+ * This is roughly a compiled component
+ */
+export type CompiledComponent = {
+    (): CompiledComponent;
+    ɵfac: Function;
+    ɵcmp: {
+        consts: any;
+        contentQueries: any;
+        data: any;
+        declaredInputs: any;
+        decls: any;
+        dependencies: any;
+        directiveDefs: any;
+        encapsulation: any;
+        exportAs: any;
+        factory: any;
+        features: any;
+        findHostDirectiveDefs: any;
+        getStandaloneInjector: any;
+        hostAttrs: any;
+        hostBindings: any;
+        hostDirectives: any;
+        hostVars: any;
+        id: string;
+        inputs: any;
+        ngContentSelectors: any;
+        onPush: boolean;
+        outputs: any;
+        pipeDefs: any;
+        providersResolver: any;
+        schemas: any;
+        selectors: string[];
+        setInput: any;
+        standalone: boolean;
+        styles: string[];
+        tView: any;
+        template: any;
+        type: Function;
+        vars: number;
+        viewQuery: any;
+    };
+};
+/**
+ * This is roughly a compiled module
+ */
+export type CompiledModule = {
+    (): CompiledModule;
+    ɵfac: Function;
+    ɵinj: {
+        providers: any[];
+        imports: any[];
+    };
+    ɵmod: {
+        bootstrap: any[];
+        declarations: Function[];
+        exports: any[];
+        id: unknown;
+        imports: any[];
+        schemas: unknown;
+        transitiveCompileScopes: unknown;
+        type: Function;
+    };
+};
+export type CompiledBundle = {
+    [key: string]: CompiledComponent | CompiledModule;
+};
+export {};

package/components/menu/menu.component.d.ts

@@ -0,0 +1,52 @@
+import { ChangeDetectorRef, EventEmitter, OnInit, ViewContainerRef } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { MenuItem, MenuOptions } from '../../types/menu';
+import * as i0 from "@angular/core";
+export declare const calcMenuItemBounds: (menuItems: MenuItem[], dataObj: any) => Promise<DOMRect>;
+export declare class MenuComponent implements OnInit {
+    viewContainer: ViewContainerRef;
+    sanitizer: DomSanitizer;
+    private _data;
+    dialog: MatDialog;
+    dialogRef: MatDialogRef<any>;
+    private changeDetector;
+    data: any;
+    parentCords: DOMRect;
+    items: MenuItem[];
+    config: MenuOptions;
+    id: string;
+    closeSignal: EventEmitter<any>;
+    selfCords: DOMRect;
+    readonly matIconRx: RegExp;
+    showIconColumn: boolean;
+    showShortcutColumn: boolean;
+    constructor(viewContainer: ViewContainerRef, sanitizer: DomSanitizer, _data: any, dialog: MatDialog, // optional only for the purpose of estimating dimensions
+    dialogRef: MatDialogRef<any>, changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     *
+     * @param item
+     * @param evt
+     * @returns
+     */
+    onMenuItemClick(item: MenuItem, row: HTMLTableRowElement, hideBackdrop?: boolean): Promise<MatDialogRef<unknown, any>>;
+    /**
+     *
+     * @param label
+     * @returns
+     */
+    formatLabel(label: string): string;
+    /**
+     * Close the context menu under these circumstances
+     */
+    close(): void;
+    /**
+     * Check if the dialog is clipping offscreen
+     * if so, move it back into view.
+     */
+    private onResize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "ngx-menu", never, { "data": "data"; "parentCords": "parentCords"; "items": "items"; "config": "config"; "id": "id"; }, { "closeSignal": "closeSignal"; }, never, never, true, never>;
+}

package/components/tooltip/tooltip.component.d.ts

@@ -0,0 +1,35 @@
+import { TemplateRef, Type, ViewContainerRef } from '@angular/core';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { PopupOptions } from '../../types/popup';
+import * as i0 from "@angular/core";
+export declare const calcTooltipBounds: (template: TemplateRef<any> | Type<any>, data: any) => Promise<DOMRect>;
+export declare class TooltipComponent {
+    viewContainer: ViewContainerRef;
+    private _data;
+    dialog: MatDialog;
+    dialogRef: MatDialogRef<any>;
+    data: any;
+    config: PopupOptions;
+    ownerCords: DOMRect;
+    selfCords: any;
+    template: TemplateRef<any> | Type<any>;
+    isTemplate: boolean;
+    hasBootstrapped: boolean;
+    pointerIsOnVoid: boolean;
+    coverRectCords: {
+        top: number;
+        left: number;
+        height: number;
+        width: number;
+    };
+    constructor(viewContainer: ViewContainerRef, _data: any, dialog: MatDialog, // optional only for the purpose of estimating dimensions
+    dialogRef: MatDialogRef<any>);
+    ngOnInit(): void;
+    /**
+     * Close the tooltip if these actions occur
+     */
+    private onClose;
+    private onPointerLeave;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "ngx-tooltip", never, { "data": "data"; "config": "config"; "ownerCords": "ownerCords"; "selfCords": "selfCords"; "template": "template"; }, {}, never, never, true, never>;
+}

package/directives/menu.directive.d.ts

@@ -0,0 +1,27 @@
+import { ViewContainerRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { MenuItem, MenuOptions } from '../types/menu';
+import * as i0 from "@angular/core";
+export declare class MenuDirective {
+    private dialog;
+    private viewContainer;
+    /**
+     * The data representing the item the menu was opened for.
+     */
+    data: any;
+    /**
+     * The items that will be bound to the context menu.
+     */
+    ctxMenuItems: MenuItem[];
+    menuItems: MenuItem[];
+    /**
+     * Configuration for opening the app menu
+     */
+    config: MenuOptions;
+    constructor(dialog: MatDialog, viewContainer: ViewContainerRef);
+    ngAfterViewInit(): void;
+    openMenu(evt: PointerEvent): Promise<[value: any]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuDirective, "[ngx-ctxmenu],[ngx-menu]", never, { "data": "ngx-menu-context"; "ctxMenuItems": "ngx-ctxmenu"; "menuItems": "ngx-menu"; "config": "ngx-menu-config"; }, {}, never, never, true, never>;
+}
+export declare const openMenu: (dialog: MatDialog, menuItems: MenuItem[], data: any, evt: PointerEvent, config?: MenuOptions) => Promise<any>;

package/directives/tooltip.directive.d.ts

@@ -0,0 +1,26 @@
+import { TemplateRef, Type, ViewContainerRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { PopupOptions } from '../types/popup';
+import * as i0 from "@angular/core";
+export declare class TooltipDirective {
+    private dialog;
+    private viewContainer;
+    /**
+     */
+    template: TemplateRef<any> | Type<any>;
+    /**
+     * Configuration for opening the app menu
+     */
+    config: PopupOptions;
+    /**
+     * Arbitrary data to pass into the template
+     */
+    data: any;
+    constructor(dialog: MatDialog, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    private dialogInstance;
+    onPointerEnter(evt: PointerEvent): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[ngxTooltip],[ngx-tooltip]", never, { "template": "ngx-tooltip"; "config": "ngx-tooltip-config"; "data": "ngx-tooltip-context"; }, {}, never, never, true, never>;
+}
+export declare const openTooltip: (dialog: MatDialog, template: TemplateRef<any> | Type<any>, data: any, el: HTMLElement, config?: PopupOptions) => Promise<any>;

package/directives/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This utils file exists outside of the strict angular DI zone
+ * This enables opening popups without requiring absolute DI bindings.
+ */
+export declare const getPosition: (el: HTMLElement | PointerEvent, config: any, bounds: DOMRect) => {
+    top: any;
+    left: any;
+};

package/esm2020/components/dynamic-html/dynamic-html.component.mjs

@@ -0,0 +1,43 @@
+import { Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./dynamic-html.service";
+export class DynamicHTMLComponent {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.ref = null;
+    }
+    ngOnChanges(_) {
+        if (this.ref) {
+            this.ref.destroy();
+            this.ref = null;
+        }
+        if (this.content && this.elementRef) {
+            this.ref = this.renderer.renderInnerHTML(this.elementRef, this.content);
+        }
+    }
+    ngDoCheck() {
+        if (this.ref) {
+            this.ref.check();
+        }
+    }
+    ngOnDestroy() {
+        if (this.ref) {
+            this.ref.destroy();
+            this.ref = null;
+        }
+    }
+}
+DynamicHTMLComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicHTMLComponent, deps: [{ token: i1.DynamicHTMLRenderer }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+DynamicHTMLComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: DynamicHTMLComponent, isStandalone: true, selector: "dynamic-html", inputs: { content: "content" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicHTMLComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dynamic-html',
+                    template: '',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicHTMLRenderer }, { type: i0.ElementRef }]; }, propDecorators: { content: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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