@ptolemy2002/react-proxy-context 1.0.3 → 1.0.5

package/README.md

@@ -60,12 +60,6 @@ These should be installed in order to use the library, as npm does not automatic
 - @types/react-dom: ^18.3.0
 - react: ^18.3.1
 - react-dom: ^18.3.1
-- @types/is-callable: ^1.1.2
-- is-callable: ^1.2.7
-- nanoid: ^5.0.7
-- @ptolemy2002/react-mount-effects: ^1.1.4
-- @ptolemy2002/react-force-rerender: ^1.0.4
-- @ptolemy2002/js-utils: ^1.0.3
 
 ## Commands
 The following commands exist in the project:

package/index.js

@@ -4,6 +4,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,6 +29,297 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/is-callable/index.js
+var require_is_callable = __commonJS({
+  "node_modules/is-callable/index.js"(exports, module2) {
+    "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;
+    module2.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);
+    };
+  }
+});
+
+// node_modules/@ptolemy2002/react-force-rerender/index.js
+var require_react_force_rerender = __commonJS({
+  "node_modules/@ptolemy2002/react-force-rerender/index.js"(exports, module2) {
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      default: () => useForceRerender2
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_react2 = require("react");
+    function useForceRerender2() {
+      const [, setTick] = (0, import_react2.useState)(0);
+      const update = (0, import_react2.useCallback)(() => {
+        setTimeout(() => {
+          setTick((tick) => tick + 1);
+        }, 0);
+      }, []);
+      return update;
+    }
+  }
+});
+
+// node_modules/@ptolemy2002/react-mount-effects/index.js
+var require_react_mount_effects = __commonJS({
+  "node_modules/@ptolemy2002/react-mount-effects/index.js"(exports, module2) {
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      useMountEffect: () => useMountEffect2,
+      useUnmountEffect: () => useUnmountEffect2
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_react2 = require("react");
+    function useMountEffect2(callback) {
+      (0, import_react2.useEffect)(() => {
+        callback();
+      }, []);
+    }
+    function useUnmountEffect2(callback) {
+      (0, import_react2.useEffect)(() => callback, []);
+    }
+  }
+});
+
+// node_modules/@ptolemy2002/js-utils/index.js
+var require_js_utils = __commonJS({
+  "node_modules/@ptolemy2002/js-utils/index.js"(exports, module2) {
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      Callable: () => Callable,
+      ext_hasNestedProperty: () => ext_hasNestedProperty,
+      isNullOrUndefined: () => isNullOrUndefined2,
+      listInPlainEnglish: () => listInPlainEnglish,
+      loadExtension: () => loadExtension,
+      unloadExtension: () => unloadExtension
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    function ext_hasNestedProperty(prop = "") {
+      if (typeof prop === "string") prop = prop.split(".");
+      if (!Array.isArray(prop)) return this.hasOwnProperty(prop);
+      let obj = this;
+      for (let i = 0; i < prop.length; i++) {
+        const p = prop[i];
+        if (!obj?.hasOwnProperty(p)) return false;
+        obj = obj[p];
+      }
+      return true;
+    }
+    function loadExtension(name, func, base = Object) {
+      if (base.prototype.hasOwnProperty(name)) return;
+      Object.defineProperty(base.prototype, name, {
+        value: func,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+    function unloadExtension(name, base = Object) {
+      delete base.prototype[name];
+    }
+    function listInPlainEnglish(list, { max = void 0, conjunction = "and" } = {}) {
+      if (max === void 0) max = list.length;
+      if (list.length === 0) {
+        return "";
+      }
+      if (list.length === 1) {
+        return list[0];
+      }
+      if (list.length === 2) {
+        return `${list[0]} ${conjunction} ${list[1]}`;
+      }
+      list = list.map((v, i) => {
+        if (i === list.length - 1) return v;
+        if (v.endsWith(`"`)) {
+          return v.slice(0, -1) + `," `;
+        } else if (v.endsWith(`'`)) {
+          return v.slice(0, -1) + `,' `;
+        } else {
+          return v + ", ";
+        }
+      });
+      if (list.length > max) {
+        return `${list.slice(0, max).join("")}${conjunction} ${list.length - max} more`;
+      } else {
+        return `${list.slice(0, -1).join("")}${conjunction} ${list[list.length - 1]}`;
+      }
+    }
+    function isNullOrUndefined2(v) {
+      return v === null || v === void 0;
+    }
+    var Callable = class extends Function {
+      constructor() {
+        super("...args", "return this.__self__.__call__(...args)");
+        let self = this.bind(this);
+        this.__self__ = self;
+        return self;
+      }
+      // This should be overridden by the subclass
+      __call__() {
+      }
+    };
+  }
+});
+
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
@@ -35,11 +329,25 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_react = __toESM(require("react"));
-var import_nanoid = require("nanoid");
-var import_is_callable = __toESM(require("is-callable"));
-var import_react_force_rerender = __toESM(require("@ptolemy2002/react-force-rerender"));
-var import_react_mount_effects = require("@ptolemy2002/react-mount-effects");
-var import_js_utils = require("@ptolemy2002/js-utils");
+
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
+  }
+  return id;
+};
+
+// src/index.js
+var import_is_callable = __toESM(require_is_callable());
+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());
 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);
@@ -51,8 +359,9 @@ function ProxyContextProvider({ contextClass, children, value, onChange, proxyRe
   const objRef = (0, import_react.useRef)();
   const contextRef = (0, import_react.useRef)({});
   const subscribe = (0, import_react.useCallback)((callback, deps, listenReinit = true) => {
-    const id = (0, import_nanoid.nanoid)();
+    const id = nanoid();
     changeSubscribers.current[id] = {
+      id,
       deps,
       callback,
       listenReinit
@@ -68,7 +377,7 @@ function ProxyContextProvider({ contextClass, children, value, onChange, proxyRe
       if (!(0, import_js_utils.isNullOrUndefined)(newObj)) {
         objRef.current = new Proxy(newObj, {
           get: function(target, prop) {
-            const result = Reflect.get(target, prop, objRef.current);
+            const result = Reflect.get(target, prop, newObj);
             if ((0, import_is_callable.default)(result)) {
               return result.bind(objRef.current);
             } else {
@@ -77,20 +386,25 @@ function ProxyContextProvider({ contextClass, children, value, onChange, proxyRe
           },
           set: function(target, prop, value2) {
             const prevValue = target[prop];
-            Reflect.set(target, prop, value2, objRef.current);
+            Reflect.set(target, prop, value2, newObj);
             value2 = target[prop];
             Object.values(changeSubscribers.current).forEach((subscriber) => {
-              if (!subscriber.deps || subscriber.deps.includes(prop) && prevValue !== value2 || subscriber.deps.some((subProp) => (0, import_is_callable.default)(subProp) && subProp(prop, value2, prevValue, objRef.current))) {
+              if (!subscriber.deps || subscriber.deps.includes(prop) && prevValue !== value2 || subscriber.deps.some((subProp) => (0, import_is_callable.default)(subProp) && subProp(prop, value2, prevValue, newObj))) {
                 subscriber.callback(prop, value2, prevValue);
               }
             });
             if ((0, import_is_callable.default)(onChange)) onChange(prop, value2, prevValue);
+            Object.values(changeSubscribers.current).forEach((subscriber) => {
+              subscriber.callback(prop, value2, prevValue);
+            });
             return true;
           }
         });
       }
       Object.values(changeSubscribers.current).forEach((subscriber) => {
-        if (subscriber.listenReinit) subscriber.callback(null, objRef.current, prevObj);
+        if (subscriber.listenReinit) {
+          subscriber.callback(null, objRef.current, prevObj);
+        }
       });
       proxyRef && (proxyRef.current = objRef.current);
       if ((0, import_is_callable.default)(onChange)) onChange(null, objRef.current, prevObj);

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@ptolemy2002/react-proxy-context",
-    "version": "1.0.3",
+    "version": "1.0.5",
     "main": "index.js",
     "files": [
         "index.js"
     ],
     "scripts": {
-        "build": "esbuild src/index.js --bundle --format=cjs --outfile=index.js --loader:.js=jsx --external:react --external:react-dom --external:@types/react --external:@types/react-dom --external:is-callable --external:nanoid --external:@ptolemy2002/react-mount-effects --external:@ptolemy2002/react-force-rerender --external:@ptolemy2002/js-utils",
+        "build": "esbuild src/index.js --bundle --format=cjs --outfile=index.js --loader:.js=jsx --external:react --external:react-dom",
         "postinstall": "npx typesync",
         "uninstall": "bash ./scripts/uninstall.sh",
         "reinstall": "bash ./scripts/reinstall.sh",
@@ -30,15 +30,15 @@
         "@types/react": "^18.3.3",
         "@types/react-dom": "^18.3.0",
         "react": "^18.3.1",
-        "react-dom": "^18.3.1",
-        "@types/is-callable": "^1.1.2",
-        "is-callable": "^1.2.7",
-        "nanoid": "^5.0.7",
-        "@ptolemy2002/react-mount-effects": "^1.1.4",
-        "@ptolemy2002/react-force-rerender": "^1.0.4",
-        "@ptolemy2002/js-utils": "^1.0.3"
+        "react-dom": "^18.3.1"
     },
     "devDependencies": {
-        "esbuild": "^0.23.0"
+        "@ptolemy2002/js-utils": "^1.0.3",
+        "@ptolemy2002/react-force-rerender": "^1.0.4",
+        "@ptolemy2002/react-mount-effects": "^1.1.4",
+        "@types/is-callable": "^1.1.2",
+        "esbuild": "^0.23.0",
+        "is-callable": "^1.2.7",
+        "nanoid": "^5.0.7"
     }
 }