shelf.js
Version:
A modular, powerful wrapper library for persistent objects in the browser and Node.js
1,638 lines (1,328 loc) • 52 kB
JavaScript
/*
http://www.JSON.org/json2.js
2011-02-23
Public Domain.
NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
See http://www.JSON.org/js.html
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.
This file creates a global JSON object containing two methods: stringify
and parse.
JSON.stringify(value, replacer, space)
value any JavaScript value, usually an object or array.
replacer an optional parameter that determines how object
values are stringified for objects. It can be a
function or an array of strings.
space an optional parameter that specifies the indentation
of nested structures. If it is omitted, the text will
be packed without extra whitespace. If it is a number,
it will specify the number of spaces to indent at each
level. If it is a string (such as '\t' or ' '),
it contains the characters used to indent at each level.
This method produces a JSON text from a JavaScript value.
When an object value is found, if the object contains a toJSON
method, its toJSON method will be called and the result will be
stringified. A toJSON method does not serialize: it returns the
value represented by the name/value pair that should be serialized,
or undefined if nothing should be serialized. The toJSON method
will be passed the key associated with the value, and this will be
bound to the value
For example, this would serialize Dates as ISO strings.
Date.prototype.toJSON = function (key) {
function f(n) {
// Format integers to have at least two digits.
return n < 10 ? '0' + n : n;
}
return this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z';
};
You can provide an optional replacer method. It will be passed the
key and value of each member, with this bound to the containing
object. The value that is returned from your method will be
serialized. If your method returns undefined, then the member will
be excluded from the serialization.
If the replacer parameter is an array of strings, then it will be
used to select the members to be serialized. It filters the results
such that only members with keys listed in the replacer array are
stringified.
Values that do not have JSON representations, such as undefined or
functions, will not be serialized. Such values in objects will be
dropped; in arrays they will be replaced with null. You can use
a replacer function to replace those with JSON values.
JSON.stringify(undefined) returns undefined.
The optional space parameter produces a stringification of the
value that is filled with line breaks and indentation to make it
easier to read.
If the space parameter is a non-empty string, then that string will
be used for indentation. If the space parameter is a number, then
the indentation will be that many spaces.
Example:
text = JSON.stringify(['e', {pluribus: 'unum'}]);
// text is '["e",{"pluribus":"unum"}]'
text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
// text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
text = JSON.stringify([new Date()], function (key, value) {
return this[key] instanceof Date ?
'Date(' + this[key] + ')' : value;
});
// text is '["Date(---current time---)"]'
JSON.parse(text, reviver)
This method parses a JSON text to produce an object or array.
It can throw a SyntaxError exception.
The optional reviver parameter is a function that can filter and
transform the results. It receives each of the keys and values,
and its return value is used instead of the original value.
If it returns what it received, then the structure is not modified.
If it returns undefined then the member is deleted.
Example:
// Parse the text. Values that look like ISO date strings will
// be converted to Date objects.
myData = JSON.parse(text, function (key, value) {
var a;
if (typeof value === 'string') {
a =
/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
if (a) {
return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+a[5], +a[6]));
}
}
return value;
});
myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
var d;
if (typeof value === 'string' &&
value.slice(0, 5) === 'Date(' &&
value.slice(-1) === ')') {
d = new Date(value.slice(5, -1));
if (d) {
return d;
}
}
return value;
});
This is a reference implementation. You are free to copy, modify, or
redistribute.
*/
/*jslint evil: true, strict: false, regexp: false */
/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
lastIndex, length, parse, prototype, push, replace, slice, stringify,
test, toJSON, toString, valueOf
*/
// Create a JSON object only if one does not already exist. We create the
// methods in a closure to avoid creating global variables.
var JSON;
if (!JSON) {
JSON = {};
}
(function () {
"use strict";
var global = Function('return this')()
, JSON = global.JSON
;
if (!JSON) {
JSON = {};
}
function f(n) {
// Format integers to have at least two digits.
return n < 10 ? '0' + n : n;
}
if (typeof Date.prototype.toJSON !== 'function') {
Date.prototype.toJSON = function (key) {
return isFinite(this.valueOf()) ?
this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z' : null;
};
String.prototype.toJSON =
Number.prototype.toJSON =
Boolean.prototype.toJSON = function (key) {
return this.valueOf();
};
}
var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
gap,
indent,
meta = { // table of character substitutions
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'"' : '\\"',
'\\': '\\\\'
},
rep;
function quote(string) {
// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can safely slap some quotes around it.
// Otherwise we must also replace the offending characters with safe escape
// sequences.
escapable.lastIndex = 0;
return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
var c = meta[a];
return typeof c === 'string' ? c :
'\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
}) + '"' : '"' + string + '"';
}
function str(key, holder) {
// Produce a string from holder[key].
var i, // The loop counter.
k, // The member key.
v, // The member value.
length,
mind = gap,
partial,
value = holder[key];
// If the value has a toJSON method, call it to obtain a replacement value.
if (value && typeof value === 'object' &&
typeof value.toJSON === 'function') {
value = value.toJSON(key);
}
// If we were called with a replacer function, then call the replacer to
// obtain a replacement value.
if (typeof rep === 'function') {
value = rep.call(holder, key, value);
}
// What happens next depends on the value's type.
switch (typeof value) {
case 'string':
return quote(value);
case 'number':
// JSON numbers must be finite. Encode non-finite numbers as null.
return isFinite(value) ? String(value) : 'null';
case 'boolean':
case 'null':
// If the value is a boolean or null, convert it to a string. Note:
// typeof null does not produce 'null'. The case is included here in
// the remote chance that this gets fixed someday.
return String(value);
// If the type is 'object', we might be dealing with an object or an array or
// null.
case 'object':
// Due to a specification blunder in ECMAScript, typeof null is 'object',
// so watch out for that case.
if (!value) {
return 'null';
}
// Make an array to hold the partial results of stringifying this object value.
gap += indent;
partial = [];
// Is the value an array?
if (Object.prototype.toString.apply(value) === '[object Array]') {
// The value is an array. Stringify every element. Use null as a placeholder
// for non-JSON values.
length = value.length;
for (i = 0; i < length; i += 1) {
partial[i] = str(i, value) || 'null';
}
// Join all of the elements together, separated with commas, and wrap them in
// brackets.
v = partial.length === 0 ? '[]' : gap ?
'[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
'[' + partial.join(',') + ']';
gap = mind;
return v;
}
// If the replacer is an array, use it to select the members to be stringified.
if (rep && typeof rep === 'object') {
length = rep.length;
for (i = 0; i < length; i += 1) {
if (typeof rep[i] === 'string') {
k = rep[i];
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ': ' : ':') + v);
}
}
}
} else {
// Otherwise, iterate through all of the keys in the object.
for (k in value) {
if (Object.prototype.hasOwnProperty.call(value, k)) {
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ': ' : ':') + v);
}
}
}
}
// Join all of the member texts together, separated with commas,
// and wrap them in braces.
v = partial.length === 0 ? '{}' : gap ?
'{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
'{' + partial.join(',') + '}';
gap = mind;
return v;
}
}
// If the JSON object does not yet have a stringify method, give it one.
if (typeof JSON.stringify !== 'function') {
JSON.stringify = function (value, replacer, space) {
// The stringify method takes a value and an optional replacer, and an optional
// space parameter, and returns a JSON text. The replacer can be a function
// that can replace values, or an array of strings that will select the keys.
// A default replacer method can be provided. Use of the space parameter can
// produce text that is more easily readable.
var i;
gap = '';
indent = '';
// If the space parameter is a number, make an indent string containing that
// many spaces.
if (typeof space === 'number') {
for (i = 0; i < space; i += 1) {
indent += ' ';
}
// If the space parameter is a string, it will be used as the indent string.
} else if (typeof space === 'string') {
indent = space;
}
// If there is a replacer, it must be a function or an array.
// Otherwise, throw an error.
rep = replacer;
if (replacer && typeof replacer !== 'function' &&
(typeof replacer !== 'object' ||
typeof replacer.length !== 'number')) {
throw new Error('JSON.stringify');
}
// Make a fake root object containing our value under the key of ''.
// Return the result of stringifying the value.
return str('', {'': value});
};
}
// If the JSON object does not yet have a parse method, give it one.
if (typeof JSON.parse !== 'function') {
JSON.parse = function (text, reviver) {
// The parse method takes a text and an optional reviver function, and returns
// a JavaScript value if the text is a valid JSON text.
var j;
function walk(holder, key) {
// The walk method is used to recursively walk the resulting structure so
// that modifications can be made.
var k, v, value = holder[key];
if (value && typeof value === 'object') {
for (k in value) {
if (Object.prototype.hasOwnProperty.call(value, k)) {
v = walk(value, k);
if (v !== undefined) {
value[k] = v;
} else {
delete value[k];
}
}
}
}
return reviver.call(holder, key, value);
}
// Parsing happens in four stages. In the first stage, we replace certain
// Unicode characters with escape sequences. JavaScript handles many characters
// incorrectly, either silently deleting them, or treating them as line endings.
text = String(text);
cx.lastIndex = 0;
if (cx.test(text)) {
text = text.replace(cx, function (a) {
return '\\u' +
('0000' + a.charCodeAt(0).toString(16)).slice(-4);
});
}
// In the second stage, we run the text against regular expressions that look
// for non-JSON patterns. We are especially concerned with '()' and 'new'
// because they can cause invocation, and '=' because it can cause mutation.
// But just to be safe, we want to reject all unexpected forms.
// We split the second stage into 4 regexp operations in order to work around
// crippling inefficiencies in IE's and Safari's regexp engines. First we
// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
// replace all simple value tokens with ']' characters. Third, we delete all
// open brackets that follow a colon or comma or that begin the text. Finally,
// we look to see that the remaining characters are only whitespace or ']' or
// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
if (/^[\],:{}\s]*$/
.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
.replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
// In the third stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.
j = eval('(' + text + ')');
// In the optional fourth stage, we recursively walk the new structure, passing
// each name/value pair to a reviver function for possible transformation.
return typeof reviver === 'function' ?
walk({'': j}, '') : j;
}
// If the text is not JSON parseable, then a SyntaxError is thrown.
throw new SyntaxError('JSON.parse');
};
}
global.JSON = JSON;
// 10.05.2013 mod for browsers compatibility
if (JSUS.isNodeJS()) {
module.exports = JSON;
}
}());
// cycle.js
// 2011-08-24
/*jslint evil: true, regexp: true */
/*members $ref, apply, call, decycle, hasOwnProperty, length, prototype, push,
retrocycle, stringify, test, toString
*/
if (typeof JSON.decycle !== 'function') {
JSON.decycle = function decycle(object) {
'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":"$"}]'.
// JSONPath is used to locate the unique object. $ indicates the top level of
// the object or array. [NUMBER] or [STRING] indicates a child member or
// property.
var objects = [], // Keep a reference to each unique object or array
paths = []; // Keep the path to each unique object or array
return (function derez(value, path) {
// The derez recurses through the object, producing the deep copy.
var i, // The loop counter
name, // Property name
nu; // The new object or array
switch (typeof value) {
case 'object':
// typeof null === 'object', so get out if this value is not really an object.
if (!value) {
return null;
}
// 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 is a hard way,
// linear search that will get slower as the number of unique objects grows.
for (i = 0; i < objects.length; i += 1) {
if (objects[i] === value) {
return {$ref: paths[i]};
}
}
// Otherwise, accumulate the unique value and its path.
objects.push(value);
paths.push(path);
// If it is an array, replicate the array.
if (Object.prototype.toString.apply(value) === '[object Array]') {
nu = [];
for (i = 0; i < value.length; i += 1) {
nu[i] = derez(value[i], path + '[' + i + ']');
}
} else {
// If it is an object, replicate the object.
nu = {};
for (name in value) {
if (Object.prototype.hasOwnProperty.call(value, name)) {
nu[name] = derez(value[name],
path + '[' + JSON.stringify(name) + ']');
}
}
}
return nu;
case 'number':
case 'string':
case 'boolean':
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.
var i, item, name, path;
if (value && typeof value === 'object') {
if (Object.prototype.toString.apply(value) === '[object Array]') {
for (i = 0; i < value.length; i += 1) {
item = value[i];
if (item && typeof item === 'object') {
path = item.$ref;
if (typeof path === 'string' && px.test(path)) {
value[i] = eval(path);
} else {
rez(item);
}
}
}
} else {
for (name in value) {
if (typeof value[name] === 'object') {
item = value[name];
if (item) {
path = item.$ref;
if (typeof path === 'string' && px.test(path)) {
value[name] = eval(path);
} else {
rez(item);
}
}
}
}
}
}
}($));
return $;
};
}
/**
* # Shelf.JS
* Copyright 2014 Stefano Balietti
* GPL licenses.
*
* Persistent Client-Side Storage
* ---
*/
(function(exports) {
var version = '5.1';
var store, mainStorageType;
mainStorageType = "volatile";
store = exports.store = function(key, value, options, type) {
options = options || {};
type = (options.type && options.type in store.types) ?
options.type : store.type;
if (!type || !store.types[type]) {
store.log('Cannot save/load value. Invalid storage type ' +
'selected: ' + type, 'ERR');
return;
}
store.log('Accessing ' + type + ' storage');
return store.types[type](key, value, options);
};
// Adding functions and properties to store
///////////////////////////////////////////
store.prefix = "__shelf__";
store.verbosity = 0;
store.types = {};
//if Object.defineProperty works...
try {
Object.defineProperty(store, 'type', {
set: function(type) {
if ('undefined' === typeof store.types[type]) {
store.log('Cannot set store.type to an invalid type: ' +
type);
return false;
}
mainStorageType = type;
return type;
},
get: function(){
return mainStorageType;
},
configurable: false,
enumerable: true
});
}
catch(e) {
store.type = mainStorageType; // default: memory
}
store.addType = function(type, storage) {
store.types[type] = storage;
store[type] = function(key, value, options) {
options = options || {};
options.type = type;
return store(key, value, options);
};
if (!store.type || store.type === "volatile") {
store.type = type;
}
};
// TODO: create unit test
store.onquotaerror = undefined;
store.error = function() {
console.log("shelf quota exceeded");
if ('function' === typeof store.onquotaerror) {
store.onquotaerror(null);
}
};
store.log = function(text) {
if (store.verbosity > 0) {
console.log('Shelf v.' + version + ': ' + text);
}
};
store.isPersistent = function() {
if (!store.types) return false;
if (store.type === "volatile") return false;
return true;
};
//if Object.defineProperty works...
try {
Object.defineProperty(store, 'persistent', {
set: function(){},
get: store.isPersistent,
configurable: false
});
}
catch(e) {
// safe case
store.persistent = false;
}
store.decycle = function(o) {
if (JSON && JSON.decycle && 'function' === typeof JSON.decycle) {
o = JSON.decycle(o);
}
return o;
};
store.retrocycle = function(o) {
if (JSON && JSON.retrocycle && 'function' === typeof JSON.retrocycle) {
o = JSON.retrocycle(o);
}
return o;
};
store.stringify = function(o) {
if (!JSON || !JSON.stringify || 'function' !== typeof JSON.stringify) {
throw new Error('JSON.stringify not found. Received non-string' +
'value and could not serialize.');
}
o = store.decycle(o);
return JSON.stringify(o);
};
store.parse = function(o) {
if ('undefined' === typeof o) return undefined;
if (JSON && JSON.parse && 'function' === typeof JSON.parse) {
try {
o = JSON.parse(o);
}
catch (e) {
store.log('Error while parsing a value: ' + e, 'ERR');
store.log(o);
}
}
o = store.retrocycle(o);
return o;
};
// ## In-memory storage
// ### fallback to enable the API even if we can't persist data
(function() {
var memory = {},
timeout = {};
function copy(obj) {
return store.parse(store.stringify(obj));
}
store.addType("volatile", function(key, value, options) {
if (!key) {
return copy(memory);
}
if (value === undefined) {
return copy(memory[key]);
}
if (timeout[key]) {
clearTimeout(timeout[key]);
delete timeout[key];
}
if (value === null) {
delete memory[key];
return null;
}
memory[key] = value;
if (options.expires) {
timeout[key] = setTimeout(function() {
delete memory[key];
delete timeout[key];
}, options.expires);
}
return value;
});
}());
}(
'undefined' !== typeof module && 'undefined' !== typeof module.exports ?
module.exports : this
));
/**
* ## Amplify storage for Shelf.js
* Copyright 2014 Stefano Balietti
*
* v. 1.1.0 22.05.2013 a275f32ee7603fbae6607c4e4f37c4d6ada6c3d5
*
* Important! When updating to next Amplify.JS release, remember to change:
*
* - JSON.stringify -> store.stringify to keep support for cyclic objects
* - JSON.parse -> store.parse (cyclic objects)
* - store.name -> store.prefix (check)
* - rprefix -> regex
* - "__amplify__" -> store.prefix
*
* ---
*/
(function(exports) {
var store = exports.store;
if (!store) {
throw new Error('amplify.shelf.js: shelf.js core not found.');
}
if ('undefined' === typeof window) {
throw new Error('amplify.shelf.js: window object not found.');
}
var regex = new RegExp("^" + store.prefix);
function createFromStorageInterface( storageType, storage ) {
store.addType( storageType, function( key, value, options ) {
var storedValue, parsed, i, remove,
ret = value,
now = (new Date()).getTime();
if ( !key ) {
ret = {};
remove = [];
i = 0;
try {
// accessing the length property works around a localStorage bug
// in Firefox 4.0 where the keys don't update cross-page
// we assign to key just to avoid Closure Compiler from removing
// the access as "useless code"
// https://bugzilla.mozilla.org/show_bug.cgi?id=662511
key = storage.length;
while ( key = storage.key( i++ ) ) {
if ( regex.test( key ) ) {
parsed = store.parse( storage.getItem( key ) );
if ( parsed.expires && parsed.expires <= now ) {
remove.push( key );
} else {
ret[ key.replace( rprefix, "" ) ] = parsed.data;
}
}
}
while ( key = remove.pop() ) {
storage.removeItem( key );
}
} catch ( error ) {}
return ret;
}
// protect against name collisions with direct storage
key = store.prefix + key;
if ( value === undefined ) {
storedValue = storage.getItem( key );
parsed = storedValue ? store.parse( storedValue ) : { expires: -1 };
if ( parsed.expires && parsed.expires <= now ) {
storage.removeItem( key );
} else {
return parsed.data;
}
} else {
if ( value === null ) {
storage.removeItem( key );
} else {
parsed = store.stringify({
data: value,
expires: options.expires ? now + options.expires : null
});
try {
storage.setItem( key, parsed );
// quota exceeded
} catch( error ) {
// expire old data and try again
store[ storageType ]();
try {
storage.setItem( key, parsed );
} catch( error ) {
throw store.error();
}
}
}
}
return ret;
});
}
// localStorage + sessionStorage
// IE 8+, Firefox 3.5+, Safari 4+, Chrome 4+, Opera 10.5+, iPhone 2+, Android 2+
for ( var webStorageType in { localStorage: 1, sessionStorage: 1 } ) {
// try/catch for file protocol in Firefox and Private Browsing in Safari 5
try {
// Safari 5 in Private Browsing mode exposes localStorage
// but doesn't allow storing data, so we attempt to store and remove an item.
// This will unfortunately give us a false negative if we're at the limit.
window[ webStorageType ].setItem(store.prefix, "x" );
window[ webStorageType ].removeItem(store.prefix );
createFromStorageInterface( webStorageType, window[ webStorageType ] );
} catch( e ) {}
}
// globalStorage
// non-standard: Firefox 2+
// https://developer.mozilla.org/en/dom/storage#globalStorage
if ( !store.types.localStorage && window.globalStorage ) {
// try/catch for file protocol in Firefox
try {
createFromStorageInterface( "globalStorage",
window.globalStorage[ window.location.hostname ] );
// Firefox 2.0 and 3.0 have sessionStorage and globalStorage
// make sure we default to globalStorage
// but don't default to globalStorage in 3.5+ which also has localStorage
if ( store.type === "sessionStorage" ) {
store.type = "globalStorage";
}
} catch( e ) {}
}
// userData
// non-standard: IE 5+
// http://msdn.microsoft.com/en-us/library/ms531424(v=vs.85).aspx
(function() {
// IE 9 has quirks in userData that are a huge pain
// rather than finding a way to detect these quirks
// we just don't register userData if we have localStorage
if ( store.types.localStorage ) {
return;
}
// append to html instead of body so we can do this from the head
var div = document.createElement( "div" ),
attrKey = store.prefix; // was "amplify" and not __amplify__
div.style.display = "none";
document.getElementsByTagName( "head" )[ 0 ].appendChild( div );
// we can't feature detect userData support
// so just try and see if it fails
// surprisingly, even just adding the behavior isn't enough for a failure
// so we need to load the data as well
try {
div.addBehavior( "#default#userdata" );
div.load( attrKey );
} catch( e ) {
div.parentNode.removeChild( div );
return;
}
store.addType( "userData", function( key, value, options ) {
div.load( attrKey );
var attr, parsed, prevValue, i, remove,
ret = value,
now = (new Date()).getTime();
if ( !key ) {
ret = {};
remove = [];
i = 0;
while ( attr = div.XMLDocument.documentElement.attributes[ i++ ] ) {
parsed = store.parse( attr.value );
if ( parsed.expires && parsed.expires <= now ) {
remove.push( attr.name );
} else {
ret[ attr.name ] = parsed.data;
}
}
while ( key = remove.pop() ) {
div.removeAttribute( key );
}
div.save( attrKey );
return ret;
}
// convert invalid characters to dashes
// http://www.w3.org/TR/REC-xml/#NT-Name
// simplified to assume the starting character is valid
// also removed colon as it is invalid in HTML attribute names
key = key.replace( /[^\-._0-9A-Za-z\xb7\xc0-\xd6\xd8-\xf6\xf8-\u037d\u037f-\u1fff\u200c-\u200d\u203f\u2040\u2070-\u218f]/g, "-" );
// adjust invalid starting character to deal with our simplified sanitization
key = key.replace( /^-/, "_-" );
if ( value === undefined ) {
attr = div.getAttribute( key );
parsed = attr ? store.parse( attr ) : { expires: -1 };
if ( parsed.expires && parsed.expires <= now ) {
div.removeAttribute( key );
} else {
return parsed.data;
}
} else {
if ( value === null ) {
div.removeAttribute( key );
} else {
// we need to get the previous value in case we need to rollback
prevValue = div.getAttribute( key );
parsed = store.stringify({
data: value,
expires: (options.expires ? (now + options.expires) : null)
});
div.setAttribute( key, parsed );
}
}
try {
div.save( attrKey );
// quota exceeded
} catch ( error ) {
// roll the value back to the previous value
if ( prevValue === null ) {
div.removeAttribute( key );
} else {
div.setAttribute( key, prevValue );
}
// expire old data and try again
store.userData();
try {
div.setAttribute( key, parsed );
div.save( attrKey );
} catch ( error ) {
// roll the value back to the previous value
if ( prevValue === null ) {
div.removeAttribute( key );
} else {
div.setAttribute( key, prevValue );
}
throw store.error();
}
}
return ret;
});
}());
}(this));
/**
* ## Cookie storage for Shelf.js
* Copyright 2014 Stefano Balietti
*
* Original library from:
* See http://code.google.com/p/cookies/
*/
(function(exports) {
var store = exports.store;
if (!store) {
throw new Error('cookie.shelf.js: shelf.js core not found.');
}
if ('undefined' === typeof window) {
throw new Error('cookie.shelf.js: window object not found.');
}
var cookie = (function() {
var resolveOptions, assembleOptionsString, parseCookies, constructor;
var defaultOptions = {
expiresAt: null,
path: '/',
domain: null,
secure: false
};
/**
* resolveOptions - receive an options object and ensure all options
* are present and valid, replacing with defaults where necessary
*
* @access private
* @static
* @parameter Object options - optional options to start with
* @return Object complete and valid options object
*/
resolveOptions = function(options){
var returnValue, expireDate;
if(typeof options !== 'object' || options === null){
returnValue = defaultOptions;
}
else {
returnValue = {
expiresAt: defaultOptions.expiresAt,
path: defaultOptions.path,
domain: defaultOptions.domain,
secure: defaultOptions.secure
};
if (typeof options.expiresAt === 'object' && options.expiresAt instanceof Date) {
returnValue.expiresAt = options.expiresAt;
}
else if (typeof options.hoursToLive === 'number' && options.hoursToLive !== 0){
expireDate = new Date();
expireDate.setTime(expireDate.getTime() + (options.hoursToLive * 60 * 60 * 1000));
returnValue.expiresAt = expireDate;
}
if (typeof options.path === 'string' && options.path !== '') {
returnValue.path = options.path;
}
if (typeof options.domain === 'string' && options.domain !== '') {
returnValue.domain = options.domain;
}
if (options.secure === true) {
returnValue.secure = options.secure;
}
}
return returnValue;
};
/**
* assembleOptionsString - analyze options and assemble appropriate string for setting a cookie with those options
*
* @access private
* @static
* @parameter options OBJECT - optional options to start with
* @return STRING - complete and valid cookie setting options
*/
assembleOptionsString = function (options) {
options = resolveOptions(options);
return (
(typeof options.expiresAt === 'object' && options.expiresAt instanceof Date ? '; expires=' + options.expiresAt.toGMTString() : '') +
'; path=' + options.path +
(typeof options.domain === 'string' ? '; domain=' + options.domain : '') +
(options.secure === true ? '; secure' : '')
);
};
/**
* parseCookies - retrieve document.cookie string and break it into a hash with values decoded and unserialized
*
* @access private
* @static
* @return OBJECT - hash of cookies from document.cookie
*/
parseCookies = function() {
var cookies = {}, i, pair, name, value, separated = document.cookie.split(';'), unparsedValue;
for(i = 0; i < separated.length; i = i + 1){
pair = separated[i].split('=');
name = pair[0].replace(/^\s*/, '').replace(/\s*$/, '');
try {
value = decodeURIComponent(pair[1]);
}
catch(e1) {
value = pair[1];
}
// if (JSON && 'object' === typeof JSON && 'function' === typeof JSON.parse) {
// try {
// unparsedValue = value;
// value = JSON.parse(value);
// }
// catch (e2) {
// value = unparsedValue;
// }
// }
cookies[name] = store.parse(value);
}
return cookies;
};
constructor = function(){};
/**
* get - get one, several, or all cookies
*
* @access public
* @paramater Mixed cookieName - String:name of single cookie; Array:list of multiple cookie names; Void (no param):if you want all cookies
* @return Mixed - Value of cookie as set; Null:if only one cookie is requested and is not found; Object:hash of multiple or all cookies (if multiple or all requested);
*/
constructor.prototype.get = function(cookieName) {
var returnValue, item, cookies = parseCookies();
if(typeof cookieName === 'string') {
returnValue = (typeof cookies[cookieName] !== 'undefined') ? cookies[cookieName] : null;
}
else if (typeof cookieName === 'object' && cookieName !== null) {
returnValue = {};
for (item in cookieName) {
if (typeof cookies[cookieName[item]] !== 'undefined') {
returnValue[cookieName[item]] = cookies[cookieName[item]];
}
else {
returnValue[cookieName[item]] = null;
}
}
}
else {
returnValue = cookies;
}
return returnValue;
};
/**
* filter - get array of cookies whose names match the provided RegExp
*
* @access public
* @paramater Object RegExp - The regular expression to match against cookie names
* @return Mixed - Object:hash of cookies whose names match the RegExp
*/
constructor.prototype.filter = function (cookieNameRegExp) {
var cookieName, returnValue = {}, cookies = parseCookies();
if (typeof cookieNameRegExp === 'string') {
cookieNameRegExp = new RegExp(cookieNameRegExp);
}
for (cookieName in cookies) {
if (cookieName.match(cookieNameRegExp)) {
returnValue[cookieName] = cookies[cookieName];
}
}
return returnValue;
};
/**
* set - set or delete a cookie with desired options
*
* @access public
* @paramater String cookieName - name of cookie to set
* @paramater Mixed value - Any JS value. If not a string, will be JSON encoded; NULL to delete
* @paramater Object options - optional list of cookie options to specify
* @return void
*/
constructor.prototype.set = function(cookieName, value, options){
if (typeof options !== 'object' || options === null) {
options = {};
}
if (typeof value === 'undefined' || value === null) {
value = '';
options.hoursToLive = -8760;
}
else if (typeof value !== 'string'){
// if(typeof JSON === 'object' && JSON !== null && typeof store.stringify === 'function') {
//
// value = JSON.stringify(value);
// }
// else {
// throw new Error('cookies.set() received non-string value and could not serialize.');
// }
value = store.stringify(value);
}
var optionsString = assembleOptionsString(options);
document.cookie = cookieName + '=' + encodeURIComponent(value) + optionsString;
};
/**
* del - delete a cookie (domain and path options must match those with which the cookie was set; this is really an alias for set() with parameters simplified for this use)
*
* @access public
* @paramater MIxed cookieName - String name of cookie to delete, or Bool true to delete all
* @paramater Object options - optional list of cookie options to specify (path, domain)
* @return void
*/
constructor.prototype.del = function(cookieName, options) {
var allCookies = {}, name;
if(typeof options !== 'object' || options === null) {
options = {};
}
if(typeof cookieName === 'boolean' && cookieName === true) {
allCookies = this.get();
}
else if(typeof cookieName === 'string') {
allCookies[cookieName] = true;
}
for(name in allCookies) {
if(typeof name === 'string' && name !== '') {
this.set(name, null, options);
}
}
};
/**
* test - test whether the browser is accepting cookies
*
* @access public
* @return Boolean
*/
constructor.prototype.test = function() {
var returnValue = false, testName = 'cT', testValue = 'data';
this.set(testName, testValue);
if(this.get(testName) === testValue) {
this.del(testName);
returnValue = true;
}
return returnValue;
};
/**
* setOptions - set default options for calls to cookie methods
*
* @access public
* @param Object options - list of cookie options to specify
* @return void
*/
constructor.prototype.setOptions = function(options) {
if(typeof options !== 'object') {
options = null;
}
defaultOptions = resolveOptions(options);
};
return new constructor();
})();
// if cookies are supported by the browser
if (cookie.test()) {
store.addType("cookie", function(key, value, options) {
if ('undefined' === typeof key) {
return cookie.get();
}
if ('undefined' === typeof value) {
return cookie.get(key);
}
// Set to NULL means delete
if (value === null) {
cookie.del(key);
return null;
}
return cookie.set(key, value, options);
});
}
}(this));
/**
* ## File System storage for Shelf.js
* Copyright 2015 Stefano Balietti
*
* Available only in Node.JS
*/
(function(exports) {
var store = exports.store;
if (!store) {
throw new Error('fs.shelf.js: shelf.js core not found.');
}
var lock = false;
var queue = [];
function clearQueue() {
if (isLocked()) {
// console.log('cannot clear queue if lock is active');
return false;
}
// console.log('clearing queue');
for (var i=0; i< queue.length; i++) {
queue[i].call(queue[i]);
}
}
function locked() {
lock = true;
}
function unlocked() {
lock = false;
}
function isLocked() {
return lock;
}
function addToQueue(cb) {
queue.push(cb);
}
var counter = 0;
store.filename = './shelf.out';
var fs = require('fs'),
path = require('path'),
util = require('util');
// https://github.com/jprichardson/node-fs-extra/blob/master/lib/copy.js
//var copyFile = function(srcFile, destFile, cb) {
//
// var fdr, fdw;
//
// fdr = fs.createReadStream(srcFile, {
// flags: 'r'
// });
//// fs.flockSync(fdr, 'sh');
//
// fdw = fs.createWriteStream(destFile, {
// flags: 'w'
// });
//
//// fs.flockSync(fdw, 'ex');
//
// fdr.on('end', function() {
//// fs.flockSync(fdr, 'un');
// });
//
// fdw.on('close', function() {
//// fs.flockSync(fdw, 'un');
// if (cb) cb(null);
// });
//
// fdr.pipe(fdw);
//};
//var overwrite = function (fileName, items) {
//console.log('OW: ' + counter++);
//
//var file = fileName || store.filename;
//if (!file) {
// store.log('You must specify a valid file.', 'ERR');
// return false;
//}
//
//var tmp_copy = path.dirname(file) + '/.' + path.basename(file);
//
////console.log('files')
////console.log(file);
////console.log(fileName);
////console.log(tmp_copy)
//
//copyFile(file, tmp_copy, function(){
// var s = store.stringify(items);
// // removing leading { and trailing }
// s = s.substr(1, s = s.substr(0, s.legth-1));
//// console.log('SAVING')
//// console.log(s)
// fs.writeFile(file, s, 'utf-8', function(e) {
// console.log('UNLINK ' + counter)
// if (e) throw e;
//// fs.unlinkSync(tmp_copy);
// fs.unlink(tmp_copy, function (err) {
// if (err) throw err;
// });
// return true;
// });
//
//});
//
//};
var BUF_LENGTH = 64 * 1024;
var _buff = new Buffer(BUF_LENGTH);
var copyFileSync = function(srcFile, destFile) {
var bytesRead, fdr, fdw, pos;
fdr = fs.openSync(srcFile, 'r');
fdw = fs.openSync(destFile, 'w');
bytesRead = 1;
pos = 0;
while (bytesRead > 0) {
bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
fs.writeSync(fdw, _buff, 0, bytesRead);
pos += bytesRead;
}
fs.closeSync(fdr);
return fs.closeSync(fdw);
};
var timeout = {};
var overwrite = function (fileName, items) {
if (isLocked()) {
addToQueue(this);
return false;
}
locked();
// console.log('OW: ' + counter++);
var file = fileName || store.filename;
if (!file) {
store.log('You must specify a valid file.', 'ERR');
return false;
}
var tmp_copy = path.dirname(file) + '/.' + path.basename(file);
copyFileSync(file, tmp_copy);
var s = store.stringify(items);
// removing leading { and trailing }
s = s.substr(1, s = s.substr(0, s.legth-1));
fs.writeFileSync(file, s, 'utf-8');
fs.unlinkSync(tmp_copy);
// console.log('UNLINK ' + counter);
unlocked();
clearQueue();
return true;
};
if ('undefined' !== typeof fs.appendFileSync) {
// node 0.8
var save = function (fileName, key, value) {
var file = fileName || store.filename;
if (!file) {
store.log('You must specify a valid file.', 'ERR');
return false;
}
if (!key) return;
var item = store.stringify(key) + ": " +
store.stringify(value) + ",\n";
return fs.appendFileSync(file, item, 'utf-8');
};
}
else {
// node < 0.8
var save = function (fileName, key, value) {
var file = fileName || store.filename;
if (!file) {
store.log('You must specify a valid file.', 'ERR');
return false;
}
if (!key) return;
var item = store.stringify(key) + ": " +
store.stringify(value) + ",\n";
var fd = fs.openSync(file