Spaces:
Runtime error
Runtime error
File size: 4,373 Bytes
b5ea024 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
/* eslint max-statements: 0 */
// Support for functions returning promise
"use strict";
var objectMap = require("es5-ext/object/map")
, primitiveSet = require("es5-ext/object/primitive-set")
, ensureString = require("es5-ext/object/validate-stringifiable-value")
, toShortString = require("es5-ext/to-short-string-representation")
, isPromise = require("is-promise")
, nextTick = require("next-tick");
var create = Object.create
, supportedModes = primitiveSet("then", "then:finally", "done", "done:finally");
require("../lib/registered-extensions").promise = function (mode, conf) {
var waiting = create(null), cache = create(null), promises = create(null);
if (mode === true) {
mode = null;
} else {
mode = ensureString(mode);
if (!supportedModes[mode]) {
throw new TypeError("'" + toShortString(mode) + "' is not valid promise mode");
}
}
// After not from cache call
conf.on("set", function (id, ignore, promise) {
var isFailed = false;
if (!isPromise(promise)) {
// Non promise result
cache[id] = promise;
conf.emit("setasync", id, 1);
return;
}
waiting[id] = 1;
promises[id] = promise;
var onSuccess = function (result) {
var count = waiting[id];
if (isFailed) {
throw new Error(
"Memoizee error: Detected unordered then|done & finally resolution, which " +
"in turn makes proper detection of success/failure impossible (when in " +
"'done:finally' mode)\n" +
"Consider to rely on 'then' or 'done' mode instead."
);
}
if (!count) return; // Deleted from cache before resolved
delete waiting[id];
cache[id] = result;
conf.emit("setasync", id, count);
};
var onFailure = function () {
isFailed = true;
if (!waiting[id]) return; // Deleted from cache (or succeed in case of finally)
delete waiting[id];
delete promises[id];
conf.delete(id);
};
var resolvedMode = mode;
if (!resolvedMode) resolvedMode = "then";
if (resolvedMode === "then") {
var nextTickFailure = function () { nextTick(onFailure); };
// Eventual finally needs to be attached to non rejected promise
// (so we not force propagation of unhandled rejection)
promise = promise.then(function (result) {
nextTick(onSuccess.bind(this, result));
}, nextTickFailure);
// If `finally` is a function we attach to it to remove cancelled promises.
if (typeof promise.finally === "function") {
promise.finally(nextTickFailure);
}
} else if (resolvedMode === "done") {
// Not recommended, as it may mute any eventual "Unhandled error" events
if (typeof promise.done !== "function") {
throw new Error(
"Memoizee error: Retrieved promise does not implement 'done' " +
"in 'done' mode"
);
}
promise.done(onSuccess, onFailure);
} else if (resolvedMode === "done:finally") {
// The only mode with no side effects assuming library does not throw unconditionally
// for rejected promises.
if (typeof promise.done !== "function") {
throw new Error(
"Memoizee error: Retrieved promise does not implement 'done' " +
"in 'done:finally' mode"
);
}
if (typeof promise.finally !== "function") {
throw new Error(
"Memoizee error: Retrieved promise does not implement 'finally' " +
"in 'done:finally' mode"
);
}
promise.done(onSuccess);
promise.finally(onFailure);
}
});
// From cache (sync)
conf.on("get", function (id, args, context) {
var promise;
if (waiting[id]) {
++waiting[id]; // Still waiting
return;
}
promise = promises[id];
var emit = function () { conf.emit("getasync", id, args, context); };
if (isPromise(promise)) {
if (typeof promise.done === "function") promise.done(emit);
else {
promise.then(function () { nextTick(emit); });
}
} else {
emit();
}
});
// On delete
conf.on("delete", function (id) {
delete promises[id];
if (waiting[id]) {
delete waiting[id];
return; // Not yet resolved
}
if (!hasOwnProperty.call(cache, id)) return;
var result = cache[id];
delete cache[id];
conf.emit("deleteasync", id, [result]);
});
// On clear
conf.on("clear", function () {
var oldCache = cache;
cache = create(null);
waiting = create(null);
promises = create(null);
conf.emit("clearasync", objectMap(oldCache, function (data) { return [data]; }));
});
};
|