@human-kit/svelte-components 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/table/checkbox/table-checkbox.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type TableCheckboxProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children' | 'class' | 'id' | 'role' | 'tabindex' | 'aria-checked' | 'aria-disabled' | 'onclick' | 'onkeydown'> & {
+    id?: string;
+    title?: string;
+    children?: Snippet;
+    class?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+};
+declare const TableCheckbox: import("svelte").Component<TableCheckboxProps, {}, "">;
+type TableCheckbox = ReturnType<typeof TableCheckbox>;
+export default TableCheckbox;

package/dist/table/checkbox-indicator/README.md

@@ -0,0 +1,29 @@
+# Table.CheckboxIndicator
+
+## API reference
+
+### Table.CheckboxIndicator
+
+Name: `Table.CheckboxIndicator`
+Description: Headless presence wrapper for indicator content inside `Table.Checkbox`. It renders when the checkbox is checked or indeterminate.
+
+| Prop           | Type                              | Default     | Description                                                                     |
+| -------------- | --------------------------------- | ----------- | ------------------------------------------------------------------------------- |
+| `keepMounted`  | `boolean`                         | `false`     | Keeps the indicator mounted while hidden when the checkbox is unchecked.        |
+| `children`     | `Snippet`                         | `undefined` | Rendered indicator content, such as a check icon or dash icon.                  |
+| `class`        | `string`                          | `''`        | CSS class names for the indicator wrapper.                                      |
+| `...restProps` | `HTMLAttributes<HTMLSpanElement>` | `-`         | Additional native attributes forwarded to the composed checkbox indicator span. |
+
+## Usage notes
+
+- Use `Table.CheckboxIndicator` inside `Table.Checkbox`.
+- The part is headless and unstyled.
+- It mirrors the visibility behavior of `Checkbox.Indicator` and renders for checked and indeterminate states.
+
+```svelte
+<Table.Checkbox class="inline-flex h-5 w-5 items-center justify-center rounded border">
+	<Table.CheckboxIndicator>
+		<CheckIcon class="h-3.5 w-3.5" />
+	</Table.CheckboxIndicator>
+</Table.Checkbox>
+```

package/dist/table/checkbox-indicator/table-checkbox-indicator.svelte

@@ -0,0 +1,22 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+	import { Checkbox } from '../../checkbox';
+
+	type TableCheckboxIndicatorProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children' | 'class'> & {
+		keepMounted?: boolean;
+		children?: Snippet;
+		class?: string;
+	};
+
+	let {
+		keepMounted = false,
+		children,
+		class: className = '',
+		...restProps
+	}: TableCheckboxIndicatorProps = $props();
+</script>
+
+<Checkbox.Indicator {keepMounted} class={className} {...restProps}>
+	{@render children?.()}
+</Checkbox.Indicator>

package/dist/table/checkbox-indicator/table-checkbox-indicator.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type TableCheckboxIndicatorProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children' | 'class'> & {
+    keepMounted?: boolean;
+    children?: Snippet;
+    class?: string;
+};
+declare const TableCheckboxIndicator: import("svelte").Component<TableCheckboxIndicatorProps, {}, "">;
+type TableCheckboxIndicator = ReturnType<typeof TableCheckboxIndicator>;
+export default TableCheckboxIndicator;

package/dist/table/column/README.md

@@ -0,0 +1,32 @@
+<!-- markdownlint-disable MD024 MD060 -->
+
+# Table.Column
+
+## API reference
+
+### Table.Column
+
+Name: `Table.Column`
+Description: Logical metadata wrapper for a header column. It does not render DOM and is used to register stable column identity, sorting capability, row-header semantics, and resize metadata.
+
+| Prop             | Type                        | Default     | Description                                                                                                                         |
+| ---------------- | --------------------------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `id`             | `string`                    | `-`         | Stable identifier for the column.                                                                                                   |
+| `allowsSorting`  | `boolean`                   | `false`     | Enables sorting for the wrapped header cell.                                                                                        |
+| `allowsResizing` | `boolean`                   | `false`     | Legacy explicit resize opt-in. `Table.ColumnResizer` now enables resizing automatically; keep this only for backward compatibility. |
+| `isRowHeader`    | `boolean`                   | `false`     | Marks the associated body column as row-header cells.                                                                               |
+| `textValue`      | `string`                    | `undefined` | Optional spoken label used by `Table.Root` sort announcements when it should differ from `id`.                                      |
+| `width`          | `number \| \`${number}px\`` | `undefined` | Explicit column width hint. Px numbers are the first-class format for the current resize release.                                   |
+| `defaultWidth`   | `number \| \`${number}px\`` | `undefined` | Uncontrolled initial width hint for the column.                                                                                     |
+| `minWidth`       | `number`                    | `undefined` | Minimum width in px enforced during resize interactions.                                                                            |
+| `maxWidth`       | `number`                    | `undefined` | Maximum width in px enforced during resize interactions.                                                                            |
+| `children`       | `Snippet`                   | `undefined` | Usually a single `Table.ColumnHeaderCell`.                                                                                          |
+
+### Context utilities
+
+Name: `Table.Column` column context
+Description: Provides column metadata to `Table.ColumnHeaderCell`.
+
+| Prop                    | Type                       | Default | Description                                                          |
+| ----------------------- | -------------------------- | ------- | -------------------------------------------------------------------- |
+| `useTableColumnContext` | `() => TableColumnContext` | `-`     | Reads the current column metadata and throws outside `Table.Column`. |

package/dist/table/column/table-column.svelte

@@ -0,0 +1,108 @@
+<script lang="ts">
+	import { onDestroy } from 'svelte';
+	import type { Snippet } from 'svelte';
+	import {
+		setTableColumnContext,
+		useTableContext,
+		useTableSectionContext,
+		type TableColumnWidth
+	} from '../root/context';
+
+	type TableColumnProps = {
+		id: string;
+		allowsSorting?: boolean;
+		/** @deprecated `Table.ColumnResizer` now enables resizing automatically. */
+		allowsResizing?: boolean;
+		isRowHeader?: boolean;
+		textValue?: string;
+		width?: TableColumnWidth;
+		defaultWidth?: TableColumnWidth;
+		minWidth?: number;
+		maxWidth?: number;
+		children?: Snippet;
+	};
+
+	let {
+		id,
+		allowsSorting = false,
+		allowsResizing = false,
+		isRowHeader = false,
+		textValue,
+		width,
+		defaultWidth,
+		minWidth,
+		maxWidth,
+		children
+	}: TableColumnProps = $props();
+
+	const table = useTableContext();
+	const section = useTableSectionContext();
+	const token = table.createInstanceToken('column');
+
+	if (section.section !== 'header') {
+		throw new Error('`Table.Column` must be used inside `Table.Header`.');
+	}
+
+	setTableColumnContext({
+		token,
+		get id() {
+			return id;
+		},
+		get allowsSorting() {
+			return allowsSorting;
+		},
+		get allowsResizing() {
+			return allowsResizing || table.isColumnResizable(id);
+		},
+		get isHidden() {
+			return table.isColumnHidden(id);
+		},
+		get isRowHeader() {
+			return isRowHeader;
+		},
+		get textValue() {
+			return textValue;
+		},
+		get width() {
+			return width;
+		},
+		get defaultWidth() {
+			return defaultWidth;
+		},
+		get minWidth() {
+			return minWidth;
+		},
+		get maxWidth() {
+			return maxWidth;
+		}
+	});
+
+	function syncColumnRegistration() {
+		table.registerColumn({
+			token,
+			id,
+			allowsSorting,
+			allowsResizing,
+			isRowHeader,
+			textValue,
+			width,
+			defaultWidth,
+			minWidth,
+			maxWidth
+		});
+	}
+
+	syncColumnRegistration();
+
+	$effect(() => {
+		syncColumnRegistration();
+	});
+
+	onDestroy(() => {
+		table.unregisterColumn(token);
+	});
+</script>
+
+{#if children}
+	{@render children()}
+{/if}

package/dist/table/column/table-column.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { Snippet } from 'svelte';
+import { type TableColumnWidth } from '../root/context';
+type TableColumnProps = {
+    id: string;
+    allowsSorting?: boolean;
+    /** @deprecated `Table.ColumnResizer` now enables resizing automatically. */
+    allowsResizing?: boolean;
+    isRowHeader?: boolean;
+    textValue?: string;
+    width?: TableColumnWidth;
+    defaultWidth?: TableColumnWidth;
+    minWidth?: number;
+    maxWidth?: number;
+    children?: Snippet;
+};
+declare const TableColumn: import("svelte").Component<TableColumnProps, {}, "">;
+type TableColumn = ReturnType<typeof TableColumn>;
+export default TableColumn;

package/dist/table/column-header-cell/README.md

@@ -0,0 +1,28 @@
+<!-- markdownlint-disable MD024 -->
+
+# Table.ColumnHeaderCell
+
+## API reference
+
+### Table.ColumnHeaderCell
+
+Name: `Table.ColumnHeaderCell`
+Description: Focusable header cell for a column. It participates in roving focus and toggles sorting when the wrapping `Table.Column` allows it.
+
+- When a nested control like `Table.ColumnResizer` receives focus, the header exposes `data-focus-within` / `data-focus-visible-within` instead of remaining `data-focused`.
+
+| Prop       | Type      | Default     | Description                       |
+| ---------- | --------- | ----------- | --------------------------------- |
+| `class`    | `string`  | `''`        | Class names for the `th` element. |
+| `children` | `Snippet` | `undefined` | Header content.                   |
+
+### Context utilities
+
+Name: `Table.ColumnHeaderCell` dependencies
+Description: Consumes both column and row context to register a navigable header cell.
+
+| Prop                    | Type                       | Default | Description                          |
+| ----------------------- | -------------------------- | ------- | ------------------------------------ |
+| `useTableColumnContext` | `() => TableColumnContext` | `-`     | Reads current column metadata.       |
+| `useTableRowContext`    | `() => TableRowContext`    | `-`     | Reads the current row token.         |
+| `useTableContext`       | `() => TableContext`       | `-`     | Reads table focus and sorting state. |

package/dist/table/column-header-cell/table-column-header-cell.svelte

@@ -0,0 +1,281 @@
+<script lang="ts">
+	import { onDestroy } from 'svelte';
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+	import {
+		setTableCellContext,
+		useTableColumnContext,
+		useTableContext,
+		useTableRowContext
+	} from '../root/context';
+	import {
+		shouldShowFocusVisible,
+		trackInteractionModality
+	} from '../../primitives/input-modality';
+
+	type TableColumnHeaderCellProps = Omit<HTMLAttributes<HTMLTableCellElement>, 'children'> & {
+		children?: Snippet;
+		class?: string;
+	};
+
+	let { children, class: className = '', ...restProps }: TableColumnHeaderCellProps = $props();
+
+	const table = useTableContext();
+	const column = useTableColumnContext();
+	const row = useTableRowContext();
+	const key = table.createInstanceToken('header-cell');
+	const focusVersion = table.focusVersion;
+	const layoutVersion = table.layoutVersion;
+	const sortVersion = table.sortVersion;
+	const widthVersion = table.widthVersion;
+
+	let element = $state<HTMLElement | undefined>(undefined);
+	let focusDelegate = $state<(() => HTMLElement | undefined) | undefined>(undefined);
+	let isElementFocused = $state(false);
+	let isElementFocusVisible = $state(false);
+	let isFocusWithin = $state(false);
+	let isFocusVisibleWithin = $state(false);
+	row.registerCellToken(key, () => element);
+	function syncHeaderCellRegistration() {
+		table.registerCell({
+			key,
+			rowToken: row.rowToken,
+			section: 'header',
+			columnToken: column.token,
+			element,
+			focusDelegate
+		});
+	}
+
+	function registerFocusDelegate(getElement: () => HTMLElement | undefined) {
+		focusDelegate = getElement;
+	}
+
+	function unregisterFocusDelegate() {
+		focusDelegate = undefined;
+	}
+
+	function notifyResizerPresent() {
+		// No-op. Header cells now always provide the positioning context that
+		// column resizers need so the handle is available in SSR HTML too.
+	}
+
+	function notifyResizerRemoved() {
+		// No-op. See notifyResizerPresent().
+	}
+
+	setTableCellContext({
+		cellKey: key,
+		registerFocusDelegate,
+		unregisterFocusDelegate,
+		notifyResizerPresent,
+		notifyResizerRemoved
+	});
+
+	syncHeaderCellRegistration();
+
+	$effect(() => {
+		syncHeaderCellRegistration();
+	});
+
+	onDestroy(() => {
+		row.unregisterCellToken(key);
+		table.unregisterCell(key);
+	});
+
+	const isFocused = $derived.by(() => {
+		void $focusVersion;
+		return table.isCellFocused(key) && isElementFocused;
+	});
+	const isFocusVisible = $derived.by(() => {
+		void $focusVersion;
+		return isFocused && isElementFocusVisible;
+	});
+	const sortDirection = $derived.by(() => {
+		void $sortVersion;
+		return table.getSortDirection(column.id);
+	});
+	const isHidden = $derived.by(() => {
+		void $layoutVersion;
+		return column.isHidden;
+	});
+
+	const columnWidth = $derived.by(() => {
+		void $widthVersion;
+		return table.getColumnWidth(column.id);
+	});
+	const visibleColumnIndex = $derived.by(() => {
+		void $layoutVersion;
+		return table.getVisibleColumnIndexByToken(column.token);
+	});
+	const headerTabIndex = $derived.by(() => {
+		if (isHidden || focusDelegate) return undefined;
+		return table.isCellTabStop(key) ? 0 : -1;
+	});
+
+	function focusResizerInHeader(target: HTMLElement | undefined) {
+		const resizer = target?.querySelector<HTMLElement>('[data-table-column-resizer="true"]');
+		if (!resizer) return false;
+		resizer.focus();
+		return document.activeElement === resizer;
+	}
+
+	function getSiblingHeaderCell(direction: 'left' | 'right') {
+		const headerRow = element?.closest('tr');
+		if (!headerRow || !element) return null;
+
+		const headerCells = Array.from(
+			headerRow.querySelectorAll<HTMLElement>('th[role="columnheader"]')
+		);
+		const currentIndex = headerCells.indexOf(element);
+		if (currentIndex < 0) return null;
+
+		return headerCells[currentIndex + (direction === 'left' ? -1 : 1)] ?? null;
+	}
+
+	function moveFocusIntoResizeHandle(direction: 'left' | 'right') {
+		if (direction === 'right') {
+			return focusResizerInHeader(element);
+		}
+
+		return focusResizerInHeader(getSiblingHeaderCell('left') ?? undefined);
+	}
+
+	function handleFocus() {
+		isElementFocused = true;
+		isElementFocusVisible = shouldShowFocusVisible(element ?? null);
+		table.setFocusedCell(key);
+		table.setFocusVisible(isElementFocusVisible);
+	}
+
+	function handleBlur() {
+		isElementFocused = false;
+		isElementFocusVisible = false;
+	}
+
+	function handleFocusIn(event: FocusEvent) {
+		if (event.target === element) {
+			isFocusWithin = false;
+			isFocusVisibleWithin = false;
+			return;
+		}
+		isFocusWithin = true;
+		isFocusVisibleWithin = shouldShowFocusVisible(event.target as HTMLElement | null);
+	}
+
+	function handleFocusOut(event: FocusEvent) {
+		const nextFocused = event.relatedTarget;
+		if (nextFocused instanceof Node && element?.contains(nextFocused)) return;
+		isFocusWithin = false;
+		isFocusVisibleWithin = false;
+	}
+
+	function handleClick() {
+		table.focusCellByKey(key);
+		if (table.consumeHeaderClickSuppression()) {
+			return;
+		}
+		if (column.allowsSorting) {
+			table.toggleSort(column.id);
+		}
+	}
+
+	function handleMouseDown(event: MouseEvent) {
+		trackInteractionModality(event, element ?? null);
+		isElementFocusVisible = false;
+		isFocusVisibleWithin = false;
+		table.setFocusVisible(false);
+	}
+
+	function handleKeyDown(event: KeyboardEvent) {
+		trackInteractionModality(event, element ?? null);
+
+		if ((event.ctrlKey || event.metaKey) && event.key === 'Home') {
+			event.preventDefault();
+			table.moveToGridStart();
+			return;
+		}
+
+		if ((event.ctrlKey || event.metaKey) && event.key === 'End') {
+			event.preventDefault();
+			table.moveToGridEnd();
+			return;
+		}
+
+		switch (event.key) {
+			case 'ArrowUp':
+				event.preventDefault();
+				table.moveFocus('up');
+				return;
+			case 'ArrowDown':
+				event.preventDefault();
+				table.moveFocus('down');
+				return;
+			case 'ArrowLeft':
+				event.preventDefault();
+				if (moveFocusIntoResizeHandle('left')) return;
+				table.moveFocus('left');
+				return;
+			case 'ArrowRight':
+				event.preventDefault();
+				if (moveFocusIntoResizeHandle('right')) return;
+				table.moveFocus('right');
+				return;
+			case 'Home':
+				event.preventDefault();
+				table.moveToRowStart();
+				return;
+			case 'End':
+				event.preventDefault();
+				table.moveToRowEnd();
+				return;
+			case 'Enter':
+			case ' ':
+				if (!column.allowsSorting) return;
+				event.preventDefault();
+				if (event.repeat) return;
+				table.toggleSort(column.id);
+				return;
+		}
+	}
+</script>
+
+<th
+	bind:this={element}
+	role="columnheader"
+	class={className}
+	tabindex={headerTabIndex}
+	aria-colindex={!isHidden && visibleColumnIndex >= 0 ? visibleColumnIndex + 1 : undefined}
+	aria-hidden={isHidden ? true : undefined}
+	aria-sort={column.allowsSorting ? (sortDirection ?? 'none') : undefined}
+	data-focused={isFocused ? 'true' : undefined}
+	data-focus-visible={isFocusVisible ? 'true' : undefined}
+	data-focus-within={isFocusWithin ? 'true' : undefined}
+	data-focus-visible-within={isFocusVisibleWithin ? 'true' : undefined}
+	data-sortable={column.allowsSorting || undefined}
+	data-sort-direction={sortDirection}
+	data-column-index={visibleColumnIndex >= 0 ? visibleColumnIndex : undefined}
+	style:width={columnWidth !== undefined ? `${columnWidth}px` : undefined}
+	style:display={isHidden ? 'none' : undefined}
+	onfocusin={handleFocusIn}
+	onfocusout={handleFocusOut}
+	onfocus={handleFocus}
+	onblur={handleBlur}
+	onclick={handleClick}
+	onmousedown={handleMouseDown}
+	onkeydown={handleKeyDown}
+	{...restProps}
+>
+	<div
+		data-table-header-content
+		style:overflow="visible"
+		style:position="relative"
+		style:min-width="0"
+		style:width="100%"
+		style:height="100%"
+	>
+		{#if children}
+			{@render children()}
+		{/if}
+	</div>
+</th>

package/dist/table/column-header-cell/table-column-header-cell.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type TableColumnHeaderCellProps = Omit<HTMLAttributes<HTMLTableCellElement>, 'children'> & {
+    children?: Snippet;
+    class?: string;
+};
+declare const TableColumnHeaderCell: import("svelte").Component<TableColumnHeaderCellProps, {}, "">;
+type TableColumnHeaderCell = ReturnType<typeof TableColumnHeaderCell>;
+export default TableColumnHeaderCell;

package/dist/table/column-resizer/README.md

@@ -0,0 +1,32 @@
+<!-- markdownlint-disable MD024 MD060 -->
+
+# Table.ColumnResizer
+
+## API reference
+
+### Table.ColumnResizer
+
+Name: `Table.ColumnResizer`
+Description: Interactive resize handle for the current `Table.Column`. It must be composed inside `Table.ColumnHeaderCell`, and it resizes the column that owns the surrounding `Table.Column` context.
+
+| Prop        | Type      | Default     | Description                                                          |
+| ----------- | --------- | ----------- | -------------------------------------------------------------------- |
+| `step`      | `number`  | `16`        | Keyboard resize delta in px for `ArrowLeft` / `ArrowRight`.          |
+| `shiftStep` | `number`  | `48`        | Larger keyboard resize delta in px for `Shift+ArrowLeft/ArrowRight`. |
+| `class`     | `string`  | `''`        | Class names for the resize handle element.                           |
+| `children`  | `Snippet` | `undefined` | Optional custom resize affordance content.                           |
+
+## Usage notes
+
+- `Table.ColumnResizer` must be used inside `Table.ColumnHeaderCell`.
+- Rendering `Table.ColumnResizer` inside `Table.ColumnHeaderCell` is enough to make the owning `Table.Column` resizable.
+- `Table.Column.allowsResizing` is still accepted for backward compatibility, but it is no longer required.
+- The handle resolves the active column from `Table.Column` context. It does not accept a separate `columnId` prop.
+- Width state lives in `Table.Root` through `columnWidths` / `defaultColumnWidths`.
+- Pointer resizing uses Pointer Events, so mouse, touch, and pen interactions share the same behavior.
+- Keyboard resizing uses an explicit resize mode: focus the handle, press `Enter` to capture resize, use `ArrowLeft` / `ArrowRight` (plus `Shift`) to adjust the width, `Home` to jump to the minimum width, and `End` to auto-fit the column to its content width, then press `Enter` again to commit the width and keep focus on the handle.
+- While keyboard resize mode is active, pressing `Escape` restores the starting width, exits resize mode, and returns focus to the owning header cell.
+- Keyboard resizing uses the same resize lifecycle callbacks as pointer resizing and announces committed widths through a polite live region.
+- During pointer drag, pressing `Escape` restores the starting width and cancels the resize interaction.
+- Double-click still auto-fits the column to its content width.
+- In RTL layouts, `ArrowLeft` and `ArrowRight` are inverted so the logical resize direction matches the visual layout.

package/dist/table/column-resizer/table-column-resizer-freeze-layout-test.svelte

@@ -0,0 +1,51 @@
+<script lang="ts">
+	import { Table } from '../index';
+
+	let currentColumnWidths = $state<Map<string, number> | undefined>(undefined);
+</script>
+
+<div style="width: 640px;">
+	<Table.Root
+		aria-label="Freeze layout table"
+		bind:columnWidths={currentColumnWidths}
+		class="min-w-full border-collapse text-left"
+	>
+		<Table.Header>
+			<Table.Row>
+				<Table.Column id="email" isRowHeader textValue="Email" minWidth={80}>
+					<Table.ColumnHeaderCell>
+						<div class="flex items-center justify-between gap-3">
+							<span>Email address</span>
+							<Table.ColumnResizer
+								data-testid="freeze-email-resizer"
+								class="inline-flex w-3 cursor-col-resize justify-center"
+							/>
+						</div>
+					</Table.ColumnHeaderCell>
+				</Table.Column>
+				<Table.Column id="group" textValue="Group" minWidth={80}>
+					<Table.ColumnHeaderCell>
+						<div class="flex items-center justify-between gap-3">
+							<span>Group membership</span>
+							<Table.ColumnResizer
+								data-testid="freeze-group-resizer"
+								class="inline-flex w-3 cursor-col-resize justify-center"
+							/>
+						</div>
+					</Table.ColumnHeaderCell>
+				</Table.Column>
+			</Table.Row>
+		</Table.Header>
+
+		<Table.Body>
+			<Table.Row id="danilo">
+				<Table.Cell>danilo@example.com</Table.Cell>
+				<Table.Cell>Developer relations</Table.Cell>
+			</Table.Row>
+		</Table.Body>
+	</Table.Root>
+</div>
+
+<output data-testid="freeze-column-widths"
+	>{JSON.stringify(Object.fromEntries(currentColumnWidths ?? new Map()))}</output
+>

package/dist/table/column-resizer/table-column-resizer-freeze-layout-test.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const TableColumnResizerFreezeLayoutTest: import("svelte").Component<Record<string, never>, {}, "">;
+type TableColumnResizerFreezeLayoutTest = ReturnType<typeof TableColumnResizerFreezeLayoutTest>;
+export default TableColumnResizerFreezeLayoutTest;