@ptolemy2002/react-proxy-context 1.0.10 → 1.0.12

package/index.js

@@ -207,6 +207,7 @@ var require_react_mount_effects = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var src_exports2 = {};
     __export2(src_exports2, {
+      useDelayedEffect: () => useDelayedEffect,
       useMountEffect: () => useMountEffect2,
       useUnmountEffect: () => useUnmountEffect2
     });
@@ -220,6 +221,13 @@ var require_react_mount_effects = __commonJS({
     function useUnmountEffect2(callback) {
       (0, import_react2.useEffect)(() => callback, []);
     }
+    function useDelayedEffect(callback, deps = [], delay = 0) {
+      const changeCount = (0, import_react2.useRef)(0);
+      (0, import_react2.useEffect)(() => {
+        changeCount.current++;
+        if (changeCount.current > delay + 1) callback(changeCount, () => changeCount.current = 0);
+      }, deps);
+    }
   }
 });
 
@@ -320,6 +328,218 @@ var require_js_utils = __commonJS({
   }
 });
 
+// node_modules/@ptolemy2002/react-hook-result/index.js
+var require_react_hook_result = __commonJS({
+  "node_modules/@ptolemy2002/react-hook-result/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_js_utils2 = __commonJS2({
+      "node_modules/@ptolemy2002/js-utils/index.js"(exports2, module22) {
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var src_exports22 = {};
+        __export22(src_exports22, {
+          Callable: () => Callable,
+          ext_getAllProperties: () => ext_getAllProperties,
+          ext_hasNestedProperty: () => ext_hasNestedProperty,
+          ext_hasOwnNestedProperty: () => ext_hasOwnNestedProperty,
+          ext_hasProperty: () => ext_hasProperty2,
+          getAllProperties: () => getAllProperties,
+          hasNestedProperty: () => hasNestedProperty,
+          hasProperty: () => hasProperty,
+          isNullOrUndefined: () => isNullOrUndefined2,
+          listInPlainEnglish: () => listInPlainEnglish,
+          loadExtension: () => loadExtension2,
+          unloadExtension: () => unloadExtension
+        });
+        module22.exports = __toCommonJS22(src_exports22);
+        function hasNestedProperty(self, prop = "", hasPropCallback = (o, p) => o.hasOwnProperty(p)) {
+          if (typeof prop === "string") prop = prop.split(".");
+          if (!Array.isArray(prop)) return hasPropCallback(self, prop);
+          let obj = self;
+          for (let i = 0; i < prop.length; i++) {
+            const p = prop[i];
+            if (!obj) return false;
+            if (!hasPropCallback(obj, p)) return false;
+            obj = obj[p];
+          }
+          return true;
+        }
+        function ext_hasOwnNestedProperty(prop = "") {
+          return hasNestedProperty(this, prop);
+        }
+        function getAllProperties(self) {
+          let allProps = [], curr = self;
+          do {
+            let props = Object.getOwnPropertyNames(curr);
+            props.forEach(function(prop) {
+              if (allProps.indexOf(prop) === -1) {
+                allProps.push(prop);
+              }
+            });
+          } while (curr = Object.getPrototypeOf(curr));
+          return allProps;
+        }
+        function ext_getAllProperties() {
+          return getAllProperties(this);
+        }
+        function hasProperty(self, prop) {
+          let curr = self;
+          do {
+            if (curr.hasOwnProperty(prop)) return true;
+          } while (curr = Object.getPrototypeOf(curr));
+          return false;
+        }
+        function ext_hasProperty2(prop) {
+          return hasProperty(this, prop);
+        }
+        function ext_hasNestedProperty(prop) {
+          return hasNestedProperty(this, prop, (o, p) => hasProperty(o, p));
+        }
+        function loadExtension2(name, func, base = Object) {
+          if (hasProperty(base.prototype, 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__() {
+          }
+        };
+      }
+    });
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      default: () => HookResult2
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_js_utils2 = __toESM2(require_js_utils2());
+    (0, import_js_utils2.loadExtension)("hasProperty", import_js_utils2.ext_hasProperty, Object);
+    var HookResult2 = class {
+      _data = /* @__PURE__ */ new Map();
+      constructor(data = {}, order = []) {
+        if (typeof Proxy == "undefined") throw new Error("Proxy is not supported in this environment.");
+        order.forEach((key) => {
+          this._data.set(key, data[key]);
+        });
+        Object.keys(data).forEach((key) => {
+          if (!order.includes(key)) {
+            this._data.set(key, data[key]);
+          }
+        });
+        return new Proxy(this, {
+          // If the property is not found on the object, get it from the data map
+          get: function(target, prop) {
+            if (target.hasProperty(prop)) {
+              return target[prop];
+            } else {
+              return target._data.get(prop);
+            }
+          },
+          // If the property is not found on the object, set it in the data map
+          set: function(target, prop, value) {
+            if (target.hasProperty(prop)) {
+              target[prop] = value;
+            } else {
+              target._data.set(prop, value);
+            }
+          }
+        });
+      }
+      // This is a generator function: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
+      *[Symbol.iterator]() {
+        yield* this._data.values();
+      }
+    };
+  }
+});
+
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
@@ -348,6 +568,7 @@ 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());
+var import_react_hook_result = __toESM(require_react_hook_result());
 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);
@@ -392,7 +613,6 @@ function ProxyContextProvider({ contextClass, children, value, onChange, proxyRe
             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, newObj))) {
-                console.log("Calling subscriber:", subscriber);
                 subscriber.callback(prop, value2, prevValue);
               }
             });
@@ -437,5 +657,5 @@ function useProxyContext(contextClass, deps, onChange, listenReinit = true) {
   (0, import_react_mount_effects.useUnmountEffect)(() => {
     context?.unsubscribe(id.current);
   });
-  return [context?.obj, context?.set];
+  return new import_react_hook_result.default({ value: context?.obj, set: context?.set }, ["value", "set"]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/react-proxy-context",
-    "version": "1.0.10",
+    "version": "1.0.12",
     "main": "index.js",
     "files": [
         "index.js"
@@ -40,5 +40,8 @@
         "esbuild": "^0.23.0",
         "is-callable": "^1.2.7",
         "nanoid": "^5.0.7"
+    },
+    "dependencies": {
+        "@ptolemy2002/react-hook-result": "^1.0.2"
     }
 }