svas 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# Svelte library
+
+Everything you need to build a Svelte library, powered by [`sv`](https://npmjs.com/package/sv).
+
+Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/Maybe.d.ts

@@ -0,0 +1,2 @@
+export type Maybe<T, E extends Error = Error> = null | T | E;
+export type Just<T extends Maybe<unknown>> = Exclude<T, null | Error>;

package/dist/Maybe.js

@@ -0,0 +1 @@
+export {};

package/dist/async/Async.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from 'svelte';
+import type { Readable } from 'svelte/store';
+export interface Props<T> {
+    store: Readable<T | null | Error>;
+    waiting?: Snippet;
+    awaited: Snippet<[T]>;
+    error?: Snippet<[Error]>;
+    silent?: boolean;
+    class?: string;
+}
+export { default as Async } from './Async.svelte';

package/dist/async/Async.js

@@ -0,0 +1 @@
+export { default as Async } from './Async.svelte';

package/dist/async/Async.svelte

@@ -0,0 +1,35 @@
+<script lang="ts" generics="T">
+  import { LoaderCircle } from "@lucide/svelte";
+  import type { Props } from "./Async";
+
+  const {
+    store,
+    waiting,
+    awaited,
+    error,
+    silent = false,
+    class: classes,
+  }: Props<T> = $props();
+</script>
+
+<div class={classes}>
+  {#if $store === null}
+    {#if waiting}
+      {@render waiting()}
+    {:else if !silent}
+      <div class="w-full h-full flex justify-center items-center">
+        <LoaderCircle class="animate-spin text-gray-400" />
+      </div>
+    {/if}
+  {:else if $store instanceof Error}
+    {#if error}
+      {@render error($store)}
+    {:else if !silent}
+      <div class="w-full h-full flex justify-center items-center">
+        Something went terribly wrong
+      </div>
+    {/if}
+  {:else}
+    {@render awaited($store)}
+  {/if}
+</div>

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

@@ -0,0 +1,18 @@
+import type { Props } from "./Async";
+declare class __sveltets_Render<T> {
+    props(): Props<T>;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Async: $$IsomorphicComponent;
+type Async<T> = InstanceType<typeof Async<T>>;
+export default Async;

package/dist/async/index.d.ts

@@ -0,0 +1 @@
+export { Async } from './Async';

package/dist/async/index.js

@@ -0,0 +1 @@
+export { Async } from './Async';

package/dist/collection.d.ts

@@ -0,0 +1,63 @@
+import { type Readable, type Subscriber, type Unsubscriber } from 'svelte/store';
+import type { Maybe } from './Maybe';
+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 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;
+    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;
+    update(id: string, update: (item: T) => T | void): void;
+    sync(): this;
+    replace<I = T>(items: Array<Input<T, typeof this.map, I>>): 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;
+    /** Time in milliseconds before revalidating the collection. */
+    revalidate?: number;
+    /** Whether to keep the collection while revalidating. */
+    stale?: boolean;
+    /** Values store. */
+    values?: Values<T, E>;
+    /** Key to persist the collection. */
+    persist?: string;
+    /** Nullifies the collection when the bound store is null. */
+    bind?: Readable<unknown | null>;
+}
+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 after setting the item. Defaults to true. */
+    bind?: boolean;
+}
+export declare function collection<T extends Identifiable, E extends Error = Error>(options: Options<T, E>): Collection<T, E>;
+export {};

package/dist/collection.js

@@ -0,0 +1,165 @@
+import { writable } from 'svelte/store';
+import { browser } from '$app/environment';
+export class Collection {
+    store;
+    values;
+    fetch;
+    map;
+    sort;
+    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.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);
+        }
+    }
+    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.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 items;
+            }
+        });
+    }
+    get(id, options) {
+        if (this.values === undefined)
+            throw new Error('Collection: values is not defined');
+        return this.values.get(id, options);
+    }
+    extract(id) {
+        if (this.values === undefined)
+            throw new Error('Collection: values is not defined');
+        return this.values.extract(id);
+    }
+    delete(id) {
+        this.values?.delete(id);
+        this.store.update((items) => {
+            if (items === null || items instanceof Error)
+                return items;
+            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);
+            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 items;
+        });
+        if (options?.bind === 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, { bind: false });
+    }
+    update(id, update) {
+        if (this.values === undefined)
+            throw new Error('Collection: values is not defined');
+        const asis = this.values.extract(id);
+        if (asis === null)
+            return;
+        const tobe = update(asis) ?? asis;
+        this.set(tobe);
+    }
+    sync() {
+        const stale = this.timestamp === 0 || this.timestamp + this.revalidate < Date.now();
+        if (stale) {
+            if (!this.stale)
+                this.clear();
+            this.refresh();
+        }
+        return this;
+    }
+    replace(items) {
+        const values = this.map === undefined ? items : items.map((item) => this.map(item));
+        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)
+            return;
+        this.fetch().then((items) => {
+            if (!(items instanceof Error))
+                this.replace(items);
+        });
+        this.timestamp = Date.now();
+    }
+    persist(key) {
+        const stored = localStorage.getItem(key);
+        if (stored !== null) {
+            const items = JSON.parse(stored);
+            this.store.set(items);
+            if (this.values?.persistent === false)
+                for (const item of items)
+                    this.values.set(item.id, item);
+        }
+        this.store.subscribe((items) => {
+            if (items instanceof Error)
+                return;
+            if (items === null)
+                localStorage.removeItem(key);
+            else
+                localStorage.setItem(key, JSON.stringify(items));
+        });
+    }
+    bind(store) {
+        store.subscribe((value) => {
+            if (value === null)
+                this.clear();
+        });
+    }
+    clear() {
+        this.store.set(null);
+        this.values?.clear();
+        this.timestamp = 0;
+    }
+}
+export function collection(options) {
+    return new Collection(options);
+}
+const DEFAULTS = {
+    revalidate: 300_000,
+    stale: false
+};

package/dist/combined.d.ts

@@ -0,0 +1,6 @@
+import { type Readable } from 'svelte/store';
+import type { Maybe } from './Maybe';
+export declare function combined<T extends Readable<unknown>[]>(...stores: T): Readable<Maybe<Values<T>>>;
+type Value<T> = T extends Readable<infer U | null | Error> ? U : never;
+type Values<T extends Readable<Maybe<unknown>>[]> = T extends [infer U, ...infer R] ? [Value<U>, ...Values<R extends Readable<unknown | null | Error>[] ? R : []>] : [];
+export {};

package/dist/combined.js

@@ -0,0 +1,24 @@
+import { readable } from 'svelte/store';
+export function combined(...stores) {
+    return readable(null, (set) => {
+        const values = new Array(stores.length).fill(null);
+        const unsubs = stores.map((store, index) => store.subscribe((value) => {
+            if (value instanceof Error) {
+                values[index] = null;
+                set(value);
+            }
+            else if (value === null) {
+                values[index] = value;
+                set(value);
+            }
+            else {
+                values[index] = value;
+                if (values.every((value) => value !== null))
+                    set(values);
+            }
+        }));
+        return () => {
+            unsubs.forEach((unsub) => unsub());
+        };
+    });
+}

package/dist/ensure.d.ts

@@ -0,0 +1,3 @@
+import type { Maybe } from './reflection/Maybe';
+import { type Readable } from 'svelte/store';
+export declare function ensure<T>(store: Readable<Maybe<T>>): T;

package/dist/ensure.js

@@ -0,0 +1,7 @@
+import { get } from 'svelte/store';
+export function ensure(store) {
+    const value = get(store);
+    if (value === null || value instanceof Error)
+        throw new Error('Store contains null or an error');
+    return value;
+}

package/dist/having.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,22 @@
+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);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { collection, type Collection } from './collection';
+export { values, type Values } from './values';
+export { value } from './value';
+export { having } from './having';
+export { ensure } from './ensure';
+export { sync } from './sync';
+export { combined } from './combined';
+export { ok } from './ok';
+export { Async } from './async';
+export type { Maybe } from './Maybe';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { collection } from './collection';
+export { values } from './values';
+export { value } from './value';
+export { having } from './having';
+export { ensure } from './ensure';
+export { sync } from './sync';
+export { combined } from './combined';
+export { ok } from './ok';
+export { Async } from './async';

package/dist/ok.d.ts

@@ -0,0 +1 @@
+export declare function ok<T>(value: T): value is Exclude<T, null | Error>;

package/dist/ok.js

@@ -0,0 +1,3 @@
+export function ok(value) {
+    return value !== null && !(value instanceof Error);
+}

package/dist/sync.d.ts

@@ -0,0 +1,9 @@
+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;
+interface Comparable extends Identifiable {
+    _version: number;
+    _deleted?: number | null;
+}
+type Options = SetOptions;
+export {};

package/dist/sync.js

@@ -0,0 +1,14 @@
+export function sync(input, collection, options) {
+    const tobe = input;
+    if (tobe._deleted !== null && tobe._deleted !== undefined) {
+        collection.delete(tobe.id);
+        return;
+    }
+    const asis = collection.extract(tobe.id);
+    if (asis === null)
+        collection.add(tobe);
+    else if (asis._version < tobe._version)
+        collection.set(tobe, { add: true, ...options });
+    else
+        console.debug('Sync skipped', tobe);
+}

package/dist/value.d.ts

@@ -0,0 +1,36 @@
+import { type Readable, type Subscriber, type Unsubscriber, type Updater, type Writable } from 'svelte/store';
+declare class Value<T> implements Writable<T | null> {
+    private readonly store;
+    private readonly map?;
+    constructor(options: Options<T>);
+    set(value: T | null): void;
+    update(updater: Updater<T | null>): void;
+    subscribe(run: Subscriber<T | null>, invalidate?: () => void): Unsubscriber;
+    extract(): T | null;
+    private bind;
+}
+export declare function value<T>(options?: Options<T>): Value<T>;
+interface Options<T> {
+    /**
+     * Key to persist the collection.
+     */
+    persist?: string;
+    /**
+     * Persist the collection in the session storage.
+     * If `persist` is not set, `session` is ignored.
+     */
+    session?: boolean;
+    /**
+     * Nullify values when the bound store is null.
+     */
+    bind?: Readable<unknown | null>;
+    /**
+     * Maps values on set.
+     */
+    map?: (item: T) => T;
+    /**
+     * Default value.
+     */
+    default?: T;
+}
+export {};

package/dist/value.js

@@ -0,0 +1,57 @@
+import { get, writable } from 'svelte/store';
+import { browser } from '$app/environment';
+class Value {
+    store;
+    map;
+    constructor(options) {
+        const persist = browser && options.persist !== undefined;
+        const def = options.default ?? null;
+        this.store = persist
+            ? persistent(options.persist, def, options.session)
+            : writable(def);
+        if (browser) {
+            if (options.bind)
+                this.bind(options.bind);
+            if (options.map)
+                this.map = options.map;
+        }
+    }
+    set(value) {
+        if (value !== null && this.map)
+            value = this.map(value);
+        this.store.set(value);
+    }
+    update(updater) {
+        this.store.update(updater);
+    }
+    subscribe(run, invalidate) {
+        return this.store.subscribe(run, invalidate);
+    }
+    extract() {
+        return get(this.store);
+    }
+    bind(store) {
+        store.subscribe((value) => {
+            if (value === null)
+                this.store.set(null);
+        });
+    }
+}
+export function value(options = {}) {
+    return new Value(options);
+}
+function persistent(key, def, session) {
+    const store = writable(load(key) ?? def);
+    const type = session ? 'sessionStorage' : 'localStorage';
+    store.subscribe((value) => {
+        if (value === null)
+            window[type].removeItem(key);
+        else
+            window[type].setItem(key, JSON.stringify(value));
+    });
+    return store;
+}
+function load(key) {
+    const json = window.localStorage.getItem(key);
+    return json === null ? null : JSON.parse(json);
+}

package/dist/values.d.ts

@@ -0,0 +1,79 @@
+import { type Readable } from 'svelte/store';
+import type { Maybe } from './Maybe';
+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;
+    private readonly persist?;
+    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>;
+    /**
+     * Restores persistent value.
+     */
+    reset(key: string): Maybe<T | E>;
+    get(key: string, options?: GetOptions): Readable<Maybe<T, E>>;
+    extract(key: string): T | null;
+    delete(key: string): void;
+    clear(): void;
+    private create;
+    private stash;
+    private dump;
+    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;
+    /**
+     * Time in milliseconds before revalidating the value.
+     * Default is 60 seconds.
+     */
+    revalidate?: number;
+    /**
+     * Whether to keep the values while revalidating.
+     * Default is false.
+     */
+    stale?: boolean;
+    /**
+     * Key to persist values.
+     */
+    persist?: string;
+    /**
+     * Do not refresh persistent values on application restart.
+     * Default is false.
+     *
+     * { permanent: true, revalidate: Infinity } prevents revalidation entirely.
+     */
+    permanent?: boolean;
+    /**
+     * Nullify values when the bound store is null.
+     */
+    bind?: Readable<unknown | null>;
+}
+export interface GetOptions {
+    /**
+     * Whether to fetch the value if it's not in the store. Defaults to true.
+     */
+    fetch?: boolean;
+}
+export interface SetOptions {
+    /**
+     * Whether value is transient. Defaults to false.
+     */
+    stash?: boolean;
+}
+declare function values<T, E extends Error = Error>(options?: Options<T, E>): Values<T, E>;
+export { values, type Values };

package/dist/values.js

@@ -0,0 +1,148 @@
+import { browser } from '$app/environment';
+import { get, writable } from 'svelte/store';
+class Values {
+    persistent;
+    values = {};
+    fetch;
+    map;
+    revalidate;
+    permanent;
+    stale;
+    persist;
+    ready = false;
+    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);
+        }
+    }
+    set(key, item, options) {
+        const value = this.map?.(item) ?? item;
+        const entry = this.values[key] ?? (this.values[key] = this.create(value));
+        if (options?.stash === true)
+            this.stash(key);
+        else
+            delete entry.stash;
+        entry.store.set(value);
+        if (!(value instanceof Error) && this.ready && options?.stash !== true)
+            this.dump();
+        return this.values[key].store;
+    }
+    /**
+     * Restores persistent value.
+     */
+    reset(key) {
+        const stash = this.values[key]?.stash;
+        if (stash === undefined)
+            return this.extract(key);
+        if (stash === null)
+            this.delete(key);
+        else
+            this.set(key, stash);
+        return stash;
+    }
+    get(key, options) {
+        this.ready = true;
+        const value = (this.values[key] ??= this.create());
+        if (this.fetch === undefined || options?.fetch === false)
+            return value.store;
+        const stale = value.timestamp === 0 || value.timestamp + this.revalidate < Date.now();
+        if (stale) {
+            if (!this.stale)
+                value.store.set(null);
+            value.timestamp = Date.now();
+            this.fetch(key).then((data) => this.set(key, data));
+        }
+        return value.store;
+    }
+    extract(key) {
+        if (this.values[key] === undefined)
+            return null;
+        const value = get(this.values[key].store);
+        return value instanceof Error ? null : value;
+    }
+    delete(key) {
+        if (!(key in this.values))
+            return;
+        const value = this.values[key];
+        value.store.set(null);
+        value.timestamp = 0;
+        delete value.stash;
+        this.dump();
+    }
+    clear() {
+        for (const key of Object.keys(this.values))
+            this.delete(key);
+        this.ready = false;
+    }
+    create(value) {
+        return {
+            store: writable(value ?? null),
+            timestamp: this.permanent && value !== undefined ? Date.now() : 0
+        };
+    }
+    stash(key) {
+        const entry = this.values[key];
+        if (entry.stash !== undefined) {
+            console.warn('Stash overlap, skipping');
+            return;
+        }
+        const store = this.get(key, { fetch: false });
+        entry.stash ??= get(store);
+    }
+    dump(delay = true) {
+        if (this.persist === undefined || !browser)
+            return;
+        if (delay) {
+            this.dumping ??= setTimeout(() => this.dump(false), DUMP_GAP);
+            return;
+        }
+        else
+            this.dumping = null;
+        const data = {};
+        for (const [key, value] of Object.entries(this.values)) {
+            const state = value.stash ?? get(value.store);
+            if (state !== null && !(state instanceof Error))
+                data[key] = state;
+        }
+        if (Object.keys(data).length === 0)
+            localStorage.removeItem(this.persist);
+        else
+            localStorage.setItem(this.persist, JSON.stringify(data));
+    }
+    load() {
+        if (this.persist === undefined)
+            return;
+        const data = localStorage.getItem(this.persist);
+        if (data === null)
+            return;
+        const values = JSON.parse(data);
+        for (const [key, value] of Object.entries(values))
+            this.set(key, value);
+    }
+    bind(store) {
+        store.subscribe((value) => {
+            if (value === null)
+                this.clear();
+        });
+    }
+}
+const DUMP_GAP = 100; // should not be 0 to prevent unnecessary disk writes
+const DEFAULTS = {
+    revalidate: 300_000,
+    permanent: false,
+    stale: false
+};
+function values(options = {}) {
+    return new Values(options);
+}
+export { values };

package/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "svas",
+	"version": "0.0.1",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run prepack",
+		"preview": "vite preview",
+		"prepare": "svelte-kit sync || echo ''",
+		"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 ."
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"sideEffects": [
+		"**/*.css"
+	],
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"peerDependencies": {
+		"@lucide/svelte": "^0.510.0",
+		"svelte": "^5.0.0"
+	},
+	"devDependencies": {
+		"@eslint/compat": "^1.2.5",
+		"@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"
+	},
+	"keywords": [
+		"svelte"
+	]
+}