@kouji-ui/core 0.1.1 → 0.1.2

package/src/table/filter-models.ts

@@ -1,124 +0,0 @@
-/**
- * Structured filter models — a near-direct adaptation of AG-Grid's
- * `FilterModel` shape. Each built-in filter writes one of these models
- * to `column.setFilterValue(...)` instead of a raw value. The structured
- * shape buys two things:
- *
- * 1. **Server-side rendering.** `gridApi.filter.getModel()` returns a
- *    `KjGridFilterModel` (`Record<columnId, KjFilterModel>`) that
- *    serialises cleanly into a JSON payload your backend can translate
- *    to SQL/Mongo/etc. without re-parsing free-form values. Pair with
- *    `kjTableResource({ loader })` to fan changes back to the server.
- *
- * 2. **Cross-filter introspection.** Code that needs to "what does the
- *    user currently have selected on column X" can discriminate on
- *    `filterType` and `type` instead of guessing from a `string | unknown`
- *    value.
- *
- * The companion `filter-fns` helpers (`kjTextFilterFn` etc.) implement
- * client-side filtering against these models so client-mode tables work
- * out of the box — point `kjColumn({ filterFn: kjTextFilterFn })` at one
- * and TanStack will dispatch row matching for you.
- */
-
-/** Comparison operators for {@link KjTextFilterModel}. */
-export type KjTextFilterType =
-  | 'contains'
-  | 'notContains'
-  | 'equals'
-  | 'notEquals'
-  | 'startsWith'
-  | 'endsWith'
-  | 'blank'
-  | 'notBlank';
-
-export interface KjTextFilterModel {
-  readonly filterType: 'text';
-  readonly type: KjTextFilterType;
-  /** Match string. Omitted for `blank` / `notBlank`. */
-  readonly filter?: string;
-  /** Case-insensitive matching. Defaults to `true`. */
-  readonly caseSensitive?: boolean;
-}
-
-/** Comparison operators for {@link KjNumberFilterModel}. */
-export type KjNumberFilterType =
-  | 'equals'
-  | 'notEquals'
-  | 'greaterThan'
-  | 'greaterThanOrEqual'
-  | 'lessThan'
-  | 'lessThanOrEqual'
-  | 'inRange'
-  | 'blank'
-  | 'notBlank';
-
-export interface KjNumberFilterModel {
-  readonly filterType: 'number';
-  readonly type: KjNumberFilterType;
-  /** Primary number. Omitted for `blank` / `notBlank`. */
-  readonly filter?: number;
-  /** Range upper bound — used by `inRange`. */
-  readonly filterTo?: number;
-}
-
-/** Comparison operators for {@link KjDateFilterModel}. */
-export type KjDateFilterType =
-  | 'equals'
-  | 'notEquals'
-  | 'greaterThan'      // after
-  | 'lessThan'         // before
-  | 'inRange'
-  | 'blank'
-  | 'notBlank';
-
-export interface KjDateFilterModel {
-  readonly filterType: 'date';
-  readonly type: KjDateFilterType;
-  /** Primary date — ISO `YYYY-MM-DD`. */
-  readonly dateFrom?: string;
-  /** Range upper bound — used by `inRange`. */
-  readonly dateTo?: string;
-}
-
-/**
- * Set / multi-select filter — the row passes if the cell value is in
- * `values`. An empty `values` array means "no filter" (cleared); pair
- * with `setFilterValue(undefined)` for the cleared state by preference.
- */
-export interface KjSetFilterModel {
-  readonly filterType: 'set';
-  readonly values: readonly unknown[];
-}
-
-/** Compound filter — combine two conditions with AND / OR. */
-export interface KjMultiConditionFilterModel<TModel extends KjFilterModel = KjFilterModel> {
-  readonly filterType: 'multi';
-  readonly operator: 'AND' | 'OR';
-  readonly conditions: readonly TModel[];
-}
-
-/** Discriminated union of every built-in filter model. */
-export type KjFilterModel =
-  | KjTextFilterModel
-  | KjNumberFilterModel
-  | KjDateFilterModel
-  | KjSetFilterModel
-  | KjMultiConditionFilterModel;
-
-/**
- * Bulk filter snapshot — keyed by column id. Shape mirrors AG-Grid's
- * `api.getFilterModel()` return so SSR loaders that already understand
- * AG-Grid payloads can consume it as-is.
- */
-export type KjGridFilterModel = Record<string, KjFilterModel>;
-
-/** Narrowing helper. */
-export function isKjFilterModel(value: unknown): value is KjFilterModel {
-  return (
-    !!value &&
-    typeof value === 'object' &&
-    'filterType' in (value as object) &&
-    typeof (value as { filterType: unknown }).filterType === 'string'
-  );
-}

package/src/table/filter-params.ts

@@ -1,90 +0,0 @@
-import {
-  InjectionToken,
-  Injector,
-  Provider,
-  TemplateRef,
-  Type,
-  inject,
-  type Signal,
-} from '@angular/core';
-import type { Column, RowData } from '@tanstack/angular-table';
-import type { KjColumnApi, KjGridApi } from './grid-api';
-
-/**
- * Context handed to every custom filter — component class or template.
- *
- * Mirrors AG-Grid's `IFilterParams` shape: the column being filtered, the
- * grid + column APIs for cross-cutting actions, the current model as a
- * reactive signal, and an imperative setter that clears the filter on
- * `null`/`undefined`/`''`. A signal is used (rather than a callback) so
- * filter UIs can derive bound values via `computed()` without their own
- * change-detection plumbing.
- *
- * Components either accept a single required input named `params` of this
- * shape, or call {@link injectKjFilterParams}. Templates receive the same
- * context via `$implicit` (`let-params`).
- */
-export interface KjFilterParams<TData extends RowData = unknown, TValue = unknown> {
-  /** The TanStack column the filter targets. */
-  readonly column: Column<TData, TValue>;
-  /** Grid-wide imperative API for cross-column actions. */
-  readonly api: KjGridApi<TData>;
-  /** Per-column imperative API. */
-  readonly columnApi: KjColumnApi<TData>;
-  /** Live filter model — reactive view of `column.getFilterValue()`. */
-  readonly model: Signal<TValue | null>;
-  /** Imperative setter. `null`, `undefined`, or `''` clear the filter. */
-  setModel(value: TValue | null | undefined): void;
-  /** True when the filter currently restricts results. */
-  isActive(): boolean;
-  /** Convenience: clear this filter. Equivalent to `setModel(null)`. */
-  clear(): void;
-}
-
-/**
- * Anything that can render a filter UI: a standalone component class or a
- * `TemplateRef` whose `$implicit` context is a `KjFilterParams`.
- */
-export type KjFilterRenderer<TData extends RowData = unknown, TValue = unknown> =
-  | Type<{ params?: unknown } & object>
-  | TemplateRef<KjFilterParams<TData, TValue>>;
-
-/**
- * Private token. Use {@link provideKjFilterParams} / {@link injectKjFilterParams}
- * — the token itself is not exported from the package so consumers cannot
- * bypass the helpers (and can't accidentally provide a malformed value).
- */
-const KJ_FILTER_PARAMS = new InjectionToken<KjFilterParams>('kj.filter.params');
-
-/**
- * Returns a `Provider` that exposes a `KjFilterParams` instance to a child
- * injector. Used by `KjTableFilterOutlet` and the styled-wrapper's filter
- * mounting code; user code should normally not call this directly.
- */
-export function provideKjFilterParams<TData extends RowData, TValue>(
-  params: KjFilterParams<TData, TValue>,
-): Provider {
-  return { provide: KJ_FILTER_PARAMS, useValue: params };
-}
-
-/**
- * Resolve the active `KjFilterParams` from the current injection context.
- *
- * @example
- * ```ts
- * @Component({ selector: 'my-filter', template: '…' })
- * class MyFilter {
- *   protected readonly params = injectKjFilterParams<User, string>();
- *   protected onInput(v: string) { this.params.setModel(v || null); }
- * }
- * ```
- */
-export function injectKjFilterParams<
-  TData extends RowData = unknown,
-  TValue = unknown,
->(injector?: Injector): KjFilterParams<TData, TValue> {
-  const params = injector
-    ? injector.get(KJ_FILTER_PARAMS)
-    : inject(KJ_FILTER_PARAMS);
-  return params as KjFilterParams<TData, TValue>;
-}

package/src/table/grid-api-impl.ts

@@ -1,321 +0,0 @@
-import type { WritableSignal, Signal } from '@angular/core';
-import type {
-  ColumnFiltersState,
-  ColumnOrderState,
-  ColumnPinningState,
-  ColumnSizingState,
-  ExpandedState,
-  GroupingState,
-  PaginationState,
-  RowData,
-  RowSelectionState,
-  Table,
-  VisibilityState,
-} from '@tanstack/angular-table';
-import type {
-  KjColumnApi,
-  KjColumnGroupingApi,
-  KjColumnOrderApi,
-  KjColumnPinningApi,
-  KjColumnSizingApi,
-  KjColumnVisibilityApi,
-  KjDensityApi,
-  KjExpansionApi,
-  KjFilterApi,
-  KjGlobalFilterApi,
-  KjGridApi,
-  KjGroupingApi,
-  KjPaginationApi,
-  KjRowsApi,
-  KjSelectionApi,
-  KjSortApi,
-} from './grid-api';
-import { isKjFilterModel, type KjFilterModel, type KjGridFilterModel } from './filter-models';
-import type { KjTableDensity, KjTableState } from './table.types';
-
-/**
- * Build a `KjGridApi` + `KjColumnApi` pair bound to a directive instance.
- * Called once from `KjTable` and cached. Methods close over the directive's
- * private state signal and the lazy TanStack `Table` getter so every call
- * sees the live grid.
- */
-export function createGridApi<TData extends RowData>(opts: {
-  state: Signal<KjTableState>;
-  table: () => Table<TData>;
-  patch: <K extends keyof KjTableState>(
-    key: K,
-    updater: KjTableState[K] | ((prev: KjTableState[K]) => KjTableState[K]),
-  ) => void;
-  setStateInternal: WritableSignal<KjTableState>['update'];
-  resetState: () => void;
-  defaultState: KjTableState;
-}): { gridApi: KjGridApi<TData>; columnApi: KjColumnApi<TData> } {
-  const { state, table, patch, resetState, defaultState } = opts;
-
-  const setStateMerge = (partial: Partial<KjTableState>): void => {
-    opts.setStateInternal((s) => ({ ...s, ...partial }));
-  };
-
-  // ── KjColumnApi namespaces ────────────────────────────────────────────────
-
-  const visibility: KjColumnVisibilityApi = {
-    get: () => state().columnVisibility,
-    set: (model) => patch('columnVisibility', model),
-    isVisible: (id) => state().columnVisibility[id] !== false,
-    setVisible: (id, visible) =>
-      patch('columnVisibility', (prev: VisibilityState) => ({ ...prev, [id]: visible })),
-    setManyVisible: (ids, visible) =>
-      patch('columnVisibility', (prev: VisibilityState) => {
-        const next = { ...prev };
-        for (const id of ids) next[id] = visible;
-        return next;
-      }),
-  };
-
-  const sizing: KjColumnSizingApi = {
-    get: () => state().columnSizing,
-    set: (model) => patch('columnSizing', model),
-    width: (id) => table().getColumn(id)?.getSize() ?? 0,
-    setWidth: (id, width) =>
-      patch('columnSizing', (prev: ColumnSizingState) => ({ ...prev, [id]: width })),
-  };
-
-  const pinning: KjColumnPinningApi = {
-    get: () => state().columnPinning,
-    set: (model) => patch('columnPinning', model),
-    of: (id) => {
-      const p = state().columnPinning;
-      if ((p.left ?? []).includes(id)) return 'left';
-      if ((p.right ?? []).includes(id)) return 'right';
-      return null;
-    },
-    pin: (id, side) =>
-      patch('columnPinning', (prev: ColumnPinningState) => ({
-        left:  (prev.left  ?? []).filter((c) => c !== id).concat(side === 'left'  ? [id] : []),
-        right: (prev.right ?? []).filter((c) => c !== id).concat(side === 'right' ? [id] : []),
-      })),
-  };
-
-  const order: KjColumnOrderApi = {
-    get: () => state().columnOrder,
-    set: (o) => patch('columnOrder', o),
-    move: (id, toIndex) =>
-      patch('columnOrder', (prev: ColumnOrderState) => {
-        const base = prev.length > 0 ? prev : table().getAllLeafColumns().map((c) => c.id);
-        const without = base.filter((c) => c !== id);
-        const clamped = Math.max(0, Math.min(toIndex, without.length));
-        return [...without.slice(0, clamped), id, ...without.slice(clamped)];
-      }),
-  };
-
-  const colGrouping: KjColumnGroupingApi = {
-    is: (id) => state().grouping.includes(id),
-    set: (id, grouped) =>
-      patch('grouping', (prev: GroupingState) =>
-        grouped
-          ? prev.includes(id) ? prev : [...prev, id]
-          : prev.filter((c) => c !== id),
-      ),
-  };
-
-  const columnApi: KjColumnApi<TData> = {
-    get: (id) => table().getColumn(id) ?? null,
-    all: () => table().getAllColumns(),
-    leaves: () => table().getAllLeafColumns(),
-    visibleLeaves: () => table().getVisibleLeafColumns(),
-    visibility,
-    sizing,
-    pinning,
-    order,
-    grouping: colGrouping,
-    reset: () =>
-      setStateMerge({
-        columnVisibility: defaultState.columnVisibility,
-        columnSizing:     defaultState.columnSizing,
-        columnPinning:    defaultState.columnPinning,
-        columnOrder:      defaultState.columnOrder,
-        grouping:         defaultState.grouping,
-      }),
-  };
-
-  // ── KjGridApi namespaces ──────────────────────────────────────────────────
-
-  const rows: KjRowsApi<TData> = {
-    all: () => (table().options.data ?? []) as readonly TData[],
-    displayed: () => table().getRowModel().rows,
-    count: () => (table().options.data?.length ?? 0),
-    filteredCount: () => table().getFilteredRowModel().rows.length,
-    displayedCount: () => table().getRowModel().rows.length,
-    get: (id) => table().getRow(id, /* searchAll */ true),
-  };
-
-  const selection: KjSelectionApi<TData> = {
-    get: () => state().rowSelection,
-    set: (model) => patch('rowSelection', model),
-    rows: () => table().getSelectedRowModel().rows,
-    ids: () => Object.keys(state().rowSelection).filter((id) => state().rowSelection[id]),
-    has: () => {
-      const sel = state().rowSelection;
-      for (const key in sel) if (sel[key]) return true;
-      return false;
-    },
-    select: (id, selected = true) =>
-      patch('rowSelection', (prev: RowSelectionState) => ({ ...prev, [id]: selected })),
-    deselect: (id) =>
-      patch('rowSelection', (prev: RowSelectionState) => {
-        const next = { ...prev };
-        delete next[id];
-        return next;
-      }),
-    toggle: (id) =>
-      patch('rowSelection', (prev: RowSelectionState) => ({ ...prev, [id]: !prev[id] })),
-    all: () => {
-      const next: RowSelectionState = {};
-      for (const r of table().getFilteredRowModel().rows) next[r.id] = true;
-      patch('rowSelection', next);
-    },
-    clear: () => patch('rowSelection', {}),
-  };
-
-  const sort: KjSortApi = {
-    get: () => state().sorting,
-    set: (s) => patch('sorting', s),
-    toggle: (columnId, multi = false) => {
-      const col = table().getColumn(columnId);
-      if (!col) return;
-      col.toggleSorting(undefined, multi);
-    },
-    clear: () => patch('sorting', []),
-  };
-
-  const globalFilter: KjGlobalFilterApi = {
-    get: () => state().globalFilter,
-    set: (value) => patch('globalFilter', value),
-    clear: () => patch('globalFilter', ''),
-  };
-
-  const filter: KjFilterApi = {
-    get: (id) => state().columnFilters.find((f) => f.id === id)?.value,
-    set: (id, value) =>
-      patch('columnFilters', (prev: ColumnFiltersState) => {
-        const without = prev.filter((f) => f.id !== id);
-        return value === undefined || value === null || value === ''
-          ? without
-          : [...without, { id, value }];
-      }),
-    clear: (id) =>
-      patch('columnFilters', (prev: ColumnFiltersState) => prev.filter((f) => f.id !== id)),
-    all: () => state().columnFilters,
-    setAll: (filters) => patch('columnFilters', filters),
-    global: globalFilter,
-    clearAll: () => setStateMerge({ columnFilters: [], globalFilter: '' }),
-
-    getModelFor: (id) => {
-      const v = state().columnFilters.find((f) => f.id === id)?.value;
-      return isKjFilterModel(v) ? v : undefined;
-    },
-    setModelFor: (id, model) =>
-      patch('columnFilters', (prev: ColumnFiltersState) => {
-        const without = prev.filter((f) => f.id !== id);
-        return model == null ? without : [...without, { id, value: model }];
-      }),
-    getModel: (): KjGridFilterModel => {
-      const out: Record<string, KjFilterModel> = {};
-      for (const entry of state().columnFilters) {
-        if (isKjFilterModel(entry.value)) out[entry.id] = entry.value;
-      }
-      return out;
-    },
-    setModel: (model) =>
-      patch('columnFilters', () => {
-        if (!model) return [];
-        return Object.entries(model).map(([id, value]) => ({ id, value }));
-      }),
-  };
-
-  const pagination: KjPaginationApi = {
-    get: () => state().pagination,
-    set: (p) => patch('pagination', p),
-    pageCount: () => table().getPageCount(),
-    setPageIndex: (pageIndex) =>
-      patch('pagination', (prev: PaginationState) => ({ ...prev, pageIndex: Math.max(0, pageIndex) })),
-    setPageSize: (pageSize) =>
-      patch('pagination', () => ({ pageIndex: 0, pageSize: Math.max(1, pageSize) })),
-    next: () =>
-      patch('pagination', (prev: PaginationState) => ({
-        ...prev,
-        pageIndex: Math.min(prev.pageIndex + 1, Math.max(0, table().getPageCount() - 1)),
-      })),
-    previous: () =>
-      patch('pagination', (prev: PaginationState) => ({
-        ...prev,
-        pageIndex: Math.max(0, prev.pageIndex - 1),
-      })),
-    first: () => patch('pagination', (prev: PaginationState) => ({ ...prev, pageIndex: 0 })),
-    last: () =>
-      patch('pagination', (prev: PaginationState) => ({
-        ...prev,
-        pageIndex: Math.max(0, table().getPageCount() - 1),
-      })),
-  };
-
-  const expansion: KjExpansionApi<TData> = {
-    get: () => state().expanded,
-    set: (e) => patch('expanded', e),
-    setRow: (id, expanded) =>
-      patch('expanded', (prev: ExpandedState) => {
-        if (prev === true) {
-          const next: Record<string, boolean> = {};
-          for (const r of table().getCoreRowModel().rows) next[r.id] = true;
-          next[id] = expanded;
-          return next;
-        }
-        return { ...prev, [id]: expanded };
-      }),
-    toggle: (id) =>
-      patch('expanded', (prev: ExpandedState) => {
-        if (prev === true) {
-          const next: Record<string, boolean> = {};
-          for (const r of table().getCoreRowModel().rows) next[r.id] = true;
-          next[id] = false;
-          return next;
-        }
-        return { ...prev, [id]: !prev[id] };
-      }),
-    expandAll: () => patch('expanded', true),
-    collapseAll: () => patch('expanded', {}),
-  };
-
-  const grouping: KjGroupingApi = {
-    get: () => state().grouping,
-    set: (g) => patch('grouping', g),
-    add: (id) =>
-      patch('grouping', (prev: GroupingState) => prev.includes(id) ? prev : [...prev, id]),
-    remove: (id) =>
-      patch('grouping', (prev: GroupingState) =>
-        id === undefined ? [] : prev.filter((c) => c !== id),
-      ),
-  };
-
-  const density: KjDensityApi = {
-    get: () => state().density,
-    set: (d: KjTableDensity) => patch('density', d),
-  };
-
-  const gridApi: KjGridApi<TData> = {
-    state,
-    table,
-    rows,
-    selection,
-    sort,
-    filter,
-    pagination,
-    expansion,
-    grouping,
-    density,
-    setState: setStateMerge,
-    resetState,
-  };
-
-  return { gridApi, columnApi };
-}