crelte 0.5.11 → 0.5.12

package/src/std/stores/StagedWritable.ts

@@ -0,0 +1,96 @@
+import { CloneableOrPrimitive } from '../index.js';
+import { Readable } from './index.js';
+import Writable from './Writable.js';
+
+export default class StagedWritable<T> {
+	private inner: Writable<T>;
+	// -1 = not staged, 0 = staged but no new value, 1 = staged
+	private mode: -1 | 0 | 1;
+	private staged: T | undefined;
+
+	/**
+	 * Creates a new StagedWritable
+	 *
+	 * @param def A default value
+	 */
+	constructor(def: T) {
+		this.inner = new Writable(def);
+		this.mode = -1;
+		this.staged = undefined;
+	}
+
+	/**
+	 * Returns true if the store is currently staged
+	 */
+	isStaged(): boolean {
+		return this.mode >= 0;
+	}
+
+	/**
+	 * Returns a new StagedWritable which is staged and has the same value as the current one
+	 * To commit the staged value, call `commit` on the returned StagedWritable
+	 */
+	stage(): StagedWritable<T> {
+		const n = Object.create(this);
+		n.inner = this.inner;
+		n.mode = 0;
+		n.staged = undefined;
+		return n;
+	}
+
+	/**
+	 * The function get's called once with the current value and then when the
+	 * values changes
+	 *
+	 * #### Note
+	 * This does not check for equality like svelte.
+	 *
+	 * @return a function which should be called to unsubscribe
+	 */
+	subscribe(fn: (val: T) => void, invalidate?: () => void): () => void {
+		return this.inner.subscribe(fn, invalidate);
+	}
+
+	/**
+	 * Either updates the store and calls all subscribers with the value or
+	 * updates the stateful value if previously toStateful was called
+	 */
+	set(inner: T) {
+		if (this.mode >= 0) {
+			this.mode = 1;
+			this.staged = inner;
+		} else {
+			this.inner.set(inner);
+		}
+	}
+
+	/**
+	 * If the value was staged, then update the store and call all subscribers with the value
+	 */
+	commit() {
+		if (this.mode < 0) throw new Error('not staged, call stage first');
+
+		if (this.mode === 1) this.inner.set(this.staged as T);
+
+		this.staged = undefined;
+		this.mode = -1;
+	}
+
+	/**
+	 * Get the current value either staged or not
+	 */
+	get(): T {
+		if (this.mode === 1) return this.staged as T;
+		return this.inner.get();
+	}
+
+	readonly(): Readable<T> {
+		return this.inner.readonly();
+	}
+
+	readclone<U extends T & CloneableOrPrimitive>(
+		this: StagedWritable<U>,
+	): Readable<U> {
+		return this.inner.readclone();
+	}
+}

package/src/std/stores/index.ts

@@ -1,5 +1,6 @@
 import Readable from './Readable.js';
 import Writable from './Writable.js';
 import Readclone from './Readclone.js';
+import StagedWritable from './StagedWritable.js';
 
-export { Writable, Readable, Readclone };
+export { Writable, Readable, Readclone, StagedWritable };

package/src/std/sync/Barrier.ts

@@ -83,7 +83,7 @@ export default class Barrier<T> {
 
 	private _maybeTrigger(): boolean {
 		const ready = this.listeners.every(v => v === null || v.ready);
-		// if all are ready
+		// if not all are ready
 		if (!ready) return false;
 
 		// send the last value to all of them

package/src/utils.ts

@@ -13,6 +13,21 @@ export function isPromise<T>(p: Promise<T> | T): p is Promise<T> {
 	return typeof (p as any)?.then === 'function';
 }
 
+/**
+ * A helper to chain promises without needing a microtask if its not a promise
+ * Equivalent to:
+ * ```
+ * const val = await p;
+ * then(val);
+ * ```
+ */
+export function promiseThen<T, R = void>(
+	p: Promise<T> | T,
+	then: (val: T) => R,
+): Promise<R> | R {
+	return isPromise(p) ? p.then(then) : then(p);
+}
+
 // the pathname is always replaced
 export function urlWithPath(url: string, path?: string): URL {
 	const u = new URL(url);