src/ajax-adapter.js
+
export default class AjaxAdapter {
+
+ constructor(options) {
+ this._base = (options && options.base) || "";
+ };
+
+ create(store, type, partial, success, error, context) {
+
+ if (error && {}.toString.call(error) !== '[object Function]') {
+
+ this.create(store, type, partial, success, null, error);
+
+ } else if (store._types[type]) {
+
+ let request = new XMLHttpRequest();
+
+ request.open('POST', `${this._base}/${type}`, true);
+
+ request.onload = function () {
+ if (request.status >= 200 && request.status < 300) {
+ let response = JSON.parse(request.responseText);
+ try {
+ store.push(response);
+ if (success) {
+ success.call(context, store.find(response.data.type, response.data.id));
+ }
+ } catch (e) {
+ if (error) {
+ error.call(context, e);
+ }
+ }
+ } else {
+ if (error) {
+ error.call(context);
+ }
+ }
+ };
+
+ request.send({
+ data: JSON.stringify(store.convert(type, partial))
+ });
+
+ } else {
+ throw new Error(`Unknown type '${type}'`);
+ }
+
+ }
+
+ destroy(store, type, id, success, error, context) {
+
+ if (error && {}.toString.call(error) !== '[object Function]') {
+
+ this.destroy(store, type, id, success, null, error);
+
+ } else if (store._types[type]) {
+
+ let request = new XMLHttpRequest();
+
+ request.open('DELETE', `${this._base}/${type}/${id}`, true);
+
+ request.onload = function () {
+ if (request.status >= 200 && request.status < 300) {
+ try {
+ store.remove(type, id);
+ if (success) {
+ success.call(context);
+ }
+ } catch (e) {
+ error.call(context, e);
+ }
+ } else if (error) {
+ error.call(context);
+ }
+ };
+
+ request.send();
+
+ } else {
+ throw new Error(`Unknown type '${type}'`);
+ }
+
+ }
+
+ load(store, type, id, options, success, error, context) {
+
+ if (id && {}.toString.call(id) === '[object Function]') {
+ this.load(store, type, null, null, id, options, success);
+ } else if (id && typeof id === "object") {
+ this.load(store, type, null, id, options, success, error);
+ } else if (options && {}.toString.call(options) === '[object Function]') {
+ this.load(store, type, id, {}, options, success, error);
+ } else if (error && {}.toString.call(error) !== '[object Function]') {
+ this.load(store, type, id, options, success, null, error);
+ } else if (store._types[type]) {
+
+ let request = new XMLHttpRequest();
+ let url;
+
+ options = options || {};
+ url = id ? `${this._base}/${type}/${id}` : `${this._base}/${type}`;
+
+ if (options) {
+
+ let params = [];
+
+ if (options.fields) {
+ Object.keys(options.fields).forEach(field => {
+ options[`fields[${field}]`] = options.fields[field];
+ });
+ delete options.fields;
+ }
+
+ params = Object.keys(options).map(key => {
+ return key + "=" + encodeURIComponent(options[key]);
+ }).sort();
+
+ if (params.length) {
+ url = `${url}?${params.join("&")}`;
+ }
+
+ }
+
+ request.open('GET', url, true);
+
+ request.onload = function () {
+ if (request.status >= 200 && request.status < 300) {
+ try {
+ store.push(JSON.parse(request.responseText));
+ if (success) {
+ success.call(context, id ? store.find(type, id) : store.find(type));
+ }
+ } catch (e) {
+ error.call({}, e);
+ }
+ } else if (error) {
+ error.call(context);
+ }
+ };
+
+ request.send();
+
+ } else {
+ throw new Error(`Unknown type '${type}'`);
+ }
+
+ }
+
+ update(store, type, id, partial, success, error, context) {
+
+ if (error && {}.toString.call(error) !== '[object Function]') {
+
+ this.update(store, type, id, partial, success, null, error);
+
+ } else if (store._types[type]) {
+
+ let request = new XMLHttpRequest();
+ let data = store.convert(type, id, partial);
+
+ request.open('PATCH', `${this._base}/${type}/${id}`, true);
+
+ request.onload = function () {
+ if (request.status >= 200 && request.status < 300) {
+ try {
+ store.add(data);
+ if (success) {
+ success.call(context, store.find(data.type, data.id));
+ }
+ } catch (e) {
+ if (error) {
+ error.call(context, e);
+ }
+ }
+ } else if (error) {
+ error.call(context);
+ }
+ };
+
+ request.send({
+ data: JSON.stringify(data)
+ });
+
+ } else {
+ throw new Error(`Unknown type '${type}'`);
+ }
+
+ }
+
+}
+
+
src/store.js
+
import "array.prototype.find";
+import AjaxAdapter from "./ajax-adapter";
+
+export default class Store {
+
+ /**
+ * Creates a field definition for an attribute.
+ *
+ * @since 0.1.0
+ * @param {string} [name] - Name of the property to map this field from.
+ * @param {Object} [options] - An options object.
+ * @param {string} [options.default] - Default value for this field.
+ * @return {Object} - Field definition.
+ */
+ static attr(name, options) {
+ if (name && typeof name === 'object') {
+ return Store.attr(null, name);
+ } else {
+ return {
+ type: "attr",
+ default: options && options.default,
+ deserialize: function (data, key) {
+ return data.attributes && data.attributes[name || key];
+ },
+ serialize: function (resource, data, key) {
+ data.attributes[name || key] = resource[key];
+ }
+ };
+ }
+ }
+
+ /**
+ * Creates a field definition for an has-one relationship.
+ *
+ * @since 0.1.0
+ * @param {string} [name] - Name of the property to map this field from.
+ * @param {Object} [options] - An options object.
+ * @param {string} [options.inverse] - Name of the inverse relationship.
+ * @return {Object} - Field definition.
+ */
+ static hasOne(name, options) {
+ if (name && typeof name === 'object') {
+ return Store.hasOne(null, name);
+ } else {
+ return {
+ type: "has-one",
+ inverse: options && options.inverse,
+ deserialize: function (data, key) {
+ name = name || key;
+ if (data.relationships && data.relationships[name]) {
+ if (data.relationships[name].data === null) {
+ return null;
+ } else if (data.relationships[name].data) {
+ return this.find(data.relationships[name].data.type, data.relationships[name].data.id);
+ }
+ }
+ }
+ };
+ }
+ }
+
+ /**
+ * Creates a field definition for an has-many relationship.
+ *
+ * @since 0.1.0
+ * @param {string} [name] - Name of the property to map this field from.
+ * @param {Object} [options] - An options object.
+ * @param {string} [options.inverse] - Name of the inverse relationship.
+ * @return {Object} - Field definition.
+ */
+ static hasMany(name, options) {
+ if (name && typeof name === 'object') {
+ return Store.hasMany(null, name);
+ } else {
+ return {
+ type: "has-many",
+ default: [],
+ inverse: options && options.inverse,
+ deserialize: function (data, key) {
+ name = name || key;
+ if (data.relationships && data.relationships[name]) {
+ if (data.relationships[name].data === null) {
+ return [];
+ } else if (data.relationships[name].data) {
+ return data.relationships[name].data.map((c) => {
+ return this.find(c.type, c.id);
+ });
+ }
+ }
+ }
+ };
+ }
+ }
+
+ constructor(adapter) {
+ this._adapter = adapter;
+ this._collectionListeners = { "added": {}, "updated": {}, "removed": {} };
+ this._data = {};
+ this._resourceListeners = { "added": {}, "updated": {}, "removed": {} };
+ this._types = {};
+ }
+
+ /**
+ * Add an individual resource to the store. This is used internally by the
+ * `push()` method.
+ *
+ * @since 0.1.0
+ * @param {!Object} object - Resource Object to add. See:
+ http://jsonapi.org/format/#document-resource-objects
+ * @return {undefined} - Nothing.
+ */
+ add(object) {
+ if (object) {
+ if (object.type && object.id) {
+ let event = this._data[object.type] && this._data[object.type][object.id] ? "updated" : "added";
+ let resource = this.find(object.type, object.id);
+ let definition = this._types[object.type];
+ Object.keys(definition).forEach(fieldName => {
+ if (fieldName[0] !== "_") {
+ this._addField(object, resource, definition, fieldName);
+ }
+ });
+ if (this._resourceListeners[event][object.type] && this._resourceListeners[event][object.type][object.id]) {
+ this._resourceListeners[event][object.type][object.id].forEach(x => x[0].call(x[1], resource));
+ }
+ if (this._collectionListeners[event][object.type]) {
+ this._collectionListeners[event][object.type].forEach(x => x[0].call(x[1], resource));
+ }
+ } else {
+ throw new TypeError(`The data must have a type and id`);
+ }
+ } else {
+ throw new TypeError(`You must provide data to add`);
+ }
+ }
+
+ /**
+ * Converts the given partial into a JSON API compliant representation.
+ *
+ * @since 0.5.0
+ * @param {!string} [type] - The type of the resource. This can be omitted if the partial includes a type property.
+ * @param {!string} [id] - The id of the resource. This can be omitted if the partial includes an id property.
+ * @param {!object} partial - The data to convert.
+ * @return {object} - JSON API version of the object.
+ */
+ convert(type, id, partial) {
+ if (type && typeof type === "object") {
+ return this.convert(type.type, type.id, type);
+ } else if (id && typeof id === "object") {
+ return this.convert(type, id.id, id);
+ } else {
+ let data = {
+ type: type,
+ attributes: {},
+ relationships: {}
+ };
+ if (id) {
+ data.id = id;
+ }
+ let definition = this._types[data.type];
+ Object.keys(definition).forEach(fieldName => {
+ if (fieldName[0] !== "_") {
+ definition[fieldName].serialize(partial, data, fieldName);
+ }
+ });
+ return data;
+ }
+ }
+
+ /**
+ * Attempts to create the resource through the adapter and adds it to the
+ * store if successful.
+ *
+ * @since 0.5.0
+ * @param {!string} type - Type of resource.
+ * @param {!Object} partial - Data to create the resource with.
+ * @param {function} [success] - Callback on success.
+ * @param {function} [error] - Callback on error.
+ * @param {Object} [context] - Context for the callbacks.
+ * @return {undefined} - Nothing.
+ *
+ * @example
+ * let adapter = new Store.AjaxAdapter();
+ * let store = new Store(adpater);
+ * store.create("product", { title: "A Book" }, (product) => {
+ * console.log(product.title);
+ * });
+ */
+ create(type, partial, success, error, context) {
+ if (this._adapter) {
+ this._adapter.create(this, type, partial, success, error, context);
+ } else {
+ throw new Error("Adapter missing. Specify an adapter when creating the store: `var store = new Store(adapter);`");
+ }
+ }
+
+ /**
+ * Defines a type of resource.
+ *
+ * @since 0.2.0
+ * @param {!string|string[]} names - Name(s) of the resource.
+ * @param {!Object} definition - The resource's definition.
+ * @return {undefined} - Nothing.
+ */
+ define(names, definition) {
+ names = (names.constructor === Array) ? names : [ names ];
+ if (definition) {
+ definition._names = names;
+ names.forEach(name => {
+ if (!this._types[name]) {
+ this._types[name] = definition;
+ } else {
+ throw new Error(`The type '${name}' has already been defined.`);
+ }
+ });
+ } else {
+ throw new Error(`You must provide a definition for the type '${names[0]}'.`);
+ }
+ }
+
+ /**
+ * Attempts to delete the resource through the adapter and removes it from
+ * the store if successful.
+ *
+ * @since 0.5.0
+ * @param {!string} type - Type of resource.
+ * @param {!string} id - ID of resource.
+ * @param {function} [success] - Callback on success.
+ * @param {function} [error] - Callback on error.
+ * @param {Object} [context] - Context for the callbacks.
+ * @return {undefined} - Nothing.
+ *
+ * @example
+ * let adapter = new Store.AjaxAdapter();
+ * let store = new Store(adpater);
+ * store.destroy("product", "1", () => {
+ * console.log("Destroyed!");
+ * });
+ */
+ destroy(type, id, success, error, context) {
+ if (this._adapter) {
+ this._adapter.destroy(this, type, id, success, error, context);
+ } else {
+ throw new Error("Adapter missing. Specify an adapter when creating the store: `var store = new Store(adapter);`");
+ }
+ }
+
+ /**
+ * Find a resource or entire collection of resources.
+ *
+ * NOTE: If the resource hasn't been loaded via an add() or push() call it
+ * will be automatically created when find is called.
+ *
+ * @since 0.1.0
+ * @param {!string} type - Type of the resource(s) to find.
+ * @param {string} [id] - The id of the resource to find. If omitted all
+ * resources of the type will be returned.
+ * @return {Object|Object[]} - Either the resource or an array of resources.
+ */
+ find(type, id) {
+ if (type) {
+ let definition = this._types[type];
+ if (definition) {
+ if (!this._data[type]) {
+ let collection = {};
+ definition._names.forEach(t => this._data[t] = collection);
+ }
+ if (id) {
+ if (!this._data[type][id]) {
+ this._data[type][id] = {
+ _dependents: [],
+ type: type,
+ id: id
+ };
+ Object.keys(definition).forEach(key => {
+ if (key[0] !== "_") {
+ this._data[type][id][key] = definition[key].default;
+ }
+ });
+ }
+ return this._data[type][id];
+ } else {
+ return Object.keys(this._data[type]).map(x => this._data[type][x]);
+ }
+ } else {
+ throw new TypeError(`Unknown type '${type}'`);
+ }
+ } else {
+ throw new TypeError(`You must provide a type`);
+ }
+ }
+
+ /**
+ * Attempts to load the resource(s) through the adapter and adds it/them to
+ * the store if successful.
+ *
+ * @since 0.5.0
+ * @param {!string} type - Type of resource.
+ * @param {!string} [id] - ID of resource.
+ * @param {Object} [options] - **NOT YET IMPLEMENTED** (this will include sorting, filtering and pagination options)
+ * @param {function} [success] - Callback on success.
+ * @param {function} [error] - Callback on error.
+ * @param {Object} [context] - Context for the callbacks.
+ * @return {undefined} - Nothing.
+ *
+ * @example
+ * let adapter = new Store.AjaxAdapter();
+ * let store = new Store(adpater);
+ * store.load("product", "1", (product) => {
+ * console.log(product.title);
+ * });
+ */
+ load(type, id, options, success, error, context) {
+ if (this._adapter) {
+ this._adapter.load(this, type, id, options, success, error, context);
+ } else {
+ throw new Error("Adapter missing. Specify an adapter when creating the store: `var store = new Store(adapter);`");
+ }
+ }
+
+ /**
+ * Unregister an event listener that was registered with on().
+ *
+ * @since 0.4.0
+ * @param {string} event - Name of the event.
+ * @param {string} type - Name of resource to originally passed to on().
+ * @param {string} [id] - ID of the resource to originally passed to on().
+ * @param {function} callback - Function originally passed to on().
+ * @return {undefined} - Nothing.
+ */
+ off(event, type, id, callback) {
+ if (this._resourceListeners[event] && this._collectionListeners[event]) {
+ if (this._types[type]) {
+ if (id && ({}).toString.call(id) === '[object Function]') {
+ this.off.call(this, event, type, null, id, callback);
+ } else {
+ // TODO: Performance-wise, this can be made way better. There shouldn't be a need to maintain separate lists.
+ this._types[type]._names.forEach(type => {
+ if (id) {
+ if (this._resourceListeners[event][type] && this._resourceListeners[event][type][id]) {
+ this._resourceListeners[event][type][id] = this._resourceListeners[event][type][id].filter(x => {
+ return x[0] !== callback;
+ });
+ }
+ } else if (this._collectionListeners[event][type]) {
+ this._collectionListeners[event][type] = this._collectionListeners[event][type].filter(x => {
+ return x[0] !== callback;
+ });
+ }
+ });
+ }
+ } else {
+ throw new Error(`Unknown type '${type}'`);
+ }
+ } else {
+ throw new Error(`Unknown event '${event}'`);
+ }
+ }
+
+ /**
+ * Register an event listener: "added", "updated" or "removed".
+ *
+ * @since 0.4.0
+ * @param {string} event - Name of the event.
+ * @param {string} type - Name of resource to watch.
+ * @param {string} [id] - ID of the resource to watch.
+ * @param {function} callback - Function to call when the event occurs.
+ * @param {Object} [context] - Context in which to call the callback.
+ * @return {undefined} - Nothing.
+ */
+ on(event, type, id, callback, context) {
+ if (this._resourceListeners[event] && this._collectionListeners[event]) {
+ if (this._types[type]) {
+ if (id && ({}).toString.call(id) === '[object Function]') {
+ this.on.call(this, event, type, null, id, callback);
+ } else {
+ // TODO: Performance-wise, this can be made way better. There shouldn't be a need to maintain separate lists.
+ this._types[type]._names.forEach(type => {
+ if (id) {
+ this._resourceListeners[event][type] = this._resourceListeners[event][type] || {};
+ this._resourceListeners[event][type][id] = this._resourceListeners[event][type][id] || [];
+ if (!this._resourceListeners[event][type][id].find(x => x[0] === callback)) {
+ this._resourceListeners[event][type][id].push([ callback, context ]);
+ }
+ } else {
+ this._collectionListeners[event][type] = this._collectionListeners[event][type] || [];
+ if (!this._collectionListeners[event][type].find(x => x[0] === callback)) {
+ this._collectionListeners[event][type].push([ callback, context ]);
+ }
+ }
+ });
+ }
+ } else {
+ throw new Error(`Unknown type '${type}'`);
+ }
+ } else {
+ throw new Error(`Unknown event '${event}'`);
+ }
+ }
+
+ /**
+ * Add a JSON API response to the store. This method can be used to handle a
+ * successful GET or POST response from the server.
+ *
+ * @since 0.1.0
+ * @param {Object} root - Top Level Object to push. See:
+ http://jsonapi.org/format/#document-top-level
+ * @return {undefined} - Nothing.
+ */
+ push(root) {
+ if (root.data.constructor === Array) {
+ root.data.forEach(x => this.add(x));
+ } else {
+ this.add(root.data);
+ }
+ if (root.included) {
+ root.included.forEach(x => this.add(x));
+ }
+ }
+
+ /**
+ * Remove a resource or collection of resources from the store.
+ *
+ * @since 0.1.0
+ * @param {!string} type - Type of the resource(s) to remove.
+ * @param {string} [id] - The id of the resource to remove. If omitted all
+ * resources of the type will be removed.
+ * @return {undefined} - Nothing.
+ */
+ remove(type, id) {
+ if (type) {
+ if (this._types[type]) {
+ if (id) {
+ let resource = this._data[type] && this._data[type][id];
+ if (resource) {
+ this._remove(resource);
+ if (this._resourceListeners["removed"][type] && this._resourceListeners["removed"][type][id]) {
+ this._resourceListeners["removed"][type][id].forEach(x => x[0].call(x[1], resource));
+ }
+ if (this._collectionListeners["removed"][type]) {
+ this._collectionListeners["removed"][type].forEach(x => x[0].call(x[1], resource));
+ }
+ }
+ } else {
+ Object.keys(this._data[type]).forEach(id => this.remove(type, id));
+ }
+ } else {
+ throw new TypeError(`Unknown type '${type}'`);
+ }
+ } else {
+ throw new TypeError(`You must provide a type to remove`);
+ }
+ }
+
+ /**
+ * Attempts to update the resource through the adapter and updates it in the
+ * store if successful.
+ *
+ * @since 0.5.0
+ * @param {!string} type - Type of resource.
+ * @param {!string} id - ID of resource.
+ * @param {!Object} partial - Data to update the resource with.
+ * @param {function} [success] - Callback on success.
+ * @param {function} [error] - Callback on error.
+ * @param {Object} [context] - Context for the callbacks.
+ * @return {undefined} - Nothing.
+ *
+ * @example
+ * let adapter = new Store.AjaxAdapter();
+ * let store = new Store(adpater);
+ * store.update("product", "1", { title: "foo" }, (product) => {
+ * console.log(product.title);
+ * });
+ */
+ update(type, id, partial, success, error, context) {
+ if (this._adapter) {
+ this._adapter.update(this, type, id, partial, success, error, context);
+ } else {
+ throw new Error("Adapter missing. Specify an adapter when creating the store: `var store = new Store(adapter);`");
+ }
+ }
+
+ _addField(object, resource, definition, fieldName) {
+ var field = definition[fieldName];
+ var newValue = field.deserialize.call(this, object, fieldName);
+ if (typeof newValue !== "undefined") {
+ if (field.type === "has-one") {
+ if (resource[fieldName]) {
+ this._removeInverseRelationship(resource, fieldName, resource[fieldName], field);
+ }
+ if (newValue) {
+ this._addInverseRelationship(resource, fieldName, newValue, field);
+ }
+ } else if (field.type === "has-many") {
+ resource[fieldName].forEach(r => {
+ if (resource[fieldName].indexOf(r) !== -1) {
+ this._removeInverseRelationship(resource, fieldName, r, field);
+ }
+ });
+ newValue.forEach(r => {
+ this._addInverseRelationship(resource, fieldName, r, field);
+ });
+ }
+ resource[fieldName] = newValue;
+ }
+ }
+
+ _addInverseRelationship(sourceResource, sourceFieldName, targetResource, sourceField) {
+ var targetDefinition = this._types[targetResource.type];
+ var sourceDefinition = this._types[sourceResource.type];
+ if (targetDefinition) {
+ let targetFieldName = [ sourceField.inverse ].concat(sourceDefinition._names).find(x => targetDefinition[x]);
+ let targetField = targetDefinition && targetDefinition[targetFieldName];
+ targetResource._dependents.push({ type: sourceResource.type, id: sourceResource.id, fieldName: sourceFieldName });
+ if (targetField) {
+ if (targetField.type === "has-one") {
+ sourceResource._dependents.push({ type: targetResource.type, id: targetResource.id, fieldName: targetFieldName });
+ targetResource[targetFieldName] = sourceResource;
+ } else if (targetField.type === "has-many") {
+ sourceResource._dependents.push({ type: targetResource.type, id: targetResource.id, fieldName: targetFieldName });
+ if (targetResource[targetFieldName].indexOf(sourceResource) === -1) {
+ targetResource[targetFieldName].push(sourceResource);
+ }
+ } else if (targetField.type === "attr") {
+ throw new Error(`The the inverse relationship for '${sourceFieldName}' is an attribute ('${targetFieldName}')`);
+ }
+ } else if (sourceField.inverse) {
+ throw new Error(`The the inverse relationship for '${sourceFieldName}' is missing ('${sourceField.inverse}')`);
+ }
+ }
+ }
+
+ _remove(resource) {
+ resource._dependents.forEach(dependent => {
+ let dependentResource = this._data[dependent.type][dependent.id];
+ switch (this._types[dependent.type][dependent.fieldName].type) {
+ case "has-one": {
+ dependentResource[dependent.fieldName] = null;
+ break;
+ }
+ case "has-many": {
+ let index = dependentResource[dependent.fieldName].indexOf(resource);
+ if (index !== -1) {
+ dependentResource[dependent.fieldName].splice(index, 1);
+ }
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ // TODO: This only needs to be run once for each dependent.
+ dependentResource._dependents = dependentResource._dependents.filter(d => {
+ return !(d.type === resource.type && d.id === resource.id);
+ });
+ });
+ delete this._data[resource.type][resource.id];
+ }
+
+ _removeInverseRelationship(sourceResource, sourceFieldName, targetResource, sourceField) {
+ var targetDefinition = this._types[targetResource.type];
+ var targetFieldName = sourceField.inverse || sourceResource.type;
+ var targetField = targetDefinition && targetDefinition[targetFieldName];
+ targetResource._dependents = targetResource._dependents.filter(r => {
+ return !(r.type === sourceResource.type && r.id === sourceResource.id && r.fieldName === sourceFieldName);
+ });
+ if (targetField) {
+ if (targetField.type === "has-one") {
+ sourceResource._dependents = sourceResource._dependents.filter(r => {
+ return !(r.type === targetResource.type && r.id === targetResource.id && r.fieldName === targetFieldName);
+ });
+ targetResource[targetFieldName] = null;
+ } else if (targetField.type === "has-many") {
+ sourceResource._dependents = sourceResource._dependents.filter(r => {
+ return !(r.type === targetResource.type && r.id === targetResource.id && r.fieldName === targetFieldName);
+ });
+ targetResource[targetFieldName] = targetResource[targetFieldName].filter(r => {
+ return r !== sourceResource;
+ });
+ } else if (targetField.type === "attr") {
+ throw new Error(`The the inverse relationship for '${sourceFieldName}' is an attribute ('${targetFieldName}')`);
+ }
+ } else if (sourceField.inverse) {
+ throw new Error(`The the inverse relationship for '${sourceFieldName}' is missing ('${sourceField.inverse}')`);
+ }
+ }
+
+}
+
+Store.AjaxAdapter = AjaxAdapter;
+
+
+
+ 
