@lavalogic/scoria 0.20.0 → 0.21.0

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

@@ -2,7 +2,7 @@ import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
 import type { ToolbarPosition } from '../Toolbar/ToolbarPosition.js';
 export type Primitive = string | number;
 export interface TableInitOptions<T extends object, Identifier extends Primitive> {
-    selectionExtractor: (item: T) => Promise<Identifier>;
+    selectionExtractor: (item: T) => Identifier | Promise<Identifier>;
     allowCopy?: boolean;
     enableResize?: boolean;
     allowColumnReordering?: boolean;

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

@@ -1,4 +1,3 @@
-import { devCatch } from '../../../../Helpers/Helpers.svelte.js';
 import { Colour } from '../../../../scss/colours.js';
 import { Validity } from '../../../../Types/Internal/Validity.js';
 export class TableFocusDetails {
@@ -12,25 +11,9 @@ export class TableFocusDetails {
             column: this.cell.column.columnDef.index,
             id: this.cell.column.columnDef.id,
         });
-        $effect(() => {
-            void this.tableContext.focusedColumnIds;
-            void this.tableContext.focusedRowIndices;
-            (async () => {
-                this.isMultiFocused =
-                    (await this.tableContext.focusedColumnIds).has(this.cell.column.columnDef.id) &&
-                        (await this.tableContext.focusedRowIndices).has(this.cell.row.visibleIndex);
-            })().catch(devCatch);
-        });
-        $effect(() => {
-            void this.isMultiFocused;
-            void this.tableContext.focusedColumnIds;
-            void this.tableContext.focusedRowIndices;
-            (async () => {
-                this.hasMultipleFocus =
-                    (await this.tableContext.focusedColumnIds).size > 1 ||
-                        (await this.tableContext.focusedRowIndices).size > 1;
-            })().catch(devCatch);
-        });
+        this.isMultiFocused = $derived(this.tableContext.focusedColumnIds.has(this.cell.column.columnDef.id) &&
+            this.tableContext.focusedRowIndices.has(this.cell.row.visibleIndex));
+        this.hasMultipleFocus = $derived(this.tableContext.focusedColumnIds.size > 1 || this.tableContext.focusedRowIndices.size > 1);
         this.isMultiFocusStart = $derived.by(() => {
             void this.hasMultipleFocus;
             return (this.hasMultipleFocus &&
@@ -50,8 +33,8 @@ export class TableFocusDetails {
         });
     }
     coordinates;
-    isMultiFocused = $state(false);
-    hasMultipleFocus = $state(false);
+    isMultiFocused;
+    hasMultipleFocus;
     isMultiFocusStart;
     topToBottom;
     leftToRight;

package/dist/Helpers/Helpers.svelte.d.ts

@@ -38,14 +38,14 @@ export declare function isValidEmailAddress(emailAddress: string): RegExpMatchAr
 export declare function gridItem(element: HTMLElement): (() => void) | undefined;
 export type Milliseconds = number;
 export declare function asyncSleep(delay: Milliseconds): Promise<void>;
-export declare function asyncMap<T, R>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<R>): Promise<Awaited<R>[]>;
-export declare function asyncForEach<T>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<void>): Promise<void>;
-export declare function asyncFlatMap<T, R>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<R>): Promise<(Awaited<R> extends infer T_1 ? T_1 extends Awaited<R> ? T_1 extends readonly (infer InnerArr)[] ? InnerArr : T_1 : never : never)[]>;
-export declare function asyncSome<T>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<boolean>): Promise<boolean>;
-export declare function asyncAll<T>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<boolean>): Promise<boolean>;
+export declare function asyncMap<T, R>(array: Array<T>, callback: (item: T, index: number) => R | Promise<R>): Array<R> | Promise<Array<R>>;
+export declare function asyncForEach<T>(array: Array<T>, callback: (item: T, index: number) => void | Promise<void>): void | Promise<void>;
+export declare function asyncFlatMap<T, R>(array: Array<T>, callback: (item: T, index: number) => Array<R> | Promise<Array<R>>): Array<R> | Promise<Array<R>>;
+export declare function asyncSome<T>(array: Array<T>, callback: (item: T, index: number) => boolean | Promise<boolean>): boolean | Promise<boolean>;
+export declare function asyncAll<T>(array: Array<T>, callback: (item: T, index: number) => boolean | Promise<boolean>): boolean | Promise<boolean>;
 export declare const asyncEvery: typeof asyncAll;
-export declare function asyncFilterIndices<T>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<boolean>): Promise<Array<number>>;
-export declare function asyncFilter<T>(array: Array<T>, asyncCallback: (item: T, index: number) => Promise<boolean>): Promise<Array<T>>;
+export declare function asyncFilterIndices<T>(array: Array<T>, callback: (item: T, index: number) => boolean | Promise<boolean>): Array<number> | Promise<Array<number>>;
+export declare function asyncFilter<T>(array: Array<T>, callback: (item: T, index: number) => boolean | Promise<boolean>): Array<T> | Promise<Array<T>>;
 export declare function devCatch(e: unknown): void;
 export declare function hasQuery<FilterValueType>(customFilter: CustomFilter<FilterValueType> | undefined): customFilter is CustomFilter<FilterValueType> & Required<Pick<CustomFilter<FilterValueType>, 'query'>>;
 export declare function isDateTuple(value: unknown): value is [Date | null, Date | null];

package/dist/Helpers/Helpers.svelte.js

@@ -191,56 +191,137 @@ export async function asyncSleep(delay) {
         }, delay);
     }));
 }
-export async function asyncMap(array, asyncCallback) {
-    return Promise.all(array.map(asyncCallback));
+export function asyncMap(array, callback) {
+    const results = new Array(array.length);
+    const pending = [];
+    for (let i = array.length - 1; i > -1; i--) {
+        const r = callback(array[i], i);
+        if (r instanceof Promise) {
+            const idx = i;
+            pending.push(r.then((v) => {
+                results[idx] = v;
+            }));
+        }
+        else {
+            results[i] = r;
+        }
+    }
+    if (pending.length === 0) {
+        return results;
+    }
+    return Promise.all(pending).then(() => results);
 }
-export async function asyncForEach(array, asyncCallback) {
-    await Promise.all(array.map(asyncCallback));
+export function asyncForEach(array, callback) {
+    const pending = [];
+    for (let i = array.length - 1; i > -1; i--) {
+        const r = callback(array[i], i);
+        if (r !== undefined) {
+            pending.push(r);
+        }
+    }
+    if (pending.length === 0) {
+        return;
+    }
+    return Promise.all(pending).then(() => { });
 }
-export async function asyncFlatMap(array, asyncCallback) {
-    return (await Promise.all(array.map(asyncCallback))).flat();
+export function asyncFlatMap(array, callback) {
+    const results = new Array(array.length);
+    const pending = [];
+    for (let i = 0; i < array.length; i++) {
+        const r = callback(array[i], i);
+        if (r instanceof Promise) {
+            const idx = i;
+            pending.push(r.then((v) => {
+                results[idx] = v;
+            }));
+        }
+        else {
+            results[i] = r;
+        }
+    }
+    if (pending.length === 0) {
+        return results.flat();
+    }
+    return Promise.all(pending).then(() => results.flat());
 }
-const emptyPromise = new Promise(() => null);
-export async function asyncSome(array, asyncCallback) {
-    const promises = array.map(asyncCallback);
+export function asyncSome(array, callback) {
+    const asyncItems = [];
+    for (let i = array.length - 1; i > -1; i--) {
+        const r = callback(array[i], i);
+        if (r === true) {
+            return true;
+        }
+        if (r instanceof Promise) {
+            asyncItems.push({ index: i, promise: r });
+        }
+    }
+    if (asyncItems.length === 0) {
+        return false;
+    }
+    // Fall back to parallel race for async results
+    const emptyPromise = new Promise(() => { });
+    const promises = asyncItems.map((it) => it.promise);
     return Promise.race([
-        Promise.race(
-        // empty promise is required here
-        // because otherwise the first false would immediately end the race without checking the rest of the array
-        promises.map(async (p) => (await p) || emptyPromise)),
+        Promise.race(promises.map(async (p) => (await p) || emptyPromise)),
         Promise.all(promises).then((r) => r.some(Boolean)),
     ]);
 }
-export async function asyncAll(array, asyncCallback) {
-    const promises = array.map(asyncCallback);
-    return promises.length == 0
-        ? true
-        : Promise.race([
-            Promise.race(
-            // empty promise is required here
-            // because otherwise the first false would immediately end the race without checking the rest of the array
-            promises.map(async (p) => (await p) || emptyPromise)),
-            Promise.all(promises).then((r) => r.every(Boolean)),
-        ]);
+export function asyncAll(array, callback) {
+    if (array.length === 0) {
+        return true;
+    }
+    const asyncItems = [];
+    for (let i = array.length - 1; i > -1; i--) {
+        const r = callback(array[i], i);
+        if (r === false) {
+            return false;
+        } // sync short-circuit
+        if (r instanceof Promise) {
+            asyncItems.push({ index: i, promise: r });
+        }
+        // r === true: continue
+    }
+    if (asyncItems.length === 0) {
+        return true;
+    } // all sync and all true
+    // Fall back to parallel: short-circuit on first false
+    const emptyPromise = new Promise(() => { });
+    const promises = asyncItems.map((it) => it.promise);
+    return Promise.race([
+        // Return false as soon as any resolves to false
+        Promise.race(promises.map(async (p) => ((await p) ? emptyPromise : false))),
+        Promise.all(promises).then((r) => r.every(Boolean)),
+    ]);
 }
 export const asyncEvery = asyncAll;
-export async function asyncFilterIndices(array, asyncCallback) {
+export function asyncFilterIndices(array, callback) {
     const filtered = [];
-    await asyncForEach(array, async (item, index) => {
-        if (await asyncCallback(item, index)) {
-            filtered.push(index);
+    const pending = [];
+    for (let i = array.length - 1; i > -1; i--) {
+        const r = callback(array[i], i);
+        if (r === true) {
+            filtered.push(i);
         }
-    });
-    return filtered.sort((a, b) => a - b);
-}
-export async function asyncFilter(array, asyncCallback) {
-    const filtered = [];
-    await asyncForEach(array, async (item, index) => {
-        if (await asyncCallback(item, index)) {
-            filtered.push(index);
+        else if (r instanceof Promise) {
+            const idx = i;
+            pending.push(r.then((v) => {
+                if (v) {
+                    filtered.push(idx);
+                }
+            }));
         }
-    });
-    return filtered.sort((a, b) => a - b).map((i) => array[i]);
+    }
+    if (pending.length === 0) {
+        return filtered.sort((a, b) => a - b);
+    }
+    return Promise.all(pending).then(() => filtered.sort((a, b) => a - b));
+}
+export function asyncFilter(array, callback) {
+    const filtered = asyncFilterIndices(array, callback);
+    if (Array.isArray(filtered)) {
+        return filtered.sort((a, b) => a - b).map((i) => array[i]);
+    }
+    return filtered.then((f) => f.sort((a, b) => a - b).map((i) => array[i]));
 }
 export function devCatch(e) {
     if (dev) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lavalogic/scoria",
   "description": "Svelte components used for the FloWMS Web Frontend",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "publishConfig": {
     "access": "restricted"
   },
@@ -33,24 +33,24 @@
     "@eslint/compat": "^2.0.3",
     "@eslint/js": "^10.0.1",
     "@playwright/test": "^1.58.2",
-    "@storybook/addon-a11y": "^10.2.17",
-    "@storybook/addon-docs": "^10.2.17",
+    "@storybook/addon-a11y": "^10.2.19",
+    "@storybook/addon-docs": "^10.2.19",
     "@storybook/addon-svelte-csf": "^5.0.11",
-    "@storybook/addon-vitest": "^10.2.17",
-    "@storybook/sveltekit": "^10.2.17",
+    "@storybook/addon-vitest": "^10.2.19",
+    "@storybook/sveltekit": "^10.2.19",
     "@sveltejs/adapter-node": "^5.5.4",
-    "@sveltejs/kit": "^2.54.0",
+    "@sveltejs/kit": "^2.55.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@types/eslint": "^9.6.1",
-    "@types/node": "^25.4.0",
+    "@types/node": "^25.5.0",
     "@typescript-eslint/eslint-plugin": "^8.57.0",
     "@typescript-eslint/parser": "^8.57.0",
     "@vitest/browser": "^4.1.0",
     "@vitest/browser-playwright": "^4.1.0",
     "eslint": "^10.0.3",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-storybook": "^10.2.17",
+    "eslint-plugin-storybook": "^10.2.19",
     "eslint-plugin-svelte": "^3.15.2",
     "globals": "^17.4.0",
     "mdsvex": "^0.12.7",
@@ -59,8 +59,8 @@
     "prettier-plugin-svelte": "^3.5.1",
     "publint": "^0.3.18",
     "sass-embedded": "^1.98.0",
-    "storybook": "^10.2.17",
-    "svelte": "^5.53.11",
+    "storybook": "^10.2.19",
+    "svelte": "^5.53.12",
     "svelte-check": "^4.4.5",
     "svelte-render-scan": "^1.1.0",
     "typescript": "^5.9.3",
@@ -68,7 +68,7 @@
     "vite": "^7.3.1",
     "vite-plugin-devtools-json": "^1.0.0",
     "vitest": "^4.1.0",
-    "vitest-browser-svelte": "^2.0.2"
+    "vitest-browser-svelte": "^2.1.0"
   },
   "keywords": [
     "svelte"
@@ -86,8 +86,7 @@
     "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
-    "test:unit": "vitest",
-    "test": "npm run test:unit -- --run && npm run test:e2e",
+    "test": "vitest run --project server",
     "test:e2e": "playwright test",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build"