@plasmicapp/react-web 0.2.294 → 0.2.296

package/dist/states/helpers.d.ts

@@ -41,4 +41,10 @@ export declare function assert<T>(cond: T, msg?: StringGen): asserts cond;
  * Changes: fixed setting a deep value to a proxy object
  */
 export declare function set(obj: any, keys: any, val: any): void;
+/**
+ * Forked from https://github.com/jamesfoster/DeepEqual
+ * Changes: removed the comparison between constructors and instanceof objects
+ * because they are dependent on the window object
+ */
+export declare function deepEqual(a: any, b: any): boolean;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasmicapp/react-web",
-  "version": "0.2.294",
+  "version": "0.2.296",
   "description": "plasmic library for rendering in the presentational style",
   "main": "dist/index.cjs.js",
   "types": "dist/index.d.ts",
@@ -86,13 +86,13 @@
     "test-storybook": "test-storybook"
   },
   "dependencies": {
-    "@plasmicapp/auth-react": "0.0.17",
-    "@plasmicapp/data-sources": "0.1.136",
-    "@plasmicapp/data-sources-context": "0.1.18",
-    "@plasmicapp/host": "1.0.178",
-    "@plasmicapp/loader-splits": "1.0.47",
-    "@plasmicapp/prepass": "1.0.11",
-    "@plasmicapp/query": "0.1.75",
+    "@plasmicapp/auth-react": "0.0.18",
+    "@plasmicapp/data-sources": "0.1.137",
+    "@plasmicapp/data-sources-context": "0.1.19",
+    "@plasmicapp/host": "1.0.179",
+    "@plasmicapp/loader-splits": "1.0.48",
+    "@plasmicapp/prepass": "1.0.12",
+    "@plasmicapp/query": "0.1.76",
     "@react-aria/checkbox": "^3.11.2",
     "@react-aria/focus": "^3.14.3",
     "@react-aria/interactions": "^3.19.1",
@@ -157,5 +157,5 @@
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0"
   },
-  "gitHead": "6f034859cd2316dfed75d01006abbc002149374c"
+  "gitHead": "48a2877c3dc093d101508fcdde2fd213055fdab9"
 }

package/skinny/dist/index.js

@@ -15,7 +15,6 @@ import ReactDOM__default from 'react-dom';
 import { useFocusRing } from '@react-aria/focus';
 import { proxy, useSnapshot, ref, getVersion, subscribe } from 'valtio';
 import clone from 'clone';
-import deepEqual from 'fast-deep-equal';
 import '@react-aria/ssr';
 import '@plasmicapp/host';
 
@@ -1604,6 +1603,132 @@ function assignValue(object, key, value) {
         baseAssignValue(object, key, value);
     }
 }
+var isInstanceOfMap = function (a) {
+    return a != null &&
+        typeof a === "object" &&
+        "size" in a &&
+        typeof a.entries === "function" &&
+        typeof a.get === "function" &&
+        typeof a.set === "function" &&
+        typeof a.has === "function";
+};
+var isInstanceOfSet = function (a) {
+    return a != null &&
+        typeof a === "object" &&
+        "size" in a &&
+        typeof a.entries === "function" &&
+        typeof a.add === "function" &&
+        typeof a.has === "function" &&
+        typeof a.delete === "function";
+};
+var isRegExp = function (a) {
+    return Object.prototype.toString.call(a) === "[object RegExp]";
+};
+/**
+ * Forked from https://github.com/jamesfoster/DeepEqual
+ * Changes: removed the comparison between constructors and instanceof objects
+ * because they are dependent on the window object
+ */
+function deepEqual(a, b) {
+    var e_4, _a, e_5, _b, e_6, _c;
+    if (a === b)
+        return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+        // if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+            length = a.length;
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;)
+                if (!deepEqual(a[i], b[i]))
+                    return false;
+            return true;
+        }
+        // if ((a instanceof Map) && (b instanceof Map)) {
+        if (isInstanceOfMap(a) && isInstanceOfMap(b)) {
+            if (a.size !== b.size)
+                return false;
+            try {
+                for (var _d = __values(a.entries()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    i = _e.value;
+                    if (!b.has(i[0]))
+                        return false;
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            try {
+                for (var _f = __values(a.entries()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    i = _g.value;
+                    if (!deepEqual(i[1], b.get(i[0])))
+                        return false;
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            return true;
+        }
+        // if ((a instanceof Set) && (b instanceof Set)) {
+        if (isInstanceOfSet(a) && isInstanceOfSet(b)) {
+            if (a.size !== b.size)
+                return false;
+            try {
+                for (var _h = __values(a.entries()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    i = _j.value;
+                    if (!b.has(i[0]))
+                        return false;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return true;
+        }
+        // if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (isRegExp(a) && isRegExp(b))
+            return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+            return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+            return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+            return false;
+        for (i = length; i-- !== 0;)
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+                return false;
+        for (i = length; i-- !== 0;) {
+            var key = keys[i];
+            if (key === "_owner" && a.$$typeof) {
+                // React-specific: avoid traversing React elements' _owner.
+                //  _owner contains circular references
+                // and is not needed when comparing the actual elements (and not their owners)
+                continue;
+            }
+            if (!deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    // true if both NaN, false otherwise
+    return a !== a && b !== b;
+}
 
 // Utilities used by generated code
 var classNames = classNames$1;