some optimizations

Author: ged-odoo

src/runtime/component_node.ts

@@ -57,11 +57,11 @@ export class ComponentNode implements VNode<ComponentNode> {
     this.parent = parent;
     this.parentKey = parentKey;
     this.pluginManager = parent ? parent.pluginManager : app.pluginManager;
-    this.signalComputation = createComputation({
-      compute: () => this.render(false),
-      state: ComputationState.EXECUTED,
-      isDerived: false,
-    });
+    this.signalComputation = createComputation(
+      () => this.render(false),
+      false,
+      ComputationState.EXECUTED
+    );
     this.props = Object.assign({}, props);
     contextStack.push({
       type: "component",

src/runtime/reactivity/computations.ts

@@ -33,15 +33,18 @@ export const atomSymbol = Symbol("Atom");
 let observers: ComputationAtom[] = [];
 let currentComputation: ComputationAtom | undefined;
 
-export function createComputation(options: Partial<ComputationAtom> = {}): ComputationAtom {
+export function createComputation(
+  compute: () => any,
+  isDerived: boolean,
+  state: ComputationState = ComputationState.STALE
+): ComputationAtom {
   return {
-    state: ComputationState.STALE,
+    state,
     value: undefined,
-    compute() {},
+    compute,
     sources: new Set(),
     observers: new Set(),
-    isDerived: false,
-    ...options,
+    isDerived,
   };
 }
 

src/runtime/reactivity/computed.ts

@@ -15,13 +15,13 @@ export function computed<TRead, TWrite = TRead>(
   getter: () => TRead,
   options: ComputedOptions<TWrite> = {}
 ): ReactiveValue<TRead, TWrite> {
-  const computation = createComputation({
-    compute: () => {
+  const computation = createComputation(
+    () => {
       onWriteAtom(computation);
       return getter();
     },
-    isDerived: true,
-  });
+    true
+  );
 
   function readComputed() {
     updateComputation(computation);

src/runtime/reactivity/effect.ts

@@ -9,17 +9,17 @@ import {
 } from "./computations";
 
 export function effect<T>(fn: () => T) {
-  const computation = createComputation({
-    compute() {
+  const computation = createComputation(
+    () => {
       // In case the cleanup read an atom.
       // todo: test it
       setComputation(undefined);
       unsubscribeEffect(computation);
       setComputation(computation);
       return fn();
     },
-    isDerived: false,
-  });
+    false
+  );
   getCurrentComputation()?.observers.add(computation);
   updateComputation(computation);
 

src/runtime/reactivity/proxy.ts

@@ -15,33 +15,21 @@ type CollectionRawType = "Set" | "Map" | "WeakMap";
 const objectToString = Object.prototype.toString;
 const objectHasOwnProperty = Object.prototype.hasOwnProperty;
 
-// Use arrays because Array.includes is faster than Set.has for small arrays
-const SUPPORTED_RAW_TYPES = ["Object", "Array", "Set", "Map", "WeakMap"];
-const COLLECTION_RAW_TYPES = ["Set", "Map", "WeakMap"];
-
-/**
- * extract "RawType" from strings like "[object RawType]" => this lets us ignore
- * many native objects such as Promise (whose toString is [object Promise])
- * or Date ([object Date]), while also supporting collections without using
- * instanceof in a loop
- *
- * @param obj the object to check
- * @returns the raw type of the object
- */
-function rawType(obj: any) {
-  return objectToString.call(toRaw(obj)).slice(8, -1);
-}
 /**
  * Checks whether a given value can be made into a proxy object.
  *
  * @param value the value to check
  * @returns whether the value can be made proxy
  */
 function canBeMadeReactive(value: any): boolean {
-  if (typeof value !== "object") {
+  if (typeof value !== "object" || value === null) {
     return false;
   }
-  return SUPPORTED_RAW_TYPES.includes(rawType(value));
+  const raw = toRaw(value);
+  if (Array.isArray(raw) || raw instanceof Set || raw instanceof Map || raw instanceof WeakMap) {
+    return true;
+  }
+  return objectToString.call(raw) === "[object Object]";
 }
 /**
  * Creates a proxy from the given object/callback if possible and returns it,
@@ -151,10 +139,16 @@ export function proxifyTarget<T extends Target>(target: T, atom: Atom | null): T
     return reactive as T;
   }
 
-  const targetRawType = rawType(target);
-  const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
-    ? collectionsProxyHandler(target as Collection, targetRawType as CollectionRawType, atom)
-    : basicProxyHandler<T>(atom);
+  let handler: ProxyHandler<any>;
+  if (target instanceof Map) {
+    handler = collectionsProxyHandler(target as unknown as Collection, "Map", atom);
+  } else if (target instanceof Set) {
+    handler = collectionsProxyHandler(target as unknown as Collection, "Set", atom);
+  } else if (target instanceof WeakMap) {
+    handler = collectionsProxyHandler(target as unknown as Collection, "WeakMap", atom);
+  } else {
+    handler = basicProxyHandler<T>(atom);
+  }
   const proxy = new Proxy(target, handler as ProxyHandler<T>) as Reactive<T>;
 
   proxyCache.set(target, proxy);
@@ -203,13 +197,21 @@ export function proxy<T extends Target>(target: T): T {
 function basicProxyHandler<T extends Target>(atom: Atom | null): ProxyHandler<T> {
   return {
     get(target, key, receiver) {
+      onReadTargetKey(target, key, atom);
+      const value = Reflect.get(target, key, receiver);
+      // Fast path: signal-based proxies and primitive values don't need wrapping
+      if (atom || typeof value !== "object" || value === null) {
+        return value;
+      }
+      if (!canBeMadeReactive(value)) {
+        return value;
+      }
       // non-writable non-configurable properties cannot be made proxy
       const desc = Object.getOwnPropertyDescriptor(target, key);
       if (desc && !desc.writable && !desc.configurable) {
-        return Reflect.get(target, key, receiver);
+        return value;
       }
-      onReadTargetKey(target, key, atom);
-      return possiblyReactive(Reflect.get(target, key, receiver), atom);
+      return proxifyTarget(value, null);
     },
     set(target, key, value, receiver) {
       const hadKey = objectHasOwnProperty.call(target, key);