@lavalogic/scoria 0.36.0 → 0.37.0

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

@@ -4,36 +4,51 @@
 	lang="ts"
 	module
 >
+	import type { TableCell } from '../../../Types/Columns/TableCell.js';
+
+	/**
+	 * Props for {@link TableNumberInput}. The cell renders a `NumberInput`
+	 * when the row enters edit mode, otherwise shows the awaited display
+	 * value. Cell value is parsed to `number` through `parseFloat` so that
+	 * decimal values are preserved.
+	 */
 	export interface TableNumberInputProps<T extends object> {
+		/** The number cell to render. */
 		cell: TableCell<T>;
 	}
 </script>
 
 <script
 	lang="ts"
-	generics="T extends object"
+	generics="T extends object, RowIdType extends Primitive"
 >
 	import NumberInput from '../../../../NumberInput.svelte';
 	import { NumberInputDef } from '../../../Types/Columns/Definitions/Accessors/NumberInputDef.svelte.js';
-	import type { TableCell } from '../../../Types/Columns/TableCell.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 { InputVariant } from '../../../../../Types/Internal/InputVariant.js';
 	import { Validity } from '../../../../../Types/Internal/Validity.js';
 	import { getContext, tick, untrack } from 'svelte';
+	import { useAsyncEditable } from './_helpers/useAsyncEditable.svelte.js';
 
 	const { cell }: TableNumberInputProps<T> = $props();
 
+	/**
+	 * Coerce the cell value (which may be a string, number, null, or a promise)
+	 * into a numeric (or numeric-string / null) value usable by `NumberInput`.
+	 * `parseFloat` preserves decimals (the original used `parseInt`, which was
+	 * a P2 workorder finding because it silently truncated `12.34` to `12`).
+	 */
 	const value: Promise<number | string | null> | number | string | null = $derived.by(() => {
 		const _value = cell.getValue();
 
 		return typeof _value === 'string'
-			? parseInt(_value)
+			? parseFloat(_value)
 			: typeof _value === 'number'
 				? _value
 				: ((_value as Promise<string | number | null | undefined> | null | undefined)?.then((v) => {
-						return v === 'string' ? parseInt(v) : (v ?? null);
+						return typeof v === 'string' ? parseFloat(v) : (v ?? null);
 					}) ?? null);
 	});
 	let tempNumericValue: number = $state(0);
@@ -50,129 +65,38 @@
 	});
 
 	function resetValue() {
-		tempNumericValue = typeof value === 'string' ? parseInt(value) : (value as number);
+		tempNumericValue = typeof value === 'string' ? parseFloat(value) : (value as number);
 	}
 
-	let tdref: HTMLTableCellElement | undefined = $state();
+	let tdref: HTMLElement | undefined = $state();
 	let inputRef: HTMLInputElement | undefined = $state();
 
-	const tableContext = getContext<TableContext<T, never>>(TableContext.identifier);
-
-	const editableAsync = $derived(
-		cell.column.columnDef.isEditable(cell.row.original, cell.row.originalIndex)
-	);
-	let editable = $state(false);
-	let asyncCounter = 0;
-	$effect(() => {
-		void editableAsync;
-		const localCounter = (asyncCounter = asyncCounter + 1);
-		(async () => {
-			try {
-				const isEditable = await editableAsync;
-				if (asyncCounter === localCounter) {
-					editable = isEditable;
-				} else if (cell.column.columnDef.debug) {
-					console.log('skipping async editable because it is stale');
-				}
-			} catch (e) {
-				if (cell.column.columnDef.debug) {
-					console.error(e);
-				}
-				if (asyncCounter === localCounter) {
-					editable = false;
-				} else if (cell.column.columnDef.debug) {
-					console.log('skipping async editable because it is stale');
-				}
-			}
-		})().catch(devCatch);
-	});
-
-	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
-	);
+	const tableContext = getContext<TableContext<T, RowIdType>>(TableContext.identifier);
 
-	let isBeingEdited = $state(false);
+	function onBlur(): void {
+		const oldValue = typeof value === 'string' ? parseFloat(value) : value;
 
-	$effect(() => {
-		if (wantsToBeEdited) {
-			if (editable) {
-				tick()
-					.then(() => {
-						untrack(() => {
-							isBeingEdited = true;
-						});
-					})
-					.catch(devCatch);
-			} else {
-				tick()
-					.then(() => {
-						untrack(() => {
-							tableContext.focusStartIsBeingEdited = false;
-						});
-					})
-					.catch(devCatch);
-			}
-		} else {
-			if (isBeingEdited) {
-				untrack(() => {
-					isBeingEdited = false;
-					tick()
-						.then(() => {
-							onBlur();
-						})
-						.catch(devCatch);
-				});
-			}
+		if (oldValue != tempNumericValue) {
+			tableContext
+				.onEditCell(cell.row.original, editable.focusDetails.coordinates, tempNumericValue)
+				.catch(devCatch);
 		}
-	});
-
-	let overrideEdit = $state(false);
 
-	$effect(() => {
-		if (isBeingEdited) {
-			if (overrideEdit) {
-				overrideEdit = false;
-			} else {
-				handleBeingEdited();
-			}
+		if (!tableContext.singleClickEditing) {
+			tableContext.focusStartIsBeingEdited = false;
 		}
-	});
-
-	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,
+		onLeaveEdit: () => {
+			onBlur();
+		},
+		onAfterEnterEdit: () => {
+			inputRef?.select();
+		},
 	});
 
-	function handleBeingEdited() {
-		tableContext.isMousingDown = false;
-		tick()
-			.then(() => {
-				inputRef?.select();
-			})
-			.catch(devCatch);
-	}
-
 	function handleInputKeydown(e: KeyboardEvent) {
 		switch (e.key) {
 			case 'Escape':
@@ -180,25 +104,14 @@
 				e.stopPropagation();
 
 				resetValue();
-				tableContext.focusStartIsBeingEdited = false;
-				tick()
-					.then(() => {
-						tdref?.focus();
-					})
-					.catch(devCatch);
+				editable.leaveEditingViaKeyboard(tdref);
 				break;
 			case 'Enter':
 				e.preventDefault();
 				e.stopPropagation();
 
-				// shouldFocusTDOnBlur.current = true;
-				tableContext.focusStartIsBeingEdited = false;
 				(e.target as HTMLInputElement).blur();
-				tick()
-					.then(() => {
-						tdref?.focus();
-					})
-					.catch(devCatch);
+				editable.leaveEditingViaKeyboard(tdref);
 				break;
 			default: {
 				//ignore other keys
@@ -207,24 +120,6 @@
 		}
 	}
 
-	function onBlur(): void {
-		const oldValue = typeof value === 'string' ? parseInt(value) : value;
-
-		if (oldValue != tempNumericValue) {
-			tableContext
-				.onEditCell(cell.row.original, focusDetails.coordinates, tempNumericValue)
-				.catch(devCatch);
-		}
-
-		if (!tableContext.singleClickEditing) {
-			tableContext.focusStartIsBeingEdited = false;
-		}
-	}
-
-	const onEdit = (e: CustomEvent<{ selectAll: boolean }>) => {
-		handleTDFocus(e.detail.selectAll);
-	};
-
 	function onInputFocus(e: FocusEvent) {
 		(e.target as HTMLInputElement).scrollIntoView({
 			behavior: 'instant',
@@ -233,70 +128,16 @@
 		});
 	}
 
-	function handleTDFocus(selectAll: boolean = false): boolean {
-		if (
-			tableContext.focusStart?.column === focusDetails.coordinates.column &&
-			tableContext.focusStart.row === focusDetails.coordinates.row &&
-			editable
-		) {
-			if (
-				tableContext.focusEnd?.column !== focusDetails.coordinates.column ||
-				tableContext.focusEnd.row !== focusDetails.coordinates.row
-			) {
-				tableContext.setFocusEnd(focusDetails.coordinates);
-			}
-
-			resetValue();
-			tableContext.isMousingDown = false;
-
-			if (!selectAll) {
-				overrideEdit = true;
-
-				tableContext.isMousingDown = false;
-				tick()
-					.then(() => {
-						inputRef?.focus();
-					})
-					.catch(devCatch);
-			}
-
-			tableContext.focusStartIsBeingEdited = true;
-
-			return true;
-		}
-
-		return false;
-	}
-
-	function handleSingleClickFocus(): boolean {
-		return tableContext.singleClickEditing && handleTDFocus();
-	}
-
-	function handleDoubleClickFocus() {
-		return !tableContext.singleClickEditing && handleTDFocus();
-	}
-
-	let prevTdRef: HTMLTableCellElement | undefined;
-
-	$effect(() => {
-		let unsubscriber = () => {};
-
-		if (tdref != prevTdRef) {
-			prevTdRef = tdref;
-			prevTdRef?.addEventListener('edit', onEdit);
-			unsubscriber = () => {
-				prevTdRef?.removeEventListener('edit', onEdit);
-			};
-		}
-
-		return unsubscriber;
-	});
+	/**
+	 * Effect wires the custom `edit` event via the shared
+	 * `useAsyncEditable` helper, which returns a cleanup unsubscriber so the
+	 * listener is removed when `tdref` is remounted or the cell unmounts.
+	 */
+	$effect(() => editable.attachEditListener(tdref));
 </script>
 
-{#if isBeingEdited}
-	<!-- {#if true} -->
-
-	<td class="input-cell">
+{#if editable.isBeingEdited}
+	<div class="input-cell">
 		<NumberInput
 			id={`${tableContext.tableName}-cell-${cell.row.visibleIndex}-${cell.column.id}`}
 			min={(cell.column.columnDef as NumberInputDef<T>).min}
@@ -308,54 +149,75 @@
 			bind:inputRef
 		/>
 		<!-- HACK this onBlur is now being called by an effect because otherwise it fires twice -->
-		<!-- onblur={onBlur} -->
-	</td>
+	</div>
 {:else}
 	<!-- svelte-ignore a11y_mouse_events_have_key_events -->
-
-	<td
-		style={focusDetails.outline}
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div
+		style={editable.focusDetails.outline}
 		id={`${tableContext.tableName}-cell-${cell.row.visibleIndex}-${cell.column.id}`}
 		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={() => {
-			const wasHandled = handleSingleClickFocus();
-			if (!wasHandled) {
-				tableContext.endFocus(focusDetails.coordinates);
+			const wasHandled = editable.handleSingleClickFocus();
+			if (wasHandled) {
+				resetValue();
+				tick()
+					.then(() => {
+						inputRef?.focus();
+					})
+					.catch(devCatch);
+			} else {
+				tableContext.endFocus(editable.focusDetails.coordinates);
 			}
 		}}
 		bind:this={tdref}
 		tabIndex="0"
-		class:editable
+		class:editable={editable.editable}
 		class="focusable"
-		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={handleDoubleClickFocus}
-		>{#await visibleValue}
-			{loadingText}
-		{:then value}{value ?? '-'}{/await}</td
+		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={() => {
+			const wasHandled = editable.handleDoubleClickFocus();
+			if (wasHandled) {
+				resetValue();
+				tick()
+					.then(() => {
+						inputRef?.focus();
+					})
+					.catch(devCatch);
+			}
+		}}
 	>
+		{#await visibleValue}
+			{loadingText}
+		{:then value}{value ?? '-'}{/await}
+	</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);
@@ -365,38 +227,55 @@
   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.input-cell {
+.input-cell {
   padding: unset;
   box-sizing: border-box;
-  vertical-align: middle;
 }</style>

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

@@ -1,28 +1,36 @@
+import type { TableCell } from '../../../Types/Columns/TableCell.js';
+/**
+ * Props for {@link TableNumberInput}. The cell renders a `NumberInput`
+ * when the row enters edit mode, otherwise shows the awaited display
+ * value. Cell value is parsed to `number` through `parseFloat` so that
+ * decimal values are preserved.
+ */
 export interface TableNumberInputProps<T extends object> {
+    /** The number cell to render. */
     cell: TableCell<T>;
 }
-import type { TableCell } from '../../../Types/Columns/TableCell.js';
-declare function $$render<T extends object>(): {
+import { type Primitive } from '../../../Types/Context/TableInitOptions.js';
+declare function $$render<T extends object, RowIdType extends Primitive>(): {
     props: TableNumberInputProps<T>;
     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 TableNumberInput: $$IsomorphicComponent;
-type TableNumberInput<T extends object> = InstanceType<typeof TableNumberInput<T>>;
+type TableNumberInput<T extends object, RowIdType extends Primitive> = InstanceType<typeof TableNumberInput<T, RowIdType>>;
 export default TableNumberInput;

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

@@ -1,5 +1,13 @@
 import type { TableCell } from '../../../Types/Columns/TableCell.js';
 import type { TableQueryColumn } from './TableQueryColumn.js';
+/**
+ * Narrowed `TableCell<T>` whose `column` is a `TableQueryColumn`. Consumed by
+ * `TableQuerySelect.svelte` so the cell handle is already pre-narrowed.
+ *
+ * As with `SelectTableCell`, the third generic on `TableQueryColumn`
+ * (`SelectValueType`) is not threaded through; tightening is deferred (see
+ * workorder Cell Glue Types finding 4).
+ */
 export interface TableQueryCell<T extends object, FilterValueType> extends TableCell<T, FilterValueType> {
     column: TableQueryColumn<T, FilterValueType>;
 }

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

@@ -1,5 +1,14 @@
 import type { Column } from '../../../Types/Columns/Column.js';
 import type { QueryDef } from '../../../Types/Columns/Definitions/Accessors/QueryDef.svelte.js';
+/**
+ * Narrowed `Column<T>` whose `columnDef` is a `QueryDef` (asynchronously
+ * fetched select options).
+ *
+ * Variance and default-generic considerations mirror `SelectColumn`: the
+ * defaults (`FilterValueType = T`, `SelectValueType = T`) are retained for
+ * compatibility with current call sites and would be tightened to `unknown`
+ * by a future breaking change.
+ */
 export interface TableQueryColumn<T extends object, in FilterValueType = T, out SelectValueType = T> extends Column<T, FilterValueType, SelectValueType> {
     columnDef: QueryDef<T, FilterValueType, SelectValueType>;
 }