@virentia/effector 0.1.0

package/dist/index.mjs

@@ -0,0 +1,499 @@
+import * as core from "@virentia/core";
+//#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 = 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 core.scoped(scope.__core, fn);
+	try {
+		return fn();
+	} catch (error) {
+		if (!isScopeError(error)) throw error;
+		return core.scoped(defaultScope, fn);
+	}
+}
+function callWithFallback(unit) {
+	return ((...args) => {
+		try {
+			return unit(...args).catch((error) => {
+				if (!isScopeError(error)) throw error;
+				return core.scoped(defaultScope, () => unit(...args));
+			});
+		} catch (error) {
+			if (!isScopeError(error)) throw error;
+			return 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 = 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);
+		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()));
+			core.scoped(defaultScope, () => {
+				core.reaction(() => {
+					mapped.setState(fn(result.getState()));
+				});
+			});
+			return mapped;
+		},
+		on(trigger, reducer) {
+			core.reaction({
+				on: trigger,
+				run: (payload) => {
+					result.setState(reducer(result.getState(), payload));
+				}
+			});
+			return result;
+		},
+		reset(trigger) {
+			for (const unit of toArray(trigger)) 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()));
+			core.scoped(defaultScope, () => {
+				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) => {
+		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) 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));
+	core.scoped(defaultScope, () => {
+		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();
+	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 = 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(core.event(), name);
+}
+function wrapEvent(event, name = "event") {
+	const result = callWithFallback(typeof event === "function" ? event : ((...payload) => 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 = 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(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 core.scoped(scope.__core, () => unit(options.params))
+		};
+	} catch (value) {
+		return {
+			status: "fail",
+			value
+		};
+	}
+	await core.allSettled(unit.__core, {
+		scope: scope.__core,
+		payload: options.params
+	});
+}
+function scopeBind(unit, config) {
+	const scope = config?.scope ?? createCompatScope(defaultScope);
+	return (...payload) => core.scoped(scope.__core, () => unit(...payload));
+}
+//#endregion
+export { allSettled, attach, combine, createApi, createEffect, createEvent, createStore, fork, hydrate, is, restore, sample, scopeBind, serialize, split };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@virentia/effector",
+  "version": "0.1.0",
+  "description": "Effector-compatible facade powered by @virentia/core",
+  "keywords": [],
+  "homepage": "https://movpushmov.dev/virentia/effector/",
+  "bugs": {
+    "url": "https://github.com/movpushmov/virentia/issues"
+  },
+  "license": "MIT",
+  "author": "movpushmov",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/movpushmov/virentia.git",
+    "directory": "packages/effector"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@virentia/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}