@converse/skeletor 0.0.8 → 0.0.9

package/src/helpers.js

@@ -12,13 +12,13 @@ import result from 'lodash-es/result.js';
 export class NotImplementedError extends Error {}
 
 function S4() {
-    // Generate four random hex digits.
-    return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
+  // Generate four random hex digits.
+  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
 }
 
 export function guid() {
-    // Generate a pseudo-GUID by concatenating random hexadecimal.
-    return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
+  // Generate a pseudo-GUID by concatenating random hexadecimal.
+  return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
 }
 
 // Helpers
@@ -29,139 +29,164 @@ export function guid() {
 // class properties to be extended.
 //
 export function inherits(protoProps, staticProps) {
-    const parent = this;
-    let child;
-
-    // The constructor function for the new subclass is either defined by you
-    // (the "constructor" property in your `extend` definition), or defaulted
-    // by us to simply call the parent constructor.
-    if (protoProps && has(protoProps, 'constructor')) {
-        child = protoProps.constructor;
-    } else {
-        child = function(){ return parent.apply(this, arguments); };
-    }
-
-    // Add static properties to the constructor function, if supplied.
-    extend(child, parent, staticProps);
-
-    // Set the prototype chain to inherit from `parent`, without calling
-    // `parent`'s constructor function and add the prototype properties.
-    child.prototype = create(parent.prototype, protoProps);
-    child.prototype.constructor = child;
-
-    // Set a convenience property in case the parent's prototype is needed
-    // later.
-    child.__super__ = parent.prototype;
-
-    return child;
-}
+  // eslint-disable-next-line @typescript-eslint/no-this-alias
+  const parent = this;
+  let child;
+
+  // The constructor function for the new subclass is either defined by you
+  // (the "constructor" property in your `extend` definition), or defaulted
+  // by us to simply call the parent constructor.
+  if (protoProps && has(protoProps, 'constructor')) {
+    child = protoProps.constructor;
+  } else {
+    child = function () {
+      return parent.apply(this, arguments);
+    };
+  }
 
+  // Add static properties to the constructor function, if supplied.
+  extend(child, parent, staticProps);
 
-export function getResolveablePromise () {
-    const wrapper = {
-        isResolved: false,
-        isPending: true,
-        isRejected: false
-    };
-    const promise = new Promise((resolve, reject) => {
-        wrapper.resolve = resolve;
-        wrapper.reject = reject;
-    })
-    Object.assign(promise, wrapper);
-    promise.then(
-        function (v) {
-            promise.isResolved = true;
-            promise.isPending = false;
-            promise.isRejected = false;
-            return v;
-        },
-        function (e) {
-            promise.isResolved = false;
-            promise.isPending = false;
-            promise.isRejected = true;
-            throw (e);
-        }
-    );
-    return promise;
+  // Set the prototype chain to inherit from `parent`, without calling
+  // `parent`'s constructor function and add the prototype properties.
+  child.prototype = create(parent.prototype, protoProps);
+  child.prototype.constructor = child;
+
+  // Set a convenience property in case the parent's prototype is needed
+  // later.
+  child.__super__ = parent.prototype;
+
+  return child;
 }
 
+export function getResolveablePromise() {
+  /**
+   * @typedef {Object} PromiseWrapper
+   * @property {boolean} isResolved
+   * @property {boolean} isPending
+   * @property {boolean} isRejected
+   * @property {Function} resolve
+   * @property {Function} reject
+   */
+
+  /** @type {PromiseWrapper} */
+  const wrapper = {
+    isResolved: false,
+    isPending: true,
+    isRejected: false,
+    resolve: null,
+    reject: null,
+  };
+
+  /**
+   * @typedef {Promise & PromiseWrapper} ResolveablePromise
+   */
+
+  const promise = /** @type {ResolveablePromise} */ (
+    new Promise((resolve, reject) => {
+      wrapper.resolve = resolve;
+      wrapper.reject = reject;
+    })
+  );
+  Object.assign(promise, wrapper);
+  promise.then(
+    function (v) {
+      promise.isResolved = true;
+      promise.isPending = false;
+      promise.isRejected = false;
+      return v;
+    },
+    function (e) {
+      promise.isResolved = false;
+      promise.isPending = false;
+      promise.isRejected = true;
+      throw e;
+    },
+  );
+  return promise;
+}
 
 // Throw an error when a URL is needed, and none is supplied.
 export function urlError() {
-    throw new Error('A "url" property or function must be specified');
+  throw new Error('A "url" property or function must be specified');
 }
 
 // Wrap an optional error callback with a fallback error event.
 export function wrapError(model, options) {
-    const error = options.error;
-    options.error = function(resp) {
-        if (error) error.call(options.context, model, resp, options);
-        model.trigger('error', model, resp, options);
-    };
+  const error = options.error;
+  options.error = function (resp) {
+    if (error) error.call(options.context, model, resp, options);
+    model.trigger('error', model, resp, options);
+  };
 }
 
 // Map from CRUD to HTTP for our default `sync` implementation.
 const methodMap = {
-    create: 'POST',
-    update: 'PUT',
-    patch: 'PATCH',
-    delete: 'DELETE',
-    read: 'GET'
+  create: 'POST',
+  update: 'PUT',
+  patch: 'PATCH',
+  delete: 'DELETE',
+  read: 'GET',
 };
 
-export function getSyncMethod(model) {
-    const store = result(model, 'browserStorage') || result(model.collection, 'browserStorage');
-    return store ? store.sync() : sync;
-}
-
-// sync
-// ----
+/**
+ * @typedef {import('./model.js').Model} Model
+ * @typedef {import('./collection.js').Collection} Collection
+ */
 
-// Override this function to change the manner in which Backbone persists
-// models to the server. You will be passed the type of request, and the
-// model in question. By default, makes a RESTful Ajax request
-// to the model's `url()`. Some possible customizations could be:
-//
-// * Use `setTimeout` to batch rapid-fire updates into a single request.
-// * Send up the models as XML instead of JSON.
-// * Persist models via WebSockets instead of Ajax.
-//
-export function sync(method, model, options={}) {
-    const type = methodMap[method];
-
-    // Default JSON-request options.
-    const params = {type: type, dataType: 'json'};
-
-    // Ensure that we have a URL.
-    if (!options.url) {
-        params.url = result(model, 'url') || urlError();
-    }
-
-    // Ensure that we have the appropriate request data.
-    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
-        params.contentType = 'application/json';
-        params.data = JSON.stringify(options.attrs || model.toJSON(options));
-    }
-
-    // Don't process data on a non-GET request.
-    if (params.type !== 'GET') {
-        params.processData = false;
-    }
-
-    // Pass along `textStatus` and `errorThrown` from jQuery.
-    const error = options.error;
-    options.error = function(xhr, textStatus, errorThrown) {
-        options.textStatus = textStatus;
-        options.errorThrown = errorThrown;
-        if (error) error.call(options.context, xhr, textStatus, errorThrown);
-    };
 
-    // Make the request, allowing the user to override any Ajax options.
-    const xhr = options.xhr = ajax(extend(params, options));
-    model.trigger('request', model, xhr, options);
-    return xhr;
+/**
+ * @param {Model | Collection} model
+ */
+export function getSyncMethod(model) {
+  const store = result(model, 'browserStorage') || result(/** @type {Model} */(model).collection, 'browserStorage');
+  return store ? store.sync() : sync;
 }
 
-export function ajax() {
-    return fetch.apply(this, arguments);
+/**
+ * @typedef {Object} SyncOptions
+ * @property {string} [url]
+ * @property {any} [data]
+ * @property {any} [attrs]
+ * @property {Function} [success]
+ * @property {Function} [error]
+ * @property {any} [xhr]
+ */
+
+/**
+ * Override this function to change the manner in which Backbone persists
+ * models to the server. You will be passed the type of request, and the
+ * model in question. By default makes a `fetch()` API call
+ * to the model's `url()`.
+ *
+ * Some possible customizations could be:
+ *
+ * - Use `setTimeout` to batch rapid-fire updates into a single request.
+ * - Persist models via WebSockets instead of Ajax.
+ * - Persist models to browser storage
+ *
+ * @param {'create'|'update'|'patch'} method
+ * @param {import('./model.js').Model} model
+ * @param {SyncOptions} [options]
+ */
+export function sync(method, model, options = {}) {
+  let data = options.data;
+
+  // Ensure that we have the appropriate request data.
+  if (data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+    data = options.attrs || model.toJSON();
+  }
+
+  const type = methodMap[method];
+  const params = {
+    method: type,
+    body: data ? JSON.stringify(data) : '',
+    success: options.success,
+    error: options.error,
+  };
+
+  const url = options.url || result(model, 'url') || urlError();
+  const xhr = (options.xhr = fetch(url, params));
+  model.trigger('request', model, xhr, { ...params, xhr });
+  return xhr;
 }

package/src/{main.js → index.js}

@@ -1,29 +1,24 @@
 /* global global */
-import { ajax, sync } from './helpers.js';
+import ElementView from './element.js';
+import EventEmitter from './eventemitter.js';
+import Storage from './storage.js';
 import { Collection } from './collection.js';
-import { Events } from './events.js';
-import History from './history.js';
 import { Model } from './model.js';
-import { Router } from './router.js';
-import { View } from './view.js';
+import { sync } from './helpers.js';
 
 const skeletor = {
   Collection,
-  Events,
-  History,
+  ElementView,
+  EventEmitter,
   Model,
-  Router,
-  View,
-  ajax,
-  sync
-}
-
-Object.assign(skeletor, Events);
+  sync,
+};
 
 // Establish the root object, `window` (`self`) in the browser, or `global` on the server.
 // We use `self` instead of `window` for `WebWorker` support.
-const root = typeof self == 'object' && self.self === self && self ||
-          typeof global == 'object' && global.global === global && global;
+const root =
+  (typeof self == 'object' && self.self === self && self) ||
+  (typeof global == 'object' && global.global === global && global);
 
 // Current version of the library. Keep in sync with `package.json`.
 skeletor.VERSION = '0.0.1';
@@ -34,10 +29,19 @@ const previousSkeletor = root.Skeletor;
 
 // Runs Skeletor.js in *noConflict* mode, returning the `Skeletor` variable
 // to its previous owner. Returns a reference to this Skeletor object.
-skeletor.noConflict = function() {
+skeletor.noConflict = function () {
   root.Skeletor = previousSkeletor;
   return this;
 };
 
 root.Skeletor = skeletor;
 export default skeletor;
+
+export {
+  Collection,
+  ElementView,
+  EventEmitter,
+  Model,
+  Storage,
+  sync,
+}

package/src/listening.js

@@ -0,0 +1,81 @@
+import { eventsApi, onApi, offApi } from './utils/events.js';
+
+/**
+ * A listening class that tracks and cleans up memory bindings
+ * when all callbacks have been offed.
+ */
+class Listening {
+
+  /** @typedef {import('./eventemitter.js').default} EventEmitter */
+
+  /**
+   * @param {any} listener
+   * @param {any} obj
+   */
+  constructor(listener, obj) {
+    this.id = listener._listenId;
+    this.listener = listener;
+    this.obj = obj;
+    this.interop = true;
+    this.count = 0;
+    this._events = undefined;
+  }
+
+  /**
+   * @param {string} name
+   * @param {Function} callback
+   * @param {any} context
+   * @param {Listening} _listening
+   */
+  start(name, callback, context, _listening) {
+    this._events = eventsApi(onApi, this._events || {}, name, callback, {
+      context: this.obj,
+      ctx: context,
+      listening: _listening,
+    });
+
+    if (_listening) {
+      const listeners = this.obj._listeners || (this.obj._listeners = {});
+      listeners[this.id] = this;
+
+      // Allow the listening to use a counter, instead of tracking
+      // callbacks for library interop
+      this.interop = false;
+    }
+
+    return this;
+  }
+
+  /**
+   * Stop's listening to 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.
+   * @param {string} name
+   * @param {Function} callback
+   */
+  stop(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.
+   */
+  cleanup() {
+    delete this.listener._listeningTo[this.obj._listenId];
+    if (!this.interop) delete this.obj._listeners[this.id];
+  }
+}
+
+export default Listening;