Applied style rules to genocide all \t characters

app/imports/api/engine/actions/applyPropertyByType/applyBuff.js

@@ -1,8 +1,8 @@
 import {
-	setLineageOfDocs,
-	renewDocIds
+  setLineageOfDocs,
+  renewDocIds
 } from '/imports/api/parenting/parenting.js';
-import {setDocToLastOrder} from '/imports/api/parenting/order.js';
+import { setDocToLastOrder } from '/imports/api/parenting/order.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import computedSchemas from '/imports/api/properties/computedPropertySchemasIndex.js';
 import applyFnToKey from '/imports/api/engine/computation/utility/applyFnToKey.js';
@@ -15,14 +15,14 @@ import cyrb53 from '/imports/api/engine/computation/utility/cyrb53.js';
 import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
 import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
 
-export default function applyBuff(node, actionContext){
+export default function applyBuff(node, actionContext) {
   applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
   let buffTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
 
   // Then copy the decendants of the buff to the targets
   let propList = [prop];
-  function addChildrenToPropList(children, { skipCrystalize } = {}){
+  function addChildrenToPropList(children, { skipCrystalize } = {}) {
     children.forEach(child => {
       if (skipCrystalize) child.node._skipCrystalize = true;
       propList.push(child.node);
@@ -34,7 +34,7 @@ export default function applyBuff(node, actionContext){
   }
   addChildrenToPropList(node.children);
   if (!prop.skipCrystalization) {
-    crystalizeVariables({propList, actionContext});
+    crystalizeVariables({ propList, actionContext });
   }
 
   let oldParent = {
@@ -46,8 +46,8 @@ export default function applyBuff(node, actionContext){
     copyNodeListToTarget(propList, target, oldParent);
 
     //Log the buff
-    if ((prop.name || prop.description?.value) && !prop.silent){
-      if (target._id === actionContext.creature._id){
+    if ((prop.name || prop.description?.value) && !prop.silent) {
+      if (target._id === actionContext.creature._id) {
         // Targeting self
         actionContext.addLog({
           name: prop.name,
@@ -72,8 +72,8 @@ export default function applyBuff(node, actionContext){
   // Don't apply the children of the buff, they get copied to the target instead
 }
 
-function copyNodeListToTarget(propList, target, oldParent){
-  let ancestry = [{collection: 'creatures', id: target._id}];
+function copyNodeListToTarget(propList, target, oldParent) {
+  let ancestry = [{ collection: 'creatures', id: target._id }];
   setLineageOfDocs({
     docArray: propList,
     newAncestry: ancestry,
@@ -93,14 +93,14 @@ function copyNodeListToTarget(propList, target, oldParent){
  * Replaces all variables with their resolved values
  * except variables of the form `$target.thing.total` become `thing.total`
  */
-function crystalizeVariables({propList, actionContext}){
+function crystalizeVariables({ propList, actionContext }) {
   propList.forEach(prop => {
     if (prop._skipCrystalize) {
       delete prop._skipCrystalize;
       return;
     }
     // Iterate through all the calculations and crystalize them
-    computedSchemas[prop.type].computedFields().forEach( calcKey => {
+    computedSchemas[prop.type].computedFields().forEach(calcKey => {
       applyFnToKey(prop, calcKey, (prop, key) => {
         const calcObj = get(prop, key);
         if (!calcObj?.parseNode) return;
@@ -110,12 +110,12 @@ function crystalizeVariables({propList, actionContext}){
             node.parseType !== 'accessor' && node.parseType !== 'symbol'
           ) return node;
           // Handle variables
-          if (node.name === '$target'){
+          if (node.name === '$target') {
             // strip $target
-            if (node.parseType === 'accessor'){
+            if (node.parseType === 'accessor') {
               node.name = node.path.shift();
-              if (!node.path.length){
-                return symbol.create({name: node.name})
+              if (!node.path.length) {
+                return symbol.create({ name: node.name })
               }
             } else {
               // Can't strip symbols
@@ -127,7 +127,7 @@ function crystalizeVariables({propList, actionContext}){
             return node;
           } else {
             // Resolve all other variables
-            const {result, context} = resolve('reduce', node, actionContext.scope);
+            const { result, context } = resolve('reduce', node, actionContext.scope);
             logErrors(context.errors, actionContext);
             return result;
           }
@@ -137,14 +137,14 @@ function crystalizeVariables({propList, actionContext}){
       });
     });
     // For each key in the schema
-    computedSchemas[prop.type].inlineCalculationFields().forEach( calcKey => {
+    computedSchemas[prop.type].inlineCalculationFields().forEach(calcKey => {
       // That ends in .inlineCalculations
       applyFnToKey(prop, calcKey, (prop, key) => {
         const inlineCalcObj = get(prop, key);
         if (!inlineCalcObj) return;
 
         // If there is no text, skip
-        if (!inlineCalcObj.text){
+        if (!inlineCalcObj.text) {
           return;
         }
 

app/imports/api/engine/actions/doAction.js

@@ -41,8 +41,8 @@ const doAction = new ValidatedMethod({
     let action = CreatureProperties.findOne(actionId);
     const creatureId = action.ancestors[0].id;
     const actionContext = new ActionContext(creatureId, targetIds, this);
-    
-		// Check permissions
+
+    // Check permissions
     assertEditPermission(actionContext.creature, this.userId);
     actionContext.targets.forEach(target => {
       assertEditPermission(target, this.userId);
@@ -56,13 +56,13 @@ const doAction = new ValidatedMethod({
     properties.sort((a, b) => a.order - b.order);
 
     // Do the action
-    doActionWork({properties, ancestors, actionContext, methodScope: scope});
+    doActionWork({ properties, ancestors, actionContext, methodScope: scope });
 
     // Recompute all involved creatures
     Creatures.update({
       _id: { $in: [creatureId, ...targetIds] }
     }, {
-      $set: {dirty: true},
+      $set: { dirty: true },
     });
   },
 });
@@ -71,11 +71,11 @@ export default doAction;
 
 export function doActionWork({
   properties, ancestors, actionContext, methodScope = {},
-}){
+}) {
   // get the docs
   const ancestorScope = getAncestorScope(ancestors);
   const propertyForest = nodeArrayToTree(properties);
-  if (propertyForest.length !== 1){
+  if (propertyForest.length !== 1) {
     throw new Meteor.Error(`The action has ${propertyForest.length} top level properties, expected 1`);
   }
 
@@ -91,7 +91,7 @@ export function doActionWork({
 }
 
 // Assumes ancestors are in tree order already
-function getAncestorScope(ancestors){
+function getAncestorScope(ancestors) {
   let scope = {};
   ancestors.forEach(prop => {
     scope[`#${prop.type}`] = prop;

app/imports/api/engine/actions/doCastSpell.js

@@ -42,12 +42,12 @@ const doAction = new ValidatedMethod({
     timeInterval: 5000,
   },
   run({ spellId, slotId, targetIds = [], scope = {} }) {
-		// Get action context
+    // Get action context
     let spell = CreatureProperties.findOne(spellId);
     const creatureId = spell.ancestors[0].id;
     const actionContext = new ActionContext(creatureId, targetIds, this);
 
-		// Check permissions
+    // Check permissions
     assertEditPermission(actionContext.creature, this.userId);
     actionContext.targets.forEach(target => {
       assertEditPermission(target, this.userId);
@@ -64,25 +64,25 @@ const doAction = new ValidatedMethod({
     let slotLevel = spell.level || 0;
     let slot;
 
-    if (slotId && !spell.castWithoutSpellSlots){
+    if (slotId && !spell.castWithoutSpellSlots) {
       slot = CreatureProperties.findOne(slotId);
-      if (!slot){
+      if (!slot) {
         throw new Meteor.Error('No slot',
           'Slot not found to cast spell');
       }
-      if (!slot.value){
+      if (!slot.value) {
         throw new Meteor.Error('No slot',
           'Slot depleted');
       }
-      if (slot.attributeType !== 'spellSlot'){
+      if (slot.attributeType !== 'spellSlot') {
         throw new Meteor.Error('Not a slot',
           'The given property is not a valid spell slot');
       }
-      if (!slot.spellSlotLevel?.value){
+      if (!slot.spellSlotLevel?.value) {
         throw new Meteor.Error('No slot level',
           'Slot does not have a spell slot level');
       }
-      if (slot.spellSlotLevel.value < spell.level){
+      if (slot.spellSlotLevel.value < spell.level) {
         throw new Meteor.Error('Slot too small',
           'Slot is not large enough to cast spell');
       }
@@ -96,7 +96,7 @@ const doAction = new ValidatedMethod({
     }
 
     // Post the slot level spent to the log
-    if (slot?.spellSlotLevel?.value){
+    if (slot?.spellSlotLevel?.value) {
       actionContext.addLog({
         name: `Casting using a level ${slotLevel} spell slot`
       });

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateEffect.js

@@ -1,4 +1,4 @@
-import { pick } from "lodash";
+import { pick } from 'lodash';
 
 export default function aggregateEffect({node, linkedNode, link}){
   if (link.data !== 'effect') return;