eliminate closures

packages/svelte/src/internal/client/magic.js

@@ -1,61 +1,48 @@
 import { effect_active, get, set, increment, source } from './runtime.js';
 
+/** @typedef {{ p: MagicObject | null; s: Map<string | symbol, import('./types').SourceSignal<any>>; v: import('./types').SourceSignal<number>; a: boolean }} Magic */
+/** @typedef {Record<string | symbol, any> & { [MAGIC_SYMBOL]: Magic }} MagicObject */
+
 export const MAGIC_SYMBOL = Symbol();
 export const MAGIC_EACH_SYMBOL = Symbol();
 
 /**
- * @template T
+ * @template {MagicObject} T
  * @param {T} value
  * @returns {T}
  */
 export function magic(value) {
-	if (value && typeof value === 'object') {
 	return wrap(value, null);
 }
 
-	return value;
-}
-
 /**
- * @template T
+ * @template {MagicObject} T
+ * @template {MagicObject} P
  * @param {T} value
- * @param {T | null} parent
+ * @param {P | null} parent
  * @returns {T}
  */
 function wrap(value, parent) {
 	if (value && typeof value === 'object') {
-		return object(value, parent);
+		return proxy(value, parent);
 	}
 
 	return value;
 }
 
-/**
- * @template {Record<string | symbol, any>} T
- * @template P
- * @param {T} value
- * @param {P | null} parent
- * @returns {T}
- */
-function object(value, parent) {
-	if (MAGIC_SYMBOL in value) return value;
-
-	/** @type {Map<string | symbol, any>} */
-	const sources = new Map();
-	let version = source(0);
-
-	const is_array = Array.isArray(value);
-
-	return new Proxy(value, {
+/** @type {ProxyHandler<MagicObject>} */
+const handler = {
 	get(target, prop, receiver) {
 		if (prop === MAGIC_EACH_SYMBOL) {
 			return parent;
 		}
-			let s = sources.get(prop);
+
+		const metadata = target[MAGIC_SYMBOL];
+		let s = metadata.s.get(prop);
 
 		if (s === undefined && effect_active()) {
 			s = source(wrap(target[prop], receiver));
-				sources.set(prop, s);
+			metadata.s.set(prop, s);
 		}
 
 		const value = s !== undefined ? get(s) : target[prop];
@@ -69,39 +56,77 @@ function object(value, parent) {
 		return value;
 	},
 	set(target, prop, value) {
-			const s = sources.get(prop);
+		const metadata = target[MAGIC_SYMBOL];
+
+		const s = metadata.s.get(prop);
 		if (s !== undefined) set(s, wrap(value, target));
 
-			if (is_array && prop === 'length') {
+		if (metadata.a && prop === 'length') {
 			for (let i = value; i < target.length; i += 1) {
-					const s = sources.get(i + '');
+				const s = metadata.s.get(i + '');
 				if (s !== undefined) set(s, undefined);
 			}
 		}
 
-			if (!(prop in target)) increment(version);
+		if (!(prop in target)) increment(metadata.v);
 		// @ts-ignore
 		target[prop] = value;
 
 		return true;
 	},
 	deleteProperty(target, prop) {
-			const s = sources.get(prop);
+		const metadata = target[MAGIC_SYMBOL];
+
+		const s = metadata.s.get(prop);
 		if (s !== undefined) set(s, undefined);
 
-			if (prop in target) increment(version);
+		if (prop in target) increment(metadata.v);
 
 		return delete target[prop];
 	},
 	has(target, prop) {
 		if (prop === MAGIC_SYMBOL) return true;
 
-			get(version);
+		const metadata = target[MAGIC_SYMBOL];
+
+		get(metadata.v);
 		return Reflect.has(target, prop);
 	},
 	ownKeys(target) {
-			get(version);
+		const metadata = target[MAGIC_SYMBOL];
+
+		get(metadata.v);
 		return Reflect.ownKeys(target);
 	}
-	});
+};
+
+/**
+ * @template {MagicObject} T
+ * @template {MagicObject} P
+ * @param {T} value
+ * @param {P | null} parent
+ * @returns {T}
+ */
+function proxy(value, parent) {
+	if (MAGIC_SYMBOL in value) return value;
+
+	// @ts-expect-error
+	value[MAGIC_SYMBOL] = init(value, parent);
+
+	// @ts-expect-error not sure how to fix this
+	return new Proxy(value, handler);
+}
+
+/**
+ * @param {MagicObject} value
+ * @param {MagicObject | null} parent
+ * @returns {Magic}
+ */
+function init(value, parent) {
+	return {
+		p: parent,
+		s: new Map(),
+		v: source(0),
+		a: Array.isArray(value)
+	};
 }