sheer-ui 0.4.2 → 0.5.0

package/src/lib/internal/table/core.ts

@@ -1,53 +0,0 @@
-import type { ColumnDef, ColumnSort } from './types.js';
-import type { Comparator, RowLike } from './sorting-fns.js';
-
-/** Id resolution priority ported from upstream: explicit `id` → `accessorKey` (dots → underscores) → string `header`. */
-export const resolveColumnId = <TData, TValue>(def: ColumnDef<TData, TValue>): string => {
-	const id = def.id ?? def.accessorKey?.replaceAll('.', '_') ?? (typeof def.header === 'string' ? def.header : undefined);
-	if (id === undefined) throw new Error('Column definition needs an id, an accessorKey or a string header');
-	return id;
-};
-
-export const makeAccessor = <TData>(def: ColumnDef<TData, unknown>): ((original: TData, index: number) => unknown) | undefined => {
-	if (def.accessorFn) return def.accessorFn;
-	const key = def.accessorKey;
-	if (key === undefined) return undefined;
-	if (!key.includes('.')) return (original) => (original as Record<string, unknown>)[key];
-	const path = key.split('.');
-	return (original) =>
-		path.reduce<unknown>((value, part) => (value == null ? undefined : (value as Record<string, unknown>)[part]), original);
-};
-
-/**
- * Stable multi-key sort: ties break on the next sorting entry, then on row index. Entries whose
- * column can't sort (per `comparatorFor`) are skipped. Returns the input array untouched when
- * nothing applies, so downstream deriveds keep referential equality.
- */
-export const sortRows = <TRow extends RowLike & { index: number }>(
-	rows: readonly TRow[],
-	sorting: readonly ColumnSort[],
-	comparatorFor: (columnId: string) => Comparator | undefined,
-): readonly TRow[] => {
-	const active = sorting.flatMap((entry) => {
-		const comparator = comparatorFor(entry.id);
-		return comparator ? [{ ...entry, comparator }] : [];
-	});
-	if (active.length === 0 || rows.length === 0) return rows;
-
-	return [...rows].sort((rowA, rowB) => {
-		for (const { id, desc, comparator } of active) {
-			const result = comparator(rowA, rowB, id);
-			if (result !== 0) return desc ? -result : result;
-		}
-		return rowA.index - rowB.index;
-	});
-};
-
-export const facetCounts = (rows: readonly RowLike[], columnId: string): Map<unknown, number> => {
-	const counts = new Map<unknown, number>();
-	for (const row of rows) {
-		const value = row.getValue(columnId);
-		counts.set(value, (counts.get(value) ?? 0) + 1);
-	}
-	return counts;
-};

package/src/lib/internal/table/filter-fns.ts

@@ -1,10 +0,0 @@
-import type { RowLike } from './sorting-fns.js';
-
-export const includesString = (row: RowLike, columnId: string, filterValue: unknown): boolean => {
-	const search = String(filterValue).toLowerCase();
-	const value = row.getValue(columnId);
-	return value != null && String(value).toLowerCase().includes(search);
-};
-
-// A cleared filter input drops its entry entirely, so `columnFilters.length` keeps meaning "is filtered".
-export const shouldAutoRemoveFilter = (value: unknown): boolean => value === undefined || value === '';

package/src/lib/internal/table/sorting-fns.ts

@@ -1,84 +0,0 @@
-// Ported from @tanstack/table-core@8.21.3 sortingFns.ts / RowSorting.ts (MIT).
-
-export interface RowLike {
-	getValue(columnId: string): unknown;
-}
-
-export type Comparator = (rowA: RowLike, rowB: RowLike, columnId: string) => number;
-
-export const reSplitAlphaNumeric = /([0-9]+)/gm;
-
-const compareBasic = (a: unknown, b: unknown) => (a === b ? 0 : (a as number) > (b as number) ? 1 : -1);
-
-const toComparableString = (value: unknown): string => {
-	if (typeof value === 'number') {
-		return Number.isNaN(value) || value === Infinity || value === -Infinity ? '' : String(value);
-	}
-	return typeof value === 'string' ? value : '';
-};
-
-// Handles numbers, mixed alphanumeric combinations, null/undefined and Infinity.
-const compareAlphanumeric = (aStr: string, bStr: string): number => {
-	const a = aStr.split(reSplitAlphaNumeric).filter(Boolean);
-	const b = bStr.split(reSplitAlphaNumeric).filter(Boolean);
-
-	while (a.length && b.length) {
-		const aa = a.shift()!;
-		const bb = b.shift()!;
-
-		const an = parseInt(aa, 10);
-		const bn = parseInt(bb, 10);
-
-		const combo = [an, bn].sort();
-
-		if (isNaN(combo[0]!)) {
-			if (aa > bb) return 1;
-			if (bb > aa) return -1;
-			continue;
-		}
-
-		if (isNaN(combo[1]!)) return isNaN(an) ? -1 : 1;
-
-		if (an > bn) return 1;
-		if (bn > an) return -1;
-	}
-
-	return a.length - b.length;
-};
-
-export const basic: Comparator = (rowA, rowB, columnId) => compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
-
-export const text: Comparator = (rowA, rowB, columnId) =>
-	compareBasic(toComparableString(rowA.getValue(columnId)).toLowerCase(), toComparableString(rowB.getValue(columnId)).toLowerCase());
-
-export const alphanumeric: Comparator = (rowA, rowB, columnId) =>
-	compareAlphanumeric(toComparableString(rowA.getValue(columnId)).toLowerCase(), toComparableString(rowB.getValue(columnId)).toLowerCase());
-
-export const datetime: Comparator = (rowA, rowB, columnId) => {
-	const a = rowA.getValue(columnId) as Date;
-	const b = rowB.getValue(columnId) as Date;
-	// > and < instead of === so Date objects compare by time value.
-	return a > b ? 1 : a < b ? -1 : 0;
-};
-
-/**
- * Picks a comparator from a sample of row values, mirroring upstream's `getAutoSortingFn` —
- * except the sample is the FIRST ten rows. Upstream's `.slice(10)` drops them instead, leaving
- * every table under 11 rows on `basic` (case-sensitive for strings).
- */
-export const inferSortingFn = (rows: readonly RowLike[], columnId: string): Comparator => {
-	let isString = false;
-
-	for (const row of rows.slice(0, 10)) {
-		const value = row.getValue(columnId);
-
-		if (Object.prototype.toString.call(value) === '[object Date]') return datetime;
-
-		if (typeof value === 'string') {
-			isString = true;
-			if (value.split(reSplitAlphaNumeric).length > 1) return alphanumeric;
-		}
-	}
-
-	return isString ? text : basic;
-};

package/src/lib/internal/table/table.svelte.ts

@@ -1,310 +0,0 @@
-import { SvelteSet } from 'svelte/reactivity';
-import type { CellContext, ColumnDef, ColumnFilter, ColumnSort, FilterFn, HeaderContext } from './types.js';
-import { facetCounts, makeAccessor, resolveColumnId, sortRows } from './core.js';
-import { inferSortingFn } from './sorting-fns.js';
-import { includesString, shouldAutoRemoveFilter } from './filter-fns.js';
-
-export interface DataTableOptions<TData> {
-	/** Thunk so the table tracks the consumer's own reactive source. */
-	data: () => TData[];
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	columns: ColumnDef<TData, any>[] | (() => ColumnDef<TData, any>[]);
-	/** Omit for an unpaginated table. */
-	pageSize?: number;
-}
-
-export const createDataTable = <TData>(options: DataTableOptions<TData>) => new DataTable(options);
-
-export class DataTable<TData> {
-	readonly #data: () => TData[];
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	readonly #defs: () => ColumnDef<TData, any>[];
-	readonly #paginated: boolean;
-	readonly selectedRowIds = new SvelteSet<string>();
-
-	// Raw so a change is always a reassignment: the page record below keys on their identity.
-	sorting = $state.raw<ColumnSort[]>([]);
-	columnFilters = $state.raw<ColumnFilter[]>([]);
-	columnVisibility = $state<Record<string, boolean>>({});
-	#pageSize = $state(10);
-	// A page index holds for the sorting and filters it was set under: a sort or filter change reads
-	// as page 0 without a write, while a data refetch underneath keeps the page.
-	#page = $state.raw({ index: 0, sorting: this.sorting, columnFilters: this.columnFilters });
-
-	constructor(options: DataTableOptions<TData>) {
-		this.#data = options.data;
-		const { columns } = options;
-		this.#defs = typeof columns === 'function' ? columns : () => columns;
-		this.#paginated = options.pageSize !== undefined;
-		if (options.pageSize !== undefined) this.#pageSize = options.pageSize;
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	readonly #columns: Column<TData, any>[] = $derived.by(() => this.#defs().map((def) => new Column(this, def)));
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	readonly #columnsById = $derived(new Map<string, Column<TData, any>>(this.#columns.map((column) => [column.id, column])));
-	readonly #coreRows: readonly Row<TData>[] = $derived.by(() => this.#data().map((original, index) => new Row(this, this.selectedRowIds, original, index)));
-
-	readonly #activeFilters = $derived(
-		this.columnFilters.flatMap((filter) => {
-			const column = this.#columnsById.get(filter.id);
-			return column ? [{ id: filter.id, filterFn: column.filterFn, value: filter.value }] : [];
-		}),
-	);
-	// One row-id set per active filter, reused by both the filtered model and every facet.
-	readonly #masks = $derived(
-		this.#activeFilters.map((filter) => new Set(this.#coreRows.filter((row) => filter.filterFn(row, filter.id, filter.value)).map((row) => row.id))),
-	);
-
-	readonly filteredRows: readonly Row<TData>[] = $derived(
-		this.#masks.length === 0 ? this.#coreRows : this.#coreRows.filter((row) => this.#masks.every((mask) => mask.has(row.id))),
-	);
-
-	readonly #sorted = $derived(
-		sortRows(this.filteredRows, this.sorting, (columnId) =>
-			this.#columnsById.get(columnId)?.canSort ? inferSortingFn(this.filteredRows, columnId) : undefined,
-		),
-	);
-
-	readonly pageCount = $derived.by(() => (this.#paginated ? Math.max(1, Math.ceil(this.#sorted.length / this.#pageSize)) : 1));
-	// Clamped on read, never written back: data shrinking under a stale index lands on the last page.
-	readonly #safeIndex = $derived(
-		this.#page.sorting === this.sorting && this.#page.columnFilters === this.columnFilters ? Math.min(this.#page.index, this.pageCount - 1) : 0,
-	);
-
-	readonly rows: readonly Row<TData>[] = $derived.by(() =>
-		this.#paginated ? this.#sorted.slice(this.#safeIndex * this.#pageSize, (this.#safeIndex + 1) * this.#pageSize) : this.#sorted,
-	);
-
-	readonly canPreviousPage = $derived(this.#safeIndex > 0);
-	readonly canNextPage = $derived(this.#safeIndex < this.pageCount - 1);
-
-	get pagination(): { pageIndex: number; pageSize: number } {
-		return { pageIndex: this.#safeIndex, pageSize: this.#pageSize };
-	}
-
-	setPageIndex(index: number) {
-		this.#page = { index: Math.min(Math.max(index, 0), this.pageCount - 1), sorting: this.sorting, columnFilters: this.columnFilters };
-	}
-	nextPage() {
-		this.setPageIndex(this.#safeIndex + 1);
-	}
-	previousPage() {
-		this.setPageIndex(this.#safeIndex - 1);
-	}
-	setPageSize(size: number) {
-		const next = Math.max(1, size);
-		// Keep the current top row visible, matching upstream's paging math.
-		this.#page = { index: Math.floor((this.#safeIndex * this.#pageSize) / next), sorting: this.sorting, columnFilters: this.columnFilters };
-		this.#pageSize = next;
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	get allColumns(): readonly Column<TData, any>[] {
-		return this.#columns;
-	}
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	column(id: string): Column<TData, any> | undefined {
-		return this.#columnsById.get(id);
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	readonly visibleColumns: readonly Column<TData, any>[] = $derived(this.#columns.filter((column) => column.isVisible));
-	readonly headerGroups: readonly HeaderGroup<TData>[] = $derived([
-		{ id: '0', headers: this.visibleColumns.map((column) => new Header(this, column)) },
-	]);
-
-	readonly selectedRows: readonly Row<TData>[] = $derived(this.#coreRows.filter((row) => row.isSelected));
-	readonly filteredSelectedRows: readonly Row<TData>[] = $derived(this.filteredRows.filter((row) => row.isSelected));
-
-	readonly isAllPageRowsSelected = $derived(this.rows.length > 0 && this.rows.every((row) => row.isSelected));
-	readonly isSomePageRowsSelected = $derived(this.isAllPageRowsSelected ? false : this.rows.some((row) => row.isSelected));
-	toggleAllPageRowsSelected(value?: boolean) {
-		const resolved = value ?? !this.isAllPageRowsSelected;
-		for (const row of this.rows) row.toggleSelected(resolved);
-	}
-
-	/** Core rows minus every active filter except `columnId`'s own, so a facet counts its remaining options. */
-	facetedRows(columnId: string): readonly Row<TData>[] {
-		const masks = this.#activeFilters.flatMap((filter, index) => (filter.id === columnId ? [] : [this.#masks[index]!]));
-		return masks.length === 0 ? this.#coreRows : this.#coreRows.filter((row) => masks.every((mask) => mask.has(row.id)));
-	}
-}
-
-export class Column<TData, TValue = unknown> {
-	readonly id: string;
-	readonly columnDef: ColumnDef<TData, TValue>;
-	readonly accessorFn?: (original: TData, index: number) => unknown;
-	readonly filterFn: FilterFn<TData>;
-	readonly #table: DataTable<TData>;
-
-	constructor(table: DataTable<TData>, def: ColumnDef<TData, TValue>) {
-		this.#table = table;
-		this.columnDef = def;
-		this.id = resolveColumnId(def);
-		this.accessorFn = makeAccessor(def);
-		this.filterFn = def.filterFn ?? includesString;
-	}
-
-	get canSort(): boolean {
-		return (this.columnDef.enableSorting ?? true) && this.accessorFn !== undefined;
-	}
-	get isSorted(): false | 'asc' | 'desc' {
-		const entry = this.#table.sorting.find((sort) => sort.id === this.id);
-		return entry ? (entry.desc ? 'desc' : 'asc') : false;
-	}
-
-	// String columns start ascending, everything else descending (upstream's getAutoSortDir).
-	#firstSortDir(): 'asc' | 'desc' {
-		return typeof this.#table.filteredRows[0]?.getValue(this.id) === 'string' ? 'asc' : 'desc';
-	}
-	// Three-state cycle with removal: first direction → other direction → unsorted.
-	#nextSortingOrder(): 'asc' | 'desc' | false {
-		const first = this.#firstSortDir();
-		const isSorted = this.isSorted;
-		if (!isSorted) return first;
-		if (isSorted !== first) return false;
-		return isSorted === 'desc' ? 'asc' : 'desc';
-	}
-
-	toggleSorting(desc?: boolean, multi = false) {
-		const nextOrder = this.#nextSortingOrder();
-		const hasManualValue = desc !== undefined;
-		const nextDesc = hasManualValue ? desc : nextOrder === 'desc';
-
-		const old = this.#table.sorting;
-		const existing = old.find((sort) => sort.id === this.id);
-		const existingIndex = old.findIndex((sort) => sort.id === this.id);
-
-		if (old.length > 0 && this.#canMultiSort && multi) {
-			this.#table.sorting = existing
-				? !hasManualValue && nextOrder === false
-					? old.filter((sort) => sort.id !== this.id)
-					: old.map((sort) => (sort.id === this.id ? { ...sort, desc: nextDesc } : sort))
-				: [...old, { id: this.id, desc: nextDesc }];
-			return;
-		}
-
-		// Single mode: only the most recently applied sort toggles through the cycle; anything else replaces.
-		if (existing !== undefined && existingIndex === old.length - 1) {
-			this.#table.sorting =
-				!hasManualValue && nextOrder === false
-					? old.filter((sort) => sort.id !== this.id)
-					: old.map((sort) => (sort.id === this.id ? { ...sort, desc: nextDesc } : sort));
-			return;
-		}
-		this.#table.sorting = [{ id: this.id, desc: nextDesc }];
-	}
-
-	get #canMultiSort(): boolean {
-		return this.accessorFn !== undefined;
-	}
-
-	readonly sortHandler = (event: MouseEvent) => {
-		if (!this.canSort) return;
-		this.toggleSorting(undefined, this.#canMultiSort && event.shiftKey);
-	};
-
-	get canHide(): boolean {
-		return this.columnDef.enableHiding ?? true;
-	}
-	get isVisible(): boolean {
-		return this.#table.columnVisibility[this.id] ?? true;
-	}
-	set isVisible(visible: boolean) {
-		if (!this.canHide || visible === this.isVisible) return;
-		this.#table.columnVisibility = { ...this.#table.columnVisibility, [this.id]: visible };
-	}
-
-	get filterValue(): unknown {
-		return this.#table.columnFilters.find((filter) => filter.id === this.id)?.value;
-	}
-	set filterValue(value: unknown) {
-		const others = this.#table.columnFilters.filter((filter) => filter.id !== this.id);
-		this.#table.columnFilters = shouldAutoRemoveFilter(value) ? others : [...others, { id: this.id, value }];
-	}
-
-	get facetedUniqueValues(): ReadonlyMap<unknown, number> {
-		return facetCounts(this.#table.facetedRows(this.id), this.id);
-	}
-}
-
-export class Row<TData> {
-	readonly id: string;
-	readonly index: number;
-	readonly original: TData;
-	readonly #table: DataTable<TData>;
-	readonly #selection: SvelteSet<string>;
-	// Plain Maps on purpose: both are written during $derived reads (sorting, templates), and a
-	// reactive container there is a write-inside-read loop (effect_update_depth_exceeded).
-	readonly #values = new Map<string, unknown>();
-	readonly #cells = new Map<string, Cell<TData>>();
-
-	constructor(table: DataTable<TData>, selection: SvelteSet<string>, original: TData, index: number) {
-		this.#table = table;
-		this.#selection = selection;
-		this.original = original;
-		this.index = index;
-		this.id = String(index);
-	}
-
-	getValue<TValue = unknown>(columnId: string): TValue {
-		if (this.#values.has(columnId)) return this.#values.get(columnId) as TValue;
-		const value = this.#table.column(columnId)?.accessorFn?.(this.original, this.index);
-		this.#values.set(columnId, value);
-		return value as TValue;
-	}
-
-	get isSelected(): boolean {
-		return this.#selection.has(this.id);
-	}
-	toggleSelected(value?: boolean) {
-		if (value ?? !this.isSelected) this.#selection.add(this.id);
-		else this.#selection.delete(this.id);
-	}
-
-	get visibleCells(): Cell<TData>[] {
-		return this.#table.visibleColumns.map((column) => {
-			let cell = this.#cells.get(column.id);
-			if (cell === undefined) {
-				cell = new Cell(this.#table, column, this);
-				this.#cells.set(column.id, cell);
-			}
-			return cell;
-		});
-	}
-}
-
-export class Cell<TData, TValue = unknown> {
-	readonly id: string;
-	readonly column: Column<TData, TValue>;
-	readonly row: Row<TData>;
-	readonly context: CellContext<TData, TValue>;
-
-	constructor(table: DataTable<TData>, column: Column<TData, TValue>, row: Row<TData>) {
-		this.id = `${row.id}_${column.id}`;
-		this.column = column;
-		this.row = row;
-		this.context = { table, column, row, cell: this };
-	}
-}
-
-export class Header<TData, TValue = unknown> {
-	readonly id: string;
-	readonly colSpan = 1;
-	readonly isPlaceholder = false;
-	readonly column: Column<TData, TValue>;
-	readonly context: HeaderContext<TData, TValue>;
-
-	constructor(table: DataTable<TData>, column: Column<TData, TValue>) {
-		this.id = column.id;
-		this.column = column;
-		this.context = { table, column, header: this };
-	}
-}
-
-export interface HeaderGroup<TData> {
-	id: string;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	headers: Header<TData, any>[];
-}

package/src/lib/internal/table/types.ts

@@ -1,33 +0,0 @@
-import type { Cell, Column, DataTable, Header, Row } from './table.svelte.js';
-
-export type ColumnDefTemplate<TProps> = string | ((props: TProps) => unknown);
-
-export type FilterFn<TData> = (row: Row<TData>, columnId: string, value: unknown) => boolean;
-
-export interface ColumnDef<TData, TValue = unknown> {
-	id?: string;
-	accessorKey?: string;
-	accessorFn?: (original: TData, index: number) => TValue;
-	header?: ColumnDefTemplate<HeaderContext<TData, TValue>>;
-	cell?: ColumnDefTemplate<CellContext<TData, TValue>>;
-	filterFn?: FilterFn<TData>;
-	enableSorting?: boolean;
-	enableHiding?: boolean;
-	meta?: { class?: string };
-}
-
-export type ColumnSort = { id: string; desc: boolean };
-export type ColumnFilter = { id: string; value: unknown };
-
-export interface HeaderContext<TData, TValue = unknown> {
-	table: DataTable<TData>;
-	column: Column<TData, TValue>;
-	header: Header<TData, TValue>;
-}
-
-export interface CellContext<TData, TValue = unknown> {
-	table: DataTable<TData>;
-	column: Column<TData, TValue>;
-	row: Row<TData>;
-	cell: Cell<TData, TValue>;
-}

package/src/lib/internal/timeout-fn.svelte.ts

@@ -1,38 +0,0 @@
-import type { AnyFn } from './types.js';
-
-/**
- * A self-cancelling timeout. `start()` (re)schedules `cb` after `getInterval()` ms,
- * `stop()` clears it; auto-stops when the owning component/effect is destroyed.
- */
-export function createEffectTimeout<T extends AnyFn>(cb: T, getDelay: () => number, getWindow: () => typeof globalThis = () => globalThis) {
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	let timerWindow: typeof globalThis;
-
-	const stop = () => {
-		if (timer === undefined) return;
-
-		timerWindow.clearTimeout(timer);
-		timer = undefined;
-	};
-
-	const start = (...args: Parameters<T>) => {
-		stop();
-
-		timerWindow = getWindow();
-		timer = timerWindow.setTimeout(() => {
-			timer = undefined;
-			cb(...args);
-		}, getDelay());
-	};
-
-	$effect(() => stop);
-
-	return {
-		start,
-		stop,
-		// Not reactive: a plain `let`, only ever read from event handlers.
-		get pending() {
-			return timer !== undefined;
-		},
-	};
-}

package/src/lib/internal/tools/box.svelte.ts

@@ -1,44 +0,0 @@
-import { untrack } from 'svelte';
-
-/** What a vendored engine reads a reactive option through. Any object with a `current` qualifies. */
-export type ReadableBox<T> = {
-	readonly current: T;
-};
-
-export type WritableBox<T> = {
-	current: T;
-};
-
-export function boxWith<T>(getter: () => T): ReadableBox<T>;
-export function boxWith<T>(getter: () => T, setter: (v: T) => void): WritableBox<T>;
-export function boxWith<T>(getter: () => T, setter?: (v: T) => void) {
-	if (setter) {
-		return {
-			get current() {
-				return getter();
-			},
-			set current(v: T) {
-				setter(v);
-			},
-		};
-	}
-
-	return {
-		get current() {
-			return getter();
-		},
-	};
-}
-
-/**
- * Repair a bindable value synchronously for setup/SSR, then repair it again
- * before DOM updates whenever the tracked source changes.
- */
-export function repairBindable(track: () => unknown, repair: () => void) {
-	repair();
-
-	$effect.pre(() => {
-		track();
-		untrack(repair);
-	});
-}

package/src/lib/internal/tools/index.ts

@@ -1,12 +0,0 @@
-export { boxWith, repairBindable, type WritableBox, type ReadableBox } from './box.svelte.js';
-export type {
-	AnyFn,
-	Box,
-	Expand,
-	Getter,
-	ReadableBoxedValues,
-	WithChildren,
-	WithRefProps,
-	WritableBoxedValues,
-} from './types.js';
-export * from './utils/index.js';

package/src/lib/internal/tools/types.ts

@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Snippet } from 'svelte';
-import type { ReadableBox, WritableBox } from './box.svelte.js';
-import { BROWSER } from 'esm-env';
-
-export type Getter<T> = () => T;
-
-export type Box<T> = ReadableBox<T> | WritableBox<T>;
-
-export type Expand<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
-
-/**
- * Given a Record type T, returns a type that represents the same type, but with
- * all values wrapped in a `ReadableBox`.
- */
-export type ReadableBoxedValues<T> = {
-	[K in keyof T]: ReadableBox<T[K]>;
-};
-
-/**
- * Given a Record type T, returns a type that represents the same type, but with
- * all values wrapped in a `WritableBox`.
- */
-export type WritableBoxedValues<T> = {
-	[K in keyof T]: WritableBox<T[K]>;
-};
-
-export type WithChildren<Props = {}> = Props & {
-	children?: Snippet | undefined;
-};
-
-export type WithRefProps<T = {}> = T & ReadableBoxedValues<{ id: string }> & WritableBoxedValues<{ ref: HTMLElement | null }>;
-
-/** camelCase CSS property names from the DOM lib, plus custom properties. Values are not typed per property: every
- *  style object here ends up in overrule's `styleToString`, which takes strings anyway. */
-type CSSPropertyName = {
-	[K in keyof CSSStyleDeclaration]: K extends string ? (CSSStyleDeclaration[K] extends string ? K : never) : never;
-}[keyof CSSStyleDeclaration];
-export type StyleProperties = Partial<Record<CSSPropertyName, string | number>> & { [custom: `--${string}`]: string | number };
-
-export type AnyFn = (...args: any[]) => any;