store2

You can extend the store interface by using the internal store._ object. The store._.fn(fnName, fn) method automatically adds a new function to every instance of the store interface, including the main store, store.session, and all existing or future namespaces.

Warning: Using _.fn will override existing methods if the names collide.

Example: Adding falsy and truthy helpers

(function(_) {
    _.fn('falsy', function(key) {
        return !this.get(key);
    });
    _.fn('truthy', function(key) {
        return !this.falsy(key);
    });
})(store._);

Once registered, these methods are available on all store instances:

store('foo', 1);
store.falsy('foo'); // returns false

store.session('bar', 'one');
store.session.truthy('bar'); // returns true;

const widgetStore = store.namespace('widget');
widgetStore.falsy('state'); // returns true

Use store.namespace(prefix) to prevent key collisions by adding a prefix to all keys. The namespaced object provides the exact same API as the main store object.

var cart = store.namespace('cart');
cart('total', 23.25); // stores in localStorage as 'cart.total'
console.log(store('cart.total') == cart('total')); // true
console.log(store.cart.getAll()); // {total: 23.25}
cart.session('group', 'toys'); // stores in sessionStorage as 'cart.group'

Advanced Namespace Options:

• Create a namespace only in a specific storage area: store.page.namespace("subpage", true, ":") (where true limits it to the current area and ":" sets a custom delimiter).
• Access namespaces directly via store[namespace] if they don't conflict with the API.

var cart = store.namespace('cart');
cart('total', 23.25);// stores in localStorage as 'cart.total'
console.log(store('cart.total') == cart('total'));// logs true
console.log(store.cart.getAll());// logs {total: 23.25}
cart.session('group', 'toys');// stores in sessionStorage as 'cart.group'

The store library supports various extensions to add specialized behavior. These are categorized by stability:

Stable Extensions

• store.cache.js: Enables data expiration. Pass the number of seconds as the third parameter to set() calls.
• store.array.js: Adds array functions like store.push(key, v1, v2).
• store.on.js: Provides advanced storage event handling (per key, per namespace, etc.).
• store.cookie.js: Uses a cookie as a storage area (e.g., store.cookie('num', 1)).
• store.dom.js: Enables declarative, persistent DOM element content.
• store.overflow.js: Automatically falls back to fake storage on quota errors.
• store.old.js: Provides polyfills for ancient browsers.

Alpha/Experimental Extensions

• store.async.js: Adds an .async duplicate to stores/namespaces that returns Promises.
• store.deep.js: Allows retrieving properties from within stored objects using dot notation (e.g., store.get('key.property')).
• store.dot.js: Creates accessors for keys (e.g., store.foo == store.get('foo')).
• store.quota.js: Allows registering callbacks to handle or cancel quota errors.
• store.cookies.js: Manages all cookies as a storage area via the store API.
• store.onlyreal.js: Silently fails if only fake storage is available.
• store.measure.js: Experimental tool for measuring used and available space.

The main store function is a versatile entry point that handles several actions based on the arguments provided:

• Set data: store(key, data) sets stringified data under key.
• Get data: store(key) gets and parses data stored under key.
• Transaction: store(key, fn[, alt]) runs a transaction function on/with data stored under key.
• Set multiple: store({key: data, key2: data2}) sets all key/data pairs in the object.
• Get all: store() gets all stored key/data pairs as an object.
• Iterate: store((key, data)=>{ }) calls a function for each key/data in storage. Returning false exits the loop.
• Clear all: store(false) clears all items from storage.

store(key, data);                 // sets stringified data under key
store(key);                       // gets and parses data stored under key
store(key, fn[, alt]);            // run transaction function on/with data stored under key
store({key: data, key2: data2});  // sets all key/data pairs in the object
store();                          // gets all stored key/data pairs as an object
store((key, data)=>{ });          // calls function for each key/data in storage, return false to exit
store(false);                     // clears all items from storage

For more explicit control, use the following methods on the store object: