@lavalogic/scoria 0.36.0 → 0.37.0

package/dist/Components/Table/Body/Rows/Columns/TableQuerySelect.svelte

@@ -2,16 +2,17 @@
 
 <script
 	lang="ts"
-	generics="T extends object,"
+	generics="T extends object, RowIdType extends Primitive"
 >
 	import QuerySelect from '../../../../QuerySelect.svelte';
 	import type { QueryDef } from '../../../Types/Columns/Definitions/Accessors/QueryDef.svelte.js';
 	import { TableContext } from '../../../Types/Context/TableContext.svelte.js';
-	import { TableFocusDetails } from '../../../Types/Focus/TableFocusDetails.svelte.js';
-	import { devCatch, isValidityTuple, loadingText } from '../../../../../Helpers/Helpers.svelte.js';
+	import { type Primitive } from '../../../Types/Context/TableInitOptions.js';
+	import { devCatch, loadingText } from '../../../../../Helpers/Helpers.svelte.js';
 	import type { SelectOption } from '../../../../../Types/Internal/SelectOption.js';
 	import { Validity } from '../../../../../Types/Internal/Validity.js';
 	import { getContext, tick, untrack } from 'svelte';
+	import { useAsyncEditable } from './_helpers/useAsyncEditable.svelte.js';
 	import type { TableQuerySelectProps } from './TableQuerySelectProps.js';
 
 	const { cell }: TableQuerySelectProps<T, unknown> = $props();
@@ -22,18 +23,24 @@
 		cell.column.columnDef.getDisplayValue(cell.row.original, cell.row.originalIndex)
 	);
 
-	let tdref = $state<HTMLTableCellElement | undefined>();
-
-	const columnDef: QueryDef<T> = $derived(cell.column.columnDef) as unknown as QueryDef<T>; // TODO stabilise and remove `as unknown`
-	// const optional = $derived(columnDef.optional ?? false);
-
+	let tdref = $state<HTMLElement | undefined>();
+
+	/**
+	 * Narrow the column def to `QueryDef<T>`. The cast is required because
+	 * `TableCell.column.columnDef` is the loose `ColumnDef<T>`; `TableColumn`
+	 * dispatches this component only when the underlying def is in fact a
+	 * `QueryDef`, but the static type does not reflect that. Replacing this
+	 * with a discriminated cell-host props type is tracked under the
+	 * cross-cutting RowGenericThreading workorder.
+	 */
+	const columnDef: QueryDef<T> = $derived(cell.column.columnDef) as unknown as QueryDef<T>;
+
+	// `bind:options` below requires a `let` binding even though we never
+	// reassign the reference (Svelte uses the binding for two-way wiring).
+	// eslint-disable-next-line svelte/prefer-const
 	let lastOptions: Array<SelectOption<unknown>> = $state([]);
 
-	const tableContext = getContext<TableContext<T, never>>(TableContext.identifier);
-
-	const editable = $derived(
-		cell.column.columnDef.isEditable(cell.row.original, cell.row.originalIndex)
-	);
+	const tableContext = getContext<TableContext<T, RowIdType>>(TableContext.identifier);
 
 	let valueAsyncCounter = 0;
 	$effect(() => {
@@ -80,126 +87,15 @@
 		});
 	});
 
-	const focusDetails: TableFocusDetails<T, never> = $derived(
-		new TableFocusDetails(cell, tableContext)
-	);
-
-	const wantsToBeEdited = $derived(
-		tableContext.focusStart?.column === focusDetails.coordinates.column &&
-			tableContext.focusEnd?.column === focusDetails.coordinates.column &&
-			tableContext.focusStart.row === focusDetails.coordinates.row &&
-			tableContext.focusEnd.row === focusDetails.coordinates.row &&
-			!tableContext.isMousingDown &&
-			tableContext.focusStartIsBeingEdited
-	);
-
-	let isBeingEdited = $state(false);
-
-	function handleIsEditable(isEditable: boolean): Promise<void> {
-		if (isEditable) {
-			return tick().then(() => {
-				isBeingEdited = true;
-			});
-		} else {
-			if (isBeingEdited) {
-				return tick()
-					.then(() => {
-						if (!tableContext.singleClickEditing) {
-							tableContext.focusStartIsBeingEdited = false;
-						}
-
-						isBeingEdited = false;
-					})
-					.catch(devCatch);
-			}
-		}
-		return Promise.resolve();
-	}
-
-	$effect(() => {
-		void editable;
-		if (wantsToBeEdited) {
-			if (editable instanceof Promise) {
-				editable
-					.then((isEditable) => {
-						return handleIsEditable(isEditable);
-					})
-
-					.catch(devCatch);
-			} else {
-				handleIsEditable(editable).catch(devCatch);
-			}
-		} else {
-			tick()
-				.then(() => {
-					isBeingEdited = false;
-					tableContext.focusStartIsBeingEdited = false;
-				})
-				.catch(devCatch);
-		}
-	});
-
-	let validity: Validity = $state(Validity.Valid);
-	$effect(() => {
-		const validityPromise = focusDetails.validity;
-
-		validityPromise
-			.then((v) => {
-				if (!v) {
-					validity = Validity.Neutral;
-				} else if (isValidityTuple(v)) {
-					validity = v.value;
-				} else {
-					validity = v;
-				}
-			})
-			.catch(devCatch);
+	const editable = useAsyncEditable<T, RowIdType>({
+		cell: () => cell,
 	});
 
-	const handleTDFocus = async () => {
-		if (
-			(await editable) &&
-			tableContext.focusStart?.column === focusDetails.coordinates.column &&
-			tableContext.focusStart.row === focusDetails.coordinates.row
-		) {
-			if (
-				tableContext.focusEnd?.column !== focusDetails.coordinates.column ||
-				tableContext.focusEnd.row !== focusDetails.coordinates.row
-			) {
-				tableContext.setFocusEnd(focusDetails.coordinates);
-			}
-
-			tableContext.isMousingDown = false;
-			tableContext.focusStartIsBeingEdited = true;
-			return true;
-		}
-
-		return false;
-	};
-
-	async function handleSingleClick(): Promise<boolean> {
-		return tableContext.singleClickEditing && (await handleTDFocus());
-	}
-	async function handleDoubleClick(): Promise<boolean> {
-		return !tableContext.singleClickEditing && (await handleTDFocus());
-	}
-
-	function tryHandleTDFocus() {
-		handleTDFocus().catch(devCatch);
-	}
-
 	function handleUnfocus(e: KeyboardEvent) {
 		if (e.key === 'Escape') {
 			e.preventDefault();
 			e.stopPropagation();
-
-			tableContext.focusStartIsBeingEdited = false;
-			tick()
-				.then(() => {
-					tdref?.focus();
-				})
-				.catch(devCatch);
-
+			editable.leaveEditingViaKeyboard(tdref);
 			return true;
 		}
 
@@ -231,50 +127,74 @@
 		}
 	}
 
+	/**
+	 * Tracks the inner QuerySelect input so the keydown re-dispatcher can be
+	 * removed cleanly on blur or remount; the prior implementation accumulated
+	 * one listener per focus event (P1 workorder finding). This wiring is
+	 * genuinely cell-specific (Select / QuerySelect only) and therefore lives
+	 * outside the shared `useAsyncEditable` helper.
+	 */
+	let activeKeydownTarget: HTMLInputElement | undefined;
+
 	function addKeydownEvent(target: HTMLInputElement | undefined) {
-		target?.addEventListener('keydown', keydownForce);
+		if (activeKeydownTarget && activeKeydownTarget !== target) {
+			activeKeydownTarget.removeEventListener('keydown', keydownForce);
+		}
+		if (target) {
+			target.addEventListener('keydown', keydownForce);
+			activeKeydownTarget = target;
+		}
 	}
 
-	let prevtdref: HTMLTableCellElement | undefined = undefined;
-	$effect(() => {
-		void tdref;
-		untrack(() => {
-			if (tdref && tdref != prevtdref) {
-				tdref.addEventListener('edit', tryHandleTDFocus);
-			} else {
-				prevtdref = tdref;
-			}
-		});
-	});
+	function removeKeydownEvent() {
+		if (activeKeydownTarget) {
+			activeKeydownTarget.removeEventListener('keydown', keydownForce);
+			activeKeydownTarget = undefined;
+		}
+	}
+
+	/**
+	 * Effect wires the `edit` custom event with proper cleanup on tdref
+	 * remount or component unmount (replaces the previous `prevtdref` pattern
+	 * that accumulated listeners; P1 workorder finding). The listener wiring
+	 * lives in the shared `useAsyncEditable` helper.
+	 */
+	$effect(() => editable.attachEditListener(tdref));
+
+	// Ensure the keydown listener is dropped when the cell unmounts.
+	$effect(() => removeKeydownEvent);
 </script>
 
-{#if isBeingEdited}
-	<!-- onkeydown={handleInputKeydown} -->
-	<!-- onkeydown={handleEsc} -->
-	<td
+{#if editable.isBeingEdited}
+	<div
 		class="select-cell"
 		bind:this={tdref}
 	>
-		<!-- TODO: -->
 		{#await value then value}
 			<QuerySelect
 				focusOnLoad
 				name={cell.column.columnDef.id}
-				valueProp="value"
-				labelProp="label"
+				valueProp={'value' as never}
+				labelProp={'label' as never}
 				clearable={cell.column.columnDef.clearable}
 				valueAsObject={false}
-				{value}
+				value={value as never}
 				query={(v: string) => columnDef.query(v, cell.row.original, cell.row.originalIndex)}
-				bind:options={lastOptions}
+				bind:options={lastOptions as never}
 				onfocus={addKeydownEvent}
-				onchange={(newValue: SelectOption<unknown> | null) => {
-					if (newValue?.value !== value) {
+				onchange={(newValue: unknown) => {
+					// Phase 7.6: `valueAsObject={false}` means QuerySelect
+					// hands us the primitive value directly; no more
+					// `.value` dig off an option object. The `as never`
+					// casts work around inference: see TableSelect for the
+					// same workaround.
+					if (newValue !== value) {
 						tableContext
-							.onEditCell(cell.row.original, focusDetails.coordinates, newValue?.value ?? null)
+							.onEditCell(cell.row.original, editable.focusDetails.coordinates, newValue ?? null)
 							.catch(devCatch);
 					}
 
+					removeKeydownEvent();
 					tableContext.focusStartIsBeingEdited = false;
 					tick()
 						.then(() => {
@@ -284,47 +204,46 @@
 				}}
 			/>
 		{/await}
-	</td>
+	</div>
 {:else}
-	<!-- // onkeydown={handleTdKeydown} -->
 	<!-- svelte-ignore a11y_mouse_events_have_key_events -->
-	<td
-		style={focusDetails.outline}
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div
+		style={editable.focusDetails.outline}
 		bind:this={tdref}
 		tabIndex="0"
 		id={`${tableContext.tableName}-cell-${cell.row.visibleIndex}-${cell.column.id}`}
 		class="focusable editable"
-		class:multifocus={focusDetails.isMultiFocused}
-		class:multifocus-start={focusDetails.isMultiFocusStart}
-		class:info={validity == Validity.Info}
-		class:success={validity == Validity.Valid}
-		class:warning={validity == Validity.Warning}
-		class:error={validity == Validity.Invalid}
-		ondblclick={handleDoubleClick}
+		class:multifocus={editable.focusDetails.isMultiFocused}
+		class:multifocus-start={editable.focusDetails.isMultiFocusStart}
+		class:info={editable.validity == Validity.Info}
+		class:success={editable.validity == Validity.Valid}
+		class:warning={editable.validity == Validity.Warning}
+		class:error={editable.validity == Validity.Invalid}
+		ondblclick={() => {
+			editable.handleDoubleClickFocus();
+		}}
 		onmousedown={(e) => {
 			// start focus only on left click
 			if (e.button === 0) {
 				if (e.shiftKey) {
 					e.preventDefault();
-					tableContext.setFocusEnd(focusDetails.coordinates);
+					tableContext.setFocusEnd(editable.focusDetails.coordinates);
 				} else {
-					tableContext.startFocus(focusDetails.coordinates);
+					tableContext.startFocus(editable.focusDetails.coordinates);
 				}
 			}
 		}}
 		onmouseover={() => {
 			if (tableContext.isMousingDown) {
-				tableContext.setFocusEnd(focusDetails.coordinates);
+				tableContext.setFocusEnd(editable.focusDetails.coordinates);
 			}
 		}}
 		onmouseup={() => {
-			handleSingleClick()
-				.then((wasHandled) => {
-					if (!wasHandled) {
-						tableContext.endFocus(focusDetails.coordinates);
-					}
-				})
-				.catch(devCatch);
+			const wasHandled = editable.handleSingleClickFocus();
+			if (!wasHandled) {
+				tableContext.endFocus(editable.focusDetails.coordinates);
+			}
 		}}
 	>
 		{#await visibleValue}
@@ -332,10 +251,14 @@
 		{:then v}
 			{v}
 		{/await}
-	</td>
+	</div>
 {/if}
 
-<style>td {
+<style>.focusable,
+.checkbox-cell,
+.input-cell,
+.select-cell,
+.datepicker-cell {
   transition: line-height 0.2s ease, height 0.2s ease;
   --input-border: none;
   --input-height: var(--height);
@@ -345,47 +268,61 @@
   position: relative;
   padding-left: 0.75rem;
   padding-right: 0.75rem;
-  border: solid 1px #cbd4da;
-  border-left: none;
+  border-right: solid 1px #cbd4da;
+  border-bottom: solid 1px #cbd4da;
+  box-sizing: border-box;
+  width: 100%;
+  height: var(--height);
 }
 
-td.multifocus {
+.focusable.multifocus,
+.checkbox-cell.multifocus,
+.input-cell.multifocus,
+.select-cell.multifocus {
   background-color: var(--multifocus-colour, #e6f8fd);
 }
-td.multifocus.multifocus-start {
+.focusable.multifocus.multifocus-start,
+.checkbox-cell.multifocus.multifocus-start,
+.input-cell.multifocus.multifocus-start,
+.select-cell.multifocus.multifocus-start {
   background-color: #ffffff;
 }
 
-td.focusable {
+.focusable {
   user-select: none;
   cursor: default;
   outline: none;
 }
-td.focusable.editable {
+.focusable.editable {
   cursor: pointer;
 }
 
-td.info {
+.focusable.info,
+.checkbox-cell.info,
+.input-cell.info,
+.select-cell.info {
   background-color: #1f81a0;
 }
-td.warning {
+.focusable.warning,
+.checkbox-cell.warning,
+.input-cell.warning,
+.select-cell.warning {
   background-color: #f8eab8;
 }
-td.error {
+.focusable.error,
+.checkbox-cell.error,
+.input-cell.error,
+.select-cell.error {
   background-color: #f9e9e9;
 }
 
-td.select-cell {
+.select-cell {
   padding: unset;
   box-sizing: border-box;
-  vertical-align: middle;
   text-align: center;
-}
-
-td {
   --sv-border: none;
 }
-td :global(.select-wrapper) {
+.select-cell :global(.select-wrapper) {
   --sv-min-height: 0px;
   --sv-general-padding: 0px;
   --sv-item-wrap-padding: 0px 0.75rem;

package/dist/Components/Table/Body/Rows/Columns/TableQuerySelect.svelte.d.ts

@@ -1,25 +1,26 @@
+import { type Primitive } from '../../../Types/Context/TableInitOptions.js';
 import type { TableQuerySelectProps } from './TableQuerySelectProps.js';
-declare function $$render<T extends object>(): {
+declare function $$render<T extends object, RowIdType extends Primitive>(): {
     props: TableQuerySelectProps<T, unknown>;
     exports: {};
     bindings: "";
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<T extends object> {
-    props(): ReturnType<typeof $$render<T>>['props'];
-    events(): ReturnType<typeof $$render<T>>['events'];
-    slots(): ReturnType<typeof $$render<T>>['slots'];
+declare class __sveltets_Render<T extends object, RowIdType extends Primitive> {
+    props(): ReturnType<typeof $$render<T, RowIdType>>['props'];
+    events(): ReturnType<typeof $$render<T, RowIdType>>['events'];
+    slots(): ReturnType<typeof $$render<T, RowIdType>>['slots'];
     bindings(): "";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <T extends object>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
-    } & ReturnType<__sveltets_Render<T>['exports']>;
-    <T extends object>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+    new <T extends object, RowIdType extends Primitive>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T, RowIdType>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T, RowIdType>['props']>, ReturnType<__sveltets_Render<T, RowIdType>['events']>, ReturnType<__sveltets_Render<T, RowIdType>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T, RowIdType>['bindings']>;
+    } & ReturnType<__sveltets_Render<T, RowIdType>['exports']>;
+    <T extends object, RowIdType extends Primitive>(internal: unknown, props: ReturnType<__sveltets_Render<T, RowIdType>['props']> & {}): ReturnType<__sveltets_Render<T, RowIdType>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
 }
 declare const TableQuerySelect: $$IsomorphicComponent;
-type TableQuerySelect<T extends object> = InstanceType<typeof TableQuerySelect<T>>;
+type TableQuerySelect<T extends object, RowIdType extends Primitive> = InstanceType<typeof TableQuerySelect<T, RowIdType>>;
 export default TableQuerySelect;

package/dist/Components/Table/Body/Rows/Columns/TableQuerySelectProps.d.ts

@@ -1,4 +1,12 @@
 import type { TableQueryCell } from './TableQueryCell.js';
+/**
+ * Props for {@link TableQuerySelect}. The cell shows the awaited display
+ * value out of edit mode and opens a `QuerySelect` (backed by
+ * `QueryDef.query`) in edit mode. Callers forwarding raw user input through
+ * the `QueryDef.query` callback must follow the security guidance documented
+ * on `QueryDef`.
+ */
 export interface TableQuerySelectProps<T extends object, FilterValueType> {
+    /** The query-backed cell to render. */
     cell: TableQueryCell<T, FilterValueType>;
 }

package/dist/Components/Table/Body/Rows/Columns/TableRowSelectionCheckbox.svelte

@@ -5,30 +5,26 @@
 	module
 >
 	import type { RowSelectionDef } from '../../../Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.js';
-	import type { TableCell } from '../../../Types/Columns/TableCell.js';
 	import { TableContext } from '../../../Types/Context/TableContext.svelte.js';
 	import { type Primitive } from '../../../Types/Context/TableInitOptions.js';
-	import { TableFocusDetails } from '../../../Types/Focus/TableFocusDetails.svelte.js';
+	import type { TableFocusDetails } from '../../../Types/Focus/TableFocusDetails.svelte.js';
 	import { devCatch, isValidityTuple } from '../../../../../Helpers/Helpers.svelte.js';
 	import { Validity } from '../../../../../Types/Internal/Validity.js';
 	import { getContext, tick, untrack } from 'svelte';
 	import type { ChangeEventHandler } from 'svelte/elements';
-
-	export interface TableCheckboxProps<T extends object> {
-		cell: TableCell<T>;
-	}
+	import type { TableRowSelectionCheckboxProps } from './TableRowSelectionCheckboxProps.js';
 </script>
 
 <script
 	lang="ts"
-	generics="T extends object,RowIdType extends Primitive"
+	generics="T extends object, RowIdType extends Primitive"
 >
-	const { cell }: TableCheckboxProps<T> = $props();
+	const { cell }: TableRowSelectionCheckboxProps<T> = $props();
 
 	const tableContext = getContext<TableContext<T, RowIdType>>(TableContext.identifier);
 
 	const focusDetails: TableFocusDetails<T, RowIdType> = $derived(
-		new TableFocusDetails(cell, tableContext)
+		tableContext._focus.getFocusDetailsFor(cell)
 	);
 
 	const keyOrPromise: RowIdType | Promise<RowIdType> = $derived(
@@ -55,7 +51,7 @@
 		}
 	});
 
-	// Sync path (common): uses selectedItems.has(key) for per-key reactive tracking —
+	// Sync path (common): uses selectedItems.has(key) for per-key reactive tracking -
 	// only this row's checkbox re-runs when its specific key changes.
 	// Async path (rare): returns null and defers to _isSelectedAsync updated by the $effect below.
 	const isSelected: boolean | null = $derived.by(() => {
@@ -123,7 +119,8 @@
 </script>
 
 <!-- svelte-ignore a11y_mouse_events_have_key_events -->
-<td
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div
 	class="checkbox-cell"
 	class:info={validity == Validity.Info}
 	class:success={validity == Validity.Valid}
@@ -152,7 +149,6 @@
 			tableContext.toggleSelected(cell.row.original)?.catch(devCatch);
 
 			inputRef?.dispatchEvent(new InputEvent('change'));
-			// tableContext.onEditCell(cell.row.original, focusDetails.coordinates, !value);
 		}
 	}}
 	onmouseover={() => {
@@ -178,9 +174,13 @@
 			disabled={!isSelectable || tableContext.showSelectedOnly}
 		/>
 	</label>
-</td>
+</div>
 
-<style>td {
+<style>.focusable,
+.checkbox-cell,
+.input-cell,
+.select-cell,
+.datepicker-cell {
   transition: line-height 0.2s ease, height 0.2s ease;
   --input-border: none;
   --input-height: var(--height);
@@ -190,8 +190,11 @@
   position: relative;
   padding-left: 0.75rem;
   padding-right: 0.75rem;
-  border: solid 1px #cbd4da;
-  border-left: none;
+  border-right: solid 1px #cbd4da;
+  border-bottom: solid 1px #cbd4da;
+  box-sizing: border-box;
+  width: 100%;
+  height: var(--height);
 }
 
 input[type=checkbox] {
@@ -230,12 +233,21 @@ label.multifocus.multifocus-start {
   background-color: #ffffff;
 }
 
-td.info {
+.focusable.info,
+.checkbox-cell.info,
+.input-cell.info,
+.select-cell.info {
   background-color: #1f81a0;
 }
-td.warning {
+.focusable.warning,
+.checkbox-cell.warning,
+.input-cell.warning,
+.select-cell.warning {
   background-color: #f8eab8;
 }
-td.error {
+.focusable.error,
+.checkbox-cell.error,
+.input-cell.error,
+.select-cell.error {
   background-color: #f9e9e9;
 }</style>

package/dist/Components/Table/Body/Rows/Columns/TableRowSelectionCheckbox.svelte.d.ts

@@ -1,10 +1,7 @@
-import type { TableCell } from '../../../Types/Columns/TableCell.js';
 import { type Primitive } from '../../../Types/Context/TableInitOptions.js';
-export interface TableCheckboxProps<T extends object> {
-    cell: TableCell<T>;
-}
+import type { TableRowSelectionCheckboxProps } from './TableRowSelectionCheckboxProps.js';
 declare function $$render<T extends object, RowIdType extends Primitive>(): {
-    props: TableCheckboxProps<T>;
+    props: TableRowSelectionCheckboxProps<T>;
     exports: {};
     bindings: "";
     slots: {};

package/dist/Components/Table/Body/Rows/Columns/TableRowSelectionCheckboxProps.d.ts

@@ -0,0 +1,14 @@
+import type { TableCell } from '../../../Types/Columns/TableCell.js';
+/**
+ * Props for {@link TableRowSelectionCheckbox}. The cell renders a checkbox
+ * whose checked state mirrors `TableContext.selectedItems` and whose toggle
+ * goes through `TableContext.toggleSelected`.
+ *
+ * Renamed from the previous inline `TableCheckboxProps` (which collided
+ * with the unrelated `TableCheckbox` cell's props of the same name) per
+ * the type-strictness workorder finding.
+ */
+export interface TableRowSelectionCheckboxProps<T extends object> {
+    /** The row-selection cell to render. */
+    cell: TableCell<T>;
+}

package/dist/Components/Table/Body/Rows/Columns/TableRowSelectionCheckboxProps.js

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