@tanstack/angular-table 8.20.5 → 8.21.0

package/build/lib/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9mbGV4LXJlbmRlci9jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRXRELE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLElBQUksY0FBYyxDQUV4RCwrREFBK0QsQ0FBQyxDQUFBO0FBRWxFLE1BQU0sVUFBVSx1QkFBdUI7SUFDckMsT0FBTyxNQUFNLENBQUksd0JBQXdCLENBQUMsQ0FBQTtBQUM1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0LCBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmV4cG9ydCBjb25zdCBGbGV4UmVuZGVyQ29tcG9uZW50UHJvcHMgPSBuZXcgSW5qZWN0aW9uVG9rZW48XG4gIE5vbk51bGxhYmxlPHVua25vd24+XG4+KCdbQHRhbnN0YWNrL2FuZ3VsYXItdGFibGVdIEZsZXggcmVuZGVyIGNvbXBvbmVudCBjb250ZXh0IHByb3BzJylcblxuZXhwb3J0IGZ1bmN0aW9uIGluamVjdEZsZXhSZW5kZXJDb250ZXh0PFQgZXh0ZW5kcyBOb25OdWxsYWJsZTx1bmtub3duPj4oKTogVCB7XG4gIHJldHVybiBpbmplY3Q8VD4oRmxleFJlbmRlckNvbXBvbmVudFByb3BzKVxufVxuIl19

package/build/lib/esm2022/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,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

package/build/lib/esm2022/flex-render/flex-render-component-ref.mjs

@@ -0,0 +1,173 @@
+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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: FlexRenderComponentFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: FlexRenderComponentFactory });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: FlexRenderComponentFactory, decorators: [{
+            type: Injectable
+        }] });
+export class FlexRenderComponentRef {
+    componentRef;
+    componentInjector;
+    #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":["../../../../src/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/build/lib/esm2022/flex-render/flex-render-component.mjs

@@ -0,0 +1,44 @@
+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 {
+    component;
+    inputs;
+    injector;
+    outputs;
+    mirror;
+    allowedInputNames = [];
+    allowedOutputNames = [];
+    constructor(component, inputs, injector, outputs) {
+        this.component = component;
+        this.inputs = inputs;
+        this.injector = injector;
+        this.outputs = outputs;
+        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/build/lib/esm2022/flex-render/view.mjs

@@ -0,0 +1,102 @@
+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 {
+    view;
+    #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":["../../../../src/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"]}