as-model 0.1.12 → 0.1.15

package/dist/index.js

@@ -677,7 +677,6 @@
       }
       return method2.apply(void 0, _to_consumable_array(args));
     };
-    Object.assign(replace, method2());
     replace.identifier = cacheIdentify.method;
     return replace;
   }

package/esm/store/instance.js

@@ -45,7 +45,6 @@ function createMethod(method) {
   const replace = function replace2(...args) {
     return method(...args);
   };
-  Object.assign(replace, method());
   replace.identifier = cacheIdentify.method;
   return replace;
 }

package/esm/tools.js

@@ -0,0 +1,78 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+function getDescriptors(target, receiver, ownOrPrototype, handler) {
+  var it = Object.keys(ownOrPrototype);
+  var result = {};
+  it.forEach(function(key) {
+    result[key] = {
+      get: function() {
+        if (!handler.get) {
+          return target[key];
+        }
+        return handler.get(target, key, receiver);
+      },
+      set: function(v) {
+        if (!handler.set) {
+          target[key] = v;
+          return;
+        }
+        var valid = handler.set(target, key, v, receiver);
+        if (!valid) {
+          throw new Error("".concat(key, " in proxy target is not mutable"));
+        }
+      }
+    };
+  });
+  return result;
+}
+var createSimpleProxy = function(target, handler) {
+  var proxy = {};
+  var own = getDescriptors(target, proxy, target, handler);
+  var prototype = getDescriptors(target, proxy, Object.getPrototypeOf(target), handler);
+  Object.defineProperties(proxy, _object_spread({}, prototype, own));
+  return proxy;
+};
+var createProxy = function(target, handler) {
+  if (typeof Proxy !== "function") {
+    return createSimpleProxy(target, handler);
+  }
+  return new Proxy(target, handler);
+};
+function isObject(data) {
+  return data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object";
+}
+function shallowEqual(prev, current) {
+  if (Object.is(prev, current)) {
+    return true;
+  }
+  if (!isObject(prev) || !isObject(current)) {
+    return false;
+  }
+  var prevKeys = Object.keys(prev);
+  var currentKeys = Object.keys(current);
+  if (prevKeys.length !== currentKeys.length) {
+    return false;
+  }
+  var pre = prev;
+  var curr = current;
+  var hasDiffKey = prevKeys.some(function(key) {
+    return !Object.prototype.hasOwnProperty.call(curr, key);
+  });
+  if (hasDiffKey) {
+    return false;
+  }
+  var hasDiffValue = currentKeys.some(function(key) {
+    var currentValue = curr[key];
+    var prevValue = pre[key];
+    return !Object.is(currentValue, prevValue);
+  });
+  return !hasDiffValue;
+}
+function noop() {
+}
+export {
+  createProxy,
+  createSimpleProxy,
+  noop,
+  shallowEqual
+};