@kouji-ui/core 0.1.1 → 0.1.3

package/src/table/table-filter-outlet.ts

@@ -1,120 +0,0 @@
-import {
-  Directive,
-  EnvironmentInjector,
-  Injector,
-  TemplateRef,
-  Type,
-  ViewContainerRef,
-  computed,
-  effect,
-  inject,
-  input,
-  signal,
-  type ComponentRef,
-  type EmbeddedViewRef,
-  type Signal,
-} from '@angular/core';
-import type { Column, RowData } from '@tanstack/angular-table';
-import { KJ_TABLE, KjTable } from './table';
-import { provideKjFilterParams, type KjFilterParams, type KjFilterRenderer } from './filter-params';
-
-/**
- * Mounts a user-supplied filter UI (component class or `TemplateRef`) and
- * wires it to a single `Column`. The mounted view receives a stable
- * `KjFilterParams` object via:
- *
- * - the component's `params` input (if it declares one), and
- * - the `KJ_FILTER_PARAMS` DI token (for components that prefer DI), and
- * - `let-params` on a template.
- *
- * The outlet itself owns the column's filter signal — it reads
- * `column.getFilterValue()` through the table's state signal so any external
- * change (URL state, persisted state, programmatic `gridApi.setColumnFilter`)
- * flows back into the UI.
- *
- * @example
- * ```html
- * <th kj-table-filter-outlet [kjColumn]="col" [kjFilter]="MyFilter" />
- * ```
- */
-@Directive({
-  selector: '[kj-table-filter-outlet],[kjTableFilterOutlet]',
-  standalone: true,
-})
-export class KjTableFilterOutlet<TData extends RowData = unknown, TValue = unknown> {
-  /** The TanStack column this outlet's filter operates on. */
-  kjColumn = input.required<Column<TData, TValue>>();
-
-  /** The filter renderer — a component class or a `TemplateRef`. */
-  kjFilter = input.required<KjFilterRenderer<TData, TValue>>();
-
-  private readonly tableDir = inject<KjTable<TData>>(KJ_TABLE as never);
-  private readonly viewContainer = inject(ViewContainerRef);
-  private readonly envInjector = inject(EnvironmentInjector);
-  private readonly parentInjector = inject(Injector);
-
-  /** Reactive view of the column's current filter value. */
-  private readonly modelSignal: Signal<TValue | null> = computed(() => {
-    // Subscribe to the underlying state slice so this re-runs whenever the
-    // filter changes — `getFilterValue()` itself isn't a signal.
-    this.tableDir.state.columnFilters();
-    const v = this.kjColumn().getFilterValue();
-    return (v ?? null) as TValue | null;
-  });
-
-  private mounted = signal<
-    | { kind: 'component'; ref: ComponentRef<{ params?: KjFilterParams<TData, TValue> }> }
-    | { kind: 'template';  ref: EmbeddedViewRef<KjFilterParams<TData, TValue>> }
-    | null
-  >(null);
-
-  constructor() {
-    // Mount / re-mount whenever the renderer or column changes.
-    effect(() => {
-      const renderer = this.kjFilter();
-      const column   = this.kjColumn();
-      this.destroyMount();
-      this.viewContainer.clear();
-
-      const params: KjFilterParams<TData, TValue> = {
-        column,
-        api: this.tableDir.gridApi,
-        columnApi: this.tableDir.columnApi,
-        model: this.modelSignal,
-        setModel: (value) => {
-          column.setFilterValue(
-            value === '' || value === null || value === undefined ? undefined : value,
-          );
-        },
-        isActive: () => column.getIsFiltered(),
-        clear: () => column.setFilterValue(undefined),
-      };
-
-      if (renderer instanceof TemplateRef) {
-        const view = this.viewContainer.createEmbeddedView(renderer, params);
-        this.mounted.set({ kind: 'template', ref: view });
-      } else {
-        const childInjector = Injector.create({
-          providers: [provideKjFilterParams(params)],
-          parent: this.parentInjector,
-        });
-        const ref = this.viewContainer.createComponent(renderer as Type<{ params?: KjFilterParams<TData, TValue> }>, {
-          environmentInjector: this.envInjector,
-          injector: childInjector,
-        });
-        // Set the input only when the component declares it — Angular
-        // throws if the input doesn't exist, so we guard with try/catch.
-        try { ref.setInput('params', params); } catch { /* component opted out of the input */ }
-        this.mounted.set({ kind: 'component', ref });
-      }
-    });
-  }
-
-  private destroyMount(): void {
-    const m = this.mounted();
-    if (!m) return;
-    if (m.kind === 'component') m.ref.destroy();
-    else m.ref.destroy();
-    this.mounted.set(null);
-  }
-}

package/src/table/table-header.spec.ts

@@ -1,54 +0,0 @@
-import { Component, signal, ChangeDetectionStrategy } from '@angular/core';
-import { render } from '@testing-library/angular';
-import { describe, expect, it } from 'vitest';
-import { KjTable } from './table';
-import { KjTableHeader } from './table-header';
-import { kjColumn } from './column-helpers';
-
-interface Row {
-  name: string;
-}
-
-@Component({
-  standalone: true,
-  imports: [KjTable, KjTableHeader],
-  changeDetection: ChangeDetectionStrategy.Eager,
-  template: `
-    <table [kjTable]="cols" [kjTableData]="data()" #t="kjTable">
-      <thead>
-        @for (g of t.table().getHeaderGroups(); track g.id) {
-          <tr>
-            @for (h of g.headers; track h.id) {
-              <th kjTableHeader [kjHeader]="h" scope="col">{{ h.column.columnDef.header }}</th>
-            }
-          </tr>
-        }
-      </thead>
-    </table>
-  `,
-})
-class Host {
-  protected readonly cols = [kjColumn<Row>({ accessorKey: 'name', header: 'Name' })];
-  protected readonly data = signal<Row[]>([{ name: 'a' }, { name: 'b' }]);
-}
-
-describe('KjTableHeader', () => {
-  it('sets aria-sort to none initially', async () => {
-    const { container } = await render(Host);
-    const th = container.querySelector('th') as HTMLElement;
-    expect(th.getAttribute('aria-sort')).toBe('none');
-  });
-
-  it('toggles aria-sort on click', async () => {
-    const { container, fixture } = await render(Host);
-    const th = container.querySelector('th') as HTMLElement;
-    th.click();
-    await fixture.whenStable();
-    fixture.detectChanges();
-    expect(th.getAttribute('aria-sort')).toBe('ascending');
-    th.click();
-    await fixture.whenStable();
-    fixture.detectChanges();
-    expect(th.getAttribute('aria-sort')).toBe('descending');
-  });
-});

package/src/table/table-header.ts

@@ -1,63 +0,0 @@
-import { Directive, computed, inject, input } from '@angular/core';
-import type { RowData, Table } from '@tanstack/angular-table';
-import { KJ_TABLE } from './table';
-
-/** Sort direction for table columns. */
-export type KjSortDirection = 'asc' | 'desc';
-
-/**
- * Marks a `<th>` as a sortable column header. Sets `aria-sort` based on TanStack sort state.
- * Clicking toggles sort direction only when the column has sorting enabled.
- * If `enableSorting: false` is set on the column def, the header renders as plain text.
- *
- * @example
- * ```html
- * <th kjTableHeader [kjHeader]="header" scope="col">Name</th>
- * ```
- */
-@Directive({
-  selector: '[kjTableHeader]',
-  standalone: true,
-  host: {
-    '[style.cursor]':   'canSort() ? "pointer" : null',
-    '[attr.tabindex]':  'canSort() ? "0" : null',
-    '[attr.aria-sort]': 'canSort() ? ariaSort() : null',
-    '[attr.data-sort]': 'canSort() ? sortDir() : null',
-    '(click)':          'onHeaderClick()',
-    '(keydown.enter)':  'onHeaderClick()',
-    '(keydown.space)':  '$event.preventDefault(); onHeaderClick()',
-  },
-})
-export class KjTableHeader<TData extends RowData = unknown> {
-  /** The TanStack header object for this column. Pass from the table's getHeaderGroups(). */
-  kjHeader = input<ReturnType<Table<TData>['getHeaderGroups']>[0]['headers'][0] | undefined>(undefined);
-
-  private readonly _table = inject(KJ_TABLE, { optional: true });
-
-  /** Whether this column supports sorting, derived from TanStack column state. */
-  readonly canSort = computed(() => this.kjHeader()?.column.getCanSort() ?? false);
-
-  /** Current sort direction, or null when unsorted. */
-  readonly sortDir = computed((): KjSortDirection | null => {
-    // Track parent table sorting signal so this computed re-runs on sort changes.
-    this._table?.state.sorting();
-    const h = this.kjHeader();
-    if (!h) return null;
-    const sorted = h.column.getIsSorted();
-    if (sorted === 'asc') return 'asc';
-    if (sorted === 'desc') return 'desc';
-    return null;
-  });
-
-  /** ARIA sort attribute value derived from sort direction. */
-  readonly ariaSort = computed(() => {
-    const d = this.sortDir();
-    if (d === 'asc')  return 'ascending';
-    if (d === 'desc') return 'descending';
-    return 'none';
-  });
-
-  onHeaderClick(): void {
-    if (this.canSort()) this.kjHeader()?.column.toggleSorting();
-  }
-}

package/src/table/table-keyboard.spec.ts

@@ -1,68 +0,0 @@
-import { Component, signal, ChangeDetectionStrategy } from '@angular/core';
-import { render } from '@testing-library/angular';
-import { describe, expect, it } from 'vitest';
-import { KjTable } from './table';
-import { KjTableRow } from './table-row';
-import { KjTableCell } from './table-cell';
-import { KjTableKeyboardNav } from './table-keyboard';
-import { kjColumn } from './column-helpers';
-
-interface Row {
-  a: string;
-  b: string;
-}
-
-@Component({
-  standalone: true,
-  imports: [KjTable, KjTableRow, KjTableCell, KjTableKeyboardNav],
-  changeDetection: ChangeDetectionStrategy.Eager,
-  template: `
-    <table kjTableKeyboardNav [kjTable]="cols" [kjTableData]="data()" #t="kjTable">
-      <tbody>
-        @for (r of t.table().getRowModel().rows; track r.id) {
-          <tr kjTableRow [kjRow]="r">
-            @for (c of r.getVisibleCells(); track c.id) {
-              <td kjTableCell [kjCell]="c" tabindex="-1">{{ c.getValue() }}</td>
-            }
-          </tr>
-        }
-      </tbody>
-    </table>
-  `,
-})
-class Host {
-  protected readonly cols = [
-    kjColumn<Row>({ accessorKey: 'a' }),
-    kjColumn<Row>({ accessorKey: 'b' }),
-  ];
-  protected readonly data = signal<Row[]>([
-    { a: '1', b: '2' },
-    { a: '3', b: '4' },
-  ]);
-}
-
-describe('KjTableKeyboardNav', () => {
-  it('ArrowRight moves focus to the next cell', async () => {
-    const { container } = await render(Host);
-    const cells = container.querySelectorAll<HTMLElement>('tbody td');
-    cells[0].focus();
-    cells[0].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }));
-    expect(document.activeElement).toBe(cells[1]);
-  });
-
-  it('ArrowDown moves focus down a row, same column', async () => {
-    const { container } = await render(Host);
-    const cells = container.querySelectorAll<HTMLElement>('tbody td');
-    cells[0].focus();
-    cells[0].dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }));
-    expect(document.activeElement).toBe(cells[2]);
-  });
-
-  it('Home moves focus to first cell of the row', async () => {
-    const { container } = await render(Host);
-    const cells = container.querySelectorAll<HTMLElement>('tbody td');
-    cells[1].focus();
-    cells[1].dispatchEvent(new KeyboardEvent('keydown', { key: 'Home', bubbles: true }));
-    expect(document.activeElement).toBe(cells[0]);
-  });
-});

package/src/table/table-keyboard.ts

@@ -1,107 +0,0 @@
-import { Directive, contentChildren } from '@angular/core';
-import { KjTableCell } from './table-cell';
-
-/**
- * WAI-ARIA Grid keyboard pattern. Attach to the same element as `[kjTable]`.
- * Handles Arrow / Home / End / Ctrl+Home/End / PageUp/Down. Tab leaves the
- * grid; cell-level F2 / Enter / Esc / Space are handled by row/cell
- * directives or the styled wrapper's editor.
- *
- * Cells are resolved through Angular's `contentChildren()` query against
- * `KjTableCell`, so the directive only ever sees **rendered** (visible) cells.
- * That keeps navigation correct under virtualization (off-window rows aren't
- * in the query result) and column visibility (hidden columns aren't queryable
- * either). No raw DOM selectors.
- */
-@Directive({
-  selector: '[kjTableKeyboardNav]',
-  standalone: true,
-  host: { '(keydown)': 'onKeyDown($event)' },
-})
-export class KjTableKeyboardNav {
-  /** Live list of every `KjTableCell` rendered inside the grid. */
-  private readonly cells = contentChildren(KjTableCell, { descendants: true });
-
-  onKeyDown(event: KeyboardEvent): void {
-    const startEl = (event.target as HTMLElement).closest<HTMLElement>('[kjTableCell]');
-    if (!startEl) return;
-
-    const matrix = this.buildMatrix();
-    if (!matrix.length) return;
-
-    const pos = this.findCell(matrix, startEl);
-    if (!pos) return;
-    const { rowIdx, colIdx } = pos;
-
-    let target: HTMLElement | null;
-
-    switch (event.key) {
-      case 'ArrowLeft':  target = matrix[rowIdx]?.[colIdx - 1] ?? null; break;
-      case 'ArrowRight': target = matrix[rowIdx]?.[colIdx + 1] ?? null; break;
-      case 'ArrowUp':    target = matrix[rowIdx - 1]?.[colIdx] ?? null; break;
-      case 'ArrowDown':  target = matrix[rowIdx + 1]?.[colIdx] ?? null; break;
-      case 'Home':
-        target = event.ctrlKey
-          ? (matrix[0]?.[0] ?? null)
-          : (matrix[rowIdx]?.[0] ?? null);
-        break;
-      case 'End': {
-        const lastRow = matrix[matrix.length - 1];
-        if (event.ctrlKey) {
-          target = lastRow?.[lastRow.length - 1] ?? null;
-        } else {
-          const row = matrix[rowIdx];
-          target = row?.[row.length - 1] ?? null;
-        }
-        break;
-      }
-      case 'PageDown':
-        target = matrix[Math.min(rowIdx + 10, matrix.length - 1)]?.[colIdx] ?? null;
-        break;
-      case 'PageUp':
-        target = matrix[Math.max(rowIdx - 10, 0)]?.[colIdx] ?? null;
-        break;
-      default: return;
-    }
-
-    if (target) {
-      event.preventDefault();
-      target.focus();
-    }
-  }
-
-  /**
-   * Group every rendered cell host by its `<tr>` ancestor, then sort the
-   * rows in DOM order. This produces a `rows[r][c]` matrix that interleaves
-   * pinned and virtualized tbodies in the order the user actually sees.
-   */
-  private buildMatrix(): HTMLElement[][] {
-    const byRow = new Map<HTMLTableRowElement, HTMLElement[]>();
-    const order: HTMLTableRowElement[] = [];
-    for (const cell of this.cells()) {
-      const host = cell.hostElement;
-      const tr = host.closest<HTMLTableRowElement>('tr');
-      if (!tr) continue;
-      if (!byRow.has(tr)) {
-        byRow.set(tr, []);
-        order.push(tr);
-      }
-      byRow.get(tr)!.push(host);
-    }
-    order.sort((a, b) =>
-      a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1
-    );
-    return order.map((tr) => byRow.get(tr)!);
-  }
-
-  private findCell(
-    matrix: HTMLElement[][],
-    el: HTMLElement,
-  ): { rowIdx: number; colIdx: number } | null {
-    for (let r = 0; r < matrix.length; r++) {
-      const c = matrix[r].indexOf(el);
-      if (c !== -1) return { rowIdx: r, colIdx: c };
-    }
-    return null;
-  }
-}

package/src/table/table-resource.spec.ts

@@ -1,37 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { signal } from '@angular/core';
-import { describe, expect, it, vi } from 'vitest';
-import { kjTableResource } from './table-resource';
-import type { KjTableState } from './table.types';
-
-const initialState: KjTableState = {
-  sorting: [], columnFilters: [], globalFilter: '',
-  pagination: { pageIndex: 0, pageSize: 25 },
-  rowSelection: {}, columnSizing: {}, columnVisibility: {},
-  columnOrder: [], columnPinning: { left: [], right: [] },
-  expanded: {}, grouping: [], density: 'standard',
-};
-
-describe('kjTableResource', () => {
-  it('starts in loading state then resolves', async () => {
-    const r = TestBed.runInInjectionContext(() => kjTableResource<{ id: string }>({
-      stateSignal: signal(initialState),
-      loader: async () => ({ rows: [{ id: '1' }], rowCount: 1 }),
-    }));
-    expect(r.status()).toBe('loading');
-    await new Promise(res => setTimeout(res));
-    expect(r.status()).toBe('resolved');
-    expect(r.value()).toEqual({ rows: [{ id: '1' }], rowCount: 1 });
-  });
-
-  it('re-loads when state signal changes', async () => {
-    const loader = vi.fn(async () => ({ rows: [], rowCount: 0 }));
-    const state = signal(initialState);
-    TestBed.runInInjectionContext(() => kjTableResource({ stateSignal: state, loader }));
-    await new Promise(res => setTimeout(res));
-    expect(loader).toHaveBeenCalledTimes(1);
-    state.set({ ...initialState, pagination: { pageIndex: 1, pageSize: 25 } });
-    await new Promise(res => setTimeout(res));
-    expect(loader).toHaveBeenCalledTimes(2);
-  });
-});

package/src/table/table-resource.ts

@@ -1,36 +0,0 @@
-import { resource, Signal, type ResourceRef } from '@angular/core';
-import type { KjTableState, KjResourceResult } from './table.types';
-
-export interface KjTableResourceOptions<TData, TRequest = unknown> {
-  /** Signal carrying the table's current state. Wired into the resource request. */
-  stateSignal: Signal<KjTableState>;
-  /** Optional extra request inputs — merged into the loader's `request` arg. */
-  request?: Signal<TRequest> | (() => TRequest);
-  /** Async loader. Receives the current table state + extra request + abort signal. */
-  loader: (ctx: {
-    state: KjTableState;
-    request: TRequest | undefined;
-    abortSignal: AbortSignal;
-  }) => Promise<KjResourceResult<TData>>;
-}
-
-/**
- * Resource that wires the table's state signal into Angular's `resource()`.
- * The loader is re-invoked whenever the state (or optional extra request)
- * changes. Aborts in-flight loads on changes.
- */
-export function kjTableResource<TData, TRequest = unknown>(
-  opts: KjTableResourceOptions<TData, TRequest>,
-): ResourceRef<KjResourceResult<TData> | undefined> {
-  const requestSig = opts.request
-    ? (typeof opts.request === 'function' ? opts.request : () => opts.request!())
-    : () => undefined;
-  return resource<KjResourceResult<TData>, { state: KjTableState; request: TRequest | undefined }>({
-    params: () => ({ state: opts.stateSignal(), request: requestSig() as TRequest | undefined }),
-    loader: ({ params, abortSignal }) => opts.loader({
-      state: params.state,
-      request: params.request,
-      abortSignal,
-    }),
-  });
-}

package/src/table/table-row.spec.ts

@@ -1,54 +0,0 @@
-import { Component, signal, ChangeDetectionStrategy } from '@angular/core';
-import { render } from '@testing-library/angular';
-import { describe, expect, it } from 'vitest';
-import { KjTable } from './table';
-import { KjTableRow } from './table-row';
-import { kjColumn } from './column-helpers';
-
-interface Row {
-  id: string;
-  name: string;
-}
-
-@Component({
-  standalone: true,
-  imports: [KjTable, KjTableRow],
-  changeDetection: ChangeDetectionStrategy.Eager,
-  template: `
-    <table [kjTable]="cols" [kjTableData]="data()" #t="kjTable">
-      <tbody>
-        @for (r of t.table().getRowModel().rows; track r.id) {
-          <tr kjTableRow [kjRow]="r"></tr>
-        }
-      </tbody>
-    </table>
-  `,
-})
-class Host {
-  protected readonly cols = [kjColumn<Row>({ accessorKey: 'name', header: 'Name' })];
-  protected readonly data = signal<Row[]>([
-    { id: 'a', name: 'A' },
-    { id: 'b', name: 'B' },
-  ]);
-}
-
-describe('KjTableRow', () => {
-  it('sets role="row" and aria-rowindex', async () => {
-    const { container } = await render(Host);
-    const rows = container.querySelectorAll('tbody tr');
-    expect(rows[0].getAttribute('role')).toBe('row');
-    expect(rows[0].getAttribute('aria-rowindex')).toBe('2'); // 1 = header
-    expect(rows[1].getAttribute('aria-rowindex')).toBe('3');
-  });
-
-  it('reflects aria-selected when row is selected', async () => {
-    const { container, fixture } = await render(Host);
-    const dir = fixture.debugElement.children[0].injector.get(KjTable);
-    // TanStack default row id is the row index as a string ('0' = first row).
-    dir.setState({ rowSelection: { '0': true } });
-    fixture.detectChanges();
-    const rows = container.querySelectorAll('tbody tr');
-    expect(rows[0].getAttribute('aria-selected')).toBe('true');
-    expect(rows[1].getAttribute('aria-selected')).toBe('false');
-  });
-});

package/src/table/table-row.ts

@@ -1,31 +0,0 @@
-import { Directive, computed, inject, input } from '@angular/core';
-import type { RowData, Table } from '@tanstack/angular-table';
-import { KJ_TABLE, KjTable } from './table';
-
-type Row<T> = ReturnType<Table<T>['getRowModel']>['rows'][number];
-
-@Directive({
-  selector: '[kjTableRow]',
-  standalone: true,
-  host: {
-    'role': 'row',
-    '[attr.aria-rowindex]':  'ariaRowIndex()',
-    '[attr.aria-selected]':  'isSelectable() ? isSelected() : null',
-    '[attr.data-selected]':  'isSelected() ? "" : null',
-  },
-})
-export class KjTableRow<TData extends RowData = unknown> {
-  /** TanStack row instance — pass from getRowModel().rows. */
-  kjRow = input.required<Row<TData>>();
-
-  private readonly table = inject(KJ_TABLE) as unknown as KjTable<TData>;
-
-  /** 1-based ARIA index — accounts for header row(s). */
-  readonly ariaRowIndex = computed(() => this.kjRow().index + 2);
-  readonly isSelectable = computed(() => Object.keys(this.table.state.rowSelection()).length >= 0); // always true if selection enabled
-  readonly isSelected   = computed(() => {
-    // Track parent selection signal so the computed re-runs on selection changes.
-    this.table.state.rowSelection();
-    return this.kjRow().getIsSelected();
-  });
-}

package/src/table/table-storage.spec.ts

@@ -1,67 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { describe, expect, it, beforeEach, vi } from 'vitest';
-import {
-  KJ_TABLE_STORAGE,
-  inMemoryAdapter,
-  localStorageAdapter,
-  sessionStorageAdapter,
-  provideKjTableStorage,
-  type KjStorageAdapter,
-} from './table-storage';
-
-describe('inMemoryAdapter', () => {
-  it('round-trips values', () => {
-    const a = inMemoryAdapter();
-    expect(a.read('x')).toBeNull();
-    a.write('x', { a: 1 });
-    expect(a.read('x')).toEqual({ a: 1 });
-  });
-  it('isolates between instances', () => {
-    const a = inMemoryAdapter();
-    const b = inMemoryAdapter();
-    a.write('k', 1);
-    expect(b.read('k')).toBeNull();
-  });
-});
-
-describe('localStorageAdapter', () => {
-  beforeEach(() => localStorage.clear());
-  it('round-trips through localStorage', () => {
-    const a = localStorageAdapter();
-    a.write('k', { a: 1 });
-    expect(a.read('k')).toEqual({ a: 1 });
-  });
-  it('honours keyPrefix', () => {
-    const a = localStorageAdapter({ keyPrefix: 'myapp:' });
-    a.write('k', 1);
-    expect(localStorage.getItem('myapp:k')).toBe('1');
-  });
-  it('returns null when value is corrupt JSON', () => {
-    localStorage.setItem('k', '{bad json');
-    expect(localStorageAdapter().read('k')).toBeNull();
-  });
-});
-
-describe('sessionStorageAdapter', () => {
-  beforeEach(() => sessionStorage.clear());
-  it('round-trips through sessionStorage', () => {
-    const a = sessionStorageAdapter();
-    a.write('k', { a: 1 });
-    expect(a.read('k')).toEqual({ a: 1 });
-  });
-});
-
-describe('provideKjTableStorage', () => {
-  it('binds adapter to KJ_TABLE_STORAGE token', () => {
-    const mock: KjStorageAdapter = { read: vi.fn(() => null), write: vi.fn() };
-    TestBed.configureTestingModule({ providers: [provideKjTableStorage(mock)] });
-    expect(TestBed.inject(KJ_TABLE_STORAGE)).toBe(mock);
-  });
-
-  it('default factory yields inMemory adapter when not provided', () => {
-    TestBed.configureTestingModule({ providers: [] });
-    const adapter = TestBed.inject(KJ_TABLE_STORAGE);
-    expect(typeof adapter.read).toBe('function');
-    expect(typeof adapter.write).toBe('function');
-  });
-});