Applied style rules to genocide all \t characters

app/imports/api/creature/creatureFolders/CreatureFolders.js

@@ -8,7 +8,7 @@ let creatureFolderSchema = new SimpleSchema({
 		type: String,
 		trim: false,
 		optional: true,
-    max: STORAGE_LIMITS.name,
+		max: STORAGE_LIMITS.name,
 	},
 	creatures: {
 		type: Array,
@@ -21,16 +21,16 @@ let creatureFolderSchema = new SimpleSchema({
 	owner: {
 		type: String,
 		regEx: SimpleSchema.RegEx.Id,
-    index: 1,
+		index: 1,
+	},
+	archived: {
+		type: Boolean,
+		optional: true,
+	},
+	order: {
+		type: Number,
+		defaultValue: 0,
 	},
-  archived: {
-    type: Boolean,
-    optional: true,
-  },
-  order: {
-    type: Number,
-    defaultValue: 0,
-  },
 });
 
 CreatureFolders.attachSchema(creatureFolderSchema);

app/imports/api/creature/creatureProperties/CreatureProperties.js

@@ -18,23 +18,23 @@ let CreaturePropertySchema = new SimpleSchema({
     type: String,
     optional: true,
   },
-	type: {
+  type: {
     type: String,
     allowedValues: Object.keys(propertySchemasIndex),
   },
-	tags: {
-		type: Array,
-		defaultValue: [],
+  tags: {
+    type: Array,
+    defaultValue: [],
     maxCount: STORAGE_LIMITS.tagCount,
-	},
-	'tags.$': {
-		type: String,
+  },
+  'tags.$': {
+    type: String,
     max: STORAGE_LIMITS.tagLength,
-	},
-	disabled: {
-		type: Boolean,
-		optional: true,
-	},
+  },
+  disabled: {
+    type: Boolean,
+    optional: true,
+  },
   icon: {
     type: storedIconsSchema,
     optional: true,
@@ -93,20 +93,20 @@ const DenormalisedOnlyCreaturePropertySchema = new SimpleSchema({
 
 CreaturePropertySchema.extend(DenormalisedOnlyCreaturePropertySchema);
 
-for (let key in propertySchemasIndex){
-	let schema = new SimpleSchema({});
-	schema.extend(propertySchemasIndex[key]);
-	schema.extend(CreaturePropertySchema);
+for (let key in propertySchemasIndex) {
+  let schema = new SimpleSchema({});
+  schema.extend(propertySchemasIndex[key]);
+  schema.extend(CreaturePropertySchema);
   schema.extend(ColorSchema);
-	schema.extend(ChildSchema);
-	schema.extend(SoftRemovableSchema);
-	CreatureProperties.attachSchema(schema, {
-		selector: {type: key}
-	});
+  schema.extend(ChildSchema);
+  schema.extend(SoftRemovableSchema);
+  CreatureProperties.attachSchema(schema, {
+    selector: { type: key }
+  });
 }
 
 export default CreatureProperties;
 export {
   DenormalisedOnlyCreaturePropertySchema,
-	CreaturePropertySchema,
+  CreaturePropertySchema,
 };

app/imports/api/creature/creatureProperties/methods/adjustQuantity.js

@@ -20,33 +20,33 @@ const adjustQuantity = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, operation, value}) {
+  run({ _id, operation, value }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
-		assertEditPermission(rootCreature, this.userId);
+    assertEditPermission(rootCreature, this.userId);
 
     // Do work
-    adjustQuantityWork({property, operation, value});
+    adjustQuantityWork({ property, operation, value });
   },
 });
 
-export function adjustQuantityWork({property, operation, value}){
+export function adjustQuantityWork({ property, operation, value }) {
   // Check if property has quantity
   let schema = CreatureProperties.simpleSchema(property);
-  if (!schema.allowsKey('quantity')){
+  if (!schema.allowsKey('quantity')) {
     throw new Meteor.Error(
       'Adjust quantity failed',
       `Property of type "${property.type}" doesn't have a quantity`
     );
   }
-  if (operation === 'set'){
+  if (operation === 'set') {
     CreatureProperties.update(property._id, {
-      $set: {quantity: value, dirty: true}
+      $set: { quantity: value, dirty: true }
     }, {
       selector: property
     });
-  } else if (operation === 'increment'){
+  } else if (operation === 'increment') {
     // value here is 'damage'
     value = -value;
     let currentQuantity = property.quantity;

app/imports/api/creature/creatureProperties/methods/damageProperty.js

@@ -22,7 +22,7 @@ const damageProperty = new ValidatedMethod({
     timeInterval: 5000,
   },
   run({ _id, operation, value }) {
-    
+
     // Get action context
     let prop = CreatureProperties.findOne(_id);
     if (!prop) throw new Meteor.Error(
@@ -30,17 +30,17 @@ const damageProperty = new ValidatedMethod({
     );
     const creatureId = prop.ancestors[0].id;
     const actionContext = new ActionContext(creatureId, [creatureId], this);
-    
-		// Check permissions
+
+    // Check permissions
     assertEditPermission(actionContext.creature, this.userId);
 
-		// Check if property can take damage
-		let schema = CreatureProperties.simpleSchema(prop);
-		if (!schema.allowsKey('damage')){
-			throw new Meteor.Error(
-				'Damage property failed',
-				`Property of type "${prop.type}" can't be damaged`
-			);
+    // Check if property can take damage
+    let schema = CreatureProperties.simpleSchema(prop);
+    if (!schema.allowsKey('damage')) {
+      throw new Meteor.Error(
+        'Damage property failed',
+        `Property of type "${prop.type}" can't be damaged`
+      );
     }
 
     // Replace the prop by its actionContext counterpart if possible
@@ -50,9 +50,9 @@ const damageProperty = new ValidatedMethod({
         prop = actionContextProp;
       }
     }
-    
+
     const result = damagePropertyWork({ prop, operation, value, actionContext });
-  
+
     // Insert the log
     actionContext.writeLog();
     return result;
@@ -86,7 +86,7 @@ export function damagePropertyWork({ prop, operation, value, actionContext }) {
   }
 
   let damage, newValue, increment;
-  if (operation === 'set'){
+  if (operation === 'set') {
     const total = prop.total || 0;
     // Set represents what we want the value to be after damage
     // So we need the actual damage to get to that value
@@ -105,7 +105,7 @@ export function damagePropertyWork({ prop, operation, value, actionContext }) {
     // Also write it straight to the prop so that it is updated in the actionContext
     prop.damage = damage;
     prop.value = newValue;
-  } else if (operation === 'increment'){
+  } else if (operation === 'increment') {
     let currentValue = prop.value || 0;
     let currentDamage = prop.damage || 0;
     increment = value;

app/imports/api/creature/creatureProperties/methods/duplicateProperty.js

@@ -5,12 +5,12 @@ import CreatureProperties from '/imports/api/creature/creatureProperties/Creatur
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import {
-	setLineageOfDocs,
-	renewDocIds
+  setLineageOfDocs,
+  renewDocIds
 } from '/imports/api/parenting/parenting.js';
 import { reorderDocs } from '/imports/api/parenting/order.js';
 var snackbar;
-if (Meteor.isClient){
+if (Meteor.isClient) {
   snackbar = require(
     '/imports/ui/components/snackbars/SnackbarQueue.js'
   ).snackbar
@@ -31,7 +31,7 @@ const duplicateProperty = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id}) {
+  run({ _id }) {
     let property = CreatureProperties.findOne(_id);
     let creature = getRootCreatureAncestor(property);
 
@@ -44,17 +44,17 @@ const duplicateProperty = new ValidatedMethod({
 
     // Get all the descendants
     let nodes = CreatureProperties.find({
-			'ancestors.id': _id,
-			removed: {$ne: true},
-		}, {
+      'ancestors.id': _id,
+      removed: { $ne: true },
+    }, {
       limit: DUPLICATE_CHILDREN_LIMIT + 1,
-      sort: {order: 1},
+      sort: { order: 1 },
     }).fetch();
 
     // Alert the user if the limit was hit
-    if (nodes.length > DUPLICATE_CHILDREN_LIMIT){
+    if (nodes.length > DUPLICATE_CHILDREN_LIMIT) {
       nodes.pop();
-      if (Meteor.isClient){
+      if (Meteor.isClient) {
         snackbar({
           text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
         });
@@ -63,25 +63,25 @@ const duplicateProperty = new ValidatedMethod({
 
     // re-map all the ancestors
     setLineageOfDocs({
-			docArray: nodes,
-			newAncestry : [
+      docArray: nodes,
+      newAncestry: [
         ...property.ancestors,
-        {id: propertyId, collection: 'creatureProperties'}
+        { id: propertyId, collection: 'creatureProperties' }
       ],
-			oldParent : {id: _id, collection: 'creatureProperties'},
-		});
+      oldParent: { id: _id, collection: 'creatureProperties' },
+    });
 
     // Give the docs new IDs without breaking internal references
-    renewDocIds({docArray: nodes});
+    renewDocIds({ docArray: nodes });
 
     // Order the root node
     property.order += 0.5;
-    
+
     // Mark the sheet as needing recompute
     property.dirty = true;
 
     // Insert the properties
-		CreatureProperties.batchInsert([property, ...nodes]);
+    CreatureProperties.batchInsert([property, ...nodes]);
 
     // Tree structure changed by inserts, reorder the tree
     reorderDocs({

app/imports/api/creature/creatureProperties/methods/equipItem.js

@@ -10,8 +10,8 @@ import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/
 // Equipping or unequipping an item will also change its parent
 const equipItem = new ValidatedMethod({
   name: 'creatureProperties.equip',
-  validate({_id, equipped}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
+  validate({ _id, equipped }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
     if (equipped !== true && equipped !== false) {
       throw new Meteor.Error('No equipped', 'equipped is required to be true or false');
     }
@@ -21,20 +21,20 @@ const equipItem = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, equipped}) {
+  run({ _id, equipped }) {
     let item = CreatureProperties.findOne(_id);
     if (item.type !== 'item') throw new Meteor.Error('wrong type',
-    'Equip and unequip can only be performed on items');
+      'Equip and unequip can only be performed on items');
     let creature = getRootCreatureAncestor(item);
     assertEditPermission(creature, this.userId);
     CreatureProperties.update(_id, {
       $set: { equipped, dirty: true },
     }, {
-			selector: {type: 'item'},
-		});
+      selector: { type: 'item' },
+    });
     let tag = equipped ? BUILT_IN_TAGS.equipment : BUILT_IN_TAGS.carried;
     let parentRef = getParentRefByTag(creature._id, tag);
-    if (!parentRef) parentRef = {id: creature._id, collection: 'creatures'};
+    if (!parentRef) parentRef = { id: creature._id, collection: 'creatures' };
 
     organizeDoc.call({
       docRef: {

app/imports/api/creature/creatureProperties/methods/flipToggle.js

@@ -6,24 +6,24 @@ import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/ge
 
 const flipToggle = new ValidatedMethod({
   name: 'creatureProperties.flipToggle',
-  validate({_id}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
+  validate({ _id }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
   },
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id}) {
+  run({ _id }) {
     // Permission
     let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1, enabled: 1, disabled: 1}
+      fields: { type: 1, ancestors: 1, enabled: 1, disabled: 1 }
     });
-    if (property.type !== 'toggle'){
+    if (property.type !== 'toggle') {
       throw new Meteor.Error('wrong property',
         'This method can only be applied to toggles');
     }
-    if (!property.enabled && !property.disabled){
+    if (!property.enabled && !property.disabled) {
       throw new Meteor.Error('Computed toggle',
         'Can\'t flip a toggle that is computed')
     }
@@ -32,13 +32,15 @@ const flipToggle = new ValidatedMethod({
 
     // Invert the current value, disabled is the canonical store of value
     const currentValue = !property.disabled;
-		CreatureProperties.update(_id, {$set: {
-      enabled: !currentValue,
-      disabled: currentValue,
-      dirty: true,
-    }}, {
-			selector: {type: 'toggle'},
-		});
+    CreatureProperties.update(_id, {
+      $set: {
+        enabled: !currentValue,
+        disabled: currentValue,
+        dirty: true,
+      }
+    }, {
+      selector: { type: 'toggle' },
+    });
   },
 });
 

app/imports/api/creature/creatureProperties/methods/insertProperty.js

@@ -12,7 +12,7 @@ import { getHighestOrder } from '/imports/api/parenting/order.js';
 
 const insertProperty = new ValidatedMethod({
   name: 'creatureProperties.insert',
-	validate: new SimpleSchema({
+  validate: new SimpleSchema({
     creatureProperty: {
       type: Object,
       blackbox: true,
@@ -24,25 +24,25 @@ const insertProperty = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty, parentRef}) {
+  run({ creatureProperty, parentRef }) {
     // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+    let { parentDoc, ancestors } = getAncestry({ parentRef });
 
-		// Check permission to edit
+    // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
     creatureProperty.parent = parentRef;
     creatureProperty.ancestors = ancestors;
 
-		return insertPropertyWork({
+    return insertPropertyWork({
       property: creatureProperty,
       creature: rootCreature,
     });
@@ -75,31 +75,31 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty, creatureId, tag, tagDefaultName}) {
+  run({ creatureProperty, creatureId, tag, tagDefaultName }) {
     let parentRef = getParentRefByTag(creatureId, tag);
 
-    if (!parentRef){
+    if (!parentRef) {
       // Use the creature as the parent and mark that we need to insert the folder first later
       var insertFolderFirst = true;
-      parentRef = {id: creatureId, collection: 'creatures'};
+      parentRef = { id: creatureId, collection: 'creatures' };
     }
 
     // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+    let { parentDoc, ancestors } = getAncestry({ parentRef });
 
     // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
     // Add the folder first if we need to
-    if (insertFolderFirst){
+    if (insertFolderFirst) {
       let order = getHighestOrder({
         collection: CreatureProperties,
         ancestorId: parentRef.id,
@@ -113,7 +113,7 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
         order,
       });
       // Make the folder our new parent
-      let newParentRef = {id, collection: 'creatureProperties'};
+      let newParentRef = { id, collection: 'creatureProperties' };
       ancestors = [parentRef, newParentRef];
       parentRef = newParentRef;
       creatureProperty.order = order + 1;
@@ -122,14 +122,14 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
     creatureProperty.parent = parentRef;
     creatureProperty.ancestors = ancestors;
 
-		return insertPropertyWork({
+    return insertPropertyWork({
       property: creatureProperty,
       creature: rootCreature,
     });
   },
 });
 
-export function insertPropertyWork({property, creature}){
+export function insertPropertyWork({ property, creature }) {
   delete property._id;
   property.dirty = true;
   let _id = CreatureProperties.insert(property);

app/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js

@@ -7,57 +7,57 @@ import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import {
-	setLineageOfDocs,
-	getAncestry,
-	renewDocIds
+  setLineageOfDocs,
+  getAncestry,
+  renewDocIds
 } from '/imports/api/parenting/parenting.js';
 import { reorderDocs } from '/imports/api/parenting/order.js';
 import { setDocToLastOrder } from '/imports/api/parenting/order.js';
 import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
 
 const insertPropertyFromLibraryNode = new ValidatedMethod({
-	name: 'creatureProperties.insertPropertyFromLibraryNode',
-	validate: new SimpleSchema({
+  name: 'creatureProperties.insertPropertyFromLibraryNode',
+  validate: new SimpleSchema({
     nodeIds: {
       type: Array,
       max: 20,
     },
-		'nodeIds.$': {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-		parentRef: {
-			type: RefSchema,
-		},
+    'nodeIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    parentRef: {
+      type: RefSchema,
+    },
     order: {
       type: Number,
       optional: true,
     },
-	}).validator(),
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({nodeIds, parentRef, order}) {
-		// get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+  run({ nodeIds, parentRef, order }) {
+    // get the new ancestry for the properties
+    let { parentDoc, ancestors } = getAncestry({ parentRef });
 
-		// Check permission to edit
+    // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
     // {libraryId: hasViewPermission}
     //let libraryPermissionMemoir = {};
     let node;
-		nodeIds.forEach(nodeId => {
+    nodeIds.forEach(nodeId => {
       // TODO: Check library view permission for each node before starting
       node = insertPropertyFromNode(nodeId, ancestors, order);
     });
@@ -70,18 +70,18 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
       collection: CreatureProperties,
       ancestorId: rootCreature._id,
     });
-		// Return the docId of the last property, the inserted root property
-		return rootId;
-	},
+    // Return the docId of the last property, the inserted root property
+    return rootId;
+  },
 });
 
-function insertPropertyFromNode(nodeId, ancestors, order){
+function insertPropertyFromNode(nodeId, ancestors, order) {
   // Fetch the library node and its decendents, provided they have not been
   // removed
   // TODO: Check permission to read the library this node is in
   let node = LibraryNodes.findOne({
     _id: nodeId,
-    removed: {$ne: true},
+    removed: { $ne: true },
   });
   if (!node) {
     if (Meteor.isClient) return;
@@ -95,7 +95,7 @@ function insertPropertyFromNode(nodeId, ancestors, order){
   let oldParent = node.parent;
   let nodes = LibraryNodes.find({
     'ancestors.id': nodeId,
-    removed: {$ne: true},
+    removed: { $ne: true },
   }).fetch();
 
   // Convert all references into actual nodes
@@ -118,11 +118,11 @@ function insertPropertyFromNode(nodeId, ancestors, order){
   // Give the docs new IDs without breaking internal references
   renewDocIds({
     docArray: nodes,
-    collectionMap: {'libraryNodes': 'creatureProperties'}
+    collectionMap: { 'libraryNodes': 'creatureProperties' }
   });
 
   // Order the root node
-  if (order === undefined){
+  if (order === undefined) {
     setDocToLastOrder({
       collection: CreatureProperties,
       doc: node,
@@ -139,7 +139,7 @@ function insertPropertyFromNode(nodeId, ancestors, order){
   return node;
 }
 
-function storeLibraryNodeReferences(nodes){
+function storeLibraryNodeReferences(nodes) {
   nodes.forEach(node => {
     if (node.libraryNodeId) return;
     node.libraryNodeId = node._id;
@@ -154,7 +154,7 @@ function dirtyNodes(nodes) {
 
 // Covert node references into actual nodes
 // TODO: check permissions for each library a reference node references
-function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
+function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0) {
   depth += 1;
   // New nodes added this function
   let newNodes = [];
@@ -165,9 +165,9 @@ function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
     if (node.type !== 'reference') return true;
 
     // We have gone too deep, keep the reference node as an error
-    if (depth >= 10){
+    if (depth >= 10) {
       if (Meteor.isClient) console.warn('Reference depth limit exceeded');
-      node.cache = {error: 'Reference depth limit exceeded'};
+      node.cache = { error: 'Reference depth limit exceeded' };
       return true;
     }
 
@@ -177,17 +177,17 @@ function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
       referencedNode.order = node.order;
       // We are definitely replacing this node, so add it to the list
       visitedRefs.add(node._id);
-    } catch (e){
-      node.cache = {error: e.reason || e.message || e.toString()};
+    } catch (e) {
+      node.cache = { error: e.reason || e.message || e.toString() };
       return true;
     }
 
     // Get all the descendants of the referenced node
     let descendents = LibraryNodes.find({
       'ancestors.id': referencedNode._id,
-      removed: {$ne: true},
+      removed: { $ne: true },
     }, {
-      sort: {order: 1},
+      sort: { order: 1 },
     }).fetch();
 
     // We are adding the referenced node and its descendants
@@ -195,20 +195,20 @@ function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
 
     // re-map all the ancestors to parent the new sub-tree into our existing
     // node tree
-		setLineageOfDocs({
-			docArray: addedNodes,
-			newAncestry: node.ancestors,
-			oldParent: referencedNode.parent,
-		});
+    setLineageOfDocs({
+      docArray: addedNodes,
+      newAncestry: node.ancestors,
+      oldParent: referencedNode.parent,
+    });
 
     // Filter all the looped references
     addedNodes = addedNodes.filter(addedNode => {
       // Add all non-reference nodes
-      if (addedNode.type !== 'reference'){
+      if (addedNode.type !== 'reference') {
         return true;
       }
       // If this exact reference has already been resolved before, filter it out
-      if (visitedRefs.has(addedNode._id)){
+      if (visitedRefs.has(addedNode._id)) {
         return false;
       } else {
         // Otherwise mark it as visited, and keep it

app/imports/api/creature/creatureProperties/methods/pullFromProperty.js

@@ -5,28 +5,28 @@ import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 
 const pullFromProperty = new ValidatedMethod({
-	name: 'creatureProperties.pull',
-	validate: null,
+  name: 'creatureProperties.pull',
+  validate: null,
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id, path, itemId}){
+  run({ _id, path, itemId }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-		CreatureProperties.update(_id, {
+    CreatureProperties.update(_id, {
       $pull: { [path.join('.')]: { _id: itemId } },
       $set: { dirty: true }
-		}, {
-			selector: {type: property.type},
-			getAutoValues: false,
-		});
-	}
+    }, {
+      selector: { type: property.type },
+      getAutoValues: false,
+    });
+  }
 });
 
 export default pullFromProperty;

app/imports/api/creature/creatureProperties/methods/pushToProperty.js

@@ -6,16 +6,16 @@ import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/ge
 import { get } from 'lodash';
 
 const pushToProperty = new ValidatedMethod({
-	name: 'creatureProperties.push',
-	validate: null,
+  name: 'creatureProperties.push',
+  validate: null,
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id, path, value}){
+  run({ _id, path, value }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
@@ -25,10 +25,10 @@ const pushToProperty = new ValidatedMethod({
     let schema = CreatureProperties.simpleSchema(property);
     let maxCount = schema.get(joinedPath, 'maxCount');
 
-    if (Number.isFinite(maxCount)){
+    if (Number.isFinite(maxCount)) {
       let array = get(property, path);
       let currentCount = array ? array.length : 0;
-      if (currentCount >= maxCount){
+      if (currentCount >= maxCount) {
         throw new Meteor.Error(
           'Array is full',
           `Cannot have more than ${maxCount} values`
@@ -37,13 +37,13 @@ const pushToProperty = new ValidatedMethod({
     }
 
     // Do work
-		CreatureProperties.update(_id, {
+    CreatureProperties.update(_id, {
       $push: { [joinedPath]: value },
       $set: { dirty: true },
-		}, {
-			selector: {type: property.type},
-		});
-	}
+    }, {
+      selector: { type: property.type },
+    });
+  }
 });
 
 export default pushToProperty;

app/imports/api/creature/creatureProperties/methods/restoreProperty.js

@@ -7,18 +7,18 @@ import { restore } from '/imports/api/parenting/softRemove.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 
 const restoreProperty = new ValidatedMethod({
-	name: 'creatureProperties.restore',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'creatureProperties.restore',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id}){
+  run({ _id }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
@@ -30,7 +30,7 @@ const restoreProperty = new ValidatedMethod({
         $set: { dirty: true }
       },
     });
-	}
+  }
 });
 
 export default restoreProperty;

app/imports/api/creature/creatureProperties/methods/selectAmmoItem.js

@@ -17,20 +17,20 @@ const selectAmmoItem = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({actionId, itemId, itemConsumedIndex}) {
+  run({ actionId, itemId, itemConsumedIndex }) {
     // Permissions
-		let action = CreatureProperties.findOne(actionId);
+    let action = CreatureProperties.findOne(actionId);
     let rootCreature = getRootCreatureAncestor(action);
-		assertEditPermission(rootCreature, this.userId);
+    assertEditPermission(rootCreature, this.userId);
 
     // Check that this index has a document to edit
     let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
-    if (!itemConsumed){
+    if (!itemConsumed) {
       throw new Meteor.Error('Resouce not found',
         'Could not set ammo, because the ammo document was not found');
     }
     let itemToLink = CreatureProperties.findOne(itemId);
-    if (!itemToLink){
+    if (!itemToLink) {
       throw new Meteor.Error('Item not found',
         'Could not set ammo: the item was not found');
     }

app/imports/api/creature/creatureProperties/methods/softRemoveProperty.js

@@ -7,24 +7,24 @@ import { softRemove } from '/imports/api/parenting/softRemove.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 
 const softRemoveProperty = new ValidatedMethod({
-	name: 'creatureProperties.softRemove',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'creatureProperties.softRemove',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id}){
+  run({ _id }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-		softRemove({_id, collection: CreatureProperties});
-	}
+    softRemove({ _id, collection: CreatureProperties });
+  }
 });
 
 export default softRemoveProperty;

app/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js

@@ -6,28 +6,28 @@ import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/ge
 
 const updateCreatureProperty = new ValidatedMethod({
   name: 'creatureProperties.update',
-  validate({_id, path}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
-		// We cannot change these fields with a simple update
-		switch (path[0]){
-			case 'type':
+  validate({ _id, path }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
+    // We cannot change these fields with a simple update
+    switch (path[0]) {
+      case 'type':
       case 'order':
       case 'parent':
       case 'ancestors':
-			case 'damage':
-				throw new Meteor.Error('Permission denied',
-				'This property can\'t be updated directly');
-		}
+      case 'damage':
+        throw new Meteor.Error('Permission denied',
+          'This property can\'t be updated directly');
+    }
   },
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, path, value}) {
+  run({ _id, path, value }) {
     // Permission
     let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1}
+      fields: { type: 1, ancestors: 1 }
     });
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
@@ -35,14 +35,14 @@ const updateCreatureProperty = new ValidatedMethod({
     let pathString = path.join('.');
     let modifier;
     // unset empty values
-    if (value === null || value === undefined){
-      modifier = { $unset: {[pathString]: 1}, $set: { dirty: true } };
+    if (value === null || value === undefined) {
+      modifier = { $unset: { [pathString]: 1 }, $set: { dirty: true } };
     } else {
-      modifier = { $set: {[pathString]: value, dirty: true } };
+      modifier = { $set: { [pathString]: value, dirty: true } };
     }
-		CreatureProperties.update(_id, modifier, {
-			selector: {type: property.type},
-		});
+    CreatureProperties.update(_id, modifier, {
+      selector: { type: property.type },
+    });
   },
 });
 

app/imports/api/creature/creatureProperties/recomputeCreaturesByProperty.js

@@ -4,9 +4,9 @@ import computeCreature from '/imports/api/engine/computeCreature.js';
  * Recomputes all ancestor creatures of this property
  */
 export default function recomputeCreaturesByProperty(property){
-	for (let ref of property.ancestors){
-		if (ref.collection === 'creatures') {
-			computeCreature.call(ref.id);
-		}
-	}
+  for (let ref of property.ancestors){
+    if (ref.collection === 'creatures') {
+      computeCreature.call(ref.id);
+    }
+  }
 }

app/imports/api/creature/creatures/Creatures.js

@@ -8,21 +8,21 @@ import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
 let Creatures = new Mongo.Collection('creatures');
 
 let CreatureSettingsSchema = new SimpleSchema({
-	//slowed down by carrying too much?
-	useVariantEncumbrance: {
-		type: Boolean,
-		optional: true,
-	},
-	//hide spellcasting tab
-	hideSpellcasting: {
-		type: Boolean,
-		optional: true,
-	},
-	// Swap around the modifier and stat
-	swapStatAndModifier: {
-		type: Boolean,
-		optional: true,
-	},
+  //slowed down by carrying too much?
+  useVariantEncumbrance: {
+    type: Boolean,
+    optional: true,
+  },
+  //hide spellcasting tab
+  hideSpellcasting: {
+    type: Boolean,
+    optional: true,
+  },
+  // Swap around the modifier and stat
+  swapStatAndModifier: {
+    type: Boolean,
+    optional: true,
+  },
   // Hide all the unused stats
   hideUnusedStats: {
     type: Boolean,
@@ -58,28 +58,28 @@ let CreatureSettingsSchema = new SimpleSchema({
 });
 
 let CreatureSchema = new SimpleSchema({
-	// Strings
-	name: {
-		type: String,
-		defaultValue: '',
-		optional: true,
+  // Strings
+  name: {
+    type: String,
+    defaultValue: '',
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	alignment: {
-		type: String,
-		optional: true,
+  },
+  alignment: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	gender: {
-		type: String,
-		optional: true,
+  },
+  gender: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	picture: {
-		type: String,
-		optional: true,
+  },
+  picture: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.url,
-	},
+  },
   avatarPicture: {
     type: String,
     optional: true,
@@ -90,37 +90,37 @@ let CreatureSchema = new SimpleSchema({
   allowedLibraries: {
     type: Array,
     optional: true,
-		maxCount: 100,
-	},
-	'allowedLibraries.$': {
-		type: String,
+    maxCount: 100,
+  },
+  'allowedLibraries.$': {
+    type: String,
     regEx: SimpleSchema.RegEx.Id,
-	},
-	allowedLibraryCollections: {
-		type: Array,
+  },
+  allowedLibraryCollections: {
+    type: Array,
     optional: true,
-		maxCount: 100,
-	},
-	'allowedLibraryCollections.$': {
-		type: String,
+    maxCount: 100,
+  },
+  'allowedLibraryCollections.$': {
+    type: String,
     regEx: SimpleSchema.RegEx.Id,
   },
 
-	// Mechanics
-	deathSave: {
-		type: deathSaveSchema,
-		defaultValue: {},
-	},
+  // Mechanics
+  deathSave: {
+    type: deathSaveSchema,
+    defaultValue: {},
+  },
   // Stats that are computed and denormalised outside of recomputation
   denormalizedStats: {
     type: Object,
     defaultValue: {},
   },
   // Sum of all XP gained by this character
-	'denormalizedStats.xp': {
-		type: SimpleSchema.Integer,
-		defaultValue: 0,
-	},
+  'denormalizedStats.xp': {
+    type: SimpleSchema.Integer,
+    defaultValue: 0,
+  },
   // Sum of all levels granted by milestone XP
   'denormalizedStats.milestoneLevels': {
     type: SimpleSchema.Integer,
@@ -133,24 +133,24 @@ let CreatureSchema = new SimpleSchema({
   },
   // Version of computation engine that was last used to compute this creature
   computeVersion: {
-		type: String,
+    type: String,
     optional: true,
-	},
-	type: {
-		type: String,
-		defaultValue: 'pc',
-		allowedValues: ['pc', 'npc', 'monster'],
-	},
+  },
+  type: {
+    type: String,
+    defaultValue: 'pc',
+    allowedValues: ['pc', 'npc', 'monster'],
+  },
   damageMultipliers: {
     type: Object,
-		blackbox: true,
-		defaultValue: {}
+    blackbox: true,
+    defaultValue: {}
+  },
+  variables: {
+    type: Object,
+    blackbox: true,
+    defaultValue: {}
   },
-	variables: {
-		type: Object,
-		blackbox: true,
-		defaultValue: {}
-	},
   computeErrors: {
     type: Array,
     optional: true,
@@ -161,7 +161,7 @@ let CreatureSchema = new SimpleSchema({
   'computeErrors.$.type': {
     type: String,
   },
-  'computeErrors.$.details' : {
+  'computeErrors.$.details': {
     type: Object,
     blackbox: true,
     optional: true,
@@ -178,11 +178,11 @@ let CreatureSchema = new SimpleSchema({
     optional: true,
   },
 
-	// Settings
-	settings: {
-		type: CreatureSettingsSchema,
-		defaultValue: {},
-	},
+  // Settings
+  settings: {
+    type: CreatureSettingsSchema,
+    defaultValue: {},
+  },
 });
 
 CreatureSchema.extend(ColorSchema);

app/imports/api/creature/creatures/methods/changeAllowedLibraries.js

@@ -1,7 +1,7 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import SimpleSchema from 'simpl-schema';
 import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
 
@@ -36,8 +36,8 @@ const changeAllowedLibraries = new ValidatedMethod({
     numRequests: 10,
     timeInterval: 5000,
   },
-  run({_id, allowedLibraries, allowedLibraryCollections}) {
-		let creature = Creatures.findOne(_id);
+  run({ _id, allowedLibraries, allowedLibraryCollections }) {
+    let creature = Creatures.findOne(_id);
     assertEditPermission(creature, this.userId);
     let $set;
     if (allowedLibraries) {
@@ -48,7 +48,7 @@ const changeAllowedLibraries = new ValidatedMethod({
       $set.allowedLibraryCollections = allowedLibraryCollections;
     }
     if (!$set) return;
-    Creatures.update(_id, {$set});
+    Creatures.update(_id, { $set });
   },
 });
 
@@ -68,7 +68,7 @@ const toggleAllUserLibraries = new ValidatedMethod({
     numRequests: 10,
     timeInterval: 5000,
   },
-  run({_id, value}) {
+  run({ _id, value }) {
     if (value) {
       Creatures.update(_id, {
         $unset: {
@@ -87,4 +87,4 @@ const toggleAllUserLibraries = new ValidatedMethod({
   },
 });
 
-export {changeAllowedLibraries, toggleAllUserLibraries};
+export { changeAllowedLibraries, toggleAllUserLibraries };

app/imports/api/creature/creatures/methods/insertCreature.js

@@ -51,7 +51,7 @@ const insertCreature = new ValidatedMethod({
       allowedLibraries,
       allowedLibraryCollections,
     });
-    
+
     // Insert experience to get character to starting level
     if (startingLevel) {
       insertExperienceForCreature({
@@ -70,7 +70,7 @@ const insertCreature = new ValidatedMethod({
     let baseId, rulesetSlot;
     defaultCharacterProperties(creatureId).forEach(prop => {
       let id = CreatureProperties.insert(prop);
-      if (prop.name === 'Ruleset'){
+      if (prop.name === 'Ruleset') {
         baseId = id;
         rulesetSlot = prop;
       }
@@ -81,7 +81,7 @@ const insertCreature = new ValidatedMethod({
       insertDefaultRuleset(creatureId, baseId, userId, rulesetSlot);
     }
 
-		return creatureId;
+    return creatureId;
   },
 });
 
@@ -95,7 +95,7 @@ function insertDefaultRuleset(creatureId, baseId, userId, slot) {
     const ruleset = fillCursor.fetch()[0]
     insertPropertyFromLibraryNode.call({
       nodeIds: [ruleset._id],
-      parentRef: {id: baseId, collection: 'creatureProperties'},
+      parentRef: { id: baseId, collection: 'creatureProperties' },
       order: 0.5,
     });
   }

app/imports/api/creature/creatures/methods/updateCreature.js

@@ -1,14 +1,14 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 
 const updateCreature = new ValidatedMethod({
   name: 'creatures.update',
-  validate({_id, path}){
-		if (!_id) return false;
-		// Allowed fields
-		let allowedFields = [
+  validate({ _id, path }) {
+    if (!_id) return false;
+    // Allowed fields
+    let allowedFields = [
       'name',
       'alignment',
       'gender',
@@ -17,26 +17,26 @@ const updateCreature = new ValidatedMethod({
       'color',
       'settings',
     ];
-		if (!allowedFields.includes(path[0])){
-			throw new Meteor.Error('Creatures.methods.update.denied',
-      'This field can\'t be updated using this method');
-		}
+    if (!allowedFields.includes(path[0])) {
+      throw new Meteor.Error('Creatures.methods.update.denied',
+        'This field can\'t be updated using this method');
+    }
   },
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, path, value}) {
-		let creature = Creatures.findOne(_id);
+  run({ _id, path, value }) {
+    let creature = Creatures.findOne(_id);
     assertEditPermission(creature, this.userId);
-    if (value === undefined || value === null){
+    if (value === undefined || value === null) {
       Creatures.update(_id, {
-        $unset: {[path.join('.')]: 1},
+        $unset: { [path.join('.')]: 1 },
       });
     } else {
       Creatures.update(_id, {
-        $set: {[path.join('.')]: value},
+        $set: { [path.join('.')]: value },
       });
     }
   },

app/imports/api/creature/experience/Experiences.js

@@ -8,17 +8,17 @@ import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
 let Experiences = new Mongo.Collection('experiences');
 
 let ExperienceSchema = new SimpleSchema({
-	name: {
-		type: String,
-		optional: true,
+  name: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	// The amount of XP this experience gives
-	xp: {
-		type: SimpleSchema.Integer,
-		optional: true,
+  },
+  // The amount of XP this experience gives
+  xp: {
+    type: SimpleSchema.Integer,
+    optional: true,
     min: 0,
-	},
+  },
   // Setting levels instead of value grants whole levels
   levels: {
     type: SimpleSchema.Integer,
@@ -26,17 +26,17 @@ let ExperienceSchema = new SimpleSchema({
     min: 0,
     index: 1,
   },
-	// The real-world date that it occured, usually sorted by date
-	date: {
-		type: Date,
-		autoValue: function() {
-			// If the date isn't set, set it to now
-			if (!this.isSet) {
-				return new Date();
-			}
-		},
+  // The real-world date that it occured, usually sorted by date
+  date: {
+    type: Date,
+    autoValue: function () {
+      // If the date isn't set, set it to now
+      if (!this.isSet) {
+        return new Date();
+      }
+    },
     index: 1,
-	},
+  },
   creatureId: {
     type: String,
     regEx: SimpleSchema.RegEx.Id,
@@ -46,8 +46,8 @@ let ExperienceSchema = new SimpleSchema({
 
 Experiences.attachSchema(ExperienceSchema);
 
-const insertExperienceForCreature = function({experience, creatureId, userId}){
-  if (experience.xp){
+const insertExperienceForCreature = function ({ experience, creatureId }) {
+  if (experience.xp) {
     Creatures.update(creatureId, {
       $inc: { 'denormalizedStats.xp': experience.xp },
       $set: { dirty: true },
@@ -84,16 +84,16 @@ const insertExperience = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({experience, creatureIds}) {
+  run({ experience, creatureIds }) {
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('Experiences.methods.insert.denied',
-      'You need to be logged in to insert an experience');
+        'You need to be logged in to insert an experience');
     }
     let insertedIds = [];
     creatureIds.forEach(creatureId => {
       assertEditPermission(creatureId, userId);
-      let id = insertExperienceForCreature({experience, creatureId, userId});
+      let id = insertExperienceForCreature({ experience, creatureId, userId });
       insertedIds.push(id);
     });
     return insertedIds;
@@ -113,17 +113,17 @@ const removeExperience = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({experienceId}) {
+  run({ experienceId }) {
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('Experiences.methods.remove.denied',
-      'You need to be logged in to remove an experience');
+        'You need to be logged in to remove an experience');
     }
     let experience = Experiences.findOne(experienceId);
     if (!experience) return;
     let creatureId = experience.creatureId
     assertEditPermission(creatureId, userId);
-    if (experience.xp){
+    if (experience.xp) {
       Creatures.update(creatureId, {
         $inc: { 'denormalizedStats.xp': -experience.xp },
         $set: { dirty: true },
@@ -154,11 +154,11 @@ const recomputeExperiences = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureId}) {
+  run({ creatureId }) {
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('Experiences.methods.recompute.denied',
-      'You need to be logged in to recompute a creature\'s experiences');
+        'You need to be logged in to recompute a creature\'s experiences');
     }
     assertEditPermission(creatureId, userId);
 
@@ -167,16 +167,18 @@ const recomputeExperiences = new ValidatedMethod({
     Experiences.find({
       creatureId
     }, {
-      fields: {xp: 1, levels: 1}
+      fields: { xp: 1, levels: 1 }
     }).forEach(experience => {
       xp += experience.xp || 0;
       milestoneLevels += experience.levels || 0;
     });
-    Creatures.update(creatureId, {$set: {
-      'denormalizedStats.xp': xp,
-      'denormalizedStats.milestoneLevels': milestoneLevels,
-      dirty: true,
-    }});
+    Creatures.update(creatureId, {
+      $set: {
+        'denormalizedStats.xp': xp,
+        'denormalizedStats.milestoneLevels': milestoneLevels,
+        dirty: true,
+      }
+    });
   },
 });
 

app/imports/api/creature/journal/JournalEntry.js

@@ -5,18 +5,18 @@ let ExperienceSchema = new SimpleSchema({
 	title: {
 		type: String,
 		optional: true,
-    max: STORAGE_LIMITS.name,
+		max: STORAGE_LIMITS.name,
 	},
 	// Potentially long description of the event
 	description: {
 		type: String,
 		optional: true,
-    max: STORAGE_LIMITS.description,
+		max: STORAGE_LIMITS.description,
 	},
 	// The real-world date that it occured
 	date: {
 		type: Date,
-		autoValue: function() {
+		autoValue: function () {
 			// If the date isn't set, set it to now
 			if (!this.isSet) {
 				return new Date();
@@ -27,24 +27,24 @@ let ExperienceSchema = new SimpleSchema({
 	worldDate: {
 		type: String,
 		optional: true,
-    max: STORAGE_LIMITS.name,
+		max: STORAGE_LIMITS.name,
 	},
-  // Tags to better find this entry later
-  tags: {
-    type: Array,
-    defaultValue: [],
-    maxCount: STORAGE_LIMITS.tagCount,
-  },
-  'tags.$': {
-    type: String,
-    max: STORAGE_LIMITS.tagLength,
-  },
-  // ID of the journal this entry belongs to
-  journalId: {
-    type: String,
-    regEx: SimpleSchema.RegEx.Id,
-    index: 1,
-  }
+	// Tags to better find this entry later
+	tags: {
+		type: Array,
+		defaultValue: [],
+		maxCount: STORAGE_LIMITS.tagCount,
+	},
+	'tags.$': {
+		type: String,
+		max: STORAGE_LIMITS.tagLength,
+	},
+	// ID of the journal this entry belongs to
+	journalId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	}
 });
 
 export { ExperienceSchema };

app/imports/api/creature/log/CreatureLogs.js

@@ -4,13 +4,13 @@ import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables
 import LogContentSchema from '/imports/api/creature/log/LogContentSchema.js';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import {assertEditPermission} from '/imports/api/creature/creatures/creaturePermissions.js';
-import {parse, prettifyParseError} from '/imports/parser/parser.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
+import { parse, prettifyParseError } from '/imports/parser/parser.js';
 import resolve, { toString } from '/imports/parser/resolve.js';
 const PER_CREATURE_LOG_LIMIT = 100;
 import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
 
-if (Meteor.isServer){
+if (Meteor.isServer) {
   var sendWebhookAsCreature = require('/imports/server/discord/sendWebhook.js').sendWebhookAsCreature;
 }
 
@@ -25,17 +25,17 @@ let CreatureLogSchema = new SimpleSchema({
   'content.$': {
     type: LogContentSchema,
   },
-	// The real-world date that it occured, usually sorted by date
-	date: {
-		type: Date,
-		autoValue: function() {
-			// If the date isn't set, set it to now
-			if (!this.isSet) {
-				return new Date();
-			}
-		},
+  // The real-world date that it occured, usually sorted by date
+  date: {
+    type: Date,
+    autoValue: function () {
+      // If the date isn't set, set it to now
+      if (!this.isSet) {
+        return new Date();
+      }
+    },
     index: 1,
-	},
+  },
   creatureId: {
     type: String,
     regEx: SimpleSchema.RegEx.Id,
@@ -50,23 +50,23 @@ let CreatureLogSchema = new SimpleSchema({
 
 CreatureLogs.attachSchema(CreatureLogSchema);
 
-function removeOldLogs(creatureId){
+function removeOldLogs(creatureId) {
   // Find the first log that is over the limit
   let firstExpiredLog = CreatureLogs.find({
     creatureId
   }, {
-    sort: {date: -1},
+    sort: { date: -1 },
     skip: PER_CREATURE_LOG_LIMIT,
   });
   if (!firstExpiredLog) return;
   // Remove all logs older than the one over the limit
   CreatureLogs.remove({
     creatureId,
-    date: {$lte: firstExpiredLog.date},
+    date: { $lte: firstExpiredLog.date },
   });
 }
 
-function logToMessageData(log){
+function logToMessageData(log) {
   let embed = {
     fields: [],
   };
@@ -78,8 +78,8 @@ function logToMessageData(log){
   return { embeds: [embed] };
 }
 
-function logWebhook({log, creature}){
-  if (Meteor.isServer){
+function logWebhook({ log, creature }) {
+  if (Meteor.isServer) {
     sendWebhookAsCreature({
       creature,
       data: logToMessageData(log),
@@ -94,47 +94,49 @@ const insertCreatureLog = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-	validate: new SimpleSchema({
-		log: CreatureLogSchema.omit('date'),
-	}).validator(),
-  run({log}){
+  validate: new SimpleSchema({
+    log: CreatureLogSchema.omit('date'),
+  }).validator(),
+  run({ log }) {
     const creatureId = log.creatureId;
-    const creature = Creatures.findOne(creatureId, {fields: {
-      readers: 1,
-      writers: 1,
-      owner: 1,
-      'settings.discordWebhook': 1,
-      name: 1,
-      avatarPicture: 1,
-    }});
+    const creature = Creatures.findOne(creatureId, {
+      fields: {
+        readers: 1,
+        writers: 1,
+        owner: 1,
+        'settings.discordWebhook': 1,
+        name: 1,
+        avatarPicture: 1,
+      }
+    });
     assertEditPermission(creature, this.userId);
     // Build the new log
-    let id = insertCreatureLogWork({log, creature, method: this})
+    let id = insertCreatureLogWork({ log, creature, method: this })
     return id;
   },
 });
 
-export function insertCreatureLogWork({log, creature, method}){
+export function insertCreatureLogWork({ log, creature, method }) {
   // Build the new log
-  if (typeof log === 'string'){
-    log = {content: [{value: log}]};
+  if (typeof log === 'string') {
+    log = { content: [{ value: log }] };
   }
   if (!log.content?.length) return;
   log.date = new Date();
   // Insert it
   let id = CreatureLogs.insert(log);
-  if (Meteor.isServer){
+  if (Meteor.isServer) {
     method?.unblock();
     removeOldLogs(creature._id);
-    logWebhook({log, creature});
+    logWebhook({ log, creature });
   }
   return id;
 }
 
 
-function equalIgnoringWhitespace(a, b){
+function equalIgnoringWhitespace(a, b) {
   if (typeof a !== 'string' || typeof b !== 'string') return a === b;
-  return a.replace(/\s/g,'') === b.replace(/\s/g, '');
+  return a.replace(/\s/g, '') === b.replace(/\s/g, '');
 }
 
 const logRoll = new ValidatedMethod({
@@ -144,33 +146,35 @@ const logRoll = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-	validate: new SimpleSchema({
-		roll: {
-			type: String,
-		},
-		creatureId: {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-	}).validator(),
-  run({roll, creatureId}){
-    const creature = Creatures.findOne(creatureId, {fields: {
-      readers: 1,
-      writers: 1,
-      owner: 1,
-      'settings.discordWebhook': 1,
-      name: 1,
-      avatarPicture: 1,
-    }});
+  validate: new SimpleSchema({
+    roll: {
+      type: String,
+    },
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  run({ roll, creatureId }) {
+    const creature = Creatures.findOne(creatureId, {
+      fields: {
+        readers: 1,
+        writers: 1,
+        owner: 1,
+        'settings.discordWebhook': 1,
+        name: 1,
+        avatarPicture: 1,
+      }
+    });
     assertEditPermission(creature, this.userId);
     const variables = CreatureVariables.findOne({ _creatureId: creatureId });
     let logContent = []
     let parsedResult = undefined;
     try {
       parsedResult = parse(roll);
-    } catch (e){
+    } catch (e) {
       let error = prettifyParseError(e);
-      logContent.push({name: 'Parse Error', value: error});
+      logContent.push({ name: 'Parse Error', value: error });
     }
     if (parsedResult) try {
       let {
@@ -184,19 +188,19 @@ const logRoll = new ValidatedMethod({
       logContent.push({
         value: compiledString
       });
-      let {result: rolled} = resolve('roll', compiled, variables, context);
+      let { result: rolled } = resolve('roll', compiled, variables, context);
       let rolledString = toString(rolled);
       if (rolledString !== compiledString) logContent.push({
         value: rolledString
       });
-      let {result} = resolve('reduce', rolled, variables, context);
+      let { result } = resolve('reduce', rolled, variables, context);
       let resultString = toString(result);
       if (resultString !== rolledString) logContent.push({
         value: resultString
       });
-    } catch (e){
+    } catch (e) {
       console.error(e);
-      logContent = [{name: 'Calculation error'}];
+      logContent = [{ name: 'Calculation error' }];
     }
     const log = {
       content: logContent,
@@ -204,11 +208,11 @@ const logRoll = new ValidatedMethod({
       date: new Date(),
     };
 
-    let id = insertCreatureLogWork({log, creature, method: this});
+    let id = insertCreatureLogWork({ log, creature, method: this });
 
     return id;
   },
 });
 
 export default CreatureLogs;
-export { CreatureLogSchema, insertCreatureLog, logRoll, PER_CREATURE_LOG_LIMIT};
+export { CreatureLogSchema, insertCreatureLog, logRoll, PER_CREATURE_LOG_LIMIT };