@selvajs/ui 6.5.1-beta.1 → 6.6.0-beta.12

package/src/lib/compute/solving.svelte.ts

@@ -2,76 +2,92 @@ import { untrack } from 'svelte';
 import { APP_DEFAULTS } from '../constants';
 
 /**
- * Adaptive solving indicator: measures solve durations and adjusts its
- * visibility delay from the running average.
+ * When to show that a solve is running. A solve that ends within `SHOW_AFTER_MS` shows nothing:
+ * the result updating is feedback enough, and a spinner that flashes for a frame reads as jank.
+ * Once shown, the indicator stays `MIN_VISIBLE_MS` for the same reason. `slow` turns on past
+ * `SLOW_AFTER_MS`, the case of a Rhino.Compute round trip or a heavy definition.
  *
- * - Average under FAST_THRESHOLD_MS: never shown, so quick solves don't flicker
- * - Average over SLOW_THRESHOLD_MS: shown immediately
- * - Between the two: shown after a proportional slice of ANIMATION_DELAY
- * - First solve: shown immediately, there is no history yet
+ * `freezesDuringSolve` is for a host that can't paint while it solves (an embedded WebView on
+ * the solver's thread). A delay can't run there, so the indicator shows on every solve, before
+ * the solve takes the thread: it is the only place that host can say Esc aborts.
  */
-export function createSolvingIndicator(isSolving: () => boolean): { readonly show: boolean } {
-	const { FAST_THRESHOLD_MS, SLOW_THRESHOLD_MS, HISTORY_SIZE, ANIMATION_DELAY } =
-		APP_DEFAULTS.SOLVING_INDICATOR;
+export function createSolvingIndicator(
+	isSolving: () => boolean,
+	options: { freezesDuringSolve?: boolean } = {}
+): { readonly show: boolean; readonly slow: boolean } {
+	const { SHOW_AFTER_MS, MIN_VISIBLE_MS, SLOW_AFTER_MS } = APP_DEFAULTS.SOLVING_INDICATOR;
+
+	if (options.freezesDuringSolve) {
+		return {
+			// Read straight from `isSolving`, not through an effect: an effect would run a tick
+			// later, after the solve has already frozen the page.
+			get show() {
+				return isSolving();
+			},
+			slow: false
+		};
+	}
 
 	let show = $state(false);
-	let timeout: ReturnType<typeof setTimeout> | null = null;
-	let solveStartTime: number | null = null;
-	const solveHistory: number[] = [];
+	let slow = $state(false);
+	let shownAt = 0;
+	let showTimer: ReturnType<typeof setTimeout> | null = null;
+	let slowTimer: ReturnType<typeof setTimeout> | null = null;
+	let hideTimer: ReturnType<typeof setTimeout> | null = null;
+
+	function clear(timer: ReturnType<typeof setTimeout> | null) {
+		if (timer) clearTimeout(timer);
+		return null;
+	}
+
+	function hide() {
+		hideTimer = null;
+		show = false;
+		slow = false;
+	}
 
 	$effect(() => {
 		const solving = isSolving();
-
 		untrack(() => {
 			if (solving) {
-				solveStartTime = performance.now();
-
-				const avg =
-					solveHistory.length === 0
-						? Infinity
-						: solveHistory.reduce((a, b) => a + b, 0) / solveHistory.length;
-
-				if (solveHistory.length > 0 && avg < FAST_THRESHOLD_MS) return;
-
-				const delay =
-					avg === Infinity || avg >= SLOW_THRESHOLD_MS
-						? 0
-						: ((avg - FAST_THRESHOLD_MS) / (SLOW_THRESHOLD_MS - FAST_THRESHOLD_MS)) *
-							ANIMATION_DELAY;
-
-				if (!timeout) {
-					if (delay === 0) {
+				// A solve that starts while the last one's indicator is held keeps it up.
+				hideTimer = clear(hideTimer);
+				if (!show) {
+					showTimer ??= setTimeout(() => {
+						showTimer = null;
 						show = true;
-					} else {
-						timeout = setTimeout(() => {
-							show = true;
-							timeout = null;
-						}, delay);
-					}
+						shownAt = performance.now();
+					}, SHOW_AFTER_MS);
 				}
+				slowTimer ??= setTimeout(() => {
+					slowTimer = null;
+					slow = true;
+				}, SLOW_AFTER_MS);
 			} else {
-				if (solveStartTime !== null) {
-					solveHistory.push(performance.now() - solveStartTime);
-					if (solveHistory.length > HISTORY_SIZE) solveHistory.shift();
-					solveStartTime = null;
-				}
-
-				if (timeout) {
-					clearTimeout(timeout);
-					timeout = null;
-				}
-				show = false;
+				showTimer = clear(showTimer);
+				slowTimer = clear(slowTimer);
+				if (!show) return;
+				const remaining = MIN_VISIBLE_MS - (performance.now() - shownAt);
+				if (remaining > 0) hideTimer ??= setTimeout(hide, remaining);
+				else hide();
 			}
 		});
+	});
 
-		return () => {
-			if (timeout) clearTimeout(timeout);
-		};
+	// Separate from the effect above: a cleanup there would run on every `isSolving` flip and
+	// cancel the timers it just set.
+	$effect(() => () => {
+		clear(showTimer);
+		clear(slowTimer);
+		clear(hideTimer);
 	});
 
 	return {
 		get show() {
 			return show;
+		},
+		get slow() {
+			return slow;
 		}
 	};
 }

package/src/lib/compute/useSolveSession.svelte.ts

@@ -86,10 +86,13 @@ export function useSolveSession(args: SolveSessionArgs): SolveSession {
 		discard: () => session.discard(),
 		setValue: (id, value, forceSolve) => session.setValue(id, value, forceSolve),
 		solve: () => session.solve(),
+		ensureSolved: () => session.ensureSolved(),
+		onSettled: (listener) => session.onSettled(listener),
 		loadValues: (incoming) => session.loadValues(incoming),
 		rebuild: (schema, scopeKey) => session.rebuild(schema, scopeKey),
 		report: (result) => session.report(result),
 		reportError: (message) => session.reportError(message),
+		reportAborted: () => session.reportAborted(),
 		subscribe: (listener) => session.subscribe(listener),
 		notify: () => session.notify(),
 		dispose: () => session.dispose()

package/src/lib/constants.ts

@@ -18,16 +18,14 @@ export const APP_DEFAULTS = {
 		DRAWER_ANIMATION_MS: 350
 	},
 
-	// Solving indicator adaptive thresholds
+	// See createSolvingIndicator.
 	SOLVING_INDICATOR: {
-		/** If solve is faster than this, don't show indicator (ms) */
-		FAST_THRESHOLD_MS: 200,
-		/** If solve is slower than this, show indicator immediately (ms) */
-		SLOW_THRESHOLD_MS: 600,
-		/** Animation delay for solve indicator (ms) */
-		ANIMATION_DELAY: 300,
-		/** Number of solve durations to keep in history for averaging */
-		HISTORY_SIZE: 3
+		/** A solve that ends sooner shows no indicator (ms) */
+		SHOW_AFTER_MS: 400,
+		/** Once shown, the indicator stays at least this long (ms) */
+		MIN_VISIBLE_MS: 500,
+		/** Past this a solve counts as slow and the viewer dims its stale result (ms) */
+		SLOW_AFTER_MS: 2000
 	},
 
 	// File size formatting

package/src/lib/contexts/hostContext.svelte.ts

@@ -0,0 +1,51 @@
+import { getContext, setContext } from 'svelte';
+import type { GeometryKind } from '@selvajs/schemas';
+import type { UIHost } from '$lib/schema/host-support';
+
+// Tells InputControl which host it renders in and how to reach the host's own actions, without
+// threading a prop through every layout layer. Without a provider the host is Selva.
+
+export type GeometryPickResult =
+	| { outcome: 'picked'; summary: string }
+	| { outcome: 'cancelled' }
+	| { outcome: 'failed'; error: string };
+
+/** What a pick button can ask for: a Get Geometry filter's kinds, or Get Point/Line/Plane's own. */
+export type PickKind = GeometryKind | 'line' | 'plane';
+
+/** What a geometry input lets the user pick, as the host discovered it on the canvas. */
+export interface GeometryPickTarget {
+	/** The kinds its filter allows; absent when it takes anything. */
+	kinds?: readonly GeometryKind[];
+	/** 1 picks a single object. */
+	atMost?: number;
+}
+
+export interface HostActions {
+	host: UIHost;
+	/** Prompts in the Rhino viewport for a geometry input. The picked geometry stays in Grasshopper. */
+	pickGeometry?: (paramId: string) => Promise<GeometryPickResult>;
+	/** Empties a geometry input again, back to the definition's own value. */
+	clearGeometry?: (paramId: string) => void;
+	/**
+	 * Reports what the param holds after every pick or clear, including those another page asked
+	 * for; null when nothing is picked into it. Returns an unsubscribe.
+	 */
+	onGeometrySummary?: (paramId: string, listener: (summary: string | null) => void) => () => void;
+	describeGeometry?: (paramId: string) => GeometryPickTarget | undefined;
+	/** Presses a button input: one solve with `true`, then it goes back to `false`. */
+	trigger?: (paramId: string) => void;
+	/** Grasshopper refuses a press while it solves, so the button waits it out disabled. */
+	isSolving?: () => boolean;
+}
+
+const SELVA_HOST: HostActions = { host: 'selva' };
+const HOST_CONTEXT_KEY = Symbol('host-context');
+
+export function setHostContext(actions: HostActions): void {
+	setContext(HOST_CONTEXT_KEY, actions);
+}
+
+export function getHostContext(): HostActions {
+	return getContext<HostActions | undefined>(HOST_CONTEXT_KEY) ?? SELVA_HOST;
+}

package/src/lib/i18n/localeContext.svelte.ts

@@ -1,11 +1,18 @@
 import { getContext, setContext } from 'svelte';
-import { type Locale, type ViewerMessages, messagesFor, DEFAULT_LOCALE } from './messages';
+import {
+	type Locale,
+	type ViewerMessages,
+	messagesFor,
+	withOverrides,
+	DEFAULT_LOCALE
+} from './messages';
 
 // Carries the UI locale down to the viewer and its panels without threading a
 // `lang` prop through every layer.
 //
 // Resolution order for any consuming component:
 //   explicit `lang` prop  →  nearest locale context  →  English default
+// and the strings are that locale's catalog with any `messages` overrides on top.
 //
 // Two ways to provide it:
 //   - Standalone: <Viewer lang="de" /> — Viewer provides the context itself.
@@ -20,22 +27,50 @@ export interface LocaleContext {
 }
 
 /**
- * Provide the locale to descendants. Pass a getter, not a value: it is re-read on every
+ * Provide the locale to descendants. Pass getters, not values: they are re-read on every
  * consumer render, so a reactive source (a `$state`, the app's Paraglide locale) switches
- * the language live.
+ * the language live. `getOverrides` replaces individual strings of the resolved catalog.
  */
-export function setLocaleContext(getLocale: () => Locale | undefined): void {
+export function setLocaleContext(
+	getLocale: () => Locale | undefined,
+	getOverrides?: () => Partial<ViewerMessages> | undefined
+): void {
 	const ctx: LocaleContext = {
 		get locale() {
 			return getLocale() ?? DEFAULT_LOCALE;
 		},
 		get messages() {
-			return messagesFor(getLocale());
+			return withOverrides(messagesFor(getLocale()), getOverrides?.());
 		}
 	};
 	setContext(LOCALE_CONTEXT_KEY, ctx);
 }
 
+/**
+ * Re-provides the nearest context for a component that takes its own `lang`/`messages` props.
+ * Without `lang`, or with the inherited locale, the subtree keeps the overrides an outer provider
+ * applied; a different `lang` starts from that locale's catalog, since those overrides were
+ * written for another language.
+ */
+export function layerLocaleContext(
+	getLang: () => Locale | undefined,
+	getOverrides?: () => Partial<ViewerMessages> | undefined
+): LocaleContext {
+	const outer = getLocaleContext();
+	const ctx: LocaleContext = {
+		get locale() {
+			return getLang() ?? outer.locale;
+		},
+		get messages() {
+			const lang = getLang();
+			const base = lang === undefined || lang === outer.locale ? outer.messages : messagesFor(lang);
+			return withOverrides(base, getOverrides?.());
+		}
+	};
+	setContext(LOCALE_CONTEXT_KEY, ctx);
+	return ctx;
+}
+
 /**
  * Falls back to an English-only context when no provider exists (a primitive used in
  * isolation), so consumers never need a null check.