Merge pull request #5 from RoundingWellOS/update-build

Update build tools and bump version to 1.1.1

Author: paulfalgout

.babelrc

@@ -1,3 +1,8 @@
 {
-  "presets": [ "es2015" ]
-}
+  "presets": ["@babel/env"],
+  "env": {
+    "test": {
+      "plugins": ["istanbul"]
+    }
+  }
+}

.eslintrc

@@ -1,8 +1,11 @@
 {
-  "parser": "babel-eslint",
   "extends": "eslint:recommended",
+  "parserOptions": {
+    "ecmaVersion": 6,
+    "sourceType": "module"
+  },
   "env": {
     "node": true,
     "mocha": true
   }
-}
+}

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 coverage
 .DS_Store
+.nyc_output

.travis.yml

@@ -1,3 +1,3 @@
 language: node_js
 node_js:
-  - "6.0"
+  - "12.0"

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 RoundingWell
+Copyright (c) 2020 RoundingWell
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -176,4 +176,4 @@ Backbone.Store is heavily inspired by [Backbone.UniqueModel](https://github.com/
 
 ===
 
-This library is © 2017 RoundingWell. Distributed under MIT license.
+This library is © 2020 RoundingWell. Distributed under MIT license.

dist/backbone.store.esm.js

@@ -0,0 +1,121 @@
+import _ from 'underscore';
+import Backbone from 'backbone';
+
+/*
+ * Encapsulates a cache for a single model.
+ */
+
+function ModelCache(Model, modelName) {
+  this.instances = {};
+  this.Model = Model;
+  this.modelName = modelName;
+  this.ModelConstructor = this._getConstructor(Model);
+}
+
+_.extend(ModelCache.prototype, {
+  _getConstructor: function _getConstructor(Model) {
+    var cache = this;
+
+    var ModelConstructor = function ModelConstructor(attrs, options) {
+      return cache.get(attrs, options);
+    }; // Extend Model's static properties onto new
+
+
+    _.extend(ModelConstructor, Model); // Backbone collections need prototype of wrapped class
+
+
+    ModelConstructor.prototype = this.Model.prototype;
+    return ModelConstructor;
+  },
+  get: function get(attrs, options) {
+    var instanceId = attrs && attrs[this.Model.prototype.idAttribute]; // Attempt to restore a locally cached instance
+
+    var instance = this.instances[instanceId];
+
+    if (!instance) {
+      // If we haven't seen this instance before, start caching it
+      return this._new(attrs, options);
+    } // Otherwise update the attributes of the cached instance
+
+
+    instance.set(attrs);
+    Store.trigger('update', instance, this);
+    return instance;
+  },
+  _new: function _new(attrs, options) {
+    var instance = new this.Model(attrs, options);
+
+    if (instance.isNew()) {
+      // Store the instance if we get an id after instantation
+      instance.once("change:".concat(instance.idAttribute), this._add, this);
+    } else {
+      this._add(instance);
+    }
+
+    instance.on('destroy', this.remove, this);
+    return instance;
+  },
+  _add: function _add(instance) {
+    // If the id is already stored do not add it.
+    if (this.instances[instance.id]) return;
+    this.instances[instance.id] = instance;
+    Store.trigger('add', instance, this);
+  },
+  remove: function remove(instance) {
+    if (!this.instances[instance.id]) return instance;
+    delete this.instances[instance.id];
+    Store.trigger('remove', instance, this);
+    return instance;
+  }
+});
+
+var ModelCaches = {};
+/**
+ * Store wrapper converts regular Backbone models into unique ones.
+ *
+ * Example:
+ *   const StoredUser = Store(User);
+ */
+
+function Store(Model) {
+  var modelName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _.uniqueId('Store_');
+  var cache = Store.add(Model, modelName);
+  return cache.ModelConstructor;
+} // Static functions
+
+
+_.extend(Store, Backbone.Events, {
+  ModelCache: ModelCache,
+  add: function add(Model, modelName) {
+    if (!modelName) throw 'Model name required';
+    if (ModelCaches[modelName]) return ModelCaches[modelName];
+    return ModelCaches[modelName] = new Store.ModelCache(Model, modelName);
+  },
+  getCache: function getCache(modelName) {
+    if (!ModelCaches[modelName]) throw "Unrecognized Model: \"".concat(modelName, "\"");
+    return ModelCaches[modelName];
+  },
+  getAllCache: function getAllCache() {
+    return _.clone(ModelCaches);
+  },
+  get: function get(modelName) {
+    return Store.getCache(modelName).ModelConstructor;
+  },
+  getAll: function getAll() {
+    return _.reduce(ModelCaches, function (all, cache, modelName) {
+      all[modelName] = cache.ModelConstructor;
+      return all;
+    }, {});
+  },
+  remove: function remove(modelName) {
+    delete ModelCaches[modelName];
+  },
+  removeAll: function removeAll() {
+    ModelCaches = {};
+  }
+});
+
+Backbone.Store = Store;
+
+export default Store;
+export { ModelCache };