@lavalogic/scoria 0.37.44 → 0.37.46

package/dist/Helpers/Helpers.svelte.js

@@ -68,10 +68,8 @@ export function generateWeakId() {
     return generateUUID().substring(0, 13);
 }
 /**
- * @deprecated - use `generateWeakId`; the short form trades collision
- * resistance for brevity and is NOT suitable for security tokens. The
- * rename is part of the SecureUUIDs follow-up; this alias is preserved
- * to avoid breaking existing consumers in the same release.
+ * @deprecated use `generateWeakId`. This short-form id trades collision
+ * resistance for brevity and is NOT suitable for security tokens.
  */
 export function generateShortUUID() {
     return generateWeakId();
@@ -247,6 +245,101 @@ export const localTimeFormat = new Intl.DateTimeFormat('en-GB', {
     second: '2-digit',
     timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
 });
+/**
+ * Default locale used by {@link formatDate} / {@link formatDateTime}
+ * when a caller does not pass one explicitly. UK English — a 24-hour
+ * clock and `DD/MM/YYYY` day-first ordering.
+ */
+export const defaultDateLocale = 'en-GB';
+/**
+ * Per-locale caches of `Intl.DateTimeFormat` instances. Constructing a
+ * formatter is comparatively expensive, so the first call for a given
+ * locale builds it and every later call for that locale reuses it. The
+ * caches only ever grow and hold immutable formatters, so they are safe
+ * to share across SSR requests.
+ */
+const dateTimeFormatters = {};
+const dateFormatters = {};
+/** Build (and cache) a full date + time formatter for `locale`. */
+function dateTimeFormatterFor(locale) {
+    return (dateTimeFormatters[locale] ??= new Intl.DateTimeFormat(locale, {
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+        hour: '2-digit',
+        hourCycle: 'h23',
+        minute: '2-digit',
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    }));
+}
+/** Build (and cache) a date-only formatter for `locale`. */
+function dateFormatterFor(locale) {
+    return (dateFormatters[locale] ??= new Intl.DateTimeFormat(locale, {
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    }));
+}
+/**
+ * Canonical date + time display formatter. Use this anywhere a
+ * timestamp is shown to a user — table cells, cards, modals, headers —
+ * so every surface formats identically.
+ *
+ * The optional `locale` (a BCP-47 tag such as `'en-GB'`, `'en-US'`,
+ * `'de-DE'`) selects the display conventions: it drives the
+ * day/month/year ordering and separators — `en-GB` → `19/05/2026,
+ * 14:30`, `en-US` → `05/19/2026, 14:30`. It defaults to
+ * {@link defaultDateLocale}. The clock is always 24-hour and the
+ * timezone is the runtime-resolved one regardless of locale.
+ *
+ * - `Date` values format directly.
+ * - `string` / `number` values are parsed via `new Date(...)`. An
+ *   unparseable string is returned unchanged (so a non-date value is
+ *   not silently blanked); an unparseable number yields `''`.
+ * - `null` / `undefined` / empty string yield `''`.
+ *
+ * For a time-only render use {@link localTimeFormat}; for a date with
+ * no time use {@link formatDate}; for the SQL-backend serialisation
+ * shapes use {@link SQLFriendly} / {@link SQLFriendlyWithLocalTime}.
+ */
+export function formatDateTime(value, locale = defaultDateLocale) {
+    if (value == null || value === '') {
+        return '';
+    }
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return typeof value === 'string' ? value : '';
+    }
+    return dateTimeFormatterFor(locale).format(date);
+}
+/**
+ * Canonical date-only display formatter. Use this for values that carry
+ * no meaningful time component — due dates, expiry dates, pod-line date
+ * attributes — so every surface formats identically. When the value
+ * also has a time the user needs to see, use {@link formatDateTime}.
+ *
+ * The optional `locale` works exactly as in {@link formatDateTime} — it
+ * selects the day/month/year ordering and separators and defaults to
+ * {@link defaultDateLocale}.
+ *
+ * Parsing and null-handling match {@link formatDateTime}: a `Date`
+ * formats directly; `string` / `number` are parsed via `new Date(...)`;
+ * an unparseable string is returned unchanged; `null` / `undefined` /
+ * empty string yield `''`.
+ */
+export function formatDate(value, locale = defaultDateLocale) {
+    if (value == null || value === '') {
+        return '';
+    }
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return typeof value === 'string' ? value : '';
+    }
+    return dateFormatterFor(locale).format(date);
+}
 /**
  * Barcode-scanner helper. Wire as an `onkeydown` on **buttons and
  * other non-text focusable elements** that should yield focus when a

package/dist/Helpers/dropdownPortal.d.ts

@@ -1,50 +1,35 @@
 /**
  * Portal helper for Svelecte-style dropdowns.
  *
- * Svelecte renders its `.sv_dropdown` element inline as a sibling of the
- * `.svelecte-control` trigger. That means the dropdown is clipped by
- * any ancestor with `overflow: hidden` / `overflow: auto`, sits below
- * any ancestor with a higher `z-index`, and is repositioned by any
- * `transform` / `filter` / `will-change: transform` on the way up to
- * the body.
+ * Svelecte renders its `.sv_dropdown` inline as a sibling of the
+ * `.svelecte-control` trigger, so the dropdown is clipped by ancestor
+ * overflow, sits below higher-z-index ancestors, and is repositioned by
+ * any `transform` / `filter` on the way up to the body. This helper fixes
+ * those without moving the element in the DOM.
  *
- * This helper does NOT move the dropdown in the DOM. Moving the
- * `.sv_dropdown` element to `document.body` (the original strategy)
- * broke Svelte 5's per-component event delegation: inline
- * `onmousedown` / `onclick` handlers declared in Svelecte's template
- * are dispatched by the app's root-level delegated listener, which
- * walks the live `parentNode` chain at dispatch time. Once the
- * dropdown was a sibling of the app root rather than a descendant,
- * the chain no longer reached the selection handler, so mouse clicks
- * silently did nothing (keyboard Enter still worked because that
- * path is wired on the input, not the dropdown).
+ * **Do NOT move the dropdown to `document.body`.** Svelte 5's root-level
+ * event delegation walks the live `parentNode` chain at dispatch time;
+ * if the dropdown is a sibling of the app root rather than a descendant
+ * of the mount target, Svelecte's inline `onmousedown` / `onclick` selection
+ * handlers never fire. Mouse selection silently breaks while keyboard Enter
+ * (wired on the input) keeps working, making the regression hard to spot.
  *
- * Instead, the helper:
+ * Instead, when the dropdown opens this helper:
  *
- *   1. Switches the dropdown to `position: fixed` and sets
- *      `top` / `left` / `width` / `bottom` from the trigger's
- *      `getBoundingClientRect()`, so it escapes ancestor
- *      `overflow: hidden` / `overflow: auto` clipping (which was
- *      the original motivation for portaling).
- *   2. Picks `top` vs `bottom` based on available space below vs
- *      above the trigger, so the dropdown auto-flips upwards when
- *      the trigger sits near the bottom of the viewport.
- *   3. Listens for capture-phase `scroll` events and for viewport
- *      `resize` events so the position tracks the trigger while
- *      the dropdown is open. Repositioning is rAF-throttled.
- *   4. Applies a very large `z-index` to the dropdown AND
- *      temporarily lifts the dropdown's nearest stacking-context
- *      ancestor (the sticky / isolated table strip that contains
- *      the trigger) so the dropdown's z-index can actually win
- *      against other peer stacking contexts in the same parent.
- *      Without the lift the dropdown's z-index was trapped inside
- *      its ancestor's own context and could be hidden by an
- *      adjacent sibling stacking context with even a small
- *      z-index - which is exactly what happened with the table's
- *      sticky footer covering open cell dropdowns (or, after the
- *      initial fix, the table body covering open footer
- *      dropdowns). The lift is ref-counted so two dropdowns that
- *      share an ancestor coordinate cleanly.
+ *   1. Switches it to `position: fixed` and writes `top` / `left` / `width`
+ *      from the trigger's `getBoundingClientRect()`, escaping ancestor
+ *      overflow clipping.
+ *   2. Picks `top` vs `bottom` based on available viewport space, so the
+ *      dropdown flips upwards near the viewport bottom.
+ *   3. Listens (rAF-throttled) for capture-phase scroll + viewport resize
+ *      so the position tracks the trigger.
+ *   4. Sets a very large `z-index` on the dropdown AND lifts the dropdown's
+ *      nearest stacking-context ancestor for the lifetime of the open. The
+ *      lift is needed because z-index only competes inside the ancestor's
+ *      own stacking context: without it, a sibling sticky/isolated block
+ *      (the table footer, the table body) can paint over the dropdown
+ *      despite the dropdown's higher z-index. The lift is ref-counted so
+ *      two dropdowns sharing an ancestor coordinate cleanly.
  */
 export interface DropdownPortalOptions {
     /** The Svelecte root wrapper `<div class="svelecte">`. Used as the

package/dist/Helpers/dropdownPortal.js

@@ -1,84 +1,53 @@
 /**
  * Portal helper for Svelecte-style dropdowns.
  *
- * Svelecte renders its `.sv_dropdown` element inline as a sibling of the
- * `.svelecte-control` trigger. That means the dropdown is clipped by
- * any ancestor with `overflow: hidden` / `overflow: auto`, sits below
- * any ancestor with a higher `z-index`, and is repositioned by any
- * `transform` / `filter` / `will-change: transform` on the way up to
- * the body.
+ * Svelecte renders its `.sv_dropdown` inline as a sibling of the
+ * `.svelecte-control` trigger, so the dropdown is clipped by ancestor
+ * overflow, sits below higher-z-index ancestors, and is repositioned by
+ * any `transform` / `filter` on the way up to the body. This helper fixes
+ * those without moving the element in the DOM.
  *
- * This helper does NOT move the dropdown in the DOM. Moving the
- * `.sv_dropdown` element to `document.body` (the original strategy)
- * broke Svelte 5's per-component event delegation: inline
- * `onmousedown` / `onclick` handlers declared in Svelecte's template
- * are dispatched by the app's root-level delegated listener, which
- * walks the live `parentNode` chain at dispatch time. Once the
- * dropdown was a sibling of the app root rather than a descendant,
- * the chain no longer reached the selection handler, so mouse clicks
- * silently did nothing (keyboard Enter still worked because that
- * path is wired on the input, not the dropdown).
+ * **Do NOT move the dropdown to `document.body`.** Svelte 5's root-level
+ * event delegation walks the live `parentNode` chain at dispatch time;
+ * if the dropdown is a sibling of the app root rather than a descendant
+ * of the mount target, Svelecte's inline `onmousedown` / `onclick` selection
+ * handlers never fire. Mouse selection silently breaks while keyboard Enter
+ * (wired on the input) keeps working, making the regression hard to spot.
  *
- * Instead, the helper:
+ * Instead, when the dropdown opens this helper:
  *
- *   1. Switches the dropdown to `position: fixed` and sets
- *      `top` / `left` / `width` / `bottom` from the trigger's
- *      `getBoundingClientRect()`, so it escapes ancestor
- *      `overflow: hidden` / `overflow: auto` clipping (which was
- *      the original motivation for portaling).
- *   2. Picks `top` vs `bottom` based on available space below vs
- *      above the trigger, so the dropdown auto-flips upwards when
- *      the trigger sits near the bottom of the viewport.
- *   3. Listens for capture-phase `scroll` events and for viewport
- *      `resize` events so the position tracks the trigger while
- *      the dropdown is open. Repositioning is rAF-throttled.
- *   4. Applies a very large `z-index` to the dropdown AND
- *      temporarily lifts the dropdown's nearest stacking-context
- *      ancestor (the sticky / isolated table strip that contains
- *      the trigger) so the dropdown's z-index can actually win
- *      against other peer stacking contexts in the same parent.
- *      Without the lift the dropdown's z-index was trapped inside
- *      its ancestor's own context and could be hidden by an
- *      adjacent sibling stacking context with even a small
- *      z-index - which is exactly what happened with the table's
- *      sticky footer covering open cell dropdowns (or, after the
- *      initial fix, the table body covering open footer
- *      dropdowns). The lift is ref-counted so two dropdowns that
- *      share an ancestor coordinate cleanly.
+ *   1. Switches it to `position: fixed` and writes `top` / `left` / `width`
+ *      from the trigger's `getBoundingClientRect()`, escaping ancestor
+ *      overflow clipping.
+ *   2. Picks `top` vs `bottom` based on available viewport space, so the
+ *      dropdown flips upwards near the viewport bottom.
+ *   3. Listens (rAF-throttled) for capture-phase scroll + viewport resize
+ *      so the position tracks the trigger.
+ *   4. Sets a very large `z-index` on the dropdown AND lifts the dropdown's
+ *      nearest stacking-context ancestor for the lifetime of the open. The
+ *      lift is needed because z-index only competes inside the ancestor's
+ *      own stacking context: without it, a sibling sticky/isolated block
+ *      (the table footer, the table body) can paint over the dropdown
+ *      despite the dropdown's higher z-index. The lift is ref-counted so
+ *      two dropdowns sharing an ancestor coordinate cleanly.
  */
 /**
- * Z-index applied to the open dropdown. Picked very high so the
- * dropdown sits above sticky table strips (`z 5-11` in the table
- * grid), the table footer (`z 10`), and the side-panel chrome, but
- * stays below modal overlays (`z 99999` in `Action`-based popovers).
+ * Z-index for the open dropdown. Above sticky table strips and the table
+ * footer, below modal overlays (`Action`-based popovers use `99999`).
  */
 const PORTAL_Z_INDEX = 99998;
 /**
- * Z-index applied to the dropdown's nearest stacking-context ancestor
- * while the dropdown is open. One below `PORTAL_Z_INDEX` so the
- * dropdown still wins inside its own stacking context, but high
- * enough that the whole ancestor block paints above its peer stacking
- * contexts (e.g. the table footer's `position: sticky; z-index: 10`
- * row, or the table body's `isolation: isolate; z-index: 20`
- * container). Without this lift, the dropdown's `z-index: 99998` was
- * trapped inside the ancestor's own stacking context and could not
- * paint above a sibling stacking context with even a small z-index.
- *
- * The previous workaround pinned `.datatable-grid` at `z-index: 20`
- * so its cell dropdowns sat above the footer; that fixed the cell
- * case but reversed the failure for the footer's `Records-per-Page`
- * select, whose dropdown opens upwards into the rows. Lifting the
- * dropdown's actual ancestor at open time means both cases work
- * without either side needing a hard-coded z-index bias.
+ * Z-index applied to the dropdown's stacking-context ancestor while open.
+ * One below `PORTAL_Z_INDEX` so the dropdown still wins inside its own
+ * context, but high enough that the ancestor block paints above sibling
+ * stacking contexts (e.g. the sticky footer at `z-index: 10`, the body's
+ * `isolation: isolate` container).
  */
 const STACKING_LIFT_Z_INDEX = 99997;
 /**
- * Walk up the DOM from `el` and return the first ancestor that
- * establishes a new CSS stacking context. The dropdown's z-index
- * only competes inside this ancestor's context, so lifting this
- * element is what determines whether the dropdown can paint above a
- * sibling sticky / isolated block. Stops at `document.body` (which
- * doesn't form a useful pivot for the lift).
+ * Walk up from `el` and return the first ancestor that establishes a new
+ * CSS stacking context. The dropdown's z-index only competes inside this
+ * ancestor's context, so this is the element to lift. Stops at `body`.
  */
 function findStackingContextAncestor(el) {
     let current = el.parentElement;
@@ -91,11 +60,10 @@ function findStackingContextAncestor(el) {
     return null;
 }
 /**
- * True when the computed style of `el` causes the browser to
- * establish a new stacking context. Covers the cases that actually
- * appear in scoria today (sticky / isolated table strips, fixed
- * popover ancestors). Not exhaustive against every CSS feature that
- * triggers a stacking context, but tuned for our tree.
+ * True when the computed style of `el` establishes a new stacking context.
+ * Covers the cases scoria's tree actually produces (sticky / isolated
+ * strips, fixed popover ancestors). Not exhaustive against every CSS
+ * feature that triggers one — extend if a new case surfaces.
  */
 function createsStackingContext(el) {
     const cs = getComputedStyle(el);
@@ -156,24 +124,19 @@ function liftStackingContext(el) {
     };
 }
 /**
- * Minimum free vertical space below the trigger before the dropdown
- * is flipped to open upwards. Picked to fit the default Svelecte
- * dropdown (six rows + search input + padding) plus a little air;
- * dropdowns with longer option lists will still scroll internally
- * inside their fixed-height box.
+ * Minimum free space below the trigger before the dropdown flips upwards.
+ * Sized for the default Svelecte dropdown (six rows + search + padding);
+ * longer lists scroll internally.
  */
 const FLIP_THRESHOLD_PX = 240;
 /**
- * Hard cap on the dropdown's open height, regardless of how much
- * vertical space the trigger leaves between itself and the viewport
- * edge. Matches Svelecte's own `--sv-dropdown-height` default (320px)
- * so a typical dropdown opens at a sensible "six rows plus search
- * input" size and only shrinks below that when the trigger is genuinely
- * close to the viewport edge.
+ * Cap on the dropdown's open height. Matches Svelecte's own
+ * `--sv-dropdown-height` default so typical dropdowns open at six rows plus
+ * search input and only shrink when the trigger is near a viewport edge.
  */
 const MAX_DROPDOWN_HEIGHT_PX = 320;
-/** Run a function on the next animation frame, coalescing repeat
- *  calls so we don't queue dozens of layout reads per scroll burst. */
+/** Run a function on the next animation frame, coalescing repeat calls so
+ *  we don't queue dozens of layout reads per scroll burst. */
 function rafThrottle(fn) {
     let handle = null;
     return {
@@ -233,13 +196,10 @@ export function attachDropdownPortal(options) {
         dropdown.style.minWidth = `${tr.width}px`;
         dropdown.style.maxWidth = `${tr.width}px`;
         dropdown.style.zIndex = String(PORTAL_Z_INDEX);
-        // Cap the dropdown height at `MAX_DROPDOWN_HEIGHT_PX` regardless
-        // of how much space the trigger has below / above it - we never
-        // want the dropdown to be as tall as the viewport just because
-        // the option list could fit. The `Math.max(..., 64)` floor
-        // stops the dropdown from collapsing to a single-row sliver
-        // when the trigger is genuinely pinned against the viewport
-        // edge; the inner scroll handles the rest.
+        // Cap at `MAX_DROPDOWN_HEIGHT_PX` so a long option list never paints
+        // at viewport height. The 64px floor keeps the dropdown legible when
+        // the trigger is pinned against a viewport edge; the inner scroll
+        // handles the rest.
         const availableHeightPx = openUp
             ? Math.min(MAX_DROPDOWN_HEIGHT_PX, Math.max(spaceAbove - 8, 64))
             : Math.min(MAX_DROPDOWN_HEIGHT_PX, Math.max(spaceBelow - 8, 64));
@@ -252,22 +212,11 @@ export function attachDropdownPortal(options) {
             dropdown.style.bottom = '';
         }
         dropdown.style.maxHeight = `${availableHeightPx}px`;
-        // Svelecte's inner `.sv-dropdown-scroll` element has its own
-        // `max-height: var(--sv-dropdown-height, 320px); overflow-y:
-        // auto` rule, AND the outer `.sv_dropdown` element has
-        // `overflow-y: auto` by default. When the trigger is near the
-        // viewport edge our outer `max-height` is forced below 320px,
-        // so both ended up with their own scrollbars (the visible "two
-        // scrollbars stacked" symptom). Two complementary fixes:
-        //   1. Override `--sv-dropdown-height` to match the outer's
-        //      max-height so the inner scroll container shrinks in
-        //      lockstep instead of staying at its 320px default.
-        //   2. Force the outer to `overflow: hidden` so even if the
-        //      inner's actual rendered height nudges a pixel or two
-        //      past the outer's content box (border / padding
-        //      rounding), the outer doesn't sprout its own scrollbar
-        //      on top of the inner's. The inner remains the single
-        //      scroll surface.
+        // Svelecte's outer `.sv_dropdown` and inner `.sv-dropdown-scroll`
+        // both default to scrolling, so when the outer's max-height is
+        // forced below the inner's 320px default the user sees two stacked
+        // scrollbars. Sync the inner's CSS variable to the outer's height
+        // and hide the outer's overflow so only the inner scrolls.
         dropdown.style.setProperty('--sv-dropdown-height', `${availableHeightPx}px`);
         dropdown.style.overflow = 'hidden';
     };
@@ -283,14 +232,11 @@ export function attachDropdownPortal(options) {
             return;
         }
         isOpen = true;
-        // Lift the dropdown's nearest stacking-context ancestor so the
-        // whole block paints above any sibling stacking contexts that
-        // would otherwise hide it. Without this, the dropdown's high
-        // z-index is trapped inside the ancestor's own stacking context.
-        // Resolved from `trigger` rather than `dropdown` because the
-        // dropdown's `position: fixed` makes it its own stacking
-        // context; we want to lift the surrounding sticky / isolated
-        // table strip, not the dropdown itself.
+        // Lift the dropdown's stacking-context ancestor so the whole block
+        // paints above sibling stacking contexts. Resolved from `trigger`
+        // rather than `dropdown` because `position: fixed` makes the
+        // dropdown its own stacking context — we want to lift the
+        // surrounding sticky / isolated strip, not the dropdown itself.
         const stackingAncestor = findStackingContextAncestor(trigger);
         if (stackingAncestor) {
             releaseStackingLift = liftStackingContext(stackingAncestor);

package/dist/Types/Examples/ExampleModal.svelte

@@ -1,39 +1,39 @@
-<svelte:options runes />
-
-<script lang="ts">
-	import DesktopModal from '../../Components/DesktopModal.svelte';
-	import { cssLength } from '../../Helpers/Helpers.svelte.js';
-	import Switch from '../../Components/Switch.svelte';
-	import type { DisplayModalProps } from '../../Components/Table/Types/Public/ColumnOptions.js';
-	import type { ExampleItem } from './ExampleItem.js';
-
-	const { row, close }: DisplayModalProps<ExampleItem> = $props();
-</script>
-
-<DesktopModal
-	width={cssLength('1220px')}
-	headerLabel="Hello World"
-	onclose={close}
-	onsubmit={close}
-	buttons={[{ label: 'Close', callback: close }]}
->
-	<div class="wrapper">
-		This is an Example modal where you can do additional work through the `row` prop or a custom
-		context.
-		<div>
-			<Switch
-				label="{row.id} checked?"
-				value={row.isChecked}
-				onchange={() => {
-					row.isChecked = !row.isChecked;
-				}}
-			/>
-		</div>
-	</div>
-</DesktopModal>
-
+<svelte:options runes />
+
+<script lang="ts">
+	import DesktopModal from '../../Components/DesktopModal.svelte';
+	import { cssLength } from '../../Helpers/Helpers.svelte.js';
+	import Switch from '../../Components/Switch.svelte';
+	import type { DisplayModalProps } from '../../Components/Table/Types/Public/ColumnOptions.js';
+	import type { ExampleItem } from './ExampleItem.js';
+
+	const { row, close }: DisplayModalProps<ExampleItem> = $props();
+</script>
+
+<DesktopModal
+	width={cssLength('1220px')}
+	headerLabel="Hello World"
+	onclose={close}
+	onsubmit={close}
+	buttons={[{ label: 'Close', callback: close }]}
+>
+	<div class="wrapper">
+		This is an Example modal where you can do additional work through the `row` prop or a custom
+		context.
+		<div>
+			<Switch
+				label="{row.id} checked?"
+				value={row.isChecked}
+				onchange={() => {
+					row.isChecked = !row.isChecked;
+				}}
+			/>
+		</div>
+	</div>
+</DesktopModal>
+
 <style>.wrapper div {
   box-sizing: border-box;
   margin-top: 1rem;
   width: 300px;
-}</style>
+}</style>

package/dist/index.d.ts

@@ -103,7 +103,6 @@ export { type SwitchProps } from './Components/SwitchProps.js';
 export type { TabGroupButtonProps } from './Components/TabGroupButtonProps.js';
 export { default as Table, type TableProps } from './Components/Table/Table.svelte';
 export { createTable, customRows, localRows, remoteRows, } from './Components/Table/createTable.svelte.js';
-export type { ColumnSpecInternals } from './Components/Table/ColumnFactory.svelte.js';
 export type { ActionsColumnOptions, AnyEditEvent, BaseColumnOptions, BooleanKeyOf, BubbleColumnOptions, CheckboxColumnOptions, ClipboardApi, ColumnFactory as TableColumnFactory, ColumnKind, ColumnSpec, ColumnsApi, CreateTableOptions, CustomRowSource, DateColumnOptions, DateKeyOf, DisplayColumnOptions, DisplayModalProps, ExpandColumnOptions, ExpandInnerTableOptions, FilterOnlyColumnOptions, FilteringApi, FocusApi, LiteralRowIdKey, LocalRowSource, ModalApi, NumberColumnOptions, NumberKeyOf, PaginationApi, PreferencesApi, ProgressColumnOptions, QueryColumnOptions, RemoteRowSource, RowAction, RowFetchRequest, RowFetchResponse, RowSelectionColumnOptions, RowSource, SavedPreset, SelectColumnOptions, SelectionApi, SelectionOptions, SortingApi, StringKeyOf, Table as TableInstance, TableInitialState, TablePersistence, TablePersistenceObject, TableStorageAdapter, TextColumnOptions, ValidityColumnOptions, } from './Components/Table/Types/Public/index.js';
 export { type CellCoordinates } from './Components/Table/Types/Coordinates/CellCoordinates.js';
 export { type ColumnPinningState } from './Components/Table/Types/Columns/ColumnPinningState.js';
@@ -168,7 +167,7 @@ export { TooltipContext } from './Contexts/TooltipContext.svelte.js';
 export { UntypedInputContext } from './Contexts/UntypedInputContext.svelte.js';
 export { Delay } from './Delay/Delay.js';
 export { DATAMatrix } from './Helpers/Datamatrix.js';
-export { asyncAll, asyncEvery, asyncFilter, asyncFilterIndices, asyncFlatMap, asyncForEach, asyncMap, asyncSleep, asyncSome, autoPluralise, cssLength, devCatch, ellipses, generateShortUUID, generateUUID, generateWeakId, getCanvasContext, getErrorMessage, gridItem, isDateTuple, isNumericArray, isValidEmailAddress, loadingText, localTimeFormat, passthrough, refWrapper, scoriaStorageKey, SQLFriendly, SQLFriendlyWithLocalTime, vowels, } from './Helpers/Helpers.svelte.js';
+export { asyncAll, asyncEvery, asyncFilter, asyncFilterIndices, asyncFlatMap, asyncForEach, asyncMap, asyncSleep, asyncSome, autoPluralise, cssLength, defaultDateLocale, devCatch, ellipses, formatDate, formatDateTime, generateShortUUID, generateUUID, generateWeakId, getCanvasContext, getErrorMessage, gridItem, isDateTuple, isNumericArray, isValidEmailAddress, loadingText, localTimeFormat, passthrough, refWrapper, scoriaStorageKey, SQLFriendly, SQLFriendlyWithLocalTime, vowels, } from './Helpers/Helpers.svelte.js';
 export { type INamed } from './Helpers/INamed.js';
 export { type PrefersReducedMotionResult, usePrefersReducedMotion, } from './Helpers/prefersReducedMotion.svelte.js';
 export { readJSON, readVersionedJSON, writeJSON } from './Helpers/Storage.js';

package/dist/index.js

@@ -124,7 +124,7 @@ export { TooltipContext } from './Contexts/TooltipContext.svelte.js';
 export { UntypedInputContext } from './Contexts/UntypedInputContext.svelte.js';
 export { Delay } from './Delay/Delay.js';
 export { DATAMatrix } from './Helpers/Datamatrix.js';
-export { asyncAll, asyncEvery, asyncFilter, asyncFilterIndices, asyncFlatMap, asyncForEach, asyncMap, asyncSleep, asyncSome, autoPluralise, cssLength, devCatch, ellipses, 
+export { asyncAll, asyncEvery, asyncFilter, asyncFilterIndices, asyncFlatMap, asyncForEach, asyncMap, asyncSleep, asyncSome, autoPluralise, cssLength, defaultDateLocale, devCatch, ellipses, formatDate, formatDateTime, 
 // eslint-disable-next-line @typescript-eslint/no-deprecated
 generateShortUUID, generateUUID, generateWeakId, getCanvasContext, getErrorMessage, gridItem, isDateTuple, isNumericArray, isValidEmailAddress, loadingText, localTimeFormat, passthrough, refWrapper, scoriaStorageKey, SQLFriendly, SQLFriendlyWithLocalTime, vowels, } from './Helpers/Helpers.svelte.js';
 export {} from './Helpers/INamed.js';

package/dist/scss/_basics.scss

@@ -1,12 +1,12 @@
-@use './colours.scss';
-
-//border
-$border: solid 1px colours.$ui-blue-4;
-$border-mid: solid 2px colours.$ui-blue-4;
-$border-thick: solid 3px colours.$ui-blue-4;
-
-//box-shadow
-$table-focus: 0px 0px 1px 1px colours.$brand-primary inset;
-
-$box-shadow: 0px 0px 5px 0px #0002;
-$error-box-shadow: 0px 0px 5px 0px #aa141422;
+@use './colours.scss';
+
+//border
+$border: solid 1px colours.$ui-blue-4;
+$border-mid: solid 2px colours.$ui-blue-4;
+$border-thick: solid 3px colours.$ui-blue-4;
+
+//box-shadow
+$table-focus: 0px 0px 1px 1px colours.$brand-primary inset;
+
+$box-shadow: 0px 0px 5px 0px #0002;
+$error-box-shadow: 0px 0px 5px 0px #aa141422;