@lavalogic/scoria 0.16.4 → 0.17.0

package/dist/Components/Table/Types/Columns/Definitions/Accessors/SelectDef.svelte.d.ts

@@ -1,5 +1,4 @@
 import type { SelectOption } from '../../../../../../Types/Internal/SelectOption.js';
-import type { CustomFilterFn } from '../../../Filtering/CustomFilterFn.js';
 import type { FilterFn } from '../../../Filtering/FilterFn.js';
 import { AccessorDef, type AccessorDefProps } from './AccessorDef.svelte.js';
 export interface SelectDefProps<T extends object, in FilterValueType, out SelectValueType> extends AccessorDefProps<T, FilterValueType, SelectValueType> {
@@ -14,8 +13,8 @@ export declare class SelectDef<T extends object, in FilterValueType, out SelectV
     constructor(props: SelectDefProps<T, FilterValueType, SelectValueType>);
     readonly accessorType: "Select";
     private _filterFn;
-    get filterFn(): FilterFn<T, FilterValueType> | CustomFilterFn | undefined;
-    set filterFn(v: FilterFn<T, FilterValueType> | CustomFilterFn | undefined);
+    get filterFn(): FilterFn<T, FilterValueType> | undefined;
+    set filterFn(v: FilterFn<T, FilterValueType> | undefined);
     readonly sortingFn?: (a: T, b: T) => 1 | -1 | 0;
     readonly optional: boolean;
     readonly clearable: boolean;

package/dist/Components/Table/Types/Columns/Definitions/Accessors/TextInputDef.svelte.d.ts

@@ -1,4 +1,3 @@
-import type { CustomFilterFn } from '../../../Filtering/CustomFilterFn.js';
 import type { FilterFn, StringFilterValueType } from '../../../Filtering/FilterFn.js';
 import { AccessorDef, type AccessorDefProps } from './AccessorDef.svelte.js';
 export interface TextInputDefProps<T extends object, in FilterValueType = StringFilterValueType, out SelectValueType = StringFilterValueType> extends AccessorDefProps<T, FilterValueType, SelectValueType> {
@@ -8,6 +7,6 @@ export declare class TextInputDef<T extends object, in FilterValueType = StringF
     readonly accessorType: "Text";
     constructor(props: TextInputDefProps<T, FilterValueType, SelectValueType>);
     private _filterFn;
-    get filterFn(): CustomFilterFn | FilterFn<T, FilterValueType> | undefined;
-    set filterFn(v: CustomFilterFn | FilterFn<T, FilterValueType> | undefined);
+    get filterFn(): FilterFn<T, FilterValueType> | undefined;
+    set filterFn(v: FilterFn<T, FilterValueType> | undefined);
 }

package/dist/Components/Table/Types/Columns/Definitions/Actions/ActionsDef.svelte.d.ts

@@ -1,12 +1,12 @@
 import type { ColourSet } from '../../../../../../scss/colours.js';
 import type { TableActionButton } from '../../TableActionButton.js';
 import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
-export interface ActionsDefProps<T extends object, in FilterValueType, out OptionsValueType = unknown> extends Omit<ColumnDefProps<T, FilterValueType, OptionsValueType>, 'id' | 'header'> {
+export interface ActionsDefProps<T extends object, in FilterValueType, out FilterOptionsType = unknown> extends Omit<ColumnDefProps<T, FilterValueType, FilterOptionsType>, 'id' | 'header'> {
     actions: Array<TableActionButton<T>>;
     isEnabled?: (item: T, index: number, button: TableActionButton<T>) => boolean | Promise<boolean>;
     getColourSet?: (item: T, index: number, button: TableActionButton<T>) => ColourSet;
 }
-export declare class ActionsDef<T extends object, FilterValueType, out OptionsValueType = unknown> extends ColumnDef<T, FilterValueType, OptionsValueType> {
+export declare class ActionsDef<T extends object, FilterValueType, out FilterOptionsType = unknown> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
     constructor(props: ActionsDefProps<T, FilterValueType>);
     readonly columnType: "Actions";
     readonly actions: Array<TableActionButton<T>>;

package/dist/Components/Table/Types/Columns/Definitions/Actions/ActionsDef.svelte.js

@@ -7,7 +7,7 @@ export class ActionsDef extends ColumnDef {
             id: `actions-${generateUUID()}`,
             header: 'Actions',
             allowSorting: false,
-            allowFiltering: false
+            allowFiltering: false,
         });
         this.actions = $derived(props.actions);
         this.isEnabled = $derived(props.isEnabled);

package/dist/Components/Table/Types/Columns/Definitions/ColumnDef.svelte.d.ts

@@ -1,7 +1,6 @@
 import type { Pixels } from '../../../../../Types/Internal/Misc.js';
 import type { SelectOption } from '../../../../../Types/Internal/SelectOption.js';
 import type { Snippet } from 'svelte';
-import type { CustomFilterFn } from '../../Filtering/CustomFilterFn.js';
 import type { FilterFn } from '../../Filtering/FilterFn.js';
 import type { FilterValueType } from '../../Filtering/FilterValueType.js';
 import { ColumnType } from '../ColumnType.js';
@@ -20,13 +19,13 @@ export interface ColumnDefProps<T extends object, in FilterFnType, out OptionsTy
     isEditable?: (item: T, index: number) => boolean | Promise<boolean>;
     resizable?: boolean;
     isValid?: ValidationFn<T>;
-    filterFn?: FilterFn<T, FilterFnType> | CustomFilterFn;
+    filterFn?: FilterFn<T, FilterFnType>;
     filterValueType?: FilterValueType;
     getOptions?: () => Array<SelectOption<OptionsType>> | Promise<Array<SelectOption<OptionsType>>>;
     accessorFn?: AccessorFn<T>;
     getDisplayValue?: (item: T, index: number) => string | null | Promise<string | null>;
 }
-export declare abstract class ColumnDef<T extends object, in FilterFnType = unknown, out OptionsType = unknown> {
+export declare abstract class ColumnDef<T extends object, in FilterFnType = never, out OptionsType = unknown> {
     protected constructor(props: ColumnDefProps<T, FilterFnType, OptionsType>);
     readonly id: string;
     debug: boolean;
@@ -39,7 +38,7 @@ export declare abstract class ColumnDef<T extends object, in FilterFnType = unkn
     readonly allowFiltering: boolean;
     readonly isValid: ValidationFn<T> | undefined;
     readonly accessorFn: AccessorFn<T> | undefined;
-    abstract filterFn: FilterFn<T, FilterFnType> | CustomFilterFn | undefined;
+    abstract filterFn: FilterFn<T, FilterFnType> | undefined;
     private _minSize;
     get minSize(): Pixels;
     set minSize(v: Pixels);

package/dist/Components/Table/Types/Columns/Definitions/ColumnDefSet.d.ts

@@ -7,5 +7,5 @@ export interface ColumnDefSet<T extends object> {
     sortingState: SortingState;
     visibilityState: VisibilityState;
     columnPinningState: ColumnPinningState;
-    columnDefs: Array<ColumnDef<T>>;
+    columnDefs: Array<ColumnDef<T, never, unknown>>;
 }

package/dist/Components/Table/Types/Columns/Definitions/Display/AbstractDisplayDef.svelte.d.ts

@@ -2,17 +2,18 @@ import type { Component } from 'svelte';
 import type { DisplayType } from '../../DisplayType.js';
 import type { TableCell } from '../../TableCell.js';
 import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
-export interface DisplayDefModalProps<T extends object, in FilterValueType = unknown, out OptionsValueType = unknown> {
-    cell: TableCell<T, FilterValueType, OptionsValueType>;
+export interface DisplayDefModalProps<T extends object, in FilterValueType = never, out FilterOptionsType = unknown> {
+    cell: TableCell<T, FilterValueType, FilterOptionsType>;
     onclose: () => void;
     onsubmit: () => void;
 }
-export interface AbstractDisplayDefProps<T extends object, FilterFnType, out OptionsValueType = unknown> extends ColumnDefProps<T, FilterFnType, OptionsValueType> {
+export interface AbstractDisplayDefProps<T extends object, in FilterFnType, out FilterOptionsType> extends ColumnDefProps<T, FilterFnType, FilterOptionsType> {
     modal?: Component<any, any, any>;
 }
-export declare abstract class AbstractDisplayDef<T extends object, FilterValueType, out OptionsValueType = unknown> extends ColumnDef<T, FilterValueType, OptionsValueType> {
+export declare abstract class AbstractDisplayDef<T extends object, in FilterValueType = never, out FilterOptionsType = unknown> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
     abstract readonly displayType: DisplayType;
-    constructor(props: AbstractDisplayDefProps<T, FilterValueType, OptionsValueType>);
+    constructor(props: AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType>);
     readonly columnType: "Display";
-    readonly modal: Component<DisplayDefModalProps<T, FilterValueType>, any, any> | undefined;
+    readonly modal: //HACK out parameter. Need to check if it's possible to be strict
+    Component<DisplayDefModalProps<T>, any, any> | undefined;
 }

package/dist/Components/Table/Types/Columns/Definitions/Display/AbstractDisplayDef.svelte.js

@@ -6,6 +6,5 @@ export class AbstractDisplayDef extends ColumnDef {
         this.modal = $derived(props.modal);
     }
     columnType = ColumnType.Display;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    modal; //HACK out parameter. Need to check if it's possible to be strict
+    modal;
 }

package/dist/Components/Table/Types/Columns/Definitions/Display/BubbleDef.svelte.d.ts

@@ -1,15 +1,14 @@
 import type { BubbleColour } from '../../../../../BubbleColour.js';
-import type { CustomFilterFn } from '../../../Filtering/CustomFilterFn.js';
 import type { FilterFn, StringFilterValueType } from '../../../Filtering/FilterFn.js';
 import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisplayDef.svelte.js';
-export interface BubbleDefProps<T extends object, FilterValueType = StringFilterValueType> extends AbstractDisplayDefProps<T, FilterValueType> {
+export interface BubbleDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
     getColour?: (item: T, index: number, value: string) => BubbleColour | Promise<BubbleColour | null | undefined>;
 }
-export declare class BubbleDef<T extends object, FilterValueType = StringFilterValueType> extends AbstractDisplayDef<T, FilterValueType> {
+export declare class BubbleDef<T extends object, in FilterValueType = StringFilterValueType, out FilterOptionsType = unknown> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
     readonly displayType: "Bubbles";
-    constructor(props: BubbleDefProps<T, FilterValueType>);
+    constructor(props: BubbleDefProps<T, FilterValueType, FilterOptionsType>);
     private _filterFn;
-    get filterFn(): FilterFn<T, FilterValueType> | CustomFilterFn | undefined;
-    set filterFn(v: FilterFn<T, FilterValueType> | CustomFilterFn | undefined);
+    get filterFn(): FilterFn<T, FilterValueType> | undefined;
+    set filterFn(v: FilterFn<T, FilterValueType> | undefined);
     getColour: ((item: T, index: number, value: string) => BubbleColour | Promise<BubbleColour | null | undefined>) | undefined;
 }

package/dist/Components/Table/Types/Columns/Definitions/Display/DisplayDef.svelte.d.ts

@@ -1,12 +1,12 @@
-import type { CustomFilterFn } from '../../../Filtering/CustomFilterFn.js';
 import type { FilterFn } from '../../../Filtering/FilterFn.js';
 import { DisplayType } from '../../DisplayType.js';
 import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisplayDef.svelte.js';
-export type DisplayDefProps<T extends object, FilterValueType = unknown> = AbstractDisplayDefProps<T, FilterValueType>;
-export declare class DisplayDef<T extends object, FilterValueType = unknown> extends AbstractDisplayDef<T, FilterValueType> {
+export interface DisplayDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
+}
+export declare class DisplayDef<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
     readonly displayType: DisplayType;
-    constructor(props: DisplayDefProps<T, FilterValueType>);
+    constructor(props: DisplayDefProps<T, FilterValueType, FilterOptionsType>);
     private _filterFn;
-    get filterFn(): CustomFilterFn | FilterFn<T, FilterValueType> | undefined;
-    set filterFn(v: CustomFilterFn | FilterFn<T, FilterValueType> | undefined);
+    get filterFn(): FilterFn<T, FilterValueType> | undefined;
+    set filterFn(v: FilterFn<T, FilterValueType> | undefined);
 }

package/dist/Components/Table/Types/Columns/Definitions/Display/ProgressBarDef.svelte.d.ts

@@ -1,15 +1,14 @@
 import type { BubbleColour } from '../../../../../BubbleColour.js';
-import type { CustomFilterFn } from '../../../Filtering/CustomFilterFn.js';
 import type { FilterFn, NumberFilterValueType } from '../../../Filtering/FilterFn.js';
 import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisplayDef.svelte.js';
-export interface ProgressBarDefProps<T extends object, FilterValueType = NumberFilterValueType> extends AbstractDisplayDefProps<T, FilterValueType> {
+export interface ProgressBarDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
     getColour: (item: T, index: number, value: [number, number]) => BubbleColour | Promise<BubbleColour> | undefined;
 }
-export declare class ProgressBarDef<T extends object, FilterValueType = NumberFilterValueType> extends AbstractDisplayDef<T, FilterValueType> {
+export declare class ProgressBarDef<T extends object, in FilterValueType = NumberFilterValueType, out FilterOptionsType = unknown> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
     readonly displayType: "Progress";
-    constructor(props: ProgressBarDefProps<T, FilterValueType>);
+    constructor(props: ProgressBarDefProps<T, FilterValueType, FilterOptionsType>);
     readonly getColour: (item: T, index: number, value: [number, number]) => BubbleColour | Promise<BubbleColour> | undefined;
     private _filterFn;
-    get filterFn(): FilterFn<T, FilterValueType> | CustomFilterFn | undefined;
-    set filterFn(v: FilterFn<T, FilterValueType> | CustomFilterFn | undefined);
+    get filterFn(): FilterFn<T, FilterValueType> | undefined;
+    set filterFn(v: FilterFn<T, FilterValueType> | undefined);
 }

package/dist/Components/Table/Types/Columns/Definitions/Display/ValidityDef.svelte.d.ts

@@ -1,11 +1,11 @@
 import type { ValidationFn } from '../ValidationFn.js';
 import { AbstractDisplayDef, type AbstractDisplayDefProps } from './AbstractDisplayDef.svelte.js';
-export interface ValidityDefProps<T extends object, FilterValueType = unknown> extends AbstractDisplayDefProps<T, FilterValueType> {
+export interface ValidityDefProps<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDefProps<T, FilterValueType, FilterOptionsType> {
     isValid: ValidationFn<T>;
 }
-export declare class ValidityDef<T extends object, FilterValueType = unknown> extends AbstractDisplayDef<T, FilterValueType> {
+export declare class ValidityDef<T extends object, in FilterValueType, out FilterOptionsType> extends AbstractDisplayDef<T, FilterValueType, FilterOptionsType> {
     readonly displayType: "Validity";
-    constructor(props: ValidityDefProps<T, FilterValueType>);
+    constructor(props: ValidityDefProps<T, FilterValueType, FilterOptionsType>);
     readonly filterFn: undefined;
     readonly isValid: ValidationFn<T>;
 }

package/dist/Components/Table/Types/Columns/Definitions/Expand/ExpandDef.svelte.d.ts

@@ -2,7 +2,7 @@ import type { IconProps } from '../../../../../IconProps.js';
 import type { Primitive, TableInitOptions } from '../../../Context/TableInitOptions.js';
 import type { DefsWrapper } from '../../DefsWrapper.js';
 import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
-export interface ExpandDefProps<T extends object, R extends object, InnterIdType extends Primitive = Primitive, in FilterValueType = unknown, out OptionsValueType = unknown> extends ColumnDefProps<T, FilterValueType, OptionsValueType> {
+export interface ExpandDefProps<T extends object, R extends object, InnterIdType extends Primitive = Primitive, in FilterValueType = unknown, out FilterOptionsType = unknown> extends ColumnDefProps<T, FilterValueType, FilterOptionsType> {
     isEnabled: (item: T, index: number) => boolean | Promise<boolean>;
     getInnerColumnDefs: (item: T, index: number) => DefsWrapper<R>;
     headerIcon: IconProps['name'];
@@ -10,9 +10,9 @@ export interface ExpandDefProps<T extends object, R extends object, InnterIdType
     innerTableOptions: TableInitOptions<R, InnterIdType>;
     accessorFn: (item: T, index: number) => ReadonlyArray<R> | Promise<ReadonlyArray<R>>;
 }
-export declare class ExpandDef<T extends object, R extends object, InnterIdType extends Primitive = Primitive, in FilterValueType = unknown, out OptionsValueType = unknown> extends ColumnDef<T, FilterValueType, OptionsValueType> {
+export declare class ExpandDef<T extends object, R extends object, InnterIdType extends Primitive = Primitive, in FilterValueType = unknown, out FilterOptionsType = unknown> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
     readonly columnType: "Expand";
-    constructor(props: ExpandDefProps<T, R, InnterIdType, FilterValueType, OptionsValueType>);
+    constructor(props: ExpandDefProps<T, R, InnterIdType, FilterValueType, FilterOptionsType>);
     readonly accessorFn: (item: T, index: number) => ReadonlyArray<R> | Promise<ReadonlyArray<R>>;
     readonly filterFn: undefined;
     readonly innerTableName: string;

package/dist/Components/Table/Types/Columns/Definitions/FilterOnly/FilterOnlyDef.svelte.d.ts

@@ -1,11 +1,10 @@
-import type { CustomFilterFn } from '../../../Filtering/CustomFilterFn.js';
 import type { FilterFn } from '../../../Filtering/FilterFn.js';
 import { ColumnType } from '../../ColumnType.js';
 import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
-export interface FilterOnlyDefProps<T extends object, FilterFnType = unknown, out OptionsValueType = unknown> extends ColumnDefProps<T, FilterFnType, OptionsValueType> {
+export interface FilterOnlyDefProps<T extends object, FilterFnType = unknown, out FilterOptionsType = unknown> extends ColumnDefProps<T, FilterFnType, FilterOptionsType> {
 }
-export declare class FilterOnlyDef<T extends object, FilterFnType = unknown, out OptionsValueType = unknown> extends ColumnDef<T, FilterFnType, OptionsValueType> {
-    constructor(props: FilterOnlyDefProps<T, FilterFnType, OptionsValueType>);
+export declare class FilterOnlyDef<T extends object, FilterFnType = unknown, out FilterOptionsType = unknown> extends ColumnDef<T, FilterFnType, FilterOptionsType> {
+    constructor(props: FilterOnlyDefProps<T, FilterFnType, FilterOptionsType>);
     readonly columnType: ColumnType;
-    readonly filterFn: CustomFilterFn | FilterFn<T, FilterFnType> | undefined;
+    readonly filterFn: FilterFn<T, FilterFnType> | undefined;
 }

package/dist/Components/Table/Types/Columns/Definitions/JSONColumnDefSet.d.ts

@@ -7,5 +7,5 @@ export interface JSONColumnDefSet<T extends object> {
     sortingState: SortingState;
     visibilityState: VisibilityState;
     columnPinningState: JSONColumnPinningState;
-    columnDefs: Array<ColumnDef<T>>;
+    columnDefs: Array<ColumnDef<T, never, unknown>>;
 }

package/dist/Components/Table/Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.d.ts

@@ -1,6 +1,7 @@
+import type { BoolFilterValueType } from '../../../Filtering/FilterFn.js';
 import { ColumnType } from '../../ColumnType.js';
 import { ColumnDef } from '../ColumnDef.svelte.js';
-export declare class RowSelectionDef<T extends object> extends ColumnDef<T> {
+export declare class RowSelectionDef<T extends object, in FilterValueType = BoolFilterValueType, out FilterOptionsType = undefined> extends ColumnDef<T, FilterValueType, FilterOptionsType> {
     readonly isSelectable: (item: T, index: number) => boolean | Promise<boolean>;
     readonly columnType: ColumnType;
     constructor(isSelectable: (item: T, index: number) => boolean | Promise<boolean>);

package/dist/Components/Table/Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.js

@@ -9,7 +9,7 @@ export class RowSelectionDef extends ColumnDef {
             id: `is-selectable-${generateUUID()}`,
             header: 'Row Selected',
             allowSorting: false,
-            allowFiltering: false
+            allowFiltering: false,
         });
         this.isSelectable = isSelectable;
     }

package/dist/Components/Table/Types/Columns/DefsWrapper.d.ts

@@ -1,6 +1,6 @@
 import type { CustomRemoteFilters } from '../Filtering/CustomRemoteFilters.js';
 import type { ColumnDef } from './Definitions/ColumnDef.svelte.js';
-export interface DefsWrapper<T extends object, in FilterValueType = unknown> {
-    defs: Array<ColumnDef<T, FilterValueType>>;
-    remoteFilters?: CustomRemoteFilters<unknown>;
+export interface DefsWrapper<T extends object> {
+    defs: Array<ColumnDef<T, never, unknown>>;
+    remoteFilters?: CustomRemoteFilters<never>;
 }

package/dist/Components/Table/Types/Columns/TableCell.d.ts

@@ -1,7 +1,7 @@
 import type { Row } from '../Context/Row.js';
 import type { Column } from './Column.js';
-export interface TableCell<T extends object, in FilterValueType = unknown, out OptionsValueType = unknown> {
-    column: Column<T, FilterValueType, OptionsValueType>;
+export interface TableCell<T extends object, in FilterValueType = never, out FilterOptionsType = unknown> {
+    column: Column<T, FilterValueType, FilterOptionsType>;
     row: Row<T>;
     id: string;
     getValue: () => unknown | Promise<unknown>;

package/dist/Components/Table/Types/Context/Row.d.ts

@@ -5,7 +5,7 @@ export interface Row<T extends object> {
     visibleIndex: number;
     originalIndex: number;
     id: string;
-    getLeftVisibleCells: () => Array<TableCell<T>>;
-    getRightVisibleCells: () => Array<TableCell<T>>;
-    getCenterVisibleCells: () => Array<TableCell<T>>;
+    getLeftVisibleCells: () => Array<TableCell<T, never, unknown>>;
+    getRightVisibleCells: () => Array<TableCell<T, never, unknown>>;
+    getCenterVisibleCells: () => Array<TableCell<T, never, unknown>>;
 }

package/dist/Components/Table/Types/Context/TableContext.svelte.d.ts

@@ -48,7 +48,7 @@ export declare class TableContext<T extends object, RowIdType extends Primitive>
     get dataRepo(): IDataRepository<T>;
     private set dataRepo(value);
     private _remoteFilters;
-    get remoteFilters(): CustomRemoteFilters<unknown> | undefined;
+    get remoteFilters(): CustomRemoteFilters<never> | undefined;
     private set remoteFilters(value);
     private _showSelectedOnly;
     get showSelectedOnly(): boolean;
@@ -235,4 +235,4 @@ export declare class TableContext<T extends object, RowIdType extends Primitive>
     private reassignDefsToPresets;
     private filteringLoop;
 }
-export declare function isSearchable<T extends object, CD extends ColumnDef<T>>(def: CD): def is CD & HasCustomFilterFunction;
+export declare function isSearchable<T extends object, FilterValueType, FilterOptionsType, CD extends ColumnDef<T, FilterValueType, FilterOptionsType>>(def: CD): def is CD & HasCustomFilterFunction;

package/dist/Components/Table/Types/Context/TableContext.svelte.js

@@ -207,7 +207,7 @@ export class TableContext {
                                         return false;
                                     }
                                     if (def.filterFn) {
-                                        return def.filterFn(row, filter.id, filter.value);
+                                        return def.filterFn(row, filter.id, filter.value); //HACK how much parsing will be needed to be type safe?
                                     }
                                     if (this.debug) {
                                         console.warn(`column ${def.id} did not have a filter function`);

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;
+    filtering: ColumnFiltersState<unknown>;
     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;
+    filtering: ColumnFiltersState<unknown>;
     filterModes: SvelteMap<string, FilterMode>;
     setFilterMode: (id: string, mode: FilterMode) => void;
     filterBy: (id: string, value: unknown) => void;

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

@@ -8,7 +8,7 @@ export interface IRemoteDataRepository<T extends object> extends IDataRepository
     setPage: (page: number) => void;
     nextPage: () => void;
     prevPage: () => void;
-    filtering: ColumnFiltersState;
+    filtering: ColumnFiltersState<never>;
     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

@@ -11,7 +11,7 @@ import type { ILocalDataRepository } from './ILocalDataRepository.js';
 import type { SortingState } from './SortingState.js';
 import { TableDataRepository } from './TableDataRepository.svelte.js';
 export declare const allowedEmptyFilterModes: SvelteSet<StringFilterMode | NumberDateFilterMode>;
-export declare class LocalTableDataRepository<T extends object> extends TableDataRepository<T> implements ILocalDataRepository<T> {
+export declare class LocalTableDataRepository<T extends object> extends TableDataRepository<T, unknown> implements ILocalDataRepository<T> {
     addEmptyRow?: (() => void) | undefined;
     private debug;
     readonly filterType: "Real";
@@ -30,8 +30,8 @@ export declare class LocalTableDataRepository<T extends object> extends TableDat
     private _totalRows;
     get totalRows(): number;
     private _filtering;
-    get filtering(): ColumnFiltersState;
-    set filtering(v: ColumnFiltersState);
+    get filtering(): ColumnFiltersState<unknown>;
+    set filtering(v: ColumnFiltersState<unknown>);
     updateSorting: OnChangeFn<SortingState>;
     readonly paginationType: "Local";
     readonly setFilterMode: (id: string, mode: FilterMode | undefined) => void;

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

@@ -7,7 +7,7 @@ import { TableDataRepository } from './TableDataRepository.svelte.js';
 export const allowedEmptyFilterModes = new SvelteSet([
     StringFilterMode.Empty,
     StringFilterMode.null,
-    NumberDateFilterMode.null
+    NumberDateFilterMode.null,
 ]);
 export class LocalTableDataRepository extends TableDataRepository {
     addEmptyRow;
@@ -142,27 +142,27 @@ export class LocalTableDataRepository extends TableDataRepository {
         const lastIndex = Math.ceil(this._dataRef.value.length / size) - 1;
         this.paginationState = {
             pageSize: size,
-            pageIndex: Math.max(0, Math.min(this.paginationState.pageIndex, lastIndex))
+            pageIndex: Math.max(0, Math.min(this.paginationState.pageIndex, lastIndex)),
         };
     };
     setPage = (page) => {
         const lastIndex = this._lastPage - 1;
         this.paginationState = {
             ...this.paginationState,
-            pageIndex: Math.max(0, Math.min(lastIndex, page - 1))
+            pageIndex: Math.max(0, Math.min(lastIndex, page - 1)),
         };
     };
     nextPage = () => {
         const lastIndex = this._lastPage - 1;
         this.paginationState = {
             ...this.paginationState,
-            pageIndex: Math.min(lastIndex, this.paginationState.pageIndex + 1)
+            pageIndex: Math.min(lastIndex, this.paginationState.pageIndex + 1),
         };
     };
     prevPage = () => {
         this.paginationState = {
             ...this.paginationState,
-            pageIndex: Math.max(0, this.paginationState.pageIndex - 1)
+            pageIndex: Math.max(0, this.paginationState.pageIndex - 1),
         };
     };
     // #region filters

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

@@ -9,7 +9,7 @@ export interface ReadonlyPaginationState extends PaginationState {
     readonly pageIndex: number;
     readonly pageSize: number;
 }
-export declare abstract class TableDataRepository<T extends object> implements IDataRepository<T> {
+export declare abstract class TableDataRepository<T extends object, out FilterValueType> implements IDataRepository<T> {
     private tableName;
     protected getUserId: () => string | undefined;
     abstract paginationType: 'Remote' | 'Local';
@@ -18,7 +18,7 @@ export declare abstract class TableDataRepository<T extends object> implements I
     abstract isLoading: boolean;
     abstract data: Array<T>;
     abstract setPageSize: (size: number) => void;
-    abstract filtering: ColumnFiltersState;
+    abstract filtering: ColumnFiltersState<FilterValueType>;
     abstract setFilterMode: (id: string, mode: FilterMode) => void;
     abstract filterBy: (id: string, value: unknown) => void;
     abstract resetFilters: () => void;

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

@@ -10,7 +10,7 @@ export class TableDataRepository {
     __queryValues = new SvelteMap();
     _paginationState = $state({
         pageIndex: 0,
-        pageSize: 20
+        pageSize: 20,
     });
     get paginationState() {
         return this._paginationState;

package/dist/Components/Table/Types/Filtering/ColumnFiltersState.d.ts

@@ -1,5 +1,5 @@
-export interface ColumnFilter<T = unknown> {
+export interface ColumnFilter<T> {
     id: string;
     value: T;
 }
-export type ColumnFiltersState = Array<ColumnFilter>;
+export type ColumnFiltersState<T = unknown> = Array<ColumnFilter<T>>;

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

@@ -3,12 +3,12 @@ import { Validity } from '../../../../Types/Internal/Validity.js';
 import type { TableCell } from '../Columns/TableCell.js';
 import type { TableContext } from '../Context/TableContext.svelte.js';
 import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
-export declare class TableFocusDetails<T extends object, FilterValueType> {
+export declare class TableFocusDetails<T extends object> {
     private toastCallback;
-    constructor(cell: TableCell<T, FilterValueType>, tableContext: TableContext<T, never>, toastCallback: ToastContext['toast']);
+    constructor(cell: TableCell<T>, tableContext: TableContext<T, never>, toastCallback: ToastContext['toast']);
     private _cell;
-    get cell(): TableCell<T, FilterValueType>;
-    set cell(v: TableCell<T, FilterValueType>);
+    get cell(): TableCell<T>;
+    set cell(v: TableCell<T>);
     private _tableContext;
     get tableContext(): TableContext<T, never>;
     set tableContext(v: TableContext<T, never>);

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

@@ -26,7 +26,7 @@ export class TableFocusDetails {
     _coordinates = $derived({
         row: this.cell.row.visibleIndex,
         column: this.cell.column.columnDef.index,
-        id: this.cell.column.columnDef.id
+        id: this.cell.column.columnDef.id,
     });
     get coordinates() {
         return this._coordinates;

package/dist/Components/Table/Types/Header.d.ts

@@ -1,9 +1,9 @@
 import type { Column } from './Columns/Column.js';
-export interface Header<T extends object, FilterValueType> {
+export interface Header<T extends object, in FilterValueType, out FilterOptionsType> {
     id: string;
     colSpan: number;
     getSize: () => number;
-    column: Column<T, FilterValueType>;
+    column: Column<T, FilterValueType, FilterOptionsType>;
     isPlaceholder: boolean;
     getResizeHandler: () => (e: MouseEvent) => void;
 }

package/dist/Components/Table/Types/HeaderGroup.d.ts

@@ -1,5 +1,5 @@
 import type { Header } from './Header.js';
 export interface HeaderGroup<T extends object> {
     id: string;
-    headers: Array<Header<T, unknown>>;
+    headers: Array<Header<T, never, unknown>>;
 }

package/dist/Types/Examples/ExampleModal.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { DisplayDefModalProps } from '../../Components/Table/Types/Columns/Definitions/Display/AbstractDisplayDef.svelte.js';
 import type { ExampleItem } from './ExampleItem.js';
-declare const ExampleModal: import("svelte").Component<DisplayDefModalProps<ExampleItem, unknown, unknown>, {}, "">;
+declare const ExampleModal: import("svelte").Component<DisplayDefModalProps<ExampleItem, never, unknown>, {}, "">;
 type ExampleModal = ReturnType<typeof ExampleModal>;
 export default ExampleModal;