@converse/skeletor 0.0.7 → 0.0.9

package/src/overview.js

@@ -1,191 +0,0 @@
-/*!
- * Copyright (c) JC Brand <jc@opkode.com>
- */
-import debounce from 'lodash-es/debounce.js';
-import difference from 'lodash-es/difference.js';
-import drop from 'lodash-es/drop.js';
-import every from 'lodash-es/every.js';
-import extend from 'lodash-es/extend.js';
-import filter from 'lodash-es/filter.js';
-import find from 'lodash-es/find.js';
-import first from 'lodash-es/first.js';
-import forEach from 'lodash-es/forEach.js';
-import get from 'lodash-es/get.js';
-import head from 'lodash-es/head.js';
-import includes from 'lodash-es/includes.js';
-import indexOf from 'lodash-es/indexOf.js';
-import initial from 'lodash-es/initial.js';
-import invoke from 'lodash-es/invoke.js';
-import isEmpty from 'lodash-es/isEmpty.js';
-import last from 'lodash-es/last.js';
-import lastIndexOf from 'lodash-es/lastIndexOf.js';
-import map from 'lodash-es/map.js';
-import max from 'lodash-es/max.js';
-import min from 'lodash-es/min.js';
-import reduce from 'lodash-es/reduce.js';
-import reduceRight from 'lodash-es/reduceRight.js';
-import reject from 'lodash-es/reject.js';
-import rest from 'lodash-es/rest.js';
-import sample from 'lodash-es/sample.js';
-import shuffle from 'lodash-es/shuffle.js';
-import size from 'lodash-es/size.js';
-import some from 'lodash-es/some.js';
-import sortBy from 'lodash-es/sortBy.js';
-import tail from 'lodash-es/tail.js';
-import take from 'lodash-es/take.js';
-import toArray from 'lodash-es/toArray.js';
-import without from 'lodash-es/without.js';
-import { View } from "./view";
-
-
-const Overview = function (options) {
-   /* An Overview is a View that contains and keeps track of sub-views.
-    * Kind of like what a Collection is to a Model.
-    */
-   this.views = {};
-   this.keys = () => Object.keys(this.views);
-   this.getAll = () => this.views;
-   this.get = id => this.views[id];
-
-   /* Exclusive get. Returns all instances except the given id. */
-   this.xget = id => {
-      return this.keys()
-         .filter(k => (k !== id))
-         .reduce((acc, k) => {
-            acc[k] = this.views[k]
-            return acc;
-         }, {});
-   }
-
-   this.add = (id, view) => {
-      this.views[id] = view;
-      return view;
-   };
-
-   this.remove = id => {
-      if (typeof id === "undefined") {
-            new View().remove.apply(this);
-      }
-      const view = this.views[id];
-      if (view) {
-            delete this.views[id];
-            view.remove();
-            return view;
-      }
-   };
-
-   this.removeAll = () => {
-      this.keys().forEach(id => this.remove(id));
-      return this;
-   }
-
-   View.apply(this, Array.prototype.slice.apply(arguments));
-};
-
-
-const methods = {
-   includes, difference, drop,
-   every, filter, find,
-   first, forEach, head,
-   indexOf, initial, invoke, isEmpty,
-   last, lastIndexOf, map, max, min, reduce,
-   reduceRight, reject, rest, sample,
-   shuffle, size, some, sortBy, tail, take,
-   toArray, without
-}
-Object.keys(methods).forEach(name => {
-   Overview.prototype[name] = function() {
-      const args = Array.prototype.slice.call(arguments);
-      args.unshift(this.views);
-      return methods[name].apply(this, args);
-   };
-});
-
-Object.assign(Overview.prototype, View.prototype);
-Overview.extend = View.extend;
-
-
-const OrderedListView = Overview.extend({
-   /* An OrderedListView is a special type of Overview which adds some
-    * methods and conventions for rendering an ordered list of elements.
-    */
-   // The `listItems` attribute denotes the path (from this View) to the
-   // list of items.
-   listItems: 'model',
-   // The `sortEvent` attribute specifies the event which should cause the
-   // ordered list to be sorted.
-   sortEvent: 'change',
-   // If false, we debounce sorting and inserting the new item
-   // (for improved performance when a large amount of items get added all at once)
-   // Otherwise we immediately sort the items and insert the new item.
-   sortImmediatelyOnAdd: false,
-   // The `listSelector` is the selector used to query for the DOM list
-   // element which contains the ordered items.
-   listSelector: '.ordered-items',
-   // The `itemView` is constructor which should be called to create a
-   // View for a new item.
-   ItemView: undefined,
-   // The `subviewIndex` is the attribute of the list element model which
-   // acts as the index of the subview in the overview.
-   // An overview is a "Collection" of views, and they can be retrieved
-   // via an index. By default this is the 'id' attribute, but it could be
-   // set to something else.
-   subviewIndex: 'id',
-
-   initialize () {
-      this.sortEventually = debounce(() => this.sortAndPositionAllItems(), 100);
-      this.items = get(this, this.listItems);
-      this.items.on('remove', this.removeView, this);
-      this.items.on('reset', this.removeAll, this);
-
-      this.items.on('add', (a, b) => {
-         if (this.sortImmediatelyOnAdd) {
-            this.sortAndPositionAllItems();
-         } else {
-            this.sortEventually();
-         }
-      });
-
-      if (this.sortEvent) {
-         this.items.on(this.sortEvent, this.sortEventually, this);
-      }
-   },
-
-   createItemView (item) {
-      let item_view = this.get(item.get(this.subviewIndex));
-      if (!item_view) {
-            item_view = new this.ItemView({model: item});
-            this.add(item.get(this.subviewIndex), item_view);
-      } else {
-            item_view.model = item;
-            item_view.initialize();
-      }
-      item_view.render();
-      return item_view;
-   },
-
-   removeView (item) {
-      this.remove(item.get(this.subviewIndex));
-   },
-
-   sortAndPositionAllItems () {
-      if (!this.items.length) {
-            return;
-      }
-      this.items.sort();
-
-      const list_el = this.el.querySelector(this.listSelector);
-      const div = document.createElement('div');
-      list_el.parentNode.replaceChild(div, list_el);
-      this.items.forEach(item => {
-            let view = this.get(item.get(this.subviewIndex));
-            if (!view) {
-               view = this.createItemView(item)
-            }
-            list_el.insertAdjacentElement('beforeend', view.el);
-      });
-      div.parentNode.replaceChild(list_el, div);
-   }
-});
-
-export { OrderedListView, Overview }

package/src/router.js

@@ -1,119 +0,0 @@
-//     Backbone.js 1.4.0
-//     (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
-//     Backbone may be freely distributed under the MIT license.
-
-// Router
-// ------
-
-import History from './history.js';
-import extend from 'lodash-es/extend.js';
-import isFunction from 'lodash-es/isFunction.js';
-import isRegExp from 'lodash-es/isRegExp.js';
-import keys from 'lodash-es/keys.js';
-import result from 'lodash-es/result.js';
-import { Events } from './events.js';
-import { inherits } from './helpers.js';
-
-// Routers map faux-URLs to actions, and fire events when routes are
-// matched. Creating a new one sets its `routes` hash, if not set statically.
-export const Router = function(options={}) {
-  this.history = options.history || new History();
-  this.preinitialize.apply(this, arguments);
-  if (options.routes) this.routes = options.routes;
-  this._bindRoutes();
-  this.initialize.apply(this, arguments);
-};
-
-Router.extend = inherits;
-
-// Cached regular expressions for matching named param parts and splatted
-// parts of route strings.
-const optionalParam = /\((.*?)\)/g;
-const namedParam    = /(\(\?)?:\w+/g;
-const splatParam    = /\*\w+/g;
-const escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
-
-// Set up all inheritable **Router** properties and methods.
-Object.assign(Router.prototype, Events, {
-
-  // 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 Router.
-  preinitialize: function(){},
-
-  // Initialize is an empty function by default. Override it with your own
-  // initialization logic.
-  initialize: function(){},
-
-  // Manually bind a single named route to a callback. For example:
-  //
-  //     this.route('search/:query/p:num', 'search', function(query, num) {
-  //       ...
-  //     });
-  //
-  route: function(route, name, callback) {
-    if (!isRegExp(route)) route = this._routeToRegExp(route);
-    if (isFunction(name)) {
-      callback = name;
-      name = '';
-    }
-    if (!callback) callback = this[name];
-    this.history.route(route, (fragment) => {
-      const args = this._extractParameters(route, fragment);
-      if (this.execute(callback, args, name) !== false) {
-        this.trigger.apply(this, ['route:' + name].concat(args));
-        this.trigger('route', name, args);
-        this.history.trigger('route', this, name, args);
-      }
-    });
-    return this;
-  },
-
-  // Execute a route handler with the provided parameters.  This is an
-  // excellent place to do pre-route setup or post-route cleanup.
-  execute: function(callback, args, name) {
-    if (callback) callback.apply(this, args);
-  },
-
-  // Simple proxy to `history` to save a fragment into the history.
-  navigate: function(fragment, options) {
-    this.history.navigate(fragment, options);
-    return this;
-  },
-
-  // Bind all defined routes to `history`. We have to reverse the
-  // order of the routes here to support behavior where the most general
-  // routes can be defined at the bottom of the route map.
-  _bindRoutes: function() {
-    if (!this.routes) return;
-    this.routes = result(this, 'routes');
-    let route;
-    const routes = keys(this.routes);
-    while ((route = routes.pop()) != null) {
-      this.route(route, this.routes[route]);
-    }
-  },
-
-  // Convert a route string into a regular expression, suitable for matching
-  // against the current location hash.
-  _routeToRegExp: function(route) {
-    route = route.replace(escapeRegExp, '\\$&')
-      .replace(optionalParam, '(?:$1)?')
-      .replace(namedParam, function(match, optional) {
-        return optional ? match : '([^/?]+)';
-      })
-      .replace(splatParam, '([^?]*?)');
-    return new RegExp('^' + route + '(?:\\?([\\s\\S]*))?$');
-  },
-
-  // Given a route, and a URL fragment that it matches, return the array of
-  // extracted decoded parameters. Empty or unmatched parameters will be
-  // treated as `null` to normalize cross-browser behavior.
-  _extractParameters: function(route, fragment) {
-    const params = route.exec(fragment).slice(1);
-    return params.map(function(param, i) {
-      // Don't decode the search params.
-      if (i === params.length - 1) return param || null;
-      return param ? decodeURIComponent(param) : null;
-    });
-  }
-});

package/src/storage.js~

@@ -1,269 +0,0 @@
-/**
- * IndexedDB, localStorage and sessionStorage adapter
- */
-import * as memoryDriver from 'localforage-driver-memory';
-import cloneDeep from 'lodash-es/cloneDeep.js';
-import isString from 'lodash-es/isString.js';
-import localForage from "localforage/src/localforage";
-import mergebounce from 'mergebounce';
-import sessionStorageWrapper from "./drivers/sessionStorage.js";
-import { extendPrototype as extendPrototypeWithSetItems } from 'localforage-setitems';
-import { extendPrototype as extendPrototypeWithGetItems } from 'localforage-getitems';
-
-const IN_MEMORY = memoryDriver._driver
-localForage.defineDriver(memoryDriver);
-extendPrototypeWithSetItems(localForage);
-extendPrototypeWithGetItems(localForage);
-
-function S4() {
-    // Generate four random hex digits.
-    return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
-}
-
-function guid() {
-    // Generate a pseudo-GUID by concatenating random hexadecimal.
-    return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
-}
-
-
-class Storage {
-
-    constructor (id, type, batchedWrites=false) {
-        if (type === 'local' && !window.localStorage ) {
-            throw new Error("Skeletor.storage: Environment does not support localStorage.");
-        } else if (type === 'session' && !window.sessionStorage ) {
-            throw new Error("Skeletor.storage: Environment does not support sessionStorage.");
-        }
-        if (isString(type)) {
-            this.storeInitialized = this.initStore(type, batchedWrites);
-        } else {
-            this.store = type;
-            if (batchedWrites) {
-                this.store.debouncedSetItems = mergebounce(
-                    items => this.store.setItems(items),
-                    50,
-                    {'promise': true}
-                );
-            }
-            this.storeInitialized = Promise.resolve();
-        }
-        this.name = id;
-    }
-
-    async initStore (type, batchedWrites) {
-        if (type === 'session') {
-            localForage.setDriver(sessionStorageWrapper._driver);
-        } else if (type === 'local') {
-            await localForage.config({'driver': localForage.LOCALSTORAGE});
-        } else if (type === 'in_memory') {
-            localForage.config({'driver': IN_MEMORY});
-        } else if (type !== 'indexed') {
-            throw new Error("Skeletor.storage: No storage type was specified");
-        }
-        this.store = localForage;
-        if (batchedWrites) {
-            this.store.debouncedSetItems = mergebounce(
-                items => this.store.setItems(items),
-                50,
-                {'promise': true}
-            );
-        }
-    }
-
-    flush () {
-        return this.store.debouncedSetItems?.flush();
-    }
-
-    async clear () {
-        await this.store.removeItem(this.name).catch(e => console.error(e));
-        const re = new RegExp(`^${this.name}-`);
-        const keys = await this.store.keys();
-        const removed_keys = keys.filter(k => re.test(k));
-        await Promise.all(removed_keys.map(k => this.store.removeItem(k).catch(e => console.error(e))));
-    }
-
-    sync () {
-        const that = this;
-
-        async function localSync (method, model, options) {
-            let resp, errorMessage, promise, new_attributes;
-
-            // We get the collection (and if necessary the model attribute.
-            // Waiting for storeInitialized will cause another iteration of
-            // the event loop, after which the collection reference will
-            // be removed from the model.
-            const collection = model.collection;
-            if (['patch', 'update'].includes(method)) {
-                new_attributes = cloneDeep(model.attributes);
-            }
-            await that.storeInitialized;
-            try {
-                const original_attributes = model.attributes;
-                switch (method) {
-                    case "read":
-                        if (model.id !== undefined) {
-                            resp = await that.find(model);
-                        } else {
-                            resp = await that.findAll();
-                        }
-                        break;
-                    case "create":
-                        resp = await that.create(model, options);
-                        break;
-                    case 'patch':
-                    case "update":
-                        if (options.wait) {
-                            // When `wait` is set to true, Skeletor waits until
-                            // confirmation of storage before setting the values on
-                            // the model.
-                            // However, the new attributes needs to be sent, so it
-                            // sets them manually on the model and then removes
-                            // them after calling `sync`.
-                            // Because our `sync` method is asynchronous and we
-                            // wait for `storeInitialized`, the attributes are
-                            // already restored once we get here, so we need to do
-                            // the attributes dance again.
-                            model.attributes = new_attributes;
-                        }
-                        promise = that.update(model, options);
-                        if (options.wait) {
-                            model.attributes = original_attributes;
-                        }
-                        resp = await promise;
-                        break;
-                    case "delete":
-                        resp = await that.destroy(model, collection);
-                        break;
-                }
-            } catch (error) {
-                if (error.code === 22 && that.getStorageSize() === 0) {
-                    errorMessage = "Private browsing is unsupported";
-                } else {
-                    errorMessage = error.message;
-                }
-            }
-
-            if (resp) {
-                if (options && options.success) {
-                    // When storing, we don't pass back the response (which is
-                    // the set attributes returned from localforage because
-                    // Skeletor sets them again on the model and due to the async
-                    // nature of localforage it can cause stale attributes to be
-                    // set on a model after it's been updated in the meantime.
-                    const data = (method === "read") ? resp : null;
-                    options.success(data, options);
-                }
-            } else {
-                errorMessage = errorMessage ? errorMessage : "Record Not Found";
-                if (options && options.error) {
-                    options.error(errorMessage);
-                }
-            }
-        }
-        localSync.__name__ = 'localSync';
-        return localSync;
-    }
-
-    removeCollectionReference (model, collection) {
-        if (!collection) {
-            return;
-        }
-        const ids = collection
-            .filter(m => (m.id !== model.id))
-            .map(m => this.getItemName(m.id));
-
-        return this.store.setItem(this.name, ids);
-    }
-
-    addCollectionReference (model, collection) {
-        if (!collection) {
-            return;
-        }
-        const ids = collection.map(m => this.getItemName(m.id));
-        const new_id = this.getItemName(model.id);
-        if (!ids.includes(new_id)) {
-            ids.push(new_id);
-        }
-        return this.store.setItem(this.name, ids);
-    }
-
-    getCollectionReferenceData (model) {
-        if (!model.collection) {
-            return {};
-        }
-        const ids = model.collection.map(m => this.getItemName(m.id));
-        const new_id = this.getItemName(model.id);
-        if (!ids.includes(new_id)) {
-            ids.push(new_id);
-        }
-        const result = {};
-        result[this.name] = ids;
-        return result;
-    }
-
-    async save (model) {
-        if (this.store.setItems) {
-            const items = {}
-            items[this.getItemName(model.id)] = model.toJSON();
-            Object.assign(items, this.getCollectionReferenceData(model));
-            return (this.store.debouncedSetItems) ?
-                this.store.debouncedSetItems(items) :
-                this.store.setItems(items);
-        } else {
-            const key = this.getItemName(model.id);
-            const data = await this.store.setItem(key, model.toJSON());
-            await this.addCollectionReference(model, model.collection);
-            return data;
-        }
-    }
-
-    create (model, options) {
-        /* Add a model, giving it a (hopefully)-unique GUID, if it doesn't already
-         * have an id of it's own.
-         */
-        if (!model.id) {
-            model.id = guid();
-            model.set(model.idAttribute, model.id, options);
-        }
-        return this.save(model);
-    }
-
-    update (model) {
-        return this.save(model);
-    }
-
-    find (model) {
-        return this.store.getItem(this.getItemName(model.id));
-    }
-
-    async findAll () {
-        /* Return the array of all models currently in storage.
-         */
-        const keys = await this.store.getItem(this.name);
-        if (keys?.length) {
-            const items = await this.store.getItems(keys);
-            debugger;
-            return Object.values(items);
-        }
-        return [];
-    }
-
-    async destroy (model, collection) {
-        await this.flush();
-        await this.store.removeItem(this.getItemName(model.id));
-        await this.removeCollectionReference(model, collection);
-        return model;
-    }
-
-    getStorageSize () {
-        return this.store.length;
-    }
-
-    getItemName (id) {
-        return this.name+"-"+id;
-    }
-}
-
-Storage.sessionStorageInitialized = localForage.defineDriver(sessionStorageWrapper);
-Storage.localForage = localForage;
-export default Storage;