@virentia/effector 0.1.0

package/README.md

@@ -0,0 +1,61 @@
+# @virentia/effector
+
+Effector-shaped compatibility layer powered by `@virentia/core`.
+
+Use this package when existing code already has an Effector-style shape and you want to run it on Virentia primitives.
+
+## Links
+
+- Documentation: [movpushmov.dev/virentia/effector](https://movpushmov.dev/virentia/effector/)
+
+## Install
+
+```sh
+pnpm add @virentia/effector
+```
+
+## Counter
+
+```ts
+import { allSettled, createEvent, createStore, fork } from "@virentia/effector";
+
+const incremented = createEvent<number>();
+const $count = createStore(0).on(incremented, (count, amount) => count + amount);
+
+const appScope = fork();
+
+await allSettled(incremented, {
+  scope: appScope,
+  params: 2,
+});
+
+console.log(appScope.getState($count)); // 2
+```
+
+## Effects
+
+```ts
+const loadUserFx = createEffect<string, { id: string; name: string }>(async (id) => {
+  const response = await fetch(`/api/users/${id}`);
+  return response.json();
+});
+
+const result = await allSettled(loadUserFx, {
+  scope: appScope,
+  params: "user:1",
+});
+```
+
+Effects expose Effector-shaped lifecycle units: `done`, `fail`, `finally`, `doneData`, `failData`, `pending`, and `inFlight`.
+
+## Main API
+
+`createEvent`, `createStore`, `createEffect`, `sample`, `combine`, `split`, `createApi`, `restore`, `attach`, `fork`, `allSettled`, `serialize`, `hydrate`, `scopeBind`, `is`.
+
+## Notes
+
+The bridge keeps Effector-shaped names around Virentia core primitives. `fork` creates a Virentia scope. `allSettled` uses `params`, while core `allSettled` uses `payload`.
+
+## License
+
+MIT © 2026 movpushmov

package/dist/index.cjs

@@ -0,0 +1,537 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _virentia_core = require("@virentia/core");
+_virentia_core = __toESM(_virentia_core, 1);
+//#region lib/types.ts
+const unitKind = Symbol("virentia.effector.unit");
+//#endregion
+//#region lib/guards.ts
+const is = {
+	unit(value) {
+		return isUnit(value);
+	},
+	event(value) {
+		return isEvent(value);
+	},
+	store(value) {
+		return isStore(value);
+	},
+	effect(value) {
+		return isEffect(value);
+	},
+	targetable(value) {
+		return isTargetable(value);
+	}
+};
+function isUnit(value) {
+	return Boolean(value && (typeof value === "object" || typeof value === "function") && unitKind in value);
+}
+function isEvent(value) {
+	return isUnit(value) && value[unitKind] === "event";
+}
+function isStore(value) {
+	return isUnit(value) && value[unitKind] === "store";
+}
+function isEffect(value) {
+	return isUnit(value) && value[unitKind] === "effect";
+}
+function isTargetable(value) {
+	return isEvent(value) || isEffect(value) || isStore(value) && typeof value.setState === "function";
+}
+function isScope(value) {
+	return Boolean(value && typeof value === "object" && "__core" in value && !(unitKind in value));
+}
+function isScopeError(error) {
+	return error instanceof Error && error.message === "Scope is required";
+}
+//#endregion
+//#region lib/shared.ts
+const defaultScope = _virentia_core.scope();
+const compatScopes = /* @__PURE__ */ new WeakMap();
+const storesBySid = /* @__PURE__ */ new Map();
+const nativeStoreKeys = new Set([
+	"node",
+	"writable",
+	"subscribe",
+	"map",
+	"filter",
+	"filterMap"
+]);
+function createCompatScope(scope) {
+	const existing = compatScopes.get(scope);
+	if (existing) return existing;
+	const compatScope = {
+		__core: scope,
+		__changedSids: /* @__PURE__ */ new Set(),
+		getState(store) {
+			return store.getState(this);
+		}
+	};
+	compatScopes.set(scope, compatScope);
+	return compatScope;
+}
+function inScope(scope, fn) {
+	if (scope) return _virentia_core.scoped(scope.__core, fn);
+	try {
+		return fn();
+	} catch (error) {
+		if (!isScopeError(error)) throw error;
+		return _virentia_core.scoped(defaultScope, fn);
+	}
+}
+function callWithFallback(unit) {
+	return ((...args) => {
+		try {
+			return unit(...args).catch((error) => {
+				if (!isScopeError(error)) throw error;
+				return _virentia_core.scoped(defaultScope, () => unit(...args));
+			});
+		} catch (error) {
+			if (!isScopeError(error)) throw error;
+			return _virentia_core.scoped(defaultScope, () => unit(...args));
+		}
+	});
+}
+function readSource(source) {
+	if (isStore(source)) return source.getState();
+	if (Array.isArray(source)) return source.map((store) => store.getState());
+	return Object.fromEntries(Object.entries(source).map(([key, store]) => [key, store.getState()]));
+}
+function sourceToClock(source) {
+	if (!source) throw new Error("sample: clock or source is required");
+	if (isStore(source)) return source;
+	return Object.values(source);
+}
+function passesFilter(filter, source, clock) {
+	if (!filter) return true;
+	if (isStore(filter)) return filter.getState();
+	return filter(source, clock);
+}
+function launchTarget(target, payload) {
+	for (const unit of toArray(target)) if (isStore(unit)) unit.setState(payload);
+	else unit(payload);
+}
+function computeCombined(shape, fn) {
+	const value = readSource(shape);
+	return fn ? fn(value) : value;
+}
+function registerStore(store) {
+	if (store.sid) storesBySid.set(store.sid, store);
+}
+function markScopeChanged(scope, sid) {
+	if (sid) createCompatScope(scope ?? defaultScope).__changedSids.add(sid);
+}
+function applyStoreValues(scope, values) {
+	if (Array.isArray(values)) {
+		for (const [store, value] of values) store.setState(value, scope);
+		return;
+	}
+	if (values instanceof Map) {
+		for (const [store, value] of values) applyStoreValue(scope, store, value);
+		return;
+	}
+	for (const [sid, value] of Object.entries(values)) applyStoreValue(scope, sid, value);
+}
+function getName(input) {
+	if (typeof input === "string") return input;
+	if (input && (typeof input === "object" || typeof input === "function") && "shortName" in input) return String(input.shortName ?? "unit");
+	if (input && (typeof input === "object" || typeof input === "function") && "name" in input) return String(input.name ?? "unit");
+	return "unit";
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function applyStoreValue(scope, storeOrSid, value) {
+	if (typeof storeOrSid === "string") {
+		storesBySid.get(storeOrSid)?.setState(value, scope);
+		return;
+	}
+	storeOrSid.setState(value, scope);
+}
+//#endregion
+//#region lib/store.ts
+function createStore(defaultState, config) {
+	const box = _virentia_core.store({ value: defaultState });
+	const updates = createEvent({ name: `${config?.name ?? "store"} updates` });
+	const store = createStoreFromBox(box, updates, defaultState, config?.name, config?.sid);
+	registerStore(store);
+	box.subscribe((next, scope) => {
+		markScopeChanged(scope, store.sid);
+		_virentia_core.run({
+			unit: updates.__core.node,
+			payload: next.value,
+			scope
+		});
+	});
+	return store;
+}
+function createStoreFromBox(box, updates, defaultState, name = "store", sid) {
+	const result = {
+		[unitKind]: "store",
+		__box: box,
+		__core: updates,
+		node: updates.__core.node,
+		shortName: name,
+		sid,
+		defaultState,
+		updates,
+		getType: () => name,
+		getState(scope) {
+			return readBox(box, scope);
+		},
+		setState(value, scope) {
+			writeBox(box, value, scope);
+		},
+		watch(fn) {
+			fn(readBox(box));
+			return box.subscribe((next) => {
+				fn(next.value);
+			});
+		},
+		map(fn) {
+			const mapped = createStore(fn(result.getState()));
+			_virentia_core.scoped(defaultScope, () => {
+				_virentia_core.reaction(() => {
+					mapped.setState(fn(result.getState()));
+				});
+			});
+			return mapped;
+		},
+		on(trigger, reducer) {
+			_virentia_core.reaction({
+				on: trigger,
+				run: (payload) => {
+					result.setState(reducer(result.getState(), payload));
+				}
+			});
+			return result;
+		},
+		reset(trigger) {
+			for (const unit of toArray(trigger)) _virentia_core.reaction({
+				on: unit,
+				run: () => {
+					result.setState(defaultState);
+				}
+			});
+			return result;
+		}
+	};
+	return result;
+}
+function wrapNativeStore(store, defaultState, name) {
+	const updates = createEvent(`${name}.updates`);
+	const result = {
+		[unitKind]: "store",
+		__core: updates,
+		node: updates.__core.node,
+		shortName: name,
+		defaultState,
+		updates,
+		getType: () => name,
+		getState(scope) {
+			return readNativeStore(store, scope);
+		},
+		watch(fn) {
+			fn(readNativeStore(store));
+			return store.subscribe((next) => {
+				fn(next);
+			});
+		},
+		map(fn) {
+			const mapped = createStore(fn(result.getState()));
+			_virentia_core.scoped(defaultScope, () => {
+				_virentia_core.reaction(() => {
+					mapped.setState(fn(result.getState()));
+				});
+			});
+			return mapped;
+		},
+		on() {
+			throw new Error("Store is read-only");
+		},
+		reset() {
+			throw new Error("Store is read-only");
+		}
+	};
+	store.subscribe((next, scope) => {
+		_virentia_core.run({
+			unit: updates.__core.node,
+			payload: next,
+			scope
+		});
+	});
+	return result;
+}
+function readBox(box, scope) {
+	return inScope(scope, () => box.value);
+}
+function writeBox(box, value, scope) {
+	inScope(scope, () => {
+		box.value = value;
+	});
+}
+function readNativeStore(store, scope) {
+	return inScope(scope, () => {
+		const keys = Reflect.ownKeys(store).filter((key) => !nativeStoreKeys.has(key));
+		if (keys.length === 1 && keys[0] === "value") return Reflect.get(store, "value");
+		return Object.fromEntries(keys.map((key) => [key, Reflect.get(store, key)]));
+	});
+}
+//#endregion
+//#region lib/operators.ts
+function sample(config) {
+	const target = config.target ?? createEvent();
+	const clocks = toArray(config.clock ?? sourceToClock(config.source));
+	for (const clock of clocks) _virentia_core.reaction({
+		on: clock,
+		run: (clockPayload) => {
+			const sourceValue = config.source === void 0 ? void 0 : readSource(config.source);
+			if (!passesFilter(config.filter, sourceValue, clockPayload)) return;
+			launchTarget(target, config.fn ? config.source === void 0 ? config.fn(clockPayload, clockPayload) : config.fn(sourceValue, clockPayload) : config.source === void 0 ? clockPayload : sourceValue);
+		}
+	});
+	return Array.isArray(target) ? target[0] : target;
+}
+function combine(...args) {
+	const fn = typeof args[args.length - 1] === "function" ? args.pop() : void 0;
+	const shape = args.length === 1 ? args[0] : args;
+	const result = createStore(computeCombined(shape, fn));
+	_virentia_core.scoped(defaultScope, () => {
+		_virentia_core.reaction(() => {
+			result.setState(computeCombined(shape, fn));
+		});
+	});
+	return result;
+}
+function split(sourceOrConfig, maybeCases) {
+	const source = "source" in sourceOrConfig ? sourceOrConfig.source : sourceOrConfig;
+	const match = "source" in sourceOrConfig ? sourceOrConfig.match : maybeCases ?? {};
+	const result = {};
+	if (typeof match === "function") {
+		const configuredCases = "source" in sourceOrConfig ? sourceOrConfig.cases ?? {} : {};
+		for (const key of Object.keys(configuredCases)) result[key] = configuredCases[key] ?? createEvent();
+	} else for (const key of Object.keys(match)) result[key] = createEvent();
+	result.__ = createEvent();
+	_virentia_core.reaction({
+		on: source,
+		run: (payload) => {
+			launchTarget(result[(typeof match === "function" ? match(payload) : Object.keys(match).find((caseName) => match[caseName](payload))) ?? "__"] ?? result.__, payload);
+		}
+	});
+	return result;
+}
+function createApi(store, reducers) {
+	const result = {};
+	for (const key of Object.keys(reducers)) {
+		const event = createEvent(String(key));
+		store.on(event, reducers[key]);
+		result[key] = event;
+	}
+	return result;
+}
+function restore(unit, defaultState) {
+	const store = createStore(defaultState);
+	const source = isEffect(unit) ? unit.doneData : unit;
+	store.on(source, (_, payload) => payload);
+	return store;
+}
+//#endregion
+//#region lib/watch.ts
+function watchUnit(unit, fn) {
+	const subscription = _virentia_core.reaction({
+		on: unit,
+		run: fn
+	});
+	return () => subscription.stop();
+}
+//#endregion
+//#region lib/event.ts
+function createEvent(nameOrConfig) {
+	const name = typeof nameOrConfig === "string" ? nameOrConfig : nameOrConfig?.name ?? "unit";
+	return wrapEvent(_virentia_core.event(), name);
+}
+function wrapEvent(event, name = "event") {
+	const result = callWithFallback(typeof event === "function" ? event : ((...payload) => _virentia_core.allSettled(event, { payload: payload[0] })));
+	Object.assign(result, {
+		[unitKind]: "event",
+		__core: event,
+		node: event.node,
+		shortName: name,
+		getType: () => name,
+		watch(fn) {
+			return watchUnit(result, fn);
+		},
+		map(fn) {
+			return wrapEvent(event.map(fn));
+		},
+		filter(config) {
+			const fn = typeof config === "function" ? config : config.fn;
+			return wrapEvent(event.filter(fn));
+		},
+		filterMap(fn) {
+			return wrapEvent(event.filterMap(fn));
+		},
+		prepend(fn) {
+			const prepended = createEvent();
+			sample({
+				clock: prepended,
+				fn,
+				target: result
+			});
+			return prepended;
+		}
+	});
+	return result;
+}
+//#endregion
+//#region lib/effect.ts
+function createEffect(handlerOrConfig) {
+	let handler = typeof handlerOrConfig === "function" ? handlerOrConfig : handlerOrConfig?.handler;
+	const effectName = getName(handlerOrConfig);
+	const fx = _virentia_core.effect((params) => {
+		if (!handler) throw new Error("Effect handler is not defined");
+		return handler(params);
+	});
+	const result = callWithFallback(((...params) => fx(...params)));
+	Object.assign(result, {
+		[unitKind]: "effect",
+		__core: fx,
+		node: fx.node,
+		shortName: effectName,
+		getType: () => effectName,
+		watch(fn) {
+			return watchUnit(wrapEvent(fx.started), fn);
+		},
+		done: wrapEvent(fx.done),
+		fail: wrapEvent(fx.fail),
+		finally: wrapEvent(fx.finally),
+		doneData: wrapEvent(fx.doneData),
+		failData: wrapEvent(fx.failData),
+		pending: wrapNativeStore(fx.$pending, false, `${effectName}.pending`),
+		inFlight: wrapNativeStore(fx.$inFlight, 0, `${effectName}.inFlight`),
+		prepend(fn) {
+			const prepended = createEvent();
+			sample({
+				clock: prepended,
+				fn,
+				target: result
+			});
+			return prepended;
+		}
+	});
+	const use = ((nextHandler) => {
+		handler = nextHandler;
+		return result;
+	});
+	use.getCurrent = () => {
+		if (!handler) throw new Error("Effect handler is not defined");
+		return handler;
+	};
+	result.use = use;
+	return result;
+}
+//#endregion
+//#region lib/attach.ts
+function attach(config) {
+	return createEffect({
+		name: config.name ?? getName(config.effect),
+		handler: (params) => {
+			const hasSource = config.source !== void 0;
+			const sourceValue = hasSource ? readSource(config.source) : void 0;
+			if (isEffect(config.effect)) {
+				const nextParams = config.mapParams ? config.mapParams(params, sourceValue) : params;
+				return config.effect.use.getCurrent()(nextParams);
+			}
+			return hasSource ? config.effect(sourceValue, params) : config.effect(params);
+		}
+	});
+}
+//#endregion
+//#region lib/persistence.ts
+function serialize(scope, config = {}) {
+	const compatScope = createCompatScope(scope.__core);
+	const onlyChanges = config.onlyChanges ?? true;
+	const ignored = new Set((config.ignore ?? []).map((item) => typeof item === "string" ? item : item.sid).filter((sid) => typeof sid === "string"));
+	const result = {};
+	for (const [sid, store] of storesBySid) {
+		if (ignored.has(sid)) continue;
+		if (onlyChanges && !compatScope.__changedSids.has(sid)) continue;
+		result[sid] = store.getState(compatScope);
+	}
+	return result;
+}
+function hydrate(scope, config) {
+	applyStoreValues(scope, config.values);
+}
+//#endregion
+//#region lib/scope.ts
+function fork(config) {
+	const nextScope = createCompatScope(_virentia_core.scope());
+	if (config?.values) hydrate(nextScope, { values: config.values });
+	return nextScope;
+}
+async function allSettled(unitOrScope, options = {}) {
+	if (isScope(unitOrScope)) return;
+	const scope = options.scope ?? createCompatScope(defaultScope);
+	const unit = unitOrScope;
+	if (isStore(unit)) {
+		unit.setState(options.params, scope);
+		return;
+	}
+	if (isEffect(unit)) try {
+		return {
+			status: "done",
+			value: await _virentia_core.scoped(scope.__core, () => unit(options.params))
+		};
+	} catch (value) {
+		return {
+			status: "fail",
+			value
+		};
+	}
+	await _virentia_core.allSettled(unit.__core, {
+		scope: scope.__core,
+		payload: options.params
+	});
+}
+function scopeBind(unit, config) {
+	const scope = config?.scope ?? createCompatScope(defaultScope);
+	return (...payload) => _virentia_core.scoped(scope.__core, () => unit(...payload));
+}
+//#endregion
+exports.allSettled = allSettled;
+exports.attach = attach;
+exports.combine = combine;
+exports.createApi = createApi;
+exports.createEffect = createEffect;
+exports.createEvent = createEvent;
+exports.createStore = createStore;
+exports.fork = fork;
+exports.hydrate = hydrate;
+exports.is = is;
+exports.restore = restore;
+exports.sample = sample;
+exports.scopeBind = scopeBind;
+exports.serialize = serialize;
+exports.split = split;