@svelte-lean/table 0.1.0

package/dist/export.js

@@ -0,0 +1,68 @@
+import { valueOf } from './core.js';
+export function toCsv(rows, columns, options = {}) {
+    const delimiter = options.delimiter ?? ',';
+    const escape = (value) => {
+        let text = value instanceof Date ? value.toISOString() : String(value ?? '');
+        if (options.protectFormulas !== false && /^[\s]*[=+\-@\t\r]/.test(text))
+            text = `'${text}`;
+        return /["\r\n]/.test(text) || text.includes(delimiter)
+            ? `"${text.replaceAll('"', '""')}"`
+            : text;
+    };
+    const output = options.headers === false ? [] : [columns.map((c) => escape(c.header)).join(delimiter)];
+    for (const row of rows)
+        output.push(columns
+            .map((c) => escape(c.format ? c.format(valueOf(row, c), row) : valueOf(row, c)))
+            .join(delimiter));
+    return (options.bom === false ? '' : '\uFEFF') + output.join('\r\n');
+}
+export function downloadText(content, filename, type = 'text/csv;charset=utf-8') {
+    const url = URL.createObjectURL(new Blob([content], { type }));
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    link.click();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+/** RFC-style quoted cells, including embedded line breaks and escaped quotes. */
+export function parseDelimited(text, delimiter = ',') {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let quoted = false;
+    const source = text.replace(/^\uFEFF/, '');
+    for (let i = 0; i < source.length; i++) {
+        const char = source[i];
+        if (char === '"') {
+            if (quoted && source[i + 1] === '"') {
+                cell += '"';
+                i++;
+            }
+            else if (!quoted && cell.length > 0)
+                cell += char;
+            else
+                quoted = !quoted;
+        }
+        else if (char === delimiter && !quoted) {
+            row.push(cell);
+            cell = '';
+        }
+        else if ((char === '\n' || char === '\r') && !quoted) {
+            if (char === '\r' && source[i + 1] === '\n')
+                i++;
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = '';
+        }
+        else
+            cell += char;
+    }
+    if (quoted)
+        throw new Error('Unclosed quoted field.');
+    if (cell.length || row.length) {
+        row.push(cell);
+        rows.push(row);
+    }
+    return rows;
+}

package/dist/grouping.d.ts

@@ -0,0 +1,5 @@
+import type { Aggregate, ModelContext, RowModel } from './types.js';
+export declare function aggregate(values: unknown[], operation?: Aggregate): unknown;
+/** Optional model: register by passing getRowModel={groupBy(['team'])}. */
+export declare function groupBy<T>(ids: readonly string[]): (context: ModelContext<T>) => RowModel<T>;
+export declare function summarize<T>(rows: readonly T[], columns: readonly import('./types.js').Column<T>[]): Record<string, unknown>;

package/dist/grouping.js

@@ -0,0 +1,71 @@
+import { leafColumns, paginateNodes, prepareRows, valueOf } from './core.js';
+export function aggregate(values, operation = 'count') {
+    if (typeof operation === 'function')
+        return operation(values);
+    if (operation === 'count')
+        return values.length;
+    const numbers = values.filter((v) => typeof v === 'number' && Number.isFinite(v));
+    if (!numbers.length)
+        return operation === 'sum' ? 0 : null;
+    if (operation === 'min')
+        return numbers.reduce((a, b) => Math.min(a, b));
+    if (operation === 'max')
+        return numbers.reduce((a, b) => Math.max(a, b));
+    const sum = numbers.reduce((a, b) => a + b, 0);
+    return operation === 'mean' ? sum / numbers.length : sum;
+}
+/** Optional model: register by passing getRowModel={groupBy(['team'])}. */
+export function groupBy(ids) {
+    return (context) => {
+        if (context.getSubRows)
+            throw new Error('Grouping and nested tree input are separate row models.');
+        const columns = leafColumns(context.columns);
+        const roots = prepareRows(context);
+        const occupied = new Set(roots.map((row) => row.id));
+        const build = (nodes, depth, path) => {
+            const column = columns.find((c) => c.id === ids[depth]);
+            if (!column)
+                return nodes.map((node) => ({ ...node, depth }));
+            const buckets = new Map();
+            for (const node of nodes) {
+                if (node.data === undefined)
+                    continue;
+                const key = valueOf(node.data, column);
+                const bucket = buckets.get(key) ?? [];
+                bucket.push(node);
+                buckets.set(key, bucket);
+            }
+            return [...buckets].map(([key, members]) => {
+                const nextPath = [...path, `${column.id}:${typeof key}:${JSON.stringify(key)}`];
+                let id = `__group:${JSON.stringify(nextPath)}`;
+                while (occupied.has(id))
+                    id += ':';
+                occupied.add(id);
+                const aggregates = Object.fromEntries(columns
+                    .filter((c) => c.aggregate)
+                    .map((c) => [
+                    c.id,
+                    aggregate(members.map((n) => valueOf(n.data, c)), c.aggregate)
+                ]));
+                return {
+                    id,
+                    kind: 'group',
+                    label: `${column.header}: ${String(key ?? '—')}`,
+                    depth,
+                    count: members.length,
+                    aggregates,
+                    children: build(members, depth + 1, nextPath)
+                };
+            });
+        };
+        return paginateNodes(build(roots, 0, []), context);
+    };
+}
+export function summarize(rows, columns) {
+    return Object.fromEntries(leafColumns(columns)
+        .filter((c) => c.aggregate)
+        .map((c) => [
+        c.id,
+        aggregate(rows.map((row) => valueOf(row, c)), c.aggregate)
+    ]));
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as DataTable } from './table/data-table.svelte';
+export { en, tr } from './messages.js';
+export { defaultState, createRowModel, valueOf, visibleColumns, toggleSort, toggleSelection } from './core.js';
+export { createTable } from './table.svelte.js';
+export type { MaybeGetter, SelectionMode, Table, TableOptions } from './table.svelte.js';
+export type { HeaderCell } from './core.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { default as DataTable } from './table/data-table.svelte';
+export { en, tr } from './messages.js';
+export { defaultState, createRowModel, valueOf, visibleColumns, toggleSort, toggleSelection } from './core.js';
+export { createTable } from './table.svelte.js';

package/dist/messages.d.ts

@@ -0,0 +1,3 @@
+import type { TableMessages } from './types.js';
+export declare const en: TableMessages;
+export declare const tr: TableMessages;

package/dist/messages.js

@@ -0,0 +1,72 @@
+export const en = {
+    search: 'Search rows',
+    columns: 'Columns',
+    selectAll: 'Select all eligible rows',
+    selectRow: 'Select row',
+    expand: 'Expand row',
+    collapse: 'Collapse row',
+    previous: 'Previous page',
+    next: 'Next page',
+    first: 'First page',
+    last: 'Last page',
+    pageSize: 'Rows per page',
+    loading: 'Loading rows…',
+    empty: 'No matching rows',
+    retry: 'Retry',
+    save: 'Save',
+    cancel: 'Cancel',
+    edit: 'Edit',
+    resize: 'Resize',
+    moveLeft: 'Move earlier',
+    moveRight: 'Move later',
+    moveUp: 'Move up',
+    moveDown: 'Move down',
+    pin: 'Pin',
+    unpin: 'Unpinned',
+    pinLeft: 'Pin start',
+    pinRight: 'Pin end',
+    allRows: 'All',
+    sortOrder: 'Sort order',
+    selectionHeader: 'Selection',
+    expandHeader: 'Details',
+    filter: (column) => `Filter ${column}`,
+    page: (page, pages, rows) => rows === undefined ? `Page ${page} of ${pages}` : `Page ${page} of ${pages} · ${rows} rows`,
+    pageNumber: (page) => `Page ${page}`,
+    selected: (count) => `${count} selected`
+};
+export const tr = {
+    search: 'Satırlarda ara',
+    columns: 'Sütunlar',
+    selectAll: 'Uygun satırların tümünü seç',
+    selectRow: 'Satırı seç',
+    expand: 'Satırı aç',
+    collapse: 'Satırı kapat',
+    previous: 'Önceki sayfa',
+    next: 'Sonraki sayfa',
+    first: 'İlk sayfa',
+    last: 'Son sayfa',
+    pageSize: 'Sayfadaki satır',
+    loading: 'Satırlar yükleniyor…',
+    empty: 'Eşleşen satır yok',
+    retry: 'Yeniden dene',
+    save: 'Kaydet',
+    cancel: 'Vazgeç',
+    edit: 'Düzenle',
+    resize: 'Boyutlandır',
+    moveLeft: 'Öne taşı',
+    moveRight: 'Arkaya taşı',
+    moveUp: 'Yukarı taşı',
+    moveDown: 'Aşağı taşı',
+    pin: 'Sabitle',
+    unpin: 'Sabit değil',
+    pinLeft: 'Başa sabitle',
+    pinRight: 'Sona sabitle',
+    allRows: 'Tümü',
+    sortOrder: 'Sıralama önceliği',
+    selectionHeader: 'Seçim',
+    expandHeader: 'Ayrıntılar',
+    filter: (column) => `${column} filtrele`,
+    page: (page, pages, rows) => rows === undefined ? `${page} / ${pages} sayfa` : `${page} / ${pages} sayfa · ${rows} satır`,
+    pageNumber: (page) => `${page}. sayfa`,
+    selected: (count) => `${count} seçili`
+};

package/dist/pivot.d.ts

@@ -0,0 +1,19 @@
+import type { Aggregate, Column } from './types.js';
+export interface PivotOptions<T> {
+    row: (item: T) => string;
+    column: (item: T) => string;
+    value: (item: T) => unknown;
+    aggregate?: Aggregate;
+    rowLabel?: string;
+}
+export interface PivotRow {
+    id: string;
+    label: string;
+    values: Record<string, unknown>;
+    total: unknown;
+}
+/** No workbook, chart or grid runtime dependencies are needed for a pivot. */
+export declare function pivot<T>(data: readonly T[], options: PivotOptions<T>): {
+    data: PivotRow[];
+    columns: Column<PivotRow>[];
+};

package/dist/pivot.js

@@ -0,0 +1,33 @@
+import { aggregate } from './grouping.js';
+/** No workbook, chart or grid runtime dependencies are needed for a pivot. */
+export function pivot(data, options) {
+    const columnKeys = [...new Set(data.map(options.column))];
+    const buckets = new Map();
+    for (const item of data) {
+        const row = options.row(item), col = options.column(item);
+        const bucket = buckets.get(row) ?? new Map();
+        const values = bucket.get(col) ?? [];
+        values.push(options.value(item));
+        bucket.set(col, values);
+        buckets.set(row, bucket);
+    }
+    const op = options.aggregate ?? 'sum';
+    return {
+        data: [...buckets].map(([label, bucket]) => ({
+            id: label,
+            label,
+            values: Object.fromEntries(columnKeys.map((key, index) => [`p${index}`, aggregate(bucket.get(key) ?? [], op)])),
+            total: aggregate([...bucket.values()].flat(), op)
+        })),
+        columns: [
+            { id: 'label', header: options.rowLabel ?? 'Group', accessor: 'label', pin: 'left' },
+            ...columnKeys.map((key, index) => ({
+                id: `p${index}`,
+                header: key,
+                accessor: (row) => row.values[`p${index}`],
+                align: 'end'
+            })),
+            { id: 'total', header: 'Total', accessor: 'total', align: 'end' }
+        ]
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+import type { TableState } from './types.js';
+export interface ServerResult<T> {
+    rows: T[];
+    total: number;
+}
+export interface ServerSnapshot<T> {
+    rows: T[];
+    total: number;
+    loading: boolean;
+    error: string | null;
+}
+/** Abort plus sequence guard: even a transport ignoring AbortSignal cannot overwrite newer data. */
+export declare function createDataSource<T>(load: (state: TableState, signal: AbortSignal) => Promise<ServerResult<T>>, onChange: (snapshot: ServerSnapshot<T>) => void): {
+    request(state: TableState): Promise<void>;
+    dispose(): void;
+};

package/dist/server.js

@@ -0,0 +1,39 @@
+/** Abort plus sequence guard: even a transport ignoring AbortSignal cannot overwrite newer data. */
+export function createDataSource(load, onChange) {
+    let controller;
+    let sequence = 0;
+    let disposed = false;
+    let snapshot = { rows: [], total: 0, loading: false, error: null };
+    const emit = (patch) => {
+        snapshot = { ...snapshot, ...patch };
+        onChange(snapshot);
+    };
+    return {
+        async request(state) {
+            if (disposed)
+                return;
+            controller?.abort();
+            controller = new AbortController();
+            const current = ++sequence;
+            emit({ loading: true, error: null });
+            try {
+                const result = await load(state, controller.signal);
+                if (current !== sequence || disposed)
+                    return;
+                if (!Array.isArray(result.rows) || !Number.isFinite(result.total) || result.total < 0)
+                    throw new Error('Invalid data source result.');
+                emit({ rows: result.rows, total: result.total, loading: false });
+            }
+            catch (error) {
+                if (current !== sequence || disposed)
+                    return;
+                emit({ loading: false, error: error instanceof Error ? error.message : String(error) });
+            }
+        },
+        dispose() {
+            disposed = true;
+            sequence++;
+            controller?.abort();
+        }
+    };
+}

package/dist/state.d.ts

@@ -0,0 +1,4 @@
+import type { Column, TableState } from './types.js';
+export declare function serializeState(state: TableState): string;
+/** Persist presentation, not data. Unknown columns and malformed values are discarded. */
+export declare function restoreState<T>(serialized: string, columns: readonly Column<T>[]): TableState;

package/dist/state.js

@@ -0,0 +1,66 @@
+import { defaultState, leafColumns } from './core.js';
+export function serializeState(state) {
+    return JSON.stringify({ version: 1, state });
+}
+/** Persist presentation, not data. Unknown columns and malformed values are discarded. */
+export function restoreState(serialized, columns) {
+    let raw;
+    try {
+        raw = JSON.parse(serialized);
+    }
+    catch {
+        return defaultState();
+    }
+    if (!raw ||
+        typeof raw !== 'object' ||
+        !('version' in raw) ||
+        raw.version !== 1 ||
+        !('state' in raw) ||
+        !raw.state ||
+        typeof raw.state !== 'object')
+        return defaultState();
+    const source = raw.state;
+    const known = new Set(leafColumns(columns).map((c) => c.id));
+    const ids = (v) => Array.isArray(v)
+        ? [...new Set(v.filter((id) => typeof id === 'string' && known.has(id)))]
+        : [];
+    const keys = (v) => Array.isArray(v)
+        ? [
+            ...new Set(v.filter((id) => typeof id === 'string' || (typeof id === 'number' && Number.isFinite(id))))
+        ]
+        : [];
+    const state = defaultState();
+    state.hidden = ids(source.hidden);
+    state.order = ids(source.order);
+    state.search = typeof source.search === 'string' ? source.search : '';
+    for (const key of ['pageIndex', 'pageSize'])
+        if (typeof source[key] === 'number' && Number.isFinite(source[key]))
+            state[key] = Math.max(0, Math.floor(source[key]));
+    state.selection = keys(source.selection);
+    state.expanded = keys(source.expanded);
+    if (Array.isArray(source.sorting))
+        state.sorting = source.sorting.filter((s) => s && known.has(s.id) && typeof s.desc === 'boolean');
+    const operators = new Set([
+        'contains',
+        'equals',
+        'startsWith',
+        'gt',
+        'gte',
+        'lt',
+        'lte',
+        'between',
+        'in',
+        'empty'
+    ]);
+    if (Array.isArray(source.filters))
+        state.filters = source.filters.filter((f) => f && known.has(f.id) && (f.operator === undefined || operators.has(f.operator)));
+    if (source.widths && typeof source.widths === 'object')
+        state.widths = Object.fromEntries(Object.entries(source.widths).filter(([id, value]) => known.has(id) && typeof value === 'number' && Number.isFinite(value) && value > 0));
+    if (source.pinning && typeof source.pinning === 'object')
+        state.pinning = Object.fromEntries(Object.entries(source.pinning).filter(([id, value]) => known.has(id) && (value === false || value === 'left' || value === 'right')));
+    if (source.rowPinning && typeof source.rowPinning === 'object') {
+        const p = source.rowPinning;
+        state.rowPinning = { top: keys(p.top), bottom: keys(p.bottom) };
+    }
+    return state;
+}