@oscarpalmer/tabela 0.8.0 → 0.10.0

package/types/managers/filter.manager.d.ts

@@ -0,0 +1,19 @@
+import type { FilterItem } from '../models/filter.model';
+import type { TabelaManagers } from '../models/tabela.model';
+export declare class FilterManager {
+    readonly managers: TabelaManagers;
+    handlers: Readonly<{
+        add: (item: FilterItem) => void;
+        clear: () => void;
+        remove: (value: string | FilterItem) => void;
+        set: (items: FilterItem[]) => void;
+    }>;
+    items: Record<string, FilterItem[]>;
+    constructor(managers: TabelaManagers);
+    add(item: FilterItem): void;
+    clear(): void;
+    destroy(): void;
+    filter(): void;
+    remove(value: string | FilterItem): void;
+    set(items: FilterItem[]): void;
+}

package/types/managers/{virtualization.manager.d.ts → render.manager.d.ts}

@@ -1,15 +1,15 @@
+import type { Key } from '@oscarpalmer/atoms/models';
 import type { RemovableEventListener } from '@oscarpalmer/toretto/models';
-import { RowComponent } from '../components/row.component';
+import type { RenderElementPool, RenderState } from '../models/render.model';
 import type { TabelaComponents, TabelaManagers } from '../models/tabela.model';
-import type { VirtualizationPool, VirtualizationState } from '../models/virtualization.model';
-export declare class VirtualizationManager {
+export declare class RenderManager {
     managers: TabelaManagers;
     components: TabelaComponents;
     fragment: DocumentFragment;
     listener: RemovableEventListener;
-    readonly pool: VirtualizationPool;
-    readonly state: VirtualizationState;
-    readonly visible: Map<number, RowComponent>;
+    readonly pool: RenderElementPool;
+    readonly state: RenderState;
+    visible: Map<number, Key>;
     constructor(managers: TabelaManagers, components: TabelaComponents);
     destroy(): void;
     removeCells(fields: string[]): void;

package/types/managers/selection.manager.d.ts

@@ -0,0 +1,19 @@
+import type { Key } from '@oscarpalmer/atoms/models';
+import type { TabelaManagers, TabelaSelection } from '../models/tabela.model';
+export declare class SelectionManager {
+    element: HTMLElement;
+    readonly managers: TabelaManagers;
+    handlers: Readonly<TabelaSelection>;
+    items: Set<Key>;
+    last: Key | undefined;
+    constructor(element: HTMLElement, managers: TabelaManagers);
+    clear(): void;
+    deselect(keys: Key[]): void;
+    destroy(): void;
+    handle(event: MouseEvent, target: HTMLElement): void;
+    range(from: Key | HTMLElement, to: Key | HTMLElement): void;
+    select(keys: Key[]): void;
+    set(keys: Key[]): void;
+    toggle(): void;
+    update(removed: Key[]): void;
+}

package/types/managers/sort.manager.d.ts

@@ -1,19 +1,22 @@
+import { type ArrayKeySorter } from '@oscarpalmer/atoms/array';
+import type { PlainObject } from '@oscarpalmer/atoms/models';
 import type { SortDirection, SortItem } from '../models/sort.model';
 import type { TabelaManagers } from '../models/tabela.model';
 export declare class SortManager {
     readonly managers: TabelaManagers;
-    readonly handlers: Readonly<{
+    handlers: Readonly<{
         add: (field: string, direction: SortDirection | undefined) => void;
         flip: (field: string) => void;
         clear: () => void;
         remove: (field: string) => void;
         set: (items: SortItem[]) => void;
     }>;
-    readonly items: SortItem[];
+    readonly items: ArrayKeySorter<PlainObject>[];
     constructor(managers: TabelaManagers);
     add(field: string, direction?: SortDirection): void;
     addOrSet(event: MouseEvent, field: string): void;
     clear(): void;
+    destroy(): void;
     flip(field: string): void;
     remove(field: string): void;
     removeOrClear(event: MouseEvent, field: string): void;

package/types/models/filter.model.d.ts

@@ -0,0 +1,6 @@
+export type FilterComparison = 'contains' | 'ends-with' | 'equals' | 'greater-than' | 'greater-than-or-equal' | 'less-than' | 'less-than-or-equal' | 'not-contains' | 'not-equals' | 'starts-with';
+export type FilterItem = {
+    comparison: FilterComparison;
+    field: string;
+    value: unknown;
+};

package/types/models/{virtualization.model.d.ts → render.model.d.ts}

@@ -1,12 +1,12 @@
-export type VirtualizationPool = {
+export type RenderElementPool = {
     cells: Record<string, HTMLDivElement[]>;
     rows: HTMLDivElement[];
 };
-export type VirtualizationRange = {
+export type RenderRange = {
     end: number;
     start: number;
 };
-export type VirtualizationState = {
+export type RenderState = {
     active: boolean;
     top: number;
 };

package/types/models/sort.model.d.ts

@@ -1,5 +1,5 @@
 export type SortDirection = 'ascending' | 'descending';
 export type SortItem = {
     direction: SortDirection;
-    key: string;
+    field: string;
 };

package/types/models/tabela.model.d.ts

@@ -5,9 +5,12 @@ import type { HeaderComponent } from '../components/header.component';
 import type { ColumnManager } from '../managers/column.manager';
 import type { DataManager } from '../managers/data.manager';
 import type { EventManager } from '../managers/event.manager';
+import type { FilterManager } from '../managers/filter.manager';
+import type { RenderManager } from '../managers/render.manager';
 import type { RowManager } from '../managers/row.manager';
+import type { SelectionManager } from '../managers/selection.manager';
 import type { SortManager } from '../managers/sort.manager';
-import type { VirtualizationManager } from '../managers/virtualization.manager';
+import type { FilterItem } from './filter.model';
 import type { SortDirection, SortItem } from './sort.model';
 export type TabelaComponents = {
     body: BodyComponent;
@@ -23,13 +26,28 @@ export type TabelaData = {
     synchronize(data: PlainObject[], remove?: boolean): void;
     update(data: PlainObject[]): void;
 };
+export type TabelaFilter = {
+    add(item: FilterItem): void;
+    clear(): void;
+    remove(field: string): void;
+    remove(item: FilterItem): void;
+    set(items: FilterItem[]): void;
+};
 export type TabelaManagers = {
     column: ColumnManager;
     data: DataManager;
     event: EventManager;
+    filter: FilterManager;
     row: RowManager;
+    selection: SelectionManager;
     sort: SortManager;
-    virtualization: VirtualizationManager;
+    render: RenderManager;
+};
+export type TabelaSelection = {
+    clear(): void;
+    deselect(keys: Key[]): void;
+    select(keys: Key[]): void;
+    toggle(): void;
 };
 export type TabelaSort = {
     add(field: string, direction?: SortDirection): void;

package/types/tabela.d.ts

@@ -1,8 +1,10 @@
-import type { TabelaData, TabelaSort } from './models/tabela.model';
+import type { TabelaData, TabelaFilter, TabelaSelection, TabelaSort } from './models/tabela.model';
 import type { TabelaOptions } from './models/tabela.options';
 export declare class Tabela {
     #private;
     readonly data: TabelaData;
+    readonly filter: TabelaFilter;
+    readonly selection: TabelaSelection;
     readonly sort: TabelaSort;
     get key(): string;
     constructor(element: HTMLElement, options: TabelaOptions);