solid-js 1.9.6 → 1.9.8

package/store/dist/store.js

@@ -1,4 +1,4 @@
-import { $PROXY, $TRACK, getListener, batch, createSignal } from "solid-js";
+import { $PROXY, $TRACK, getListener, batch, createSignal } from 'solid-js';
 
 const $RAW = Symbol("store-raw"),
   $NODE = Symbol("store-node"),
@@ -8,7 +8,7 @@ function wrap$1(value) {
   let p = value[$PROXY];
   if (!p) {
     Object.defineProperty(value, $PROXY, {
-      value: (p = new Proxy(value, proxyTraps$1))
+      value: p = new Proxy(value, proxyTraps$1)
     });
     if (!Array.isArray(value)) {
       const keys = Object.keys(value),
@@ -28,29 +28,20 @@ function wrap$1(value) {
 }
 function isWrappable(obj) {
   let proto;
-  return (
-    obj != null &&
-    typeof obj === "object" &&
-    (obj[$PROXY] ||
-      !(proto = Object.getPrototypeOf(obj)) ||
-      proto === Object.prototype ||
-      Array.isArray(obj))
-  );
+  return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
 }
 function unwrap(item, set = new Set()) {
   let result, unwrapped, v, prop;
-  if ((result = item != null && item[$RAW])) return result;
+  if (result = item != null && item[$RAW]) return result;
   if (!isWrappable(item) || set.has(item)) return item;
   if (Array.isArray(item)) {
-    if (Object.isFrozen(item)) item = item.slice(0);
-    else set.add(item);
+    if (Object.isFrozen(item)) item = item.slice(0);else set.add(item);
     for (let i = 0, l = item.length; i < l; i++) {
       v = item[i];
       if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
     }
   } else {
-    if (Object.isFrozen(item)) item = Object.assign({}, item);
-    else set.add(item);
+    if (Object.isFrozen(item)) item = Object.assign({}, item);else set.add(item);
     const keys = Object.keys(item),
       desc = Object.getOwnPropertyDescriptors(item);
     for (let i = 0, l = keys.length; i < l; i++) {
@@ -64,10 +55,9 @@ function unwrap(item, set = new Set()) {
 }
 function getNodes(target, symbol) {
   let nodes = target[symbol];
-  if (!nodes)
-    Object.defineProperty(target, symbol, {
-      value: (nodes = Object.create(null))
-    });
+  if (!nodes) Object.defineProperty(target, symbol, {
+    value: nodes = Object.create(null)
+  });
   return nodes;
 }
 function getNode(nodes, property, value) {
@@ -77,12 +67,11 @@ function getNode(nodes, property, value) {
     internal: true
   });
   s.$ = set;
-  return (nodes[property] = s);
+  return nodes[property] = s;
 }
 function proxyDescriptor$1(target, property) {
   const desc = Reflect.getOwnPropertyDescriptor(target, property);
-  if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE)
-    return desc;
+  if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE) return desc;
   delete desc.value;
   delete desc.writable;
   desc.get = () => target[$PROXY][property];
@@ -109,25 +98,12 @@ const proxyTraps$1 = {
     if (property === $NODE || property === $HAS || property === "__proto__") return value;
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(target, property);
-      if (
-        getListener() &&
-        (typeof value !== "function" || target.hasOwnProperty(property)) &&
-        !(desc && desc.get)
-      )
-        value = getNode(nodes, property, value)();
+      if (getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();
     }
     return isWrappable(value) ? wrap$1(value) : value;
   },
   has(target, property) {
-    if (
-      property === $RAW ||
-      property === $PROXY ||
-      property === $TRACK ||
-      property === $NODE ||
-      property === $HAS ||
-      property === "__proto__"
-    )
-      return true;
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
     getListener() && getNode(getNodes(target, $HAS), property)();
     return property in target;
   },
@@ -153,7 +129,7 @@ function setProperty(state, property, value, deleting = false) {
   }
   let nodes = getNodes(state, $NODE),
     node;
-  if ((node = getNode(nodes, property, prev))) node.$(() => value);
+  if (node = getNode(nodes, property, prev)) node.$(() => value);
   if (Array.isArray(state) && state.length !== len) {
     for (let i = state.length; i < len; i++) (node = nodes[i]) && node.$();
     (node = getNode(nodes, "length", len)) && node.$(state.length);
@@ -199,7 +175,11 @@ function updatePath(current, path, traversed = []) {
       }
       return;
     } else if (isArray && partType === "object") {
-      const { from = 0, to = current.length - 1, by = 1 } = part;
+      const {
+        from = 0,
+        to = current.length - 1,
+        by = 1
+      } = part;
       for (let i = from; i <= to; i += by) {
         updatePath(current, [i].concat(path), traversed);
       }
@@ -218,7 +198,7 @@ function updatePath(current, path, traversed = []) {
   }
   if (part === undefined && value == undefined) return;
   value = unwrap(value);
-  if (part === undefined || (isWrappable(prev) && isWrappable(value) && !Array.isArray(value))) {
+  if (part === undefined || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
     mergeStoreNode(prev, value);
   } else setProperty(current, part, value);
 }
@@ -228,9 +208,7 @@ function createStore(...[store, options]) {
   const wrappedStore = wrap$1(unwrappedStore);
   function setStore(...args) {
     batch(() => {
-      isArray && args.length === 1
-        ? updateArray(unwrappedStore, args[0])
-        : updatePath(unwrappedStore, args);
+      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
     });
   }
   return [wrappedStore, setStore];
@@ -238,19 +216,11 @@ function createStore(...[store, options]) {
 
 function proxyDescriptor(target, property) {
   const desc = Reflect.getOwnPropertyDescriptor(target, property);
-  if (
-    !desc ||
-    desc.get ||
-    desc.set ||
-    !desc.configurable ||
-    property === $PROXY ||
-    property === $NODE
-  )
-    return desc;
+  if (!desc || desc.get || desc.set || !desc.configurable || property === $PROXY || property === $NODE) return desc;
   delete desc.value;
   delete desc.writable;
   desc.get = () => target[$PROXY][property];
-  desc.set = v => (target[$PROXY][property] = v);
+  desc.set = v => target[$PROXY][property] = v;
   return desc;
 }
 const proxyTraps = {
@@ -268,24 +238,14 @@ const proxyTraps = {
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(target, property);
       const isFunction = typeof value === "function";
-      if (getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get))
-        value = getNode(nodes, property, value)();
-      else if (value != null && isFunction && value === Array.prototype[property]) {
+      if (getListener() && (!isFunction || target.hasOwnProperty(property)) && !(desc && desc.get)) value = getNode(nodes, property, value)();else if (value != null && isFunction && value === Array.prototype[property]) {
         return (...args) => batch(() => Array.prototype[property].apply(receiver, args));
       }
     }
     return isWrappable(value) ? wrap(value) : value;
   },
   has(target, property) {
-    if (
-      property === $RAW ||
-      property === $PROXY ||
-      property === $TRACK ||
-      property === $NODE ||
-      property === $HAS ||
-      property === "__proto__"
-    )
-      return true;
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__") return true;
     getListener() && getNode(getNodes(target, $HAS), property)();
     return property in target;
   },
@@ -304,21 +264,20 @@ function wrap(value) {
   let p = value[$PROXY];
   if (!p) {
     Object.defineProperty(value, $PROXY, {
-      value: (p = new Proxy(value, proxyTraps))
+      value: p = new Proxy(value, proxyTraps)
     });
     const keys = Object.keys(value),
       desc = Object.getOwnPropertyDescriptors(value);
     const proto = Object.getPrototypeOf(value);
-    const isClass =
-      proto !== null &&
-      value !== null &&
-      typeof value === "object" &&
-      !Array.isArray(value) &&
-      proto !== Object.prototype;
+    const isClass = proto !== null && value !== null && typeof value === "object" && !Array.isArray(value) && proto !== Object.prototype;
     if (isClass) {
-      const descriptors = Object.getOwnPropertyDescriptors(proto);
-      keys.push(...Object.keys(descriptors));
-      Object.assign(desc, descriptors);
+      let curProto = proto;
+      while (curProto != null) {
+        const descriptors = Object.getOwnPropertyDescriptors(curProto);
+        keys.push(...Object.keys(descriptors));
+        Object.assign(desc, descriptors);
+        curProto = Object.getPrototypeOf(curProto);
+      }
     }
     for (let i = 0, l = keys.length; i < l; i++) {
       const prop = keys[i];
@@ -356,42 +315,19 @@ function applyState(target, parent, property, merge, key) {
   const previous = parent[property];
   if (target === previous) return;
   const isArray = Array.isArray(target);
-  if (
-    property !== $ROOT &&
-    (!isWrappable(target) ||
-      !isWrappable(previous) ||
-      isArray !== Array.isArray(previous) ||
-      (key && target[key] !== previous[key]))
-  ) {
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
     setProperty(parent, property, target);
     return;
   }
   if (isArray) {
-    if (
-      target.length &&
-      previous.length &&
-      (!merge || (key && target[0] && target[0][key] != null))
-    ) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
-      for (
-        start = 0, end = Math.min(previous.length, target.length);
-        start < end &&
-        (previous[start] === target[start] ||
-          (key && previous[start] && target[start] && previous[start][key] === target[start][key]));
-        start++
-      ) {
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
         applyState(target[start], previous, start, merge, key);
       }
       const temp = new Array(target.length),
         newIndices = new Map();
-      for (
-        end = previous.length - 1, newEnd = target.length - 1;
-        end >= start &&
-        newEnd >= start &&
-        (previous[end] === target[newEnd] ||
-          (key && previous[end] && target[newEnd] && previous[end][key] === target[newEnd][key]));
-        end--, newEnd--
-      ) {
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
         temp[newEnd] = previous[end];
       }
       if (start > newEnd || start > end) {
@@ -445,19 +381,16 @@ function applyState(target, parent, property, merge, key) {
   }
 }
 function reconcile(value, options = {}) {
-  const { merge, key = "id" } = options,
+  const {
+      merge,
+      key = "id"
+    } = options,
     v = unwrap(value);
   return state => {
     if (!isWrappable(state) || !isWrappable(v)) return v;
-    const res = applyState(
-      v,
-      {
-        [$ROOT]: state
-      },
-      $ROOT,
-      merge,
-      key
-    );
+    const res = applyState(v, {
+      [$ROOT]: state
+    }, $ROOT, merge, key);
     return res === undefined ? state : res;
   };
 }
@@ -467,10 +400,7 @@ const setterTraps = {
     if (property === $RAW) return target;
     const value = target[property];
     let proxy;
-    return isWrappable(value)
-      ? producers.get(value) ||
-          (producers.set(value, (proxy = new Proxy(value, setterTraps))), proxy)
-      : value;
+    return isWrappable(value) ? producers.get(value) || (producers.set(value, proxy = new Proxy(value, setterTraps)), proxy) : value;
   },
   set(target, property, value) {
     setProperty(target, property, unwrap(value));
@@ -486,7 +416,7 @@ function produce(fn) {
     if (isWrappable(state)) {
       let proxy;
       if (!(proxy = producers.get(state))) {
-        producers.set(state, (proxy = new Proxy(state, setterTraps)));
+        producers.set(state, proxy = new Proxy(state, setterTraps));
       }
       fn(proxy);
     }

package/store/types/index.d.ts

@@ -1,26 +1,12 @@
 export { $RAW, createStore, unwrap } from "./store.js";
-export type {
-  ArrayFilterFn,
-  DeepMutable,
-  DeepReadonly,
-  NotWrappable,
-  Part,
-  SetStoreFunction,
-  SolidStore,
-  Store,
-  StoreNode,
-  StorePathRange,
-  StoreSetter
-} from "./store.js";
+export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StorePathRange, StoreSetter } from "./store.js";
 export * from "./mutable.js";
 export * from "./modifiers.js";
 import { $NODE, isWrappable } from "./store.js";
-export declare const DEV:
-  | {
-      readonly $NODE: typeof $NODE;
-      readonly isWrappable: typeof isWrappable;
-      readonly hooks: {
+export declare const DEV: {
+    readonly $NODE: typeof $NODE;
+    readonly isWrappable: typeof isWrappable;
+    readonly hooks: {
         onStoreNodeUpdate: import("./store.js").OnStoreNodeUpdate | null;
-      };
-    }
-  | undefined;
+    };
+} | undefined;

package/store/types/modifiers.d.ts

@@ -1,9 +1,6 @@
 export type ReconcileOptions = {
-  key?: string | null;
-  merge?: boolean;
+    key?: string | null;
+    merge?: boolean;
 };
-export declare function reconcile<T extends U, U>(
-  value: T,
-  options?: ReconcileOptions
-): (state: U) => T;
+export declare function reconcile<T extends U, U>(value: T, options?: ReconcileOptions): (state: U) => T;
 export declare function produce<T>(fn: (state: T) => void): (state: T) => T;

package/store/types/mutable.d.ts

@@ -1,8 +1,5 @@
 import { StoreNode } from "./store.js";
-export declare function createMutable<T extends StoreNode>(
-  state: T,
-  options?: {
+export declare function createMutable<T extends StoreNode>(state: T, options?: {
     name?: string;
-  }
-): T;
+}): T;
 export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;

package/store/types/server.d.ts

@@ -1,37 +1,17 @@
 import type { SetStoreFunction, Store } from "./store.js";
-export type {
-  ArrayFilterFn,
-  DeepMutable,
-  DeepReadonly,
-  NotWrappable,
-  Part,
-  SetStoreFunction,
-  SolidStore,
-  Store,
-  StoreNode,
-  StorePathRange,
-  StoreSetter
-} from "./store.js";
+export type { ArrayFilterFn, DeepMutable, DeepReadonly, NotWrappable, Part, SetStoreFunction, SolidStore, Store, StoreNode, StorePathRange, StoreSetter } from "./store.js";
 export declare const $RAW: unique symbol;
 export declare function isWrappable(obj: any): boolean;
 export declare function unwrap<T>(item: T): T;
-export declare function setProperty(
-  state: any,
-  property: PropertyKey,
-  value: any,
-  force?: boolean
-): void;
+export declare function setProperty(state: any, property: PropertyKey, value: any, force?: boolean): void;
 export declare function updatePath(current: any, path: any[], traversed?: PropertyKey[]): void;
 export declare function createStore<T>(state: T | Store<T>): [Store<T>, SetStoreFunction<T>];
 export declare function createMutable<T>(state: T | Store<T>): T;
 export declare function modifyMutable<T>(state: T, modifier: (state: T) => T): void;
 type ReconcileOptions = {
-  key?: string | null;
-  merge?: boolean;
+    key?: string | null;
+    merge?: boolean;
 };
-export declare function reconcile<T extends U, U extends object>(
-  value: T,
-  options?: ReconcileOptions
-): (state: U) => T;
+export declare function reconcile<T extends U, U extends object>(value: T, options?: ReconcileOptions): (state: U) => T;
 export declare function produce<T>(fn: (state: T) => void): (state: T) => T;
 export declare const DEV: undefined;