3 changed files with 470 additions and 0 deletions
@ -0,0 +1,468 @@ |
|||
"use strict"; |
|||
|
|||
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|||
|
|||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; |
|||
|
|||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|||
|
|||
(function (f) { |
|||
if ((typeof exports === "undefined" ? "undefined" : _typeof(exports)) === "object" && typeof module !== "undefined") { |
|||
module.exports = f(); |
|||
} else if (typeof define === "function" && define.amd) { |
|||
define([], f); |
|||
} else { |
|||
var g;if (typeof window !== "undefined") { |
|||
g = window; |
|||
} else if (typeof global !== "undefined") { |
|||
g = global; |
|||
} else if (typeof self !== "undefined") { |
|||
g = self; |
|||
} else { |
|||
g = this; |
|||
}g.isEq = f(); |
|||
} |
|||
})(function () { |
|||
var define, module, exports;return function () { |
|||
function r(e, n, t) { |
|||
function o(i, f) { |
|||
if (!n[i]) { |
|||
if (!e[i]) { |
|||
var c = "function" == typeof require && require;if (!f && c) return c(i, !0);if (u) return u(i, !0);var a = new Error("Cannot find module '" + i + "'");throw a.code = "MODULE_NOT_FOUND", a; |
|||
}var p = n[i] = { exports: {} };e[i][0].call(p.exports, function (r) { |
|||
var n = e[i][1][r];return o(n || r); |
|||
}, p, p.exports, r, e, n, t); |
|||
}return n[i].exports; |
|||
}for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) { |
|||
o(t[i]); |
|||
}return o; |
|||
}return r; |
|||
}()({ 1: [function (require, module, exports) { |
|||
/** |
|||
* ∞ |
|||
* Infinity: Create infinitely generating lists in JavaScript. |
|||
* @version 0.2.0 |
|||
* @author Muthu Kumar (MKRhere) |
|||
*/ |
|||
|
|||
// Utils
|
|||
var _require = require('./utils'), |
|||
always = _require.always, |
|||
isNonZeroFalsy = _require.isNonZeroFalsy, |
|||
stringify = _require.stringify, |
|||
areNumbers = _require.areNumbers; |
|||
|
|||
/** |
|||
* An item of the InfiniteList class. Created when calling .get(n) on an InfiniteList. |
|||
* Exposed for instanceof utility sake. Not to be called directly. |
|||
* @class InfiniteListItem |
|||
*/ |
|||
|
|||
|
|||
var InfiniteListItem = function () { |
|||
/** |
|||
* Creates an instance of InfiniteListItem. |
|||
* @param {any} list Parent list, instance of InfiniteList |
|||
* @param {any} value Current value |
|||
* @param {any} index Current index |
|||
* @memberof InfiniteListItem |
|||
*/ |
|||
function InfiniteListItem(list, value, index) { |
|||
_classCallCheck(this, InfiniteListItem); |
|||
|
|||
this.value = value; |
|||
this.index = index; |
|||
this.next = function (z) { |
|||
return !z ? list.get(index + 1) : list.get(index + z); |
|||
}; |
|||
this.previous = function (z) { |
|||
return !z ? list.get(index - 1) : list.get(index - z); |
|||
}; |
|||
|
|||
// Check if Symbol exists
|
|||
if (typeof Symbol !== 'undefined' && Symbol.iterator) { |
|||
/** |
|||
* ES6 Symbol.iterator |
|||
* @returns {Iterable.<*>} |
|||
*/ |
|||
this[Symbol.iterator] = function () { |
|||
return { |
|||
next: function next() { |
|||
return { |
|||
done: false, |
|||
value: list.get(index + 1) |
|||
}; |
|||
} |
|||
}; |
|||
}; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* toString method for pretty printing InfiniteListItem instance. |
|||
* @returns {String} Decycled and beautified string |
|||
*/ |
|||
|
|||
|
|||
_createClass(InfiniteListItem, [{ |
|||
key: "toString", |
|||
value: function toString() { |
|||
return 'InfiniteListItem [ .. ' + stringify(this.value) + ' .. ]'; |
|||
} |
|||
}]); |
|||
|
|||
return InfiniteListItem; |
|||
}(); |
|||
|
|||
var InfiniteList = |
|||
/** |
|||
* InfiniteList Constructor. |
|||
* Iterates infinitely until index value is found. |
|||
* Stores cache in closure so when the same index is requested again, |
|||
* it's returned immediately. |
|||
* @param {*} start Starting value |
|||
* @param {Function} next Function to find next item |
|||
* Accepts current value and optionally previous value |
|||
* @constructs InfiniteList |
|||
*/ |
|||
function InfiniteList(start, next) { |
|||
_classCallCheck(this, InfiniteList); |
|||
|
|||
// Closure magic!
|
|||
var cache = []; |
|||
var j = 0; |
|||
|
|||
/** |
|||
* Get InfiniteListItem at index. |
|||
* @param {Number} index A non-negative integer representing index |
|||
* @returns {InfiniteListItem} |
|||
*/ |
|||
this.get = function (index) { |
|||
|
|||
// Validation
|
|||
if ( |
|||
// i is a non-zero falsy value, or is negative
|
|||
isNonZeroFalsy(index) || index < 0 || !areNumbers(index)) return; |
|||
|
|||
//TODO: Cache limiting. (Removed for unexpected behaviour)
|
|||
|
|||
// Initializing first item if it doesn't exist
|
|||
if (!cache[0]) cache[0] = start; |
|||
|
|||
// If index were to be infinity, value and index are infinity
|
|||
if (index === Infinity) return new InfiniteListItem(this, Infinity, Infinity); |
|||
|
|||
// If index exists in cache, return the value
|
|||
if (index in cache) return new InfiniteListItem(this, cache[index], index); |
|||
|
|||
// If i doesn't exist in cache
|
|||
if (!(index in cache)) { |
|||
if (cache.length <= index && cache.length - 1 in cache) while (cache.length <= index) { |
|||
cache[cache.length] = next(cache[cache.length - 1], cache[cache.length - 2]); |
|||
} |
|||
} |
|||
return new InfiniteListItem(this, cache[index], index); |
|||
}; |
|||
|
|||
/** |
|||
* Clear cache manually. |
|||
* Forces destroy reference to cache, and creates a new cache. |
|||
* Old cache will be GC'd. |
|||
* @returns {undefined} |
|||
*/ |
|||
this.clearCache = function () { |
|||
return cache = [], undefined; |
|||
}; |
|||
|
|||
// Check if Symbol exists
|
|||
if (typeof Symbol !== 'undefined' && Symbol.iterator) { |
|||
/** |
|||
* ES6 Symbol.iterator |
|||
* @returns {Iterable.<*>} |
|||
*/ |
|||
this[Symbol.iterator] = function () { |
|||
var _this = this; |
|||
|
|||
return { |
|||
next: function next() { |
|||
return { |
|||
done: false, |
|||
value: _this.get(j++) |
|||
}; |
|||
} |
|||
}; |
|||
}; |
|||
} |
|||
}; |
|||
|
|||
/** |
|||
* Takes a given number of elements from the InfiniteList. |
|||
* @param {Number} from Number of elements or starting index |
|||
* @param {Number} to Optional ending index |
|||
* @returns {Array<InfiniteListItem>} An array of InfiniteListItems |
|||
*/ |
|||
|
|||
|
|||
InfiniteList.prototype.take = function (from, to) { |
|||
var arr = []; |
|||
|
|||
if (isNonZeroFalsy(from) || from === 0 && isNonZeroFalsy(to) // Take 0 elements?
|
|||
|| !areNumbers(from) && isNonZeroFalsy(to)) return arr; |
|||
|
|||
var source = void 0, |
|||
target = void 0; |
|||
// "from" number of elements
|
|||
if (isNonZeroFalsy(to)) { |
|||
source = 0; |
|||
target = from; |
|||
} |
|||
// "target" is the end index!
|
|||
else { |
|||
source = from; |
|||
target = to + 1; |
|||
}; |
|||
|
|||
for (var i = source; i < target; i++) { |
|||
arr.push(this.get(i)); |
|||
}; |
|||
return arr; |
|||
}; |
|||
|
|||
/** |
|||
* Returns first element of InfiniteList. |
|||
* @returns {InfiniteListItem} Instance of InfiniteListItem |
|||
*/ |
|||
InfiniteList.prototype.top = function () { |
|||
return this.get(0); |
|||
}; |
|||
|
|||
/** |
|||
* Returns last element of InfiniteList (Infinity). |
|||
* @returns {InfiniteListItem} Instance of InfiniteListItem |
|||
*/ |
|||
InfiniteList.prototype.end = function () { |
|||
return this.get(Infinity); |
|||
}; |
|||
|
|||
/** |
|||
* toString method for pretty printing InfiniteList instance. |
|||
* Snips at 2 elements for arrays and objects, or 5 elements otherwise. |
|||
* @returns {String} Pretty printed InfiniteList |
|||
*/ |
|||
InfiniteList.prototype.toString = function () { |
|||
var length = _typeof(this.first()) === 'object' ? 2 : 5; |
|||
return ['InfiniteList [', this.take(length).map(function (x) { |
|||
return ' ' + stringify(x.value); |
|||
}) + ',', '... ]'].join(' '); |
|||
}; |
|||
|
|||
/* Convenience methods */ |
|||
InfiniteList.prototype.first = InfiniteList.prototype.top; |
|||
InfiniteList.prototype.last = InfiniteList.prototype.end; |
|||
|
|||
// Exports
|
|||
module.exports = InfiniteList; |
|||
module.exports.InfiniteListItem = InfiniteListItem; |
|||
}, { "./utils": 3 }], 2: [function (require, module, exports) { |
|||
/* |
|||
cycle.js |
|||
2018-05-15 |
|||
Public Domain. |
|||
NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. |
|||
This code should be minified before deployment. |
|||
See http://javascript.crockford.com/jsmin.html
|
|||
USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO |
|||
NOT CONTROL. |
|||
*/ |
|||
|
|||
// The file uses the WeakMap feature of ES6.
|
|||
|
|||
/*jslint eval */ |
|||
|
|||
/*property |
|||
$ref, decycle, forEach, get, indexOf, isArray, keys, length, push, |
|||
retrocycle, set, stringify, test |
|||
*/ |
|||
|
|||
if (typeof JSON.decycle !== "function") { |
|||
JSON.decycle = function decycle(object, replacer) { |
|||
"use strict"; |
|||
|
|||
// Make a deep copy of an object or array, assuring that there is at most
|
|||
// one instance of each object or array in the resulting structure. The
|
|||
// duplicate references (which might be forming cycles) are replaced with
|
|||
// an object of the form
|
|||
|
|||
// {"$ref": PATH}
|
|||
|
|||
// where the PATH is a JSONPath string that locates the first occurance.
|
|||
|
|||
// So,
|
|||
|
|||
// var a = [];
|
|||
// a[0] = a;
|
|||
// return JSON.stringify(JSON.decycle(a));
|
|||
|
|||
// produces the string '[{"$ref":"$"}]'.
|
|||
|
|||
// If a replacer function is provided, then it will be called for each value.
|
|||
// A replacer function receives a value and returns a replacement value.
|
|||
|
|||
// JSONPath is used to locate the unique object. $ indicates the top level of
|
|||
// the object or array. [NUMBER] or [STRING] indicates a child element or
|
|||
// property.
|
|||
|
|||
var objects = new WeakMap(); // object to path mappings
|
|||
|
|||
return function derez(value, path) { |
|||
|
|||
// The derez function recurses through the object, producing the deep copy.
|
|||
|
|||
var old_path; // The path of an earlier occurance of value
|
|||
var nu; // The new object or array
|
|||
|
|||
// If a replacer function was provided, then call it to get a replacement value.
|
|||
|
|||
if (replacer !== undefined) { |
|||
value = replacer(value); |
|||
} |
|||
|
|||
// typeof null === "object", so go on if this value is really an object but not
|
|||
// one of the weird builtin objects.
|
|||
|
|||
if ((typeof value === "undefined" ? "undefined" : _typeof(value)) === "object" && value !== null && !(value instanceof Boolean) && !(value instanceof Date) && !(value instanceof Number) && !(value instanceof RegExp) && !(value instanceof String)) { |
|||
|
|||
// If the value is an object or array, look to see if we have already
|
|||
// encountered it. If so, return a {"$ref":PATH} object. This uses an
|
|||
// ES6 WeakMap.
|
|||
|
|||
old_path = objects.get(value); |
|||
if (old_path !== undefined) { |
|||
return { |
|||
$ref: old_path |
|||
}; |
|||
} |
|||
|
|||
// Otherwise, accumulate the unique value and its path.
|
|||
|
|||
objects.set(value, path); |
|||
|
|||
// If it is an array, replicate the array.
|
|||
|
|||
if (Array.isArray(value)) { |
|||
nu = []; |
|||
value.forEach(function (element, i) { |
|||
nu[i] = derez(element, path + "[" + i + "]"); |
|||
}); |
|||
} else { |
|||
|
|||
// If it is an object, replicate the object.
|
|||
|
|||
nu = {}; |
|||
Object.keys(value).forEach(function (name) { |
|||
nu[name] = derez(value[name], path + "[" + JSON.stringify(name) + "]"); |
|||
}); |
|||
} |
|||
return nu; |
|||
} |
|||
return value; |
|||
}(object, "$"); |
|||
}; |
|||
} |
|||
|
|||
if (typeof JSON.retrocycle !== "function") { |
|||
JSON.retrocycle = function retrocycle($) { |
|||
"use strict"; |
|||
|
|||
// Restore an object that was reduced by decycle. Members whose values are
|
|||
// objects of the form
|
|||
// {$ref: PATH}
|
|||
// are replaced with references to the value found by the PATH. This will
|
|||
// restore cycles. The object will be mutated.
|
|||
|
|||
// The eval function is used to locate the values described by a PATH. The
|
|||
// root object is kept in a $ variable. A regular expression is used to
|
|||
// assure that the PATH is extremely well formed. The regexp contains nested
|
|||
// * quantifiers. That has been known to have extremely bad performance
|
|||
// problems on some browsers for very long strings. A PATH is expected to be
|
|||
// reasonably short. A PATH is allowed to belong to a very restricted subset of
|
|||
// Goessner's JSONPath.
|
|||
|
|||
// So,
|
|||
// var s = '[{"$ref":"$"}]';
|
|||
// return JSON.retrocycle(JSON.parse(s));
|
|||
// produces an array containing a single element which is the array itself.
|
|||
|
|||
var px = /^\$(?:\[(?:\d+|"(?:[^\\"\u0000-\u001f]|\\(?:[\\"\/bfnrt]|u[0-9a-zA-Z]{4}))*")\])*$/; |
|||
|
|||
(function rez(value) { |
|||
|
|||
// The rez function walks recursively through the object looking for $ref
|
|||
// properties. When it finds one that has a value that is a path, then it
|
|||
// replaces the $ref object with a reference to the value that is found by
|
|||
// the path.
|
|||
|
|||
if (value && (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object") { |
|||
if (Array.isArray(value)) { |
|||
value.forEach(function (element, i) { |
|||
if ((typeof element === "undefined" ? "undefined" : _typeof(element)) === "object" && element !== null) { |
|||
var path = element.$ref; |
|||
if (typeof path === "string" && px.test(path)) { |
|||
value[i] = eval(path); |
|||
} else { |
|||
rez(element); |
|||
} |
|||
} |
|||
}); |
|||
} else { |
|||
Object.keys(value).forEach(function (name) { |
|||
var item = value[name]; |
|||
if ((typeof item === "undefined" ? "undefined" : _typeof(item)) === "object" && item !== null) { |
|||
var path = item.$ref; |
|||
if (typeof path === "string" && px.test(path)) { |
|||
value[name] = eval(path); |
|||
} else { |
|||
rez(item); |
|||
} |
|||
} |
|||
}); |
|||
} |
|||
} |
|||
})($); |
|||
return $; |
|||
}; |
|||
} |
|||
|
|||
module.exports = JSON; |
|||
}, {}], 3: [function (require, module, exports) { |
|||
var JSON = require('./cycle'); |
|||
|
|||
var always = function always(x) { |
|||
return function (_) { |
|||
return x; |
|||
}; |
|||
}; |
|||
var isNonZeroFalsy = function isNonZeroFalsy(_) { |
|||
return Boolean(_) === false && _ !== 0; |
|||
}; |
|||
var stringify = function stringify(_) { |
|||
return (typeof _ === "undefined" ? "undefined" : _typeof(_)) === 'object' && _ !== null ? JSON.stringify(JSON.decycle(_), null, 2) : _.toString(); |
|||
}; |
|||
var areNumbers = function areNumbers() { |
|||
for (var _len = arguments.length, items = Array(_len), _key = 0; _key < _len; _key++) { |
|||
items[_key] = arguments[_key]; |
|||
} |
|||
|
|||
return items.every(function (x) { |
|||
return typeof x === 'number' && x !== NaN; |
|||
}); |
|||
}; |
|||
|
|||
module.exports = { |
|||
always: always, |
|||
isNonZeroFalsy: isNonZeroFalsy, |
|||
stringify: stringify, |
|||
areNumbers: areNumbers |
|||
}; |
|||
}, { "./cycle": 2 }] }, {}, [1])(1); |
|||
}); |
|||
File diff suppressed because one or more lines are too long
@ -0,0 +1 @@ |
|||
module.exports = require('..'); |
|||
Loading…
Reference in new issue