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

package/dist/compute/solving.svelte.d.ts

@@ -1,12 +1,16 @@
 /**
- * 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 declare function createSolvingIndicator(isSolving: () => boolean): {
+export declare function createSolvingIndicator(isSolving: () => boolean, options?: {
+    freezesDuringSolve?: boolean;
+}): {
     readonly show: boolean;
+    readonly slow: boolean;
 };

package/dist/compute/solving.svelte.js

@@ -1,68 +1,87 @@
 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) {
-    const { FAST_THRESHOLD_MS, SLOW_THRESHOLD_MS, HISTORY_SIZE, ANIMATION_DELAY } = APP_DEFAULTS.SOLVING_INDICATOR;
+export function createSolvingIndicator(isSolving, options = {}) {
+    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 = null;
-    let solveStartTime = null;
-    const solveHistory = [];
+    let slow = $state(false);
+    let shownAt = 0;
+    let showTimer = null;
+    let slowTimer = null;
+    let hideTimer = null;
+    function clear(timer) {
+        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/dist/compute/useSolveSession.svelte.js

@@ -79,10 +79,13 @@ export function useSolveSession(args) {
         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/dist/constants.d.ts

@@ -10,14 +10,12 @@ export declare const APP_DEFAULTS: {
         DRAWER_ANIMATION_MS: number;
     };
     SOLVING_INDICATOR: {
-        /** If solve is faster than this, don't show indicator (ms) */
-        FAST_THRESHOLD_MS: number;
-        /** If solve is slower than this, show indicator immediately (ms) */
-        SLOW_THRESHOLD_MS: number;
-        /** Animation delay for solve indicator (ms) */
-        ANIMATION_DELAY: number;
-        /** Number of solve durations to keep in history for averaging */
-        HISTORY_SIZE: number;
+        /** A solve that ends sooner shows no indicator (ms) */
+        SHOW_AFTER_MS: number;
+        /** Once shown, the indicator stays at least this long (ms) */
+        MIN_VISIBLE_MS: number;
+        /** Past this a solve counts as slow and the viewer dims its stale result (ms) */
+        SLOW_AFTER_MS: number;
     };
     FILE_SIZE: {
         /** Bytes per kilobyte */

package/dist/constants.js

@@ -16,16 +16,14 @@ export const APP_DEFAULTS = {
         /** Drawer open/close animation duration (ms) — matches the CSS transition. */
         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
     FILE_SIZE: {

package/dist/contexts/hostContext.svelte.d.ts

@@ -0,0 +1,39 @@
+import type { GeometryKind } from '@selvajs/schemas';
+import type { UIHost } from '../schema/host-support';
+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;
+}
+export declare function setHostContext(actions: HostActions): void;
+export declare function getHostContext(): HostActions;

package/dist/contexts/hostContext.svelte.js

@@ -0,0 +1,9 @@
+import { getContext, setContext } from 'svelte';
+const SELVA_HOST = { host: 'selva' };
+const HOST_CONTEXT_KEY = Symbol('host-context');
+export function setHostContext(actions) {
+    setContext(HOST_CONTEXT_KEY, actions);
+}
+export function getHostContext() {
+    return getContext(HOST_CONTEXT_KEY) ?? SELVA_HOST;
+}

package/dist/i18n/localeContext.svelte.d.ts

@@ -4,11 +4,18 @@ export interface LocaleContext {
     readonly messages: ViewerMessages;
 }
 /**
- * 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 declare function setLocaleContext(getLocale: () => Locale | undefined): void;
+export declare function setLocaleContext(getLocale: () => Locale | undefined, getOverrides?: () => Partial<ViewerMessages> | undefined): void;
+/**
+ * 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 declare function layerLocaleContext(getLang: () => Locale | undefined, getOverrides?: () => Partial<ViewerMessages> | undefined): LocaleContext;
 /**
  * Falls back to an English-only context when no provider exists (a primitive used in
  * isolation), so consumers never need a null check.

package/dist/i18n/localeContext.svelte.js

@@ -1,10 +1,11 @@
 import { getContext, setContext } from 'svelte';
-import { messagesFor, DEFAULT_LOCALE } from './messages';
+import { 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.
@@ -12,21 +13,42 @@ import { messagesFor, DEFAULT_LOCALE } from './messages';
 //     viewer (and anything else) reads it.
 const LOCALE_CONTEXT_KEY = Symbol('viewer-locale-context');
 /**
- * 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) {
+export function setLocaleContext(getLocale, getOverrides) {
     const ctx = {
         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, getOverrides) {
+    const outer = getLocaleContext();
+    const ctx = {
+        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.

package/dist/i18n/messages.d.ts

@@ -20,6 +20,13 @@ export interface ViewerMessages {
     viewLeft: string;
     viewBottom: string;
     viewIso: string;
+    lookTechnical: string;
+    lookStudio: string;
+    lookShowcase: string;
+    lookArctic: string;
+    lookXray: string;
+    lookLineart: string;
+    lookWireframe: string;
     searchObjects: string;
     clearSearch: string;
     expandLayer: string;
@@ -43,12 +50,14 @@ export interface ViewerMessages {
     solveMessagesConfirm: string;
     solveMessagesDiscard: string;
     solveMessagesAbort: string;
+    /** Stands in for Abort where the page can't take a click mid-solve. */
+    solveMessagesEscHint: string;
     solveMessagesDismiss: string;
     solveSolving: string;
     parametersTab: string;
     moreTab: string;
-    expandPanel: string;
-    collapsePanel: string;
+    scrollTabsBack: string;
+    scrollTabsForward: string;
     /** `{side}` is replaced with `panelSideLeft` / `panelSideRight`. */
     expandSidePanel: string;
     panelSideLeft: string;
@@ -60,8 +69,147 @@ export interface ViewerMessages {
     pressToCalculate: string;
     calculate: string;
     upToDate: string;
+    /** The panel footer's ⋯ menu: saving and loading inputs, plus the host's own actions. */
+    moreActions: string;
+    /** Under a menu action that solves before it runs, while the inputs have changed. */
+    calculatesFirst: string;
+    /** `{count}` is replaced with the number of errors. */
+    errorCountOne: string;
+    errorCountOther: string;
+    /** `{count}` is replaced with the number of warnings. */
+    warningCountOne: string;
+    warningCountOther: string;
+    /** `{count}` is replaced with the number of notes. */
+    noteCountOne: string;
+    noteCountOther: string;
+    /** `{count}` is replaced with the number of messages. */
+    lastSolveMessagesOne: string;
+    lastSolveMessagesOther: string;
+    messagesTitle: string;
+    /** `{name}` is replaced with the copyright holder, `{year}` with the current year. */
+    copyright: string;
+    close: string;
+    toggleTheme: string;
+    errorTitle: string;
+    goHome: string;
+    selectOption: string;
+    noOptionsYet: string;
+    /** `{min}` is replaced with the field's minimum. */
+    minValue: string;
+    /** `{max}` is replaced with the field's maximum. */
+    maxValue: string;
+    fineDragHint: string;
+    /** `{max}` is replaced with the field's character limit. */
+    maxLength: string;
+    invalidFormat: string;
+    invalidPattern: string;
+    /** The pick button when the input takes several kinds of object. */
+    geometryPickAnyOne: string;
+    geometryPickAnyOther: string;
+    /** Shown while Rhino's viewport prompt for a pick is open. */
+    geometryPicking: string;
+    /** Where this page may not pick, such as a browser tab beside the Rhino panel. */
+    geometryPickInPanel: string;
+    geometryPickAgain: string;
+    geometryClear: string;
+    geometryPickPointOne: string;
+    geometryPickPointOther: string;
+    geometryPickPointCloudOne: string;
+    geometryPickPointCloudOther: string;
+    geometryPickCurveOne: string;
+    geometryPickCurveOther: string;
+    geometryPickLineOne: string;
+    geometryPickLineOther: string;
+    geometryPickPlaneOne: string;
+    geometryPickPlaneOther: string;
+    geometryPickSurfaceOne: string;
+    geometryPickSurfaceOther: string;
+    geometryPickPolysurfaceOne: string;
+    geometryPickPolysurfaceOther: string;
+    geometryPickExtrusionOne: string;
+    geometryPickExtrusionOther: string;
+    geometryPickMeshOne: string;
+    geometryPickMeshOther: string;
+    geometryPickSubdOne: string;
+    geometryPickSubdOther: string;
+    geometryPickBlockOne: string;
+    geometryPickBlockOther: string;
+    fileModeUpload: string;
+    fileModeUrl: string;
+    fileUrlLabel: string;
+    fetchFile: string;
+    fetchingFile: string;
+    fileUrlPublic: string;
+    chooseFile: string;
+    /** `{formats}` is replaced with the accepted extensions. */
+    acceptedFormats: string;
+    /** `{ext}` is replaced with the file's extension. */
+    uploadedFile: string;
+    /** `{ext}` is replaced with the file's extension, `{size}` with its size in MB. */
+    uploadedFileSize: string;
+    /** `{ext}` is replaced with the file's extension, `{size}` with its size in KB. */
+    fileLoaded: string;
+    urlInvalid: string;
+    urlProtocolUnsupported: string;
+    /** `{status}` is replaced with the HTTP status the server answered with. */
+    urlServerError: string;
+    /** `{ext}` is replaced with the rejected extension, `{formats}` with the accepted ones. */
+    fileFormatNotAccepted: string;
+    /** `{size}` is replaced with the file's size in MB, `{max}` with the limit in MB. */
+    fileTooLarge: string;
+    fileTooLargeUseUpload: string;
+    fileReadFailed: string;
+    /** `{host}` is replaced with the URL's host name. */
+    urlUnreachable: string;
+    urlUnreachableHint: string;
+    urlHintSharePoint: string;
+    urlHintGoogleDrive: string;
+    urlHintDropbox: string;
+    unknownError: string;
+    waitingForData: string;
+    waitingForFiles: string;
+    /** `{count}` is replaced with the number of files. */
+    fileCount: string;
+    duplicateFilesTitle: string;
+    duplicatePathsOne: string;
+    duplicatePathsOther: string;
+    duplicateFilesHint: string;
+    downloadFile: string;
+    /** `{count}` is replaced with the number of files. */
+    downloadFiles: string;
+    downloading: string;
+    downloadFailed: string;
+    copy: string;
+    copied: string;
+    chartReceiving: string;
+    chartRenderFailed: string;
+    /** `{error}` is replaced with the browser's reason. */
+    fullscreenUnavailable: string;
+    /** `{error}` is replaced with the browser's reason. */
+    exitFullscreenFailed: string;
+    imageViewer: string;
+    imageLoading: string;
+    /** `{ext}` is replaced with the file's extension, `{formats}` with the supported ones. */
+    imageUnsupported: string;
+    imageUnknownFormat: string;
+    /** `{file}` is replaced with the file's name. */
+    imageDecodeFailed: string;
+    previousImage: string;
+    nextImage: string;
+    zoomHint: string;
+    zoomIn: string;
+    zoomOut: string;
+    zoomFit: string;
+    zoomActual: string;
+    downloadImage: string;
 }
 export declare const VIEWER_MESSAGES: Record<Locale, ViewerMessages>;
 export declare const DEFAULT_LOCALE: Locale;
 /** Resolve a catalog for a locale, falling back to English for unknown locales. */
 export declare function messagesFor(locale: Locale | undefined): ViewerMessages;
+/** Layers a host's partial overrides over a full catalog. An `undefined` entry keeps the base string. */
+export declare function withOverrides(base: ViewerMessages, overrides: Partial<ViewerMessages> | undefined): ViewerMessages;
+/** Fills each `{name}` placeholder from `vars`; an unknown placeholder is left as written. */
+export declare function formatMessage(template: string, vars: Record<string, string | number>): string;
+/** Picks the singular or plural form for `count` and fills its `{count}`. */
+export declare function formatCount(count: number, one: string, other: string): string;