@ptolemy2002/react-proxy-context 1.0.13 → 1.0.15

package/index.js

@@ -540,6 +540,193 @@ var require_react_hook_result = __commonJS({
   }
 });
 
+// node_modules/@ptolemy2002/react-utils/index.js
+var require_react_utils = __commonJS({
+  "node_modules/@ptolemy2002/react-utils/index.js"(exports, module2) {
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __commonJS2 = (cb, mod) => function __require() {
+      return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var require_is_callable2 = __commonJS2({
+      "node_modules/is-callable/index.js"(exports2, module22) {
+        "use strict";
+        var fnToStr = Function.prototype.toString;
+        var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
+        var badArrayLike;
+        var isCallableMarker;
+        if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
+          try {
+            badArrayLike = Object.defineProperty({}, "length", {
+              get: function() {
+                throw isCallableMarker;
+              }
+            });
+            isCallableMarker = {};
+            reflectApply(function() {
+              throw 42;
+            }, null, badArrayLike);
+          } catch (_) {
+            if (_ !== isCallableMarker) {
+              reflectApply = null;
+            }
+          }
+        } else {
+          reflectApply = null;
+        }
+        var constructorRegex = /^\s*class\b/;
+        var isES6ClassFn = function isES6ClassFunction(value) {
+          try {
+            var fnStr = fnToStr.call(value);
+            return constructorRegex.test(fnStr);
+          } catch (e) {
+            return false;
+          }
+        };
+        var tryFunctionObject = function tryFunctionToStr(value) {
+          try {
+            if (isES6ClassFn(value)) {
+              return false;
+            }
+            fnToStr.call(value);
+            return true;
+          } catch (e) {
+            return false;
+          }
+        };
+        var toStr = Object.prototype.toString;
+        var objectClass = "[object Object]";
+        var fnClass = "[object Function]";
+        var genClass = "[object GeneratorFunction]";
+        var ddaClass = "[object HTMLAllCollection]";
+        var ddaClass2 = "[object HTML document.all class]";
+        var ddaClass3 = "[object HTMLCollection]";
+        var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
+        var isIE68 = !(0 in [,]);
+        var isDDA = function isDocumentDotAll() {
+          return false;
+        };
+        if (typeof document === "object") {
+          all = document.all;
+          if (toStr.call(all) === toStr.call(document.all)) {
+            isDDA = function isDocumentDotAll(value) {
+              if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
+                try {
+                  var str = toStr.call(value);
+                  return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
+                } catch (e) {
+                }
+              }
+              return false;
+            };
+          }
+        }
+        var all;
+        module22.exports = reflectApply ? function isCallable2(value) {
+          if (isDDA(value)) {
+            return true;
+          }
+          if (!value) {
+            return false;
+          }
+          if (typeof value !== "function" && typeof value !== "object") {
+            return false;
+          }
+          try {
+            reflectApply(value, null, badArrayLike);
+          } catch (e) {
+            if (e !== isCallableMarker) {
+              return false;
+            }
+          }
+          return !isES6ClassFn(value) && tryFunctionObject(value);
+        } : function isCallable2(value) {
+          if (isDDA(value)) {
+            return true;
+          }
+          if (!value) {
+            return false;
+          }
+          if (typeof value !== "function" && typeof value !== "object") {
+            return false;
+          }
+          if (hasToStringTag) {
+            return tryFunctionObject(value);
+          }
+          if (isES6ClassFn(value)) {
+            return false;
+          }
+          var strClass = toStr.call(value);
+          if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
+            return false;
+          }
+          return tryFunctionObject(value);
+        };
+      }
+    });
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      Spacer: () => Spacer,
+      partialMemo: () => partialMemo2
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_react2 = __toESM2(require("react"));
+    function r(e) {
+      var t, f, n = "";
+      if ("string" == typeof e || "number" == typeof e) n += e;
+      else if ("object" == typeof e) if (Array.isArray(e)) {
+        var o = e.length;
+        for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+      } else for (f in e) e[f] && (n && (n += " "), n += f);
+      return n;
+    }
+    function clsx() {
+      for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+      return n;
+    }
+    var clsx_default = clsx;
+    var import_is_callable2 = __toESM2(require_is_callable2());
+    var partialMemo2 = (component, deps = []) => {
+      return (0, import_react2.memo)(component, (prevProps, nextProps) => {
+        if (deps.length === 0) return true;
+        return deps.every((dep) => {
+          if ((0, import_is_callable2.default)(dep)) return dep(prevProps, nextProps);
+          return prevProps[dep] === nextProps[dep];
+        });
+      });
+    };
+    var Spacer = (0, import_react2.memo)(function({ size = "1rem", horizontal = false, style = {}, className = null, ...props } = {}) {
+      const keyName = horizontal ? "width" : "height";
+      return /* @__PURE__ */ import_react2.default.createElement("div", { className: clsx_default("spacer", className), style: { ...style, [keyName]: size }, ...props });
+    });
+  }
+});
+
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
@@ -569,13 +756,14 @@ var import_react_force_rerender = __toESM(require_react_force_rerender());
 var import_react_mount_effects = __toESM(require_react_mount_effects());
 var import_js_utils = __toESM(require_js_utils());
 var import_react_hook_result = __toESM(require_react_hook_result());
+var import_react_utils = __toESM(require_react_utils());
 function createProxyContext(defaultValue, name) {
   if (typeof Proxy == "undefined") throw new Error("Proxy is not supported in this environment.");
   const context = (0, import_react.createContext)(defaultValue);
   context.name = name;
   return context;
 }
-function ProxyContextProvider({ contextClass, children, value, onChange, proxyRef }) {
+var ProxyContextProvider = (0, import_react_utils.partialMemo)(function ProxyContextProvider2({ contextClass, children, value, onChange, proxyRef }) {
   const changeSubscribers = (0, import_react.useRef)({});
   const objRef = (0, import_react.useRef)();
   const contextRef = (0, import_react.useRef)({});
@@ -639,7 +827,7 @@ function ProxyContextProvider({ contextClass, children, value, onChange, proxyRe
   contextRef.current.subscribe = subscribe;
   contextRef.current.unsubscribe = unsubscribe;
   return /* @__PURE__ */ import_react.default.createElement(contextClass.Provider, { value: contextRef.current }, children);
-}
+}, ["children", "onChange", "proxyRef"]);
 function useProxyContext(contextClass, deps, onChange, listenReinit = true) {
   const context = (0, import_react.useContext)(contextClass);
   const forceRerender = (0, import_react_force_rerender.default)();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/react-proxy-context",
-    "version": "1.0.13",
+    "version": "1.0.15",
     "main": "index.js",
     "files": [
         "index.js"
@@ -42,6 +42,7 @@
         "nanoid": "^5.0.7"
     },
     "dependencies": {
-        "@ptolemy2002/react-hook-result": "^1.0.2"
+        "@ptolemy2002/react-hook-result": "^1.0.2",
+        "@ptolemy2002/react-utils": "^1.1.0"
     }
 }