@nova-design-system/nova-angular 3.15.0 → 3.16.0

package/dist/nova-components/esm2022/lib/components/datatable.utils/flex-render/context.mjs

@@ -0,0 +1,6 @@
+import { inject, InjectionToken } from '@angular/core';
+export const FlexRenderComponentProps = new InjectionToken('[@tanstack/angular-table] Flex render component context props');
+export function injectFlexRenderContext() {
+    return inject(FlexRenderComponentProps);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25vdmEtY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvZGF0YXRhYmxlLnV0aWxzL2ZsZXgtcmVuZGVyL2NvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFFdEQsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsSUFBSSxjQUFjLENBRXhELCtEQUErRCxDQUFDLENBQUE7QUFFbEUsTUFBTSxVQUFVLHVCQUF1QjtJQUNyQyxPQUFPLE1BQU0sQ0FBSSx3QkFBd0IsQ0FBQyxDQUFBO0FBQzVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpbmplY3QsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcblxuZXhwb3J0IGNvbnN0IEZsZXhSZW5kZXJDb21wb25lbnRQcm9wcyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxcbiAgTm9uTnVsbGFibGU8dW5rbm93bj5cbj4oJ1tAdGFuc3RhY2svYW5ndWxhci10YWJsZV0gRmxleCByZW5kZXIgY29tcG9uZW50IGNvbnRleHQgcHJvcHMnKVxuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0RmxleFJlbmRlckNvbnRleHQ8VCBleHRlbmRzIE5vbk51bGxhYmxlPHVua25vd24+PigpOiBUIHtcbiAgcmV0dXJuIGluamVjdDxUPihGbGV4UmVuZGVyQ29tcG9uZW50UHJvcHMpXG59XG4iXX0=

package/dist/nova-components/esm2022/lib/components/datatable.utils/flex-render/flags.mjs

@@ -0,0 +1,42 @@
+/**
+ * Flags used to manage and optimize the rendering lifecycle of content of the cell,
+ * while using FlexRenderDirective.
+ */
+export var FlexRenderFlags;
+(function (FlexRenderFlags) {
+    /**
+     * Indicates that the view is being created for the first time or will be cleared during the next update phase.
+     * This is the initial state and will transition after the first ngDoCheck.
+     */
+    FlexRenderFlags[FlexRenderFlags["ViewFirstRender"] = 1] = "ViewFirstRender";
+    /**
+     * Represents a state where the view is not dirty, meaning no changes require rendering updates.
+     */
+    FlexRenderFlags[FlexRenderFlags["Pristine"] = 2] = "Pristine";
+    /**
+     * Indicates the `content` property has been modified or the view requires a complete re-render.
+     * When this flag is enabled, the view will be cleared and recreated from scratch.
+     */
+    FlexRenderFlags[FlexRenderFlags["ContentChanged"] = 4] = "ContentChanged";
+    /**
+     * Indicates that the `props` property reference has changed.
+     * When this flag is enabled, the view context is updated based on the type of the content.
+     *
+     * For Component view, inputs will be updated and view will be marked as dirty.
+     * For TemplateRef and primitive values, view will be marked as dirty
+     */
+    FlexRenderFlags[FlexRenderFlags["PropsReferenceChanged"] = 8] = "PropsReferenceChanged";
+    /**
+     * Indicates that the current rendered view needs to be checked for changes.
+     */
+    FlexRenderFlags[FlexRenderFlags["DirtyCheck"] = 16] = "DirtyCheck";
+    /**
+     * Indicates that a signal within the `content(props)` result has changed
+     */
+    FlexRenderFlags[FlexRenderFlags["DirtySignal"] = 32] = "DirtySignal";
+    /**
+     * Indicates that the first render effect has been checked at least one time.
+     */
+    FlexRenderFlags[FlexRenderFlags["RenderEffectChecked"] = 64] = "RenderEffectChecked";
+})(FlexRenderFlags || (FlexRenderFlags = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxhZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZhLWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2RhdGF0YWJsZS51dGlscy9mbGV4LXJlbmRlci9mbGFncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQU4sSUFBWSxlQW1DWDtBQW5DRCxXQUFZLGVBQWU7SUFDekI7OztPQUdHO0lBQ0gsMkVBQXdCLENBQUE7SUFDeEI7O09BRUc7SUFDSCw2REFBaUIsQ0FBQTtJQUNqQjs7O09BR0c7SUFDSCx5RUFBdUIsQ0FBQTtJQUN2Qjs7Ozs7O09BTUc7SUFDSCx1RkFBOEIsQ0FBQTtJQUM5Qjs7T0FFRztJQUNILGtFQUFtQixDQUFBO0lBQ25COztPQUVHO0lBQ0gsb0VBQW9CLENBQUE7SUFDcEI7O09BRUc7SUFDSCxvRkFBNEIsQ0FBQTtBQUM5QixDQUFDLEVBbkNXLGVBQWUsS0FBZixlQUFlLFFBbUMxQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRmxhZ3MgdXNlZCB0byBtYW5hZ2UgYW5kIG9wdGltaXplIHRoZSByZW5kZXJpbmcgbGlmZWN5Y2xlIG9mIGNvbnRlbnQgb2YgdGhlIGNlbGwsXG4gKiB3aGlsZSB1c2luZyBGbGV4UmVuZGVyRGlyZWN0aXZlLlxuICovXG5leHBvcnQgZW51bSBGbGV4UmVuZGVyRmxhZ3Mge1xuICAvKipcbiAgICogSW5kaWNhdGVzIHRoYXQgdGhlIHZpZXcgaXMgYmVpbmcgY3JlYXRlZCBmb3IgdGhlIGZpcnN0IHRpbWUgb3Igd2lsbCBiZSBjbGVhcmVkIGR1cmluZyB0aGUgbmV4dCB1cGRhdGUgcGhhc2UuXG4gICAqIFRoaXMgaXMgdGhlIGluaXRpYWwgc3RhdGUgYW5kIHdpbGwgdHJhbnNpdGlvbiBhZnRlciB0aGUgZmlyc3QgbmdEb0NoZWNrLlxuICAgKi9cbiAgVmlld0ZpcnN0UmVuZGVyID0gMSA8PCAwLFxuICAvKipcbiAgICogUmVwcmVzZW50cyBhIHN0YXRlIHdoZXJlIHRoZSB2aWV3IGlzIG5vdCBkaXJ0eSwgbWVhbmluZyBubyBjaGFuZ2VzIHJlcXVpcmUgcmVuZGVyaW5nIHVwZGF0ZXMuXG4gICAqL1xuICBQcmlzdGluZSA9IDEgPDwgMSxcbiAgLyoqXG4gICAqIEluZGljYXRlcyB0aGUgYGNvbnRlbnRgIHByb3BlcnR5IGhhcyBiZWVuIG1vZGlmaWVkIG9yIHRoZSB2aWV3IHJlcXVpcmVzIGEgY29tcGxldGUgcmUtcmVuZGVyLlxuICAgKiBXaGVuIHRoaXMgZmxhZyBpcyBlbmFibGVkLCB0aGUgdmlldyB3aWxsIGJlIGNsZWFyZWQgYW5kIHJlY3JlYXRlZCBmcm9tIHNjcmF0Y2guXG4gICAqL1xuICBDb250ZW50Q2hhbmdlZCA9IDEgPDwgMixcbiAgLyoqXG4gICAqIEluZGljYXRlcyB0aGF0IHRoZSBgcHJvcHNgIHByb3BlcnR5IHJlZmVyZW5jZSBoYXMgY2hhbmdlZC5cbiAgICogV2hlbiB0aGlzIGZsYWcgaXMgZW5hYmxlZCwgdGhlIHZpZXcgY29udGV4dCBpcyB1cGRhdGVkIGJhc2VkIG9uIHRoZSB0eXBlIG9mIHRoZSBjb250ZW50LlxuICAgKlxuICAgKiBGb3IgQ29tcG9uZW50IHZpZXcsIGlucHV0cyB3aWxsIGJlIHVwZGF0ZWQgYW5kIHZpZXcgd2lsbCBiZSBtYXJrZWQgYXMgZGlydHkuXG4gICAqIEZvciBUZW1wbGF0ZVJlZiBhbmQgcHJpbWl0aXZlIHZhbHVlcywgdmlldyB3aWxsIGJlIG1hcmtlZCBhcyBkaXJ0eVxuICAgKi9cbiAgUHJvcHNSZWZlcmVuY2VDaGFuZ2VkID0gMSA8PCAzLFxuICAvKipcbiAgICogSW5kaWNhdGVzIHRoYXQgdGhlIGN1cnJlbnQgcmVuZGVyZWQgdmlldyBuZWVkcyB0byBiZSBjaGVja2VkIGZvciBjaGFuZ2VzLlxuICAgKi9cbiAgRGlydHlDaGVjayA9IDEgPDwgNCxcbiAgLyoqXG4gICAqIEluZGljYXRlcyB0aGF0IGEgc2lnbmFsIHdpdGhpbiB0aGUgYGNvbnRlbnQocHJvcHMpYCByZXN1bHQgaGFzIGNoYW5nZWRcbiAgICovXG4gIERpcnR5U2lnbmFsID0gMSA8PCA1LFxuICAvKipcbiAgICogSW5kaWNhdGVzIHRoYXQgdGhlIGZpcnN0IHJlbmRlciBlZmZlY3QgaGFzIGJlZW4gY2hlY2tlZCBhdCBsZWFzdCBvbmUgdGltZS5cbiAgICovXG4gIFJlbmRlckVmZmVjdENoZWNrZWQgPSAxIDw8IDYsXG59XG4iXX0=

package/dist/nova-components/esm2022/lib/components/datatable.utils/flex-render/flex-render-component-ref.mjs

@@ -0,0 +1,171 @@
+import { ChangeDetectorRef, inject, Injectable, KeyValueDiffers, OutputEmitterRef, ViewContainerRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FlexRenderComponentFactory {
+    #viewContainerRef = inject(ViewContainerRef);
+    createComponent(flexRenderComponent, componentInjector) {
+        const componentRef = this.#viewContainerRef.createComponent(flexRenderComponent.component, {
+            injector: componentInjector,
+        });
+        const view = new FlexRenderComponentRef(componentRef, flexRenderComponent, componentInjector);
+        const { inputs, outputs } = flexRenderComponent;
+        if (inputs)
+            view.setInputs(inputs);
+        if (outputs)
+            view.setOutputs(outputs);
+        return view;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: FlexRenderComponentFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: FlexRenderComponentFactory }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: FlexRenderComponentFactory, decorators: [{
+            type: Injectable
+        }] });
+export class FlexRenderComponentRef {
+    #keyValueDiffersFactory;
+    #componentData;
+    #inputValueDiffer;
+    #outputRegistry;
+    constructor(componentRef, componentData, componentInjector) {
+        this.componentRef = componentRef;
+        this.componentInjector = componentInjector;
+        this.#componentData = componentData;
+        this.#keyValueDiffersFactory = componentInjector.get(KeyValueDiffers);
+        this.#outputRegistry = new FlexRenderComponentOutputManager(this.#keyValueDiffersFactory, this.outputs);
+        this.#inputValueDiffer = this.#keyValueDiffersFactory
+            .find(this.inputs)
+            .create();
+        this.#inputValueDiffer.diff(this.inputs);
+        this.componentRef.onDestroy(() => this.#outputRegistry.unsubscribeAll());
+    }
+    get component() {
+        return this.#componentData.component;
+    }
+    get inputs() {
+        return this.#componentData.inputs ?? {};
+    }
+    get outputs() {
+        return this.#componentData.outputs ?? {};
+    }
+    /**
+     * Get component input and output diff by the given item
+     */
+    diff(item) {
+        return {
+            inputDiff: this.#inputValueDiffer.diff(item.inputs ?? {}),
+            outputDiff: this.#outputRegistry.diff(item.outputs ?? {}),
+        };
+    }
+    /**
+     *
+     * @param compare Whether the current ref component instance is the same as the given one
+     */
+    eqType(compare) {
+        return compare.component === this.component;
+    }
+    /**
+     * Tries to update current component refs input by the new given content component.
+     */
+    update(content) {
+        const eq = this.eqType(content);
+        if (!eq)
+            return;
+        const { inputDiff, outputDiff } = this.diff(content);
+        if (inputDiff) {
+            inputDiff.forEachAddedItem(item => this.setInput(item.key, item.currentValue));
+            inputDiff.forEachChangedItem(item => this.setInput(item.key, item.currentValue));
+            inputDiff.forEachRemovedItem(item => this.setInput(item.key, undefined));
+        }
+        if (outputDiff) {
+            outputDiff.forEachAddedItem(item => {
+                this.setOutput(item.key, item.currentValue);
+            });
+            outputDiff.forEachChangedItem(item => {
+                if (item.currentValue) {
+                    this.#outputRegistry.setListener(item.key, item.currentValue);
+                }
+                else {
+                    this.#outputRegistry.unsubscribe(item.key);
+                }
+            });
+            outputDiff.forEachRemovedItem(item => {
+                this.#outputRegistry.unsubscribe(item.key);
+            });
+        }
+        this.#componentData = content;
+    }
+    markAsDirty() {
+        this.componentRef.injector.get(ChangeDetectorRef).markForCheck();
+    }
+    setInputs(inputs) {
+        for (const prop in inputs) {
+            this.setInput(prop, inputs[prop]);
+        }
+    }
+    setInput(key, value) {
+        if (this.#componentData.allowedInputNames.includes(key)) {
+            this.componentRef.setInput(key, value);
+        }
+    }
+    setOutputs(outputs) {
+        this.#outputRegistry.unsubscribeAll();
+        for (const prop in outputs) {
+            this.setOutput(prop, outputs[prop]);
+        }
+    }
+    setOutput(outputName, emit) {
+        if (!this.#componentData.allowedOutputNames.includes(outputName))
+            return;
+        if (!emit) {
+            this.#outputRegistry.unsubscribe(outputName);
+            return;
+        }
+        const hasListener = this.#outputRegistry.hasListener(outputName);
+        this.#outputRegistry.setListener(outputName, emit);
+        if (hasListener) {
+            return;
+        }
+        const instance = this.componentRef.instance;
+        const output = instance[outputName];
+        if (output && output instanceof OutputEmitterRef) {
+            output.subscribe(value => {
+                this.#outputRegistry.getListener(outputName)?.(value);
+            });
+        }
+    }
+}
+class FlexRenderComponentOutputManager {
+    #outputSubscribers = {};
+    #outputListeners = {};
+    #valueDiffer;
+    constructor(keyValueDiffers, initialOutputs) {
+        this.#valueDiffer = keyValueDiffers.find(initialOutputs).create();
+        if (initialOutputs) {
+            this.#valueDiffer.diff(initialOutputs);
+        }
+    }
+    hasListener(outputName) {
+        return outputName in this.#outputListeners;
+    }
+    setListener(outputName, callback) {
+        this.#outputListeners[outputName] = callback;
+    }
+    getListener(outputName) {
+        return this.#outputListeners[outputName];
+    }
+    unsubscribeAll() {
+        for (const prop in this.#outputSubscribers) {
+            this.unsubscribe(prop);
+        }
+    }
+    unsubscribe(outputName) {
+        if (outputName in this.#outputSubscribers) {
+            this.#outputSubscribers[outputName]?.unsubscribe();
+            delete this.#outputSubscribers[outputName];
+            delete this.#outputListeners[outputName];
+        }
+    }
+    diff(outputs) {
+        return this.#valueDiffer.diff(outputs ?? {});
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flex-render-component-ref.js","sourceRoot":"","sources":["../../../../../../../projects/nova-components/src/lib/components/datatable.utils/flex-render/flex-render-component-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  ComponentRef,\n  inject,\n  Injectable,\n  Injector,\n  KeyValueDiffer,\n  KeyValueDiffers,\n  OutputEmitterRef,\n  OutputRefSubscription,\n  ViewContainerRef,\n} from '@angular/core'\nimport { FlexRenderComponent } from './flex-render-component'\n\n@Injectable()\nexport class FlexRenderComponentFactory {\n  #viewContainerRef = inject(ViewContainerRef)\n\n  createComponent<T>(\n    flexRenderComponent: FlexRenderComponent<T>,\n    componentInjector: Injector\n  ): FlexRenderComponentRef<T> {\n    const componentRef = this.#viewContainerRef.createComponent(\n      flexRenderComponent.component,\n      {\n        injector: componentInjector,\n      }\n    )\n    const view = new FlexRenderComponentRef(\n      componentRef,\n      flexRenderComponent,\n      componentInjector\n    )\n\n    const { inputs, outputs } = flexRenderComponent\n\n    if (inputs) view.setInputs(inputs)\n    if (outputs) view.setOutputs(outputs)\n\n    return view\n  }\n}\n\nexport class FlexRenderComponentRef<T> {\n  readonly #keyValueDiffersFactory: KeyValueDiffers\n  #componentData: FlexRenderComponent<T>\n  #inputValueDiffer: KeyValueDiffer<string, unknown>\n\n  readonly #outputRegistry: FlexRenderComponentOutputManager\n\n  constructor(\n    readonly componentRef: ComponentRef<T>,\n    componentData: FlexRenderComponent<T>,\n    readonly componentInjector: Injector\n  ) {\n    this.#componentData = componentData\n    this.#keyValueDiffersFactory = componentInjector.get(KeyValueDiffers)\n\n    this.#outputRegistry = new FlexRenderComponentOutputManager(\n      this.#keyValueDiffersFactory,\n      this.outputs\n    )\n\n    this.#inputValueDiffer = this.#keyValueDiffersFactory\n      .find(this.inputs)\n      .create()\n    this.#inputValueDiffer.diff(this.inputs)\n\n    this.componentRef.onDestroy(() => this.#outputRegistry.unsubscribeAll())\n  }\n\n  get component() {\n    return this.#componentData.component\n  }\n\n  get inputs() {\n    return this.#componentData.inputs ?? {}\n  }\n\n  get outputs() {\n    return this.#componentData.outputs ?? {}\n  }\n\n  /**\n   * Get component input and output diff by the given item\n   */\n  diff(item: FlexRenderComponent<T>) {\n    return {\n      inputDiff: this.#inputValueDiffer.diff(item.inputs ?? {}),\n      outputDiff: this.#outputRegistry.diff(item.outputs ?? {}),\n    }\n  }\n  /**\n   *\n   * @param compare Whether the current ref component instance is the same as the given one\n   */\n  eqType(compare: FlexRenderComponent<T>): boolean {\n    return compare.component === this.component\n  }\n\n  /**\n   * Tries to update current component refs input by the new given content component.\n   */\n  update(content: FlexRenderComponent<T>) {\n    const eq = this.eqType(content)\n    if (!eq) return\n    const { inputDiff, outputDiff } = this.diff(content)\n    if (inputDiff) {\n      inputDiff.forEachAddedItem(item =>\n        this.setInput(item.key, item.currentValue)\n      )\n      inputDiff.forEachChangedItem(item =>\n        this.setInput(item.key, item.currentValue)\n      )\n      inputDiff.forEachRemovedItem(item => this.setInput(item.key, undefined))\n    }\n    if (outputDiff) {\n      outputDiff.forEachAddedItem(item => {\n        this.setOutput(item.key, item.currentValue)\n      })\n      outputDiff.forEachChangedItem(item => {\n        if (item.currentValue) {\n          this.#outputRegistry.setListener(item.key, item.currentValue)\n        } else {\n          this.#outputRegistry.unsubscribe(item.key)\n        }\n      })\n      outputDiff.forEachRemovedItem(item => {\n        this.#outputRegistry.unsubscribe(item.key)\n      })\n    }\n\n    this.#componentData = content\n  }\n\n  markAsDirty(): void {\n    this.componentRef.injector.get(ChangeDetectorRef).markForCheck()\n  }\n\n  setInputs(inputs: Record<string, unknown>) {\n    for (const prop in inputs) {\n      this.setInput(prop, inputs[prop])\n    }\n  }\n\n  setInput(key: string, value: unknown) {\n    if (this.#componentData.allowedInputNames.includes(key)) {\n      this.componentRef.setInput(key, value)\n    }\n  }\n\n  setOutputs(\n    outputs: Record<\n      string,\n      OutputEmitterRef<unknown>['emit'] | null | undefined\n    >\n  ) {\n    this.#outputRegistry.unsubscribeAll()\n    for (const prop in outputs) {\n      this.setOutput(prop, outputs[prop])\n    }\n  }\n\n  setOutput(\n    outputName: string,\n    emit: OutputEmitterRef<unknown>['emit'] | undefined | null\n  ): void {\n    if (!this.#componentData.allowedOutputNames.includes(outputName)) return\n    if (!emit) {\n      this.#outputRegistry.unsubscribe(outputName)\n      return\n    }\n\n    const hasListener = this.#outputRegistry.hasListener(outputName)\n    this.#outputRegistry.setListener(outputName, emit)\n\n    if (hasListener) {\n      return\n    }\n\n    const instance = this.componentRef.instance\n    const output = instance[outputName as keyof typeof instance]\n    if (output && output instanceof OutputEmitterRef) {\n      output.subscribe(value => {\n        this.#outputRegistry.getListener(outputName)?.(value)\n      })\n    }\n  }\n}\n\nclass FlexRenderComponentOutputManager {\n  readonly #outputSubscribers: Record<string, OutputRefSubscription> = {}\n  readonly #outputListeners: Record<string, (...args: any[]) => void> = {}\n\n  readonly #valueDiffer: KeyValueDiffer<\n    string,\n    undefined | null | OutputEmitterRef<unknown>['emit']\n  >\n\n  constructor(keyValueDiffers: KeyValueDiffers, initialOutputs: any) {\n    this.#valueDiffer = keyValueDiffers.find(initialOutputs).create()\n    if (initialOutputs) {\n      this.#valueDiffer.diff(initialOutputs)\n    }\n  }\n\n  hasListener(outputName: string) {\n    return outputName in this.#outputListeners\n  }\n\n  setListener(outputName: string, callback: (...args: any[]) => void) {\n    this.#outputListeners[outputName] = callback\n  }\n\n  getListener(outputName: string) {\n    return this.#outputListeners[outputName]\n  }\n\n  unsubscribeAll(): void {\n    for (const prop in this.#outputSubscribers) {\n      this.unsubscribe(prop)\n    }\n  }\n\n  unsubscribe(outputName: string) {\n    if (outputName in this.#outputSubscribers) {\n      this.#outputSubscribers[outputName]?.unsubscribe()\n      delete this.#outputSubscribers[outputName]\n      delete this.#outputListeners[outputName]\n    }\n  }\n\n  diff(outputs: Record<string, OutputEmitterRef<unknown>['emit'] | undefined>) {\n    return this.#valueDiffer.diff(outputs ?? {})\n  }\n}\n"]}

package/dist/nova-components/esm2022/lib/components/datatable.utils/flex-render/flex-render-component.mjs

@@ -0,0 +1,39 @@
+import { reflectComponentType, } from '@angular/core';
+/**
+ * Helper function to create a [@link FlexRenderComponent] instance, with better type-safety.
+ *
+ * - options object must be passed when the given component instance contains at least one required signal input.
+ * - options/inputs is typed with the given component inputs
+ * - options/outputs is typed with the given component outputs
+ */
+export function flexRenderComponent(component, ...options) {
+    const { inputs, injector, outputs } = options?.[0] ?? {};
+    return new FlexRenderComponent(component, inputs, injector, outputs);
+}
+/**
+ * Wrapper class for a component that will be used as content for {@link FlexRenderDirective}
+ *
+ * Prefer {@link flexRenderComponent} helper for better type-safety
+ */
+export class FlexRenderComponent {
+    constructor(component, inputs, injector, outputs) {
+        this.component = component;
+        this.inputs = inputs;
+        this.injector = injector;
+        this.outputs = outputs;
+        this.allowedInputNames = [];
+        this.allowedOutputNames = [];
+        const mirror = reflectComponentType(component);
+        if (!mirror) {
+            throw new Error(`[@tanstack-table/angular] The provided symbol is not a component`);
+        }
+        this.mirror = mirror;
+        for (const input of this.mirror.inputs) {
+            this.allowedInputNames.push(input.propName);
+        }
+        for (const output of this.mirror.outputs) {
+            this.allowedOutputNames.push(output.propName);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/nova-components/esm2022/lib/components/datatable.utils/flex-render/view.mjs

@@ -0,0 +1,101 @@
+import { TemplateRef, Type } from '@angular/core';
+import { FlexRenderComponent } from './flex-render-component';
+export function mapToFlexRenderTypedContent(content) {
+    if (content === null || content === undefined) {
+        return { kind: 'null' };
+    }
+    if (typeof content === 'string' || typeof content === 'number') {
+        return { kind: 'primitive', content };
+    }
+    if (content instanceof FlexRenderComponent) {
+        return { kind: 'flexRenderComponent', content };
+    }
+    else if (content instanceof TemplateRef) {
+        return { kind: 'templateRef', content };
+    }
+    else if (content instanceof Type) {
+        return { kind: 'component', content };
+    }
+    else {
+        return { kind: 'primitive', content };
+    }
+}
+export class FlexRenderView {
+    #previousContent;
+    #content;
+    constructor(initialContent, view) {
+        this.#content = initialContent;
+        this.view = view;
+    }
+    get previousContent() {
+        return this.#previousContent ?? { kind: 'null' };
+    }
+    get content() {
+        return this.#content;
+    }
+    set content(content) {
+        this.#previousContent = this.#content;
+        this.#content = content;
+    }
+}
+export class FlexRenderTemplateView extends FlexRenderView {
+    constructor(initialContent, view) {
+        super(initialContent, view);
+    }
+    updateProps(props) {
+        this.view.markForCheck();
+    }
+    dirtyCheck() {
+        // Basically a no-op. When the view is created via EmbeddedViewRef, we don't need to do any manual update
+        // since this type of content has a proxy as a context, then every time the root component is checked for changes,
+        // the property getter will be re-evaluated.
+        //
+        // If in a future we need to manually mark the view as dirty, just uncomment next line
+        // this.view.markForCheck()
+    }
+    onDestroy(callback) {
+        this.view.onDestroy(callback);
+    }
+}
+export class FlexRenderComponentView extends FlexRenderView {
+    constructor(initialContent, view) {
+        super(initialContent, view);
+    }
+    updateProps(props) {
+        switch (this.content.kind) {
+            case 'component': {
+                this.view.setInputs(props);
+                break;
+            }
+            case 'flexRenderComponent': {
+                // No-op. When FlexRenderFlags.PropsReferenceChanged is set,
+                // FlexRenderComponent will be updated into `dirtyCheck`.
+                break;
+            }
+        }
+    }
+    dirtyCheck() {
+        switch (this.content.kind) {
+            case 'component': {
+                // Component context is currently valuated with the cell context. Since it's reference
+                // shouldn't change, we force mark the component as dirty in order to re-evaluate function invocation in view.
+                // NOTE: this should behave like having a component with ChangeDetectionStrategy.Default
+                this.view.markAsDirty();
+                break;
+            }
+            case 'flexRenderComponent': {
+                // Given context instance will always have a different reference than the previous one,
+                // so instead of recreating the entire view, we will only update the current view
+                if (this.view.eqType(this.content.content)) {
+                    this.view.update(this.content.content);
+                }
+                this.view.markAsDirty();
+                break;
+            }
+        }
+    }
+    onDestroy(callback) {
+        this.view.componentRef.onDestroy(callback);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../../projects/nova-components/src/lib/components/datatable.utils/flex-render/view.ts"],"names":[],"mappings":"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","sourcesContent":["import { FlexRenderComponentRef } from './flex-render-component-ref'\nimport { EmbeddedViewRef, TemplateRef, Type } from '@angular/core'\nimport type { FlexRenderContent } from '../flex-render'\nimport { FlexRenderComponent } from './flex-render-component'\n\nexport type FlexRenderTypedContent =\n  | { kind: 'null' }\n  | {\n      kind: 'primitive'\n      content: string | number | Record<string, any>\n    }\n  | { kind: 'flexRenderComponent'; content: FlexRenderComponent<unknown> }\n  | { kind: 'templateRef'; content: TemplateRef<unknown> }\n  | { kind: 'component'; content: Type<unknown> }\n\nexport function mapToFlexRenderTypedContent(\n  content: FlexRenderContent<any>\n): FlexRenderTypedContent {\n  if (content === null || content === undefined) {\n    return { kind: 'null' }\n  }\n  if (typeof content === 'string' || typeof content === 'number') {\n    return { kind: 'primitive', content }\n  }\n  if (content instanceof FlexRenderComponent) {\n    return { kind: 'flexRenderComponent', content }\n  } else if (content instanceof TemplateRef) {\n    return { kind: 'templateRef', content }\n  } else if (content instanceof Type) {\n    return { kind: 'component', content }\n  } else {\n    return { kind: 'primitive', content }\n  }\n}\n\nexport abstract class FlexRenderView<\n  TView extends FlexRenderComponentRef<any> | EmbeddedViewRef<unknown> | null,\n> {\n  readonly view: TView\n  #previousContent: FlexRenderTypedContent | undefined\n  #content: FlexRenderTypedContent\n\n  protected constructor(\n    initialContent: Exclude<FlexRenderTypedContent, { kind: 'null' }>,\n    view: TView\n  ) {\n    this.#content = initialContent\n    this.view = view\n  }\n\n  get previousContent(): FlexRenderTypedContent {\n    return this.#previousContent ?? { kind: 'null' }\n  }\n\n  get content() {\n    return this.#content\n  }\n\n  set content(content: FlexRenderTypedContent) {\n    this.#previousContent = this.#content\n    this.#content = content\n  }\n\n  abstract updateProps(props: Record<string, any>): void\n\n  abstract dirtyCheck(): void\n\n  abstract onDestroy(callback: Function): void\n}\n\nexport class FlexRenderTemplateView extends FlexRenderView<\n  EmbeddedViewRef<unknown>\n> {\n  constructor(\n    initialContent: Extract<\n      FlexRenderTypedContent,\n      { kind: 'primitive' | 'templateRef' }\n    >,\n    view: EmbeddedViewRef<unknown>\n  ) {\n    super(initialContent, view)\n  }\n\n  override updateProps(props: Record<string, any>) {\n    this.view.markForCheck()\n  }\n\n  override dirtyCheck() {\n    // Basically a no-op. When the view is created via EmbeddedViewRef, we don't need to do any manual update\n    // since this type of content has a proxy as a context, then every time the root component is checked for changes,\n    // the property getter will be re-evaluated.\n    //\n    // If in a future we need to manually mark the view as dirty, just uncomment next line\n    // this.view.markForCheck()\n  }\n\n  override onDestroy(callback: Function) {\n    this.view.onDestroy(callback)\n  }\n}\n\nexport class FlexRenderComponentView extends FlexRenderView<\n  FlexRenderComponentRef<unknown>\n> {\n  constructor(\n    initialContent: Extract<\n      FlexRenderTypedContent,\n      { kind: 'component' | 'flexRenderComponent' }\n    >,\n    view: FlexRenderComponentRef<unknown>\n  ) {\n    super(initialContent, view)\n  }\n\n  override updateProps(props: Record<string, any>) {\n    switch (this.content.kind) {\n      case 'component': {\n        this.view.setInputs(props)\n        break\n      }\n      case 'flexRenderComponent': {\n        // No-op. When FlexRenderFlags.PropsReferenceChanged is set,\n        // FlexRenderComponent will be updated into `dirtyCheck`.\n        break\n      }\n    }\n  }\n\n  override dirtyCheck() {\n    switch (this.content.kind) {\n      case 'component': {\n        // Component context is currently valuated with the cell context. Since it's reference\n        // shouldn't change, we force mark the component as dirty in order to re-evaluate function invocation in view.\n        // NOTE: this should behave like having a component with ChangeDetectionStrategy.Default\n        this.view.markAsDirty()\n        break\n      }\n      case 'flexRenderComponent': {\n        // Given context instance will always have a different reference than the previous one,\n        // so instead of recreating the entire view, we will only update the current view\n        if (this.view.eqType(this.content.content)) {\n          this.view.update(this.content.content)\n        }\n        this.view.markAsDirty()\n        break\n      }\n    }\n  }\n\n  override onDestroy(callback: Function) {\n    this.view.componentRef.onDestroy(callback)\n  }\n}\n"]}