seitu 0.3.0 → 0.4.1

package/dist/core/computed.d.ts

@@ -0,0 +1,33 @@
+import type { Readable, Subscribable } from './subscription';
+export interface Computed<T> extends Readable<T>, Subscribable<T> {
+}
+type Source<T = unknown> = Readable<T> & Subscribable<T>;
+type SourceValues<S extends readonly Source[]> = {
+    [K in keyof S]: S[K] extends Source<infer V> ? V : never;
+};
+/**
+ * Creates a computed (derived) subscription from a subscription or an array of subscriptions.
+ * The computed value is updated whenever any subscription updates.
+ *
+ * @example
+ * ```ts twoslash
+ * import { createComputed, createStore } from 'seitu'
+ *
+ * const count = createStore({ a: 1, b: 2 })
+ * const sum = createComputed(count, s => s.a + s.b)
+ * sum.get() // 3
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { createComputed, createStore } from 'seitu'
+ *
+ * const a = createStore(1)
+ * const b = createStore(2)
+ * const sum = createComputed([a, b], ([a, b]) => a + b)
+ * sum.get() // 3
+ * ```
+ */
+export declare function createComputed<S extends readonly Source[], R>(sources: [...S], transform: (values: SourceValues<S>) => R): Computed<R>;
+export declare function createComputed<T, R>(source: Source<T>, transform: (value: T) => R): Computed<R>;
+export {};

package/dist/core/computed.test.d.ts

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

package/dist/core/index.d.ts

@@ -1,2 +1,4 @@
+export * from './computed';
 export * from './schema-store';
+export * from './store';
 export * from './subscription';

package/dist/core/schema-store.d.ts

@@ -1,11 +1,6 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { Simplify } from '../utils';
 import type { Readable, Subscribable, Writable } from './index';
-export interface SchemaStoreProvider<S extends SchemaStoreSchema> {
-    get: () => SchemaStoreOutput<S>;
-    set: (value: Partial<SchemaStoreOutput<S>>) => void;
-}
-export declare function createSchemaStoreMemoryProvider<S extends SchemaStoreSchema>(): SchemaStoreProvider<S>;
 export type SchemaStoreSchema = Record<string, StandardSchemaV1<unknown, unknown>>;
 export type SchemaStoreOutput<S extends SchemaStoreSchema> = Simplify<{
     [K in keyof S]: StandardSchemaV1.InferOutput<S[K]>;
@@ -16,6 +11,49 @@ export interface SchemaStore<O extends Record<string, unknown>> extends Subscrib
 export interface SchemaStoreOptions<S extends Record<string, StandardSchemaV1>> {
     schemas: S;
     defaultValues: SchemaStoreOutput<S>;
-    provider: SchemaStoreProvider<S>;
+    /**
+     * The provider to use for the schema store. If not provided, the schema store will
+     * use an in-memory provider.
+     */
+    provider?: SchemaStoreProvider<S>;
 }
+/**
+ * Creates a reactive schema store: state is validated on read, supports partial `set`, and
+ * falls back to default values when validation fails.
+ *
+ * @example
+ * ```ts twoslash
+ * import { createSchemaStore, createSchemaStoreMemoryProvider } from 'seitu'
+ * import * as z from 'zod'
+ *
+ * const store = createSchemaStore({
+ *   schemas: { count: z.number(), name: z.string() },
+ *   defaultValues: { count: 0, name: '' },
+ * })
+ * store.get()
+ * store.set({ count: 1 })
+ * store.subscribe(console.log)
+ * ```
+ */
 export declare function createSchemaStore<S extends Record<string, StandardSchemaV1>>(options: SchemaStoreOptions<S>): SchemaStore<SchemaStoreOutput<S>>;
+export interface SchemaStoreProvider<S extends SchemaStoreSchema> {
+    get: () => SchemaStoreOutput<S>;
+    set: (value: Partial<SchemaStoreOutput<S>>) => void;
+}
+/**
+ * Creates an in-memory provider for a schema store. Use as the state backing when you don't
+ * need persistence (e.g. for testing or ephemeral UI state).
+ *
+ * @example
+ * ```ts twoslash
+ * import { createSchemaStore, createSchemaStoreMemoryProvider } from 'seitu'
+ * import * as z from 'zod'
+ *
+ * const store = createSchemaStore({
+ *   schemas: { count: z.number(), name: z.string() },
+ *   defaultValues: { count: 0, name: '' },
+ *   provider: createSchemaStoreMemoryProvider(),
+ * })
+ * ```
+ */
+export declare function createSchemaStoreMemoryProvider<S extends SchemaStoreSchema>(): SchemaStoreProvider<S>;

package/dist/core/store.d.ts

@@ -0,0 +1,15 @@
+import type { Readable, Subscribable, Writable } from './subscription';
+export interface Store<T> extends Readable<T>, Writable<T, T>, Subscribable<T> {
+}
+/**
+ * Creates a simple reactive store (minimal TanStack Store–style API).
+ *
+ * - **Standalone**: use `get()`, `set(value | updater)`, `subscribe(callback)` for any state.
+ * - **With schema-store**: use as the state backing for a memory provider.
+ *
+ * @example
+ * const store = createStore({ count: 0 })
+ * store.set(prev => ({ ...prev, count: prev.count + 1 }))
+ * store.subscribe(state => console.log(state))
+ */
+export declare function createStore<T>(initial: T): Store<T>;

package/dist/core/store.test.d.ts

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

package/dist/core-iY5ySiQY.js

@@ -0,0 +1,88 @@
+function e() {
+	let e = new Set();
+	return {
+		subscribe(t) {
+			return e.add(t), () => {
+				e.delete(t);
+			};
+		},
+		notify(t) {
+			e.forEach((e) => e(t));
+		}
+	};
+}
+function t(t, n) {
+	let { subscribe: r, notify: i } = e(), a = Array.isArray(t) ? t : [t], o = !Array.isArray(t), s = () => n(o ? a[0].get() : a.map((e) => e.get()));
+	for (let e of a) e.subscribe(() => i());
+	return {
+		get: s,
+		subscribe(e) {
+			return r(() => e(s()));
+		},
+		"~": {
+			output: null,
+			notify: i
+		}
+	};
+}
+function n(e) {
+	if (typeof e != "string") return e;
+	try {
+		return JSON.parse(e);
+	} catch {
+		return e;
+	}
+}
+function r(t) {
+	let { subscribe: r, notify: a } = e(), o = { ...t.defaultValues }, s = t.provider ?? i(), c = () => {
+		let e = { ...o };
+		for (let [r, i] of Object.entries(t.schemas)) {
+			let t = s.get()[r], a = i["~standard"].validate(n(t));
+			if (a instanceof Promise) throw TypeError("[createStorage] Validation schema should not return a Promise.");
+			a.issues && console.warn(JSON.stringify(a.issues, null, 2), { cause: a.issues }), e[r] = a.issues ? o[r] : a.value;
+		}
+		return e;
+	};
+	return {
+		get: c,
+		set: (e) => {
+			let t = typeof e == "function" ? e(c()) : e;
+			s.set(t), a();
+		},
+		getDefaultValue: (e) => o[e],
+		subscribe: (e) => r(() => {
+			e(c());
+		}),
+		"~": {
+			output: null,
+			notify: a
+		}
+	};
+}
+function i() {
+	let e = a({});
+	return {
+		get: () => e.get(),
+		set: (t) => {
+			e.set(t);
+		}
+	};
+}
+function a(t) {
+	let n = t, { subscribe: r, notify: i } = e(), a = () => n;
+	return {
+		get: a,
+		set: (e) => {
+			let t = typeof e == "function" ? e(n) : e;
+			t !== n && (n = t, i());
+		},
+		subscribe(e) {
+			return r(() => e(a()));
+		},
+		"~": {
+			output: null,
+			notify: i
+		}
+	};
+}
+export { t as a, n as i, r as n, e as o, i as r, a as t };

package/dist/core.js

@@ -1,2 +1,2 @@
-import { n as e, r as t, t as n } from "./core-CO_rFBtK.js";
-export { e as createSchemaStore, t as createSchemaStoreMemoryProvider, n as createSubscription };
+import { a as e, n as t, o as n, r, t as i } from "./core-iY5ySiQY.js";
+export { e as createComputed, t as createSchemaStore, r as createSchemaStoreMemoryProvider, i as createStore, n as createSubscription };

package/dist/web.js

@@ -1,4 +1,4 @@
-import { i as e, n as t, t as n } from "./core-CO_rFBtK.js";
+import { i as e, n as t, o as n } from "./core-iY5ySiQY.js";
 function r(n) {
 	let { kind: r, ...i } = n, a = t({
 		...i,

package/package.json

@@ -2,7 +2,7 @@
   "name": "seitu",
   "displayName": "Seitu",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "private": false,
   "author": "Valerii Strilets",
   "license": "MIT",

package/dist/core-CO_rFBtK.js

@@ -1,58 +0,0 @@
-function e(e) {
-	if (typeof e != "string") return e;
-	try {
-		return JSON.parse(e);
-	} catch {
-		return e;
-	}
-}
-function t() {
-	let e = new Map();
-	return {
-		get: () => Object.fromEntries(e.entries()),
-		set: (t) => {
-			e.clear();
-			for (let [n, r] of Object.entries(t)) e.set(n, r);
-		}
-	};
-}
-function n(t) {
-	let { subscribe: n, notify: i } = r(), a = { ...t.defaultValues }, o = () => {
-		let n = { ...a };
-		for (let [r, i] of Object.entries(t.schemas)) {
-			let o = t.provider.get()[r], s = i["~standard"].validate(e(o));
-			if (s instanceof Promise) throw TypeError("[createStorage] Validation schema should not return a Promise.");
-			s.issues && console.warn(JSON.stringify(s.issues, null, 2), { cause: s.issues }), n[r] = s.issues ? a[r] : s.value;
-		}
-		return n;
-	};
-	return {
-		get: o,
-		set: (e) => {
-			let n = typeof e == "function" ? e(o()) : e;
-			t.provider.set(n), i();
-		},
-		getDefaultValue: (e) => a[e],
-		subscribe: (e) => n(() => {
-			e(o());
-		}),
-		"~": {
-			output: null,
-			notify: i
-		}
-	};
-}
-function r() {
-	let e = new Set();
-	return {
-		subscribe(t) {
-			return e.add(t), () => {
-				e.delete(t);
-			};
-		},
-		notify(t) {
-			e.forEach((e) => e(t));
-		}
-	};
-}
-export { e as i, n, t as r, r as t };