@urbicon-ui/table 6.1.4

package/dist/factories/ColumnValidation.js

@@ -0,0 +1,188 @@
+import { resolveColumnId } from '../utils';
+/**
+ * Validation utilities for column configurations.
+ *
+ * In the 2.x column shape, identification is the column's `id` (with a
+ * string-accessor fallback). Validation enforces that every column resolves
+ * to a non-empty id, that ids are unique within a set, and that no column
+ * fails the basic structural checks.
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: intentional namespace grouping of column-validation utilities.
+export class ColumnValidation {
+    /**
+     * Validates a single column configuration
+     */
+    static validateColumn(column) {
+        const errors = [];
+        // Identifier validation — `id` is the canonical identifier; for
+        // string-accessor columns it may be omitted (falls back to the accessor).
+        const id = resolveColumnId(column);
+        if (!id || typeof id !== 'string') {
+            errors.push('Column requires a non-empty `id` (or a string `accessor` to default the id from)');
+        }
+        // Accessor validation — synthetic columns omit it, but when present it
+        // must be either a string or a function.
+        if (column.accessor !== undefined) {
+            const accessorType = typeof column.accessor;
+            if (accessorType !== 'string' && accessorType !== 'function') {
+                errors.push('Column `accessor` must be a string property name or a function');
+            }
+        }
+        // Title validation — empty string is the documented idiom for icon-only
+        // columns (e.g. `{ id: 'actions', title: '', component: ActionButtons }`),
+        // so only the type is enforced, not non-emptiness.
+        if (typeof column.title !== 'string') {
+            errors.push("Column `title` must be a string (use '' for icon-only columns)");
+        }
+        // Width validation
+        if (column.width && typeof column.width !== 'string') {
+            errors.push('Column width must be a string');
+        }
+        // MinWidth validation
+        if (column.minWidth && typeof column.minWidth !== 'string') {
+            errors.push('Column minWidth must be a string');
+        }
+        // Priority validation
+        if (column.priority && ![1, 2, 3].includes(column.priority)) {
+            errors.push('Column priority must be 1, 2, or 3');
+        }
+        // Align validation
+        if (column.align && !['left', 'center', 'right'].includes(column.align)) {
+            errors.push('Column align must be left, center, or right');
+        }
+        // DataType validation (only meaningful on data columns)
+        const validDataTypes = ['text', 'number', 'date', 'boolean', 'email', 'url'];
+        if ('dataType' in column && column.dataType && !validDataTypes.includes(column.dataType)) {
+            errors.push(`Column dataType must be one of: ${validDataTypes.join(', ')}`);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Validates an array of columns
+     */
+    static validateColumns(columns) {
+        const errors = [];
+        const ids = new Set();
+        // Check for empty array
+        if (!Array.isArray(columns) || columns.length === 0) {
+            errors.push('Columns array is required and must not be empty');
+            return { isValid: false, errors };
+        }
+        // Validate each column and check for duplicate ids
+        columns.forEach((column, index) => {
+            const validation = ColumnValidation.validateColumn(column);
+            if (!validation.isValid) {
+                errors.push(`Column ${index}: ${validation.errors.join(', ')}`);
+            }
+            const id = resolveColumnId(column);
+            if (id && ids.has(id)) {
+                errors.push(`Duplicate column id found: ${id}`);
+            }
+            else if (id) {
+                ids.add(id);
+            }
+        });
+        // Check for at least one visible column (priority 1 or 2)
+        const hasVisibleColumns = columns.some((col) => !col.priority || col.priority <= 2);
+        if (!hasVisibleColumns) {
+            errors.push('At least one column should have priority 1 or 2 for mobile visibility');
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Validates column configuration for specific use cases
+     */
+    static validateForUseCase(columns, useCase) {
+        const warnings = [];
+        switch (useCase) {
+            case 'mobile': {
+                // Check for too many priority 1 columns
+                const priority1Count = columns.filter((col) => col.priority === 1).length;
+                if (priority1Count > 2) {
+                    warnings.push(`Mobile: ${priority1Count} priority 1 columns may cause horizontal scrolling`);
+                }
+                // Check for very wide columns
+                const wideColumns = columns.filter((col) => col.width?.includes('px') && parseInt(col.width, 10) > 200);
+                if (wideColumns.length > 0) {
+                    warnings.push('Mobile: Some columns have fixed widths > 200px which may cause layout issues');
+                }
+                break;
+            }
+            case 'desktop': {
+                // Check for flex columns without proper balance
+                const flexColumns = columns.filter((col) => col.flex === true);
+                const fixedColumns = columns.filter((col) => col.width && !col.flex);
+                if (flexColumns.length === 0 && fixedColumns.length === columns.length) {
+                    warnings.push('Desktop: Consider adding at least one flexible column for better space utilization');
+                }
+                break;
+            }
+            case 'print': {
+                // Check for interactive elements
+                const interactiveColumns = columns.filter((col) => resolveColumnId(col) === 'actions' || col.component);
+                if (interactiveColumns.length > 0) {
+                    warnings.push('Print: Interactive columns may not display well in print media');
+                }
+                break;
+            }
+        }
+        return {
+            isValid: true,
+            warnings
+        };
+    }
+}
+/**
+ * Helper functions for common validation patterns
+ */
+export const ValidationHelpers = {
+    /**
+     * Checks if columns are suitable for mobile display
+     */
+    isMobileFriendly: (columns) => {
+        const priority1Count = columns.filter((col) => col.priority === 1).length;
+        return priority1Count <= 2;
+    },
+    /**
+     * Gets recommended mobile columns (priority 1 and 2)
+     */
+    getMobileColumns: (columns) => {
+        return columns.filter((col) => !col.priority || col.priority <= 2);
+    },
+    /**
+     * Suggests improvements for column configuration
+     */
+    suggestImprovements: (columns) => {
+        const suggestions = [];
+        // Check for missing priorities
+        const noPriorityCount = columns.filter((col) => !col.priority).length;
+        if (noPriorityCount > 0) {
+            suggestions.push(`Consider adding priority to ${noPriorityCount} columns for better responsive behavior`);
+        }
+        // Check for actions column placement
+        const actionsColumn = columns.find((col) => resolveColumnId(col) === 'actions');
+        const actionsIndex = actionsColumn ? columns.indexOf(actionsColumn) : -1;
+        if (actionsColumn && actionsIndex !== columns.length - 1) {
+            suggestions.push('Actions column is typically placed as the last column');
+        }
+        // Check for sortable/searchable balance — synthetic columns are
+        // structurally excluded from both via the Column shape, so we only
+        // count data columns here.
+        const dataColumns = columns.filter((col) => col.accessor !== undefined);
+        const sortableCount = dataColumns.filter((col) => col.sortable !== false).length;
+        const searchableCount = dataColumns.filter((col) => col.searchable !== false).length;
+        if (sortableCount === 0) {
+            suggestions.push('Consider making at least one column sortable for better UX');
+        }
+        if (searchableCount === 0) {
+            suggestions.push('Consider making at least one column searchable for better UX');
+        }
+        return suggestions;
+    }
+};

package/dist/factories/TableColumns.d.ts

@@ -0,0 +1,97 @@
+import type { Column, DataAccessor } from '../types/tableTypes';
+import { type ActionButtonsProps } from '../cells/ActionButtons.svelte';
+import { type CopyButtonProps } from '../cells/CopyButton.svelte';
+import { type CustomCellProps } from '../cells/CustomCell.svelte';
+import { type DateCellProps } from '../cells/DateCell.svelte';
+import { type LinkCellProps } from '../cells/LinkCell.svelte';
+import { type NumberCellProps } from '../cells/NumberCell.svelte';
+import { type StatusBadgeProps } from '../cells/StatusBadge.svelte';
+import { type UserAvatarProps } from '../cells/UserAvatar.svelte';
+/** Common column configuration properties shared across all factory methods. */
+type BaseColumnProps = {
+    sortable?: boolean;
+    searchable?: boolean;
+    groupable?: boolean;
+    summable?: boolean;
+    dataType?: 'text' | 'number' | 'date' | 'boolean' | 'email' | 'url';
+    priority?: 1 | 2 | 3;
+    align?: 'left' | 'center' | 'right';
+    width?: string;
+    minWidth?: string;
+    flex?: boolean;
+};
+type UserAvatarFactoryOptions<Item> = BaseColumnProps & Partial<Omit<UserAvatarProps<Item>, 'item'>>;
+type ActionButtonsFactoryOptions<Item> = BaseColumnProps & Omit<ActionButtonsProps<Item>, 'item'>;
+type StatusBadgeFactoryOptions<Item> = BaseColumnProps & Partial<Omit<StatusBadgeProps<Item>, 'item'>>;
+type CopyButtonFactoryOptions<Item> = BaseColumnProps & Partial<Omit<CopyButtonProps<Item>, 'item'>>;
+type CustomCellFactoryOptions<Item> = BaseColumnProps & Partial<Omit<CustomCellProps<Item>, 'item'>>;
+type DateCellFactoryOptions<Item> = BaseColumnProps & Partial<Omit<DateCellProps<Item>, 'item'>>;
+type LinkCellFactoryOptions<Item> = BaseColumnProps & Partial<Omit<LinkCellProps<Item>, 'item'>>;
+type NumberCellFactoryOptions<Item> = BaseColumnProps & Partial<Omit<NumberCellProps<Item>, 'item'>>;
+/**
+ * Column factory functions for common cell types.
+ *
+ * Data-column factories (everything except {@link TableColumns.actions}) bind
+ * the cell to a primitive-valued property via a string accessor. The
+ * property name doubles as the column id — search, sort, group and summary
+ * all read through the accessor, so values stay consistent across views.
+ *
+ * The synthetic {@link TableColumns.actions} factory produces a column
+ * without an accessor — by definition it is not searchable, sortable, or
+ * groupable, and the type system reflects that.
+ *
+ * @example
+ * ```ts
+ * const columns = [
+ *   TableColumns.userAvatar<User>('name', 'Employee'),
+ *   TableColumns.status<User>('status'),
+ *   TableColumns.number<User>('salary', 'Salary', { summable: true }),
+ *   TableColumns.date<User>('hireDate', 'Hired'),
+ *   TableColumns.actions<User>('', { onView: (item) => goto(`/users/${item.id}`) }),
+ * ];
+ * ```
+ */
+export declare const TableColumns: {
+    /**
+     * Creates a UserAvatar column displaying an avatar alongside user name/email.
+     */
+    userAvatar: <Item>(accessor: DataAccessor<Item>, title?: string, options?: UserAvatarFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates an ActionButtons column (view/edit/delete). Synthetic — no data
+     * accessor, structurally excluded from search/sort/group.
+     */
+    actions: <Item>(title?: string, options?: ActionButtonsFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a StatusBadge column displaying a colored badge. Centered, groupable.
+     */
+    status: <Item>(accessor: DataAccessor<Item>, title?: string, options?: StatusBadgeFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a CopyButton column with a click-to-copy button. Centered, non-sortable.
+     */
+    copy: <Item>(accessor: DataAccessor<Item>, title?: string, options?: CopyButtonFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a CustomCell column for generic text content with optional styling.
+     */
+    custom: <Item>(accessor: DataAccessor<Item>, title: string, options?: CustomCellFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a DateCell column with locale-aware date formatting.
+     */
+    date: <Item>(accessor: DataAccessor<Item>, title?: string, options?: DateCellFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a LinkCell column rendering an anchor tag.
+     */
+    link: <Item>(accessor: DataAccessor<Item>, title?: string, options?: LinkCellFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a NumberCell column with locale-aware number formatting.
+     */
+    number: <Item>(accessor: DataAccessor<Item>, title?: string, options?: NumberCellFactoryOptions<Item>) => Column<Item>;
+    /**
+     * Creates a plain text column with optional formatter. Auto-detects
+     * numeric-named accessors (e.g. `salary`, `amount`) and adjusts
+     * alignment/summability.
+     */
+    text: <Item>(accessor: DataAccessor<Item>, title: string, options?: BaseColumnProps & {
+        formatter?: (value: unknown, item: Item) => string;
+    }) => Column<Item>;
+};
+export type { ActionButtonsFactoryOptions, BaseColumnProps, CopyButtonFactoryOptions, CustomCellFactoryOptions, DateCellFactoryOptions, LinkCellFactoryOptions, NumberCellFactoryOptions, StatusBadgeFactoryOptions, UserAvatarFactoryOptions };

package/dist/factories/TableColumns.js

@@ -0,0 +1,262 @@
+import ActionButtons, {} from '../cells/ActionButtons.svelte';
+import CopyButton, {} from '../cells/CopyButton.svelte';
+import CustomCell, {} from '../cells/CustomCell.svelte';
+import DateCell, {} from '../cells/DateCell.svelte';
+import LinkCell, {} from '../cells/LinkCell.svelte';
+import NumberCell, {} from '../cells/NumberCell.svelte';
+import StatusBadge, {} from '../cells/StatusBadge.svelte';
+import UserAvatar, {} from '../cells/UserAvatar.svelte';
+// ===================================================================
+// Factory implementation
+// ===================================================================
+/**
+ * Column factory functions for common cell types.
+ *
+ * Data-column factories (everything except {@link TableColumns.actions}) bind
+ * the cell to a primitive-valued property via a string accessor. The
+ * property name doubles as the column id — search, sort, group and summary
+ * all read through the accessor, so values stay consistent across views.
+ *
+ * The synthetic {@link TableColumns.actions} factory produces a column
+ * without an accessor — by definition it is not searchable, sortable, or
+ * groupable, and the type system reflects that.
+ *
+ * @example
+ * ```ts
+ * const columns = [
+ *   TableColumns.userAvatar<User>('name', 'Employee'),
+ *   TableColumns.status<User>('status'),
+ *   TableColumns.number<User>('salary', 'Salary', { summable: true }),
+ *   TableColumns.date<User>('hireDate', 'Hired'),
+ *   TableColumns.actions<User>('', { onView: (item) => goto(`/users/${item.id}`) }),
+ * ];
+ * ```
+ */
+export const TableColumns = {
+    /**
+     * Creates a UserAvatar column displaying an avatar alongside user name/email.
+     */
+    userAvatar: (accessor, title = 'User', options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: UserAvatar,
+            componentProps: (item) => ({
+                item,
+                ...componentProps
+            }),
+            sortable: sortable ?? true,
+            searchable: searchable ?? true,
+            groupable: groupable ?? true,
+            summable: summable ?? false,
+            dataType: dataType ?? 'text',
+            priority,
+            align,
+            width,
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates an ActionButtons column (view/edit/delete). Synthetic — no data
+     * accessor, structurally excluded from search/sort/group.
+     */
+    actions: (title = 'Actions', options = {}) => {
+        const { priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            id: 'actions',
+            title,
+            component: ActionButtons,
+            componentProps: (item) => ({
+                item,
+                ...componentProps
+            }),
+            priority,
+            align: align ?? 'right',
+            width: width ?? '120px',
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a StatusBadge column displaying a colored badge. Centered, groupable.
+     */
+    status: (accessor, title = 'Status', options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: StatusBadge,
+            componentProps: (item) => ({
+                item,
+                statusKey: accessor,
+                ...componentProps
+            }),
+            sortable: sortable ?? true,
+            searchable: searchable ?? true,
+            groupable: groupable ?? true,
+            summable: summable ?? false,
+            dataType: dataType ?? 'text',
+            priority,
+            align: align ?? 'center',
+            width: width ?? '100px',
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a CopyButton column with a click-to-copy button. Centered, non-sortable.
+     */
+    copy: (accessor, title = 'Copy', options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: CopyButton,
+            componentProps: (item) => ({
+                item,
+                valueKey: accessor,
+                ...componentProps
+            }),
+            sortable: sortable ?? false,
+            searchable: searchable ?? false,
+            groupable: groupable ?? false,
+            summable: summable ?? false,
+            dataType: dataType ?? 'text',
+            priority,
+            align: align ?? 'center',
+            width: width ?? '100px',
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a CustomCell column for generic text content with optional styling.
+     */
+    custom: (accessor, title, options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: CustomCell,
+            componentProps: (item) => ({
+                item,
+                ...componentProps
+            }),
+            sortable: sortable ?? true,
+            searchable: searchable ?? true,
+            groupable: groupable ?? false,
+            summable: summable ?? false,
+            dataType: dataType ?? 'text',
+            priority,
+            align,
+            width,
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a DateCell column with locale-aware date formatting.
+     */
+    date: (accessor, title = 'Date', options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: DateCell,
+            componentProps: (item) => ({
+                item,
+                dateKey: accessor,
+                ...componentProps
+            }),
+            sortable: sortable ?? true,
+            searchable: searchable ?? true,
+            groupable: groupable ?? true,
+            summable: summable ?? false,
+            dataType: dataType ?? 'date',
+            priority,
+            align,
+            width,
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a LinkCell column rendering an anchor tag.
+     */
+    link: (accessor, title = 'Link', options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: LinkCell,
+            componentProps: (item) => ({
+                item,
+                urlKey: accessor,
+                ...componentProps
+            }),
+            sortable: sortable ?? true,
+            searchable: searchable ?? true,
+            groupable: groupable ?? false,
+            summable: summable ?? false,
+            dataType: dataType ?? 'url',
+            priority,
+            align,
+            width,
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a NumberCell column with locale-aware number formatting.
+     */
+    number: (accessor, title = 'Number', options = {}) => {
+        const { sortable, searchable, groupable, summable, dataType, priority, align, width, minWidth, flex, ...componentProps } = options;
+        return {
+            accessor,
+            title,
+            component: NumberCell,
+            componentProps: (item) => ({
+                item,
+                valueKey: accessor,
+                ...componentProps
+            }),
+            sortable: sortable ?? true,
+            searchable: searchable ?? true,
+            groupable: groupable ?? true,
+            summable: summable ?? true,
+            dataType: dataType ?? 'number',
+            priority,
+            align: align ?? 'right',
+            width,
+            minWidth,
+            flex
+        };
+    },
+    /**
+     * Creates a plain text column with optional formatter. Auto-detects
+     * numeric-named accessors (e.g. `salary`, `amount`) and adjusts
+     * alignment/summability.
+     */
+    text: (accessor, title, options = {}) => {
+        const { formatter, ...columnProps } = options;
+        const accessorStr = String(accessor);
+        const isNumericKey = /^(age|salary|price|amount|count|number|projectsCompleted|rating|score)$/i.test(accessorStr);
+        return {
+            accessor,
+            title,
+            formatter,
+            sortable: columnProps.sortable ?? true,
+            searchable: columnProps.searchable ?? true,
+            summable: columnProps.summable ?? (columnProps.dataType === 'number' || isNumericKey),
+            dataType: columnProps.dataType ?? (isNumericKey ? 'number' : 'text'),
+            groupable: columnProps.groupable ?? true,
+            priority: columnProps.priority,
+            align: columnProps.align ?? (isNumericKey ? 'right' : 'left'),
+            width: columnProps.width,
+            minWidth: columnProps.minWidth,
+            flex: columnProps.flex
+        };
+    }
+};

package/dist/factories/TypedColumnBuilder.d.ts

@@ -0,0 +1,41 @@
+import type { ActionButtonsFactoryOptions, BaseColumnProps, CopyButtonFactoryOptions, CustomCellFactoryOptions, DateCellFactoryOptions, LinkCellFactoryOptions, NumberCellFactoryOptions, StatusBadgeFactoryOptions, UserAvatarFactoryOptions } from '..';
+import type { Column, DataAccessor } from '../types/tableTypes';
+/**
+ * Typed column builder providing a fluent API for defining table columns.
+ * The generic parameter `Item` constrains accessor arguments to primitive
+ * properties of the data type, mirroring the runtime constraint that
+ * search/sort/group only meaningfully operate on stringifiable values.
+ *
+ * @example
+ * ```ts
+ * interface User { id: number; name: string; status: string; salary: number; }
+ *
+ * const columns = TypedColumnBuilder.for<User>()
+ *   .userAvatar('name', 'Employee')
+ *   .status('status')
+ *   .number('salary', 'Salary')
+ *   .actions()
+ *   .build();
+ * ```
+ */
+export declare class TypedColumnBuilder<Item> {
+    private columns;
+    userAvatar(accessor: DataAccessor<Item>, title?: string, options?: UserAvatarFactoryOptions<Item>): this;
+    actions(title?: string, options?: ActionButtonsFactoryOptions<Item>): this;
+    status(accessor: DataAccessor<Item>, title?: string, options?: StatusBadgeFactoryOptions<Item>): this;
+    copy(accessor: DataAccessor<Item>, title?: string, options?: CopyButtonFactoryOptions<Item>): this;
+    customCell(accessor: DataAccessor<Item>, title: string, options?: CustomCellFactoryOptions<Item>): this;
+    date(accessor: DataAccessor<Item>, title?: string, options?: DateCellFactoryOptions<Item>): this;
+    link(accessor: DataAccessor<Item>, title?: string, options?: LinkCellFactoryOptions<Item>): this;
+    number(accessor: DataAccessor<Item>, title?: string, options?: NumberCellFactoryOptions<Item>): this;
+    text(accessor: DataAccessor<Item>, title: string, options?: BaseColumnProps & {
+        formatter?: (value: unknown, item: Item) => string;
+    }): this;
+    custom(column: Column<Item>): this;
+    /**
+     * Returns the accumulated `Column<Item>[]` directly. Pair with the generic
+     * `Table<Item>` component to keep type-safety end-to-end without `as` casts.
+     */
+    build(): Column<Item>[];
+    static for<T>(): TypedColumnBuilder<T>;
+}

package/dist/factories/TypedColumnBuilder.js

@@ -0,0 +1,72 @@
+import { TableColumns } from '..';
+/**
+ * Typed column builder providing a fluent API for defining table columns.
+ * The generic parameter `Item` constrains accessor arguments to primitive
+ * properties of the data type, mirroring the runtime constraint that
+ * search/sort/group only meaningfully operate on stringifiable values.
+ *
+ * @example
+ * ```ts
+ * interface User { id: number; name: string; status: string; salary: number; }
+ *
+ * const columns = TypedColumnBuilder.for<User>()
+ *   .userAvatar('name', 'Employee')
+ *   .status('status')
+ *   .number('salary', 'Salary')
+ *   .actions()
+ *   .build();
+ * ```
+ */
+export class TypedColumnBuilder {
+    columns = [];
+    userAvatar(accessor, title = 'User', options = {}) {
+        this.columns.push(TableColumns.userAvatar(accessor, title, options));
+        return this;
+    }
+    actions(title = 'Actions', options = {}) {
+        this.columns.push(TableColumns.actions(title, options));
+        return this;
+    }
+    status(accessor, title = 'Status', options = {}) {
+        this.columns.push(TableColumns.status(accessor, title, options));
+        return this;
+    }
+    copy(accessor, title = 'Copy', options = {}) {
+        this.columns.push(TableColumns.copy(accessor, title, options));
+        return this;
+    }
+    customCell(accessor, title, options = {}) {
+        this.columns.push(TableColumns.custom(accessor, title, options));
+        return this;
+    }
+    date(accessor, title = 'Date', options = {}) {
+        this.columns.push(TableColumns.date(accessor, title, options));
+        return this;
+    }
+    link(accessor, title = 'Link', options = {}) {
+        this.columns.push(TableColumns.link(accessor, title, options));
+        return this;
+    }
+    number(accessor, title = 'Number', options = {}) {
+        this.columns.push(TableColumns.number(accessor, title, options));
+        return this;
+    }
+    text(accessor, title, options = {}) {
+        this.columns.push(TableColumns.text(accessor, title, options));
+        return this;
+    }
+    custom(column) {
+        this.columns.push(column);
+        return this;
+    }
+    /**
+     * Returns the accumulated `Column<Item>[]` directly. Pair with the generic
+     * `Table<Item>` component to keep type-safety end-to-end without `as` casts.
+     */
+    build() {
+        return [...this.columns];
+    }
+    static for() {
+        return new TypedColumnBuilder();
+    }
+}

package/dist/factories/index.d.ts

@@ -0,0 +1,12 @@
+export { default as ActionButtons } from '../cells/ActionButtons.svelte';
+export { default as CopyButton } from '../cells/CopyButton.svelte';
+export { default as CustomCell } from '../cells/CustomCell.svelte';
+export { default as DateCell } from '../cells/DateCell.svelte';
+export { default as LinkCell } from '../cells/LinkCell.svelte';
+export { default as NumberCell } from '../cells/NumberCell.svelte';
+export { default as StatusBadge } from '../cells/StatusBadge.svelte';
+export { default as UserAvatar } from '../cells/UserAvatar.svelte';
+export { ColumnValidation, ValidationHelpers } from './ColumnValidation';
+export type { ActionButtonsFactoryOptions, BaseColumnProps, CopyButtonFactoryOptions, CustomCellFactoryOptions, DateCellFactoryOptions, LinkCellFactoryOptions, NumberCellFactoryOptions, StatusBadgeFactoryOptions, UserAvatarFactoryOptions } from './TableColumns';
+export { TableColumns } from './TableColumns';
+export { TypedColumnBuilder } from './TypedColumnBuilder';