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

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

@@ -0,0 +1,211 @@
+import { ChangeDetectorRef, Directive, effect, Inject, inject, Injector, Input, runInInjectionContext, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { FlexRenderComponentProps } from './flex-render/context';
+import { FlexRenderFlags } from './flex-render/flags';
+import { flexRenderComponent, } from './flex-render/flex-render-component';
+import { FlexRenderComponentFactory } from './flex-render/flex-render-component-ref';
+import { FlexRenderComponentView, FlexRenderTemplateView, mapToFlexRenderTypedContent, } from './flex-render/view';
+import { memo } from '@tanstack/table-core';
+import * as i0 from "@angular/core";
+export { injectFlexRenderContext, } from './flex-render/context';
+export class FlexRenderDirective {
+    #flexRenderComponentFactory;
+    #changeDetectorRef;
+    #latestContent;
+    #getContentValue;
+    constructor(viewContainerRef, templateRef) {
+        this.viewContainerRef = viewContainerRef;
+        this.templateRef = templateRef;
+        this.#flexRenderComponentFactory = inject(FlexRenderComponentFactory);
+        this.#changeDetectorRef = inject(ChangeDetectorRef);
+        this.content = undefined;
+        this.props = {};
+        this.injector = inject(Injector);
+        this.renderFlags = FlexRenderFlags.ViewFirstRender;
+        this.renderView = null;
+        this.#latestContent = () => {
+            const { content, props } = this;
+            return typeof content !== 'function'
+                ? content
+                : runInInjectionContext(this.injector, () => content(props));
+        };
+        this.#getContentValue = memo(() => [this.#latestContent(), this.props, this.content], latestContent => {
+            return mapToFlexRenderTypedContent(latestContent);
+        }, { key: 'flexRenderContentValue', debug: () => false });
+        this.#currentEffectRef = null;
+    }
+    ngOnChanges(changes) {
+        if (changes['props']) {
+            this.renderFlags |= FlexRenderFlags.PropsReferenceChanged;
+        }
+        if (changes['content']) {
+            this.renderFlags |=
+                FlexRenderFlags.ContentChanged | FlexRenderFlags.ViewFirstRender;
+            this.update();
+        }
+    }
+    ngDoCheck() {
+        if (this.renderFlags & FlexRenderFlags.ViewFirstRender) {
+            // On the initial render, the view is created during the `ngOnChanges` hook.
+            // Since `ngDoCheck` is called immediately afterward, there's no need to check for changes in this phase.
+            this.renderFlags &= ~FlexRenderFlags.ViewFirstRender;
+            return;
+        }
+        this.renderFlags |= FlexRenderFlags.DirtyCheck;
+        const latestContent = this.#getContentValue();
+        if (latestContent.kind === 'null' || !this.renderView) {
+            this.renderFlags |= FlexRenderFlags.ContentChanged;
+        }
+        else {
+            this.renderView.content = latestContent;
+            const { kind: previousKind } = this.renderView.previousContent;
+            if (latestContent.kind !== previousKind) {
+                this.renderFlags |= FlexRenderFlags.ContentChanged;
+            }
+        }
+        this.update();
+    }
+    update() {
+        if (this.renderFlags &
+            (FlexRenderFlags.ContentChanged | FlexRenderFlags.ViewFirstRender)) {
+            this.render();
+            return;
+        }
+        if (this.renderFlags & FlexRenderFlags.PropsReferenceChanged) {
+            if (this.renderView)
+                this.renderView.updateProps(this.props);
+            this.renderFlags &= ~FlexRenderFlags.PropsReferenceChanged;
+        }
+        if (this.renderFlags &
+            (FlexRenderFlags.DirtyCheck | FlexRenderFlags.DirtySignal)) {
+            if (this.renderView)
+                this.renderView.dirtyCheck();
+            this.renderFlags &= ~(FlexRenderFlags.DirtyCheck | FlexRenderFlags.DirtySignal);
+        }
+    }
+    #currentEffectRef;
+    render() {
+        if (this.#shouldRecreateEntireView() && this.#currentEffectRef) {
+            this.#currentEffectRef.destroy();
+            this.#currentEffectRef = null;
+            this.renderFlags &= ~FlexRenderFlags.RenderEffectChecked;
+        }
+        this.viewContainerRef.clear();
+        this.renderFlags =
+            FlexRenderFlags.Pristine |
+                (this.renderFlags & FlexRenderFlags.ViewFirstRender) |
+                (this.renderFlags & FlexRenderFlags.RenderEffectChecked);
+        const resolvedContent = this.#getContentValue();
+        if (resolvedContent.kind === 'null') {
+            this.renderView = null;
+        }
+        else {
+            this.renderView = this.#renderViewByContent(resolvedContent);
+        }
+        // If the content is a function `content(props)`, we initialize an effect
+        // in order to react to changes if the given definition use signals.
+        if (!this.#currentEffectRef && typeof this.content === 'function') {
+            this.#currentEffectRef = effect(() => {
+                this.#latestContent();
+                if (!(this.renderFlags & FlexRenderFlags.RenderEffectChecked)) {
+                    this.renderFlags |= FlexRenderFlags.RenderEffectChecked;
+                    return;
+                }
+                this.renderFlags |= FlexRenderFlags.DirtySignal;
+                // This will mark the view as changed,
+                // so we'll try to check for updates into ngDoCheck
+                this.#changeDetectorRef.markForCheck();
+            }, { injector: this.viewContainerRef.injector });
+        }
+    }
+    #shouldRecreateEntireView() {
+        return (this.renderFlags &
+            FlexRenderFlags.ContentChanged &
+            FlexRenderFlags.ViewFirstRender);
+    }
+    #renderViewByContent(content) {
+        if (content.kind === 'primitive') {
+            return this.#renderStringContent(content);
+        }
+        else if (content.kind === 'templateRef') {
+            return this.#renderTemplateRefContent(content);
+        }
+        else if (content.kind === 'flexRenderComponent') {
+            return this.#renderComponent(content);
+        }
+        else if (content.kind === 'component') {
+            return this.#renderCustomComponent(content);
+        }
+        else {
+            return null;
+        }
+    }
+    #renderStringContent(template) {
+        const context = () => {
+            return typeof this.content === 'string' ||
+                typeof this.content === 'number'
+                ? this.content
+                : this.content?.(this.props);
+        };
+        const ref = this.viewContainerRef.createEmbeddedView(this.templateRef, {
+            get $implicit() {
+                return context();
+            },
+        });
+        return new FlexRenderTemplateView(template, ref);
+    }
+    #renderTemplateRefContent(template) {
+        const latestContext = () => this.props;
+        const view = this.viewContainerRef.createEmbeddedView(template.content, {
+            get $implicit() {
+                return latestContext();
+            },
+        });
+        return new FlexRenderTemplateView(template, view);
+    }
+    #renderComponent(flexRenderComponent) {
+        const { inputs, outputs, injector } = flexRenderComponent.content;
+        const getContext = () => this.props;
+        const proxy = new Proxy(this.props, {
+            get: (_, key) => getContext()[key],
+        });
+        const componentInjector = Injector.create({
+            parent: injector ?? this.injector,
+            providers: [{ provide: FlexRenderComponentProps, useValue: proxy }],
+        });
+        const view = this.#flexRenderComponentFactory.createComponent(flexRenderComponent.content, componentInjector);
+        return new FlexRenderComponentView(flexRenderComponent, view);
+    }
+    #renderCustomComponent(component) {
+        const view = this.#flexRenderComponentFactory.createComponent(flexRenderComponent(component.content, {
+            inputs: this.props,
+            injector: this.injector,
+        }), this.injector);
+        return new FlexRenderComponentView(component, view);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FlexRenderDirective, deps: [{ token: ViewContainerRef }, { token: TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FlexRenderDirective, isStandalone: true, selector: "[flexRender]", inputs: { content: ["flexRender", "content"], props: ["flexRenderProps", "props"], injector: ["flexRenderInjector", "injector"] }, providers: [FlexRenderComponentFactory], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FlexRenderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[flexRender]',
+                    standalone: true,
+                    providers: [FlexRenderComponentFactory],
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef, decorators: [{
+                    type: Inject,
+                    args: [ViewContainerRef]
+                }] }, { type: i0.TemplateRef, decorators: [{
+                    type: Inject,
+                    args: [TemplateRef]
+                }] }], propDecorators: { content: [{
+                type: Input,
+                args: [{ required: true, alias: 'flexRender' }]
+            }], props: [{
+                type: Input,
+                args: [{ required: true, alias: 'flexRenderProps' }]
+            }], injector: [{
+                type: Input,
+                args: [{ required: false, alias: 'flexRenderInjector' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flex-render.js","sourceRoot":"","sources":["../../../../../../projects/nova-components/src/lib/components/datatable.utils/flex-render.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  DoCheck,\n  effect,\n  type EffectRef,\n  Inject,\n  inject,\n  Injector,\n  Input,\n  OnChanges,\n  runInInjectionContext,\n  SimpleChanges,\n  TemplateRef,\n  Type,\n  ViewContainerRef,\n} from '@angular/core'\nimport { FlexRenderComponentProps } from './flex-render/context'\nimport { FlexRenderFlags } from './flex-render/flags'\nimport {\n  flexRenderComponent,\n  FlexRenderComponent,\n} from './flex-render/flex-render-component'\nimport { FlexRenderComponentFactory } from './flex-render/flex-render-component-ref'\nimport {\n  FlexRenderComponentView,\n  FlexRenderTemplateView,\n  type FlexRenderTypedContent,\n  FlexRenderView,\n  mapToFlexRenderTypedContent,\n} from './flex-render/view'\nimport { memo } from '@tanstack/table-core'\n\nexport {\n  injectFlexRenderContext,\n  type FlexRenderComponentProps,\n} from './flex-render/context'\n\nexport type FlexRenderContent<TProps extends NonNullable<unknown>> =\n  | string\n  | number\n  | Type<TProps>\n  | FlexRenderComponent<TProps>\n  | TemplateRef<{ $implicit: TProps }>\n  | null\n  | Record<any, any>\n  | undefined\n\n@Directive({\n  selector: '[flexRender]',\n  standalone: true,\n  providers: [FlexRenderComponentFactory],\n})\nexport class FlexRenderDirective<TProps extends NonNullable<unknown>>\n  implements OnChanges, DoCheck\n{\n  readonly #flexRenderComponentFactory = inject(FlexRenderComponentFactory)\n  readonly #changeDetectorRef = inject(ChangeDetectorRef)\n\n  @Input({ required: true, alias: 'flexRender' })\n  content:\n    | number\n    | string\n    | ((props: TProps) => FlexRenderContent<TProps>)\n    | null\n    | undefined = undefined\n\n  @Input({ required: true, alias: 'flexRenderProps' })\n  props: TProps = {} as TProps\n\n  @Input({ required: false, alias: 'flexRenderInjector' })\n  injector: Injector = inject(Injector)\n\n  renderFlags = FlexRenderFlags.ViewFirstRender\n  renderView: FlexRenderView<any> | null = null\n\n  readonly #latestContent = () => {\n    const { content, props } = this\n    return typeof content !== 'function'\n      ? content\n      : runInInjectionContext(this.injector, () => content(props))\n  }\n\n  #getContentValue = memo(\n    () => [this.#latestContent(), this.props, this.content],\n    latestContent => {\n      return mapToFlexRenderTypedContent(latestContent)\n    },\n    { key: 'flexRenderContentValue', debug: () => false }\n  )\n\n  constructor(\n    @Inject(ViewContainerRef)\n    private readonly viewContainerRef: ViewContainerRef,\n    @Inject(TemplateRef)\n    private readonly templateRef: TemplateRef<any>\n  ) {}\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['props']) {\n      this.renderFlags |= FlexRenderFlags.PropsReferenceChanged\n    }\n    if (changes['content']) {\n      this.renderFlags |=\n        FlexRenderFlags.ContentChanged | FlexRenderFlags.ViewFirstRender\n      this.update()\n    }\n  }\n\n  ngDoCheck(): void {\n    if (this.renderFlags & FlexRenderFlags.ViewFirstRender) {\n      // On the initial render, the view is created during the `ngOnChanges` hook.\n      // Since `ngDoCheck` is called immediately afterward, there's no need to check for changes in this phase.\n      this.renderFlags &= ~FlexRenderFlags.ViewFirstRender\n      return\n    }\n\n    this.renderFlags |= FlexRenderFlags.DirtyCheck\n\n    const latestContent = this.#getContentValue()\n    if (latestContent.kind === 'null' || !this.renderView) {\n      this.renderFlags |= FlexRenderFlags.ContentChanged\n    } else {\n      this.renderView.content = latestContent\n      const { kind: previousKind } = this.renderView.previousContent\n      if (latestContent.kind !== previousKind) {\n        this.renderFlags |= FlexRenderFlags.ContentChanged\n      }\n    }\n    this.update()\n  }\n\n  update() {\n    if (\n      this.renderFlags &\n      (FlexRenderFlags.ContentChanged | FlexRenderFlags.ViewFirstRender)\n    ) {\n      this.render()\n      return\n    }\n    if (this.renderFlags & FlexRenderFlags.PropsReferenceChanged) {\n      if (this.renderView) this.renderView.updateProps(this.props)\n      this.renderFlags &= ~FlexRenderFlags.PropsReferenceChanged\n    }\n    if (\n      this.renderFlags &\n      (FlexRenderFlags.DirtyCheck | FlexRenderFlags.DirtySignal)\n    ) {\n      if (this.renderView) this.renderView.dirtyCheck()\n      this.renderFlags &= ~(\n        FlexRenderFlags.DirtyCheck | FlexRenderFlags.DirtySignal\n      )\n    }\n  }\n\n  #currentEffectRef: EffectRef | null = null\n\n  render() {\n    if (this.#shouldRecreateEntireView() && this.#currentEffectRef) {\n      this.#currentEffectRef.destroy()\n      this.#currentEffectRef = null\n      this.renderFlags &= ~FlexRenderFlags.RenderEffectChecked\n    }\n\n    this.viewContainerRef.clear()\n    this.renderFlags =\n      FlexRenderFlags.Pristine |\n      (this.renderFlags & FlexRenderFlags.ViewFirstRender) |\n      (this.renderFlags & FlexRenderFlags.RenderEffectChecked)\n\n    const resolvedContent = this.#getContentValue()\n    if (resolvedContent.kind === 'null') {\n      this.renderView = null\n    } else {\n      this.renderView = this.#renderViewByContent(resolvedContent)\n    }\n\n    // If the content is a function `content(props)`, we initialize an effect\n    // in order to react to changes if the given definition use signals.\n    if (!this.#currentEffectRef && typeof this.content === 'function') {\n      this.#currentEffectRef = effect(\n        () => {\n          this.#latestContent()\n          if (!(this.renderFlags & FlexRenderFlags.RenderEffectChecked)) {\n            this.renderFlags |= FlexRenderFlags.RenderEffectChecked\n            return\n          }\n          this.renderFlags |= FlexRenderFlags.DirtySignal\n          // This will mark the view as changed,\n          // so we'll try to check for updates into ngDoCheck\n          this.#changeDetectorRef.markForCheck()\n        },\n        { injector: this.viewContainerRef.injector }\n      )\n    }\n  }\n\n  #shouldRecreateEntireView() {\n    return (\n      this.renderFlags &\n      FlexRenderFlags.ContentChanged &\n      FlexRenderFlags.ViewFirstRender\n    )\n  }\n\n  #renderViewByContent(\n    content: FlexRenderTypedContent\n  ): FlexRenderView<any> | null {\n    if (content.kind === 'primitive') {\n      return this.#renderStringContent(content)\n    } else if (content.kind === 'templateRef') {\n      return this.#renderTemplateRefContent(content)\n    } else if (content.kind === 'flexRenderComponent') {\n      return this.#renderComponent(content)\n    } else if (content.kind === 'component') {\n      return this.#renderCustomComponent(content)\n    } else {\n      return null\n    }\n  }\n\n  #renderStringContent(\n    template: Extract<FlexRenderTypedContent, { kind: 'primitive' }>\n  ): FlexRenderTemplateView {\n    const context = () => {\n      return typeof this.content === 'string' ||\n        typeof this.content === 'number'\n        ? this.content\n        : this.content?.(this.props)\n    }\n    const ref = this.viewContainerRef.createEmbeddedView(this.templateRef, {\n      get $implicit() {\n        return context()\n      },\n    })\n    return new FlexRenderTemplateView(template, ref)\n  }\n\n  #renderTemplateRefContent(\n    template: Extract<FlexRenderTypedContent, { kind: 'templateRef' }>\n  ): FlexRenderTemplateView {\n    const latestContext = () => this.props\n    const view = this.viewContainerRef.createEmbeddedView(template.content, {\n      get $implicit() {\n        return latestContext()\n      },\n    })\n    return new FlexRenderTemplateView(template, view)\n  }\n\n  #renderComponent(\n    flexRenderComponent: Extract<\n      FlexRenderTypedContent,\n      { kind: 'flexRenderComponent' }\n    >\n  ): FlexRenderComponentView {\n    const { inputs, outputs, injector } = flexRenderComponent.content\n\n    const getContext = () => this.props\n    const proxy = new Proxy(this.props, {\n      get: (_, key) => getContext()[key as keyof typeof _],\n    })\n    const componentInjector = Injector.create({\n      parent: injector ?? this.injector,\n      providers: [{ provide: FlexRenderComponentProps, useValue: proxy }],\n    })\n    const view = this.#flexRenderComponentFactory.createComponent(\n      flexRenderComponent.content,\n      componentInjector\n    )\n    return new FlexRenderComponentView(flexRenderComponent, view)\n  }\n\n  #renderCustomComponent(\n    component: Extract<FlexRenderTypedContent, { kind: 'component' }>\n  ): FlexRenderComponentView {\n    const view = this.#flexRenderComponentFactory.createComponent(\n      flexRenderComponent(component.content, {\n        inputs: this.props,\n        injector: this.injector,\n      }),\n      this.injector\n    )\n    return new FlexRenderComponentView(component, view)\n  }\n}\n"]}

package/dist/nova-components/esm2022/lib/components/datatable.utils/index.mjs

@@ -0,0 +1,49 @@
+import { computed, signal } from '@angular/core';
+import { createTable, } from '@tanstack/table-core';
+import { lazyInit } from './lazy-signal-initializer';
+import { proxifyTable } from './proxy';
+export * from '@tanstack/table-core';
+export { FlexRenderDirective, FlexRenderDirective as FlexRender, injectFlexRenderContext, } from './flex-render';
+export { FlexRenderComponent, flexRenderComponent, } from './flex-render/flex-render-component';
+export function createAngularTable(options) {
+    return lazyInit(() => {
+        const resolvedOptions = {
+            state: {},
+            onStateChange: () => { },
+            renderFallbackValue: null,
+            ...options(),
+        };
+        const table = createTable(resolvedOptions);
+        // By default, manage table state here using the table's initial state
+        const state = signal(table.initialState);
+        // Compose table options using computed.
+        // This is to allow `tableSignal` to listen and set table option
+        const updatedOptions = computed(() => {
+            // listen to table state changed
+            const tableState = state();
+            // listen to input options changed
+            const tableOptions = options();
+            return {
+                ...table.options,
+                ...resolvedOptions,
+                ...tableOptions,
+                state: { ...tableState, ...tableOptions.state },
+                onStateChange: updater => {
+                    const value = updater instanceof Function ? updater(tableState) : updater;
+                    state.set(value);
+                    resolvedOptions.onStateChange?.(updater);
+                },
+            };
+        });
+        // convert table instance to signal for proxify to listen to any table state and options changes
+        const tableSignal = computed(() => {
+            table.setOptions(updatedOptions());
+            return table;
+        }, {
+            equal: () => false,
+        });
+        // proxify Table instance to provide ability for consumer to listen to any table state changes
+        return proxifyTable(tableSignal);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/nova-components/esm2022/lib/components/datatable.utils/lazy-signal-initializer.mjs

@@ -0,0 +1,43 @@
+import { untracked } from '@angular/core';
+/**
+ * Implementation from @tanstack/angular-query
+ * {@link https://github.com/TanStack/query/blob/main/packages/angular-query-experimental/src/util/lazy-init/lazy-init.ts}
+ */
+export function lazyInit(initializer) {
+    let object = null;
+    const initializeObject = () => {
+        if (!object) {
+            object = untracked(() => initializer());
+        }
+    };
+    queueMicrotask(() => initializeObject());
+    const table = () => { };
+    return new Proxy(table, {
+        apply(target, thisArg, argArray) {
+            initializeObject();
+            if (typeof object === 'function') {
+                return Reflect.apply(object, thisArg, argArray);
+            }
+            return Reflect.apply(target, thisArg, argArray);
+        },
+        get(_, prop, receiver) {
+            initializeObject();
+            return Reflect.get(object, prop, receiver);
+        },
+        has(_, prop) {
+            initializeObject();
+            return Reflect.has(object, prop);
+        },
+        ownKeys() {
+            initializeObject();
+            return Reflect.ownKeys(object);
+        },
+        getOwnPropertyDescriptor() {
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/nova-components/esm2022/lib/components/datatable.utils/proxy.mjs

@@ -0,0 +1,87 @@
+import { computed, untracked } from '@angular/core';
+export function proxifyTable(tableSignal) {
+    const internalState = tableSignal;
+    return new Proxy(internalState, {
+        apply() {
+            return tableSignal();
+        },
+        get(target, property) {
+            if (target[property]) {
+                return target[property];
+            }
+            const table = untracked(tableSignal);
+            /**
+             * Attempt to convert all accessors into computed ones,
+             * excluding handlers as they do not retain any reactive value
+             */
+            if (property.startsWith('get') &&
+                !property.endsWith('Handler')
+            // e.g. getCoreRowModel, getSelectedRowModel etc.
+            // We need that after a signal change even `rowModel` may mark the view as dirty.
+            // This allows to always get the latest `getContext` value while using flexRender
+            // && !property.endsWith('Model')
+            ) {
+                const maybeFn = table[property];
+                if (typeof maybeFn === 'function') {
+                    Object.defineProperty(target, property, {
+                        value: toComputed(tableSignal, maybeFn),
+                        configurable: true,
+                        enumerable: true,
+                    });
+                    return target[property];
+                }
+            }
+            // @ts-expect-error
+            return (target[property] = table[property]);
+        },
+        has(_, prop) {
+            return !!untracked(tableSignal)[prop];
+        },
+        ownKeys() {
+            return Reflect.ownKeys(untracked(tableSignal));
+        },
+        getOwnPropertyDescriptor() {
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        },
+    });
+}
+/**
+ * Here we'll handle all type of accessors:
+ * - 0 argument -> e.g. table.getCanNextPage())
+ * - 0~1 arguments -> e.g. table.getIsSomeRowsPinned(position?)
+ * - 1 required argument -> e.g. table.getColumn(columnId)
+ * - 1+ argument -> e.g. table.getRow(id, searchAll?)
+ *
+ * Since we are not able to detect automatically the accessors parameters,
+ * we'll wrap all accessors into a cached function wrapping a computed
+ * that return it's value based on the given parameters
+ */
+function toComputed(signal, fn) {
+    const hasArgs = fn.length > 0;
+    if (!hasArgs) {
+        return computed(() => {
+            void signal();
+            return fn();
+        });
+    }
+    const computedCache = {};
+    return (...argsArray) => {
+        const serializedArgs = serializeArgs(...argsArray);
+        if (computedCache.hasOwnProperty(serializedArgs)) {
+            return computedCache[serializedArgs]?.();
+        }
+        const computedSignal = computed(() => {
+            void signal();
+            return fn(...argsArray);
+        });
+        computedCache[serializedArgs] = computedSignal;
+        return computedSignal();
+    };
+}
+function serializeArgs(...args) {
+    return JSON.stringify(args);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/nova-components/esm2022/lib/components/index.mjs

@@ -0,0 +1,2 @@
+export * from './nv-datatable.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZhLWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL252LWRhdGF0YWJsZS5jb21wb25lbnQnO1xuIl19

package/dist/nova-components/esm2022/lib/components/nv-datatable.component.mjs

@@ -0,0 +1,158 @@
+/* eslint-disable jsdoc/require-jsdoc */
+/* eslint-disable jsdoc/require-returns */
+import { Component, computed, input, CUSTOM_ELEMENTS_SCHEMA, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { createAngularTable, getCoreRowModel, FlexRenderDirective, } from './datatable.utils'; // local copy of @tanstack/angular-table (required for storybook, the built version is not working)
+import * as i0 from "@angular/core";
+export { flexRenderComponent as nvDatatableRenderComponent } from './datatable.utils';
+/**
+ * Nova Datatable built on TanStack Table (Angular).
+ */
+export class NvDatatable {
+    constructor() {
+        /** Column definitions */
+        this.columns = input([]);
+        /** Row data */
+        this.rows = input([]);
+        /** Computed table columns with proper typing and filtering. */
+        this.tableColumns = computed(() => this.columns()
+            .filter((col) => !col.hidden)
+            .map((col) => ({
+            accessorKey: col.field,
+            header: col.headerName || String(col.field),
+            size: col.width,
+            enableResizing: col.resizable ?? true,
+            cell: col.renderCell ??
+                ((context) => context.getValue()),
+        })));
+        /** TanStack table instance with Signals */
+        this.tableInstance = createAngularTable(() => ({
+            data: this.rows(),
+            columns: this.tableColumns(),
+            getCoreRowModel: getCoreRowModel(),
+        }));
+    }
+    /** Public getter for table instance. */
+    table() {
+        return this.tableInstance();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NvDatatable, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: NvDatatable, isStandalone: true, selector: "nv-datatable", inputs: { columns: { classPropertyName: "columns", publicName: "columns", isSignal: true, isRequired: false, transformFunction: null }, rows: { classPropertyName: "rows", publicName: "rows", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    <nv-table>
+      <table>
+        <thead>
+          @for (headerGroup of table().getHeaderGroups(); track headerGroup.id)
+          {
+          <tr>
+            @for (header of headerGroup.headers; track header.id) {
+            <th
+              [attr.data-testid]="'datatable-header-' + header.id"
+              [style.width]="
+                header.column.columnDef.size
+                  ? header.column.columnDef.size + 'px'
+                  : null
+              "
+              [attr.data-no-resize]="
+                !header.column.columnDef.enableResizing ? 'true' : null
+              "
+            >
+              @if (!header.isPlaceholder) {
+              {{ header.column.columnDef.header }}
+              }
+            </th>
+            }
+          </tr>
+          }
+        </thead>
+
+        <tbody>
+          @for (row of table().getRowModel().rows; track row.id) {
+          <tr [attr.data-testid]="'datatable-row-' + row.id">
+            @for (cell of row.getVisibleCells(); track cell.id) {
+            <td
+              [attr.data-testid]="'datatable-cell-' + cell.id"
+              style="padding: 8px; border-bottom: 1px solid #eee;"
+            >
+              <!-- Let FlexRender handle strings vs TemplateRef -->
+              <ng-container
+                *flexRender="
+                  cell.column.columnDef.cell;
+                  props: cell.getContext();
+                  let cellContent
+                "
+              >
+                {{ cellContent }}
+              </ng-container>
+            </td>
+            }
+          </tr>
+          }
+        </tbody>
+      </table>
+    </nv-table>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: FlexRenderDirective, selector: "[flexRender]", inputs: ["flexRender", "flexRenderProps", "flexRenderInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NvDatatable, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'nv-datatable',
+                    standalone: true,
+                    imports: [CommonModule, FlexRenderDirective],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    template: `
+    <nv-table>
+      <table>
+        <thead>
+          @for (headerGroup of table().getHeaderGroups(); track headerGroup.id)
+          {
+          <tr>
+            @for (header of headerGroup.headers; track header.id) {
+            <th
+              [attr.data-testid]="'datatable-header-' + header.id"
+              [style.width]="
+                header.column.columnDef.size
+                  ? header.column.columnDef.size + 'px'
+                  : null
+              "
+              [attr.data-no-resize]="
+                !header.column.columnDef.enableResizing ? 'true' : null
+              "
+            >
+              @if (!header.isPlaceholder) {
+              {{ header.column.columnDef.header }}
+              }
+            </th>
+            }
+          </tr>
+          }
+        </thead>
+
+        <tbody>
+          @for (row of table().getRowModel().rows; track row.id) {
+          <tr [attr.data-testid]="'datatable-row-' + row.id">
+            @for (cell of row.getVisibleCells(); track cell.id) {
+            <td
+              [attr.data-testid]="'datatable-cell-' + cell.id"
+              style="padding: 8px; border-bottom: 1px solid #eee;"
+            >
+              <!-- Let FlexRender handle strings vs TemplateRef -->
+              <ng-container
+                *flexRender="
+                  cell.column.columnDef.cell;
+                  props: cell.getContext();
+                  let cellContent
+                "
+              >
+                {{ cellContent }}
+              </ng-container>
+            </td>
+            }
+          </tr>
+          }
+        </tbody>
+      </table>
+    </nv-table>
+  `,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nv-datatable.component.js","sourceRoot":"","sources":["../../../../../projects/nova-components/src/lib/components/nv-datatable.component.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,0CAA0C;AAE1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,KAAK,EAEL,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,mBAAmB,GAIpB,MAAM,mBAAmB,CAAC,CAAC,mGAAmG;;AAI/H,OAAO,EAAE,mBAAmB,IAAI,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAmCtF;;GAEG;AA6DH,MAAM,OAAO,WAAW;IA5DxB;QA6DE,yBAAyB;QACzB,YAAO,GAAG,KAAK,CAAyB,EAAE,CAAC,CAAC;QAC5C,eAAe;QACf,SAAI,GAAG,KAAK,CAAM,EAAE,CAAC,CAAC;QAEtB,+DAA+D;QAC/D,iBAAY,GAAG,QAAQ,CAAiB,GAAG,EAAE,CAC3C,IAAI,CAAC,OAAO,EAAE;aACX,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC;aAC5B,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YACb,WAAW,EAAE,GAAG,CAAC,KAAe;YAChC,MAAM,EAAE,GAAG,CAAC,UAAU,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;YAC3C,IAAI,EAAE,GAAG,CAAC,KAAK;YACf,cAAc,EAAE,GAAG,CAAC,SAAS,IAAI,IAAI;YACrC,IAAI,EACF,GAAG,CAAC,UAAU;gBACd,CAAC,CAAC,OAAgC,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;SAC7D,CAAC,CAAC,CACN,CAAC;QAEF,2CAA2C;QACnC,kBAAa,GAAG,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC;YAChD,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE;YACjB,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE;YAC5B,eAAe,EAAE,eAAe,EAAE;SACnC,CAAC,CAAC,CAAC;KAML;IAJC,wCAAwC;IACxC,KAAK;QACH,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;+GA/BU,WAAW;mGAAX,WAAW,uUAvDZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDT,2DAvDS,YAAY,+BAAE,mBAAmB;;4FAyDhC,WAAW;kBA5DvB,SAAS;mBAAC;oBACT,QAAQ,EAAE,cAAc;oBACxB,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,YAAY,EAAE,mBAAmB,CAAC;oBAC5C,OAAO,EAAE,CAAC,sBAAsB,CAAC;oBACjC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDT;iBACF","sourcesContent":["/* eslint-disable jsdoc/require-jsdoc */\n/* eslint-disable jsdoc/require-returns */\n\nimport {\n  Component,\n  computed,\n  input,\n  TemplateRef,\n  CUSTOM_ELEMENTS_SCHEMA,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport {\n  createAngularTable,\n  getCoreRowModel,\n  FlexRenderDirective,\n  type FlexRenderComponent,\n  type ColumnDef,\n  type CellContext,\n} from './datatable.utils'; // local copy of @tanstack/angular-table (required for storybook, the built version is not working)\n\nexport type { CellContext as NvDatatableCellContext };\n\nexport { flexRenderComponent as nvDatatableRenderComponent } from './datatable.utils';\n\n/** Type definition for a datatable row. */\nexport type NvDatatableRow = Record<\n  string,\n  string | number | boolean | null | undefined | typeof Date\n>;\n\n/** Parameters for custom cell rendering function. */\nexport interface NvTableRenderCellParams<T extends NvDatatableRow, V> {\n  value: V;\n  row: T;\n  field: keyof T;\n  rowIndex: number;\n}\n\n/** Column definition for NvDatatable. */\nexport interface NvDatatableColumn<T extends NvDatatableRow> {\n  field: keyof T;\n  headerName?: string;\n  width?: number;\n  resizable?: boolean;\n  hidden?: boolean;\n  /**\n   * Custom cell renderer function that can return either a string or Angular TemplateRef.\n   * Use `$implicit` in your template to receive the CellContext.\n   */\n  renderCell?: (context: CellContext<T, unknown>) =>\n    | string\n    | FlexRenderComponent\n    | TemplateRef<{\n        $implicit: CellContext<T, unknown>;\n      }>;\n}\n\n/**\n * Nova Datatable built on TanStack Table (Angular).\n */\n@Component({\n  selector: 'nv-datatable',\n  standalone: true,\n  imports: [CommonModule, FlexRenderDirective],\n  schemas: [CUSTOM_ELEMENTS_SCHEMA],\n  template: `\n    <nv-table>\n      <table>\n        <thead>\n          @for (headerGroup of table().getHeaderGroups(); track headerGroup.id)\n          {\n          <tr>\n            @for (header of headerGroup.headers; track header.id) {\n            <th\n              [attr.data-testid]=\"'datatable-header-' + header.id\"\n              [style.width]=\"\n                header.column.columnDef.size\n                  ? header.column.columnDef.size + 'px'\n                  : null\n              \"\n              [attr.data-no-resize]=\"\n                !header.column.columnDef.enableResizing ? 'true' : null\n              \"\n            >\n              @if (!header.isPlaceholder) {\n              {{ header.column.columnDef.header }}\n              }\n            </th>\n            }\n          </tr>\n          }\n        </thead>\n\n        <tbody>\n          @for (row of table().getRowModel().rows; track row.id) {\n          <tr [attr.data-testid]=\"'datatable-row-' + row.id\">\n            @for (cell of row.getVisibleCells(); track cell.id) {\n            <td\n              [attr.data-testid]=\"'datatable-cell-' + cell.id\"\n              style=\"padding: 8px; border-bottom: 1px solid #eee;\"\n            >\n              <!-- Let FlexRender handle strings vs TemplateRef -->\n              <ng-container\n                *flexRender=\"\n                  cell.column.columnDef.cell;\n                  props: cell.getContext();\n                  let cellContent\n                \"\n              >\n                {{ cellContent }}\n              </ng-container>\n            </td>\n            }\n          </tr>\n          }\n        </tbody>\n      </table>\n    </nv-table>\n  `,\n})\nexport class NvDatatable<T extends NvDatatableRow = NvDatatableRow> {\n  /** Column definitions */\n  columns = input<NvDatatableColumn<T>[]>([]);\n  /** Row data */\n  rows = input<T[]>([]);\n\n  /** Computed table columns with proper typing and filtering. */\n  tableColumns = computed<ColumnDef<T>[]>(() =>\n    this.columns()\n      .filter((col) => !col.hidden)\n      .map((col) => ({\n        accessorKey: col.field as string,\n        header: col.headerName || String(col.field),\n        size: col.width,\n        enableResizing: col.resizable ?? true,\n        cell:\n          col.renderCell ??\n          ((context: CellContext<T, unknown>) => context.getValue()),\n      })),\n  );\n\n  /** TanStack table instance with Signals */\n  private tableInstance = createAngularTable(() => ({\n    data: this.rows(),\n    columns: this.tableColumns(),\n    getCoreRowModel: getCoreRowModel(),\n  }));\n\n  /** Public getter for table instance. */\n  table() {\n    return this.tableInstance();\n  }\n}\n"]}