@lavalogic/scoria 0.17.2 → 0.18.0

package/dist/Components/Table/Types/DataRepository/IDataRepository.d.ts

@@ -16,7 +16,7 @@ export interface IDataRepository<T extends object> {
     updateSorting?: OnChangeFn<SortingState>;
     manualSorting?: boolean;
     sorting: SortingState;
-    filtering: ColumnFiltersState<unknown>;
+    filtering: ColumnFiltersState;
     filterModes: SvelteMap<string, FilterMode>;
     setFilterMode: (id: string, mode: FilterMode) => void;
     filterBy: (id: string, value: unknown) => void;

package/dist/Components/Table/Types/DataRepository/ILocalDataRepository.d.ts

@@ -9,7 +9,7 @@ export interface ILocalDataRepository<T extends object> extends IDataRepository<
     setPage: (page: number) => void;
     nextPage: () => void;
     prevPage: () => void;
-    filtering: ColumnFiltersState<unknown>;
+    filtering: ColumnFiltersState;
     filterModes: SvelteMap<string, FilterMode>;
     setFilterMode: (id: string, mode: FilterMode) => void;
     filterBy: (id: string, value: unknown) => void;

package/dist/Components/Table/Types/DataRepository/LocalTableDataRepository.svelte.d.ts

@@ -30,8 +30,8 @@ export declare class LocalTableDataRepository<T extends object> extends TableDat
     private _totalRows;
     get totalRows(): number;
     private _filtering;
-    get filtering(): ColumnFiltersState<unknown>;
-    set filtering(v: ColumnFiltersState<unknown>);
+    get filtering(): ColumnFiltersState;
+    set filtering(v: ColumnFiltersState);
     updateSorting: OnChangeFn<SortingState>;
     readonly paginationType: "Local";
     readonly setFilterMode: (id: string, mode: FilterMode | undefined) => void;

package/dist/Components/Table/Types/DataRepository/LocalTableDataRepository.svelte.js

@@ -9,6 +9,19 @@ export const allowedEmptyFilterModes = new SvelteSet([
     StringFilterMode.null,
     NumberDateFilterMode.null,
 ]);
+const inclusiveFilterModes = new SvelteSet([
+    //strings
+    StringFilterMode.NotEquals,
+    StringFilterMode.NotContains,
+    StringFilterMode.NotStartsWith,
+    StringFilterMode.NotEndsWith,
+    StringFilterMode.NotIn,
+    //numbers and dates
+    NumberDateFilterMode.NotEquals,
+    NumberDateFilterMode.NotIn,
+    NumberDateFilterMode.null,
+]);
+// let totalRedraws = 0;
 export class LocalTableDataRepository extends TableDataRepository {
     addEmptyRow;
     debug;
@@ -98,7 +111,7 @@ export class LocalTableDataRepository extends TableDataRepository {
             const filterMode = this.filterModes.get(id);
             const hasValue = (filterMode && allowedEmptyFilterModes.has(filterMode)) ||
                 (value != null &&
-                    ((typeof value === 'object' && Array.isArray(value) && value.length !== 0) ||
+                    ((Array.isArray(value) && value[0] != null) ||
                         (typeof value === 'string' && value.length !== 0) ||
                         (typeof value !== 'object' && typeof value !== 'string')));
             if (hasValue) {
@@ -113,7 +126,7 @@ export class LocalTableDataRepository extends TableDataRepository {
                         console.log(`LOCAL REPO: no filter mode found for ${id}, skipping value ${value?.toString()}...`);
                     }
                     else {
-                        console.log(`LOCAL REPO: no value found for id ${id}. Skipping...`);
+                        console.log(`LOCAL REPO: no filter value found for id ${id}. Skipping...`);
                     }
                 }
             }
@@ -199,12 +212,13 @@ export class LocalTableDataRepository extends TableDataRepository {
     values) => {
         const columnValue = await row.getValue(columnId);
         const filterType = this.filterModes.get(columnId) ?? NumberDateFilterMode.In;
+        const isValueInvalid = columnValue == null || typeof columnValue != 'number' || isNaN(columnValue);
         if (filterType == NumberDateFilterMode.null) {
             // TODO test
-            return columnValue == null || typeof columnValue != 'number' || isNaN(columnValue);
+            return isValueInvalid;
         }
-        if (!columnValue || typeof columnValue != 'number') {
-            return false;
+        if (isValueInvalid || typeof columnValue != 'number') {
+            return inclusiveFilterModes.has(filterType);
         }
         switch (filterType) {
             case NumberDateFilterMode.Equals: {
@@ -317,8 +331,10 @@ export class LocalTableDataRepository extends TableDataRepository {
             return columnValue == null;
         }
         if (!filterValue) {
-            console.log('empty search value');
-            return true;
+            if (this.debug) {
+                console.log(`no value. going by inclusive or not`);
+            }
+            return inclusiveFilterModes.has(filterType);
         }
         filterValue = filterValue.trim().toLocaleLowerCase();
         const columnValue = (await row.getValue(columnId))

package/dist/Components/Table/Types/DataRepository/TableDataRepository.svelte.d.ts

@@ -1,4 +1,4 @@
-import { SvelteMap } from 'svelte/reactivity';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
 import type { FilterMode } from '../Filtering/FilterMode.js';
 import type { FilterType } from '../Filtering/FilterType.js';
@@ -42,7 +42,7 @@ export declare abstract class TableDataRepository<T extends object, out FilterVa
     get forceRefresh(): () => void;
     set forceRefresh(v: () => void);
     readonly registerRefreshMethod: (method: () => void) => void;
-    protected getValueSet(values: Array<string | number | undefined>): Set<number>;
+    protected getValueSet(values: Array<string | number | undefined>): SvelteSet<number>;
     static getValues(values: Array<string | number | null | undefined>): Array<number>;
     static getMinMax(values: Array<string | number | null | undefined>): number[] | undefined[];
 }

package/dist/Components/Table/Types/DataRepository/TableDataRepository.svelte.js

@@ -1,5 +1,5 @@
 import { browser } from '$app/environment';
-import { SvelteMap } from 'svelte/reactivity';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 export class TableDataRepository {
     tableName;
     getUserId;
@@ -47,9 +47,7 @@ export class TableDataRepository {
         this._forceRefresh = method;
     };
     getValueSet(values) {
-        // FIXME
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        return new Set(TableDataRepository.getValues(values));
+        return new SvelteSet(TableDataRepository.getValues(values));
     }
     static getValues(values) {
         return values

package/dist/Components/Table/Types/Focus/TableFocusDetails.svelte.d.ts

@@ -1,41 +1,23 @@
-import type { ToastContext } from '../../../../Contexts/ToastContext.svelte.js';
 import { Validity } from '../../../../Types/Internal/Validity.js';
+import type { ValidityWrapper } from '../../../../Types/Internal/ValidityWrapper.js';
 import type { TableCell } from '../Columns/TableCell.js';
 import type { TableContext } from '../Context/TableContext.svelte.js';
+import type { Primitive } from '../Context/TableInitOptions.js';
 import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
-export declare class TableFocusDetails<T extends object> {
-    private toastCallback;
-    constructor(cell: TableCell<T>, tableContext: TableContext<T, never>, toastCallback: ToastContext['toast']);
-    private _cell;
-    get cell(): TableCell<T>;
-    set cell(v: TableCell<T>);
-    private _tableContext;
-    get tableContext(): TableContext<T, never>;
-    set tableContext(v: TableContext<T, never>);
-    private _coordinates;
-    get coordinates(): CellCoordinates;
-    private _isMultiFocused;
-    get isMultiFocused(): boolean;
-    private _hasMultipleFocus;
-    get hasMultipleFocus(): boolean;
-    private _isMultiFocusStart;
-    get isMultiFocusStart(): boolean;
-    private _topToBottom;
-    get topToBottom(): boolean;
-    private _leftToRight;
-    get leftToRight(): boolean;
-    private _leftEdge;
-    get leftEdge(): boolean;
-    private _topEdge;
-    get topEdge(): boolean;
-    private _rightEdge;
-    get rightEdge(): boolean;
-    private _bottomEdge;
-    get bottomEdge(): boolean;
-    private _validityTuple;
-    private __validityTuple;
-    get validityTuple(): Promise<[Validity, string | undefined]>;
-    set validityTuple(v: Promise<[Validity, string | undefined]>);
-    private _outline;
-    get outline(): string;
+export declare class TableFocusDetails<T extends object, RowIdType extends Primitive> {
+    private cell;
+    private tableContext;
+    constructor(cell: TableCell<T>, tableContext: TableContext<T, RowIdType>);
+    coordinates: CellCoordinates;
+    isMultiFocused: boolean;
+    hasMultipleFocus: boolean;
+    isMultiFocusStart: boolean;
+    topToBottom: boolean;
+    leftToRight: boolean;
+    readonly leftEdge: boolean;
+    readonly topEdge: boolean;
+    readonly rightEdge: boolean;
+    readonly bottomEdge: boolean;
+    readonly validity: Promise<Validity | ValidityWrapper | undefined>;
+    readonly outline: string;
 }

package/dist/Components/Table/Types/Focus/TableFocusDetails.svelte.js

@@ -1,64 +1,63 @@
-import { devCatch, isErrorResponse } from '../../../../Helpers/Helpers.svelte.js';
+import { devCatch } from '../../../../Helpers/Helpers.svelte.js';
 import { Colour } from '../../../../scss/colours.js';
 import { Validity } from '../../../../Types/Internal/Validity.js';
-import { tick } from 'svelte';
 export class TableFocusDetails {
-    toastCallback;
-    constructor(cell, tableContext, toastCallback) {
-        this.toastCallback = toastCallback;
-        this._cell = $derived(cell);
-        this._tableContext = $derived(tableContext);
-    }
-    _cell;
-    get cell() {
-        return this._cell;
-    }
-    set cell(v) {
-        this._cell = v;
-    }
-    _tableContext;
-    get tableContext() {
-        return this._tableContext;
-    }
-    set tableContext(v) {
-        this._tableContext = v;
-    }
-    _coordinates = $derived({
-        row: this.cell.row.visibleIndex,
-        column: this.cell.column.columnDef.index,
-        id: this.cell.column.columnDef.id,
-    });
-    get coordinates() {
-        return this._coordinates;
-    }
-    _isMultiFocused = $derived(this.tableContext.focusedColumnIds.has(this.cell.column.columnDef.id) &&
-        this.tableContext.focusedRowIndexIds.has(this.cell.row.visibleIndex));
-    get isMultiFocused() {
-        return this._isMultiFocused;
-    }
-    _hasMultipleFocus = $derived(this.isMultiFocused &&
-        (this.tableContext.focusedColumnIds.size > 1 || this.tableContext.focusedRowIndexIds.size > 1));
-    get hasMultipleFocus() {
-        return this._hasMultipleFocus;
-    }
-    _isMultiFocusStart = $derived(this.hasMultipleFocus &&
-        this.tableContext.focusStart?.id === this.coordinates.id &&
-        this.tableContext.focusStart.column === this.coordinates.column &&
-        this.tableContext.focusStart.row === this.coordinates.row);
-    get isMultiFocusStart() {
-        return this._isMultiFocusStart;
-    }
-    _topToBottom = $derived(this.hasMultipleFocus &&
-        (this.tableContext.focusStart?.row ?? 0) < (this.tableContext.focusEnd?.row ?? 0));
-    get topToBottom() {
-        return this._topToBottom;
-    }
-    _leftToRight = $derived(this.hasMultipleFocus &&
-        (this.tableContext.focusStart?.column ?? 0) < (this.tableContext.focusEnd?.column ?? 0));
-    get leftToRight() {
-        return this._leftToRight;
-    }
-    _leftEdge = $derived.by(() => {
+    cell;
+    tableContext;
+    constructor(cell, tableContext) {
+        this.cell = cell;
+        this.tableContext = tableContext;
+        this.coordinates = $derived({
+            row: this.cell.row.visibleIndex,
+            column: this.cell.column.columnDef.index,
+            id: this.cell.column.columnDef.id,
+        });
+        $effect(() => {
+            void this.tableContext.focusedColumnIds;
+            void this.tableContext.focusedRowIndices;
+            (async () => {
+                this.isMultiFocused =
+                    (await this.tableContext.focusedColumnIds).has(this.cell.column.columnDef.id) &&
+                        (await this.tableContext.focusedRowIndices).has(this.cell.row.visibleIndex);
+            })().catch(devCatch);
+        });
+        $effect(() => {
+            void this.isMultiFocused;
+            void this.tableContext.focusedColumnIds;
+            void this.tableContext.focusedRowIndices;
+            (async () => {
+                this.hasMultipleFocus =
+                    (await this.tableContext.focusedColumnIds).size > 1 ||
+                        (await this.tableContext.focusedRowIndices).size > 1;
+            })().catch(devCatch);
+        });
+        this.isMultiFocusStart = $derived.by(() => {
+            void this.hasMultipleFocus;
+            return (this.hasMultipleFocus &&
+                this.tableContext.focusStart?.id === this.coordinates.id &&
+                this.tableContext.focusStart.column === this.coordinates.column &&
+                this.tableContext.focusStart.row === this.coordinates.row);
+        });
+        this.topToBottom = $derived.by(() => {
+            void this.hasMultipleFocus;
+            return (this.hasMultipleFocus &&
+                (this.tableContext.focusStart?.row ?? 0) < (this.tableContext.focusEnd?.row ?? 0));
+        });
+        this.leftToRight = $derived.by(() => {
+            void this.hasMultipleFocus;
+            return (this.hasMultipleFocus &&
+                (this.tableContext.focusStart?.column ?? 0) < (this.tableContext.focusEnd?.column ?? 0));
+        });
+    }
+    coordinates;
+    isMultiFocused = $state(false);
+    hasMultipleFocus = $state(false);
+    isMultiFocusStart;
+    topToBottom;
+    leftToRight;
+    leftEdge = $derived.by(() => {
+        void this.isMultiFocused;
+        void this.leftToRight;
         if (this.isMultiFocused) {
             if (this.leftToRight) {
                 return this.coordinates.column === this.tableContext.focusStart?.column;
@@ -69,10 +68,9 @@ export class TableFocusDetails {
         }
         return false;
     });
-    get leftEdge() {
-        return this._leftEdge;
-    }
-    _topEdge = $derived.by(() => {
+    topEdge = $derived.by(() => {
+        void this.isMultiFocused;
+        void this.leftToRight;
         if (this.isMultiFocused) {
             if (this.topToBottom) {
                 return this.coordinates.row === this.tableContext.focusStart?.row;
@@ -83,10 +81,9 @@ export class TableFocusDetails {
         }
         return false;
     });
-    get topEdge() {
-        return this._topEdge;
-    }
-    _rightEdge = $derived.by(() => {
+    rightEdge = $derived.by(() => {
+        void this.isMultiFocused;
+        void this.leftToRight;
         if (this.isMultiFocused) {
             if (this.leftToRight) {
                 return this.coordinates.column === this.tableContext.focusEnd?.column;
@@ -97,10 +94,9 @@ export class TableFocusDetails {
         }
         return false;
     });
-    get rightEdge() {
-        return this._rightEdge;
-    }
-    _bottomEdge = $derived.by(() => {
+    bottomEdge = $derived.by(() => {
+        void this.isMultiFocused;
+        void this.leftToRight;
         if (this.isMultiFocused) {
             if (this.topToBottom) {
                 return this.coordinates.row === this.tableContext.focusEnd?.row;
@@ -111,44 +107,18 @@ export class TableFocusDetails {
         }
         return false;
     });
-    get bottomEdge() {
-        return this._bottomEdge;
-    }
-    _validityTuple = $derived.by(() => {
-        return this.__validityTuple(this.cell.column.columnDef.isValid, this.cell.row.original);
+    validity = $derived.by(async () => {
+        void this.tableContext.selectedItems.size;
+        void this.cell.column.columnDef.isValid;
+        void this.tableContext.selectionContains;
+        void this.cell.row.original;
+        return this.cell.column.columnDef.isValid?.(this.cell.row.original, this.tableContext.selectionContains(this.cell.row.original));
     });
-    async __validityTuple(isValid, original) {
-        try {
-            void original;
-            const result = (await isValid?.(original, await this.tableContext.selectionContains(original))) ??
-                Validity.Valid;
-            if (isWrapper(result)) {
-                return [result.value, result.reason];
-            }
-            else {
-                return [result, undefined];
-            }
-        }
-        catch (e) {
-            console.warn('validity error:', e);
-            return tick().then(() => {
-                if (isErrorResponse(e)) {
-                    this.toastCallback(e);
-                }
-                else {
-                    devCatch(e);
-                }
-                return [Validity.Valid, undefined];
-            });
-        }
-    }
-    get validityTuple() {
-        return this._validityTuple;
-    }
-    set validityTuple(v) {
-        this._validityTuple = v;
-    }
-    _outline = $derived.by(() => {
+    outline = $derived.by(() => {
+        void this.topEdge;
+        void this.rightEdge;
+        void this.bottomEdge;
+        void this.leftEdge;
         const x = [];
         if (this.topEdge) {
             x.push(`inset 0px 2px 0px 0px ${Colour['$brand-primary']}`);
@@ -169,10 +139,4 @@ export class TableFocusDetails {
             return '';
         }
     });
-    get outline() {
-        return this._outline;
-    }
-}
-function isWrapper(result) {
-    return typeof result == 'object' && 'value' in result;
 }

package/dist/Components/TextInput.svelte

@@ -34,7 +34,7 @@
 		onblur,
 		onfocus,
 		onkeydown,
-		oninput
+		oninput,
 	}: TextInputProps = $props();
 
 	let isInvalid = $derived(
@@ -62,12 +62,17 @@
 				>{labelTop}{#if optional}<i>&nbsp;- optional</i>{/if}</span
 			>
 			{#if variant === InputVariant.Default}
-				<span class="border" class:invalid={isInvalid}
+				<span
+					class="border"
+					class:invalid={isInvalid}
 					>{labelTop}{#if optional}<i>&nbsp;- optional</i>{/if}</span
 				>
 			{/if}
 		{/if}
-		<div class="icon-container" class:for-modal={variant == InputVariant.Modal}>
+		<div
+			class="icon-container"
+			class:for-modal={variant == InputVariant.Modal}
+		>
 			{#if leftIcon}
 				<!-- TODO make this identical to right icon -->
 				<Icon
@@ -130,7 +135,9 @@
 				</div>
 			{/if}
 			{#if labelRight}
-				<span class="right-label" class:for-modal={variant == InputVariant.Modal}>{labelRight}</span
+				<span
+					class="right-label"
+					class:for-modal={variant == InputVariant.Modal}>{labelRight}</span
 				>
 			{/if}
 		</div>

package/dist/Components/Touch/DateModal.svelte

@@ -1,6 +1,9 @@
 <svelte:options runes />
 
-<script lang="ts" module>
+<script
+	lang="ts"
+	module
+>
 	import { devCatch, passthrough } from '../../Helpers/Helpers.svelte.js';
 	import { ColourSet } from '../../scss/colours.js';
 	import { InputVariant } from '../../Types/Internal/InputVariant.js';
@@ -44,13 +47,10 @@
 		inclusive = false,
 		explanation,
 		allowOverride = false,
-		showTime = false
+		showTime = false,
 	}: DateModalProps = $props();
 
-	//  svelte-ignore state_referenced_locally
-	let valueSnapshot = $state(value);
-	//  svelte-ignore state_referenced_locally
-	let tempValue = $state(value ?? new Date());
+	let tempValue = $derived(value ?? new Date());
 	let overrideValue = $state(new Date());
 	let isBeingEdited = $state(false);
 	let inputRef: HTMLInputElement | undefined = $state();
@@ -62,11 +62,9 @@
 	}
 
 	$effect(() => {
-		if (value && value !== valueSnapshot) {
-			valueSnapshot = value;
-			tempValue = value;
-			isBeingEdited = false;
-		}
+		void value;
+
+		isBeingEdited = false;
 	});
 
 	$effect(() => {
@@ -167,14 +165,28 @@
 
 	<div class="inputs">
 		{#if allowOverride && isBeingEdited}
-			<DatePicker {showTime} {onsubmit} {namedMonths} bind:date={overrideValue} />
+			<DatePicker
+				{showTime}
+				{onsubmit}
+				{namedMonths}
+				bind:date={overrideValue}
+			/>
 		{/if}
-		<DatePicker {showTime} {onsubmit} {namedMonths} bind:date={tempValue} />
+		<DatePicker
+			{showTime}
+			{onsubmit}
+			{namedMonths}
+			bind:date={tempValue}
+		/>
 	</div>
 
 	{#snippet footer()}
 		<div class="modal-footer">
-			<button onkeydown={passthrough} type="submit" disabled={!isValid}>Confirm</button>
+			<button
+				onkeydown={passthrough}
+				type="submit"
+				disabled={!isValid}>Confirm</button
+			>
 			<button
 				onkeydown={passthrough}
 				type="button"

package/dist/Helpers/Helpers.svelte.d.ts

@@ -1,10 +1,13 @@
 import type { CustomFilter } from '../Components/Table/Types/Filtering/CustomFilter.js';
 import type { InputDate, InputDateWithTime, SQLDate } from '../Types/Internal/Misc.js';
 import type { RefWrapper } from '../Types/Internal/RefWrapper.js';
+import type { Validity } from '../Types/Internal/Validity.js';
+import type { ValidityWrapper } from '../Types/Internal/ValidityWrapper.js';
+import { SvelteSet } from 'svelte/reactivity';
 export declare function autoPluralise(text: string, quantity?: number, { capitalise }?: {
     capitalise?: boolean | undefined;
 }): string;
-export declare const vowels: Set<string>;
+export declare const vowels: SvelteSet<string>;
 export declare function generateShortUUID<T extends string>(): T;
 export declare function generateUUID<T extends string>(): T;
 export declare function refWrapper<T>(initial: T): RefWrapper<T>;
@@ -47,3 +50,4 @@ export declare function devCatch(e: unknown): void;
 export declare function hasQuery<FilterValueType>(customFilter: CustomFilter<FilterValueType> | undefined): customFilter is CustomFilter<FilterValueType> & Required<Pick<CustomFilter<FilterValueType>, 'query'>>;
 export declare function isDateTuple(value: unknown): value is [Date | null, Date | null];
 export declare function isNumberTuple(value: unknown): value is [number | null, number | null];
+export declare function isValidityTuple(v: Validity | ValidityWrapper | undefined): v is ValidityWrapper;

package/dist/Helpers/Helpers.svelte.js

@@ -2,6 +2,7 @@ import { dev } from '$app/environment';
 import { CustomFilterType } from '../Components/Table/Types/Filtering/CustomFilterType.js';
 import { Sizing } from '../scss/sizing.js';
 import { untrack } from 'svelte';
+import { SvelteDate, SvelteSet } from 'svelte/reactivity';
 export function autoPluralise(text, quantity = 2, { capitalise = false } = {}) {
     if (quantity === 1) {
         return text;
@@ -29,16 +30,14 @@ export function autoPluralise(text, quantity = 2, { capitalise = false } = {}) {
         }
     }
 }
-// eslint-disable-next-line svelte/prefer-svelte-reactivity
-export const vowels = new Set(['a', 'e', 'i', 'o', 'u']);
+export const vowels = new SvelteSet(['a', 'e', 'i', 'o', 'u']);
 // generic is present to bypass floatAlias type requirements and the like
 export function generateShortUUID() {
     return generateUUID().substring(0, 13);
 }
 // taken from https://stackoverflow.com/a/8809472/18712055
 export function generateUUID() {
-    let // eslint-disable-next-line svelte/prefer-svelte-reactivity
-    d = new Date().getTime(), 
+    let d = new SvelteDate().getTime(), 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     d2 = (typeof performance !== 'undefined' && performance.now && performance.now() * 1000) || 0;
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
@@ -67,8 +66,7 @@ export function refWrapper(initial) {
 }
 export function SQLFriendly(date) {
     if (typeof date === 'string') {
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        date = new Date(date);
+        date = new SvelteDate(date);
     }
     return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date
         .getDate()
@@ -77,12 +75,10 @@ export function SQLFriendly(date) {
 }
 export function SQLFriendlyWithLocalTime(date, timeDate) {
     if (typeof date === 'string') {
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        date = new Date(date);
+        date = new SvelteDate(date);
     }
     if (typeof timeDate === 'string') {
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        timeDate = new Date(date);
+        timeDate = new SvelteDate(date);
     }
     return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date
         .getDate()
@@ -269,3 +265,6 @@ export function isNumberTuple(value) {
         (value[0] === null || typeof value[0] == 'number') &&
         (value[1] === null || typeof value[1] == 'number'));
 }
+export function isValidityTuple(v) {
+    return v != null && typeof v == 'object';
+}