@lavalogic/scoria 0.37.50 → 0.37.52

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

@@ -711,14 +711,35 @@ export class FocusState {
      * the call-site signature clean for cell consumers.
      */
     getFocusDetailsFor(cell) {
-        let details = this._focusDetailsCache.get(cell);
-        if (!details) {
-            // The TableContext ref is supplied via a thunk to keep this
-            // sub-context decoupled from the parent.
-            const parent = this._deps.getTableContextRef();
-            details = new TableFocusDetails(cell, parent);
-            this._focusDetailsCache.set(cell, details);
-        }
-        return details;
+        const cached = this._focusDetailsCache.get(cell);
+        if (cached) {
+            return cached;
+        }
+        // The TableContext ref is supplied via a thunk to keep this
+        // sub-context decoupled from the parent.
+        const parent = this._deps.getTableContextRef();
+        // `TableFocusDetails` exposes its whole surface as `$derived` /
+        // `$derived.by` fields. This factory is invoked by cell components
+        // from inside a `$derived(...)` expression, so constructing the
+        // instance inline would bind those deriveds to whichever cell
+        // component first missed the cache. That component is destroyed on
+        // the next re-render / scroll, leaving the cached instance's
+        // deriveds owned by a dead scope - Svelte's `derived_inert` warning,
+        // and stale focus-outline values for every later reader. Building it
+        // inside an `$effect.root` gives the deriveds a standalone owner that
+        // outlives any single cell. The root is reachable only through the
+        // `WeakMap`-cached instance, so it is collected together with the
+        // cell and needs no explicit teardown.
+        let created;
+        $effect.root(() => {
+            created = new TableFocusDetails(cell, parent);
+        });
+        if (!created) {
+            // `$effect.root` runs its callback synchronously, so this is
+            // unreachable; it exists only to narrow the type below.
+            throw new Error('getFocusDetailsFor: TableFocusDetails was not constructed');
+        }
+        this._focusDetailsCache.set(cell, created);
+        return created;
     }
 }

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

@@ -9,6 +9,18 @@ import type { SortingState as SortingStateArray } from '../DataRepository/Sortin
  * pays no extra branching per comparison.
  */
 export declare function comparableSortingFn<T>(id: keyof T, desc: boolean): (a: T, b: T) => -1 | 0 | 1;
+/**
+ * Comparator factory for columns whose sort key comes from a value
+ * accessor rather than a row property. `DisplayDef` ids are synthetic, so
+ * the row carries no property under the column id — the accessor (the
+ * `col.display` `value` thunk) is the only available sort key.
+ *
+ * A Promise-returning accessor (an async `value` thunk) is not
+ * synchronously comparable, so such pairs compare equal — the column is a
+ * stable no-op unless the consumer supplies an explicit `getSortingFn`.
+ * Nullish results sort last in both directions.
+ */
+export declare function accessorSortingFn<T, V>(accessorFn: ((row: T, index: number) => V) | undefined, desc: boolean): (a: T, b: T) => -1 | 0 | 1;
 /**
  * Comparator factory for `CheckboxDef` columns. Boolean-coercion compares
  * truthy-vs-falsy so undefined / null / 0 collapse to "unchecked".

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

@@ -47,6 +47,39 @@ export function comparableSortingFn(id, desc) {
             return 0;
         };
 }
+/**
+ * Comparator factory for columns whose sort key comes from a value
+ * accessor rather than a row property. `DisplayDef` ids are synthetic, so
+ * the row carries no property under the column id — the accessor (the
+ * `col.display` `value` thunk) is the only available sort key.
+ *
+ * A Promise-returning accessor (an async `value` thunk) is not
+ * synchronously comparable, so such pairs compare equal — the column is a
+ * stable no-op unless the consumer supplies an explicit `getSortingFn`.
+ * Nullish results sort last in both directions.
+ */
+export function accessorSortingFn(accessorFn, desc) {
+    if (!accessorFn) {
+        return () => 0;
+    }
+    return (a, b) => {
+        const av = accessorFn(a, 0);
+        const bv = accessorFn(b, 0);
+        if (av == null && bv != null) {
+            return 1;
+        }
+        if (bv == null && av != null) {
+            return -1;
+        }
+        if (av < bv) {
+            return desc ? 1 : -1;
+        }
+        if (av > bv) {
+            return desc ? -1 : 1;
+        }
+        return 0;
+    };
+}
 /**
  * Comparator factory for `CheckboxDef` columns. Boolean-coercion compares
  * truthy-vs-falsy so undefined / null / 0 collapse to "unchecked".
@@ -175,8 +208,12 @@ export class SortingState {
         if (def.getSortingFn != undefined) {
             return def.getSortingFn(desc);
         }
-        if (def instanceof DisplayDef ||
-            def instanceof TextInputDef ||
+        if (def instanceof DisplayDef) {
+            // `DisplayDef` ids are synthetic — the row has no property under
+            // `id` — so sort by the column's value accessor, not `row[id]`.
+            return accessorSortingFn(def.accessorFn, desc);
+        }
+        if (def instanceof TextInputDef ||
             def instanceof NumberInputDef ||
             def instanceof DateInputDef) {
             return comparableSortingFn(id, desc);

package/package.json

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