@sigx/reactivity 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export type EffectFn = () => void;
+export interface ReactiveEffect extends EffectFn {
+    deps: Set<ReactiveEffect>[];
+}
+export declare function batch(fn: () => void): void;
+export type Signal<T> = T & {
+    $set: (newValue: T) => void;
+};
+export declare function detectAccess(selector: () => any): [any, string | symbol] | null;
+export declare function untrack<T>(fn: () => T): T;
+export declare function signal<T extends object>(target: T): Signal<T>;
+export declare function effect(fn: EffectFn): () => void;
+export type WatchSource<T = any> = T | (() => T);
+export type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: (fn: () => void) => void) => any;
+export interface WatchOptions<Immediate = boolean> {
+    immediate?: Immediate;
+    deep?: boolean | number;
+    once?: boolean;
+}
+export interface WatchHandle {
+    (): void;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+}
+export declare function watch<T>(source: WatchSource<T>, cb: WatchCallback<T>, options?: WatchOptions): WatchHandle;
+export type EffectScope = {
+    run<T>(fn: () => T): T | undefined;
+    stop(fromParent?: boolean): void;
+};
+export declare function effectScope(detached?: boolean): EffectScope;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC,MAAM,WAAW,cAAe,SAAQ,QAAQ;IAC5C,IAAI,EAAE,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC;CAC/B;AAMD,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,QAcnC;AA0CD,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG;IACxB,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,IAAI,CAAC;CAC/B,CAAC;AAIF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI,CAe/E;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzC;AAED,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CA2G7D;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,IAAI,CAE/C;AAaD,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AACjD,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,CAAC;AACpH,MAAM,WAAW,YAAY,CAAC,SAAS,GAAG,OAAO;IAC7C,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,IAAI,CAAC;IACT,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,IAAI,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,WAAW,CAgC1G;AAED,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IACnC,IAAI,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CACpC,CAAA;AAED,wBAAgB,WAAW,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,WAAW,CAc3D"}

package/dist/index.js

@@ -0,0 +1,202 @@
+//#region src/index.ts
+let activeEffect = null;
+let batchDepth = 0;
+const pendingEffects = /* @__PURE__ */ new Set();
+function batch(fn) {
+	batchDepth++;
+	try {
+		fn();
+	} finally {
+		batchDepth--;
+		if (batchDepth === 0) {
+			const effects = Array.from(pendingEffects);
+			pendingEffects.clear();
+			for (const effect$1 of effects) effect$1();
+		}
+	}
+}
+function runEffect(fn) {
+	const effect$1 = function() {
+		cleanup(effect$1);
+		activeEffect = effect$1;
+		fn();
+		activeEffect = null;
+	};
+	effect$1.deps = [];
+	effect$1();
+	return () => cleanup(effect$1);
+}
+function cleanup(effect$1) {
+	if (!effect$1.deps) return;
+	for (const dep of effect$1.deps) dep.delete(effect$1);
+	effect$1.deps.length = 0;
+}
+function track(depSet) {
+	if (!activeEffect) return;
+	depSet.add(activeEffect);
+	activeEffect.deps.push(depSet);
+}
+function trigger(depSet) {
+	const effects = Array.from(depSet);
+	for (const effect$1 of effects) if (batchDepth > 0) pendingEffects.add(effect$1);
+	else effect$1();
+}
+let accessObserver = null;
+function detectAccess(selector) {
+	let result = null;
+	const prev = accessObserver;
+	accessObserver = (target, key) => {
+		result = [target, key];
+	};
+	try {
+		selector();
+	} finally {
+		accessObserver = prev;
+	}
+	return result;
+}
+function untrack(fn) {
+	const prev = activeEffect;
+	activeEffect = null;
+	try {
+		return fn();
+	} finally {
+		activeEffect = prev;
+	}
+}
+function signal(target) {
+	const depsMap = /* @__PURE__ */ new Map();
+	const reactiveCache = /* @__PURE__ */ new WeakMap();
+	return new Proxy(target, {
+		get(obj, prop, receiver) {
+			if (prop === "$set") return (newValue) => {
+				batch(() => {
+					if (Array.isArray(obj) && Array.isArray(newValue)) {
+						const len = newValue.length;
+						for (let i = 0; i < len; i++) Reflect.set(receiver, String(i), newValue[i]);
+						Reflect.set(receiver, "length", len);
+					} else {
+						const newKeys = Object.keys(newValue);
+						const oldKeys = Object.keys(obj);
+						for (const key of newKeys) Reflect.set(receiver, key, newValue[key]);
+						for (const key of oldKeys) if (!(key in newValue)) Reflect.deleteProperty(receiver, key);
+					}
+				});
+			};
+			if (Array.isArray(obj) && typeof prop === "string" && arrayInstrumentations.hasOwnProperty(prop)) return arrayInstrumentations[prop];
+			const value = Reflect.get(obj, prop);
+			if (accessObserver) accessObserver(receiver, prop);
+			let dep = depsMap.get(prop);
+			if (!dep) {
+				dep = /* @__PURE__ */ new Set();
+				depsMap.set(prop, dep);
+			}
+			track(dep);
+			if (value && typeof value === "object") {
+				let cached = reactiveCache.get(value);
+				if (!cached) {
+					cached = signal(value);
+					reactiveCache.set(value, cached);
+				}
+				return cached;
+			}
+			return value;
+		},
+		set(obj, prop, newValue) {
+			const oldLength = Array.isArray(obj) ? obj.length : 0;
+			const oldValue = Reflect.get(obj, prop);
+			const result = Reflect.set(obj, prop, newValue);
+			if (!Object.is(oldValue, newValue)) {
+				const dep = depsMap.get(prop);
+				if (dep) trigger(dep);
+				if (Array.isArray(obj)) {
+					if (prop !== "length" && obj.length !== oldLength) {
+						const lengthDep = depsMap.get("length");
+						if (lengthDep) trigger(lengthDep);
+					}
+					if (prop === "length" && typeof newValue === "number" && newValue < oldLength) for (let i = newValue; i < oldLength; i++) {
+						const idxDep = depsMap.get(String(i));
+						if (idxDep) trigger(idxDep);
+					}
+				}
+			}
+			return result;
+		},
+		deleteProperty(obj, prop) {
+			const hasKey = Object.prototype.hasOwnProperty.call(obj, prop);
+			const result = Reflect.deleteProperty(obj, prop);
+			if (result && hasKey) {
+				const dep = depsMap.get(prop);
+				if (dep) trigger(dep);
+			}
+			return result;
+		}
+	});
+}
+function effect(fn) {
+	return runEffect(fn);
+}
+const arrayInstrumentations = {};
+[
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse"
+].forEach((method) => {
+	arrayInstrumentations[method] = function(...args) {
+		let res;
+		batch(() => {
+			res = Array.prototype[method].apply(this, args);
+		});
+		return res;
+	};
+});
+function watch(source, cb, options) {
+	let oldValue;
+	let isFirst = true;
+	let cleanupFn = null;
+	const runner = effect(() => {
+		const newValue = typeof source === "function" ? source() : source;
+		if (isFirst) {
+			if (options?.immediate) {
+				if (cleanupFn) cleanupFn();
+				cb(newValue, oldValue, (fn) => cleanupFn = fn);
+			}
+			isFirst = false;
+		} else {
+			if (cleanupFn) cleanupFn();
+			cb(newValue, oldValue, (fn) => cleanupFn = fn);
+		}
+		oldValue = newValue;
+	});
+	const stop = () => {
+		runner();
+		if (cleanupFn) cleanupFn();
+	};
+	const handle = stop;
+	handle.stop = stop;
+	handle.pause = () => {};
+	handle.resume = () => {};
+	return handle;
+}
+function effectScope(detached) {
+	const effects = [];
+	let active = true;
+	return {
+		run(fn) {
+			if (!active) return void 0;
+			return fn();
+		},
+		stop() {
+			active = false;
+			effects.forEach((e) => e());
+		}
+	};
+}
+
+//#endregion
+export { batch, detectAccess, effect, effectScope, signal, untrack, watch };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["activeEffect: ReactiveEffect | null","effect","effect: ReactiveEffect","accessObserver: ((target: any, key: string | symbol) => void) | null","result: [any, string | symbol] | null","arrayInstrumentations: Record<string, Function>","oldValue: T | undefined","cleanupFn: (() => void) | null","effects: (() => void)[]"],"sources":["../src/index.ts"],"sourcesContent":["// signals.ts\r\n\r\nexport type EffectFn = () => void;\r\n\r\nexport interface ReactiveEffect extends EffectFn {\r\n    deps: Set<ReactiveEffect>[];\r\n}\r\n\r\nlet activeEffect: ReactiveEffect | null = null;\r\nlet batchDepth = 0;\r\nconst pendingEffects = new Set<ReactiveEffect>();\r\n\r\nexport function batch(fn: () => void) {\r\n    batchDepth++;\r\n    try {\r\n        fn();\r\n    } finally {\r\n        batchDepth--;\r\n        if (batchDepth === 0) {\r\n            const effects = Array.from(pendingEffects);\r\n            pendingEffects.clear();\r\n            for (const effect of effects) {\r\n                effect();\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nfunction runEffect(fn: EffectFn): () => void {\r\n    const effect: ReactiveEffect = function () {\r\n        cleanup(effect);\r\n        activeEffect = effect;\r\n        fn();\r\n        activeEffect = null;\r\n    } as ReactiveEffect;\r\n\r\n    effect.deps = [];\r\n    effect();\r\n\r\n    // disposer\r\n    return () => cleanup(effect);\r\n}\r\n\r\nfunction cleanup(effect: ReactiveEffect): void {\r\n    if (!effect.deps) return;\r\n    for (const dep of effect.deps) {\r\n        dep.delete(effect);\r\n    }\r\n    effect.deps.length = 0;\r\n}\r\n\r\nfunction track(depSet: Set<ReactiveEffect>): void {\r\n    if (!activeEffect) return;\r\n    depSet.add(activeEffect);\r\n    activeEffect.deps.push(depSet);\r\n}\r\n\r\nfunction trigger(depSet: Set<ReactiveEffect>): void {\r\n    const effects = Array.from(depSet);\r\n    for (const effect of effects) {\r\n        if (batchDepth > 0) {\r\n            pendingEffects.add(effect);\r\n        } else {\r\n            effect();\r\n        }\r\n    }\r\n}\r\n\r\nexport type Signal<T> = T & {\r\n    $set: (newValue: T) => void;\r\n};\r\n\r\nlet accessObserver: ((target: any, key: string | symbol) => void) | null = null;\r\n\r\nexport function detectAccess(selector: () => any): [any, string | symbol] | null {\r\n    let result: [any, string | symbol] | null = null;\r\n    const prev = accessObserver;\r\n\r\n    accessObserver = (target, key) => {\r\n        result = [target, key];\r\n    };\r\n\r\n    try {\r\n        selector();\r\n    } finally {\r\n        accessObserver = prev;\r\n    }\r\n\r\n    return result;\r\n}\r\n\r\nexport function untrack<T>(fn: () => T): T {\r\n    const prev = activeEffect;\r\n    activeEffect = null;\r\n    try {\r\n        return fn();\r\n    } finally {\r\n        activeEffect = prev;\r\n    }\r\n}\r\n\r\nexport function signal<T extends object>(target: T): Signal<T> {\r\n    const depsMap = new Map<string | symbol, Set<ReactiveEffect>>();\r\n    const reactiveCache = new WeakMap<object, any>();\r\n\r\n    return new Proxy(target, {\r\n        get(obj, prop, receiver) {\r\n            if (prop === '$set') {\r\n                return (newValue: T) => {\r\n                    batch(() => {\r\n                        if (Array.isArray(obj) && Array.isArray(newValue)) {\r\n                            const len = newValue.length;\r\n                            for (let i = 0; i < len; i++) {\r\n                                Reflect.set(receiver, String(i), newValue[i]);\r\n                            }\r\n                            Reflect.set(receiver, 'length', len);\r\n                        } else {\r\n                            const newKeys = Object.keys(newValue);\r\n                            const oldKeys = Object.keys(obj);\r\n                            for (const key of newKeys) {\r\n                                Reflect.set(receiver, key, (newValue as any)[key]);\r\n                            }\r\n                            for (const key of oldKeys) {\r\n                                if (!(key in newValue)) {\r\n                                    Reflect.deleteProperty(receiver, key);\r\n                                }\r\n                            }\r\n                        }\r\n                    });\r\n                };\r\n            }\r\n\r\n            if (Array.isArray(obj) && typeof prop === 'string' && arrayInstrumentations.hasOwnProperty(prop)) {\r\n                return arrayInstrumentations[prop];\r\n            }\r\n\r\n            const value = Reflect.get(obj, prop);\r\n\r\n            if (accessObserver) {\r\n                accessObserver(receiver, prop);\r\n            }\r\n\r\n            // Track this property access\r\n            let dep = depsMap.get(prop);\r\n            if (!dep) {\r\n                dep = new Set<ReactiveEffect>();\r\n                depsMap.set(prop, dep);\r\n            }\r\n            track(dep);\r\n\r\n            // If the value is an object, make it reactive too (with caching)\r\n            if (value && typeof value === 'object') {\r\n                let cached = reactiveCache.get(value);\r\n                if (!cached) {\r\n                    cached = signal(value);\r\n                    reactiveCache.set(value, cached);\r\n                }\r\n                return cached;\r\n            }\r\n\r\n            return value;\r\n        },\r\n        set(obj, prop, newValue) {\r\n            const oldLength = Array.isArray(obj) ? obj.length : 0;\r\n            const oldValue = Reflect.get(obj, prop);\r\n            const result = Reflect.set(obj, prop, newValue);\r\n\r\n            // Only trigger if value actually changed\r\n            if (!Object.is(oldValue, newValue)) {\r\n                const dep = depsMap.get(prop);\r\n                if (dep) {\r\n                    trigger(dep);\r\n                }\r\n\r\n                // Special handling for Arrays\r\n                if (Array.isArray(obj)) {\r\n                    // If we set an index and length changed, trigger length dependency\r\n                    if (prop !== 'length' && obj.length !== oldLength) {\r\n                        const lengthDep = depsMap.get('length');\r\n                        if (lengthDep) {\r\n                            trigger(lengthDep);\r\n                        }\r\n                    }\r\n                    // If we set length, trigger indices that are now out of bounds\r\n                    if (prop === 'length' && typeof newValue === 'number' && newValue < oldLength) {\r\n                        for (let i = newValue; i < oldLength; i++) {\r\n                            const idxDep = depsMap.get(String(i));\r\n                            if (idxDep) trigger(idxDep);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return result;\r\n        },\r\n        deleteProperty(obj, prop) {\r\n            const hasKey = Object.prototype.hasOwnProperty.call(obj, prop);\r\n            const result = Reflect.deleteProperty(obj, prop);\r\n\r\n            if (result && hasKey) {\r\n                const dep = depsMap.get(prop);\r\n                if (dep) {\r\n                    trigger(dep);\r\n                }\r\n            }\r\n            return result;\r\n        }\r\n    }) as Signal<T>;\r\n}\r\n\r\nexport function effect(fn: EffectFn): () => void {\r\n    return runEffect(fn);\r\n}\r\n\r\nconst arrayInstrumentations: Record<string, Function> = {};\r\n['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(method => {\r\n    arrayInstrumentations[method] = function (this: any, ...args: any[]) {\r\n        let res;\r\n        batch(() => {\r\n            res = (Array.prototype as any)[method].apply(this, args);\r\n        });\r\n        return res;\r\n    };\r\n});\r\n\r\nexport type WatchSource<T = any> = T | (() => T);\r\nexport type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: (fn: () => void) => void) => any;\r\nexport interface WatchOptions<Immediate = boolean> {\r\n    immediate?: Immediate;\r\n    deep?: boolean | number;\r\n    once?: boolean;\r\n}\r\n\r\nexport interface WatchHandle {\r\n    (): void; // stop\r\n    pause: () => void;\r\n    resume: () => void;\r\n    stop: () => void;\r\n}\r\n\r\nexport function watch<T>(source: WatchSource<T>, cb: WatchCallback<T>, options?: WatchOptions): WatchHandle {\r\n    let oldValue: T | undefined;\r\n    let isFirst = true;\r\n    let cleanupFn: (() => void) | null = null;\r\n\r\n    const runner = effect(() => {\r\n        const newValue = typeof source === 'function' ? (source as () => T)() : source;\r\n\r\n        if (isFirst) {\r\n            if (options?.immediate) {\r\n                if (cleanupFn) cleanupFn();\r\n                cb(newValue, oldValue, (fn) => cleanupFn = fn);\r\n            }\r\n            isFirst = false;\r\n        } else {\r\n            if (cleanupFn) cleanupFn();\r\n            cb(newValue, oldValue, (fn) => cleanupFn = fn);\r\n        }\r\n        oldValue = newValue;\r\n    });\r\n\r\n    const stop = () => {\r\n        runner();\r\n        if (cleanupFn) cleanupFn();\r\n    };\r\n\r\n    const handle = stop as unknown as WatchHandle;\r\n    handle.stop = stop;\r\n    handle.pause = () => { }; // Not implemented\r\n    handle.resume = () => { }; // Not implemented\r\n\r\n    return handle;\r\n}\r\n\r\nexport type EffectScope = {\r\n    run<T>(fn: () => T): T | undefined;\r\n    stop(fromParent?: boolean): void;\r\n}\r\n\r\nexport function effectScope(detached?: boolean): EffectScope {\r\n    const effects: (() => void)[] = [];\r\n    let active = true;\r\n\r\n    return {\r\n        run<T>(fn: () => T): T | undefined {\r\n            if (!active) return undefined;\r\n            return fn();\r\n        },\r\n        stop() {\r\n            active = false;\r\n            effects.forEach(e => e());\r\n        }\r\n    };\r\n}\r\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@sigx/reactivity",
+    "version": "0.1.0",
+    "description": "Reactivity system for SignalX",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "rolldown -c && tsc --emitDeclarationOnly",
+        "dev": "rolldown -c -w"
+    },
+    "keywords": [
+        "sigx",
+        "reactivity",
+        "signals",
+        "reactive",
+        "state-management"
+    ],
+    "author": "Andreas Ekdahl",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/signalxjs/core.git",
+        "directory": "packages/reactivity"
+    },
+    "homepage": "https://github.com/signalxjs",
+    "bugs": {
+        "url": "https://github.com/signalxjs/core/issues"
+    },
+    "devDependencies": {
+        "rolldown": "^1.0.0-beta.52",
+        "typescript": "^5.9.3"
+    }
+}