@converse/skeletor 0.0.8 → 0.0.9

package/src/drivers/sessionStorage.js~

@@ -1,307 +0,0 @@
-// Copyright 2014 Mozilla
-// Copyright 2015 Thodoris Greasidis
-// Copyright 2018 JC Brand
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import executeCallback from 'localforage/src/utils/executeCallback';
-import getCallback from 'localforage/src/utils/getCallback';
-import normalizeKey from 'localforage/src/utils/normalizeKey';
-import serializer from 'localforage/src/utils/serializer';
-
-const serialize = serializer["serialize"];
-const deserialize = serializer["deserialize"];
-
-
-function isSessionStorageValid () {
-    // If the app is running inside a Google Chrome packaged webapp, or some
-    // other context where sessionStorage isn't available, we don't use
-    // sessionStorage. This feature detection is preferred over the old
-    // `if (window.chrome && window.chrome.runtime)` code.
-    // See: https://github.com/mozilla/localForage/issues/68
-    try {
-        // If sessionStorage isn't available, we get outta here!
-        // This should be inside a try catch
-        if (sessionStorage && ('setItem' in sessionStorage)) {
-            return true;
-        }
-    } catch (e) {
-        console.log(e);
-    }
-    return false;
-}
-
-function _getKeyPrefix(options, defaultConfig) {
-    let keyPrefix = options.name + '/';
-
-    if (options.storeName !== defaultConfig.storeName) {
-        keyPrefix += options.storeName + '/';
-    }
-    return keyPrefix;
-}
-
-const dbInfo = {
-    'serializer': {
-        'serialize': serialize,
-        'deserialize': deserialize
-    }
-};
-
-function _initStorage(options) {
-    dbInfo.keyPrefix = _getKeyPrefix(options, this._defaultConfig);
-    if (options) {
-        for (const i in options) { // eslint-disable-line guard-for-in
-            dbInfo[i] = options[i];
-        }
-    }
-}
-
-// Remove all keys from the datastore, effectively destroying all data in
-// the app's key/value store!
-function clear(callback) {
-    const promise = this.ready().then(function() {
-        const keyPrefix = dbInfo.keyPrefix;
-
-        for (let i = sessionStorage.length - 1; i >= 0; i--) {
-            const key = sessionStorage.key(i);
-
-            if (key.indexOf(keyPrefix) === 0) {
-                sessionStorage.removeItem(key);
-            }
-        }
-    });
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-// Retrieve an item from the store. Unlike the original async_storage
-// library in Gaia, we don't modify return values at all. If a key's value
-// is `undefined`, we pass that value to the callback function.
-function getItem(key, callback) {
-    key = normalizeKey(key);
-
-    const promise = this.ready().then(function() {
-        let result = sessionStorage.getItem(dbInfo.keyPrefix + key);
-        // If a result was found, parse it from the serialized
-        // string into a JS object. If result isn't truthy, the key
-        // is likely undefined and we'll pass it straight to the
-        // callback.
-        if (result) {
-            result = dbInfo.serializer.deserialize(result);
-        }
-        return result;
-    });
-    executeCallback(promise, callback);
-    return promise;
-}
-
-// Iterate over all items in the store.
-function iterate(iterator, callback) {
-    const self = this;
-
-    const promise = self.ready().then(function() {
-        const keyPrefix = dbInfo.keyPrefix;
-        const keyPrefixLength = keyPrefix.length;
-        const length = sessionStorage.length;
-
-        // We use a dedicated iterator instead of the `i` variable below
-        // so other keys we fetch in sessionStorage aren't counted in
-        // the `iterationNumber` argument passed to the `iterate()`
-        // callback.
-        //
-        // See: github.com/mozilla/localForage/pull/435#discussion_r38061530
-        let iterationNumber = 1;
-
-        for (let i = 0; i < length; i++) {
-            const key = sessionStorage.key(i);
-            if (key.indexOf(keyPrefix) !== 0) {
-                continue;
-            }
-            let value = sessionStorage.getItem(key);
-
-            // If a result was found, parse it from the serialized
-            // string into a JS object. If result isn't truthy, the
-            // key is likely undefined and we'll pass it straight
-            // to the iterator.
-            if (value) {
-                value = dbInfo.serializer.deserialize(value);
-            }
-
-            value = iterator(
-                value,
-                key.substring(keyPrefixLength),
-                iterationNumber++
-            );
-
-            if (value !== void 0) { // eslint-disable-line no-void
-                return value;
-            }
-        }
-    });
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-// Same as sessionStorage's key() method, except takes a callback.
-function key(n, callback) {
-    const self = this;
-    const promise = self.ready().then(function() {
-        let result;
-        try {
-            result = sessionStorage.key(n);
-        } catch (error) {
-            result = null;
-        }
-
-        // Remove the prefix from the key, if a key is found.
-        if (result) {
-            result = result.substring(dbInfo.keyPrefix.length);
-        }
-
-        return result;
-    });
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-function keys(callback) {
-    const self = this;
-    const promise = self.ready().then(function() {
-        const length = sessionStorage.length;
-        const keys = [];
-
-        for (let i = 0; i < length; i++) {
-            const itemKey = sessionStorage.key(i);
-            if (itemKey.indexOf(dbInfo.keyPrefix) === 0) {
-                keys.push(itemKey.substring(dbInfo.keyPrefix.length));
-            }
-        }
-        return keys;
-    });
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-// Supply the number of keys in the datastore to the callback function.
-function length(callback) {
-    const self = this;
-    const promise = self.keys().then(function(keys) {
-        return keys.length;
-    });
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-// Remove an item from the store, nice and simple.
-function removeItem(key, callback) {
-    key = normalizeKey(key);
-    const promise = this.ready().then(function() {
-        sessionStorage.removeItem(dbInfo.keyPrefix + key);
-    });
-    executeCallback(promise, callback);
-    return promise;
-}
-
-// Set a key's value and run an optional callback once the value is set.
-// Unlike Gaia's implementation, the callback function is passed the value,
-// in case you want to operate on that value only after you're sure it
-// saved, or something like that.
-async function setItem(key, value, callback) {
-    key = normalizeKey(key);
-    await this.ready();
-
-    // Convert undefined values to null.
-    // https://github.com/mozilla/localForage/pull/42
-    value = value ?? null;
-
-    // Save the original value to pass to the callback.
-    const originalValue = value;
-
-    dbInfo.serializer.serialize(value, (value, error) => {
-        if (error) {
-            throw error;
-        } else {
-            try {
-                sessionStorage.setItem(dbInfo.keyPrefix + key, value);
-                executeCallback(Promise.resolve(originalValue), callback);
-            } catch (e) {
-                if (
-                    e.name === 'QuotaExceededError' ||
-                    e.name === 'NS_ERROR_DOM_QUOTA_REACHED'
-                ) {
-                    console.error("Your sesionStorage capacity is used up.");
-                    throw e;
-                }
-                throw e;
-            }
-        }
-    });
-
-}
-
-function dropInstance(options, callback) {
-    callback = getCallback.apply(this, arguments);
-
-    options = (typeof options !== 'function' && options) || {};
-    if (!options.name) {
-        const currentConfig = this.config();
-        options.name = options.name || currentConfig.name;
-        options.storeName = options.storeName || currentConfig.storeName;
-    }
-
-    const self = this;
-    let promise;
-    if (!options.name) {
-        promise = Promise.reject(new Error('Invalid arguments'));
-    } else {
-        promise = new Promise(function(resolve) {
-            if (!options.storeName) {
-                resolve(`${options.name}/`);
-            } else {
-                resolve(_getKeyPrefix(options, self._defaultConfig));
-            }
-        }).then(function(keyPrefix) {
-            for (let i = sessionStorage.length - 1; i >= 0; i--) {
-                const key = sessionStorage.key(i);
-                if (key.indexOf(keyPrefix) === 0) {
-                    sessionStorage.removeItem(key);
-                }
-            }
-        });
-    }
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-const sessionStorageWrapper = {
-    _driver: 'sessionStorageWrapper',
-    _initStorage: _initStorage,
-    _support: isSessionStorageValid(),
-    iterate: iterate,
-    getItem: getItem,
-    setItem: setItem,
-    removeItem: removeItem,
-    clear: clear,
-    length: length,
-    key: key,
-    keys: keys,
-    dropInstance: dropInstance
-};
-
-export default sessionStorageWrapper;

package/src/events.js

@@ -1,328 +0,0 @@
-//     Backbone.js 1.4.0
-//     (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
-//     Backbone may be freely distributed under the MIT license.
-
-// Events
-// ------
-
-// A module that can be mixed in to *any object* in order to provide it with
-// a custom event channel. You may bind a callback to an event with `on` or
-// remove with `off`; `trigger`-ing an event fires all callbacks in
-// succession.
-//
-//     let object = {};
-//     extend(object, Backbone.Events);
-//     object.on('expand', function(){ alert('expanded'); });
-//     object.trigger('expand');
-//
-
-import isEmpty from 'lodash-es/isEmpty.js';
-import keys from 'lodash-es/keys.js';
-import once from 'lodash-es/once.js';
-import uniqueId from 'lodash-es/uniqueId.js';
-
-export const Events = {};
-
-// Regular expression used to split event strings.
-const eventSplitter = /\s+/;
-
-// A private global variable to share between listeners and listenees.
-let _listening;
-
-// Iterates over the standard `event, callback` (as well as the fancy multiple
-// space-separated events `"change blur", callback` and jQuery-style event
-// maps `{event: callback}`).
-const eventsApi = function(iteratee, events, name, callback, opts) {
-  let i = 0, names;
-  if (name && typeof name === 'object') {
-    // Handle event maps.
-    if (callback !== undefined && 'context' in opts && opts.context === undefined) opts.context = callback;
-    for (names = keys(name); i < names.length ; i++) {
-      events = eventsApi(iteratee, events, names[i], name[names[i]], opts);
-    }
-  } else if (name && eventSplitter.test(name)) {
-    // Handle space-separated event names by delegating them individually.
-    for (names = name.split(eventSplitter); i < names.length; i++) {
-      events = iteratee(events, names[i], callback, opts);
-    }
-  } else {
-    // Finally, standard events.
-    events = iteratee(events, name, callback, opts);
-  }
-  return events;
-};
-
-// Bind an event to a `callback` function. Passing `"all"` will bind
-// the callback to all events fired.
-Events.on = function(name, callback, context) {
-  this._events = eventsApi(onApi, this._events || {}, name, callback, {
-    context: context,
-    ctx: this,
-    listening: _listening
-  });
-
-  if (_listening) {
-    const listeners = this._listeners || (this._listeners = {});
-    listeners[_listening.id] = _listening;
-    // Allow the listening to use a counter, instead of tracking
-    // callbacks for library interop
-    _listening.interop = false;
-  }
-
-  return this;
-};
-
-// Inversion-of-control versions of `on`. Tell *this* object to listen to
-// an event in another object... keeping track of what it's listening to
-// for easier unbinding later.
-Events.listenTo = function(obj, name, callback) {
-  if (!obj) return this;
-  const id = obj._listenId || (obj._listenId = uniqueId('l'));
-  const listeningTo = this._listeningTo || (this._listeningTo = {});
-  let listening = _listening = listeningTo[id];
-
-  // This object is not listening to any other events on `obj` yet.
-  // Setup the necessary references to track the listening callbacks.
-  if (!listening) {
-    this._listenId || (this._listenId = uniqueId('l'));
-    listening = _listening = listeningTo[id] = new Listening(this, obj);
-  }
-
-  // Bind callbacks on obj.
-  const error = tryCatchOn(obj, name, callback, this);
-  _listening = undefined;
-
-  if (error) throw error;
-  // If the target obj is not Backbone.Events, track events manually.
-  if (listening.interop) listening.on(name, callback);
-
-  return this;
-};
-
-// The reducing API that adds a callback to the `events` object.
-const onApi = function(events, name, callback, options) {
-  if (callback) {
-    const handlers = events[name] || (events[name] = []);
-    const context = options.context, ctx = options.ctx, listening = options.listening;
-    if (listening) listening.count++;
-
-    handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});
-  }
-  return events;
-};
-
-// An try-catch guarded #on function, to prevent poisoning the global
-// `_listening` variable.
-const tryCatchOn = function(obj, name, callback, context) {
-  try {
-    obj.on(name, callback, context);
-  } catch (e) {
-    return e;
-  }
-};
-
-// Remove one or many callbacks. If `context` is null, removes all
-// callbacks with that function. If `callback` is null, removes all
-// callbacks for the event. If `name` is null, removes all bound
-// callbacks for all events.
-Events.off = function(name, callback, context) {
-  if (!this._events) return this;
-  this._events = eventsApi(offApi, this._events, name, callback, {
-    context: context,
-    listeners: this._listeners
-  });
-
-  return this;
-};
-
-// Tell this object to stop listening to either specific events ... or
-// to every object it's currently listening to.
-Events.stopListening = function(obj, name, callback) {
-  const listeningTo = this._listeningTo;
-  if (!listeningTo) return this;
-
-  const ids = obj ? [obj._listenId] : keys(listeningTo);
-  for (let i = 0; i < ids.length; i++) {
-    const listening = listeningTo[ids[i]];
-
-    // If listening doesn't exist, this object is not currently
-    // listening to obj. Break out early.
-    if (!listening) break;
-
-    listening.obj.off(name, callback, this);
-    if (listening.interop) listening.off(name, callback);
-  }
-  if (isEmpty(listeningTo)) this._listeningTo = undefined;
-
-  return this;
-};
-
-// The reducing API that removes a callback from the `events` object.
-const offApi = function(events, name, callback, options) {
-  if (!events) return;
-
-  const context = options.context, listeners = options.listeners;
-  let i = 0, names;
-
-  // Delete all event listeners and "drop" events.
-  if (!name && !context && !callback) {
-    for (names = keys(listeners); i < names.length; i++) {
-      listeners[names[i]].cleanup();
-    }
-    return;
-  }
-
-  names = name ? [name] : keys(events);
-  for (; i < names.length; i++) {
-    name = names[i];
-    const handlers = events[name];
-
-    // Bail out if there are no events stored.
-    if (!handlers) {
-      break;
-    }
-
-    // Find any remaining events.
-    const remaining = [];
-    for (let j = 0; j < handlers.length; j++) {
-      const handler = handlers[j];
-      if (
-        callback && callback !== handler.callback &&
-          callback !== handler.callback._callback ||
-            context && context !== handler.context
-      ) {
-        remaining.push(handler);
-      } else {
-        const listening = handler.listening;
-        if (listening) listening.off(name, callback);
-      }
-    }
-
-    // Replace events if there are any remaining.  Otherwise, clean up.
-    if (remaining.length) {
-      events[name] = remaining;
-    } else {
-      delete events[name];
-    }
-  }
-
-  return events;
-};
-
-// Bind an event to only be triggered a single time. After the first time
-// the callback is invoked, its listener will be removed. If multiple events
-// are passed in using the space-separated syntax, the handler will fire
-// once for each event, not once for a combination of all events.
-Events.once = function(name, callback, context) {
-  // Map the event into a `{event: once}` object.
-  const events = eventsApi(onceMap, {}, name, callback, this.off.bind(this));
-  if (typeof name === 'string' && (context === null || context === undefined)) callback = undefined;
-  return this.on(events, callback, context);
-};
-
-// Inversion-of-control versions of `once`.
-Events.listenToOnce = function(obj, name, callback) {
-  // Map the event into a `{event: once}` object.
-  const events = eventsApi(onceMap, {}, name, callback, this.stopListening.bind(this, obj));
-  return this.listenTo(obj, events);
-};
-
-// Reduces the event callbacks into a map of `{event: onceWrapper}`.
-// `offer` unbinds the `onceWrapper` after it has been called.
-const onceMap = function(map, name, callback, offer) {
-  if (callback) {
-    const _once = map[name] = once(function() {
-      offer(name, _once);
-      callback.apply(this, arguments);
-    });
-    _once._callback = callback;
-  }
-  return map;
-};
-
-// Trigger one or many events, firing all bound callbacks. Callbacks are
-// passed the same arguments as `trigger` is, apart from the event name
-// (unless you're listening on `"all"`, which will cause your callback to
-// receive the true name of the event as the first argument).
-Events.trigger = function(name) {
-  if (!this._events) return this;
-
-  const length = Math.max(0, arguments.length - 1);
-  const args = Array(length);
-  for (let i = 0; i < length; i++) args[i] = arguments[i + 1];
-
-  eventsApi(triggerApi, this._events, name, undefined, args);
-  return this;
-};
-
-// Handles triggering the appropriate event callbacks.
-const triggerApi = function(objEvents, name, callback, args) {
-  if (objEvents) {
-    const events = objEvents[name];
-    let allEvents = objEvents.all;
-    if (events && allEvents) allEvents = allEvents.slice();
-    if (events) triggerEvents(events, args);
-    if (allEvents) triggerEvents(allEvents, [name].concat(args));
-  }
-  return objEvents;
-};
-
-// A difficult-to-believe, but optimized internal dispatch function for
-// triggering events. Tries to keep the usual cases speedy (most internal
-// Backbone events have 3 arguments).
-const triggerEvents = function(events, args) {
-  let ev, i = -1;
-  const l = events.length,
-    a1 = args[0],
-    a2 = args[1],
-    a3 = args[2];
-  switch (args.length) {
-    case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
-    case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
-    case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
-    case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
-    default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;
-  }
-};
-
-// A listening class that tracks and cleans up memory bindings
-// when all callbacks have been offed.
-const Listening = function(listener, obj) {
-  this.id = listener._listenId;
-  this.listener = listener;
-  this.obj = obj;
-  this.interop = true;
-  this.count = 0;
-  this._events = undefined;
-};
-
-Listening.prototype.on = Events.on;
-
-// Offs a callback (or several).
-// Uses an optimized counter if the listenee uses Backbone.Events.
-// Otherwise, falls back to manual tracking to support events
-// library interop.
-Listening.prototype.off = function(name, callback) {
-  let cleanup;
-  if (this.interop) {
-    this._events = eventsApi(offApi, this._events, name, callback, {
-      context: undefined,
-      listeners: undefined
-    });
-    cleanup = !this._events;
-  } else {
-    this.count--;
-    cleanup = this.count === 0;
-  }
-  if (cleanup) this.cleanup();
-};
-
-// Cleans up memory bindings between the listener and the listenee.
-Listening.prototype.cleanup = function() {
-  delete this.listener._listeningTo[this.obj._listenId];
-  if (!this.interop) delete this.obj._listeners[this.id];
-};
-
-// Aliases for backwards compatibility.
-Events.bind   = Events.on;
-Events.unbind = Events.off;