import memoize from 'micro-memoize';
import { deepEqual, shallowEqual, sameValueZeroEqual } from 'fast-equals';

function _extends() {
  _extends = Object.assign ? Object.assign.bind() : function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
    return target;
  };
  return _extends.apply(this, arguments);
}
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}

/**
 * @private
 *
 * @constant DEFAULT_OPTIONS
 */
var DEFAULT_OPTIONS = {
  isDeepEqual: false,
  isPromise: false,
  isReact: false,
  isSerialized: false,
  isShallowEqual: false,
  matchesArg: undefined,
  matchesKey: undefined,
  maxAge: undefined,
  maxArgs: undefined,
  maxSize: 1,
  onExpire: undefined,
  profileName: undefined,
  serializer: undefined,
  updateCacheForKey: undefined,
  transformArgs: undefined,
  updateExpire: false
};

/**
 * @private
 *
 * @description
 * method to combine functions and return a single function that fires them all
 *
 * @param functions the functions to compose
 * @returns the composed function
 */
function combine() {
  for (var _len = arguments.length, functions = new Array(_len), _key = 0; _key < _len; _key++) {
    functions[_key] = arguments[_key];
  }
  return functions.reduce(function (f, g) {
    if (typeof f === 'function') {
      return typeof g === 'function' ? function () {
        f.apply(this, arguments);
        g.apply(this, arguments);
      } : f;
    }
    if (typeof g === 'function') {
      return g;
    }
  });
}

/**
 * @private
 *
 * @description
 * method to compose functions and return a single function
 *
 * @param functions the functions to compose
 * @returns the composed function
 */
function compose() {
  for (var _len2 = arguments.length, functions = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    functions[_key2] = arguments[_key2];
  }
  return functions.reduce(function (f, g) {
    if (typeof f === 'function') {
      return typeof g === 'function' ? function () {
        return f(g.apply(this, arguments));
      } : f;
    }
    if (typeof g === 'function') {
      return g;
    }
  });
}

/**
 * @private
 *
 * @description
 * find the index of the expiration based on the key
 *
 * @param expirations the list of expirations
 * @param key the key to match
 * @returns the index of the expiration
 */
function findExpirationIndex(expirations, key) {
  for (var index = 0; index < expirations.length; index++) {
    if (expirations[index].key === key) {
      return index;
    }
  }
  return -1;
}

/**
 * @private
 *
 * @description
 * create function that finds the index of the key in the list of cache keys
 *
 * @param isEqual the function to test individual argument equality
 * @param isMatchingKey the function to test full key equality
 * @returns the function that finds the index of the key
 */
function createFindKeyIndex(isEqual, isMatchingKey) {
  var areKeysEqual = typeof isMatchingKey === 'function' ? isMatchingKey : function (cacheKey, key) {
    for (var index = 0; index < key.length; index++) {
      if (!isEqual(cacheKey[index], key[index])) {
        return false;
      }
    }
    return true;
  };
  return function (keys, key) {
    for (var keysIndex = 0; keysIndex < keys.length; keysIndex++) {
      if (keys[keysIndex].length === key.length && areKeysEqual(keys[keysIndex], key)) {
        return keysIndex;
      }
    }
    return -1;
  };
}
/**
 * @private
 *
 * @description
 * merge two options objects, combining or composing functions as necessary
 *
 * @param originalOptions the options that already exist on the method
 * @param newOptions the new options to merge
 * @returns the merged options
 */
function mergeOptions(originalOptions, newOptions) {
  if (!newOptions || newOptions === DEFAULT_OPTIONS) {
    return originalOptions;
  }
  return _extends({}, originalOptions, newOptions, {
    onCacheAdd: combine(originalOptions.onCacheAdd, newOptions.onCacheAdd),
    onCacheChange: combine(originalOptions.onCacheChange, newOptions.onCacheChange),
    onCacheHit: combine(originalOptions.onCacheHit, newOptions.onCacheHit),
    transformArgs: compose(originalOptions.transformArgs, newOptions.transformArgs)
  });
}
function isMoized(fn) {
  return typeof fn === 'function' && fn.isMoized;
}
function setName(fn, originalFunctionName, profileName) {
  try {
    var name = profileName || originalFunctionName || 'anonymous';
    Object.defineProperty(fn, 'name', {
      configurable: true,
      enumerable: false,
      value: "moized(" + name + ")",
      writable: true
    });
  } catch (_unused) {
    // For engines where `function.name` is not configurable, do nothing.
  }
}

/**
 * @private
 *
 * @description
 * clear an active expiration and remove it from the list if applicable
 *
 * @param expirations the list of expirations
 * @param key the key to clear
 * @param shouldRemove should the expiration be removed from the list
 */
function clearExpiration(expirations, key, shouldRemove) {
  var expirationIndex = findExpirationIndex(expirations, key);
  if (expirationIndex !== -1) {
    clearTimeout(expirations[expirationIndex].timeoutId);
    if (shouldRemove) {
      expirations.splice(expirationIndex, 1);
    }
  }
}

/**
 * @private
 *
 * @description
 * Create the timeout for the given expiration method. If the ability to `unref`
 * exists, then apply it to avoid process locks in NodeJS.
 *
 * @param expirationMethod the method to fire upon expiration
 * @param maxAge the time to expire after
 * @returns the timeout ID
 */
function createTimeout(expirationMethod, maxAge) {
  var timeoutId = setTimeout(expirationMethod, maxAge);
  if (typeof timeoutId.unref === 'function') {
    timeoutId.unref();
  }
  return timeoutId;
}

/**
 * @private
 *
 * @description
 * create a function that, when an item is added to the cache, adds an expiration for it
 *
 * @param expirations the mutable expirations array
 * @param options the options passed on initialization
 * @param isEqual the function to check argument equality
 * @param isMatchingKey the function to check complete key equality
 * @returns the onCacheAdd function to handle expirations
 */
function createOnCacheAddSetExpiration(expirations, options, isEqual, isMatchingKey) {
  var maxAge = options.maxAge;
  return function onCacheAdd(cache, moizedOptions, moized) {
    var key = cache.keys[0];
    if (findExpirationIndex(expirations, key) === -1) {
      var expirationMethod = function expirationMethod() {
        var findKeyIndex = createFindKeyIndex(isEqual, isMatchingKey);
        var keyIndex = findKeyIndex(cache.keys, key);
        var value = cache.values[keyIndex];
        if (~keyIndex) {
          cache.keys.splice(keyIndex, 1);
          cache.values.splice(keyIndex, 1);
          if (typeof options.onCacheChange === 'function') {
            options.onCacheChange(cache, moizedOptions, moized);
          }
        }
        clearExpiration(expirations, key, true);
        if (typeof options.onExpire === 'function' && options.onExpire(key) === false) {
          cache.keys.unshift(key);
          cache.values.unshift(value);
          onCacheAdd(cache, moizedOptions, moized);
          if (typeof options.onCacheChange === 'function') {
            options.onCacheChange(cache, moizedOptions, moized);
          }
        }
      };
      expirations.push({
        expirationMethod: expirationMethod,
        key: key,
        timeoutId: createTimeout(expirationMethod, maxAge)
      });
    }
  };
}

/**
 * @private
 *
 * @description
 * creates a function that, when a cache item is hit, reset the expiration
 *
 * @param expirations the mutable expirations array
 * @param options the options passed on initialization
 * @returns the onCacheAdd function to handle expirations
 */
function createOnCacheHitResetExpiration(expirations, options) {
  return function onCacheHit(cache) {
    var key = cache.keys[0];
    var expirationIndex = findExpirationIndex(expirations, key);
    if (~expirationIndex) {
      clearExpiration(expirations, key, false);
      expirations[expirationIndex].timeoutId = createTimeout(expirations[expirationIndex].expirationMethod, options.maxAge);
    }
  };
}

/**
 * @private
 *
 * @description
 * get the micro-memoize options specific to the maxAge option
 *
 * @param expirations the expirations for the memoized function
 * @param options the options passed to the moizer
 * @param isEqual the function to test equality of the key on a per-argument basis
 * @param isMatchingKey the function to test equality of the whole key
 * @returns the object of options based on the entries passed
 */
function getMaxAgeOptions(expirations, options, isEqual, isMatchingKey) {
  var onCacheAdd = typeof options.maxAge === 'number' && isFinite(options.maxAge) ? createOnCacheAddSetExpiration(expirations, options, isEqual, isMatchingKey) : undefined;
  return {
    onCacheAdd: onCacheAdd,
    onCacheHit: onCacheAdd && options.updateExpire ? createOnCacheHitResetExpiration(expirations, options) : undefined
  };
}

var statsCache = {
  anonymousProfileNameCounter: 1,
  isCollectingStats: false,
  profiles: {}
};
var hasWarningDisplayed = false;
function clearStats(profileName) {
  if (profileName) {
    delete statsCache.profiles[profileName];
  } else {
    statsCache.profiles = {};
  }
}

/**
 * @private
 *
 * @description
 * activate stats collection
 *
 * @param isCollectingStats should stats be collected
 */
function collectStats(isCollectingStats) {
  if (isCollectingStats === void 0) {
    isCollectingStats = true;
  }
  statsCache.isCollectingStats = isCollectingStats;
}

/**
 * @private
 *
 * @description
 * create a function that increments the number of calls for the specific profile
 */
function createOnCacheAddIncrementCalls(options) {
  var profileName = options.profileName;
  return function () {
    if (profileName && !statsCache.profiles[profileName]) {
      statsCache.profiles[profileName] = {
        calls: 0,
        hits: 0
      };
    }
    statsCache.profiles[profileName].calls++;
  };
}

/**
 * @private
 *
 * @description
 * create a function that increments the number of calls and cache hits for the specific profile
 */
function createOnCacheHitIncrementCallsAndHits(options) {
  return function () {
    var profiles = statsCache.profiles;
    var profileName = options.profileName;
    if (!profiles[profileName]) {
      profiles[profileName] = {
        calls: 0,
        hits: 0
      };
    }
    profiles[profileName].calls++;
    profiles[profileName].hits++;
  };
}

/**
 * @private
 *
 * @description
 * get the profileName for the function when one is not provided
 *
 * @param fn the function to be memoized
 * @returns the derived profileName for the function
 */
function getDefaultProfileName(fn) {
  return fn.displayName || fn.name || "Anonymous " + statsCache.anonymousProfileNameCounter++;
}

/**
 * @private
 *
 * @description
 * get the usage percentage based on the number of hits and total calls
 *
 * @param calls the number of calls made
 * @param hits the number of cache hits when called
 * @returns the usage as a percentage string
 */
function getUsagePercentage(calls, hits) {
  return calls ? (hits / calls * 100).toFixed(4) + "%" : '0.0000%';
}

/**
 * @private
 *
 * @description
 * get the statistics for a given method or all methods
 *
 * @param [profileName] the profileName to get the statistics for (get all when not provided)
 * @returns the object with stats information
 */
function getStats(profileName) {
  if (!statsCache.isCollectingStats && !hasWarningDisplayed) {
    console.warn('Stats are not currently being collected, please run "collectStats" to enable them.'); // eslint-disable-line no-console

    hasWarningDisplayed = true;
  }
  var profiles = statsCache.profiles;
  if (profileName) {
    if (!profiles[profileName]) {
      return {
        calls: 0,
        hits: 0,
        usage: '0.0000%'
      };
    }
    var profile = profiles[profileName];
    return _extends({}, profile, {
      usage: getUsagePercentage(profile.calls, profile.hits)
    });
  }
  var completeStats = Object.keys(statsCache.profiles).reduce(function (completeProfiles, profileName) {
    completeProfiles.calls += profiles[profileName].calls;
    completeProfiles.hits += profiles[profileName].hits;
    return completeProfiles;
  }, {
    calls: 0,
    hits: 0
  });
  return _extends({}, completeStats, {
    profiles: Object.keys(profiles).reduce(function (computedProfiles, profileName) {
      computedProfiles[profileName] = getStats(profileName);
      return computedProfiles;
    }, {}),
    usage: getUsagePercentage(completeStats.calls, completeStats.hits)
  });
}

/**
 * @private
 *
 * @function getStatsOptions
 *
 * @description
 * get the options specific to storing statistics
 *
 * @param {Options} options the options passed to the moizer
 * @returns {Object} the options specific to keeping stats
 */
function getStatsOptions(options) {
  return statsCache.isCollectingStats ? {
    onCacheAdd: createOnCacheAddIncrementCalls(options),
    onCacheHit: createOnCacheHitIncrementCallsAndHits(options)
  } : {};
}

var ALWAYS_SKIPPED_PROPERTIES = {
  arguments: true,
  callee: true,
  caller: true,
  constructor: true,
  length: true,
  name: true,
  prototype: true
};

/**
 * @private
 *
 * @description
 * copy the static properties from the original function to the moized
 * function
 *
 * @param originalFn the function copying from
 * @param newFn the function copying to
 * @param skippedProperties the list of skipped properties, if any
 */
function copyStaticProperties(originalFn, newFn, skippedProperties) {
  if (skippedProperties === void 0) {
    skippedProperties = [];
  }
  Object.getOwnPropertyNames(originalFn).forEach(function (property) {
    if (!ALWAYS_SKIPPED_PROPERTIES[property] && skippedProperties.indexOf(property) === -1) {
      var descriptor = Object.getOwnPropertyDescriptor(originalFn, property);
      if (descriptor.get || descriptor.set) {
        Object.defineProperty(newFn, property, descriptor);
      } else {
        // @ts-expect-error - properites may not align
        newFn[property] = originalFn[property];
      }
    }
  });
}

/**
 * @private
 *
 * @description
 * add methods to the moized fuction object that allow extra features
 *
 * @param memoized the memoized function from micro-memoize
 */
function addInstanceMethods(memoized, _ref) {
  var expirations = _ref.expirations;
  var options = memoized.options;
  var findKeyIndex = createFindKeyIndex(options.isEqual, options.isMatchingKey);
  var moized = memoized;
  moized.clear = function () {
    var onCacheChange = moized._microMemoizeOptions.onCacheChange,
      cache = moized.cache;
    cache.keys.length = 0;
    cache.values.length = 0;
    if (onCacheChange) {
      onCacheChange(cache, moized.options, moized);
    }
    return true;
  };
  moized.clearStats = function () {
    clearStats(moized.options.profileName);
  };
  moized.get = function (key) {
    var transformKey = moized._microMemoizeOptions.transformKey,
      cache = moized.cache;
    var cacheKey = transformKey ? transformKey(key) : key;
    var keyIndex = findKeyIndex(cache.keys, cacheKey);
    return keyIndex !== -1 ? moized.apply(this, key) : undefined;
  };
  moized.getStats = function () {
    return getStats(moized.options.profileName);
  };
  moized.has = function (key) {
    var transformKey = moized._microMemoizeOptions.transformKey;
    var cacheKey = transformKey ? transformKey(key) : key;
    return findKeyIndex(moized.cache.keys, cacheKey) !== -1;
  };
  moized.keys = function () {
    return moized.cacheSnapshot.keys;
  };
  moized.remove = function (key) {
    var _moized$_microMemoize = moized._microMemoizeOptions,
      onCacheChange = _moized$_microMemoize.onCacheChange,
      transformKey = _moized$_microMemoize.transformKey,
      cache = moized.cache;
    var keyIndex = findKeyIndex(cache.keys, transformKey ? transformKey(key) : key);
    if (keyIndex === -1) {
      return false;
    }
    var existingKey = cache.keys[keyIndex];
    cache.keys.splice(keyIndex, 1);
    cache.values.splice(keyIndex, 1);
    if (onCacheChange) {
      onCacheChange(cache, moized.options, moized);
    }
    clearExpiration(expirations, existingKey, true);
    return true;
  };
  moized.set = function (key, value) {
    var _microMemoizeOptions = moized._microMemoizeOptions,
      cache = moized.cache,
      options = moized.options;
    var onCacheAdd = _microMemoizeOptions.onCacheAdd,
      onCacheChange = _microMemoizeOptions.onCacheChange,
      transformKey = _microMemoizeOptions.transformKey;
    var cacheKey = transformKey ? transformKey(key) : key;
    var keyIndex = findKeyIndex(cache.keys, cacheKey);
    if (keyIndex === -1) {
      var cutoff = options.maxSize - 1;
      if (cache.size > cutoff) {
        cache.keys.length = cutoff;
        cache.values.length = cutoff;
      }
      cache.keys.unshift(cacheKey);
      cache.values.unshift(value);
      if (options.isPromise) {
        cache.updateAsyncCache(moized);
      }
      if (onCacheAdd) {
        onCacheAdd(cache, options, moized);
      }
      if (onCacheChange) {
        onCacheChange(cache, options, moized);
      }
    } else {
      var existingKey = cache.keys[keyIndex];
      cache.values[keyIndex] = value;
      if (keyIndex > 0) {
        cache.orderByLru(existingKey, value, keyIndex);
      }
      if (options.isPromise) {
        cache.updateAsyncCache(moized);
      }
      if (typeof onCacheChange === 'function') {
        onCacheChange(cache, options, moized);
      }
    }
  };
  moized.values = function () {
    return moized.cacheSnapshot.values;
  };
}

/**
 * @private
 *
 * @description
 * add propeties to the moized fuction object that surfaces extra information
 *
 * @param memoized the memoized function
 * @param expirations the list of expirations for cache items
 * @param options the options passed to the moizer
 * @param originalFunction the function that is being memoized
 */
function addInstanceProperties(memoized, _ref2) {
  var expirations = _ref2.expirations,
    moizeOptions = _ref2.options,
    originalFunction = _ref2.originalFunction;
  var microMemoizeOptions = memoized.options;
  Object.defineProperties(memoized, {
    _microMemoizeOptions: {
      configurable: true,
      get: function get() {
        return microMemoizeOptions;
      }
    },
    cacheSnapshot: {
      configurable: true,
      get: function get() {
        var currentCache = memoized.cache;
        return {
          keys: currentCache.keys.slice(0),
          size: currentCache.size,
          values: currentCache.values.slice(0)
        };
      }
    },
    expirations: {
      configurable: true,
      get: function get() {
        return expirations;
      }
    },
    expirationsSnapshot: {
      configurable: true,
      get: function get() {
        return expirations.slice(0);
      }
    },
    isMoized: {
      configurable: true,
      get: function get() {
        return true;
      }
    },
    options: {
      configurable: true,
      get: function get() {
        return moizeOptions;
      }
    },
    originalFunction: {
      configurable: true,
      get: function get() {
        return originalFunction;
      }
    }
  });
  var moized = memoized;
  copyStaticProperties(originalFunction, moized);
}

/**
 * @private
 *
 * @description
 * add methods and properties to the memoized function for more features
 *
 * @param memoized the memoized function
 * @param configuration the configuration object for the instance
 * @returns the memoized function passed
 */
function createMoizeInstance(memoized, configuration) {
  addInstanceMethods(memoized, configuration);
  addInstanceProperties(memoized, configuration);
  return memoized;
}

// This was stolen from React internals, which allows us to create React elements without needing
// a dependency on the React library itself.
var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol.for ? Symbol.for('react.element') : 0xeac7;

/**
 * @private
 *
 * @description
 * Create a component that memoizes based on `props` and legacy `context`
 * on a per-instance basis. This requires creating a component class to
 * store the memoized function. The cost is quite low, and avoids the
 * need to have access to the React dependency by basically re-creating
 * the basic essentials for a component class and the results of the
 * `createElement` function.
 *
 * @param moizer the top-level moize method
 * @param fn the component to memoize
 * @param options the memoization options
 * @returns the memoized component
 */
function createMoizedComponent(moizer, fn, options) {
  /**
   * This is a hack override setting the necessary options
   * for a React component to be memoized. In the main `moize`
   * method, if the `isReact` option is set it is short-circuited
   * to call this function, and these overrides allow the
   * necessary transformKey method to be derived.
   *
   * The order is based on:
   * 1) Set the necessary aspects of transformKey for React components.
   * 2) Allow setting of other options and overrides of those aspects
   *    if desired (for example, `isDeepEqual` will use deep equality).
   * 3) Always set `isReact` to false to prevent infinite loop.
   */
  var reactMoizer = moizer(_extends({
    maxArgs: 2,
    isShallowEqual: true
  }, options, {
    isReact: false
  }));
  if (!fn.displayName) {
    // @ts-ignore - allow setting of displayName
    fn.displayName = fn.name || 'Component';
  }
  function Moized(props, context, updater) {
    this.props = props;
    this.context = context;
    this.updater = updater;
    this.MoizedComponent = reactMoizer(fn);
  }
  Moized.prototype.isReactComponent = {};
  Moized.prototype.render = function () {
    return {
      $$typeof: REACT_ELEMENT_TYPE,
      type: this.MoizedComponent,
      props: this.props,
      ref: null,
      key: null,
      _owner: null
    };
  };
  copyStaticProperties(fn, Moized, ['contextType', 'contextTypes']);
  Moized.displayName = "Moized(" + (fn.displayName || fn.name || 'Component') + ")";
  setName(Moized, fn.name, options.profileName);
  return Moized;
}

function createGetInitialArgs(size) {
  /**
   * @private
   *
   * @description
   * take the first N number of items from the array (faster than slice)
   *
   * @param args the args to take from
   * @returns the shortened list of args as an array
   */
  return function (args) {
    if (size >= args.length) {
      return args;
    }
    if (size === 0) {
      return [];
    }
    if (size === 1) {
      return [args[0]];
    }
    if (size === 2) {
      return [args[0], args[1]];
    }
    if (size === 3) {
      return [args[0], args[1], args[2]];
    }
    var clone = [];
    for (var index = 0; index < size; index++) {
      clone[index] = args[index];
    }
    return clone;
  };
}

/**
 * @function getCutoff
 *
 * @description
 * faster `Array.prototype.indexOf` implementation build for slicing / splicing
 *
 * @param array the array to match the value in
 * @param value the value to match
 * @returns the matching index, or -1
 */
function getCutoff(array, value) {
  var length = array.length;
  for (var index = 0; index < length; ++index) {
    if (array[index] === value) {
      return index + 1;
    }
  }
  return 0;
}

/**
 * @private
 *
 * @description
 * custom replacer for the stringify function
 *
 * @returns if function then toString of it, else the value itself
 */
function createDefaultReplacer() {
  var cache = [];
  var keys = [];
  return function defaultReplacer(key, value) {
    var type = typeof value;
    if (type === 'function' || type === 'symbol') {
      return value.toString();
    }
    if (typeof value === 'object') {
      if (cache.length) {
        var thisCutoff = getCutoff(cache, this);
        if (thisCutoff === 0) {
          cache[cache.length] = this;
        } else {
          cache.splice(thisCutoff);
          keys.splice(thisCutoff);
        }
        keys[keys.length] = key;
        var valueCutoff = getCutoff(cache, value);
        if (valueCutoff !== 0) {
          return "[ref=" + (keys.slice(0, valueCutoff).join('.') || '.') + "]";
        }
      } else {
        cache[0] = value;
        keys[0] = key;
      }
      return value;
    }
    return '' + value;
  };
}

/**
 * @private
 *
 * @description
 * get the stringified version of the argument passed
 *
 * @param arg argument to stringify
 * @returns the stringified argument
 */
function getStringifiedArgument(arg) {
  var typeOfArg = typeof arg;
  return arg && (typeOfArg === 'object' || typeOfArg === 'function') ? JSON.stringify(arg, createDefaultReplacer()) : arg;
}

/**
 * @private
 *
 * @description
 * serialize the arguments passed
 *
 * @param options the options passed to the moizer
 * @param options.maxArgs the cap on the number of arguments used in serialization
 * @returns argument serialization method
 */
function defaultArgumentSerializer(args) {
  var key = '|';
  for (var index = 0; index < args.length; index++) {
    key += getStringifiedArgument(args[index]) + '|';
  }
  return [key];
}

/**
 * @private
 *
 * @description
 * based on the options passed, either use the serializer passed or generate the internal one
 *
 * @param options the options passed to the moized function
 * @returns the function to use in serializing the arguments
 */
function getSerializerFunction(options) {
  return typeof options.serializer === 'function' ? options.serializer : defaultArgumentSerializer;
}

/**
 * @private
 *
 * @description
 * are the serialized keys equal to one another
 *
 * @param cacheKey the cache key to compare
 * @param key the key to test
 * @returns are the keys equal
 */
function getIsSerializedKeyEqual(cacheKey, key) {
  return cacheKey[0] === key[0];
}

function createOnCacheOperation(fn) {
  if (typeof fn === 'function') {
    return function (_cacheIgnored, _microMemoizeOptionsIgnored, memoized) {
      return fn(memoized.cache, memoized.options, memoized);
    };
  }
}

/**
 * @private
 *
 * @description
 * get the isEqual method passed to micro-memoize
 *
 * @param options the options passed to the moizer
 * @returns the isEqual method to apply
 */
function getIsEqual(options) {
  return options.matchesArg || options.isDeepEqual && deepEqual || options.isShallowEqual && shallowEqual || sameValueZeroEqual;
}

/**
 * @private
 *
 * @description
 * get the isEqual method passed to micro-memoize
 *
 * @param options the options passed to the moizer
 * @returns the isEqual method to apply
 */
function getIsMatchingKey(options) {
  return options.matchesKey || options.isSerialized && getIsSerializedKeyEqual || undefined;
}

/**
 * @private
 *
 * @description
 * get the function that will transform the key based on the arguments passed
 *
 * @param options the options passed to the moizer
 * @returns the function to transform the key with
 */
function getTransformKey(options) {
  return compose(options.isSerialized && getSerializerFunction(options), typeof options.transformArgs === 'function' && options.transformArgs, typeof options.maxArgs === 'number' && createGetInitialArgs(options.maxArgs));
}

function createRefreshableMoized(moized) {
  var updateCacheForKey = moized.options.updateCacheForKey;

  /**
   * @private
   *
   * @description
   * Wrapper around already-`moize`d function which will intercept the memoization
   * and call the underlying function directly with the purpose of updating the cache
   * for the given key.
   *
   * Promise values use a tweak of the logic that exists at cache.updateAsyncCache, which
   * reverts to the original value if the promise is rejected and there was already a cached
   * value.
   */
  var refreshableMoized = function refreshableMoized() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    if (!updateCacheForKey(args)) {
      return moized.apply(this, args);
    }
    var result = moized.fn.apply(this, args);
    moized.set(args, result);
    return result;
  };
  copyStaticProperties(moized, refreshableMoized);
  return refreshableMoized;
}

var _excluded = ["matchesArg", "isDeepEqual", "isPromise", "isReact", "isSerialized", "isShallowEqual", "matchesKey", "maxAge", "maxArgs", "maxSize", "onCacheAdd", "onCacheChange", "onCacheHit", "onExpire", "profileName", "serializer", "updateCacheForKey", "transformArgs", "updateExpire"];
/**
 * @module moize
 */
/**
 * @description
 * memoize a function based its arguments passed, potentially improving runtime performance
 *
 * @example
 * import moize from 'moize';
 *
 * // standard implementation
 * const fn = (foo, bar) => `${foo} ${bar}`;
 * const memoizedFn = moize(fn);
 *
 * // implementation with options
 * const fn = async (id) => get(`http://foo.com/${id}`);
 * const memoizedFn = moize(fn, {isPromise: true, maxSize: 5});
 *
 * // implementation with convenience methods
 * const Foo = ({foo}) => <div>{foo}</div>;
 * const MemoizedFoo = moize.react(Foo);
 *
 * @param fn the function to memoized, or a list of options when currying
 * @param [options=DEFAULT_OPTIONS] the options to apply
 * @returns the memoized function
 */
var moize = function moize(fn, passedOptions) {
  var options = passedOptions || DEFAULT_OPTIONS;
  if (isMoized(fn)) {
    var moizeable = fn.originalFunction;
    var mergedOptions = mergeOptions(fn.options, options);
    return moize(moizeable, mergedOptions);
  }
  if (typeof fn === 'object') {
    return function (curriedFn, curriedOptions) {
      if (typeof curriedFn === 'function') {
        var _mergedOptions = mergeOptions(fn, curriedOptions);
        return moize(curriedFn, _mergedOptions);
      }
      var mergedOptions = mergeOptions(fn, curriedFn);
      return moize(mergedOptions);
    };
  }
  if (options.isReact) {
    return createMoizedComponent(moize, fn, options);
  }
  var coalescedOptions = _extends({}, DEFAULT_OPTIONS, options, {
    maxAge: typeof options.maxAge === 'number' && options.maxAge >= 0 ? options.maxAge : DEFAULT_OPTIONS.maxAge,
    maxArgs: typeof options.maxArgs === 'number' && options.maxArgs >= 0 ? options.maxArgs : DEFAULT_OPTIONS.maxArgs,
    maxSize: typeof options.maxSize === 'number' && options.maxSize >= 0 ? options.maxSize : DEFAULT_OPTIONS.maxSize,
    profileName: options.profileName || getDefaultProfileName(fn)
  });
  var expirations = [];
  coalescedOptions.matchesArg;
    coalescedOptions.isDeepEqual;
    var isPromise = coalescedOptions.isPromise;
    coalescedOptions.isReact;
    coalescedOptions.isSerialized;
    coalescedOptions.isShallowEqual;
    coalescedOptions.matchesKey;
    coalescedOptions.maxAge;
    coalescedOptions.maxArgs;
    var maxSize = coalescedOptions.maxSize,
    onCacheAdd = coalescedOptions.onCacheAdd,
    onCacheChange = coalescedOptions.onCacheChange,
    onCacheHit = coalescedOptions.onCacheHit;
    coalescedOptions.onExpire;
    coalescedOptions.profileName;
    coalescedOptions.serializer;
    var updateCacheForKey = coalescedOptions.updateCacheForKey;
    coalescedOptions.transformArgs;
    coalescedOptions.updateExpire;
    var customOptions = _objectWithoutPropertiesLoose(coalescedOptions, _excluded);
  var isEqual = getIsEqual(coalescedOptions);
  var isMatchingKey = getIsMatchingKey(coalescedOptions);
  var maxAgeOptions = getMaxAgeOptions(expirations, coalescedOptions, isEqual, isMatchingKey);
  var statsOptions = getStatsOptions(coalescedOptions);
  var transformKey = getTransformKey(coalescedOptions);
  var microMemoizeOptions = _extends({}, customOptions, {
    isEqual: isEqual,
    isMatchingKey: isMatchingKey,
    isPromise: isPromise,
    maxSize: maxSize,
    onCacheAdd: createOnCacheOperation(combine(onCacheAdd, maxAgeOptions.onCacheAdd, statsOptions.onCacheAdd)),
    onCacheChange: createOnCacheOperation(onCacheChange),
    onCacheHit: createOnCacheOperation(combine(onCacheHit, maxAgeOptions.onCacheHit, statsOptions.onCacheHit)),
    transformKey: transformKey
  });
  var memoized = memoize(fn, microMemoizeOptions);
  var moized = createMoizeInstance(memoized, {
    expirations: expirations,
    options: coalescedOptions,
    originalFunction: fn
  });
  if (updateCacheForKey) {
    moized = createRefreshableMoized(moized);
  }
  setName(moized, fn.name, options.profileName);
  return moized;
};

/**
 * @function
 * @name clearStats
 * @memberof module:moize
 * @alias moize.clearStats
 *
 * @description
 * clear all existing stats stored
 */
moize.clearStats = clearStats;

/**
 * @function
 * @name collectStats
 * @memberof module:moize
 * @alias moize.collectStats
 *
 * @description
 * start collecting statistics
 */
moize.collectStats = collectStats;

/**
 * @function
 * @name compose
 * @memberof module:moize
 * @alias moize.compose
 *
 * @description
 * method to compose moized methods and return a single moized function
 *
 * @param moized the functions to compose
 * @returns the composed function
 */
moize.compose = function () {
  return compose.apply(void 0, arguments) || moize;
};

/**
 * @function
 * @name deep
 * @memberof module:moize
 * @alias moize.deep
 *
 * @description
 * should deep equality check be used
 *
 * @returns the moizer function
 */
moize.deep = moize({
  isDeepEqual: true
});

/**
 * @function
 * @name getStats
 * @memberof module:moize
 * @alias moize.getStats
 *
 * @description
 * get the statistics of a given profile, or overall usage
 *
 * @returns statistics for a given profile or overall usage
 */
moize.getStats = getStats;

/**
 * @function
 * @name infinite
 * @memberof module:moize
 * @alias moize.infinite
 *
 * @description
 * a moized method that will remove all limits from the cache size
 *
 * @returns the moizer function
 */
moize.infinite = moize({
  maxSize: Infinity
});

/**
 * @function
 * @name isCollectingStats
 * @memberof module:moize
 * @alias moize.isCollectingStats
 *
 * @description
 * are stats being collected
 *
 * @returns are stats being collected
 */
moize.isCollectingStats = function isCollectingStats() {
  return statsCache.isCollectingStats;
};

/**
 * @function
 * @name isMoized
 * @memberof module:moize
 * @alias moize.isMoized
 *
 * @description
 * is the fn passed a moized function
 *
 * @param fn the object to test
 * @returns is fn a moized function
 */
moize.isMoized = function isMoized(fn) {
  return typeof fn === 'function' && !!fn.isMoized;
};

/**
 * @function
 * @name matchesArg
 * @memberof module:moize
 * @alias moize.matchesArg
 *
 * @description
 * a moized method where the arg matching method is the custom one passed
 *
 * @param keyMatcher the method to compare against those in cache
 * @returns the moizer function
 */
moize.matchesArg = function (argMatcher) {
  return moize({
    matchesArg: argMatcher
  });
};

/**
 * @function
 * @name matchesKey
 * @memberof module:moize
 * @alias moize.matchesKey
 *
 * @description
 * a moized method where the key matching method is the custom one passed
 *
 * @param keyMatcher the method to compare against those in cache
 * @returns the moizer function
 */
moize.matchesKey = function (keyMatcher) {
  return moize({
    matchesKey: keyMatcher
  });
};
function maxAge(maxAge, expireOptions) {
  if (expireOptions === true) {
    return moize({
      maxAge: maxAge,
      updateExpire: expireOptions
    });
  }
  if (typeof expireOptions === 'object') {
    var onExpire = expireOptions.onExpire,
      updateExpire = expireOptions.updateExpire;
    return moize({
      maxAge: maxAge,
      onExpire: onExpire,
      updateExpire: updateExpire
    });
  }
  if (typeof expireOptions === 'function') {
    return moize({
      maxAge: maxAge,
      onExpire: expireOptions,
      updateExpire: true
    });
  }
  return moize({
    maxAge: maxAge
  });
}

/**
 * @function
 * @name maxAge
 * @memberof module:moize
 * @alias moize.maxAge
 *
 * @description
 * a moized method where the age of the cache is limited to the number of milliseconds passed
 *
 * @param maxAge the TTL of the value in cache
 * @returns the moizer function
 */
moize.maxAge = maxAge;

/**
 * @function
 * @name maxArgs
 * @memberof module:moize
 * @alias moize.maxArgs
 *
 * @description
 * a moized method where the number of arguments used for determining cache is limited to the value passed
 *
 * @param maxArgs the number of args to base the key on
 * @returns the moizer function
 */
moize.maxArgs = function maxArgs(maxArgs) {
  return moize({
    maxArgs: maxArgs
  });
};

/**
 * @function
 * @name maxSize
 * @memberof module:moize
 * @alias moize.maxSize
 *
 * @description
 * a moized method where the total size of the cache is limited to the value passed
 *
 * @param maxSize the maximum size of the cache
 * @returns the moizer function
 */
moize.maxSize = function maxSize(maxSize) {
  return moize({
    maxSize: maxSize
  });
};

/**
 * @function
 * @name profile
 * @memberof module:moize
 * @alias moize.profile
 *
 * @description
 * a moized method with a profile name
 *
 * @returns the moizer function
 */
moize.profile = function (profileName) {
  return moize({
    profileName: profileName
  });
};

/**
 * @function
 * @name promise
 * @memberof module:moize
 * @alias moize.promise
 *
 * @description
 * a moized method specific to caching resolved promise / async values
 *
 * @returns the moizer function
 */
moize.promise = moize({
  isPromise: true,
  updateExpire: true
});

/**
 * @function
 * @name react
 * @memberof module:moize
 * @alias moize.react
 *
 * @description
 * a moized method specific to caching React element values
 *
 * @returns the moizer function
 */
moize.react = moize({
  isReact: true
});

/**
 * @function
 * @name serialize
 * @memberof module:moize
 * @alias moize.serialize
 *
 * @description
 * a moized method that will serialize the arguments passed to use as the cache key
 *
 * @returns the moizer function
 */
moize.serialize = moize({
  isSerialized: true
});

/**
 * @function
 * @name serializeWith
 * @memberof module:moize
 * @alias moize.serializeWith
 *
 * @description
 * a moized method that will serialize the arguments passed to use as the cache key
 * based on the serializer passed
 *
 * @returns the moizer function
 */
moize.serializeWith = function (serializer) {
  return moize({
    isSerialized: true,
    serializer: serializer
  });
};

/**
 * @function
 * @name shallow
 * @memberof module:moize
 * @alias moize.shallow
 *
 * @description
 * should shallow equality check be used
 *
 * @returns the moizer function
 */
moize.shallow = moize({
  isShallowEqual: true
});

/**
 * @function
 * @name transformArgs
 * @memberof module:moize
 * @alias moize.transformArgs
 *
 * @description
 * transform the args to allow for specific cache key comparison
 *
 * @param transformArgs the args transformer
 * @returns the moizer function
 */
moize.transformArgs = function (transformArgs) {
  return moize({
    transformArgs: transformArgs
  });
};

/**
 * @function
 * @name updateCacheForKey
 * @memberof module:moize
 * @alias moize.updateCacheForKey
 *
 * @description
 * update the cache for a given key when the method passed returns truthy
 *
 * @param updateCacheForKey the method to determine when to update cache
 * @returns the moizer function
 */
moize.updateCacheForKey = function (updateCacheForKey) {
  return moize({
    updateCacheForKey: updateCacheForKey
  });
};

// Add self-referring `default` property for edge-case cross-compatibility of mixed ESM/CommonJS usage.
// This property is frozen and non-enumerable to avoid visibility on iteration or accidental overrides.
Object.defineProperty(moize, 'default', {
  configurable: false,
  enumerable: false,
  value: moize,
  writable: false
});

export { moize as default };
//# sourceMappingURL=moize.esm.js.map