@take-out/helpers 0.4.3 → 0.4.4

package/dist/cjs/emitter.cjs

@@ -2,33 +2,35 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // 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 ? __defProp(target, "default", {
-    value: mod,
-    enumerable: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// 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 ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
 var emitter_exports = {};
 __export(emitter_exports, {
   Emitter: () => Emitter,
@@ -43,54 +45,78 @@ __export(emitter_exports, {
   useEmittersSelector: () => useEmittersSelector
 });
 module.exports = __toCommonJS(emitter_exports);
-var import_dequal = require("dequal"),
-  React = __toESM(require("react"), 1),
-  import_react = require("react"),
-  import_abortable = require("./async/abortable.cjs"),
-  import_constants = require("./constants.cjs"),
-  import_errors = require("./error/errors.cjs"),
-  import_globalValue = require("./global/globalValue.cjs"),
-  import_createGlobalContext = require("./react/createGlobalContext.cjs"),
-  import_jsx_runtime = require("react/jsx-runtime");
+var import_dequal = require("dequal");
+var React = __toESM(require("react"), 1);
+var import_react = require("react");
+var import_abortable = require("./async/abortable.cjs");
+var import_constants = require("./constants.cjs");
+var import_errors = require("./error/errors.cjs");
+var import_globalValue = require("./global/globalValue.cjs");
+var import_createGlobalContext = require("./react/createGlobalContext.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
 function useGet(currentValue, initialValue, forwardToFunction) {
   const curRef = React.useRef(initialValue ?? currentValue);
-  return (0, import_react.useLayoutEffect)(() => {
+  (0, import_react.useLayoutEffect)(() => {
     curRef.current = currentValue;
-  }), React.useCallback(forwardToFunction ? (...args) => curRef.current?.apply(null, args) : () => curRef.current, [curRef, forwardToFunction]);
+  });
+  return React.useCallback(forwardToFunction ? (...args) => curRef.current?.apply(null, args) : () => curRef.current, [curRef, forwardToFunction]);
 }
 class Emitter {
   disposables = /* @__PURE__ */new Set();
   value;
   options;
   constructor(value, options) {
-    this.value = value, this.options = options;
+    this.value = value;
+    this.options = options;
   }
-  listen = disposable => (this.disposables.add(disposable), () => {
-    this.disposables.delete(disposable);
-  });
+  listen = disposable => {
+    this.disposables.add(disposable);
+    return () => {
+      this.disposables.delete(disposable);
+    };
+  };
   emit = next => {
-    process.env.NODE_ENV === "development" && setCache(this, next);
+    if (process.env.NODE_ENV === "development") {
+      setCache(this, next);
+    }
     const compare = this.options?.comparator;
     if (compare) {
-      if (this.value && compare(this.value, next)) return;
-    } else this.value === next && process.env.NODE_ENV === "development" && console.warn(`[emitter] ${this.options?.name} no comparator option but received same value!
+      if (this.value && compare(this.value, next)) {
+        return;
+      }
+    } else {
+      if (this.value === next) {
+        if (process.env.NODE_ENV === "development") {
+          console.warn(`[emitter] ${this.options?.name} no comparator option but received same value!
             
 this will emit the same value again, which can be desirable, but we warn to ensure it's not unintended:
 
 - if you want this behavior, add { comparator: isEqualNever }
 - if you want only non-equal values: { comparator: isEqualIdentity }
 - if you want only deeply non-equal values: { comparator: isEqualDeep }`);
-    if (this.value = next, import_constants.DEBUG_LEVEL > 1 && !this.options?.silent) {
-      const name = this.options?.name;
-      console.groupCollapsed(`\u{1F4E3} ${name}`), console.info(next), console.trace("trace >"), console.groupEnd();
+        }
+      }
+    }
+    this.value = next;
+    if (import_constants.DEBUG_LEVEL > 1) {
+      if (!this.options?.silent) {
+        const name = this.options?.name;
+        console.groupCollapsed(`\u{1F4E3} ${name}`);
+        console.info(next);
+        console.trace(`trace >`);
+        console.groupEnd();
+      }
     }
     this.disposables.forEach(cb => cb(next));
   };
-  nextValue = () => new Promise(res => {
-    const dispose = this.listen(val => {
-      dispose(), res(val);
+  nextValue = () => {
+    return new Promise(res => {
+      const dispose = this.listen(val => {
+        dispose();
+        res(val);
+      });
     });
-  });
+  };
 }
 function createGlobalEmitter(name, defaultValue, options) {
   return (0, import_globalValue.globalValue)(name, () => createEmitter(name, defaultValue, options));
@@ -103,107 +129,151 @@ function createEmitter(name, defaultValue, options) {
   });
 }
 const useEmitter = (emitter, cb, args) => {
-    const getCallback = useGet(cb);
-    (0, import_react.useLayoutEffect)(() => emitter.listen(val => {
+  const getCallback = useGet(cb);
+  (0, import_react.useLayoutEffect)(() => {
+    return emitter.listen(val => {
       try {
         getCallback()(val);
       } catch (err) {
         (0, import_abortable.handleAbortError)(err);
       }
-    }), [emitter, getCallback]);
-  },
-  useEmitterValue = (emitter, options) => {
-    const disabled = options?.disable,
-      [state, setState] = (0, import_react.useState)(() => emitter.value);
-    return (0, import_react.useLayoutEffect)(() => {
-      if (!disabled) return emitter.value !== state && setState(emitter.value), emitter.listen(setState);
-    }, [state, disabled, emitter]), state;
-  },
-  useEmitterSelector = (emitter, selector, options, args = import_constants.EMPTY_ARRAY) => {
-    const [state, setState] = (0, import_react.useState)(() => selector(emitter.value)),
-      disabled = options?.disable,
-      getSelector = useGet(selector);
-    if (options?.lazy !== !0) {
-      const next = selector(emitter.value);
-      next !== state && setState(next);
+    });
+  }, [emitter, getCallback]);
+};
+const useEmitterValue = (emitter, options) => {
+  const disabled = options?.disable;
+  const [state, setState] = (0, import_react.useState)(() => emitter.value);
+  (0, import_react.useLayoutEffect)(() => {
+    if (disabled) return;
+    if (emitter.value !== state) {
+      setState(emitter.value);
     }
-    return (0, import_react.useLayoutEffect)(() => {
-      if (!disabled) return emitter.listen(val => {
-        try {
-          const next = (args !== import_constants.EMPTY_ARRAY ? selector : getSelector())(val);
-          setState(next);
-        } catch (error) {
-          if (error instanceof import_errors.AbortError) return;
-          throw error;
+    return emitter.listen(setState);
+  }, [state, disabled, emitter]);
+  return state;
+};
+const useEmitterSelector = (emitter, selector, options, args = import_constants.EMPTY_ARRAY) => {
+  const [state, setState] = (0, import_react.useState)(() => selector(emitter.value));
+  const disabled = options?.disable;
+  const getSelector = useGet(selector);
+  if (options?.lazy !== true) {
+    const next = selector(emitter.value);
+    if (next !== state) {
+      setState(next);
+    }
+  }
+  (0, import_react.useLayoutEffect)(() => {
+    if (disabled) return;
+    return emitter.listen(val => {
+      try {
+        const selectorFn = args !== import_constants.EMPTY_ARRAY ? selector : getSelector();
+        const next = selectorFn(val);
+        setState(next);
+      } catch (error) {
+        if (error instanceof import_errors.AbortError) {
+          return;
         }
-      });
-    }, [disabled, emitter, getSelector, ...args]), state;
-  },
-  useEmittersSelector = (emitters, selector, options) => {
-    const getSelector = useGet(selector),
-      disabled = options?.disable,
-      [state, setState] = (0, import_react.useState)(() => {
-        const values = emitters.map(e => e.value);
-        return getSelector()(values);
-      });
-    return (0, import_react.useLayoutEffect)(() => {
-      if (disabled) return;
-      const handler = () => {
-          const values = emitters.map(e => e.value);
-          try {
-            const next = getSelector()(values);
-            setState(prev => options?.isEqual?.(prev, next) || (0, import_dequal.dequal)(prev, next) ? prev : next);
-          } catch (error) {
-            if (error instanceof import_errors.AbortError) return;
-            throw error;
+        throw error;
+      }
+    });
+  }, [disabled, emitter, getSelector, ...args]);
+  return state;
+};
+const useEmittersSelector = (emitters, selector, options) => {
+  const getSelector = useGet(selector);
+  const disabled = options?.disable;
+  const [state, setState] = (0, import_react.useState)(() => {
+    const values = emitters.map(e => e.value);
+    return getSelector()(values);
+  });
+  (0, import_react.useLayoutEffect)(() => {
+    if (disabled) {
+      return;
+    }
+    const handler = () => {
+      const values = emitters.map(e => e.value);
+      try {
+        const next = getSelector()(values);
+        setState(prev => {
+          if (options?.isEqual?.(prev, next)) {
+            return prev;
+          }
+          if ((0, import_dequal.dequal)(prev, next)) {
+            return prev;
           }
-        },
-        disposals = emitters.map(emitter => emitter.listen(handler));
-      return () => {
-        disposals.forEach(d => d());
-      };
-    }, [disabled, getSelector, ...emitters]), state;
-  },
-  createUseEmitter = emitter => (cb, args) => useEmitter(emitter, cb, args),
-  createUseSelector = emitter => (selector, options, args) => useEmitterSelector(emitter, selector, options, args);
+          return next;
+        });
+      } catch (error) {
+        if (error instanceof import_errors.AbortError) {
+          return;
+        }
+        throw error;
+      }
+    };
+    const disposals = emitters.map(emitter => emitter.listen(handler));
+    return () => {
+      disposals.forEach(d => d());
+    };
+  }, [disabled, getSelector, ...emitters]);
+  return state;
+};
+const createUseEmitter = emitter => {
+  return (cb, args) => useEmitter(emitter, cb, args);
+};
+const createUseSelector = emitter => {
+  return (selector, options, args) => {
+    return useEmitterSelector(emitter, selector, options, args);
+  };
+};
 function createContextualEmitter(name, defaultValue, defaultOptions) {
-  const id = Math.random().toString(36),
-    EmitterContext = (0, import_createGlobalContext.createGlobalContext)(`contextual-emitter/${id}`, null);
-  return [() => {
+  const id = Math.random().toString(36);
+  const EmitterContext = (0, import_createGlobalContext.createGlobalContext)(`contextual-emitter/${id}`, null);
+  const useContextEmitter = () => {
     const emitter = (0, import_react.use)(EmitterContext);
-    if (!emitter) throw new Error("useContextEmitter must be used within an EmitterProvider");
+    if (!emitter) {
+      throw new Error("useContextEmitter must be used within an EmitterProvider");
+    }
     return emitter;
-  }, props => {
+  };
+  const ProvideEmitter = props => {
     const {
-        children,
-        value,
-        silent
-      } = props,
-      [emitter] = (0, import_react.useState)(() => new Emitter(value ?? defaultValue, {
-        name,
-        silent,
-        ...defaultOptions
-      }));
-    return (0, import_react.useLayoutEffect)(() => {
-      value !== void 0 && value !== emitter.value && emitter.emit(value);
-    }, [value, emitter]), /* @__PURE__ */(0, import_jsx_runtime.jsx)(EmitterContext.Provider, {
+      children,
+      value,
+      silent
+    } = props;
+    const [emitter] = (0, import_react.useState)(() => new Emitter(value ?? defaultValue, {
+      name,
+      silent,
+      ...defaultOptions
+    }));
+    (0, import_react.useLayoutEffect)(() => {
+      if (value !== void 0 && value !== emitter.value) {
+        emitter.emit(value);
+      }
+    }, [value, emitter]);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(EmitterContext.Provider, {
       value: emitter,
       children
     });
-  }];
+  };
+  return [useContextEmitter, ProvideEmitter];
 }
 const HMRCache = process.env.NODE_ENV === "development" ? /* @__PURE__ */new Map() : null;
 function setCache(emitter, value) {
   const name = emitter.options?.name;
   if (!name) return;
   const cache = HMRCache?.get(name);
-  cache && (cache.currentValue = value);
+  if (!cache) return;
+  cache.currentValue = value;
 }
 function createOrUpdateCache(name, defaultValueProp) {
-  const existing = HMRCache?.get(name),
-    defaultValue = (0, import_dequal.dequal)(existing?.originalDefaultValue, defaultValueProp) ? existing?.currentValue : defaultValueProp;
-  return existing || HMRCache?.set(name, {
-    originalDefaultValue: defaultValueProp,
-    currentValue: defaultValue
-  }), defaultValue;
+  const existing = HMRCache?.get(name);
+  const defaultValue = (0, import_dequal.dequal)(existing?.originalDefaultValue, defaultValueProp) ? existing?.currentValue : defaultValueProp;
+  if (!existing) {
+    HMRCache?.set(name, {
+      originalDefaultValue: defaultValueProp,
+      currentValue: defaultValue
+    });
+  }
+  return defaultValue;
 }