redext/dist/hooks/useDeepCallback.js

A simple global store based on React Context and Hooks

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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: 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;
};
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: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/hooks/useDeepCallback.ts
var useDeepCallback_exports = {};
__export(useDeepCallback_exports, {
  default: () => useDeepCallback_default
});
module.exports = __toCommonJS(useDeepCallback_exports);
var import_react2 = __toESM(require("react"));

// src/hooks/useDeepMemoize.ts
var import_react = require("react");

// src/utils/deepEqual.ts
var equal = (a, b) => {
  let ctor;
  let len;
  if (a === b) {
    return true;
  }
  if (a && b && (ctor = a.constructor) === b.constructor) {
    if (ctor === Date) {
      return a.getTime() === b.getTime();
    }
    if (ctor === RegExp) {
      return a.toString() === b.toString();
    }
    if (ctor === Array && (len = a.length) === b.length) {
      while (len-- && equal(a[len], b[len])) ;
      return len === -1;
    }
    if (ctor === Object) {
      if (Object.keys(a).length !== Object.keys(b).length) {
        return false;
      }
      for (len in a) {
        if (!(len in b) || !equal(a[len], b[len])) {
          return false;
        }
      }
      return true;
    }
  }
  return a !== a && b !== b;
};
function deepEqual(a, b) {
  try {
    return equal(a, b);
  } catch (error) {
    if (error.message && error.message.match(/stack|recursion/i) || error.number === -2146828260) {
      console.warn("Warning: deepEqual does not handle circular references.", error.name, error.message);
      return false;
    }
    throw error;
  }
}

// src/hooks/useDeepMemoize.ts
var useDeepMemoize = (value) => {
  const ref = (0, import_react.useRef)([]);
  if (!deepEqual(value, ref.current)) {
    ref.current = value;
  }
  return ref.current;
};
var useDeepMemoize_default = useDeepMemoize;

// src/utils/checkDeps.ts
var isPrimitive = (val) => {
  return val == null || /^[sbn]/.test(typeof val);
};
var checkDeps = (deps, name) => {
  const hookName = `React.${name.replace(/Deep/, "")}`;
  if (!deps || deps.length === 0) {
    console.warn(`${name} should not be used with no dependencies. Use ${hookName} instead.`);
  }
  if (deps.every(isPrimitive)) {
    console.warn(`${name} should not be used with dependencies that are all primitive values. Use ${hookName} instead.`);
  }
};
var checkDeps_default = checkDeps;

// src/hooks/useDeepCallback.ts
var useDeepCallback = (callback, dependencies) => {
  if (process.env.NODE_ENV !== "production") {
    checkDeps_default(dependencies, "useDeepCallback");
  }
  return import_react2.default.useCallback(callback, useDeepMemoize_default(dependencies));
};
var useDeepCallback_default = useDeepCallback;