@converse/skeletor 0.0.4 → 0.0.7

package/src/model.js~

@@ -1,439 +0,0 @@
-//     Backbone.js 1.4.0
-//     (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
-//     Backbone may be freely distributed under the MIT license.
-
-// Model
-// -----
-// **Models** are the basic data object in the framework --
-// frequently representing a row in a table in a database on your server.
-// A discrete chunk of data and a bunch of useful, related methods for
-// performing computations and transformations on that data.
-
-// Create a new model with the specified attributes. A client id (`cid`)
-// is automatically generated and assigned for you.
-
-import {
-  getResolveablePromise,
-  getSyncMethod,
-  inherits,
-  urlError,
-  wrapError
-} from './helpers.js';
-import { Events } from './events.js';
-import clone from "lodash-es/clone.js";
-import defaults from "lodash-es/defaults.js";
-import defer from "lodash-es/defer.js";
-import escape from "lodash-es/escape.js";
-import extend from "lodash-es/extend.js";
-import has from "lodash-es/has.js";
-import invert from "lodash-es/invert.js";
-import isElement from "lodash-es/isElement.js";
-import isEmpty from "lodash-es/isEmpty.js";
-import isEqual from "lodash-es/isEqual.js";
-import isFunction from "lodash-es/isFunction.js";
-import iteratee from "lodash-es/iteratee.js";
-import omit from "lodash-es/omit.js";
-import pick from "lodash-es/pick.js";
-import result from "lodash-es/result.js";
-import uniqueId from "lodash-es/uniqueId.js";
-
-
-export const Model = function(attributes, options) {
-  let attrs = attributes || {};
-  options || (options = {});
-  this.preinitialize.apply(this, arguments);
-  this.cid = uniqueId(this.cidPrefix);
-  this.attributes = {};
-  if (options.collection) this.collection = options.collection;
-  if (options.parse) attrs = this.parse(attrs, options) || {};
-  const default_attrs = result(this, 'defaults');
-  attrs = defaults(extend({}, default_attrs, attrs), default_attrs);
-  this.set(attrs, options);
-  this.changed = {};
-  this.initialize.apply(this, arguments);
-};
-
-Model.extend = inherits;
-
-// Attach all inheritable methods to the Model prototype.
-Object.assign(Model.prototype, Events, {
-
-  // A hash of attributes whose current and previous value differ.
-  changed: null,
-
-  // The value returned during the last failed validation.
-  validationError: null,
-
-  // The default name for the JSON `id` attribute is `"id"`. MongoDB and
-  // CouchDB users may want to set this to `"_id"`.
-  idAttribute: 'id',
-
-  // The prefix is used to create the client id which is used to identify models locally.
-  // You may want to override this if you're experiencing name clashes with model ids.
-  cidPrefix: 'c',
-
-  // 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 Model.
-  preinitialize: function(){},
-
-  // Initialize is an empty function by default. Override it with your own
-  // initialization logic.
-  initialize: function(){},
-
-  // Return a copy of the model's `attributes` object.
-  toJSON: function(options) {
-    return clone(this.attributes);
-  },
-
-  // Proxy `Backbone.sync` by default -- but override this if you need
-  // custom syncing semantics for *this* particular model.
-  sync: function(method, model, options) {
-    return getSyncMethod(this)(method, model, options);
-  },
-
-  // Get the value of an attribute.
-  get: function(attr) {
-    return this.attributes[attr];
-  },
-
-  keys: function() {
-    return Object.keys(this.attributes);
-  },
-
-  values: function() {
-    return Object.values(this.attributes);
-  },
-
-  pairs: function() {
-    return this.entries();
-  },
-
-  entries: function() {
-    return Object.entries(this.attributes);
-  },
-
-  invert: function() {
-    return invert(this.attributes);
-  },
-
-  pick: function(...args) {
-    if (args.length === 1 && Array.isArray(args[0])) {
-      args = args[0];
-    }
-    return pick(this.attributes, args);
-  },
-
-  omit: function(...args) {
-    if (args.length === 1 && Array.isArray(args[0])) {
-      args = args[0];
-    }
-    return omit(this.attributes, args);
-  },
-
-  isEmpty: function() {
-    return isEmpty(this.attributes);
-  },
-
-  // Get the HTML-escaped value of an attribute.
-  escape: function(attr) {
-    return escape(this.get(attr));
-  },
-
-  // Returns `true` if the attribute contains a value that is not null
-  // or undefined.
-  has: function(attr) {
-    return this.get(attr) != null;
-  },
-
-  // Special-cased proxy to lodash's `matches` method.
-  matches: function(attrs) {
-    return !!iteratee(attrs, this)(this.attributes);
-  },
-
-  // Set a hash of model attributes on the object, firing `"change"`. This is
-  // the core primitive operation of a model, updating the data and notifying
-  // anyone who needs to know about the change in state. The heart of the beast.
-  set: function(key, val, options) {
-    if (key == null) return this;
-
-    // Handle both `"key", value` and `{key: value}` -style arguments.
-    let attrs;
-    if (typeof key === 'object') {
-      attrs = key;
-      options = val;
-    } else {
-      (attrs = {})[key] = val;
-    }
-
-    options || (options = {});
-
-    // Run validation.
-    if (!this._validate(attrs, options)) return false;
-
-    // Extract attributes and options.
-    const unset      = options.unset;
-    const silent     = options.silent;
-    const changes    = [];
-    const changing   = this._changing;
-    this._changing = true;
-
-    if (!changing) {
-      this._previousAttributes = clone(this.attributes);
-      this.changed = {};
-    }
-
-    const current = this.attributes;
-    const changed = this.changed;
-    const prev    = this._previousAttributes;
-
-    // For each `set` attribute, update or delete the current value.
-    for (const attr in attrs) {
-      val = attrs[attr];
-      if (!isEqual(current[attr], val)) changes.push(attr);
-      if (!isEqual(prev[attr], val)) {
-        changed[attr] = val;
-      } else {
-        delete changed[attr];
-      }
-      unset ? delete current[attr] : current[attr] = val;
-    }
-
-    // Update the `id`.
-    if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);
-
-    // Trigger all relevant attribute changes.
-    if (!silent) {
-      if (changes.length) this._pending = options;
-      for (let i = 0; i < changes.length; i++) {
-        this.trigger('change:' + changes[i], this, current[changes[i]], options);
-      }
-    }
-
-    // You might be wondering why there's a `while` loop here. Changes can
-    // be recursively nested within `"change"` events.
-    if (changing) return this;
-    if (!silent) {
-      while (this._pending) {
-        options = this._pending;
-        this._pending = false;
-        this.trigger('change', this, options);
-      }
-    }
-    this._pending = false;
-    this._changing = false;
-    return this;
-  },
-
-  // Remove an attribute from the model, firing `"change"`. `unset` is a noop
-  // if the attribute doesn't exist.
-  unset: function(attr, options) {
-    return this.set(attr, undefined, extend({}, options, {unset: true}));
-  },
-
-  // Clear all attributes on the model, firing `"change"`.
-  clear: function(options) {
-    const attrs = {};
-    for (const key in this.attributes) attrs[key] = undefined;
-    return this.set(attrs, extend({}, options, {unset: true}));
-  },
-
-  // Determine if the model has changed since the last `"change"` event.
-  // If you specify an attribute name, determine if that attribute has changed.
-  hasChanged: function(attr) {
-    if (attr == null) return !isEmpty(this.changed);
-    return has(this.changed, attr);
-  },
-
-  // Return an object containing all the attributes that have changed, or
-  // false if there are no changed attributes. Useful for determining what
-  // parts of a view need to be updated and/or what attributes need to be
-  // persisted to the server. Unset attributes will be set to undefined.
-  // You can also pass an attributes object to diff against the model,
-  // determining if there *would be* a change.
-  changedAttributes: function(diff) {
-    if (!diff) return this.hasChanged() ? clone(this.changed) : false;
-    const old = this._changing ? this._previousAttributes : this.attributes;
-    const changed = {};
-    let hasChanged;
-    for (const attr in diff) {
-      const val = diff[attr];
-      if (isEqual(old[attr], val)) continue;
-      changed[attr] = val;
-      hasChanged = true;
-    }
-    return hasChanged ? changed : false;
-  },
-
-  // Get the previous value of an attribute, recorded at the time the last
-  // `"change"` event was fired.
-  previous: function(attr) {
-    if (attr == null || !this._previousAttributes) return null;
-    return this._previousAttributes[attr];
-  },
-
-  // Get all of the attributes of the model at the time of the previous
-  // `"change"` event.
-  previousAttributes: function() {
-    return clone(this._previousAttributes);
-  },
-
-  // Fetch the model from the server, merging the response with the model's
-  // local attributes. Any changed attributes will trigger a "change" event.
-  fetch: function(options) {
-    options = extend({parse: true}, options);
-    const model = this;
-    const success = options.success;
-    options.success = function(resp) {
-      const serverAttrs = options.parse ? model.parse(resp, options) : resp;
-      if (!model.set(serverAttrs, options)) return false;
-      if (success) success.call(options.context, model, resp, options);
-      model.trigger('sync', model, resp, options);
-    };
-    wrapError(this, options);
-    return this.sync('read', this, options);
-  },
-
-  // Set a hash of model attributes, and sync the model to the server.
-  // If the server returns an attributes hash that differs, the model's
-  // state will be `set` again.
-  save: function(key, val, options) {
-    // Handle both `"key", value` and `{key: value}` -style arguments.
-    let attrs;
-    if (key == null || typeof key === 'object') {
-      attrs = key;
-      options = val;
-    } else {
-      (attrs = {})[key] = val;
-    }
-
-    options = extend({validate: true, parse: true}, options);
-    const wait = options.wait;
-    const return_promise = options.promise;
-    const promise = return_promise && getResolveablePromise();
-
-    // If we're not waiting and attributes exist, save acts as
-    // `set(attr).save(null, opts)` with validation. Otherwise, check if
-    // the model will be valid when the attributes, if any, are set.
-    if (attrs && !wait) {
-      if (!this.set(attrs, options)) return false;
-    } else if (!this._validate(attrs, options)) {
-      return false;
-    }
-
-    // After a successful server-side save, the client is (optionally)
-    // updated with the server-side state.
-    const model = this;
-    const success = options.success;
-    const error = options.error;
-    const attributes = this.attributes;
-    options.success = function(resp) {
-      // Ensure attributes are restored during synchronous saves.
-      model.attributes = attributes;
-      let serverAttrs = options.parse ? model.parse(resp, options) : resp;
-      if (wait) serverAttrs = extend({}, attrs, serverAttrs);
-      if (serverAttrs && !model.set(serverAttrs, options)) return false;
-      if (success) success.call(options.context, model, resp, options);
-      model.trigger('sync', model, resp, options);
-      return_promise && promise.resolve();
-    };
-    options.error = function(model, e, options) {
-      error && error.call(options.context, e);
-      return_promise && promise.reject(e);
-    }
-
-    wrapError(this, options);
-
-    // Set temporary attributes if `{wait: true}` to properly find new ids.
-    if (attrs && wait) this.attributes = extend({}, attributes, attrs);
-
-    const method = this.isNew() ? 'create' : options.patch ? 'patch' : 'update';
-    if (method === 'patch' && !options.attrs) options.attrs = attrs;
-    const xhr = this.sync(method, this, options);
-
-    // Restore attributes.
-    this.attributes = attributes;
-
-    if (return_promise) {
-      return promise;
-    } else {
-      return xhr;
-    }
-
-  },
-
-  // Destroy this model on the server if it was already persisted.
-  // Optimistically removes the model from its collection, if it has one.
-  // If `wait: true` is passed, waits for the server to respond before removal.
-  destroy: function(options) {
-    options = options ? clone(options) : {};
-    const model = this;
-    const success = options.success;
-    const wait = options.wait;
-
-    const destroy = function() {
-      model.stopListening();
-      model.trigger('destroy', model, model.collection, options);
-    };
-
-    options.success = function(resp) {
-      if (wait) destroy();
-      if (success) success.call(options.context, model, resp, options);
-      if (!model.isNew()) model.trigger('sync', model, resp, options);
-    };
-
-    let xhr = false;
-    if (this.isNew()) {
-      defer(options.success);
-    } else {
-      wrapError(this, options);
-      xhr = this.sync('delete', this, options);
-    }
-    if (!wait) destroy();
-    return xhr;
-  },
-
-  // Default URL for the model's representation on the server -- if you're
-  // using Backbone's restful methods, override this to change the endpoint
-  // that will be called.
-  url: function() {
-    const base =
-      result(this, 'urlRoot') ||
-      result(this.collection, 'url') ||
-      urlError();
-    if (this.isNew()) return base;
-    const id = this.get(this.idAttribute);
-    return base.replace(/[^\/]$/, '$&/') + encodeURIComponent(id);
-  },
-
-  // **parse** converts a response into the hash of attributes to be `set` on
-  // the model. The default implementation is just to pass the response along.
-  parse: function(resp, options) {
-    return resp;
-  },
-
-  // Create a new model with identical attributes to this one.
-  clone: function() {
-    return new this.constructor(this.attributes);
-  },
-
-  // A model is new if it has never been saved to the server, and lacks an id.
-  isNew: function() {
-    return !this.has(this.idAttribute);
-  },
-
-  // Check if the model is currently in a valid state.
-  isValid: function(options) {
-    return this._validate({}, extend({}, options, {validate: true}));
-  },
-
-  // Run validation against the next complete set of model attributes,
-  // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
-  _validate: function(attrs, options) {
-    if (!options.validate || !this.validate) return true;
-    attrs = extend({}, this.attributes, attrs);
-    const error = this.validationError = this.validate(attrs, options) || null;
-    if (!error) return true;
-    this.trigger('invalid', this, error, extend(options, {validationError: error}));
-    return false;
-  }
-});

package/src/orderedlist.js~

@@ -1,88 +0,0 @@
-import Overview from './overview.js';
-import debounce from 'lodash-es/debounce.js';
-
-
-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 default OrderedListView;

package/src/overview.js~

@@ -1,111 +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;
-   }
-
-};
-
-
-const Overview = function (const) {
-   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;
-
-export default Overview;