@humanspeak/svelte-headless-table 5.0.0

package/dist/plugins/addSubRows.d.ts

@@ -0,0 +1,9 @@
+import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+export type ValidChildrenKey<Item> = {
+    [Key in keyof Item]: Item[Key] extends Item[] ? Key : never;
+}[keyof Item];
+export type ValidChildrenFn<Item> = (item: Item) => Item[] | undefined;
+export interface SubRowsConfig<Item> {
+    children: ValidChildrenKey<Item> | ValidChildrenFn<Item>;
+}
+export declare const addSubRows: <Item>({ children }: SubRowsConfig<Item>) => TablePlugin<Item, Record<string, never>, Record<string, never>, NewTablePropSet<never>>;

package/dist/plugins/addSubRows.js

@@ -0,0 +1,28 @@
+import { DataBodyRow, getSubRows } from '../bodyRows.js';
+import { derived } from 'svelte/store';
+const withSubRows = (row, getChildren) => {
+    const subItems = getChildren(row.original);
+    if (subItems === undefined) {
+        return row;
+    }
+    const subRows = getSubRows(subItems, row);
+    row.subRows = subRows.map((row) => withSubRows(row, getChildren));
+    return row;
+};
+export const addSubRows = ({ children }) => () => {
+    const getChildren = children instanceof Function ? children : (item) => item[children];
+    const deriveRows = (rows) => {
+        return derived(rows, ($rows) => {
+            return $rows.map((row) => {
+                if (row.isData()) {
+                    return withSubRows(row, getChildren);
+                }
+                return row;
+            });
+        });
+    };
+    return {
+        pluginState: {},
+        deriveRows
+    };
+};

package/dist/plugins/addTableFilter.d.ts

@@ -0,0 +1,28 @@
+import type { BodyRow } from '../bodyRows.js';
+import type { TablePlugin, NewTablePropSet } from '../types/TablePlugin.js';
+import { type Readable, type Writable } from 'svelte/store';
+export interface TableFilterConfig {
+    fn?: TableFilterFn;
+    initialFilterValue?: string;
+    includeHiddenColumns?: boolean;
+    serverSide?: boolean;
+}
+export interface TableFilterState<Item> {
+    filterValue: Writable<string>;
+    preFilteredRows: Readable<BodyRow<Item>[]>;
+}
+export interface TableFilterColumnOptions<Item> {
+    exclude?: boolean;
+    getFilterValue?: (value: any) => string;
+}
+export type TableFilterFn = (props: TableFilterFnProps) => boolean;
+export type TableFilterFnProps = {
+    filterValue: string;
+    value: string;
+};
+export type TableFilterPropSet = NewTablePropSet<{
+    'tbody.tr.td': {
+        matches: boolean;
+    };
+}>;
+export declare const addTableFilter: <Item>({ fn, initialFilterValue, includeHiddenColumns, serverSide }?: TableFilterConfig) => TablePlugin<Item, TableFilterState<Item>, TableFilterColumnOptions<Item>, TableFilterPropSet>;

package/dist/plugins/addTableFilter.js

@@ -0,0 +1,95 @@
+import { recordSetStore } from '../utils/store.js';
+import { derived, writable } from 'svelte/store';
+import { textPrefixFilter } from './addColumnFilters.js';
+const getFilteredRows = (rows, filterValue, columnOptions, { tableCellMatches, fn, includeHiddenColumns }) => {
+    const $filteredRows = rows
+        // Filter `subRows`
+        .map((row) => {
+        const { subRows } = row;
+        if (subRows === undefined) {
+            return row;
+        }
+        const filteredSubRows = getFilteredRows(subRows, filterValue, columnOptions, {
+            tableCellMatches,
+            fn,
+            includeHiddenColumns
+        });
+        const clonedRow = row.clone();
+        clonedRow.subRows = filteredSubRows;
+        return clonedRow;
+    })
+        .filter((row) => {
+        if ((row.subRows?.length ?? 0) !== 0) {
+            return true;
+        }
+        // An array of booleans, true if the cell matches the filter.
+        const rowCellMatches = Object.values(row.cellForId).map((cell) => {
+            const options = columnOptions[cell.id];
+            if (options?.exclude === true) {
+                return false;
+            }
+            const isHidden = row.cells.find((c) => c.id === cell.id) === undefined;
+            if (isHidden && !includeHiddenColumns) {
+                return false;
+            }
+            if (!cell.isData()) {
+                return false;
+            }
+            let value = cell.value;
+            if (options?.getFilterValue !== undefined) {
+                value = options?.getFilterValue(value);
+            }
+            const matches = fn({ value: String(value), filterValue });
+            if (matches) {
+                const dataRowColId = cell.dataRowColId();
+                if (dataRowColId !== undefined) {
+                    tableCellMatches[dataRowColId] = matches;
+                }
+            }
+            return matches;
+        });
+        // If any cell matches, include in the filtered results.
+        return rowCellMatches.includes(true);
+    });
+    return $filteredRows;
+};
+export const addTableFilter = ({ fn = textPrefixFilter, initialFilterValue = '', includeHiddenColumns = false, serverSide = false } = {}) => ({ columnOptions }) => {
+    const filterValue = writable(initialFilterValue);
+    const preFilteredRows = writable([]);
+    const tableCellMatches = recordSetStore();
+    const pluginState = { filterValue, preFilteredRows };
+    const deriveRows = (rows) => {
+        return derived([rows, filterValue], ([$rows, $filterValue]) => {
+            preFilteredRows.set($rows);
+            tableCellMatches.clear();
+            const $tableCellMatches = {};
+            const $filteredRows = getFilteredRows($rows, $filterValue, columnOptions, {
+                tableCellMatches: $tableCellMatches,
+                fn,
+                includeHiddenColumns
+            });
+            tableCellMatches.set($tableCellMatches);
+            if (serverSide) {
+                return $rows;
+            }
+            return $filteredRows;
+        });
+    };
+    return {
+        pluginState,
+        deriveRows,
+        hooks: {
+            'tbody.tr.td': (cell) => {
+                const props = derived([filterValue, tableCellMatches], ([$filterValue, $tableCellMatches]) => {
+                    const dataRowColId = cell.dataRowColId();
+                    return {
+                        matches: $filterValue !== '' &&
+                            dataRowColId !== undefined &&
+                            ($tableCellMatches[dataRowColId] ?? false)
+                    };
+                });
+                return { props };
+            }
+        }
+    };
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,15 @@
+export * from './addColumnFilters.js';
+export * from './addColumnOrder.js';
+export * from './addDataExport.js';
+export * from './addExpandedRows.js';
+export * from './addFlatten.js';
+export * from './addGridLayout.js';
+export * from './addGroupBy.js';
+export * from './addHiddenColumns.js';
+export * from './addPagination.js';
+export * from './addResizedColumns.js';
+export * from './addSelectedRows.js';
+export * from './addSortBy.js';
+export * from './addSubRows.js';
+export * from './addTableFilter.js';
+export * from '../types/TablePlugin.js';

package/dist/plugins/index.js

@@ -0,0 +1,16 @@
+export * from './addColumnFilters.js';
+export * from './addColumnOrder.js';
+export * from './addDataExport.js';
+export * from './addExpandedRows.js';
+export * from './addFlatten.js';
+export * from './addGridLayout.js';
+export * from './addGroupBy.js';
+export * from './addHiddenColumns.js';
+export * from './addPagination.js';
+export * from './addResizedColumns.js';
+export * from './addSelectedRows.js';
+export * from './addSortBy.js';
+export * from './addSubRows.js';
+export * from './addTableFilter.js';
+// plugin helper types
+export * from '../types/TablePlugin.js';

package/dist/plugins/package.json

@@ -0,0 +1,5 @@
+{
+    "type": "module",
+    "svelte": "./index.js",
+    "types": "../lib/plugins/index.d.ts"
+}

package/dist/tableComponent.d.ts

@@ -0,0 +1,19 @@
+import { type Readable } from 'svelte/store';
+import type { AnyPlugins, ComponentKeys, ElementHook, PluginTablePropSet } from './types/TablePlugin.js';
+import type { TableState } from './createViewModel.js';
+import type { Clonable } from './utils/clone.js';
+export interface TableComponentInit {
+    id: string;
+}
+export declare abstract class TableComponent<Item, Plugins extends AnyPlugins, Key extends ComponentKeys> implements Clonable<TableComponent<Item, Plugins, Key>> {
+    id: string;
+    constructor({ id }: TableComponentInit);
+    private attrsForName;
+    attrs(): Readable<Record<string, unknown>>;
+    private propsForName;
+    props(): Readable<PluginTablePropSet<Plugins>[Key]>;
+    state?: TableState<Item, Plugins>;
+    injectState(state: TableState<Item, Plugins>): void;
+    applyHook(pluginName: string, hook: ElementHook<Record<string, unknown>, Record<string, unknown>>): void;
+    abstract clone(): TableComponent<Item, Plugins, Key>;
+}

package/dist/tableComponent.js

@@ -0,0 +1,35 @@
+import { derived } from 'svelte/store';
+import { derivedKeys } from '@humanspeak/svelte-subscribe';
+import { finalizeAttributes, mergeAttributes } from './utils/attributes.js';
+export class TableComponent {
+    id;
+    constructor({ id }) {
+        this.id = id;
+    }
+    attrsForName = {};
+    attrs() {
+        return derived(Object.values(this.attrsForName), ($attrsArray) => {
+            let $mergedAttrs = {};
+            $attrsArray.forEach(($attrs) => {
+                $mergedAttrs = mergeAttributes($mergedAttrs, $attrs);
+            });
+            return finalizeAttributes($mergedAttrs);
+        });
+    }
+    propsForName = {};
+    props() {
+        return derivedKeys(this.propsForName);
+    }
+    state;
+    injectState(state) {
+        this.state = state;
+    }
+    applyHook(pluginName, hook) {
+        if (hook.props !== undefined) {
+            this.propsForName[pluginName] = hook.props;
+        }
+        if (hook.attrs !== undefined) {
+            this.attrsForName[pluginName] = hook.attrs;
+        }
+    }
+}

package/dist/types/Action.d.ts

@@ -0,0 +1,5 @@
+export type ActionReturnType<Props = any> = {
+    update?: (newProps: Props) => void;
+    destroy?: () => void;
+};
+export type Action<Props> = (node: Element, props?: Props) => ActionReturnType<Props> | void;

package/dist/types/Action.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Entries.d.ts

@@ -0,0 +1,3 @@
+export type Entries<Obj> = NonNullable<{
+    [K in keyof Obj]: [K, NonNullable<Obj[K]>];
+}[keyof Obj]>[];

package/dist/types/Entries.js

@@ -0,0 +1 @@
+export {};

package/dist/types/KeyPath.d.ts

@@ -0,0 +1,6 @@
+export type KeyPath<T, D extends number = 3> = KeyPath_<T, D, []>;
+type KeyPath_<T, D extends number, S extends unknown[]> = D extends S['length'] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string ? `${K}` | Join<K, KeyPath_<T[K], D, [never, ...S]>> : K extends number ? `[${K}]` | Join<`[${K}]`, KeyPath_<T[K], D, [never, ...S]>> : never;
+}[keyof T] : '';
+type Join<K, P> = K extends string | number ? P extends string | number ? P extends `[${string}` ? `${K}${P}` : `${K}${'' extends P ? '' : '.'}${P}` : never : never;
+export {};

package/dist/types/KeyPath.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Label.d.ts

@@ -0,0 +1,8 @@
+import type { RenderConfig } from '@humanspeak/svelte-subscribe';
+import type { DataBodyCell, DisplayBodyCell } from '../bodyCells.js';
+import type { TableState } from '../createViewModel.js';
+import type { HeaderCell } from '../headerCells.js';
+import type { AnyPlugins } from './TablePlugin.js';
+export type DataLabel<Item, Plugins extends AnyPlugins = AnyPlugins, Value = any> = (cell: DataBodyCell<Item, AnyPlugins, Value>, state: TableState<Item, Plugins>) => RenderConfig;
+export type DisplayLabel<Item, Plugins extends AnyPlugins = AnyPlugins> = (cell: DisplayBodyCell<Item>, state: TableState<Item, Plugins>) => RenderConfig;
+export type HeaderLabel<Item, Plugins extends AnyPlugins = AnyPlugins> = RenderConfig | ((cell: HeaderCell<Item, Plugins>, state: TableState<Item, Plugins>) => RenderConfig);

package/dist/types/Label.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Matrix.d.ts

@@ -0,0 +1 @@
+export type Matrix<T> = T[][];

package/dist/types/Matrix.js

@@ -0,0 +1 @@
+export {};

package/dist/types/TablePlugin.d.ts

@@ -0,0 +1,88 @@
+import type { BodyCell, BodyCellAttributes } from '../bodyCells.js';
+import type { BodyRow, BodyRowAttributes } from '../bodyRows.js';
+import type { DataColumn, FlatColumn } from '../columns.js';
+import type { HeaderCell, HeaderCellAttributes } from '../headerCells.js';
+import type { HeaderRow, HeaderRowAttributes } from '../headerRows.js';
+import type { PluginInitTableState, TableAttributes, TableBodyAttributes, TableHeadAttributes } from '../createViewModel.js';
+import type { Readable } from 'svelte/store';
+export type TablePlugin<Item, PluginState, ColumnOptions, TablePropSet extends AnyTablePropSet = AnyTablePropSet, TableAttributeSet extends AnyTableAttributeSet = AnyTableAttributeSet> = (init: TablePluginInit<Item, ColumnOptions>) => TablePluginInstance<Item, PluginState, ColumnOptions, TablePropSet, TableAttributeSet>;
+export type TablePluginInit<Item, ColumnOptions> = {
+    pluginName: string;
+    tableState: PluginInitTableState<Item>;
+    columnOptions: Record<string, ColumnOptions>;
+};
+export type TablePluginInstance<Item, PluginState, ColumnOptions, TablePropSet extends AnyTablePropSet = AnyTablePropSet, TableAttributeSet extends AnyTableAttributeSet = AnyTableAttributeSet> = {
+    pluginState: PluginState;
+    transformFlatColumnsFn?: Readable<TransformFlatColumnsFn<Item>>;
+    deriveFlatColumns?: DeriveFlatColumnsFn<Item>;
+    deriveRows?: DeriveRowsFn<Item>;
+    derivePageRows?: DeriveRowsFn<Item>;
+    deriveTableAttrs?: DeriveFn<TableAttributes<Item>>;
+    deriveTableHeadAttrs?: DeriveFn<TableHeadAttributes<Item>>;
+    deriveTableBodyAttrs?: DeriveFn<TableBodyAttributes<Item>>;
+    columnOptions?: ColumnOptions;
+    hooks?: TableHooks<Item, TablePropSet, TableAttributeSet>;
+};
+export type AnyPlugins = Record<any, TablePlugin<any, any, any, any, any>>;
+export type AnyPluginInstances = Record<any, TablePluginInstance<any, any, any, any, any>>;
+export type TransformFlatColumnsFn<Item> = (flatColumns: DataColumn<Item>[]) => DataColumn<Item>[];
+export type DeriveFlatColumnsFn<Item> = <Col extends FlatColumn<Item>>(flatColumns: Readable<Col[]>) => Readable<Col[]>;
+export type DeriveRowsFn<Item> = <Row extends BodyRow<Item>>(rows: Readable<Row[]>) => Readable<Row[]>;
+export type DeriveFn<T> = (obj: Readable<T>) => Readable<T>;
+export type Components<Item, Plugins extends AnyPlugins = AnyPlugins> = {
+    'thead.tr': HeaderRow<Item, Plugins>;
+    'thead.tr.th': HeaderCell<Item, Plugins>;
+    'tbody.tr': BodyRow<Item, Plugins>;
+    'tbody.tr.td': BodyCell<Item, Plugins>;
+};
+export type AttributesForKey<Item, Plugins extends AnyPlugins = AnyPlugins> = {
+    'thead.tr': HeaderRowAttributes<Item, Plugins>;
+    'thead.tr.th': HeaderCellAttributes<Item, Plugins>;
+    'tbody.tr': BodyRowAttributes<Item, Plugins>;
+    'tbody.tr.td': BodyCellAttributes<Item, Plugins>;
+};
+export type ComponentKeys = keyof Components<unknown>;
+type TablePropSet<PropSet extends {
+    [K in ComponentKeys]?: unknown;
+}> = {
+    [K in ComponentKeys]: PropSet[K];
+};
+export type NewTablePropSet<PropSet extends {
+    [K in ComponentKeys]?: unknown;
+}> = {
+    [K in ComponentKeys]: unknown extends PropSet[K] ? never : PropSet[K];
+};
+export type AnyTablePropSet = TablePropSet<any>;
+type TableAttributeSet<AttributeSet extends {
+    [K in ComponentKeys]?: unknown;
+}> = {
+    [K in ComponentKeys]: AttributeSet[K];
+};
+export type NewTableAttributeSet<AttributeSet extends {
+    [K in ComponentKeys]?: unknown;
+}> = {
+    [K in ComponentKeys]: unknown extends AttributeSet[K] ? never : AttributeSet[K];
+};
+export type AnyTableAttributeSet = TableAttributeSet<any>;
+export type TableHooks<Item, PropSet extends AnyTablePropSet = AnyTablePropSet, AttributeSet extends AnyTableAttributeSet = AnyTableAttributeSet> = {
+    [ComponentKey in keyof Components<Item>]?: (component: Components<Item>[ComponentKey]) => ElementHook<PropSet[ComponentKey], AttributeSet[ComponentKey]>;
+};
+export type ElementHook<Props, Attributes> = {
+    props?: Readable<Props>;
+    attrs?: Readable<Attributes>;
+};
+export type PluginStates<Plugins extends AnyPlugins> = {
+    [K in keyof Plugins]: ReturnType<Plugins[K]>['pluginState'];
+};
+type TablePropSetForPluginKey<Plugins extends AnyPlugins> = {
+    [K in keyof Plugins]: Plugins[K] extends TablePlugin<any, any, any, infer TablePropSet> ? TablePropSet : never;
+};
+export type PluginTablePropSet<Plugins extends AnyPlugins> = {
+    [ComponentKey in ComponentKeys]: {
+        [PluginKey in keyof Plugins]: TablePropSetForPluginKey<Plugins>[PluginKey][ComponentKey];
+    };
+};
+export type PluginColumnConfigs<Plugins extends AnyPlugins> = Partial<{
+    [K in keyof Plugins]: ReturnType<Plugins[K]>['columnOptions'];
+}>;
+export {};

package/dist/types/TablePlugin.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare const getDistinct: <T>(items: T[]) => T[];
+export declare const getDuplicates: <T>(items: T[]) => T[];

package/dist/utils/array.js

@@ -0,0 +1,9 @@
+import { getCounter } from './counter.js';
+export const getDistinct = (items) => {
+    return Array.from(getCounter(items).keys());
+};
+export const getDuplicates = (items) => {
+    return Array.from(getCounter(items).entries())
+        .filter(([, count]) => count !== 1)
+        .map(([key]) => key);
+};

package/dist/utils/attributes.d.ts

@@ -0,0 +1,2 @@
+export declare const mergeAttributes: <T extends Record<string, unknown>, U extends Record<string, unknown>>(a: T, b: U) => T & U;
+export declare const finalizeAttributes: <T extends Record<string, unknown>>(attrs: T) => Record<string, unknown>;

package/dist/utils/attributes.js

@@ -0,0 +1,23 @@
+import { stringifyCss } from './css.js';
+export const mergeAttributes = (a, b) => {
+    if (a.style === undefined && b.style === undefined) {
+        return { ...a, ...b };
+    }
+    return {
+        ...a,
+        ...b,
+        style: {
+            ...(typeof a.style === 'object' ? a.style : {}),
+            ...(typeof b.style === 'object' ? b.style : {})
+        }
+    };
+};
+export const finalizeAttributes = (attrs) => {
+    if (attrs.style === undefined || typeof attrs.style !== 'object') {
+        return attrs;
+    }
+    return {
+        ...attrs,
+        style: stringifyCss(attrs.style)
+    };
+};

package/dist/utils/clone.d.ts

@@ -0,0 +1,13 @@
+export interface Clonable<T> {
+    clone(): T;
+}
+export declare const isClonable: <T>(obj: unknown) => obj is Clonable<T>;
+/**
+ * Create a new instance of a class instance with all properties shallow
+ * copied. This is unsafe as it does not re-run the constructor. Therefore,
+ * cloned instances will share a reference to the same property instances.
+ * @param source The original instance object.
+ * @param props Any additional properties to override.
+ * @returns A new instance object with all properties shallow copied.
+ */
+export declare const unsafeClone: <T extends object>(source: T, props?: Partial<T>) => T;

package/dist/utils/clone.js

@@ -0,0 +1,18 @@
+export const isClonable = (obj) => {
+    return typeof obj.clone === 'function';
+};
+/**
+ * Create a new instance of a class instance with all properties shallow
+ * copied. This is unsafe as it does not re-run the constructor. Therefore,
+ * cloned instances will share a reference to the same property instances.
+ * @param source The original instance object.
+ * @param props Any additional properties to override.
+ * @returns A new instance object with all properties shallow copied.
+ */
+export const unsafeClone = (source, props) => {
+    const clone = Object.assign(Object.create(Object.getPrototypeOf(source)), source);
+    if (props !== undefined) {
+        Object.assign(clone, props);
+    }
+    return clone;
+};

package/dist/utils/compare.d.ts

@@ -0,0 +1,2 @@
+export declare const compare: <T extends string | number>(a: T | T[], b: T | T[]) => number;
+export declare const compareArray: <T extends string | number>(a: T[], b: T[]) => number;

package/dist/utils/compare.js

@@ -0,0 +1,17 @@
+export const compare = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return compareArray(a, b);
+    }
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    return a < b ? -1 : a > b ? 1 : 0;
+};
+export const compareArray = (a, b) => {
+    const minLength = Math.min(a.length, b.length);
+    for (let i = 0; i < minLength; i++) {
+        const order = compare(a[i], b[i]);
+        if (order !== 0)
+            return order;
+    }
+    return 0;
+};

package/dist/utils/counter.d.ts

@@ -0,0 +1 @@
+export declare const getCounter: <T>(items: T[]) => Map<T, number>;

package/dist/utils/counter.js

@@ -0,0 +1,7 @@
+export const getCounter = (items) => {
+    const result = new Map();
+    items.forEach((item) => {
+        result.set(item, (result.get(item) ?? 0) + 1);
+    });
+    return result;
+};

package/dist/utils/css.d.ts

@@ -0,0 +1 @@
+export declare const stringifyCss: (style: Record<string, unknown>) => string;

package/dist/utils/css.js

@@ -0,0 +1,5 @@
+export const stringifyCss = (style) => {
+    return Object.entries(style)
+        .map(([name, value]) => `${name}:${value}`)
+        .join(';');
+};

package/dist/utils/event.d.ts

@@ -0,0 +1 @@
+export declare const isShiftClick: (event: Event) => boolean;

package/dist/utils/event.js

@@ -0,0 +1,5 @@
+export const isShiftClick = (event) => {
+    if (!(event instanceof MouseEvent))
+        return false;
+    return event.shiftKey;
+};

package/dist/utils/filter.d.ts

@@ -0,0 +1,4 @@
+export declare const nonNull: <T>(value: T | null) => value is T;
+export declare const nonUndefined: <T>(value: T | undefined) => value is T;
+export declare const nonNullish: <T>(value: T | null | undefined) => value is T;
+export declare const isNumber: (value: unknown) => value is number;

package/dist/utils/filter.js

@@ -0,0 +1,4 @@
+export const nonNull = (value) => value !== null;
+export const nonUndefined = (value) => value !== undefined;
+export const nonNullish = (value) => value != null;
+export const isNumber = (value) => typeof value === 'number';

package/dist/utils/math.d.ts

@@ -0,0 +1,2 @@
+export declare const sum: (nums: number[]) => number;
+export declare const mean: (nums: number[]) => number;

package/dist/utils/math.js

@@ -0,0 +1,2 @@
+export const sum = (nums) => nums.reduce((a, b) => a + b, 0);
+export const mean = (nums) => (nums.length === 0 ? 0 : sum(nums) / nums.length);

package/dist/utils/matrix.d.ts

@@ -0,0 +1,3 @@
+import type { Matrix } from '../types/Matrix.js';
+export declare const getNullMatrix: (width: number, height: number) => Matrix<null>;
+export declare const getTransposed: <T>(matrix: Matrix<T>) => Matrix<T>;

package/dist/utils/matrix.js

@@ -0,0 +1,23 @@
+export const getNullMatrix = (width, height) => {
+    const result = [];
+    // Use a loop to create a new array instance per row.
+    for (let i = 0; i < height; i++) {
+        result.push(Array(width).fill(null));
+    }
+    return result;
+};
+export const getTransposed = (matrix) => {
+    const height = matrix.length;
+    if (height === 0) {
+        return matrix;
+    }
+    const width = matrix[0].length;
+    const result = getNullMatrix(height, width);
+    for (let i = 0; i < width; i++) {
+        for (let j = 0; j < height; j++) {
+            result[i][j] = matrix[j][i];
+        }
+    }
+    // We guarantee that all elements are filled.
+    return result;
+};

package/dist/utils/store.d.ts

@@ -0,0 +1,37 @@
+import { type Readable, type Writable } from 'svelte/store';
+export type ReadOrWritable<T> = Readable<T> | Writable<T>;
+export declare const isReadable: <T>(value: any) => value is Readable<T>;
+export declare const isWritable: <T>(store: any) => store is Writable<T>;
+export type WritableKeys<T> = {
+    [K in keyof T]: T[K] extends undefined ? Writable<T[K] | undefined> : Writable<T[K]>;
+};
+export type ReadableKeys<T> = {
+    [K in keyof T]: T[K] extends undefined ? Readable<T[K] | undefined> : Readable<T[K]>;
+};
+export type ReadOrWritableKeys<T> = {
+    [K in keyof T]: T[K] extends undefined ? ReadOrWritable<T[K] | undefined> : ReadOrWritable<T[K]>;
+};
+export declare const Undefined: Readable<undefined>;
+export declare const UndefinedAs: <T>() => Readable<T>;
+export interface ToggleOptions {
+    clearOthers?: boolean;
+}
+export interface ArraySetStoreOptions<T> {
+    isEqual?: (a: T, b: T) => boolean;
+}
+export interface ArraySetStore<T> extends Writable<T[]> {
+    toggle: (item: T, options?: ToggleOptions) => void;
+    add: (item: T) => void;
+    remove: (item: T) => void;
+    clear: () => void;
+}
+export declare const arraySetStore: <T>(initial?: T[], { isEqual }?: ArraySetStoreOptions<T>) => ArraySetStore<T>;
+export interface RecordSetStore<T extends string | number> extends Writable<Record<T, boolean>> {
+    toggle: (item: T) => void;
+    add: (item: T) => void;
+    addAll: (items: T[]) => void;
+    remove: (item: T) => void;
+    removeAll: (items: T[]) => void;
+    clear: () => void;
+}
+export declare const recordSetStore: <T extends string | number>(initial?: Record<T, boolean>) => RecordSetStore<T>;