svas 0.1.9 → 1.1.0

package/dist/async/Async.svelte.d.ts

@@ -1,8 +1,15 @@
 import type { Props } from "./Async";
+declare function $$render<T>(): {
+    props: Props<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
 declare class __sveltets_Render<T> {
-    props(): Props<T>;
-    events(): {};
-    slots(): {};
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
     bindings(): "";
     exports(): {};
 }

package/dist/awaited.d.ts

@@ -0,0 +1,3 @@
+import type { Readable } from "svelte/store";
+import type { Maybe } from "./Maybe";
+export declare function awaited<T>(store: Readable<Maybe<T>>): Promise<T | Error>;

package/dist/awaited.js

@@ -0,0 +1,4 @@
+import { waitUntil } from "./waitUntil";
+export function awaited(store) {
+    return waitUntil(store, (value) => value !== null);
+}

package/dist/collection.d.ts

@@ -4,37 +4,29 @@ import type { GetOptions, Values } from './values';
 export declare class Collection<T extends Identifiable, E extends Error = Error> implements Readable<Maybe<T[], E>> {
     private readonly store;
     private readonly values?;
-    private readonly fetch;
-    private readonly map;
-    private readonly sort;
+    private readonly request;
     private readonly revalidate;
     private readonly stale;
     private timestamp;
     constructor(options: Options<T, E>);
     subscribe(run: Subscriber<Maybe<T[], E>>, invalidate?: () => void): Unsubscriber;
-    add<I = T>(item: Input<T, typeof this.map, I>): void;
+    add(item: T): void;
     get(id: string, options?: GetOptions): Readable<Maybe<T, E>>;
     extract(id: string): T | null;
     delete(id: string): void;
-    set<I = T>(item: Input<T, typeof this.map, I>, options?: SetOptions): Readable<T | E>;
-    preset<I = T>(item: Input<T, typeof this.map, I>): void;
-    reset(id: string): void;
+    set(item: T, options?: SetOptions): void;
     update(id: string, update: (item: T) => T | void, options?: SetOptions): void;
     sync(): this;
-    replace<I = T>(items: Array<Input<T, typeof this.map, I>>): void;
+    fetch(): Promise<this>;
+    replace(items: T[]): void;
     private refresh;
     private persist;
     private bind;
     private clear;
 }
-type Input<T, M, Default> = M extends (arg: infer P) => T ? P : Default;
 interface Options<T = unknown, E extends Error = Error> {
     /** Fetches the collection. */
-    get?: () => Promise<any[] | E>;
-    /** Maps the fetched item to the type of the collection. */
-    map?: (item: any) => T;
-    /** Sorting function applied on updates. */
-    sort?: (a: T, b: T) => number;
+    get?: () => Promise<T[] | E>;
     /** Time in milliseconds before revalidating the collection. Defaults to 300 seconds. */
     revalidate?: number;
     /** Whether to keep the collection while revalidating. Defaults to false. */
@@ -50,14 +42,8 @@ export interface Identifiable {
     id: string;
 }
 export interface SetOptions {
-    /** Whether to sort the collection after setting the item. Defaults to true. */
-    sort?: boolean;
     /** Whether to add the item to the collection if it does not exist. Defaults to false. */
     add?: boolean;
-    /** Whether value is transient. Defaults to false. */
-    stash?: boolean;
-    /** Whether to sync the collection values after setting the item. Defaults to true. */
-    sync?: boolean;
 }
 export declare function collection<T extends Identifiable, E extends Error = Error>(options: Options<T, E>): Collection<T, E>;
 export {};

package/dist/collection.js

@@ -1,47 +1,35 @@
 import { writable } from 'svelte/store';
-import { browser } from '$app/environment';
 export class Collection {
     store;
     values;
-    fetch;
-    map;
-    sort;
+    request;
     revalidate;
     stale;
     timestamp = 0;
     constructor(options) {
         this.store = writable(null);
         this.values = options.values;
-        this.fetch = options.get;
-        this.map = options.map;
-        this.sort = options.sort;
+        this.request = options.get;
         this.revalidate = options.revalidate ?? DEFAULTS.revalidate;
         this.stale = options.stale ?? DEFAULTS.stale;
-        if (browser) {
-            if (options.persist !== undefined)
-                this.persist(options.persist);
-            if (options.bind !== undefined)
-                this.bind(options.bind);
-        }
+        if (options.persist !== undefined)
+            this.persist(options.persist);
+        if (options.bind !== undefined)
+            this.bind(options.bind);
     }
     subscribe(run, invalidate) {
         this.sync();
         return this.store.subscribe(run, invalidate);
     }
     add(item) {
-        const value = this.map?.(item) ?? item;
-        this.values?.set(value.id, value);
+        this.values?.set(item.id, item);
         this.store.update((items) => {
             if (items === null || items instanceof Error)
-                return [value];
-            else {
-                if (items.find((item) => item.id === value.id) !== undefined)
-                    return items;
-                items.unshift(value);
-                if (this.sort !== undefined)
-                    items.sort(this.sort);
+                return [item];
+            else if (items.find((i) => i.id === item.id) !== undefined)
                 return items;
-            }
+            else
+                return [item, ...items];
         });
     }
     get(id, options) {
@@ -59,37 +47,20 @@ export class Collection {
         this.store.update((items) => {
             if (items === null || items instanceof Error)
                 return items;
-            return items.filter((item) => item.id !== id);
+            else
+                return items.filter((item) => item.id !== id);
         });
     }
     set(item, options) {
-        const value = this.map?.(item) ?? item;
         this.store.update((items) => {
             if (items === null || items instanceof Error)
                 return [item];
-            const index = items.findIndex((i) => i.id === value.id);
+            const index = items.findIndex((i) => i.id === item.id);
             if (index === -1)
-                return options?.add === true ? [value, ...items] : items;
-            items[index] = value;
-            if (this.sort !== undefined && options?.sort !== false)
-                items.sort(this.sort);
+                return options?.add === true ? [item, ...items] : items;
+            items[index] = item;
             return items;
         });
-        if (options?.sync === false)
-            return this.values?.get(value.id);
-        else
-            return this.values?.set(value.id, value, options);
-    }
-    preset(item) {
-        this.set(item, { stash: true });
-    }
-    reset(id) {
-        if (this.values === undefined)
-            throw new Error('Collection: values is not defined');
-        const value = this.values?.reset(id);
-        if (value === null || value instanceof Error)
-            return;
-        this.set(value, { sync: false });
     }
     update(id, update, options) {
         if (this.values === undefined)
@@ -105,30 +76,35 @@ export class Collection {
         if (stale) {
             if (!this.stale)
                 this.clear();
-            this.refresh();
+            void this.refresh();
         }
         return this;
     }
+    async fetch() {
+        await this.refresh();
+        return this;
+    }
     replace(items) {
-        const values = this.map === undefined ? items : items.map((item) => this.map(item));
+        const values = items;
         this.store.set(values);
         this.timestamp = Date.now();
         if (this.values !== undefined)
             for (const value of values)
                 this.values.set(value.id, value);
     }
-    refresh() {
-        if (this.fetch === undefined)
+    async refresh() {
+        if (this.request === undefined)
             return;
-        this.fetch().then((items) => {
-            if (!(items instanceof Error))
-                this.replace(items);
-            else
-                this.store.set(items);
-        });
+        const items = await this.request();
+        if (!(items instanceof Error))
+            this.replace(items);
+        else
+            this.store.set(items);
         this.timestamp = Date.now();
     }
     persist(key) {
+        if (typeof window === 'undefined')
+            return;
         const stored = localStorage.getItem(key);
         if (stored !== null) {
             const items = JSON.parse(stored);

package/dist/having.d.ts

@@ -1,7 +1,3 @@
 import type { Readable } from 'svelte/store';
 import type { Maybe } from './Maybe';
-/**
- * Execute a callback once the store has a non-null and non-error value.
- */
 export declare function having<T>(store: Readable<Maybe<T>>): Promise<T>;
-export declare function having<T>(store: Readable<Maybe<T>>, callback: (value: T) => unknown | Promise<unknown>): void;

package/dist/having.js

@@ -1,22 +1,4 @@
-export function having(store, callback) {
-    const promise = new Promise((resolve) => {
-        let completed = false;
-        let unsubscribe = null;
-        unsubscribe = store.subscribe((value) => {
-            if (value === null || value instanceof Error)
-                return;
-            // A
-            unsubscribe?.();
-            completed = true;
-            resolve(value);
-        });
-        // B
-        if (completed)
-            unsubscribe?.();
-        // the execution order of A and B is uncertain
-    });
-    if (callback === undefined)
-        return promise;
-    else
-        promise.then(callback);
+import { waitUntil } from './waitUntil';
+export function having(store) {
+    return waitUntil(store, (value) => value !== null && !(value instanceof Error));
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { collection, type Collection } from './collection';
 export { values, type Values } from './values';
 export { value } from './value';
+export { awaited } from './awaited';
 export { having } from './having';
 export { ensure } from './ensure';
 export { sync } from './sync';

package/dist/index.js

@@ -1,6 +1,7 @@
 export { collection } from './collection';
 export { values } from './values';
 export { value } from './value';
+export { awaited } from './awaited';
 export { having } from './having';
 export { ensure } from './ensure';
 export { sync } from './sync';

package/dist/sync.d.ts

@@ -1,6 +1,5 @@
 import type { Collection, Identifiable, SetOptions } from './collection';
-export declare function sync<T extends Comparable, I = T>(input: Input<T, Parameters<Collection<T>['add']>[0], I>, collection: Collection<T>, options?: Options): void;
-type Input<T, M, Default> = M extends (arg: infer P) => T ? P : Default;
+export declare function sync<T extends Comparable>(collection: Collection<T>, tobe: T, options?: Options): void;
 interface Comparable extends Identifiable {
     _version: number;
     _deleted?: number | null;

package/dist/sync.js

@@ -1,5 +1,4 @@
-export function sync(input, collection, options) {
-    const tobe = input;
+export function sync(collection, tobe, options) {
     if (tobe._deleted !== null && tobe._deleted !== undefined) {
         collection.delete(tobe.id);
         return;

package/dist/value.d.ts

@@ -1,11 +1,9 @@
 import { type Readable, type Subscriber, type Unsubscriber, type Updater, type Writable } from 'svelte/store';
-type Input<T, M, Default> = M extends (arg: infer P) => T ? P : Default;
 declare class Value<T> implements Writable<T | null> {
     private readonly store;
-    private readonly map?;
     private readonly default;
     constructor(options: Options<T>);
-    set<I = T>(value: Input<T, typeof this.map, I> | null): void;
+    set(value: T | null): void;
     update(updater: Updater<T | null>): void;
     subscribe(run: Subscriber<T | null>, invalidate?: () => void): Unsubscriber;
     extract(): T | null;
@@ -26,10 +24,6 @@ interface Options<T> {
      * Nullify values when the bound store is null.
      */
     bind?: Readable<unknown | null>;
-    /**
-     * Maps values on set.
-     */
-    map?: (item: any) => T;
     /**
      * Default value.
      */

package/dist/value.js

@@ -1,34 +1,22 @@
 import { get, writable } from 'svelte/store';
-import { browser } from '$app/environment';
 class Value {
     store;
-    map;
     default;
     constructor(options) {
-        const persist = browser && options.persist !== undefined;
         this.default = options.default ?? null;
-        this.store = persist
-            ? persistent(options.persist, this.default, options.session)
-            : writable(this.default);
-        if (browser) {
-            if (options.bind)
-                this.bind(options.bind);
-            if (options.map)
-                this.map = options.map;
-        }
+        this.store = options.persist === undefined || typeof window === 'undefined'
+            ? writable(this.default)
+            : persistent(options.persist, this.default, options.session);
+        if (options.bind)
+            this.bind(options.bind);
     }
     set(value) {
-        if (value !== null && this.map)
-            value = this.map(value);
         this.store.set(value);
     }
     update(updater) {
         this.store.update((value) => {
             const updated = updater(value);
-            if (this.map)
-                return this.map(updated);
-            else
-                return updated;
+            return updated;
         });
     }
     subscribe(run, invalidate) {

package/dist/values.d.ts

@@ -4,7 +4,6 @@ declare class Values<T, E extends Error = Error> {
     readonly persistent: boolean;
     private readonly values;
     private readonly fetch;
-    private readonly map;
     private readonly revalidate;
     private readonly permanent;
     private readonly stale;
@@ -12,7 +11,7 @@ declare class Values<T, E extends Error = Error> {
     private ready;
     private dumping;
     constructor(options: Options<T, E>);
-    set<I = T>(key: string, item: Input<T, typeof this.map, I> | E, options?: SetOptions): Readable<T | E>;
+    set(key: string, item: T | E, options?: SetOptions): Readable<T | E>;
     /**
      * Restores persistent value.
      */
@@ -27,16 +26,11 @@ declare class Values<T, E extends Error = Error> {
     private load;
     private bind;
 }
-type Input<T, M, Default> = M extends (arg: infer P) => T ? P : Default;
 interface Options<T = unknown, E extends Error = Error> {
     /**
      * Fetches the value
      */
-    get?: (key: string) => Promise<Exclude<any, Error> | E>;
-    /**
-     * Maps the fetched value
-     */
-    map?: (item: any) => T;
+    get?: (key: string) => Promise<T | E>;
     /**
      * Time in milliseconds before revalidating the value.
      * Default is 60 seconds.

package/dist/values.js

@@ -1,10 +1,8 @@
-import { browser } from '$app/environment';
 import { get, writable } from 'svelte/store';
 class Values {
     persistent;
     values = {};
     fetch;
-    map;
     revalidate;
     permanent;
     stale;
@@ -13,20 +11,17 @@ class Values {
     dumping = null;
     constructor(options) {
         this.fetch = options.get;
-        this.map = options.map;
         this.revalidate = options.revalidate ?? DEFAULTS.revalidate;
         this.permanent = options.permanent ?? DEFAULTS.permanent;
         this.stale = options.stale ?? DEFAULTS.stale;
         this.persist = options.persist;
         this.persistent = this.persist !== undefined;
-        if (browser) {
-            this.load();
-            if (options.bind !== undefined)
-                this.bind(options.bind);
-        }
+        this.load();
+        if (options.bind !== undefined)
+            this.bind(options.bind);
     }
     set(key, item, options) {
-        const value = this.map?.(item) ?? item;
+        const value = item;
         const entry = this.values[key] ?? (this.values[key] = this.create(value));
         if (options?.stash === true)
             this.stash(key);
@@ -100,7 +95,7 @@ class Values {
         entry.stash ??= get(store);
     }
     dump(delay = true) {
-        if (this.persist === undefined || !browser)
+        if (this.persist === undefined || typeof window === 'undefined')
             return;
         if (delay) {
             this.dumping ??= setTimeout(() => this.dump(false), DUMP_GAP);
@@ -120,7 +115,7 @@ class Values {
             localStorage.setItem(this.persist, JSON.stringify(data));
     }
     load() {
-        if (this.persist === undefined)
+        if (this.persist === undefined || typeof window === 'undefined')
             return;
         const data = localStorage.getItem(this.persist);
         if (data === null)

package/dist/waitUntil.d.ts

@@ -0,0 +1,2 @@
+import type { Readable } from "svelte/store";
+export declare function waitUntil<T>(store: Readable<T>, condition: (value: T) => boolean): Promise<T>;

package/dist/waitUntil.js

@@ -0,0 +1,16 @@
+export function waitUntil(store, condition) {
+    const promise = new Promise((resolve) => {
+        let completed = false;
+        let unsubscribe = null;
+        unsubscribe = store.subscribe((value) => {
+            if (!condition(value))
+                return;
+            unsubscribe?.();
+            completed = true;
+            resolve(value);
+        });
+        if (completed)
+            unsubscribe?.();
+    });
+    return promise;
+}

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "svas",
-	"version": "0.1.9",
+	"version": "1.1.0",
+	"repository": "https://github.com/temich/svas",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -9,16 +10,14 @@
 		"prepack": "svelte-kit sync && svelte-package && publint",
 		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
 		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-		"lint": "eslint ."
+		"lint": "eslint .",
+		"bump": "npx -y npm-check-updates --target minor -u"
 	},
 	"files": [
 		"dist",
 		"!dist/**/*.test.*",
 		"!dist/**/*.spec.*"
 	],
-	"sideEffects": [
-		"**/*.css"
-	],
 	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"type": "module",
@@ -30,27 +29,31 @@
 	},
 	"peerDependencies": {
 		"@lucide/svelte": "*",
-		"svelte": "^5.0.0",
-		"@sveltejs/kit": "*"
+		"@sveltejs/kit": "*",
+		"svelte": "^5.0.0"
 	},
 	"devDependencies": {
-		"@eslint/compat": "^1.2.9",
-		"@eslint/js": "^9.18.0",
-		"@sveltejs/adapter-auto": "^6.0.0",
-		"@sveltejs/kit": "^2.16.0",
-		"@sveltejs/package": "^2.0.0",
-		"@sveltejs/vite-plugin-svelte": "^5.0.0",
-		"autoprefixer": "^10.4.20",
-		"eslint": "^9.18.0",
-		"eslint-plugin-svelte": "^3.0.0",
-		"globals": "^16.0.0",
-		"publint": "^0.3.2",
-		"svelte": "^5.0.0",
-		"svelte-check": "^4.0.0",
-		"tailwindcss": "^3.4.17",
-		"typescript": "^5.0.0",
-		"typescript-eslint": "^8.20.0",
-		"vite": "^6.2.6"
+		"@eslint/compat": "^2.0.0",
+		"@eslint/js": "^9.39.1",
+		"@semantic-release/changelog": "^6.0.3",
+		"@semantic-release/commit-analyzer": "^13.0.1",
+		"@semantic-release/git": "^10.0.1",
+		"@semantic-release/github": "^12.0.2",
+		"@semantic-release/npm": "^13.1.2",
+		"@semantic-release/release-notes-generator": "^14.1.0",
+		"@sveltejs/adapter-auto": "^7.0.0",
+		"@sveltejs/kit": "^2.49.2",
+		"@sveltejs/package": "^2.5.7",
+		"@sveltejs/vite-plugin-svelte": "^6.2.1",
+		"eslint": "^9.39.1",
+		"eslint-plugin-svelte": "^3.13.1",
+		"globals": "^16.5.0",
+		"publint": "^0.3.15",
+		"svelte": "^5.45.8",
+		"svelte-check": "^4.3.4",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.49.0",
+		"vite": "^7.2.7"
 	},
 	"keywords": [
 		"svelte"