@lavalogic/scoria 0.38.10 → 0.38.11

package/dist/Components/Table/Misc/TableConfigurationModal.svelte

@@ -22,6 +22,7 @@
 	import type { DatatableViewKind } from '../Types/Persistence/DatatableViewKind.js';
 	import ShareViewModal from './ShareViewModal.svelte';
 	import type { TableConfigurationModalProps } from './TableConfigurationModalProps.js';
+	import UpdateViewOptionsModal from './UpdateViewOptionsModal.svelte';
 
 	const tableContext = getContext<TableContext<T, IdType>>(TableContext.identifier);
 
@@ -60,6 +61,26 @@
 	// to; the modal closes itself on Cancel / Save.
 	let sharingView = $state<DatatableView | null>(null);
 
+	// The view whose Update Options modal is currently open. `null` when
+	// no options modal is rendered. Same pattern as `sharingView`.
+	let updatingOptionsView = $state<DatatableView | null>(null);
+
+	/**
+	 * Overwrite a saved view's stored body with the table's current
+	 * live state. Triggered by the "Save Layout" / "Save Filter"
+	 * button on an owner card - the typical flow is "apply view A,
+	 * tweak the columns / filters, then click Save on A". Refreshes
+	 * the saved-views list afterwards so the card label and dropdown
+	 * pick up the new body, and surfaces any failure in the inline
+	 * error banner.
+	 */
+	function saveLiveStateInto(view: DatatableView): void {
+		void guard(async () => {
+			await tableContext.saveLiveStateIntoView(view);
+			await tableContext.refreshSavedViews();
+		}, `Could not save changes to "${view.name}". Please try again.`);
+	}
+
 	// Whether remote saved views are available at all. A table created
 	// without `datatableUuid` / `remoteLayouts` opts out of remote views;
 	// the modal then renders a graceful "unavailable" empty state and
@@ -358,6 +379,39 @@
 											applyView(view);
 										}}>Apply</Button
 									>
+									<!--
+										"Save Layout" / "Save Filter" overwrites THIS saved
+										view's stored body with the table's current live state.
+										Typical flow: user applies the view, tweaks the
+										columns or filter inputs, then clicks Save to make
+										the tweaks part of the saved view. Distinct from
+										"Save a new …" (which always creates a fresh record).
+									-->
+									<Button
+										variant={Variant.Secondary}
+										size={Size.MediumSmall}
+										nowrap
+										iconLeft={{ name: 'circle-tick', size: Size.Small }}
+										onclick={() => {
+											saveLiveStateInto(view);
+										}}>Save {sectionNoun}</Button
+									>
+									<!--
+										"Update Options" opens a dedicated modal that edits
+										the view's name and sharing visibility (private /
+										public). Kept separate from the inline body-save
+										above so a quick name fix never accidentally
+										overwrites the saved layout / filter.
+									-->
+									<Button
+										variant={Variant.Secondary}
+										size={Size.MediumSmall}
+										nowrap
+										iconLeft={{ name: 'edit', size: Size.Small }}
+										onclick={() => {
+											updatingOptionsView = view;
+										}}>Update Options</Button
+									>
 									<Button
 										variant={Variant.Secondary}
 										size={Size.MediumSmall}
@@ -570,6 +624,23 @@
 	/>
 {/if}
 
+<!--
+	Update-Options dialog stacked the same way as the Share dialog.
+	After a successful Save we refresh the saved views so the My-* card
+	picks up the new name / visibility immediately.
+-->
+{#if updatingOptionsView}
+	<UpdateViewOptionsModal
+		view={updatingOptionsView}
+		onclose={() => {
+			updatingOptionsView = null;
+		}}
+		onsaved={async () => {
+			await tableContext.refreshSavedViews();
+		}}
+	/>
+{/if}
+
 <style>.empty-state {
   display: flex;
   flex-flow: column nowrap;

package/dist/Components/Table/Misc/UpdateViewOptionsModal.svelte

@@ -0,0 +1,225 @@
+<svelte:options runes />
+
+<script
+	lang="ts"
+	generics="T extends object, IdType extends Primitive"
+>
+	import DesktopModal from '../../DesktopModal.svelte';
+	import Icon from '../../Icon.svelte';
+	import InfoAlert from '../../InfoAlert.svelte';
+	import SingleSelect from '../../SingleSelect.svelte';
+	import TextInput from '../../TextInput.svelte';
+	import { cssLength } from '../../../Helpers/Helpers.svelte.js';
+	import { ColourSet } from '../../../scss/colours.js';
+	import type { SelectOption } from '../../../Types/Internal/SelectOption.js';
+	import { Size } from '../../../Types/Internal/Size.js';
+	import { getContext, onMount } from 'svelte';
+	import { TableContext } from '../Types/Context/TableContext.svelte.js';
+	import type { Primitive } from '../Types/Context/TableInitOptions.js';
+	import type { DatatableViewVisibility } from '../Types/Persistence/DatatableView.js';
+	import type { UpdateViewOptionsModalProps } from './UpdateViewOptionsModalProps.js';
+
+	const { view, onclose, onsaved }: UpdateViewOptionsModalProps = $props();
+
+	const tableContext = getContext<TableContext<T, IdType>>(TableContext.identifier);
+
+	// Local form state. Seeded from the view's current values inside
+	// `onMount` so the modal opens populated with what's already saved
+	// without triggering Svelte's `state_referenced_locally` lint
+	// against the prop read; Save diffs against the view's current
+	// values to skip a no-op PATCH.
+	let name: string = $state('');
+	let visibility: DatatableViewVisibility = $state('private');
+
+	onMount(() => {
+		name = view.name;
+		visibility = view.visibility ?? 'private';
+	});
+
+	// User-visible error banner. Adapter rejections are routed here so
+	// the modal never throws into the host UI.
+	let errorMessage = $state<string | null>(null);
+
+	// `true` while the PATCH is in flight, disables the footer buttons.
+	let saving = $state(false);
+
+	const visibilityOptions: Array<SelectOption<DatatableViewVisibility>> = [
+		{
+			label: 'Private — only owner and explicit subscribers',
+			value: 'private',
+		},
+		{
+			label: 'Public — anyone with access to this table can subscribe',
+			value: 'public',
+		},
+	];
+
+	const selectedVisibility: SelectOption<DatatableViewVisibility> = $derived(
+		visibilityOptions.find((o) => o.value === visibility) ?? visibilityOptions[0]
+	);
+
+	// Whether anything in the form differs from the initial values.
+	// Drives the Save button's disabled state so a no-op Save never
+	// hits the network (also enforced inside `updateViewOptions`).
+	const dirty = $derived(
+		name.trim() !== view.name || visibility !== (view.visibility ?? 'private')
+	);
+
+	/** Whether the name is valid for submission (non-empty, trimmed). */
+	const isValidName = $derived(name.trim().length > 0);
+
+	async function save(): Promise<void> {
+		if (!dirty) {
+			onclose();
+			return;
+		}
+		if (!isValidName) {
+			errorMessage = `Name cannot be empty.`;
+			return;
+		}
+
+		errorMessage = null;
+		saving = true;
+		try {
+			await tableContext.updateViewOptions(view, {
+				name: name.trim(),
+				visibility,
+			});
+			if (onsaved) {
+				await onsaved();
+			}
+			onclose();
+		} catch (e: unknown) {
+			console.error('[UpdateViewOptionsModal] save failed:', e);
+			errorMessage =
+				e instanceof Error
+					? `Could not update options. (${e.message})`
+					: 'Could not update options.';
+		} finally {
+			saving = false;
+		}
+	}
+</script>
+
+<DesktopModal
+	headerLabel={`Update Options - "${view.name}"`}
+	headerSubtitle={`Rename and change sharing for this ${view.kind === 'filter' ? 'filter' : 'layout'}.`}
+	onclose={() => {
+		if (!saving) {
+			onclose();
+		}
+	}}
+	width={cssLength('40vw')}
+	minWidth={cssLength('32rem')}
+	buttons={[
+		{
+			label: 'Cancel',
+			callback: () => {
+				if (!saving) {
+					onclose();
+				}
+			},
+			disabled: saving,
+		},
+		{
+			label: saving ? 'Saving…' : 'Save',
+			callback: () => {
+				void save();
+			},
+			colourSet: ColourSet.Primary,
+			disabled: saving || !dirty || !isValidName,
+		},
+	]}
+>
+	<div class="options-body">
+		{#if errorMessage}
+			<div
+				class="error-banner"
+				role="alert"
+			>
+				<Icon
+					name="circle-exclamation"
+					size={Size.Small}
+				/>
+				<span>{errorMessage}</span>
+			</div>
+		{/if}
+
+		<InfoAlert>
+			Changes apply to every user who has access to this {view.kind === 'filter'
+				? 'filter'
+				: 'layout'}. Making it public allows any user with access to the table to subscribe.
+		</InfoAlert>
+
+		<div class="field">
+			<label
+				class="field-label"
+				for="update-view-name">Name</label
+			>
+			<TextInput
+				id="update-view-name"
+				bind:value={name}
+				placeholder={`${view.kind === 'filter' ? 'Filter' : 'Layout'} name`}
+				required
+				invalid={!isValidName}
+			/>
+		</div>
+
+		<div class="field">
+			<label
+				class="field-label"
+				for="update-view-visibility">Visibility</label
+			>
+			<SingleSelect
+				inputId="update-view-visibility"
+				name="Visibility"
+				options={visibilityOptions}
+				labelProp="label"
+				valueProp="value"
+				value={selectedVisibility}
+				valueAsObject
+				searchable={false}
+				onchange={(option: SelectOption<DatatableViewVisibility> | null) => {
+					if (option) {
+						visibility = option.value;
+					}
+				}}
+			/>
+		</div>
+	</div>
+</DesktopModal>
+
+<style>.options-body {
+  display: flex;
+  flex-flow: column nowrap;
+  gap: 0.75rem;
+  padding: 1rem;
+  min-height: 25vh;
+  max-height: 60vh;
+  overflow-y: auto;
+  background-color: #ffffff;
+}
+
+.error-banner {
+  display: flex;
+  flex-flow: row nowrap;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 0.75rem;
+  border: solid 1px #aa1414;
+  border-radius: 4px;
+  background-color: #f9e9e9;
+  color: #aa1414;
+}
+
+.field {
+  display: flex;
+  flex-flow: column nowrap;
+  gap: 0.25rem;
+}
+
+.field-label {
+  font-size: 1.125rem;
+  font-weight: 600;
+  color: #3a4952;
+}</style>

package/dist/Components/Table/Misc/UpdateViewOptionsModal.svelte.d.ts

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

package/dist/Components/Table/Misc/UpdateViewOptionsModalProps.d.ts

@@ -0,0 +1,21 @@
+import type { DatatableView } from '../Types/Persistence/DatatableView.js';
+/**
+ * Props for `UpdateViewOptionsModal` - the FPM 403 round-6 dialog
+ * opened from a saved view card's "Update Options" button. The modal
+ * lets the user rename the view and toggle its sharing visibility
+ * (`'private'` / `'public'`); Save patches both fields in one call
+ * through `TableContext.updateViewOptions`.
+ */
+export interface UpdateViewOptionsModalProps {
+    /** The saved view being edited. Its current `name` / `visibility`
+     *  pre-populate the form; `id` + `kind` are forwarded to the
+     *  update call. */
+    view: DatatableView;
+    /** Called when the modal should close - both on Cancel and after
+     *  a successful Save. */
+    onclose: () => void;
+    /** Called after a successful Save, before `onclose`. The host
+     *  wires this to a saved-views refresh so the My-* card label
+     *  reflects the new name. Optional - omit to skip the refresh. */
+    onsaved?: () => void | Promise<void>;
+}

package/dist/Components/Table/Misc/UpdateViewOptionsModalProps.js

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

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

@@ -13,7 +13,7 @@ import type { VisibilityState } from '../Columns/VisibilityState.js';
 import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
 import type { VisualColumnIndex } from '../Coordinates/ColumnIndices.js';
 import type { RemoteTableLayoutAdapter } from '../Persistence/RemoteTableLayoutAdapter.js';
-import type { DatatableView } from '../Persistence/DatatableView.js';
+import type { DatatableView, DatatableViewVisibility } from '../Persistence/DatatableView.js';
 import type { DatatableViewKind } from '../Persistence/DatatableViewKind.js';
 import type { IDataRepository } from '../DataRepository/IDataRepository.js';
 import { SortingState } from './SortingState.svelte.js';
@@ -943,6 +943,54 @@ export declare class TableContext<T extends object, RowIdType extends Primitive>
      * disabled. An adapter rejection is routed to `devCatch`.
      */
     readonly saveActiveView: (kind: DatatableViewKind) => Promise<void>;
+    /**
+     * Save the live state of the table INTO an arbitrary saved view,
+     * overwriting that view's stored body. Unlike `saveActiveView` -
+     * which only works when the target IS the kind's active view -
+     * this accepts any saved view: a "Save Layout" / "Save Filter"
+     * button on a card can overwrite the saved view with the user's
+     * current tweaks regardless of what the active view is.
+     *
+     * Flow:
+     *
+     * 1. capture the live layout / filter (chosen by `view.kind`);
+     * 2. `await remoteLayouts.updateView({ id, body })`;
+     * 3. swap the matching entry in that kind's saved-views list with
+     *    the authoritative server return;
+     * 4. if the just-saved view IS the kind's currently active view,
+     *    repoint that kind's baseline at the new body and clear the
+     *    dirty flag - the dropdown immediately reads "<name>" instead
+     *    of "<name> (unsaved)".
+     *
+     * No-op (dev-logged) when remote saved views are disabled. Adapter
+     * rejections are re-thrown so the caller can surface them in the
+     * Table Configuration modal's inline error banner.
+     */
+    readonly saveLiveStateIntoView: (view: DatatableView) => Promise<void>;
+    /**
+     * Update a saved view's options - currently its `name` and
+     * `visibility`. The view's body is left untouched (use
+     * `saveLiveStateIntoView` or `saveActiveView` for that). Driven by
+     * the "Update Options" modal on each My-* card.
+     *
+     * Flow:
+     *
+     * 1. `await remoteLayouts.updateView({ id, name?, visibility? })`;
+     * 2. swap the matching entry in that kind's saved-views list with
+     *    the authoritative server return so the new name / visibility
+     *    are reflected in every reactive surface;
+     * 3. if the renamed view IS the kind's currently active view, push
+     *    the new name onto the active-view ref so the quick-switch
+     *    dropdown and "active view" label update immediately.
+     *
+     * No-op (dev-logged) when remote saved views are disabled. Adapter
+     * rejections are re-thrown so the caller can surface them in the
+     * modal.
+     */
+    readonly updateViewOptions: (view: DatatableView, options: {
+        name?: string;
+        visibility?: DatatableViewVisibility;
+    }) => Promise<void>;
     /**
      * Fetch the saved views for this datatable through the injected
      * `remoteLayouts` adapter and publish them into `_viewState`, split by

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

@@ -2191,10 +2191,33 @@ export class TableContext {
         // plain strings - look up cleanly against the live column set.
         // eslint-disable-next-line svelte/prefer-svelte-reactivity
         const liveColumnIds = new Set(this.columnDefs.map((def) => def.id));
+        // 1. Clear the current filter VALUES. Without this, switching
+        //    saved filter views would only ADD entries from the new view
+        //    on top of whatever the old view set - any column the old
+        //    view filtered but the new one does not would keep its old
+        //    value and `FilterInput` would still show it.
         if (typeof repo.resetFilters === 'function') {
             repo.resetFilters();
         }
-        // Modes first: a value-bearing mode must be set before its value.
+        // 2. Clear the current filter MODES the same way. `resetFilters`
+        //    deliberately keeps modes (so a "Clear filters" toolbar
+        //    action retains operator selections); but applying a saved
+        //    view is a *replace*, so a stale mode (e.g. the old view's
+        //    "Empty" operator) leaking into the new view would leave
+        //    `FilterInput`'s mode dropdown out of sync with the value it
+        //    renders.
+        if (typeof repo.setFilterMode === 'function') {
+            for (const id of [...repo.filterModes.keys()]) {
+                repo.setFilterMode(id, undefined);
+            }
+        }
+        // 3. Clear the QuerySelect typeahead-echo cache so the user
+        //    doesn't see a stale label hanging in a `QuerySelect` whose
+        //    underlying value just got reset. `_queryValues` is keyed by
+        //    `def.id`, the same key space `FilterInput` reads from.
+        this._queryValues.clear();
+        // 4. Apply the saved modes (before values so a value-bearing
+        //    mode like "Empty" sees its mode already set).
         if (typeof repo.setFilterMode === 'function') {
             for (const [id, mode] of Object.entries(filter.modes)) {
                 // Drop stale column ids and unrecognised mode strings.
@@ -2203,6 +2226,7 @@ export class TableContext {
                 }
             }
         }
+        // 5. Apply the saved values.
         if (typeof repo.filterBy === 'function') {
             for (const entry of filter.filters) {
                 if (liveColumnIds.has(entry.id)) {
@@ -2498,6 +2522,123 @@ export class TableContext {
             devCatch(e);
         }
     };
+    /**
+     * Save the live state of the table INTO an arbitrary saved view,
+     * overwriting that view's stored body. Unlike `saveActiveView` -
+     * which only works when the target IS the kind's active view -
+     * this accepts any saved view: a "Save Layout" / "Save Filter"
+     * button on a card can overwrite the saved view with the user's
+     * current tweaks regardless of what the active view is.
+     *
+     * Flow:
+     *
+     * 1. capture the live layout / filter (chosen by `view.kind`);
+     * 2. `await remoteLayouts.updateView({ id, body })`;
+     * 3. swap the matching entry in that kind's saved-views list with
+     *    the authoritative server return;
+     * 4. if the just-saved view IS the kind's currently active view,
+     *    repoint that kind's baseline at the new body and clear the
+     *    dirty flag - the dropdown immediately reads "<name>" instead
+     *    of "<name> (unsaved)".
+     *
+     * No-op (dev-logged) when remote saved views are disabled. Adapter
+     * rejections are re-thrown so the caller can surface them in the
+     * Table Configuration modal's inline error banner.
+     */
+    saveLiveStateIntoView = async (view) => {
+        const adapter = this.remoteLayouts;
+        if (!adapter) {
+            if (dev) {
+                console.warn('saveLiveStateIntoView: no adapter - cannot save remotely');
+            }
+            return;
+        }
+        const body = view.kind === 'filter'
+            ? { kind: 'filter', filter: this._captureFilter() }
+            : { kind: 'layout', layout: this._captureLayout() };
+        const request = {
+            id: view.id,
+            body,
+        };
+        const updated = await adapter.updateView(request);
+        // Swap the matching entry in the saved-views list so the picker
+        // + modal reflect the new body without an extra refresh round-trip.
+        this._viewState.setSavedViews(view.kind, this._viewState.savedViews(view.kind).map((v) => (v.id === updated.id ? updated : v)));
+        // If the saved-into view IS the active view for its kind,
+        // repoint the baseline so dirty re-compares against the new
+        // body and clears.
+        const active = this._viewState.activeView(view.kind);
+        if (active.kind === 'saved' && active.id === updated.id) {
+            this._viewState.selectSavedView(view.kind, { id: updated.id, name: updated.name });
+            if (view.kind === 'filter') {
+                this._filterBaseline =
+                    updated.body.kind === 'filter' ? updated.body.filter : this._captureFilter();
+                this._persistActiveFilterView();
+            }
+            else {
+                this._viewBaseline =
+                    updated.body.kind === 'layout' ? updated.body.layout : this._captureLayout();
+                this._persistActiveView();
+            }
+        }
+    };
+    /**
+     * Update a saved view's options - currently its `name` and
+     * `visibility`. The view's body is left untouched (use
+     * `saveLiveStateIntoView` or `saveActiveView` for that). Driven by
+     * the "Update Options" modal on each My-* card.
+     *
+     * Flow:
+     *
+     * 1. `await remoteLayouts.updateView({ id, name?, visibility? })`;
+     * 2. swap the matching entry in that kind's saved-views list with
+     *    the authoritative server return so the new name / visibility
+     *    are reflected in every reactive surface;
+     * 3. if the renamed view IS the kind's currently active view, push
+     *    the new name onto the active-view ref so the quick-switch
+     *    dropdown and "active view" label update immediately.
+     *
+     * No-op (dev-logged) when remote saved views are disabled. Adapter
+     * rejections are re-thrown so the caller can surface them in the
+     * modal.
+     */
+    updateViewOptions = async (view, options) => {
+        const adapter = this.remoteLayouts;
+        if (!adapter) {
+            if (dev) {
+                console.warn('updateViewOptions: no adapter - cannot update remotely');
+            }
+            return;
+        }
+        // Skip the network round-trip entirely when nothing actually
+        // changed. Avoids a no-op PATCH that would still bump the
+        // updated_at timestamp on the backend.
+        const nameChanged = options.name !== undefined && options.name !== view.name;
+        const visibilityChanged = options.visibility !== undefined && options.visibility !== view.visibility;
+        if (!nameChanged && !visibilityChanged) {
+            return;
+        }
+        const request = {
+            id: view.id,
+            ...(nameChanged ? { name: options.name } : {}),
+            ...(visibilityChanged ? { visibility: options.visibility } : {}),
+        };
+        const updated = await adapter.updateView(request);
+        this._viewState.setSavedViews(view.kind, this._viewState.savedViews(view.kind).map((v) => (v.id === updated.id ? updated : v)));
+        // If the just-edited view is the active one for its kind, push
+        // the new name onto the active-view ref so the dropdown label
+        // reflects the rename without waiting for a refresh.
+        const active = this._viewState.activeView(view.kind);
+        if (active.kind === 'saved' && active.id === updated.id) {
+            this._viewState.selectSavedView(view.kind, { id: updated.id, name: updated.name });
+            if (view.kind === 'filter') {
+                this._persistActiveFilterView();
+            }
+            else {
+                this._persistActiveView();
+            }
+        }
+    };
     /**
      * Fetch the saved views for this datatable through the injected
      * `remoteLayouts` adapter and publish them into `_viewState`, split by

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

@@ -65,7 +65,7 @@ export declare class BuiltInRemoteRepository<TRow extends object> extends TableD
     private _debounceTimer;
     private _quickFilterFocusCount;
     constructor(_options: BuiltInRemoteRepositoryOptions<TRow>);
-    readonly setFilterMode: (id: string, mode: FilterMode) => void;
+    readonly setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     readonly filterBy: (id: string, value: unknown) => void;
     readonly resetFilters: () => void;
     /** Jumps to the given 1-based page number, clamped at >= 1. */
@@ -121,7 +121,7 @@ export declare class CustomRemoteRepository<TRow extends object> extends TableDa
     get filtering(): ColumnFiltersState;
     private _abortController;
     constructor(tableName: string, getUserId: () => string | undefined, _fetch: CustomRowSource<TRow>['fetch']);
-    readonly setFilterMode: (id: string, mode: FilterMode) => void;
+    readonly setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     readonly filterBy: (id: string, value: unknown) => void;
     readonly resetFilters: () => void;
     /** Jumps to the given 1-based page number, clamped at >= 1. */

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

@@ -91,7 +91,16 @@ export class BuiltInRemoteRepository extends TableDataRepository {
     }
     // ── IRemoteDataRepository surface ────────────────────────────────
     setFilterMode = (id, mode) => {
-        this._filterModes.set(id, mode);
+        if (mode === undefined) {
+            // Drop the entry entirely so the column falls back to its
+            // kind's default mode on the next render. Used by
+            // `TableContext._applyFilter` to clear stale modes when a
+            // saved filter view is applied.
+            this._filterModes.delete(id);
+        }
+        else {
+            this._filterModes.set(id, mode);
+        }
         this.scheduleReload();
     };
     filterBy = (id, value) => {
@@ -366,7 +375,16 @@ export class CustomRemoteRepository extends TableDataRepository {
         this._fetch = _fetch;
     }
     setFilterMode = (id, mode) => {
-        this._filterModes.set(id, mode);
+        if (mode === undefined) {
+            // Drop the entry entirely so the column falls back to its
+            // kind's default mode on the next render. Used by
+            // `TableContext._applyFilter` when restoring a saved filter
+            // view to clear modes left over from a prior view.
+            this._filterModes.delete(id);
+        }
+        else {
+            this._filterModes.set(id, mode);
+        }
         void this.reload();
     };
     filterBy = (id, value) => {

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

@@ -37,7 +37,15 @@ export interface IDataRepository<T extends object> {
     sorting: SortingState;
     filtering: ColumnFiltersState;
     filterModes: SvelteMap<string, FilterMode>;
-    setFilterMode: (id: string, mode: FilterMode) => void;
+    /**
+     * Set the filter mode for column `id`. Pass `undefined` to delete the
+     * entry entirely (the column then falls back to its kind's default
+     * mode when the next `FilterInput` / `QuickSearchCell` renders).
+     * Used by `_applyFilter` when restoring a saved filter view, so any
+     * mode from a previously-applied view is dropped before the new
+     * one's modes are applied.
+     */
+    setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     filterBy: (id: string, value: unknown) => void;
     dateFilter?: FilterFn<T, DateFilterValueType>;
     numberFilter?: FilterFn<T, NumberFilterValueType>;

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

@@ -21,7 +21,7 @@ export interface ILocalDataRepository<T extends object> extends IDataRepository<
     prevPage: () => void;
     filtering: ColumnFiltersState;
     filterModes: SvelteMap<string, FilterMode>;
-    setFilterMode: (id: string, mode: FilterMode) => void;
+    setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     filterBy: (id: string, value: unknown) => void;
     dateFilter: FilterFn<T, DateFilterValueType>;
     numberFilter: FilterFn<T, NumberFilterValueType>;

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

@@ -26,7 +26,7 @@ export interface IRemoteDataRepository<T extends object> extends IDataRepository
     prevPage: () => void;
     filtering: ColumnFiltersState;
     filterModes: SvelteMap<string, FilterMode>;
-    setFilterMode: (id: string, mode: FilterMode) => void;
+    setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     filterBy: (id: string, value: unknown) => void;
     resetFilters: () => void;
     lastPage: number;

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

@@ -42,7 +42,7 @@ export declare abstract class TableDataRepository<T extends object, out FilterVa
      */
     abstract setPageSize: (size: number | string) => void;
     abstract filtering: ColumnFiltersState<FilterValueType>;
-    abstract setFilterMode: (id: string, mode: FilterMode) => void;
+    abstract setFilterMode: (id: string, mode: FilterMode | undefined) => void;
     abstract filterBy: (id: string, value: unknown) => void;
     abstract resetFilters: () => void;
     abstract setPage: (page: number) => void;

package/dist/Components/Table/Types/Persistence/DatatableView.d.ts

@@ -1,5 +1,15 @@
 import type { DatatableViewBody } from './DatatableViewEnvelope.js';
 import type { DatatableViewKind } from './DatatableViewKind.js';
+/**
+ * Sharing visibility for a saved view. `'private'` is the default for
+ * v1: only the owner and explicit subscribers can see and apply it.
+ * `'public'` exposes the view to every user who has access to the
+ * datatable - they see it in the "Subscribe to Additional…" picker and
+ * can subscribe to it. scoria never interprets this token beyond
+ * passing it back through the adapter; the backend enforces the
+ * visibility semantics.
+ */
+export type DatatableViewVisibility = 'private' | 'public';
 /**
  * A saved datatable view - a named, persisted column layout or filter
  * that round-trips through a `RemoteTableLayoutAdapter`. This is the
@@ -47,6 +57,15 @@ export interface DatatableView {
      * UI - scoria falls back to `userId` when it is absent.
      */
     subscribers?: ReadonlyArray<DatatableViewSubscriber>;
+    /**
+     * Sharing visibility. `'private'` (default) is only visible to the
+     * owner and explicit subscribers; `'public'` is offered to every
+     * user with datatable access through the "Subscribe to Additional…"
+     * picker. Optional on read for backwards compatibility - hosts that
+     * have not surfaced this column yet can omit it, and scoria falls
+     * back to private semantics in the UI.
+     */
+    visibility?: DatatableViewVisibility;
 }
 /**
  * One entry in a `DatatableView.subscribers` roster: an opaque user
@@ -81,6 +100,12 @@ export interface UpdateDatatableViewRequest {
     name?: string;
     /** New payload, if the layout/filter is being replaced. */
     body?: DatatableViewBody;
+    /**
+     * New sharing visibility, if it is being changed. `'private'` keeps
+     * the view scoped to its owner + subscribers; `'public'` exposes it
+     * to every user with datatable access.
+     */
+    visibility?: DatatableViewVisibility;
 }
 /**
  * A subscriber relationship for a shared `DatatableView`. v1 sharing is

package/dist/index.d.ts

@@ -114,7 +114,7 @@ export { type JSONTableLayout, TABLE_LAYOUT_SCHEMA_VERSION, isJSONTableLayout, }
 export { type JSONTableFilter, TABLE_FILTER_SCHEMA_VERSION, isJSONTableFilter, } from './Components/Table/Types/Persistence/JSONTableFilter.js';
 export { type DatatableViewKind } from './Components/Table/Types/Persistence/DatatableViewKind.js';
 export { type DatatableViewBody } from './Components/Table/Types/Persistence/DatatableViewEnvelope.js';
-export type { CreateDatatableViewRequest, DatatableView, DatatableViewSubscriber, DatatableViewSubscription, UpdateDatatableViewRequest, } from './Components/Table/Types/Persistence/DatatableView.js';
+export type { CreateDatatableViewRequest, DatatableView, DatatableViewSubscriber, DatatableViewSubscription, DatatableViewVisibility, UpdateDatatableViewRequest, } from './Components/Table/Types/Persistence/DatatableView.js';
 export { type RemoteTableLayoutAdapter, type DatatableViewUser, } from './Components/Table/Types/Persistence/RemoteTableLayoutAdapter.js';
 export { type ActiveViewRef, type JSONActiveView, TABLE_ACTIVE_VIEW_SCHEMA_VERSION, isJSONActiveView, } from './Components/Table/Types/Persistence/JSONActiveView.js';
 export { type ValidationFn } from './Components/Table/Types/Columns/Definitions/ValidationFn.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lavalogic/scoria",
   "description": "Svelte components used for the FloWMS Web Frontend",
-  "version": "0.38.10",
+  "version": "0.38.11",
   "publishConfig": {
     "access": "restricted"
   },