@one-grid-core/angular 0.1.0-beta.6 → 0.2.0

package/lib/core/models/one-grid-types.model.d.ts

@@ -1,7 +1,42 @@
+import type { Type } from "@angular/core";
 import type { OneGridApi } from "../instants/one-grid-api.class";
 import type { OneRowNode } from "../instants/one-row-node.class";
-import type { OneColumnDef } from "./one-column-def-types.model";
+import type { OneColumnDef, OneGroupColumnDef } from "./one-column-def-types.model";
+import type { RowSelectionMode } from "./one-event-types.model";
+import type { OneDetailCellRendererParams } from "./one-master-detail.model";
+import type { OneCellRendererComponent } from "./one-tree-data.model";
 export type OneGridType = 'simple' | 'master' | 'detail' | 'tree' | null;
+/**
+ * Everything `OneGridApi.init` needs to stand a grid up.
+ *
+ * An options object rather than a positional list: the previous signature took
+ * ten positional arguments, four of them optional and two of them booleans, so
+ * a call site was unreadable and adding an option meant touching every caller.
+ *
+ * `OneGridComponent` calls this from `ngOnInit`. Applications should not.
+ */
+export interface OneGridInitOptions<T = any> {
+    /** Which role this instance plays. `OneGridComponent` derives it from its inputs. */
+    gridType: OneGridType;
+    /** Column definitions, before `defaultColumnDef` is merged in. */
+    columnDefs: OneColumnDef<T>[];
+    /** Merged into every column definition. */
+    defaultColumnDef?: OneColumnDef<T>;
+    /** Header groups. Columns join one by `groupId`. */
+    groupColumnDefs?: OneGroupColumnDef[];
+    /** Passed to renderers, getters and predicates; `componentParent.getRowId` is read from it. */
+    context?: any;
+    /** `null` disables row selection entirely. Read once, here. */
+    rowSelection?: RowSelectionMode;
+    /** Turns on the nested detail grid. Mutually exclusive with `treeData`. */
+    masterDetail?: boolean;
+    /** Detail grid options plus `getDetailRowData`. Required when `masterDetail` is on. */
+    detailCellRendererParams?: OneDetailCellRendererParams;
+    /** Render a component in the detail area instead of a nested grid. */
+    detailRendererComponent?: Type<OneCellRendererComponent>;
+    /** Turns on hierarchical row building. Mutually exclusive with `masterDetail`. */
+    treeData?: boolean;
+}
 export interface OneGridReadyEvent<T = any> {
     api: OneGridApi<T>;
 }

package/lib/core/models/one-row-drag.model.d.ts

@@ -0,0 +1,44 @@
+import { OneRowNode } from '../instants/one-row-node.class';
+/**
+ * Why row reordering is unavailable right now.
+ *
+ * Reordering only means something when the order you see is the order the data
+ * is in. Each of these breaks that, so the handle is disabled rather than
+ * silently dropping the move:
+ *
+ * - `sorted`   — the displayed order is derived from the sort model, and the
+ *                next sort pass rebuilds it from scratch. A manual move would
+ *                be discarded the moment anything re-sorted.
+ * - `filtered` — rows are hidden between the ones you can see, so "drop below
+ *                this row" has no single answer.
+ * - `treeData` — moving a node between parents is a reparent, not a reorder.
+ *                Not supported yet; see the docs.
+ */
+export type OneRowDragSuppressedReason = 'sorted' | 'filtered' | 'treeData';
+/** Where a drag would land, and where it started. */
+export interface OneRowDragEvent<T = any> {
+    /** The row being moved. */
+    node: OneRowNode<T>;
+    /** Index it started at, in the grid's row order. */
+    fromIndex: number;
+    /** Index it would land at once removed from `fromIndex` and reinserted. */
+    toIndex: number;
+    /** How the move was driven. Keyboard moves are one step at a time. */
+    source: 'pointer' | 'keyboard';
+}
+/**
+ * The live state of a drag, published by the row-drag service so the body can
+ * render the handle and the drop indicator. `null` when no drag is in flight.
+ */
+export interface OneRowDragState {
+    rowId: string;
+    fromIndex: number;
+    /**
+     * Insertion boundary, in row units: 0 is above the first row, `n` is below
+     * the last. This is a gap index, not a row index — the drop indicator is
+     * drawn at `insertAt * itemSize`, and the resulting row index differs by
+     * one depending on the direction of travel.
+     */
+    insertAt: number;
+    source: 'pointer' | 'keyboard';
+}

package/lib/core/models/one-row.model.d.ts

@@ -29,10 +29,5 @@ export interface OneRowNodeEventMap<T> {
         node: OneRowNode<T>;
         expanded: boolean;
     };
-    childrenChanged: {
-        node: OneRowNode<T>;
-        children: OneRowNode<T>[];
-        source: 'masterDetail' | 'treeData';
-    };
 }
 export type OneRowNodeListener<T, K extends keyof OneRowNodeEventMap<T>> = (event: OneRowNodeEventMap<T>[K]) => void;

package/lib/core/models/one-tree-data.model.d.ts

@@ -4,6 +4,19 @@ export type TreeNode<T> = {
     children?: TreeNode<T>[];
 } & T;
 export interface OneCellRendererComponent {
+    /**
+     * Called when the cell is created and again whenever its params change.
+     *
+     * The params stay loosely typed here, unlike `cellRenderer`'s: the same
+     * directive also mounts a master/detail row's custom detail renderer, and a
+     * detail row has no column — so `field` and `columnDef` genuinely cannot be
+     * promised. For a cell renderer they are always supplied.
+     *
+     * A component that does not implement this gets the params assigned onto its
+     * own fields instead, so a renderer with plain public properties works too —
+     * but not both: the fallback only applies when `oneInit` is absent.
+     */
     oneInit(params: OneCellRendererParams): void;
+    /** Part of the interface, but the renderer directive never calls it. */
     refresh(params: OneCellRendererParams): boolean;
 }

package/lib/core/models/one-validation.model.d.ts

@@ -1,7 +1,17 @@
-export interface OneValidationResult<T> {
+/**
+ * Validation errors for a single row, keyed by column field.
+ *
+ * A field is absent when it passed, which is why the values are optional —
+ * `errors[field]` is `string | undefined`, not `string`. Keying on
+ * `keyof T & string` matches `OneColumnDef<T>.field`, so a typo in a field name
+ * is a compile error rather than a lookup that silently returns undefined.
+ */
+export type OneRowValidationErrors<T = any> = Partial<Record<keyof T & string, string>>;
+export interface OneValidationResult<T = any> {
     valid: boolean;
     invalid: boolean;
-    errors: Record<string, string>[];
+    /** One entry per row, in the order the rows were given. */
+    errors: OneRowValidationErrors<T>[];
 }
 export type OneValidatorFn<T = any> = (value: any, row?: T) => string | null;
 export type OneValidationRules<T = any> = {

package/lib/core/pipes/column-sort-state.pipe.d.ts

@@ -2,7 +2,7 @@ import { PipeTransform } from '@angular/core';
 import { OneSortModel } from '../models/one-grid-types.model';
 import * as i0 from "@angular/core";
 export declare class ColumnSortStatePipe implements PipeTransform {
-    transform(field: string, sortModel: OneSortModel[]): 'asc' | 'desc' | null;
+    transform(field: string, sortModel: readonly OneSortModel[]): 'asc' | 'desc' | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<ColumnSortStatePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<ColumnSortStatePipe, "columnSortState", false>;
 }

package/lib/core/services/og-column.service.d.ts

@@ -1,14 +1,33 @@
-import { OneCellRendererParams, OneColumnDef, OneGroupColumnDef } from '../models/one-column-def-types.model';
+import { OneCellPresentationParams, OneCellRendererParams, OneColumnDef, OneGroupColumnDef } from '../models/one-column-def-types.model';
 import { ColumnChangedEvent } from '../models/one-event-types.model';
 import * as i0 from "@angular/core";
 export declare class OgColumnService {
     private defaultColumnDef;
+    /**
+     * The grid's `context`, so header callbacks receive the same one cell
+     * callbacks do. Set during init; null in a bare service.
+     */
+    private context;
     private columnDefs$;
     private groupColumnDefs$;
-    initColumnDefs(defaultColumnDef: OneColumnDef, columnDefs: OneColumnDef[], groupColumnDefs: OneGroupColumnDef[]): void;
+    initColumnDefs(defaultColumnDef: OneColumnDef, columnDefs: OneColumnDef[], groupColumnDefs: OneGroupColumnDef[], context?: unknown): void;
     getColumnState(): ColumnChangedEvent;
     setGroupColumnDefs(groupColumnDefs: OneGroupColumnDef[]): void;
     setColumnDefs(columnDefs: OneColumnDef[]): void;
+    /**
+     * Move pinned columns to their edge and measure how far in each one sits.
+     *
+     * Display order becomes left-pinned, unpinned, right-pinned, with declared
+     * order preserved inside each band. `_pinnedOffset` is the distance from that
+     * column's own edge — the sum of the widths of the pinned columns outside it
+     * — which is what the sticky `left` / `right` binding needs.
+     *
+     * With nothing pinned this returns the same array, in the same order, so a
+     * grid that does not use the feature is unaffected.
+     */
+    private applyPinning;
+    /** Total width of the columns frozen against the given edge. */
+    getPinnedWidth(side: 'left' | 'right'): number;
     updateColumnDef(id: string, changes: Partial<OneColumnDef>): void;
     reorderColumnDefs(fromIndex: number, toIndex: number): void;
     /**
@@ -16,7 +35,29 @@ export declare class OgColumnService {
      */
     private recalculateGroups;
     resolveGroupPresentation(col: OneGroupColumnDef, params?: OneCellRendererParams): OneGroupColumnDef;
-    resolveCellPresentation(col: OneColumnDef, params?: OneCellRendererParams): OneColumnDef;
+    /**
+     * Resolve a column's header presentation. Once per column, when the columns
+     * are set — a header is one cell for the whole column, so there is no row to
+     * resolve it against and nothing to redo per render.
+     *
+     * This used to resolve the cell hooks too, from the same call, with no params
+     * at all. Two bugs came out of that: any callback touching `params` threw a
+     * TypeError at init, and the header's resolved value was then overwritten by
+     * every cell that rendered, since the body re-ran the same method per cell
+     * with row params. In dev mode the disagreement surfaced as NG0100.
+     */
+    resolveHeaderPresentation(col: OneColumnDef): OneColumnDef;
+    /**
+     * Resolve one cell's class, for one row.
+     *
+     * Pure: the result is returned rather than written back onto the column def,
+     * which every row of that column shares. Writing to it worked only because
+     * the template resolved and read in the same expression — one render order
+     * away from every row showing the last row's class.
+     */
+    resolveCellClass(col: OneColumnDef, params: OneCellPresentationParams): string | string[] | undefined;
+    /** Resolve one cell's inline style, for one row. Pure, as above. */
+    resolveCellStyle(col: OneColumnDef, params: OneCellPresentationParams): Record<string, string> | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<OgColumnService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OgColumnService>;
 }

package/lib/core/services/one-grid-cell.service.d.ts

@@ -1,5 +1,6 @@
-import { OneCellState, OneCellStates, OneColumnDef } from '../models/one-column-def-types.model';
+import { OneCellPresentationParams, OneCellState, OneCellStates, OneColumnDef } from '../models/one-column-def-types.model';
 import { OneRowNode } from '../instants/one-row-node.class';
+import type { OneGridApi } from '../instants/one-grid-api.class';
 import * as i0 from "@angular/core";
 export declare class OneGridCellService {
     private _cellFieldValueEmpty;
@@ -7,22 +8,69 @@ export declare class OneGridCellService {
     private _cellFieldValue;
     private _columnDefs;
     private _context;
+    private _api;
     applyColumnDefs(columnDefs: OneColumnDef[], context: any): void;
+    /**
+     * Back-reference to the grid api, so predicate params can carry it.
+     *
+     * Pushed in rather than injected: `OneGridApi` already depends on this
+     * service, and injecting it back would close a DI cycle.
+     */
+    setGridApi(api: OneGridApi | null): void;
+    /**
+     * The params every row-scoped column callback receives.
+     *
+     * One builder, deliberately: `editable`, `updatable`, `disable`, `rowDrag`,
+     * `hideActionButton`, `cellClass`, `cellStyle`, `cellRenderer` and
+     * `valueFormatter` are all "decide something about this cell", and a consumer
+     * should not have to remember which of them happens to be handed `value` or
+     * `field`. Each used to be called with a slightly different subset.
+     */
+    cellParams(column: OneColumnDef, node: OneRowNode): OneCellPresentationParams;
     /**
      * Generate New Node States
      */
     generateCellStates(node: OneRowNode): OneCellStates | null;
+    /**
+     * The cell's value: the `valueGetter`'s output where the column declares one,
+     * the raw field otherwise. This is the value, not the display text — see
+     * {@link formatValue}.
+     */
+    private resolveValue;
+    /**
+     * Apply the column's `valueFormatter`.
+     *
+     * `valueFormatter` was declared on the column definition and called from
+     * nowhere — a consumer could write one, get no error, and see nothing happen.
+     * It runs on displayed text only, after the `valueGetter`, and is deliberately
+     * skipped for placeholders: an empty cell already has its own mechanism in
+     * `cellRendererParams.placeholder`, and two features competing to fill the
+     * same gap is worse than one.
+     *
+     * Note that sorting and filtering read the underlying row data, not this —
+     * which is exactly why formatting belongs here rather than in the getter.
+     */
+    private formatValue;
     /**
      * Generate New Node State Based on Column Field
      */
     generateCellState(node: OneRowNode, column: OneColumnDef): OneCellState;
+    /** Whether this cell may be edited at all. A capability: unset means no. */
+    editableFn: (column: OneColumnDef, node: OneRowNode) => boolean;
     /**
-     * One Column Def Params Resolver
+     * The second edit gate, ANDed with `editable`.
+     *
+     * A restriction, so unset means "no restriction". It used to resolve through
+     * `!!undefined` to `false`, closing the gate on every column that did not name
+     * it — so `editable: true` on its own made nothing editable.
      */
-    editableFn: (column: OneColumnDef, node: OneRowNode) => boolean;
     updatableFn: (column: OneColumnDef, node: OneRowNode) => boolean;
+    /** Disables this column's row action buttons. Not an edit gate. */
     disableFn: (column: OneColumnDef, node: OneRowNode) => boolean;
-    dragableFn: (column: OneColumnDef, node: OneRowNode) => boolean;
+    /** Hides this column's row action buttons entirely. */
+    hideActionButtonFn: (column: OneColumnDef, node: OneRowNode) => boolean;
+    /** Whether this cell carries a row drag handle. */
+    rowDragFn: (column: OneColumnDef, node: OneRowNode) => boolean;
     valueGetterFn: (column: OneColumnDef, node: OneRowNode) => any;
     static ɵfac: i0.ɵɵFactoryDeclaration<OneGridCellService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OneGridCellService>;

package/lib/core/services/one-grid-row-drag.service.d.ts

@@ -0,0 +1,113 @@
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { OneRowDragEvent, OneRowDragState } from '../models/one-row-drag.model';
+import { OneRowNode } from '../instants/one-row-node.class';
+import * as i0 from "@angular/core";
+/** What the body has to lend the service to run a drag. */
+export interface OneRowDragContext<T = any> {
+    /** The scrolling element the rows live in. */
+    viewport: HTMLElement;
+    /** Fixed row height. The whole index calculation rests on rows being uniform. */
+    itemSize: number;
+    /** Current display order. Read fresh on every move — a drag mutates it. */
+    nodes: () => OneRowNode<T>[];
+    /** Apply the move. Returns false if the grid refused it. */
+    move: (fromIndex: number, toIndex: number) => boolean;
+}
+/**
+ * Owns one row-drag gesture at a time.
+ *
+ * Built on pointer events rather than HTML5 drag-and-drop or the CDK's
+ * drag-drop:
+ *
+ * - HTML5 DnD does not fire for touch at all, and its drag image cannot be
+ *   styled to match the grid.
+ * - `cdkDropList` assumes every item it manages is in the DOM. Inside a virtual
+ *   scroll viewport rows unmount as they leave the buffer, so the list it
+ *   thinks it is sorting is only ever the visible window.
+ * - Pointer events cover mouse, touch and pen in one path, and pointer capture
+ *   keeps the gesture alive when the finger leaves the row it started on.
+ *
+ * Because rows are a fixed `itemSize`, the drop target is arithmetic on the
+ * pointer's Y rather than a hit test against row elements — which is also why
+ * it stays correct for rows that are scrolled out and not rendered.
+ */
+export declare class OneGridRowDragService<T = any> implements OnDestroy {
+    private readonly zone;
+    /** Live drag, for the body to render the handle state and the indicator. */
+    readonly state$: BehaviorSubject<OneRowDragState>;
+    /** Screen-reader narration for the keyboard path. */
+    readonly announcement$: BehaviorSubject<string>;
+    private context;
+    private pointerId;
+    private handle;
+    private startY;
+    private armed;
+    private lastClientY;
+    private scrollFrame;
+    /** A move already applied during this drag, so a cancel can undo it. */
+    private appliedFrom;
+    private onMove?;
+    private onEnd?;
+    attach(context: OneRowDragContext<T>): void;
+    get state(): OneRowDragState | null;
+    get dragging(): boolean;
+    /**
+     * Begin a pointer drag. Nothing visible happens until the pointer has moved
+     * {@link DRAG_THRESHOLD_PX}, so a click on the handle — which is also the
+     * keyboard affordance — is not swallowed by a zero-distance drag.
+     */
+    startPointerDrag(event: PointerEvent, node: OneRowNode<T>, handlers?: {
+        onEnd?: (event: OneRowDragEvent<T> | null) => void;
+    }): void;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    /** Escape aborts a pointer drag, the same as it does a keyboard one. */
+    private handlePointerKeydown;
+    /**
+     * Turn the pointer's Y into an insertion boundary.
+     *
+     * Boundaries, not rows: the value is where the row would be *inserted*, so
+     * 0 is above the first row and `length` is below the last. Rounding rather
+     * than flooring puts the split at the middle of each row, which is what
+     * makes the indicator flip when you cross the halfway point.
+     */
+    private updateFromPointer;
+    /**
+     * Scroll when the pointer sits near an edge, so rows outside the viewport
+     * are reachable without letting go. Runs on rAF while the pointer is parked
+     * in the zone, and re-derives the target each frame because the content
+     * moves while the pointer does not.
+     */
+    private updateAutoScroll;
+    private stopAutoScroll;
+    private teardownPointer;
+    /** Space/Enter on the handle: pick the row up, or put it down. */
+    toggleKeyboardDrag(node: OneRowNode<T>, handlers?: {
+        onEnd?: (event: OneRowDragEvent<T> | null) => void;
+    }): void;
+    /**
+     * Arrow keys move the row a position at a time, applying as they go.
+     *
+     * Applied rather than previewed because the row has to be seen to move: a
+     * keyboard user gets no drag image, and a preview line alone tells someone
+     * relying on a screen reader nothing about where the row now sits. Escape
+     * still restores the original position.
+     */
+    moveKeyboard(delta: number): boolean;
+    private commit;
+    /** Abort, restoring anything a keyboard drag already applied. */
+    cancel(): void;
+    private finish;
+    private reset;
+    private publish;
+    private announce;
+    private describe;
+    private indexOf;
+    private nodeAt;
+    private clamp;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OneGridRowDragService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OneGridRowDragService<any>>;
+}

package/lib/core/services/one-grid-selection.service.d.ts

@@ -9,6 +9,15 @@ export declare class OneGridSelectionService {
     setSelectionMode(mode: RowSelectionMode): void;
     toggleSelection(rowId: string, selected: boolean): void;
     toggleAllSelection(allIds: string[], selected: boolean): void;
+    /**
+     * Tri-state for the header checkbox, over the rows currently present.
+     *
+     * This compared `_selectedIds.size` with `allIds.length` and never checked
+     * that the selected ids were among the present ones. Selecting two rows and
+     * then swapping in two different rows reported `checked` with nothing
+     * actually selected, because the two counts happened to match. Counting the
+     * intersection is the only thing that answers the question being asked.
+     */
     getSelectAllState(allIds: (string)[]): OneCheckboxState;
     selectAll(rowIds: string[]): void;
     deselectAll(): void;

package/lib/helpers/one-column-def.helper.d.ts

@@ -1,4 +1,16 @@
 import { OneCellRendererParams, OneColumnDef, OneValueGetterParams } from "../core/models/one-column-def-types.model";
+/** Width used when a column defines neither `width` nor `minWidth`. */
+export declare const ONE_DEFAULT_COLUMN_WIDTH = 150;
+/**
+ * The rendered width of a column, clamped to its bounds.
+ *
+ * `width`, `minWidth` and `maxWidth` are all optional, and the previous inline
+ * expression — repeated in two places — fell back to `minWidth` when `width`
+ * was absent. With neither set that produced `undefined`, and summing it gave
+ * a `NaN` row width, so the row collapsed. This is total: every combination of
+ * present and absent bounds resolves to a usable number.
+ */
+export declare function resolveColumnWidth<T>(column: OneColumnDef<T>): number;
 /**
  * Apply Default Column Definitions
  */
@@ -6,7 +18,13 @@ export declare function applyDefaultColumnDef<T>(columnDefs: OneColumnDef<T>[],
 /**
  * One Column Params Resolver (Cell Renderer)
  */
-export declare function resolveOneCellRendererParams<T>(prop: boolean | ((params: any) => boolean), params: OneCellRendererParams<T>): boolean;
+export declare function resolveOneCellRendererParams<T>(prop: boolean | ((params: any) => boolean), params: OneCellRendererParams<T>, 
+/**
+ * What an unset property means: `false` for a capability you opt into,
+ * `true` for a restriction you opt out of. `!!prop` could not tell the two
+ * apart, which left `updatable` — a restriction — defaulting to "deny".
+ */
+whenUnset?: boolean): boolean;
 /**
  * One Column Params Resolver (Generics)
  */

package/lib/helpers/one-filter.helper.d.ts

@@ -5,16 +5,41 @@ import { OneFilterModel } from "../core/models/one-filter.model";
  *
  * Rules:
  * - A node is visible if it matches the filters or has a matching descendant.
- * - A node is expanded if it has a matching descendant.
+ * - While a filter is active, a node is expanded iff it has a matching
+ *   descendant, so the hit is revealed.
+ *
+ * Overwriting `expanded` is only correct *while filtering*. This runs from
+ * `applyFilters`, which every `setRowData` / `updateRowData` calls, so doing it
+ * unconditionally force-expanded every parent on each data update: it made
+ * `groupDefaultExpanded` inert for tree data and collapsed expanded
+ * master-detail rows (they have no children, so `childMatch` is false).
  *
  * @returns True if the current node or any descendant matches.
  */
-export declare function filterTreeNode<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null, quick: string): boolean;
+export declare function filterTreeNode<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null, quick: string, fields?: readonly string[]): boolean;
+/**
+ * Whether anything is actually filtering right now. A model entry with no
+ * conditions matches everything, so it does not count as active.
+ */
+export declare function isFilterActive(filters: OneFilterModel[] | null, quick: string): boolean;
 /**
  * Apply advanced per-column filters
  */
 export declare function matchesAdvancedFilters<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null): boolean;
 /**
- * Apply quick filter across all fields
+ * Apply the quick filter to one row.
+ *
+ * Searches the fields the grid actually shows, when it is told what they are.
+ * It used to walk `Object.values(node.data)`, which had three consequences, all
+ * of them wrong:
+ *
+ * - a property with no column was searchable, so a user could match rows on
+ *   data the grid never displayed;
+ * - a nested object stringified to `[object Object]`, so typing `object`
+ *   matched every row holding one;
+ * - in a tree, `children` did the same, so most parents matched most queries.
+ *
+ * Non-primitive values are skipped regardless, so the `[object Object]` haystack
+ * cannot come back through a declared column either.
  */
-export declare function matchesQuickFilter<T = any>(node: OneRowNode<T>, quick: string): boolean;
+export declare function matchesQuickFilter<T = any>(node: OneRowNode<T>, quick: string, fields?: readonly string[]): boolean;

package/lib/index.d.ts

@@ -6,9 +6,14 @@ export * from './core/services/one-grid-event.service';
 export * from './core/services/one-grid-selection.service';
 export * from './core/services/one-grid-expansion.service';
 export * from './core/services/one-grid-cell.service';
+export * from './core/services/one-grid-row-drag.service';
 export * from './core/services/one-grid-tree-data.service';
 export * from './core/models/constants/one-pagination.constant';
 export * from './core/models/one-column-def-types.model';
+export * from './core/models/one-filter.model';
+export * from './core/models/one-master-detail.model';
+export * from './core/models/one-row.model';
+export * from './core/models/one-row-drag.model';
 export * from './core/models/one-event-types.model';
 export * from './core/models/one-grid-types.model';
 export * from './core/models/one-pagination-types.model';

package/lib/one-grid.module.d.ts

@@ -17,29 +17,27 @@ import * as i15 from "./core/pipes/cell-invalid.pipe";
 import * as i16 from "./core/pipes/cell-selected.pipe";
 import * as i17 from "./core/pipes/cell-action-button-enable.pipe";
 import * as i18 from "./core/pipes/cell-number-value.pipe";
-import * as i19 from "./core/pipes/cell-disable-resolver.pipe";
-import * as i20 from "./core/pipes/cell-field.pipe";
-import * as i21 from "./core/pipes/cell-key.pipe";
-import * as i22 from "./core/pipes/cell-level-padding.pipe";
-import * as i23 from "./core/pipes/column-sort-state.pipe";
-import * as i24 from "./core/pipes/header-checkbox-disabled.pipe";
-import * as i25 from "./core/pipes/header-checkbox-checked.pipe";
-import * as i26 from "./core/pipes/header-checkbox-indeterminate.pipe";
-import * as i27 from "./core/pipes/cell-state-renderer.pipe";
-import * as i28 from "./core/pipes/cell-state-group-renderer.pipe";
-import * as i29 from "./core/directives/one-cell-input-validator.directive";
-import * as i30 from "./core/directives/one-cell-renderer-component.directive";
-import * as i31 from "./core/directives/one-cell-text-expand.directive";
-import * as i32 from "./components/one-grid-cell-currency/one-grid-cell-currency.component";
-import * as i33 from "./components/one-grid-cell-option-menu/one-grid-cell-option-menu.component";
+import * as i19 from "./core/pipes/cell-field.pipe";
+import * as i20 from "./core/pipes/cell-key.pipe";
+import * as i21 from "./core/pipes/cell-level-padding.pipe";
+import * as i22 from "./core/pipes/column-sort-state.pipe";
+import * as i23 from "./core/pipes/header-checkbox-disabled.pipe";
+import * as i24 from "./core/pipes/header-checkbox-checked.pipe";
+import * as i25 from "./core/pipes/header-checkbox-indeterminate.pipe";
+import * as i26 from "./core/pipes/cell-state-renderer.pipe";
+import * as i27 from "./core/pipes/cell-state-group-renderer.pipe";
+import * as i28 from "./core/directives/one-cell-input-validator.directive";
+import * as i29 from "./core/directives/one-cell-renderer-component.directive";
+import * as i30 from "./core/directives/one-cell-text-expand.directive";
+import * as i31 from "./components/one-grid-cell-currency/one-grid-cell-currency.component";
+import * as i32 from "./components/one-grid-cell-option-menu/one-grid-cell-option-menu.component";
+import * as i33 from "./components/one-grid-row-drag-handle/one-grid-row-drag-handle.component";
 import * as i34 from "@angular/common";
 import * as i35 from "@angular/forms";
 import * as i36 from "@angular/cdk/scrolling";
-import * as i37 from "@ng-bootstrap/ng-bootstrap";
-import * as i38 from "@angular/cdk/drag-drop";
-import * as i39 from "lucide-angular";
+import * as i37 from "lucide-angular";
 export declare class OneGridModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<OneGridModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<OneGridModule, [typeof i1.OneGridComponent, typeof i2.OneGridHeaderComponent, typeof i3.OneGridBodyComponent, typeof i4.OneGridCheckboxComponent, typeof i5.OneGridCheckboxHeaderComponent, typeof i6.OneGridRowActionComponent, typeof i7.OneGridPaginationComponent, typeof i8.OneGridStatusComponent, typeof i9.OneGridCellGroupRendererComponent, typeof i10.CellFieldValueEmptyPipe, typeof i11.CellValueGetterPipe, typeof i12.CellFieldValuePipe, typeof i13.CellActionButtonVisiblePipe, typeof i14.CellEditablePipe, typeof i15.CellInvalidPipe, typeof i16.CellSelectedPipe, typeof i17.CellActionButtonEnablePipe, typeof i18.CellNumberValuePipe, typeof i19.CellDisableResolverPipe, typeof i20.CellFieldPipe, typeof i21.CellKeyPipe, typeof i22.CellLevelPaddingPipe, typeof i23.ColumnSortStatePipe, typeof i24.HeaderCheckboxDisabledPipe, typeof i25.HeaderCheckboxCheckedPipe, typeof i26.HeaderCheckboxIndeterminatePipe, typeof i27.CellStateRendererPipe, typeof i28.CellStateGroupRendererPipe, typeof i29.OneCellInputValidatorDirective, typeof i30.OneCellRendererComponentDirective, typeof i31.OneCellTextExpandDirective, typeof i32.OneGridCellCurrencyComponent, typeof i33.OneGridCellOptionMenuComponent], [typeof i34.CommonModule, typeof i35.FormsModule, typeof i36.ScrollingModule, typeof i37.NgbTypeahead, typeof i37.NgbHighlight, typeof i35.ReactiveFormsModule, typeof i38.CdkDragPlaceholder, typeof i39.LucideAngularModule], [typeof i1.OneGridComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OneGridModule, [typeof i1.OneGridComponent, typeof i2.OneGridHeaderComponent, typeof i3.OneGridBodyComponent, typeof i4.OneGridCheckboxComponent, typeof i5.OneGridCheckboxHeaderComponent, typeof i6.OneGridRowActionComponent, typeof i7.OneGridPaginationComponent, typeof i8.OneGridStatusComponent, typeof i9.OneGridCellGroupRendererComponent, typeof i10.CellFieldValueEmptyPipe, typeof i11.CellValueGetterPipe, typeof i12.CellFieldValuePipe, typeof i13.CellActionButtonVisiblePipe, typeof i14.CellEditablePipe, typeof i15.CellInvalidPipe, typeof i16.CellSelectedPipe, typeof i17.CellActionButtonEnablePipe, typeof i18.CellNumberValuePipe, typeof i19.CellFieldPipe, typeof i20.CellKeyPipe, typeof i21.CellLevelPaddingPipe, typeof i22.ColumnSortStatePipe, typeof i23.HeaderCheckboxDisabledPipe, typeof i24.HeaderCheckboxCheckedPipe, typeof i25.HeaderCheckboxIndeterminatePipe, typeof i26.CellStateRendererPipe, typeof i27.CellStateGroupRendererPipe, typeof i28.OneCellInputValidatorDirective, typeof i29.OneCellRendererComponentDirective, typeof i30.OneCellTextExpandDirective, typeof i31.OneGridCellCurrencyComponent, typeof i32.OneGridCellOptionMenuComponent, typeof i33.OneGridRowDragHandleComponent], [typeof i34.CommonModule, typeof i35.FormsModule, typeof i36.ScrollingModule, typeof i35.ReactiveFormsModule, typeof i37.LucideAngularModule], [typeof i1.OneGridComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<OneGridModule>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@one-grid-core/angular",
-  "version": "0.1.0-beta.6",
+  "version": "0.2.0",
   "description": "OneGrid — a feature-rich Angular data grid component with tree data, master/detail, editing, selection, pagination, and virtual scrolling.",
   "keywords": [
     "angular",
@@ -33,7 +33,6 @@
     "@angular/core": ">=17.0.0",
     "@angular/forms": ">=17.0.0",
     "@angular/cdk": ">=17.0.0",
-    "@ng-bootstrap/ng-bootstrap": ">=16.0.0",
     "lucide-angular": ">=0.400.0",
     "rxjs": "^6.5.3 || ^7.4.0"
   },