You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
492 lines
18 KiB
492 lines
18 KiB
'use strict'; |
|
|
|
var trie = require('@wry/trie'); |
|
var caches$1 = require('@wry/caches'); |
|
var context = require('@wry/context'); |
|
|
|
var parentEntrySlot = new context.Slot(); |
|
function nonReactive(fn) { |
|
return parentEntrySlot.withValue(void 0, fn); |
|
} |
|
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty; |
|
var arrayFromSet = Array.from || |
|
function (set) { |
|
var array = []; |
|
set.forEach(function (item) { return array.push(item); }); |
|
return array; |
|
}; |
|
function maybeUnsubscribe(entryOrDep) { |
|
var unsubscribe = entryOrDep.unsubscribe; |
|
if (typeof unsubscribe === "function") { |
|
entryOrDep.unsubscribe = void 0; |
|
unsubscribe(); |
|
} |
|
} |
|
|
|
var emptySetPool = []; |
|
var POOL_TARGET_SIZE = 100; |
|
// Since this package might be used browsers, we should avoid using the |
|
// Node built-in assert module. |
|
function assert(condition, optionalMessage) { |
|
if (!condition) { |
|
throw new Error(optionalMessage || "assertion failure"); |
|
} |
|
} |
|
function valueIs(a, b) { |
|
var len = a.length; |
|
return ( |
|
// Unknown values are not equal to each other. |
|
len > 0 && |
|
// Both values must be ordinary (or both exceptional) to be equal. |
|
len === b.length && |
|
// The underlying value or exception must be the same. |
|
a[len - 1] === b[len - 1]); |
|
} |
|
function valueGet(value) { |
|
switch (value.length) { |
|
case 0: throw new Error("unknown value"); |
|
case 1: return value[0]; |
|
case 2: throw value[1]; |
|
} |
|
} |
|
function valueCopy(value) { |
|
return value.slice(0); |
|
} |
|
var Entry = /** @class */ (function () { |
|
function Entry(fn) { |
|
this.fn = fn; |
|
this.parents = new Set(); |
|
this.childValues = new Map(); |
|
// When this Entry has children that are dirty, this property becomes |
|
// a Set containing other Entry objects, borrowed from emptySetPool. |
|
// When the set becomes empty, it gets recycled back to emptySetPool. |
|
this.dirtyChildren = null; |
|
this.dirty = true; |
|
this.recomputing = false; |
|
this.value = []; |
|
this.deps = null; |
|
++Entry.count; |
|
} |
|
Entry.prototype.peek = function () { |
|
if (this.value.length === 1 && !mightBeDirty(this)) { |
|
rememberParent(this); |
|
return this.value[0]; |
|
} |
|
}; |
|
// This is the most important method of the Entry API, because it |
|
// determines whether the cached this.value can be returned immediately, |
|
// or must be recomputed. The overall performance of the caching system |
|
// depends on the truth of the following observations: (1) this.dirty is |
|
// usually false, (2) this.dirtyChildren is usually null/empty, and thus |
|
// (3) valueGet(this.value) is usually returned without recomputation. |
|
Entry.prototype.recompute = function (args) { |
|
assert(!this.recomputing, "already recomputing"); |
|
rememberParent(this); |
|
return mightBeDirty(this) |
|
? reallyRecompute(this, args) |
|
: valueGet(this.value); |
|
}; |
|
Entry.prototype.setDirty = function () { |
|
if (this.dirty) |
|
return; |
|
this.dirty = true; |
|
reportDirty(this); |
|
// We can go ahead and unsubscribe here, since any further dirty |
|
// notifications we receive will be redundant, and unsubscribing may |
|
// free up some resources, e.g. file watchers. |
|
maybeUnsubscribe(this); |
|
}; |
|
Entry.prototype.dispose = function () { |
|
var _this = this; |
|
this.setDirty(); |
|
// Sever any dependency relationships with our own children, so those |
|
// children don't retain this parent Entry in their child.parents sets, |
|
// thereby preventing it from being fully garbage collected. |
|
forgetChildren(this); |
|
// Because this entry has been kicked out of the cache (in index.js), |
|
// we've lost the ability to find out if/when this entry becomes dirty, |
|
// whether that happens through a subscription, because of a direct call |
|
// to entry.setDirty(), or because one of its children becomes dirty. |
|
// Because of this loss of future information, we have to assume the |
|
// worst (that this entry might have become dirty very soon), so we must |
|
// immediately mark this entry's parents as dirty. Normally we could |
|
// just call entry.setDirty() rather than calling parent.setDirty() for |
|
// each parent, but that would leave this entry in parent.childValues |
|
// and parent.dirtyChildren, which would prevent the child from being |
|
// truly forgotten. |
|
eachParent(this, function (parent, child) { |
|
parent.setDirty(); |
|
forgetChild(parent, _this); |
|
}); |
|
}; |
|
Entry.prototype.forget = function () { |
|
// The code that creates Entry objects in index.ts will replace this method |
|
// with one that actually removes the Entry from the cache, which will also |
|
// trigger the entry.dispose method. |
|
this.dispose(); |
|
}; |
|
Entry.prototype.dependOn = function (dep) { |
|
dep.add(this); |
|
if (!this.deps) { |
|
this.deps = emptySetPool.pop() || new Set(); |
|
} |
|
this.deps.add(dep); |
|
}; |
|
Entry.prototype.forgetDeps = function () { |
|
var _this = this; |
|
if (this.deps) { |
|
arrayFromSet(this.deps).forEach(function (dep) { return dep.delete(_this); }); |
|
this.deps.clear(); |
|
emptySetPool.push(this.deps); |
|
this.deps = null; |
|
} |
|
}; |
|
Entry.count = 0; |
|
return Entry; |
|
}()); |
|
function rememberParent(child) { |
|
var parent = parentEntrySlot.getValue(); |
|
if (parent) { |
|
child.parents.add(parent); |
|
if (!parent.childValues.has(child)) { |
|
parent.childValues.set(child, []); |
|
} |
|
if (mightBeDirty(child)) { |
|
reportDirtyChild(parent, child); |
|
} |
|
else { |
|
reportCleanChild(parent, child); |
|
} |
|
return parent; |
|
} |
|
} |
|
function reallyRecompute(entry, args) { |
|
forgetChildren(entry); |
|
// Set entry as the parent entry while calling recomputeNewValue(entry). |
|
parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]); |
|
if (maybeSubscribe(entry, args)) { |
|
// If we successfully recomputed entry.value and did not fail to |
|
// (re)subscribe, then this Entry is no longer explicitly dirty. |
|
setClean(entry); |
|
} |
|
return valueGet(entry.value); |
|
} |
|
function recomputeNewValue(entry, args) { |
|
entry.recomputing = true; |
|
var normalizeResult = entry.normalizeResult; |
|
var oldValueCopy; |
|
if (normalizeResult && entry.value.length === 1) { |
|
oldValueCopy = valueCopy(entry.value); |
|
} |
|
// Make entry.value an empty array, representing an unknown value. |
|
entry.value.length = 0; |
|
try { |
|
// If entry.fn succeeds, entry.value will become a normal Value. |
|
entry.value[0] = entry.fn.apply(null, args); |
|
// If we have a viable oldValueCopy to compare with the (successfully |
|
// recomputed) new entry.value, and they are not already === identical, give |
|
// normalizeResult a chance to pick/choose/reuse parts of oldValueCopy[0] |
|
// and/or entry.value[0] to determine the final cached entry.value. |
|
if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) { |
|
try { |
|
entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]); |
|
} |
|
catch (_a) { |
|
// If normalizeResult throws, just use the newer value, rather than |
|
// saving the exception as entry.value[1]. |
|
} |
|
} |
|
} |
|
catch (e) { |
|
// If entry.fn throws, entry.value will hold that exception. |
|
entry.value[1] = e; |
|
} |
|
// Either way, this line is always reached. |
|
entry.recomputing = false; |
|
} |
|
function mightBeDirty(entry) { |
|
return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size); |
|
} |
|
function setClean(entry) { |
|
entry.dirty = false; |
|
if (mightBeDirty(entry)) { |
|
// This Entry may still have dirty children, in which case we can't |
|
// let our parents know we're clean just yet. |
|
return; |
|
} |
|
reportClean(entry); |
|
} |
|
function reportDirty(child) { |
|
eachParent(child, reportDirtyChild); |
|
} |
|
function reportClean(child) { |
|
eachParent(child, reportCleanChild); |
|
} |
|
function eachParent(child, callback) { |
|
var parentCount = child.parents.size; |
|
if (parentCount) { |
|
var parents = arrayFromSet(child.parents); |
|
for (var i = 0; i < parentCount; ++i) { |
|
callback(parents[i], child); |
|
} |
|
} |
|
} |
|
// Let a parent Entry know that one of its children may be dirty. |
|
function reportDirtyChild(parent, child) { |
|
// Must have called rememberParent(child) before calling |
|
// reportDirtyChild(parent, child). |
|
assert(parent.childValues.has(child)); |
|
assert(mightBeDirty(child)); |
|
var parentWasClean = !mightBeDirty(parent); |
|
if (!parent.dirtyChildren) { |
|
parent.dirtyChildren = emptySetPool.pop() || new Set; |
|
} |
|
else if (parent.dirtyChildren.has(child)) { |
|
// If we already know this child is dirty, then we must have already |
|
// informed our own parents that we are dirty, so we can terminate |
|
// the recursion early. |
|
return; |
|
} |
|
parent.dirtyChildren.add(child); |
|
// If parent was clean before, it just became (possibly) dirty (according to |
|
// mightBeDirty), since we just added child to parent.dirtyChildren. |
|
if (parentWasClean) { |
|
reportDirty(parent); |
|
} |
|
} |
|
// Let a parent Entry know that one of its children is no longer dirty. |
|
function reportCleanChild(parent, child) { |
|
// Must have called rememberChild(child) before calling |
|
// reportCleanChild(parent, child). |
|
assert(parent.childValues.has(child)); |
|
assert(!mightBeDirty(child)); |
|
var childValue = parent.childValues.get(child); |
|
if (childValue.length === 0) { |
|
parent.childValues.set(child, valueCopy(child.value)); |
|
} |
|
else if (!valueIs(childValue, child.value)) { |
|
parent.setDirty(); |
|
} |
|
removeDirtyChild(parent, child); |
|
if (mightBeDirty(parent)) { |
|
return; |
|
} |
|
reportClean(parent); |
|
} |
|
function removeDirtyChild(parent, child) { |
|
var dc = parent.dirtyChildren; |
|
if (dc) { |
|
dc.delete(child); |
|
if (dc.size === 0) { |
|
if (emptySetPool.length < POOL_TARGET_SIZE) { |
|
emptySetPool.push(dc); |
|
} |
|
parent.dirtyChildren = null; |
|
} |
|
} |
|
} |
|
// Removes all children from this entry and returns an array of the |
|
// removed children. |
|
function forgetChildren(parent) { |
|
if (parent.childValues.size > 0) { |
|
parent.childValues.forEach(function (_value, child) { |
|
forgetChild(parent, child); |
|
}); |
|
} |
|
// Remove this parent Entry from any sets to which it was added by the |
|
// addToSet method. |
|
parent.forgetDeps(); |
|
// After we forget all our children, this.dirtyChildren must be empty |
|
// and therefore must have been reset to null. |
|
assert(parent.dirtyChildren === null); |
|
} |
|
function forgetChild(parent, child) { |
|
child.parents.delete(parent); |
|
parent.childValues.delete(child); |
|
removeDirtyChild(parent, child); |
|
} |
|
function maybeSubscribe(entry, args) { |
|
if (typeof entry.subscribe === "function") { |
|
try { |
|
maybeUnsubscribe(entry); // Prevent double subscriptions. |
|
entry.unsubscribe = entry.subscribe.apply(null, args); |
|
} |
|
catch (e) { |
|
// If this Entry has a subscribe function and it threw an exception |
|
// (or an unsubscribe function it previously returned now throws), |
|
// return false to indicate that we were not able to subscribe (or |
|
// unsubscribe), and this Entry should remain dirty. |
|
entry.setDirty(); |
|
return false; |
|
} |
|
} |
|
// Returning true indicates either that there was no entry.subscribe |
|
// function or that it succeeded. |
|
return true; |
|
} |
|
|
|
var EntryMethods = { |
|
setDirty: true, |
|
dispose: true, |
|
forget: true, // Fully remove parent Entry from LRU cache and computation graph |
|
}; |
|
function dep(options) { |
|
var depsByKey = new Map(); |
|
var subscribe = options && options.subscribe; |
|
function depend(key) { |
|
var parent = parentEntrySlot.getValue(); |
|
if (parent) { |
|
var dep_1 = depsByKey.get(key); |
|
if (!dep_1) { |
|
depsByKey.set(key, dep_1 = new Set); |
|
} |
|
parent.dependOn(dep_1); |
|
if (typeof subscribe === "function") { |
|
maybeUnsubscribe(dep_1); |
|
dep_1.unsubscribe = subscribe(key); |
|
} |
|
} |
|
} |
|
depend.dirty = function dirty(key, entryMethodName) { |
|
var dep = depsByKey.get(key); |
|
if (dep) { |
|
var m_1 = (entryMethodName && |
|
hasOwnProperty.call(EntryMethods, entryMethodName)) ? entryMethodName : "setDirty"; |
|
// We have to use arrayFromSet(dep).forEach instead of dep.forEach, |
|
// because modifying a Set while iterating over it can cause elements in |
|
// the Set to be removed from the Set before they've been iterated over. |
|
arrayFromSet(dep).forEach(function (entry) { return entry[m_1](); }); |
|
depsByKey.delete(key); |
|
maybeUnsubscribe(dep); |
|
} |
|
}; |
|
return depend; |
|
} |
|
|
|
// The defaultMakeCacheKey function is remarkably powerful, because it gives |
|
// a unique object for any shallow-identical list of arguments. If you need |
|
// to implement a custom makeCacheKey function, you may find it helpful to |
|
// delegate the final work to defaultMakeCacheKey, which is why we export it |
|
// here. However, you may want to avoid defaultMakeCacheKey if your runtime |
|
// does not support WeakMap, or you have the ability to return a string key. |
|
// In those cases, just write your own custom makeCacheKey functions. |
|
var defaultKeyTrie; |
|
function defaultMakeCacheKey() { |
|
var args = []; |
|
for (var _i = 0; _i < arguments.length; _i++) { |
|
args[_i] = arguments[_i]; |
|
} |
|
var trie$1 = defaultKeyTrie || (defaultKeyTrie = new trie.Trie(typeof WeakMap === "function")); |
|
return trie$1.lookupArray(args); |
|
} |
|
var caches = new Set(); |
|
function wrap(originalFunction, _a) { |
|
var _b = _a === void 0 ? Object.create(null) : _a, _c = _b.max, max = _c === void 0 ? Math.pow(2, 16) : _c, keyArgs = _b.keyArgs, _d = _b.makeCacheKey, makeCacheKey = _d === void 0 ? defaultMakeCacheKey : _d, normalizeResult = _b.normalizeResult, subscribe = _b.subscribe, _e = _b.cache, cacheOption = _e === void 0 ? caches$1.StrongCache : _e; |
|
var cache = typeof cacheOption === "function" |
|
? new cacheOption(max, function (entry) { return entry.dispose(); }) |
|
: cacheOption; |
|
var optimistic = function () { |
|
var key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments); |
|
if (key === void 0) { |
|
return originalFunction.apply(null, arguments); |
|
} |
|
var entry = cache.get(key); |
|
if (!entry) { |
|
cache.set(key, entry = new Entry(originalFunction)); |
|
entry.normalizeResult = normalizeResult; |
|
entry.subscribe = subscribe; |
|
// Give the Entry the ability to trigger cache.delete(key), even though |
|
// the Entry itself does not know about key or cache. |
|
entry.forget = function () { return cache.delete(key); }; |
|
} |
|
var value = entry.recompute(Array.prototype.slice.call(arguments)); |
|
// Move this entry to the front of the least-recently used queue, |
|
// since we just finished computing its value. |
|
cache.set(key, entry); |
|
caches.add(cache); |
|
// Clean up any excess entries in the cache, but only if there is no |
|
// active parent entry, meaning we're not in the middle of a larger |
|
// computation that might be flummoxed by the cleaning. |
|
if (!parentEntrySlot.hasValue()) { |
|
caches.forEach(function (cache) { return cache.clean(); }); |
|
caches.clear(); |
|
} |
|
return value; |
|
}; |
|
Object.defineProperty(optimistic, "size", { |
|
get: function () { return cache.size; }, |
|
configurable: false, |
|
enumerable: false, |
|
}); |
|
Object.freeze(optimistic.options = { |
|
max: max, |
|
keyArgs: keyArgs, |
|
makeCacheKey: makeCacheKey, |
|
normalizeResult: normalizeResult, |
|
subscribe: subscribe, |
|
cache: cache, |
|
}); |
|
function dirtyKey(key) { |
|
var entry = key && cache.get(key); |
|
if (entry) { |
|
entry.setDirty(); |
|
} |
|
} |
|
optimistic.dirtyKey = dirtyKey; |
|
optimistic.dirty = function dirty() { |
|
dirtyKey(makeCacheKey.apply(null, arguments)); |
|
}; |
|
function peekKey(key) { |
|
var entry = key && cache.get(key); |
|
if (entry) { |
|
return entry.peek(); |
|
} |
|
} |
|
optimistic.peekKey = peekKey; |
|
optimistic.peek = function peek() { |
|
return peekKey(makeCacheKey.apply(null, arguments)); |
|
}; |
|
function forgetKey(key) { |
|
return key ? cache.delete(key) : false; |
|
} |
|
optimistic.forgetKey = forgetKey; |
|
optimistic.forget = function forget() { |
|
return forgetKey(makeCacheKey.apply(null, arguments)); |
|
}; |
|
optimistic.makeCacheKey = makeCacheKey; |
|
optimistic.getKey = keyArgs ? function getKey() { |
|
return makeCacheKey.apply(null, keyArgs.apply(null, arguments)); |
|
} : makeCacheKey; |
|
return Object.freeze(optimistic); |
|
} |
|
|
|
Object.defineProperty(exports, 'KeyTrie', { |
|
enumerable: true, |
|
get: function () { return trie.Trie; } |
|
}); |
|
Object.defineProperty(exports, 'Slot', { |
|
enumerable: true, |
|
get: function () { return context.Slot; } |
|
}); |
|
Object.defineProperty(exports, 'asyncFromGen', { |
|
enumerable: true, |
|
get: function () { return context.asyncFromGen; } |
|
}); |
|
Object.defineProperty(exports, 'bindContext', { |
|
enumerable: true, |
|
get: function () { return context.bind; } |
|
}); |
|
Object.defineProperty(exports, 'noContext', { |
|
enumerable: true, |
|
get: function () { return context.noContext; } |
|
}); |
|
Object.defineProperty(exports, 'setTimeout', { |
|
enumerable: true, |
|
get: function () { return context.setTimeout; } |
|
}); |
|
exports.defaultMakeCacheKey = defaultMakeCacheKey; |
|
exports.dep = dep; |
|
exports.nonReactive = nonReactive; |
|
exports.wrap = wrap; |
|
//# sourceMappingURL=bundle.cjs.map
|
|
|