@dereekb/dbx-web 12.6.21 → 13.0.0

package/table/lib/table.column.directive.d.ts

@@ -1,14 +0,0 @@
-import { DbxTableStore } from './table.store';
-import { type Maybe } from '@dereekb/util';
-import { DbxTableColumn } from './table';
-import * as i0 from "@angular/core";
-/**
- * Abstract directive that has a column input.
- */
-export declare class AbstractDbxTableColumnDirective<C> {
-    readonly tableStore: DbxTableStore<unknown, C, unknown, unknown>;
-    readonly column: import("@angular/core").InputSignal<Maybe<DbxTableColumn<C>>>;
-    readonly column$: import("rxjs").Observable<DbxTableColumn<C>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxTableColumnDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxTableColumnDirective<any>, never, never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
-}

package/table/lib/table.column.footer.component.d.ts

@@ -1,8 +0,0 @@
-import { AbstractDbxTableColumnDirective } from './table.column.directive';
-import * as i0 from "@angular/core";
-export declare class DbxTableColumnFooterComponent<C> extends AbstractDbxTableColumnDirective<C> {
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableColumnFooterComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableColumnFooterComponent<any>, "dbx-table-column-footer", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.column.header.component.d.ts

@@ -1,8 +0,0 @@
-import { AbstractDbxTableColumnDirective } from './table.column.directive';
-import * as i0 from "@angular/core";
-export declare class DbxTableColumnHeaderComponent<C> extends AbstractDbxTableColumnDirective<C> {
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableColumnHeaderComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableColumnHeaderComponent<any>, "dbx-table-column-header", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.column.size.d.ts

@@ -1,2 +0,0 @@
-import { type ElementRef, InjectionToken } from '@angular/core';
-export declare const DBX_TABLE_COLUMN_SIZE_PARENT_ELEMENT_REF_TOKEN: InjectionToken<ElementRef<HTMLElement>>;

package/table/lib/table.column.size.directive.d.ts

@@ -1,29 +0,0 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
-import * as i0 from "@angular/core";
-export type DbxColumnSizeColumnValue = 'head' | 'tail' | number;
-export declare class DbxTableColumnSizeDirective implements OnDestroy {
-    readonly elementRef: ElementRef<HTMLElement>;
-    readonly resized: import("@angular/core").Signal<import("@dereekb/dbx-web").ResizedEvent>;
-    private readonly _columnsMap;
-    readonly columns$: import("rxjs").Observable<Map<DbxColumnSizeColumnValue, DbxColumnSizeColumnDirective>>;
-    readonly columnsSignal: import("@angular/core").Signal<Map<DbxColumnSizeColumnValue, DbxColumnSizeColumnDirective> | undefined>;
-    readonly visibleColumnsSignal: import("@angular/core").Signal<number>;
-    addColumn(column: DbxColumnSizeColumnDirective): void;
-    removeColumn(column: DbxColumnSizeColumnDirective): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableColumnSizeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxTableColumnSizeDirective, "[dbx-table-column-size]", ["dbxTableColumnSize"], {}, {}, never, never, true, never>;
-}
-/**
- * References a specific element and the index of the column.
- */
-export declare class DbxColumnSizeColumnDirective implements OnInit, OnDestroy {
-    readonly dbxColumnSizeDirective: DbxTableColumnSizeDirective;
-    readonly elementRef: ElementRef<HTMLElement>;
-    readonly index: import("@angular/core").InputSignal<DbxColumnSizeColumnValue>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    get width(): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxColumnSizeColumnDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxColumnSizeColumnDirective, "[dbx-column-size-column]", never, { "index": { "alias": "dbx-column-size-column"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/table/lib/table.component.d.ts

@@ -1,59 +0,0 @@
-import { TrackByFunction, Signal } from '@angular/core';
-import { DbxTableStore } from './table.store';
-import { LoadingState } from '@dereekb/rxjs';
-import { Observable } from 'rxjs';
-import { MatTable } from '@angular/material/table';
-import { DbxTableItemGroup } from './table';
-import * as i0 from "@angular/core";
-export declare const DBX_TABLE_ITEMS_COLUMN_NAME = "_items";
-export declare const DBX_TABLE_ACTIONS_COLUMN_NAME = "_actions";
-export interface DbxTableViewGroupElement<T, G> {
-    readonly type: 'group';
-    readonly location: 'header' | 'footer';
-    readonly group: DbxTableItemGroup<T, G>;
-}
-export interface DbxTableViewItemElement<T, G> {
-    readonly type: 'item';
-    readonly item: T;
-}
-export type DbxTableViewElement<T, G> = DbxTableViewGroupElement<T, G> | DbxTableViewItemElement<T, G>;
-export declare function isDbxTableViewGroupElement<T, G>(element: DbxTableViewElement<T, G>): element is DbxTableViewGroupElement<T, G>;
-export declare function isDbxTableViewItemElement<T, G>(element: DbxTableViewElement<T, G>): element is DbxTableViewItemElement<T, G>;
-/**
- * A table with fixed content
- */
-export declare class DbxTableViewComponent<I, C, T, G = unknown> {
-    readonly tableStore: DbxTableStore<I, C, T, G>;
-    readonly table: Signal<MatTable<DbxTableViewElement<T, G>>>;
-    readonly DEFAULT_TRACK_BY_FUNCTION: TrackByFunction<any>;
-    readonly scrollDistance: import("@angular/core").InputSignal<number>;
-    readonly throttleScroll: import("@angular/core").InputSignal<number>;
-    readonly itemsColumnName = "_items";
-    readonly actionsColumnName = "_actions";
-    readonly innerColumns$: Observable<import("./table").DbxTableColumn<C>[]>;
-    readonly innerColumnNames$: Observable<string[]>;
-    readonly innerColumnsSignal: Signal<import("./table").DbxTableColumn<C>[] | undefined>;
-    readonly innerColumnNamesSignal: Signal<string[] | undefined>;
-    readonly elementsState$: Observable<LoadingState<DbxTableViewElement<T, G>[]>>;
-    readonly elements$: Observable<DbxTableViewElement<T, G>[]>;
-    readonly displayedColumns$: Observable<string[]>;
-    readonly displayedColumnsSignal: Signal<string[]>;
-    readonly trackByFunction$: Observable<TrackByFunction<T>>;
-    readonly inputTrackByFunctionSignal: Signal<TrackByFunction<any> | TrackByFunction<T>>;
-    readonly trackElementByFunctionSignal: Signal<TrackByFunction<DbxTableViewElement<T, G>>>;
-    readonly context: import("@dereekb/rxjs").MutableLoadingStateContext<unknown, LoadingState<import("./table").DbxTableContextData<I, C, T>>, import("@dereekb/rxjs").LoadingContextEvent & LoadingState<import("./table").DbxTableContextData<I, C, T>>>;
-    readonly dataLoadingContext: import("@dereekb/rxjs").MutableLoadingStateContext<unknown, LoadingState<DbxTableViewElement<T, G>[]>, import("@dereekb/rxjs").LoadingContextEvent & LoadingState<DbxTableViewElement<T, G>[]>>;
-    readonly contextSignal: Signal<LoadingState<import("./table").DbxTableContextData<I, C, T>> | undefined>;
-    readonly dataLoadingContextSignal: Signal<LoadingState<DbxTableViewElement<T, G>[]> | undefined>;
-    readonly viewDelegateSignal: Signal<import("./table").DbxTableViewDelegate<I, C, T, G> | undefined>;
-    readonly elementsSignal: Signal<DbxTableViewElement<T, G>[]>;
-    readonly tableCssClasses: Signal<string | undefined>;
-    onScrollDown(): void;
-    showItemRow(_: number, row: DbxTableViewElement<T, G>): boolean;
-    showGroupHeaderRow(_: number, row: DbxTableViewElement<T, G>): boolean;
-    showGroupFooterRow(_: number, row: DbxTableViewElement<T, G>): boolean;
-    readonly showFooterRowSignal: Signal<boolean | undefined>;
-    readonly showFullSummaryRowSignal: Signal<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableViewComponent<any, any, any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableViewComponent<any, any, any, any>, "dbx-table-view", never, { "scrollDistance": { "alias": "scrollDistance"; "required": false; "isSignal": true; }; "throttleScroll": { "alias": "throttleScroll"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/table/lib/table.d.ts

@@ -1,143 +0,0 @@
-import { type Observable } from 'rxjs';
-import { type LoadingState, type ObservableOrValue, type PageListLoadingState } from '@dereekb/rxjs';
-import { type CssClassesArray, type Maybe } from '@dereekb/util';
-import { type DbxInjectionComponentConfig } from '@dereekb/dbx-core';
-import { type TrackByFunction } from '@angular/core';
-/**
- * Delegate used for retrieving data for a table.
- */
-export interface DbxTableContextDataDelegate<I, C, T> {
-    /**
-     * Loads data given the input.
-     *
-     * @param input
-     */
-    loadData(input: I): Observable<LoadingState<DbxTableContextData<I, C, T>>>;
-}
-export interface DbxTableContextData<I, C, T> {
-    /**
-     * Original context input
-     */
-    readonly input: I;
-    /**
-     * All columns in this data context.
-     */
-    readonly columns: DbxTableColumn<C>[];
-    /**
-     * All currently loaded items.
-     */
-    readonly items$: Observable<PageListLoadingState<T>>;
-    /**
-     * Loads more items, if applicable.
-     */
-    loadMore?(): void;
-}
-export interface DbxTableColumn<C> {
-    /**
-     * Unique column name
-     */
-    readonly columnName: string;
-    /**
-     * Column metadata
-     */
-    readonly meta: C;
-}
-export declare const NO_GROUPS_ID = "none";
-/**
- * Unique identifier used for grouping items together.
- */
-export type DbxTableGroupId = string;
-export interface DbxTableItemGroup<T, G = unknown> {
-    readonly groupId: DbxTableGroupId;
-    readonly items: T[];
-    readonly meta: G;
-}
-export interface DefaultDbxTableItemGroup<T, G = unknown> extends DbxTableItemGroup<T, G> {
-    readonly groupId: typeof NO_GROUPS_ID;
-    readonly default: true;
-}
-export declare function defaultDbxTableItemGroup<T, G = unknown>(items: T[]): DefaultDbxTableItemGroup<T, G>;
-export type DbxTableGroupByFunction<T, G = unknown> = (items: T[]) => ObservableOrValue<DbxTableItemGroup<T, G>[]>;
-/**
- * Delegate used for generating view configurations given the input.
- */
-export interface DbxTableViewDelegate<I = unknown, C = unknown, T = unknown, G = unknown> {
-    /**
-     * Track by
-     */
-    readonly trackBy?: TrackByFunction<T>;
-    /**
-     * If provided, will group items together
-     */
-    readonly groupBy?: DbxTableGroupByFunction<T, G>;
-    /**
-     * Input picker view configuration
-     */
-    readonly inputHeader?: Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Action header view configuration
-     */
-    readonly actionHeader?: Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Full-width summary row view configuration.
-     */
-    readonly fullSummaryRow?: Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Summary row header view configuration.
-     */
-    readonly summaryRowHeader?: Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Summary row end view configuration
-     */
-    readonly summaryRowEnd?: Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Group row header view configuration for a specific group.
-     *
-     * If this function returns undefined, the group row will not be shown.
-     *
-     * @param group
-     */
-    groupHeader?(group: DbxTableItemGroup<T, G>): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Group row footer view configuration for a specific group.
-     *
-     * If this function returns undefined, the group row will not be shown.
-     *
-     * @param group
-     */
-    groupFooter?(group: DbxTableItemGroup<T, G>): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Column header view configuration for a specific column.
-     *
-     * @param item
-     */
-    columnHeader?(column: DbxTableColumn<C>): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Optional column footer view configuration for a specific column.
-     *
-     * @param item
-     */
-    columnFooter?(column: DbxTableColumn<C>): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Item header view (left-most column for an item row) configuration for a specific item.
-     *
-     * @param item
-     */
-    itemHeader(item: T): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Item cell view (middle columns for an item row) configuration for a specific item and column.
-     *
-     * @param item
-     */
-    itemCell(column: DbxTableColumn<C>, item: T): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Item action view (right-most column for an item row) configuration for a specific item.
-     *
-     * @param item
-     */
-    itemAction?(item: T): Maybe<DbxInjectionComponentConfig<any>>;
-    /**
-     * Optional classes to apply to the table.
-     */
-    tableClasses?: CssClassesArray;
-}

package/table/lib/table.directive.d.ts

@@ -1,16 +0,0 @@
-import { DbxTableStore } from './table.store';
-import { type Maybe } from '@dereekb/util';
-import { DbxTableContextDataDelegate, DbxTableViewDelegate } from './table';
-import * as i0 from "@angular/core";
-/**
- * Directive for providing and configuring a DbxTableStore
- */
-export declare class DbxTableDirective<I, C, T> {
-    readonly tableStore: DbxTableStore<I, C, T, unknown>;
-    readonly dbxTableInput: import("@angular/core").InputSignal<Maybe<I>>;
-    readonly dbxTableViewDelegate: import("@angular/core").InputSignal<Maybe<DbxTableViewDelegate<I, C, T, unknown>>>;
-    readonly dbxTableDataDelegate: import("@angular/core").InputSignal<Maybe<DbxTableContextDataDelegate<I, C, T>>>;
-    protected readonly _setOnTableStoreEffect: import("@angular/core").EffectRef;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableDirective<any, any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxTableDirective<any, any, any>, "[dbxTable]", never, { "dbxTableInput": { "alias": "dbxTableInput"; "required": false; "isSignal": true; }; "dbxTableViewDelegate": { "alias": "dbxTableViewDelegate"; "required": false; "isSignal": true; }; "dbxTableDataDelegate": { "alias": "dbxTableDataDelegate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/table/lib/table.fullsummaryrow.component.d.ts

@@ -1,12 +0,0 @@
-import { DbxTableStore } from './table.store';
-import * as i0 from "@angular/core";
-/**
- * A table header component used for injecting the input picker view.
- */
-export declare class DbxTableFullSummaryRowComponent {
-    readonly tableStore: DbxTableStore<any, any, any, any>;
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableFullSummaryRowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableFullSummaryRowComponent, "dbx-table-full-summary-row", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.group.directive.d.ts

@@ -1,14 +0,0 @@
-import { DbxTableStore } from './table.store';
-import { type Maybe } from '@dereekb/util';
-import { DbxTableItemGroup } from './table';
-import * as i0 from "@angular/core";
-/**
- * Abstract directive that has an element input.
- */
-export declare abstract class AbstractDbxTableGroupDirective<T, C = unknown, G = unknown> {
-    readonly tableStore: DbxTableStore<unknown, C, T, G>;
-    readonly group: import("@angular/core").InputSignal<Maybe<DbxTableItemGroup<T, G>>>;
-    readonly group$: import("rxjs").Observable<DbxTableItemGroup<T, G>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxTableGroupDirective<any, any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxTableGroupDirective<any, any, any>, never, never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
-}

package/table/lib/table.group.footer.component.d.ts

@@ -1,9 +0,0 @@
-import { DbxInjectionComponentConfig } from '@dereekb/dbx-core';
-import { AbstractDbxTableGroupDirective } from './table.group.directive';
-import * as i0 from "@angular/core";
-export declare class DbxTableGroupFooterComponent<T> extends AbstractDbxTableGroupDirective<T> {
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<DbxInjectionComponentConfig<unknown>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<DbxInjectionComponentConfig<unknown>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableGroupFooterComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableGroupFooterComponent<any>, "dbx-table-group-footer", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.group.header.component.d.ts

@@ -1,9 +0,0 @@
-import { DbxInjectionComponentConfig } from '@dereekb/dbx-core';
-import { AbstractDbxTableGroupDirective } from './table.group.directive';
-import * as i0 from "@angular/core";
-export declare class DbxTableGroupHeaderComponent<T> extends AbstractDbxTableGroupDirective<T> {
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<DbxInjectionComponentConfig<unknown>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<DbxInjectionComponentConfig<unknown>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableGroupHeaderComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableGroupHeaderComponent<any>, "dbx-table-group-header", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.item.action.component.d.ts

@@ -1,9 +0,0 @@
-import { AbstractDbxTableItemDirective } from './table.item.directive';
-import { DbxInjectionComponentConfig } from '@dereekb/dbx-core';
-import * as i0 from "@angular/core";
-export declare class DbxTableItemActionComponent<T> extends AbstractDbxTableItemDirective<T> {
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<DbxInjectionComponentConfig<unknown>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<DbxInjectionComponentConfig<unknown>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableItemActionComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableItemActionComponent<any>, "dbx-table-item-action", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.item.cell.component.d.ts

@@ -1,12 +0,0 @@
-import { type Maybe } from '@dereekb/util';
-import { AbstractDbxTableItemDirective } from './table.item.directive';
-import { DbxTableColumn } from './table';
-import * as i0 from "@angular/core";
-export declare class DbxTableItemCellComponent<T, C> extends AbstractDbxTableItemDirective<T, C> {
-    readonly column: import("@angular/core").InputSignal<Maybe<DbxTableColumn<C>>>;
-    readonly column$: import("rxjs").Observable<Maybe<DbxTableColumn<C>>>;
-    readonly config$: import("rxjs").Observable<Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    readonly configSignal: import("@angular/core").Signal<Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableItemCellComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableItemCellComponent<any, any>, "dbx-table-item-cell", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/table/lib/table.item.directive.d.ts

@@ -1,13 +0,0 @@
-import { DbxTableStore } from './table.store';
-import { type Maybe } from '@dereekb/util';
-import * as i0 from "@angular/core";
-/**
- * Abstract directive that has an element input.
- */
-export declare abstract class AbstractDbxTableItemDirective<T, C = unknown> {
-    readonly tableStore: DbxTableStore<unknown, C, T, unknown>;
-    readonly item: import("@angular/core").InputSignal<Maybe<T>>;
-    readonly item$: import("rxjs").Observable<Maybe<T>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxTableItemDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxTableItemDirective<any, any>, never, never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
-}

package/table/lib/table.item.header.component.d.ts

@@ -1,8 +0,0 @@
-import { AbstractDbxTableItemDirective } from './table.item.directive';
-import * as i0 from "@angular/core";
-export declare class DbxTableItemHeaderComponent<T> extends AbstractDbxTableItemDirective<T> {
-    readonly config$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    readonly configSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<import("@dereekb/dbx-core").DbxInjectionComponentConfig<any>>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableItemHeaderComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableItemHeaderComponent<any>, "dbx-table-item-header", never, {}, {}, never, never, true, never>;
-}

package/table/lib/table.module.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./table.directive";
-import * as i2 from "./table.component";
-export declare class DbxTableModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxTableModule, never, [typeof i1.DbxTableDirective, typeof i2.DbxTableViewComponent], [typeof i1.DbxTableDirective, typeof i2.DbxTableViewComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DbxTableModule>;
-}

package/table/lib/table.reader.d.ts

@@ -1,102 +0,0 @@
-import { type Observable } from 'rxjs';
-import { type PrimativeKey, type Maybe, type ReadRequiredKeyFunction } from '@dereekb/util';
-import { type DbxTableColumn } from './table';
-import { type DbxTableStore } from './table.store';
-export interface DbxTableReaderCellPair<C, T> {
-    readonly column: DbxTableColumn<C>;
-    readonly item: T;
-}
-export interface DbxTableReaderCellDataPair<C, T, O> extends DbxTableReaderCellPair<C, T> {
-    readonly value: O;
-}
-/**
- * Key used for tracking columns.
- *
- * Generally the table name is used for this.
- */
-export type DbxTableReaderColumnKey = string;
-/**
- * Key used for tracking items.
- *
- * Generally the item's unique identifier is used for this.
- */
-export type DbxTableReaderItemKey = PrimativeKey;
-/**
- * Default track by function for DbxTableColumn.
- *
- * Returns the column name.
- *
- * @param column
- * @returns
- */
-export declare const DEFAULT_DBX_TABLE_READER_COLUMN_TRACK_BY: ReadRequiredKeyFunction<DbxTableColumn<DbxTableReaderColumnKey>>;
-/**
- * Function used for tracking unique columns using the column's data.
- *
- * If the column key value is the same between those two columns, then the metadata of both columns will be considered the same/equal.
- */
-export type DbxTableReaderColumnTrackByFunction<C> = ReadRequiredKeyFunction<DbxTableColumn<C>, DbxTableReaderColumnKey>;
-/**
- * Function used for tracking unique columns using the column's data.
- *
- * If the column key value is the same between those two columns, then the metadata of both columns will be considered the same/equal.
- */
-export type DbxTableReaderItemTrackByFunction<T> = ReadRequiredKeyFunction<T, DbxTableReaderItemKey>;
-export interface DbxTableReaderDelegate<C, T, O> {
-    /**
-     * Retrieves the data for a specific column and item/row.
-     *
-     * @param column
-     * @param item
-     */
-    readItemCellDataForColumn(column: DbxTableColumn<C>, item: T): Observable<O>;
-    /**
-     * Used for tracking unique columns.
-     *
-     * Use if the metadata between columns should be used for unique identification.
-     *
-     * Defaults to using the column name as the key if not defined.
-     */
-    trackColumn?: DbxTableReaderColumnTrackByFunction<C>;
-    /**
-     * Used for tracking unique items/rows.
-     *
-     * Use if the metadata between items should be used for unique identification.
-     *
-     * Defaults to using the item itself as the key if not defined.
-     */
-    trackItem: DbxTableReaderItemTrackByFunction<T>;
-}
-export interface DbxTableReaderConfig<C, T, O, G = any> {
-    /**
-     * Delegate used for retrieving the data for a specific column and item/row.
-     */
-    readonly delegate: DbxTableReaderDelegate<C, T, O>;
-    /**
-     * The table store used for retrieving the items.
-     */
-    readonly tableStore: DbxTableStore<any, C, T, G>;
-}
-export interface DbxTableReader<C, T, O, G = any> extends DbxTableReaderConfig<C, T, O, G> {
-    /**
-     * Retrieves all cell data pairs for a specific column.
-     */
-    cellDataPairsForColumn(column: DbxTableColumn<C>): Observable<DbxTableReaderCellDataPair<C, T, O>[]>;
-    /**
-     * Retrieves all cell data for a specific column.
-     */
-    cellDataForColumn(column: DbxTableColumn<C>): Observable<O[]>;
-    /**
-     * Retrieves the cell data pair for a specific column and item.
-     *
-     * Returns null if the column is not visible or the item is not found.
-     */
-    cellDataPairForColumnAndItem(column: DbxTableColumn<C>, item: T): Observable<Maybe<DbxTableReaderCellDataPair<C, T, O>>>;
-    /**
-     * Retrieves the cell data for a specific column and item.
-     *
-     * Returns null if the column is not visible or the item is not found.
-     */
-    cellDataForColumnAndItem(column: DbxTableColumn<C>, item: T): Observable<Maybe<O>>;
-}
-export declare function dbxTableReader<C, T, O, G = any>(config: DbxTableReaderConfig<C, T, O, G>): DbxTableReader<C, T, O, G>;

package/table/lib/table.store.d.ts

@@ -1,42 +0,0 @@
-import { LoadingState, PageListLoadingState } from '@dereekb/rxjs';
-import { type Maybe } from '@dereekb/util';
-import { ComponentStore } from '@ngrx/component-store';
-import { Observable } from 'rxjs';
-import { DbxTableColumn, DbxTableContextData, DbxTableContextDataDelegate, DbxTableItemGroup, DbxTableViewDelegate } from './table';
-import * as i0 from "@angular/core";
-export interface DbxTableStoreState<I, C, T, G> {
-    /**
-     * Contextual input that is passed to the data delegate.
-     */
-    readonly input: Maybe<I>;
-    /**
-     * Delegate used for retrieving info given the selection.
-     */
-    readonly dataDelegate: Maybe<DbxTableContextDataDelegate<I, C, T>>;
-    /**
-     * Delegate used for retrieving view configurations.
-     */
-    readonly viewDelegate: Maybe<DbxTableViewDelegate<I, C, T, G>>;
-}
-export declare class DbxTableStore<I = unknown, C = unknown, T = unknown, G = unknown> extends ComponentStore<DbxTableStoreState<I, C, T, G>> {
-    constructor();
-    readonly loadMore: (observableOrValue?: void | Observable<void> | undefined) => import("rxjs").Subscription;
-    readonly input$: Observable<Maybe<I>>;
-    readonly dataDelegate$: Observable<Maybe<DbxTableContextDataDelegate<I, C, T>>>;
-    readonly currentViewDelegate$: Observable<Maybe<DbxTableViewDelegate<I, C, T, G>>>;
-    readonly viewDelegate$: Observable<DbxTableViewDelegate<I, C, T, G>>;
-    readonly tableCssClasses$: Observable<import("@dereekb/util").CssClassesArray | undefined>;
-    readonly spaceSeparatedTableCssClasses$: Observable<string>;
-    readonly dataState$: Observable<LoadingState<DbxTableContextData<I, C, T>>>;
-    readonly data$: Observable<DbxTableContextData<I, C, T>>;
-    readonly columns$: Observable<DbxTableColumn<C>[]>;
-    readonly itemsState$: Observable<PageListLoadingState<T>>;
-    readonly items$: Observable<T[]>;
-    readonly groupsState$: Observable<LoadingState<DbxTableItemGroup<T, G>[]>>;
-    readonly groups$: Observable<DbxTableItemGroup<T, G>[]>;
-    readonly setInput: (() => void) | ((observableOrValue: Maybe<I> | Observable<Maybe<I>>) => import("rxjs").Subscription) | (I extends void ? () => void : (observableOrValue: Maybe<I> | Observable<Maybe<I>>) => import("rxjs").Subscription);
-    readonly setDataDelegate: (() => void) | ((observableOrValue: Maybe<DbxTableContextDataDelegate<I, C, T>> | Observable<Maybe<DbxTableContextDataDelegate<I, C, T>>>) => import("rxjs").Subscription);
-    readonly setViewDelegate: (() => void) | ((observableOrValue: Maybe<DbxTableViewDelegate<I, C, T, G>> | Observable<Maybe<DbxTableViewDelegate<I, C, T, G>>>) => import("rxjs").Subscription);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableStore<any, any, any, any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DbxTableStore<any, any, any, any>>;
-}