hexo-adsense 1.0.21 → 1.0.25

package/packages/memoize/ext/async.js

@@ -0,0 +1,154 @@
+/* eslint consistent-this: 0, no-shadow:0, no-eq-null: 0, eqeqeq: 0, no-unused-vars: 0 */
+
+// Support for asynchronous functions
+
+"use strict";
+
+var aFrom        = require("es5-ext/array/from")
+  , objectMap    = require("es5-ext/object/map")
+  , mixin        = require("es5-ext/object/mixin")
+  , defineLength = require("es5-ext/function/_define-length")
+  , nextTick     = require("next-tick");
+
+var slice = Array.prototype.slice, apply = Function.prototype.apply, create = Object.create;
+
+require("../lib/registered-extensions").async = function (tbi, conf) {
+	var waiting = create(null)
+	  , cache = create(null)
+	  , base = conf.memoized
+	  , original = conf.original
+	  , currentCallback
+	  , currentContext
+	  , currentArgs;
+
+	// Initial
+	conf.memoized = defineLength(function (arg) {
+		var args = arguments, last = args[args.length - 1];
+		if (typeof last === "function") {
+			currentCallback = last;
+			args = slice.call(args, 0, -1);
+		}
+		return base.apply(currentContext = this, currentArgs = args);
+	}, base);
+	try { mixin(conf.memoized, base); }
+	catch (ignore) {}
+
+	// From cache (sync)
+	conf.on("get", function (id) {
+		var cb, context, args;
+		if (!currentCallback) return;
+
+		// Unresolved
+		if (waiting[id]) {
+			if (typeof waiting[id] === "function") waiting[id] = [waiting[id], currentCallback];
+			else waiting[id].push(currentCallback);
+			currentCallback = null;
+			return;
+		}
+
+		// Resolved, assure next tick invocation
+		cb = currentCallback;
+		context = currentContext;
+		args = currentArgs;
+		currentCallback = currentContext = currentArgs = null;
+		nextTick(function () {
+			var data;
+			if (hasOwnProperty.call(cache, id)) {
+				data = cache[id];
+				conf.emit("getasync", id, args, context);
+				apply.call(cb, data.context, data.args);
+			} else {
+				// Purged in a meantime, we shouldn't rely on cached value, recall
+				currentCallback = cb;
+				currentContext = context;
+				currentArgs = args;
+				base.apply(context, args);
+			}
+		});
+	});
+
+	// Not from cache
+	conf.original = function () {
+		var args, cb, origCb, result;
+		if (!currentCallback) return apply.call(original, this, arguments);
+		args = aFrom(arguments);
+		cb = function self(err) {
+			var cb, args, id = self.id;
+			if (id == null) {
+				// Shouldn't happen, means async callback was called sync way
+				nextTick(apply.bind(self, this, arguments));
+				return undefined;
+			}
+			delete self.id;
+			cb = waiting[id];
+			delete waiting[id];
+			if (!cb) {
+				// Already processed,
+				// outcome of race condition: asyncFn(1, cb), asyncFn.clear(), asyncFn(1, cb)
+				return undefined;
+			}
+			args = aFrom(arguments);
+			if (conf.has(id)) {
+				if (err) {
+					conf.delete(id);
+				} else {
+					cache[id] = { context: this, args: args };
+					conf.emit("setasync", id, typeof cb === "function" ? 1 : cb.length);
+				}
+			}
+			if (typeof cb === "function") {
+				result = apply.call(cb, this, args);
+			} else {
+				cb.forEach(function (cb) { result = apply.call(cb, this, args); }, this);
+			}
+			return result;
+		};
+		origCb = currentCallback;
+		currentCallback = currentContext = currentArgs = null;
+		args.push(cb);
+		result = apply.call(original, this, args);
+		cb.cb = origCb;
+		currentCallback = cb;
+		return result;
+	};
+
+	// After not from cache call
+	conf.on("set", function (id) {
+		if (!currentCallback) {
+			conf.delete(id);
+			return;
+		}
+		if (waiting[id]) {
+			// Race condition: asyncFn(1, cb), asyncFn.clear(), asyncFn(1, cb)
+			if (typeof waiting[id] === "function") waiting[id] = [waiting[id], currentCallback.cb];
+			else waiting[id].push(currentCallback.cb);
+		} else {
+			waiting[id] = currentCallback.cb;
+		}
+		delete currentCallback.cb;
+		currentCallback.id = id;
+		currentCallback = null;
+	});
+
+	// On delete
+	conf.on("delete", function (id) {
+		var result;
+		// If false, we don't have value yet, so we assume that intention is not
+		// to memoize this call. After value is obtained we don't cache it but
+		// gracefully pass to callback
+		if (hasOwnProperty.call(waiting, id)) return;
+		if (!cache[id]) return;
+		result = cache[id];
+		delete cache[id];
+		conf.emit("deleteasync", id, slice.call(result.args, 1));
+	});
+
+	// On clear
+	conf.on("clear", function () {
+		var oldCache = cache;
+		cache = create(null);
+		conf.emit(
+			"clearasync", objectMap(oldCache, function (data) { return slice.call(data.args, 1); })
+		);
+	});
+};

package/packages/memoize/ext/dispose.js

@@ -0,0 +1,33 @@
+// Call dispose callback on each cache purge
+
+"use strict";
+
+var callable   = require("es5-ext/object/valid-callable")
+  , forEach    = require("es5-ext/object/for-each")
+  , extensions = require("../lib/registered-extensions")
+
+  , apply = Function.prototype.apply;
+
+extensions.dispose = function (dispose, conf, options) {
+	var del;
+	callable(dispose);
+	if ((options.async && extensions.async) || (options.promise && extensions.promise)) {
+		conf.on("deleteasync", del = function (id, resultArray) {
+			apply.call(dispose, null, resultArray);
+		});
+		conf.on("clearasync", function (cache) {
+			forEach(cache, function (result, id) {
+ del(id, result);
+});
+		});
+		return;
+	}
+	conf.on("delete", del = function (id, result) {
+ dispose(result);
+});
+	conf.on("clear", function (cache) {
+		forEach(cache, function (result, id) {
+ del(id, result);
+});
+	});
+};

package/packages/memoize/ext/max-age.js

@@ -0,0 +1,90 @@
+/* eslint consistent-this: 0 */
+
+// Timeout cached values
+
+"use strict";
+
+var aFrom      = require("es5-ext/array/from")
+  , forEach    = require("es5-ext/object/for-each")
+  , nextTick   = require("next-tick")
+  , isPromise  = require("is-promise")
+  , timeout    = require("timers-ext/valid-timeout")
+  , extensions = require("../lib/registered-extensions");
+
+var noop = Function.prototype, max = Math.max, min = Math.min, create = Object.create;
+
+extensions.maxAge = function (maxAge, conf, options) {
+	var timeouts, postfix, preFetchAge, preFetchTimeouts;
+
+	maxAge = timeout(maxAge);
+	if (!maxAge) return;
+
+	timeouts = create(null);
+	postfix =
+		(options.async && extensions.async) || (options.promise && extensions.promise)
+			? "async"
+			: "";
+	conf.on("set" + postfix, function (id) {
+		timeouts[id] = setTimeout(function () { conf.delete(id); }, maxAge);
+		if (typeof timeouts[id].unref === "function") timeouts[id].unref();
+		if (!preFetchTimeouts) return;
+		if (preFetchTimeouts[id]) {
+			if (preFetchTimeouts[id] !== "nextTick") clearTimeout(preFetchTimeouts[id]);
+		}
+		preFetchTimeouts[id] = setTimeout(function () {
+			delete preFetchTimeouts[id];
+		}, preFetchAge);
+		if (typeof preFetchTimeouts[id].unref === "function") preFetchTimeouts[id].unref();
+	});
+	conf.on("delete" + postfix, function (id) {
+		clearTimeout(timeouts[id]);
+		delete timeouts[id];
+		if (!preFetchTimeouts) return;
+		if (preFetchTimeouts[id] !== "nextTick") clearTimeout(preFetchTimeouts[id]);
+		delete preFetchTimeouts[id];
+	});
+
+	if (options.preFetch) {
+		if (options.preFetch === true || isNaN(options.preFetch)) {
+			preFetchAge = 0.333;
+		} else {
+			preFetchAge = max(min(Number(options.preFetch), 1), 0);
+		}
+		if (preFetchAge) {
+			preFetchTimeouts = {};
+			preFetchAge = (1 - preFetchAge) * maxAge;
+			conf.on("get" + postfix, function (id, args, context) {
+				if (!preFetchTimeouts[id]) {
+					preFetchTimeouts[id] = "nextTick";
+					nextTick(function () {
+						var result;
+						if (preFetchTimeouts[id] !== "nextTick") return;
+						delete preFetchTimeouts[id];
+						conf.delete(id);
+						if (options.async) {
+							args = aFrom(args);
+							args.push(noop);
+						}
+						result = conf.memoized.apply(context, args);
+						if (options.promise) {
+							// Supress eventual error warnings
+							if (isPromise(result)) {
+								if (typeof result.done === "function") result.done(noop, noop);
+								else result.then(noop, noop);
+							}
+						}
+					});
+				}
+			});
+		}
+	}
+
+	conf.on("clear" + postfix, function () {
+		forEach(timeouts, function (id) { clearTimeout(id); });
+		timeouts = {};
+		if (preFetchTimeouts) {
+			forEach(preFetchTimeouts, function (id) { if (id !== "nextTick") clearTimeout(id); });
+			preFetchTimeouts = {};
+		}
+	});
+};

package/packages/memoize/ext/max.js

@@ -0,0 +1,27 @@
+// Limit cache size, LRU (least recently used) algorithm.
+
+"use strict";
+
+var toPosInteger = require("es5-ext/number/to-pos-integer")
+  , lruQueue     = require("lru-queue")
+  , extensions   = require("../lib/registered-extensions");
+
+extensions.max = function (max, conf, options) {
+	var postfix, queue, hit;
+
+	max = toPosInteger(max);
+	if (!max) return;
+
+	queue = lruQueue(max);
+	postfix = (options.async && extensions.async) || (options.promise && extensions.promise)
+		? "async" : "";
+
+	conf.on("set" + postfix, hit = function (id) {
+		id = queue.hit(id);
+		if (id === undefined) return;
+		conf.delete(id);
+	});
+	conf.on("get" + postfix, hit);
+	conf.on("delete" + postfix, queue.delete);
+	conf.on("clear" + postfix, queue.clear);
+};

package/packages/memoize/ext/promise.js

@@ -0,0 +1,147 @@
+/* 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]; }));
+	});
+};

package/packages/memoize/ext/ref-counter.js

@@ -0,0 +1,48 @@
+// Reference counter, useful for garbage collector like functionality
+
+"use strict";
+
+var d          = require("d")
+  , extensions = require("../lib/registered-extensions")
+
+  , create = Object.create, defineProperties = Object.defineProperties;
+
+extensions.refCounter = function (ignore, conf, options) {
+	var cache, postfix;
+
+	cache = create(null);
+	postfix = (options.async && extensions.async) || (options.promise && extensions.promise)
+		? "async" : "";
+
+	conf.on("set" + postfix, function (id, length) {
+ cache[id] = length || 1;
+});
+	conf.on("get" + postfix, function (id) {
+ ++cache[id];
+});
+	conf.on("delete" + postfix, function (id) {
+ delete cache[id];
+});
+	conf.on("clear" + postfix, function () {
+ cache = {};
+});
+
+	defineProperties(conf.memoized, {
+		deleteRef: d(function () {
+			var id = conf.get(arguments);
+			if (id === null) return null;
+			if (!cache[id]) return null;
+			if (!--cache[id]) {
+				conf.delete(id);
+				return true;
+			}
+			return false;
+		}),
+		getRefCount: d(function () {
+			var id = conf.get(arguments);
+			if (id === null) return 0;
+			if (!cache[id]) return 0;
+			return cache[id];
+		})
+	});
+};

package/packages/memoize/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var normalizeOpts = require("es5-ext/object/normalize-options")
+  , resolveLength = require("./lib/resolve-length")
+  , plain         = require("./plain");
+
+module.exports = function (fn/*, options*/) {
+	var options = normalizeOpts(arguments[1]), length;
+
+	if (!options.normalizer) {
+		length = options.length = resolveLength(options.length, fn.length, options.async);
+		if (length !== 0) {
+			if (options.primitive) {
+				if (length === false) {
+					options.normalizer = require("./normalizers/primitive");
+				} else if (length > 1) {
+					options.normalizer = require("./normalizers/get-primitive-fixed")(length);
+				}
+			} else if (length === false) options.normalizer = require("./normalizers/get")();
+				else if (length === 1) options.normalizer = require("./normalizers/get-1")();
+				else options.normalizer = require("./normalizers/get-fixed")(length);
+		}
+	}
+
+	// Assure extensions
+	if (options.async) require("./ext/async");
+	if (options.promise) require("./ext/promise");
+	if (options.dispose) require("./ext/dispose");
+	if (options.maxAge) require("./ext/max-age");
+	if (options.max) require("./ext/max");
+	if (options.refCounter) require("./ext/ref-counter");
+
+	return plain(fn, options);
+};