@converse/skeletor 0.0.5 → 0.0.6

package/src/drivers/sessionStorage.js~

@@ -1,316 +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.
-function setItem(key, value, callback) {
-    key = normalizeKey(key);
-
-    const promise = this.ready().then(function() {
-        // Convert undefined values to null.
-        // https://github.com/mozilla/localForage/pull/42
-        if (value === undefined) {
-            value = null;
-        }
-
-        // Save the original value to pass to the callback.
-        const originalValue = value;
-
-        return new Promise(function(resolve, reject) {
-            dbInfo.serializer.serialize(value, function(value, error) {
-                if (error) {
-                    reject(error);
-                } else {
-                    try {
-                        sessionStorage.setItem(dbInfo.keyPrefix + key, value);
-                        resolve(originalValue);
-                    } catch (e) {
-                        // sessionStorage capacity exceeded.
-                        // TODO: Make this a specific error/event.
-                        if (
-                            e.name === 'QuotaExceededError' ||
-                            e.name === 'NS_ERROR_DOM_QUOTA_REACHED'
-                        ) {
-                            reject(e);
-                        }
-                        reject(e);
-                    }
-                }
-            });
-        });
-    });
-
-    executeCallback(promise, callback);
-    return promise;
-}
-
-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 (var i = sessionStorage.length - 1; i >= 0; i--) {
-                var 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/element-overview.js~

@@ -1,4 +0,0 @@
-
-
-export class ElementOverview extends ElementView {
-}

package/src/element.js~

@@ -1,188 +0,0 @@
-import extend from "lodash-es/extend.js";
-import isElement from "lodash-es/isElement.js";
-import isFunction from "lodash-es/isFunction.js";
-import pick from "lodash-es/pick.js";
-import result from "lodash-es/result.js";
-import uniqueId from "lodash-es/uniqueId.js";
-import { Events } from './events.js';
-import { inherits, NotImplementedError } from './helpers.js';
-import { render } from 'lit-html';
-
-
-const paddedLt = /^\s*</;
-
-// Caches a local reference to `Element.prototype` for faster access.
-const ElementProto = (typeof Element !== 'undefined' && Element.prototype) || {};
-
-// Cached regex to split keys for `delegate`.
-const delegateEventSplitter = /^(\S+)\s*(.*)$/;
-
-// List of view options to be set as properties.
-const viewOptions = ['model', 'collection', 'events'];
-
-
-export class ElementView extends HTMLElement {
-
-  events = {}
-
-  constructor(options) {
-    super();
-    // Creating a View creates its initial element outside of the DOM,
-    // if an existing element is not provided...
-    this.cid = uniqueId('view');
-    this._domEvents = [];
-    extend(this, pick(options, viewOptions));
-  }
-
-  createRenderRoot () {
-    // Render without the shadow DOM
-    return this;
-  }
-
-  connectedCallback () {
-    if (!this._initialized) {
-      this.preinitialize.apply(this, arguments);
-      this.initialize.apply(this, arguments);
-      this._initialized = true;
-    }
-    this.delegateEvents();
-  }
-
-  disconnectedCallback () {
-    this.undelegateEvents();
-    this.stopListening();
-  }
-
-  // preinitialize is an empty function by default. You can override it with a function
-  // or object.  preinitialize will run before any instantiation logic is run in the View
-  preinitialize () {  // eslint-disable-line class-methods-use-this
-  }
-
-  // Initialize is an empty function by default. Override it with your own
-  // initialization logic.
-  initialize() {}  // eslint-disable-line class-methods-use-this
-
-  // **render** is the core function that your view should override, in order
-  // to populate its element (`this.el`), with the appropriate HTML. The
-  // convention is for **render** to always return `this`.
-  render() {
-    isFunction(this.beforeRender) && this.beforeRender();
-    isFunction(this.toHTML) && render(this.toHTML(), this);
-    isFunction(this.afterRender) && this.afterRender();
-    return this;
-  }
-
-  // Set callbacks, where `this.events` is a hash of
-  //
-  // *{"event selector": "callback"}*
-  //
-  //     {
-  //       'mousedown .title':  'edit',
-  //       'click .button':     'save',
-  //       'click .open':       function(e) { ... }
-  //     }
-  //
-  // pairs. Callbacks will be bound to the view, with `this` set properly.
-  // Uses event delegation for efficiency.
-  // Omitting the selector binds the event to `this.el`.
-  delegateEvents() {
-    if (!this.events) {
-      return this;
-    }
-    this.undelegateEvents();
-    for (const key in this.events) {
-      let method = this.events[key];
-      if (!isFunction(method)) method = this[method];
-      if (!method) continue;
-      const match = key.match(delegateEventSplitter);
-      this.delegate(match[1], match[2], method.bind(this));
-    }
-    return this;
-  }
-
-  // Make a event delegation handler for the given `eventName` and `selector`
-  // and attach it to `this.el`.
-  // If selector is empty, the listener will be bound to `this.el`. If not, a
-  // new handler that will recursively traverse up the event target's DOM
-  // hierarchy looking for a node that matches the selector. If one is found,
-  // the event's `delegateTarget` property is set to it and the return the
-  // result of calling bound `listener` with the parameters given to the
-  // handler.
-  delegate(eventName, selector, listener) {
-    const root = this;
-    if (!root) {
-      return this;
-    }
-    if (typeof selector === 'function') {
-      listener = selector;
-      selector = null;
-    }
-    // Given that `focus` and `blur` events do not bubble, do not delegate these events
-    if (['focus', 'blur'].indexOf(eventName) !== -1) {
-      const els = this.querySelectorAll(selector);
-      for (let i = 0, len = els.length; i < len; i++) {
-        const item = els[i];
-        item.addEventListener(eventName, listener, false);
-        this._domEvents.push({el: item, eventName: eventName, handler: listener});
-      }
-      return listener;
-    }
-
-    const handler = selector ? function (e) {
-      let node = e.target || e.srcElement;
-      for (; node && node != root; node = node.parentNode) {
-        if (node.matches(selector)) {
-          e.delegateTarget = node;
-          listener(e);
-        }
-      }
-    } : listener;
-
-    this.addEventListener(eventName, handler, false);
-    this._domEvents.push({el: this, eventName: eventName, handler: handler, listener: listener, selector: selector});
-    return this;
-  }
-
-  // Clears all callbacks previously bound to the view by `delegateEvents`.
-  // You usually don't need to use this, but may wish to if you have multiple
-  // Backbone views attached to the same DOM element.
-  undelegateEvents() {
-    if (this) {
-      for (let i = 0, len = this._domEvents.length; i < len; i++) {
-        const item = this._domEvents[i];
-        item.el.removeEventListener(item.eventName, item.handler, false);
-      }
-      this._domEvents.length = 0;
-    }
-    return this;
-  }
-
-  // A finer-grained `undelegateEvents` for removing a single delegated event.
-  // `selector` and `listener` are both optional.
-  undelegate(eventName, selector, listener) {
-    if (typeof selector === 'function') {
-      listener = selector;
-      selector = null;
-    }
-    if (this) {
-      const handlers = this._domEvents.slice();
-      let i = handlers.length;
-      while (i--) {
-        const item = handlers[i];
-        const match = item.eventName === eventName &&
-            (listener ? item.listener === listener : true) &&
-            (selector ? item.selector === selector : true);
-
-        if (!match) {
-          continue;
-        }
-        item.el.removeEventListener(item.eventName, item.handler, false);
-        this._domEvents.splice(i, 1);
-      }
-    }
-    return this;
-  }
-}
-
-// Set up all inheritable **View** properties and methods.
-Object.assign(ElementView.prototype, Events);