photon-grid-angular 0.0.1

package/README.md

@@ -0,0 +1,27 @@
+# PhotonGridAngular
+
+This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.2.14.
+
+## Development server
+
+Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The application will automatically reload if you change any of the source files.
+
+## Code scaffolding
+
+Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.
+
+## Build
+
+Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Running unit tests
+
+Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Running end-to-end tests
+
+Run `ng e2e` to execute the end-to-end tests via a platform of your choice. To use this command, you need to first add a package that implements end-to-end testing capabilities.
+
+## 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.dev/tools/cli) page.

package/esm2022/library/angular-renderer.adapter.mjs

@@ -0,0 +1,269 @@
+import { TemplateRef, createComponent, } from '@angular/core';
+import { isComponentRendererSpec, isTemplateRendererSpec, } from './angular-renderer.types';
+/**
+ * Bridges the framework-agnostic `ColumnRendererMap` (plain functions
+ * returning `HTMLElement | string`) to Angular components and templates.
+ *
+ * One instance is owned per `<photon-grid>` and lives for the component's
+ * lifetime: {@link adaptColumns} is called whenever columns are (re)supplied,
+ * and {@link dispose} is called once, in `ngOnDestroy`, to guarantee nothing
+ * outlives the host component.
+ *
+ * ### Why a MutationObserver
+ * The core owns cell/row virtualization and recycling; it has no lifecycle
+ * hook that tells us "this cell's DOM node is gone, destroy whatever you
+ * mounted into it". Since every renderer invocation mounts a *fresh*
+ * component/embedded view (the core's contract is "produce output for these
+ * params", not "patch existing output"), the only reliable place to catch
+ * disposal is watching the DOM itself: when the core removes/replaces a
+ * mounted host element, a MutationObserver on the grid root sees it and we
+ * destroy the corresponding Angular view right then. This is what keeps
+ * scrolling/virtualized grids from leaking components.
+ */
+export class RendererAdapter {
+    appRef;
+    environmentInjector;
+    elementInjector;
+    /** Host element -> live Angular view mounted into it. */
+    mounts = new Map();
+    observer;
+    constructor(appRef, environmentInjector, elementInjector) {
+        this.appRef = appRef;
+        this.environmentInjector = environmentInjector;
+        this.elementInjector = elementInjector;
+    }
+    /**
+     * Starts watching `root` for node removals so mounted views can be torn
+     * down as soon as the core discards their host element. Safe to call
+     * repeatedly (e.g. across grid recreation) — any previous observer is
+     * disconnected first, but existing mounts are left untouched.
+     */
+    observe(root) {
+        this.observer?.disconnect();
+        this.observer = new MutationObserver((mutations) => {
+            // Bounded by the number of *currently mounted* renderer views
+            // (i.e. visible custom cells), not by row/data-set size, because
+            // virtualization keeps that number small regardless of grid size.
+            if (this.mounts.size === 0) {
+                return;
+            }
+            for (const mutation of mutations) {
+                mutation.removedNodes.forEach((node) => this.cleanupRemovedNode(node));
+            }
+        });
+        this.observer.observe(root, { childList: true, subtree: true });
+    }
+    /** Recursively converts `GridColumnDef[]` into plain `ColumnDef[]`. */
+    adaptColumns(columns) {
+        return columns.map((column) => this.adaptColumn(column));
+    }
+    /**
+     * Destroys every currently-mounted component/embedded view and stops
+     * observing. Call exactly once, when the owning grid is torn down.
+     * Deliberately unconditional (does not wait on the MutationObserver):
+     * `disconnect()` drops any in-flight mutation records, so relying on it
+     * for final teardown would risk leaking whatever hadn't been flushed yet.
+     */
+    dispose() {
+        this.observer?.disconnect();
+        this.observer = undefined;
+        for (const [element, mount] of this.mounts) {
+            this.destroyMount(mount);
+            this.mounts.delete(element);
+        }
+    }
+    adaptColumn(column) {
+        const { renderer, children, ...rest } = column;
+        const adapted = { ...rest };
+        if (renderer) {
+            // Adapted per-slot (rather than via a generic loop over the
+            // slot names) so each call keeps its own TParams/TOutput pair —
+            // looping over a union of keys would force `adaptRenderer` to
+            // accept the union of every slot's renderer type at once, which
+            // doesn't type-check (an EditorRendererParams renderer isn't
+            // assignable where a TooltipRendererParams renderer is expected).
+            const adaptedRenderer = {
+                display: this.adaptRenderer(renderer.display),
+                editor: this.adaptRenderer(renderer.editor),
+                option: this.adaptRenderer(renderer.option),
+                filter: this.adaptRenderer(renderer.filter),
+                tooltip: this.adaptRenderer(renderer.tooltip),
+                group: this.adaptRenderer(renderer.group),
+                header: this.adaptRenderer(renderer.header),
+                summary: this.adaptRenderer(renderer.summary),
+            };
+            adapted.renderer = adaptedRenderer;
+        }
+        if (children) {
+            adapted.children = children.map((child) => this.adaptColumn(child));
+        }
+        return adapted;
+    }
+    adaptRenderer(renderer) {
+        if (!renderer) {
+            return undefined;
+        }
+        if (isComponentRendererSpec(renderer)) {
+            return (params) => this.mountComponent(renderer, params);
+        }
+        if (isTemplateRendererSpec(renderer)) {
+            return (params) => this.mountTemplate(renderer, params);
+        }
+        if (renderer instanceof TemplateRef) {
+            return (params) => this.mountTemplate({ template: renderer }, params);
+        }
+        if (this.isComponentType(renderer)) {
+            return (params) => this.mountComponent({ component: renderer }, params);
+        }
+        if (typeof renderer === 'function') {
+            return renderer;
+        }
+        return undefined;
+    }
+    isComponentType(value) {
+        return typeof value === 'function' && !!value.ɵcmp;
+    }
+    mountComponent(spec, params) {
+        const componentRef = createComponent(spec.component, {
+            environmentInjector: this.environmentInjector,
+            elementInjector: this.elementInjector,
+        });
+        const normalizedParams = this.normalizeRendererParams(params);
+        const inputs = spec.inputs ? spec.inputs(normalizedParams) : this.inferInputs(componentRef, normalizedParams);
+        for (const [key, value] of Object.entries(inputs)) {
+            this.setComponentInput(componentRef, key, value);
+        }
+        this.setComponentInput(componentRef, 'params', normalizedParams);
+        // Attaching to ApplicationRef is what makes this component
+        // participate in normal change detection (zone triggers, async
+        // pipe, etc.) for as long as it stays mounted — required for any
+        // interactivity inside the component itself (clicks, forms, ...).
+        this.appRef.attachView(componentRef.hostView);
+        componentRef.changeDetectorRef.detectChanges();
+        this.invokeLifecycle(componentRef.instance, 'pgGridInit', normalizedParams);
+        this.invokeLifecycle(componentRef.instance, 'pgGridRefresh', normalizedParams);
+        const element = componentRef.location.nativeElement;
+        this.mounts.set(element, { kind: 'component', ref: componentRef });
+        return element;
+    }
+    setComponentInput(componentRef, key, value) {
+        try {
+            componentRef.setInput(key, value);
+            return;
+        }
+        catch {
+            const instance = componentRef.instance;
+            instance[key] = value;
+        }
+    }
+    normalizeRendererParams(params) {
+        const normalized = { ...params };
+        const option = normalized['option'];
+        if (normalized['value'] === undefined && option && typeof option === 'object') {
+            const optionValue = option.value;
+            normalized['value'] = optionValue;
+            normalized['rawValue'] = optionValue;
+        }
+        return normalized;
+    }
+    inferInputs(componentRef, params) {
+        const instance = componentRef.instance;
+        const inputs = {};
+        const paramBag = params;
+        const row = paramBag['row'] && typeof paramBag['row'] === 'object'
+            ? paramBag['row']
+            : undefined;
+        for (const key of Object.keys(instance)) {
+            if (key === '__ngContext__' || key === 'constructor') {
+                continue;
+            }
+            if (paramBag[key] !== undefined) {
+                inputs[key] = paramBag[key];
+                continue;
+            }
+            if (row && row[key] !== undefined) {
+                inputs[key] = row[key];
+                continue;
+            }
+            if (key === 'seed' && row && row['id'] !== undefined) {
+                inputs[key] = row['id'];
+                continue;
+            }
+            if (key === 'value' && paramBag['value'] !== undefined) {
+                inputs[key] = paramBag['value'];
+            }
+        }
+        return inputs;
+    }
+    invokeLifecycle(instance, lifecycle, params) {
+        const candidate = instance?.[lifecycle];
+        if (typeof candidate === 'function') {
+            candidate.call(instance, params);
+        }
+    }
+    mountTemplate(spec, params) {
+        const normalizedParams = this.normalizeRendererParams(params);
+        const context = {
+            $implicit: normalizedParams,
+            params: normalizedParams,
+            ...(spec.context ? spec.context(normalizedParams) : {}),
+        };
+        const viewRef = spec.template.createEmbeddedView(context);
+        this.appRef.attachView(viewRef);
+        viewRef.detectChanges();
+        const host = this.resolveTemplateHost(viewRef);
+        this.mounts.set(host, { kind: 'template', ref: viewRef });
+        return host;
+    }
+    /**
+     * Uses the template's single root element directly when possible (so
+     * `editor`/`filter` slots that expect the returned element to *be* the
+     * control keep working); falls back to a wrapper `<div>` for templates
+     * with multiple root nodes or text-only content.
+     */
+    resolveTemplateHost(viewRef) {
+        const [singleRoot] = viewRef.rootNodes;
+        if (viewRef.rootNodes.length === 1 && singleRoot instanceof HTMLElement) {
+            return singleRoot;
+        }
+        const host = document.createElement('div');
+        host.classList.add('photon-grid__template-host');
+        host.append(...viewRef.rootNodes);
+        return host;
+    }
+    cleanupRemovedNode(node) {
+        if (!(node instanceof HTMLElement)) {
+            return;
+        }
+        const directMount = this.mounts.get(node);
+        if (directMount) {
+            this.mounts.delete(node);
+            this.destroyMount(directMount);
+        }
+        // The core may remove an ancestor (e.g. an entire recycled row)
+        // rather than the mounted element itself; sweep for any tracked
+        // host contained in the removed subtree.
+        if (node.childElementCount === 0) {
+            return;
+        }
+        for (const [element, mount] of this.mounts) {
+            if (node.contains(element)) {
+                this.mounts.delete(element);
+                this.destroyMount(mount);
+            }
+        }
+    }
+    destroyMount(mount) {
+        if (mount.kind === 'component') {
+            this.invokeLifecycle(mount.ref.instance, 'pgGridDestroy', undefined);
+            const viewRef = mount.ref.hostView;
+            this.appRef.detachView(viewRef);
+            mount.ref.destroy();
+            return;
+        }
+        const viewRef = mount.ref;
+        this.appRef.detachView(viewRef);
+        mount.ref.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-renderer.adapter.js","sourceRoot":"","sources":["../../../src/library/angular-renderer.adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ApplicationRef,\r\n    ComponentRef,\r\n    EmbeddedViewRef,\r\n    EnvironmentInjector,\r\n    Injector,\r\n    TemplateRef,\r\n    createComponent,\r\n} from '@angular/core';\r\n\r\nimport type { ColumnDef, RendererOutput } from 'photon-grid-core';\r\n\r\nimport {\r\n    CellRenderer,\r\n    ColumnRendererMap,\r\n    ColumnDef as GridColumnDef,\r\n    RendererContext,\r\n    isComponentRendererSpec,\r\n    isTemplateRendererSpec,\r\n} from './angular-renderer.types';\r\n\r\ntype RendererMount =\r\n    | { readonly kind: 'component'; readonly ref: ComponentRef<unknown> }\r\n    | { readonly kind: 'template'; readonly ref: EmbeddedViewRef<unknown> };\r\n\r\ntype GridLifecycleMethod = 'pgGridInit' | 'pgGridRefresh' | 'pgGridDestroy';\r\n\r\n/**\r\n * Bridges the framework-agnostic `ColumnRendererMap` (plain functions\r\n * returning `HTMLElement | string`) to Angular components and templates.\r\n *\r\n * One instance is owned per `<photon-grid>` and lives for the component's\r\n * lifetime: {@link adaptColumns} is called whenever columns are (re)supplied,\r\n * and {@link dispose} is called once, in `ngOnDestroy`, to guarantee nothing\r\n * outlives the host component.\r\n *\r\n * ### Why a MutationObserver\r\n * The core owns cell/row virtualization and recycling; it has no lifecycle\r\n * hook that tells us \"this cell's DOM node is gone, destroy whatever you\r\n * mounted into it\". Since every renderer invocation mounts a *fresh*\r\n * component/embedded view (the core's contract is \"produce output for these\r\n * params\", not \"patch existing output\"), the only reliable place to catch\r\n * disposal is watching the DOM itself: when the core removes/replaces a\r\n * mounted host element, a MutationObserver on the grid root sees it and we\r\n * destroy the corresponding Angular view right then. This is what keeps\r\n * scrolling/virtualized grids from leaking components.\r\n */\r\nexport class RendererAdapter {\r\n    /** Host element -> live Angular view mounted into it. */\r\n    private readonly mounts = new Map<HTMLElement, RendererMount>();\r\n\r\n    private observer?: MutationObserver;\r\n\r\n    constructor(\r\n        private readonly appRef: ApplicationRef,\r\n        private readonly environmentInjector: EnvironmentInjector,\r\n        private readonly elementInjector: Injector,\r\n    ) {}\r\n\r\n    /**\r\n     * Starts watching `root` for node removals so mounted views can be torn\r\n     * down as soon as the core discards their host element. Safe to call\r\n     * repeatedly (e.g. across grid recreation) — any previous observer is\r\n     * disconnected first, but existing mounts are left untouched.\r\n     */\r\n    observe(root: HTMLElement): void {\r\n        this.observer?.disconnect();\r\n\r\n        this.observer = new MutationObserver((mutations) => {\r\n            // Bounded by the number of *currently mounted* renderer views\r\n            // (i.e. visible custom cells), not by row/data-set size, because\r\n            // virtualization keeps that number small regardless of grid size.\r\n            if (this.mounts.size === 0) {\r\n                return;\r\n            }\r\n            for (const mutation of mutations) {\r\n                mutation.removedNodes.forEach((node) => this.cleanupRemovedNode(node));\r\n            }\r\n        });\r\n\r\n        this.observer.observe(root, { childList: true, subtree: true });\r\n    }\r\n\r\n    /** Recursively converts `GridColumnDef[]` into plain `ColumnDef[]`. */\r\n    adaptColumns(columns: readonly GridColumnDef[]): ColumnDef[] {\r\n        return columns.map((column) => this.adaptColumn(column));\r\n    }\r\n\r\n    /**\r\n     * Destroys every currently-mounted component/embedded view and stops\r\n     * observing. Call exactly once, when the owning grid is torn down.\r\n     * Deliberately unconditional (does not wait on the MutationObserver):\r\n     * `disconnect()` drops any in-flight mutation records, so relying on it\r\n     * for final teardown would risk leaking whatever hadn't been flushed yet.\r\n     */\r\n    dispose(): void {\r\n        this.observer?.disconnect();\r\n        this.observer = undefined;\r\n\r\n        for (const [element, mount] of this.mounts) {\r\n            this.destroyMount(mount);\r\n            this.mounts.delete(element);\r\n        }\r\n    }\r\n\r\n    private adaptColumn(column: GridColumnDef): ColumnDef {\r\n        const { renderer, children, ...rest } = column;\r\n        const adapted = { ...rest } as ColumnDef;\r\n\r\n        if (renderer) {\r\n            // Adapted per-slot (rather than via a generic loop over the\r\n            // slot names) so each call keeps its own TParams/TOutput pair —\r\n            // looping over a union of keys would force `adaptRenderer` to\r\n            // accept the union of every slot's renderer type at once, which\r\n            // doesn't type-check (an EditorRendererParams renderer isn't\r\n            // assignable where a TooltipRendererParams renderer is expected).\r\n            const adaptedRenderer: Partial<ColumnRendererMap> = {\r\n                display: this.adaptRenderer(renderer.display),\r\n                editor: this.adaptRenderer(renderer.editor),\r\n                option: this.adaptRenderer(renderer.option),\r\n                filter: this.adaptRenderer(renderer.filter),\r\n                tooltip: this.adaptRenderer(renderer.tooltip),\r\n                group: this.adaptRenderer(renderer.group),\r\n                header: this.adaptRenderer(renderer.header),\r\n                summary: this.adaptRenderer(renderer.summary),\r\n            };\r\n            adapted.renderer = adaptedRenderer as any;\r\n        }\r\n\r\n        if (children) {\r\n            adapted.children = children.map((child) => this.adaptColumn(child));\r\n        }\r\n\r\n        return adapted;\r\n    }\r\n\r\n    private adaptRenderer<TParams, TOutput extends RendererOutput | HTMLElement>(\r\n        renderer: CellRenderer<TParams, TOutput> | undefined,\r\n    ): ((params: TParams) => TOutput) | undefined {\r\n        if (!renderer) {\r\n            return undefined;\r\n        }\r\n\r\n        if (isComponentRendererSpec(renderer)) {\r\n            return (params: TParams) => this.mountComponent(renderer, params) as unknown as TOutput;\r\n        }\r\n\r\n        if (isTemplateRendererSpec(renderer)) {\r\n            return (params: TParams) => this.mountTemplate(renderer, params) as unknown as TOutput;\r\n        }\r\n\r\n        if (renderer instanceof TemplateRef) {\r\n            return (params: TParams) => this.mountTemplate({ template: renderer }, params) as unknown as TOutput;\r\n        }\r\n\r\n        if (this.isComponentType(renderer)) {\r\n            return (params: TParams) => this.mountComponent({ component: renderer }, params) as unknown as TOutput;\r\n        }\r\n\r\n        if (typeof renderer === 'function') {\r\n            return renderer;\r\n        }\r\n\r\n        return undefined;\r\n    }\r\n\r\n    private isComponentType(value: unknown): value is import('@angular/core').Type<unknown> {\r\n        return typeof value === 'function' && !!(value as { readonly ɵcmp?: unknown }).ɵcmp;\r\n    }\r\n\r\n    private mountComponent<TParams>(\r\n        spec: { component: import('@angular/core').Type<unknown>; inputs?: (params: TParams) => Record<string, unknown> },\r\n        params: TParams,\r\n    ): HTMLElement {\r\n        const componentRef = createComponent(spec.component, {\r\n            environmentInjector: this.environmentInjector,\r\n            elementInjector: this.elementInjector,\r\n        });\r\n\r\n        const normalizedParams = this.normalizeRendererParams(params);\r\n        const inputs = spec.inputs ? spec.inputs(normalizedParams) : this.inferInputs(componentRef, normalizedParams);\r\n        for (const [key, value] of Object.entries(inputs)) {\r\n            this.setComponentInput(componentRef, key, value);\r\n        }\r\n\r\n        this.setComponentInput(componentRef, 'params', normalizedParams);\r\n\r\n        // Attaching to ApplicationRef is what makes this component\r\n        // participate in normal change detection (zone triggers, async\r\n        // pipe, etc.) for as long as it stays mounted — required for any\r\n        // interactivity inside the component itself (clicks, forms, ...).\r\n        this.appRef.attachView(componentRef.hostView);\r\n        componentRef.changeDetectorRef.detectChanges();\r\n\r\n        this.invokeLifecycle(componentRef.instance, 'pgGridInit', normalizedParams);\r\n        this.invokeLifecycle(componentRef.instance, 'pgGridRefresh', normalizedParams);\r\n\r\n        const element = componentRef.location.nativeElement as HTMLElement;\r\n        this.mounts.set(element, { kind: 'component', ref: componentRef });\r\n        return element;\r\n    }\r\n\r\n    private setComponentInput<TComponent>(\r\n        componentRef: ComponentRef<TComponent>,\r\n        key: string,\r\n        value: unknown,\r\n    ): void {\r\n        try {\r\n            componentRef.setInput(key, value);\r\n            return;\r\n        } catch {\r\n            const instance = componentRef.instance as Record<string, unknown>;\r\n            instance[key] = value;\r\n        }\r\n    }\r\n\r\n    private normalizeRendererParams<TParams>(params: TParams): TParams & { value?: unknown; rawValue?: unknown } {\r\n        const normalized = { ...(params as Record<string, unknown>) };\r\n        const option = normalized['option'];\r\n\r\n        if (normalized['value'] === undefined && option && typeof option === 'object') {\r\n            const optionValue = (option as { value?: unknown }).value;\r\n            normalized['value'] = optionValue;\r\n            normalized['rawValue'] = optionValue;\r\n        }\r\n\r\n        return normalized as TParams & { value?: unknown; rawValue?: unknown };\r\n    }\r\n\r\n    private inferInputs<TComponent, TParams>(\r\n        componentRef: ComponentRef<TComponent>,\r\n        params: TParams,\r\n    ): Record<string, unknown> {\r\n        const instance = componentRef.instance as Record<string, unknown>;\r\n        const inputs: Record<string, unknown> = {};\r\n        const paramBag = params as Record<string, unknown>;\r\n        const row = paramBag['row'] && typeof paramBag['row'] === 'object'\r\n            ? paramBag['row'] as Record<string, unknown>\r\n            : undefined;\r\n\r\n        for (const key of Object.keys(instance)) {\r\n            if (key === '__ngContext__' || key === 'constructor') {\r\n                continue;\r\n            }\r\n\r\n            if (paramBag[key] !== undefined) {\r\n                inputs[key] = paramBag[key];\r\n                continue;\r\n            }\r\n\r\n            if (row && row[key] !== undefined) {\r\n                inputs[key] = row[key];\r\n                continue;\r\n            }\r\n\r\n            if (key === 'seed' && row && row['id'] !== undefined) {\r\n                inputs[key] = row['id'];\r\n                continue;\r\n            }\r\n\r\n            if (key === 'value' && paramBag['value'] !== undefined) {\r\n                inputs[key] = paramBag['value'];\r\n            }\r\n        }\r\n\r\n        return inputs;\r\n    }\r\n\r\n    private invokeLifecycle<TParams>(\r\n        instance: unknown,\r\n        lifecycle: GridLifecycleMethod,\r\n        params: TParams,\r\n    ): void {\r\n        const candidate = (instance as Record<string, unknown> | null)?.[lifecycle];\r\n        if (typeof candidate === 'function') {\r\n            (candidate as (params: TParams) => void).call(instance, params);\r\n        }\r\n    }\r\n\r\n    private mountTemplate<TParams>(\r\n        spec: {\r\n            template: import('@angular/core').TemplateRef<RendererContext<TParams>>;\r\n            context?: (params: TParams) => Record<string, unknown>;\r\n        },\r\n        params: TParams,\r\n    ): HTMLElement {\r\n        const normalizedParams = this.normalizeRendererParams(params);\r\n        const context = {\r\n            $implicit: normalizedParams,\r\n            params: normalizedParams,\r\n            ...(spec.context ? spec.context(normalizedParams) : {}),\r\n        };\r\n\r\n        const viewRef = spec.template.createEmbeddedView(context);\r\n        this.appRef.attachView(viewRef);\r\n        viewRef.detectChanges();\r\n\r\n        const host = this.resolveTemplateHost(viewRef);\r\n        this.mounts.set(host, { kind: 'template', ref: viewRef });\r\n        return host;\r\n    }\r\n\r\n    /**\r\n     * Uses the template's single root element directly when possible (so\r\n     * `editor`/`filter` slots that expect the returned element to *be* the\r\n     * control keep working); falls back to a wrapper `<div>` for templates\r\n     * with multiple root nodes or text-only content.\r\n     */\r\n    private resolveTemplateHost(viewRef: EmbeddedViewRef<unknown>): HTMLElement {\r\n        const [singleRoot] = viewRef.rootNodes;\r\n        if (viewRef.rootNodes.length === 1 && singleRoot instanceof HTMLElement) {\r\n            return singleRoot;\r\n        }\r\n\r\n        const host = document.createElement('div');\r\n        host.classList.add('photon-grid__template-host');\r\n        host.append(...viewRef.rootNodes);\r\n        return host;\r\n    }\r\n\r\n    private cleanupRemovedNode(node: Node): void {\r\n        if (!(node instanceof HTMLElement)) {\r\n            return;\r\n        }\r\n\r\n        const directMount = this.mounts.get(node);\r\n        if (directMount) {\r\n            this.mounts.delete(node);\r\n            this.destroyMount(directMount);\r\n        }\r\n\r\n        // The core may remove an ancestor (e.g. an entire recycled row)\r\n        // rather than the mounted element itself; sweep for any tracked\r\n        // host contained in the removed subtree.\r\n        if (node.childElementCount === 0) {\r\n            return;\r\n        }\r\n        for (const [element, mount] of this.mounts) {\r\n            if (node.contains(element)) {\r\n                this.mounts.delete(element);\r\n                this.destroyMount(mount);\r\n            }\r\n        }\r\n    }\r\n\r\n    private destroyMount(mount: RendererMount): void {\r\n        if (mount.kind === 'component') {\r\n            this.invokeLifecycle(mount.ref.instance, 'pgGridDestroy', undefined);\r\n            const viewRef = mount.ref.hostView;\r\n            this.appRef.detachView(viewRef);\r\n            mount.ref.destroy();\r\n            return;\r\n        }\r\n\r\n        const viewRef = mount.ref;\r\n        this.appRef.detachView(viewRef);\r\n        mount.ref.destroy();\r\n    }\r\n}"]}

package/esm2022/library/angular-renderer.types.mjs

@@ -0,0 +1,8 @@
+/** Narrowing helpers used by the adapter (and usable by consumers/tests). */
+export function isComponentRendererSpec(value) {
+    return !!value && typeof value === 'object' && value.kind === 'component';
+}
+export function isTemplateRendererSpec(value) {
+    return !!value && typeof value === 'object' && value.kind === 'template';
+}
+//# sourceMappingURL=data:application/json;base64,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