@ornery/ui-grid-vanilla 1.0.7 → 5.0.0

package/dist/events.d.ts

@@ -0,0 +1,43 @@
+/**
+ * DOM event wiring for the grid element.
+ *
+ * One entry point — `bindEvents(el)` — attaches every shadow-root event
+ * listener the grid needs: click, focusin/out, input, mousedown (selection
+ * drag + column resize), dblclick, keydown, blur, dragstart/over/leave/
+ * drop/end, wheel, scroll. Each handler is a standalone function declared
+ * inside `bindEvents` so it closes over the element and keeps the coupling
+ * local.
+ *
+ * Supporting helpers (`observeTemplateSlots`, `syncHeaderHorizontalScroll`,
+ * `maybeTriggerInfiniteScroll`) also live here because they are only used
+ * by the event path.
+ */
+import type { UiGridStandaloneElement } from './ui-grid-standalone.element';
+/**
+ * Watch the element's light DOM for `<template slot="…">` changes so
+ * consumer template edits trigger a re-render. Ports the old grid's
+ * observer that let template updates flow through without an explicit
+ * options re-assign.
+ */
+export declare function observeTemplateSlots(el: UiGridStandaloneElement): void;
+/**
+ * Mirror horizontal scroll from the body viewport onto the header +
+ * filter strips. The strips are real scroll containers (necessary for
+ * `position: sticky` on pinned cells), so they need scrollLeft set
+ * imperatively to stay aligned with the body.
+ */
+export declare function syncHeaderHorizontalScroll(el: UiGridStandaloneElement, scrollLeft: number): void;
+/**
+ * Ask the controller to evaluate whether the current scroll position
+ * should request more data at the top or bottom — ports the old grid's
+ * `handleScroll → loadData` check. The controller raises
+ * `needLoadMoreData` / `needLoadMoreDataTop` when thresholds are crossed.
+ */
+export declare function maybeTriggerInfiniteScroll(el: UiGridStandaloneElement): void;
+/**
+ * Attach every shadow-root listener the grid needs. Idempotent: a
+ * `__uiGridBound` marker on the shadow root prevents re-binding on
+ * reconnect.
+ */
+export declare function bindEvents(el: UiGridStandaloneElement): void;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAaH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAsB5E;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,uBAAuB,GAAG,IAAI,CAiCtE;AAmBD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,uBAAuB,EAC3B,UAAU,EAAE,MAAM,GACjB,IAAI,CAWN;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,uBAAuB,GAAG,IAAI,CAW5E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,uBAAuB,GAAG,IAAI,CAktB5D"}

package/dist/focus.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Keyboard navigation + focused-cell management.
+ *
+ * `moveGridFocus` is the central router: arrow keys, Tab/Enter inside an
+ * edit session, Home/End, Ctrl+Home/End all funnel through it. It knows
+ * how to walk the visible-row list (skipping group headers + expandable
+ * rows), moves the `cell-focused` decoration, nudges virtualization to
+ * bring off-screen targets into view, and DOM-focuses the target cell.
+ *
+ * Each function takes the element as its first argument and reads its
+ * internal state (snapshot / controller / focusedCell / shadowRoot)
+ * directly.
+ */
+import type { UiGridStandaloneElement } from './ui-grid-standalone.element';
+export type GridMoveDirection = 'left' | 'right' | 'up' | 'down' | 'rowStart' | 'rowEnd' | 'top' | 'bottom';
+/**
+ * Commit the in-flight edit, then move keyboard focus relative to the
+ * committed cell. Splits commit + focus across two paint frames: commit
+ * runs synchronously (editor unmounts, cell re-renders with the new
+ * value), then focus moves to the adjacent cell in a microtask so the
+ * blur handler's re-entry guard doesn't race the focus attempt.
+ *
+ * If the source cell was being edited, the destination cell also enters
+ * edit mode provided its column is editable — Tab/Enter inside an edit
+ * session stays continuous. Arrow nav outside an edit session does NOT
+ * auto-enter edit.
+ */
+export declare function commitAndMove(el: UiGridStandaloneElement, fromRowId: string | null, fromColumnName: string | null, direction: 'left' | 'right' | 'up' | 'down'): void;
+/**
+ * Move focus relative to `(rowId, columnName)`. Uses the snapshot's
+ * display-items order so ArrowDown skips over group headers + expandable
+ * rows to whatever row comes visually next. `top` / `bottom` jump to the
+ * first/last visible row; `rowStart` / `rowEnd` jump to the first/last
+ * column of the current row.
+ */
+export declare function moveGridFocus(el: UiGridStandaloneElement, direction: GridMoveDirection, rowId: string | null, columnName: string | null, opts?: {
+    resumeEdit?: boolean;
+}): void;
+/**
+ * Ensure the row for `rowId` is inside the virtualization window before
+ * focus moves there. When virtualization is on, a distant row isn't yet
+ * rendered into the DOM — scroll to bring it in, let the virtual-body
+ * rebuild on the next frame, then `focusCellElement`'s retry picks it up.
+ */
+export declare function scrollFocusedRowIntoView(el: UiGridStandaloneElement, rowId: string): void;
+/**
+ * Toggle the `cell-focused` class between the previous and next cells.
+ * The grid shell doesn't re-render on every arrow press — we hand-mutate
+ * the two affected cells instead to avoid touching the rest of the DOM.
+ */
+export declare function applyFocusedCellClass(el: UiGridStandaloneElement, previous: {
+    rowId: string;
+    columnName: string;
+} | null, next: {
+    rowId: string;
+    columnName: string;
+} | null): void;
+/**
+ * DOM-focus the body cell matching the given row/column. Retries across
+ * two animation frames so a scroll-triggered virtual-body rebuild has
+ * time to bring the target row into the DOM before we give up.
+ */
+export declare function focusCellElement(el: UiGridStandaloneElement, rowId: string | null, columnName: string | null): void;
+/**
+ * Dispatch a plain click on a body cell through the selection module.
+ * Mirrors the old `ui.grid.selection.uiGridCell` directive: shift-click
+ * ranges, ctrl/meta toggles one, plain click respects
+ * `enableFullRowSelection` + `enableSelectRowOnFocus` +
+ * `modifierKeysToMultiSelect`.
+ */
+export declare function handleRowSelectionClick(el: UiGridStandaloneElement, rowId: string, columnName: string, event: Event): void;
+/**
+ * Click handler for the row-header checkbox column. Differs from the
+ * full-row click only in that shift/ctrl semantics mirror the old
+ * selection module (shift-select pulls from `lastSelectedRow` regardless
+ * of modifier).
+ */
+export declare function handleRowHeaderCheckboxClick(el: UiGridStandaloneElement, rowId: string, event: Event): void;
+/**
+ * Does a keydown event match a cellNav key-override descriptor?
+ * Undefined fields on the override are treated as wildcards. Used by the
+ * event bus to decide whether a key should be handled internally or
+ * forwarded to the consumer via `viewPortKeyDown`.
+ */
+export declare function matchesKeyOverride(override: {
+    keyCode?: number;
+    key?: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+}, event: KeyboardEvent): boolean;
+/**
+ * Measure the natural content width of a column by cloning visible cells
+ * into a hidden max-content container. This avoids measuring the CSS Grid
+ * track width (which just reflects the current column size) and instead
+ * returns the width the content actually needs.
+ */
+export declare function measureAutoColumnWidth(el: UiGridStandaloneElement, columnName: string): number;
+//# sourceMappingURL=focus.d.ts.map

package/dist/focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../src/focus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAI5E,MAAM,MAAM,iBAAiB,GACzB,MAAM,GACN,OAAO,GACP,IAAI,GACJ,MAAM,GACN,UAAU,GACV,QAAQ,GACR,KAAK,GACL,QAAQ,CAAC;AAEb;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,uBAAuB,EAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,cAAc,EAAE,MAAM,GAAG,IAAI,EAC7B,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAC1C,IAAI,CAMN;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,uBAAuB,EAC3B,SAAS,EAAE,iBAAiB,EAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GAClC,IAAI,CA6DN;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,uBAAuB,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAkBzF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,uBAAuB,EAC3B,QAAQ,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,EACtD,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GACjD,IAAI,CAqBN;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,IAAI,CAkBN;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,KAAK,GACX,IAAI,CAiCN;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,GACX,IAAI,CAwBN;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,EACD,KAAK,EAAE,aAAa,GACnB,OAAO,CAQT;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CA0C9F"}

package/dist/framework-slots.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Framework-rendered slot bridge for the vanilla grid element.
+ *
+ * The vanilla grid renders every cell / header / filter / group / expandable
+ * / empty-state via string-interpolated templates by default. When a
+ * framework wrapper (Angular, React, or any other consumer) wants to own
+ * rendering of a slot with its own templating engine, it calls
+ * `setFrameworkRenderedSlots()` on the element to flip slot kinds into
+ * "slot placeholder" mode.
+ *
+ * In that mode the element emits `<slot name="…">` placeholders at the
+ * usual render sites. The wrapper listens for the `*SlotsChanged` event
+ * this module dispatches and inserts light-DOM nodes with matching `slot`
+ * attributes carrying its framework-rendered content. Slot projection then
+ * composes the wrapper's view back into the shadow tree without the
+ * wrapper ever touching the shadow DOM directly.
+ *
+ * Slot naming conventions:
+ *   - `cell-<columnName>-<rowId>`     per-cell (one slot per rendered body cell)
+ *   - `header-<columnName>`           per-column, singleton
+ *   - `filter-<columnName>`           per-column, singleton
+ *   - `group-row-<groupId>`           per-group
+ *   - `expandable-row-<rowId>`        per-row
+ *   - `empty`                         singleton
+ */
+import { type GridCellTemplateContext, type GridColumnDef, type GridExpandableTemplateContext, type GridHeaderTemplateContext, type GridLabels, type GridRow, type GroupItem } from '@ornery/ui-grid-core';
+/** Which slot kinds the element should render as `<slot>` placeholders. */
+export interface FrameworkRenderedSlotsConfig {
+    /** Column names whose body cells are framework-rendered. Everything else
+     * continues to use the vanilla interpolation path. */
+    cells?: readonly string[];
+    /** Column names whose header cells are framework-rendered. */
+    headers?: readonly string[];
+    /** Column names whose filter cells are framework-rendered. */
+    filters?: readonly string[];
+    /** When true, group rows are emitted as slot placeholders. */
+    groupRow?: boolean;
+    /** When true, expandable detail rows are emitted as slot placeholders. */
+    expandableRow?: boolean;
+    /** When true, the empty-state panel is emitted as a slot placeholder. */
+    emptyState?: boolean;
+}
+export interface FrameworkCellSlot {
+    slotName: string;
+    columnName: string;
+    rowId: string;
+    rowIndex: number;
+    context: GridCellTemplateContext;
+}
+export interface FrameworkHeaderSlot {
+    slotName: string;
+    columnName: string;
+    context: GridHeaderTemplateContext;
+}
+export interface FrameworkFilterSlot {
+    slotName: string;
+    columnName: string;
+    value: string;
+    placeholder: string;
+    disabled: boolean;
+    column: GridColumnDef;
+}
+export interface FrameworkGroupRowSlot {
+    slotName: string;
+    groupId: string;
+    field: string;
+    label: string;
+    count: number;
+    depth: number;
+    collapsed: boolean;
+}
+export interface FrameworkExpandableRowSlot {
+    slotName: string;
+    rowId: string;
+    rowIndex: number;
+    context: GridExpandableTemplateContext;
+}
+export interface FrameworkEmptyStateSlot {
+    slotName: 'empty';
+    heading: string;
+    description: string;
+    labels: GridLabels;
+}
+export interface FrameworkSlotDelta<TSlot> {
+    added: TSlot[];
+    removed: TSlot[];
+}
+export declare function cellSlotName(column: GridColumnDef): string;
+export declare function cellSlotNameForRow(column: GridColumnDef, row: GridRow): string;
+export declare function headerSlotName(column: GridColumnDef): string;
+export declare function filterSlotName(column: GridColumnDef): string;
+export declare function groupRowSlotName(group: GroupItem): string;
+export declare function expandableRowSlotName(row: GridRow): string;
+/**
+ * Bridge state + behavior. The element creates one instance, reads the
+ * `has*` methods during render to decide which path to take, calls the
+ * `stage*` methods as it emits slot placeholders, and calls `flush()` at
+ * the end of each render pass to emit the add/remove delta.
+ */
+export declare class FrameworkSlotBridge {
+    private readonly host;
+    private flaggedCells;
+    private flaggedHeaders;
+    private flaggedFilters;
+    private flaggedGroupRow;
+    private flaggedExpandableRow;
+    private flaggedEmptyState;
+    private lastCellSlots;
+    private lastExpandableRowSlots;
+    private lastGroupRowSlots;
+    private lastHeaderSlots;
+    private lastFilterSlots;
+    private lastEmptyStateSlot;
+    private pendingCellSlots;
+    private pendingExpandableRowSlots;
+    private pendingGroupRowSlots;
+    private pendingHeaderSlots;
+    private pendingFilterSlots;
+    private pendingEmptyStateSlot;
+    constructor(host: EventTarget);
+    /**
+     * Apply a slots config. Returns true when the structural set changed (and
+     * therefore a re-render is required), false when the config is a no-op.
+     */
+    configure(config: FrameworkRenderedSlotsConfig): boolean;
+    hasCell(columnName: string): boolean;
+    hasHeader(columnName: string): boolean;
+    hasFilter(columnName: string): boolean;
+    hasGroupRow(): boolean;
+    hasExpandableRow(): boolean;
+    hasEmptyState(): boolean;
+    stageCell(column: GridColumnDef, row: GridRow, rowIndex: number): void;
+    /**
+     * Carry forward every previously-known cell slot for `rowId` into the
+     * current pending set. Used by the structural patch path when a row's
+     * fingerprint matches the previous render's: `stageCell` would normally
+     * re-record the slot during cell rendering, but the fingerprint
+     * short-circuit skips the render pass for unchanged rows. Without this,
+     * `flush()` would diff pending (missing the row's slots) against last
+     * (containing them) and emit a spurious `removed` for every cell of the
+     * unchanged row, destroying the framework wrappers' projected content.
+     */
+    carryRowCells(rowId: string): void;
+    stageExpandableRow(row: GridRow, rowIndex: number): void;
+    stageGroupRow(group: GroupItem): void;
+    stageHeader(column: GridColumnDef): void;
+    stageFilter(column: GridColumnDef, value: string, placeholder: string, disabled: boolean): void;
+    stageEmptyState(heading: string, description: string, labels: GridLabels): void;
+    /**
+     * Diff pending vs. last, dispatch `*SlotsChanged` events for every kind
+     * that moved, then swap last = pending and reset pending. Called at the
+     * end of every render pass.
+     */
+    flush(): void;
+    /**
+     * Data-only patch variant: merge pending entries into last without firing
+     * events, since the slot structure hasn't changed (only cell contexts
+     * refreshed). Wrappers that need context updates subscribe to
+     * `rowsVisibleChanged`.
+     */
+    mergePendingIntoLast(): void;
+    /**
+     * On element teardown, emit `removed` for every remaining slot so wrappers
+     * can destroy their views.
+     */
+    flushRemovals(): void;
+    private diffAndEmit;
+    private diffAndEmitSingleton;
+}
+//# sourceMappingURL=framework-slots.d.ts.map

package/dist/framework-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-slots.d.ts","sourceRoot":"","sources":["../src/framework-slots.ts"],"names":[],"mappings":"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"}