Current File : //www/specpages-backup/node_modules/moize/dist/moize.js
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('micro-memoize'), require('fast-equals')) :
typeof define === 'function' && define.amd ? define(['micro-memoize', 'fast-equals'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.moize = factory(global.memoize, global.fe));
})(this, (function (memoize, fastEquals) { 'use strict';
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 && fastEquals.deepEqual || options.isShallowEqual && fastEquals.shallowEqual || fastEquals.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
});
return moize;
}));
//# sourceMappingURL=moize.js.map
Mini Shell