Applied style rules to genocide all \t characters

2022-10-09 16:01:36 +02:00
parent de598c70a7
commit 2fa913b09a
208 changed files with 6027 additions and 5801 deletions
--- a/app/imports/api/library/Libraries.js
+++ b/app/imports/api/library/Libraries.js
@@ -21,14 +21,14 @@ let Libraries = new Mongo.Collection('libraries');

 let LibrarySchema = new SimpleSchema({
 	name: {
-    type: String,
-    max: STORAGE_LIMITS.name,
-  },
-  description: {
-    type: String,
-    optional: true,
-    max: STORAGE_LIMITS.summary,
-  },
+		type: String,
+		max: STORAGE_LIMITS.name,
+	},
+	description: {
+		type: String,
+		optional: true,
+		max: STORAGE_LIMITS.summary,
+	},
 });

 LibrarySchema.extend(SharingSchema);
@@ -38,24 +38,24 @@ Libraries.attachSchema(LibrarySchema);
 export default Libraries;

 const insertLibrary = new ValidatedMethod({
-  name: 'libraries.insert',
+	name: 'libraries.insert',
 	mixins: [
 		simpleSchemaMixin,
-  ],
-  schema: LibrarySchema.omit('owner'),
-  run(library) {
-    if (!this.userId) {
-      throw new Meteor.Error('Libraries.methods.insert.denied',
-      'You need to be logged in to insert a library');
-    }
-    let tier = getUserTier(this.userId);
-    if (!tier.paidBenefits){
-      throw new Meteor.Error('Libraries.methods.insert.denied',
-      `The ${tier.name} tier does not allow you to insert a library`);
-    }
-    library.owner = this.userId;
+	],
+	schema: LibrarySchema.omit('owner'),
+	run(library) {
+		if (!this.userId) {
+			throw new Meteor.Error('Libraries.methods.insert.denied',
+				'You need to be logged in to insert a library');
+		}
+		let tier = getUserTier(this.userId);
+		if (!tier.paidBenefits) {
+			throw new Meteor.Error('Libraries.methods.insert.denied',
+				`The ${tier.name} tier does not allow you to insert a library`);
+		}
+		library.owner = this.userId;
 		return Libraries.insert(library);
-  },
+	},
 });

 const updateLibraryName = new ValidatedMethod({
@@ -69,15 +69,15 @@ const updateLibraryName = new ValidatedMethod({
 			type: String,
 		},
 	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id, name}){
+	mixins: [RateLimiterMixin],
+	rateLimit: {
+		numRequests: 5,
+		timeInterval: 5000,
+	},
+	run({ _id, name }) {
 		let library = Libraries.findOne(_id);
 		assertEditPermission(library, this.userId);
-		Libraries.update(_id, {$set: {name}});
+		Libraries.update(_id, { $set: { name } });
 	},
 });

@@ -92,15 +92,15 @@ const updateLibraryDescription = new ValidatedMethod({
 			type: String,
 		},
 	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id, description}){
+	mixins: [RateLimiterMixin],
+	rateLimit: {
+		numRequests: 5,
+		timeInterval: 5000,
+	},
+	run({ _id, description }) {
 		let library = Libraries.findOne(_id);
 		assertEditPermission(library, this.userId);
-		Libraries.update(_id, {$set: {description}});
+		Libraries.update(_id, { $set: { description } });
 	},
 });

@@ -112,22 +112,22 @@ const removeLibrary = new ValidatedMethod({
 			regEx: SimpleSchema.RegEx.id
 		},
 	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id}){
+	mixins: [RateLimiterMixin],
+	rateLimit: {
+		numRequests: 5,
+		timeInterval: 5000,
+	},
+	run({ _id }) {
 		let library = Libraries.findOne(_id);
 		assertOwnership(library, this.userId);
-    this.unblock();
-    removeLibaryWork(_id)
+		this.unblock();
+		removeLibaryWork(_id)
 	}
 });

-export function removeLibaryWork(libraryId){
-  Libraries.remove(libraryId);
-  LibraryNodes.remove({'ancestors.id': libraryId});
+export function removeLibaryWork(libraryId) {
+	Libraries.remove(libraryId);
+	LibraryNodes.remove({ 'ancestors.id': libraryId });
 }

 export { LibrarySchema, insertLibrary, updateLibraryName, updateLibraryDescription, removeLibrary };
--- a/app/imports/api/library/LibraryNodes.js
+++ b/app/imports/api/library/LibraryNodes.js
@@ -23,28 +23,28 @@ let LibraryNodeSchema = new SimpleSchema({
    type: String,
    regEx: SimpleSchema.RegEx.Id,
  },
-	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,
-	},
+  },
  libraryTags: {
-		type: Array,
-		defaultValue: [],
+    type: Array,
+    defaultValue: [],
    maxCount: STORAGE_LIMITS.tagCount,
-	},
-	'libraryTags.$': {
-		type: String,
+  },
+  'libraryTags.$': {
+    type: String,
    max: STORAGE_LIMITS.tagLength,
-	},
+  },
  icon: {
    type: storedIconsSchema,
    optional: true,
@@ -56,37 +56,37 @@ let LibraryNodeSchema = new SimpleSchema({
 if (Meteor.isServer) {
  LibraryNodes._ensureIndex({
    'name': 'text',
-		'tags': 'text',
+    'tags': 'text',
  });
 }

-for (let key in propertySchemasIndex){
-	let schema = new SimpleSchema({});
-	schema.extend(LibraryNodeSchema);
+for (let key in propertySchemasIndex) {
+  let schema = new SimpleSchema({});
+  schema.extend(LibraryNodeSchema);
  schema.extend(ColorSchema);
-	schema.extend(propertySchemasIndex[key]);
-	schema.extend(ChildSchema);
-	schema.extend(SoftRemovableSchema);
-	LibraryNodes.attachSchema(schema, {
-		selector: {type: key}
-	});
+  schema.extend(propertySchemasIndex[key]);
+  schema.extend(ChildSchema);
+  schema.extend(SoftRemovableSchema);
+  LibraryNodes.attachSchema(schema, {
+    selector: { type: key }
+  });
 }

-function getLibrary(node){
+function getLibrary(node) {
  if (!node) throw new Meteor.Error('No node provided');
  let library = Libraries.findOne(node.ancestors[0].id);
  if (!library) throw new Meteor.Error('Library does not exist');
  return library;
 }

-function assertNodeEditPermission(node, userId){
+function assertNodeEditPermission(node, userId) {
  let lib = getLibrary(node);
  return assertEditPermission(lib, userId);
 }

 const insertNode = new ValidatedMethod({
  name: 'libraryNodes.insert',
-	validate: null,
+  validate: null,
  mixins: [RateLimiterMixin],
  rateLimit: {
    numRequests: 5,
@@ -95,8 +95,8 @@ const insertNode = new ValidatedMethod({
  run(libraryNode) {
    delete libraryNode._id;
    assertNodeEditPermission(libraryNode, this.userId);
-		let nodeId = LibraryNodes.insert(libraryNode);
-    if (libraryNode.type == 'reference'){
+    let nodeId = LibraryNodes.insert(libraryNode);
+    if (libraryNode.type == 'reference') {
      libraryNode._id = nodeId;
      updateReferenceNodeWork(libraryNode, this.userId);
    }
@@ -106,37 +106,37 @@ const insertNode = new ValidatedMethod({

 const updateLibraryNode = new ValidatedMethod({
  name: 'libraryNodes.update',
-  validate({_id, path}){
-		if (!_id) return false;
-		// We cannot change these fields with a simple update
-		switch (path[0]){
-			case 'type':
+  validate({ _id, path }) {
+    if (!_id) return false;
+    // We cannot change these fields with a simple update
+    switch (path[0]) {
+      case 'type':
      case 'order':
      case 'parent':
      case 'ancestors':
-				return false;
-		}
+        return false;
+    }
  },
  mixins: [RateLimiterMixin],
  rateLimit: {
    numRequests: 5,
    timeInterval: 5000,
  },
-  run({_id, path, value}) {
+  run({ _id, path, value }) {
    let node = LibraryNodes.findOne(_id);
    assertNodeEditPermission(node, this.userId);
    let pathString = path.join('.');
    let modifier;
    // unset empty values
-    if (value === null || value === undefined){
-      modifier = {$unset: {[pathString]: 1}};
+    if (value === null || value === undefined) {
+      modifier = { $unset: { [pathString]: 1 } };
    } else {
-      modifier = {$set: {[pathString]: value}};
+      modifier = { $set: { [pathString]: value } };
    }
-		let numUpdated = LibraryNodes.update(_id, modifier, {
-			selector: {type: node.type},
-		});
-    if (node.type == 'reference'){
+    let numUpdated = LibraryNodes.update(_id, modifier, {
+      selector: { type: node.type },
+    });
+    if (node.type == 'reference') {
      node = LibraryNodes.findOne(_id);
      updateReferenceNodeWork(node, this.userId);
    }
@@ -145,87 +145,87 @@ const updateLibraryNode = new ValidatedMethod({
 });

 const pushToLibraryNode = new ValidatedMethod({
-	name: 'libraryNodes.push',
-	validate: null,
+  name: 'libraryNodes.push',
+  validate: null,
  mixins: [RateLimiterMixin],
  rateLimit: {
    numRequests: 5,
    timeInterval: 5000,
  },
-	run({_id, path, value}){
-		let node = LibraryNodes.findOne(_id);
+  run({ _id, path, value }) {
+    let node = LibraryNodes.findOne(_id);
    assertNodeEditPermission(node, this.userId);
-		return LibraryNodes.update(_id, {
-			$push: {[path.join('.')]: value},
-		}, {
-			selector: {type: node.type},
-		});
-	}
+    return LibraryNodes.update(_id, {
+      $push: { [path.join('.')]: value },
+    }, {
+      selector: { type: node.type },
+    });
+  }
 });

 const pullFromLibraryNode = new ValidatedMethod({
-	name: 'libraryNodes.pull',
-	validate: null,
+  name: 'libraryNodes.pull',
+  validate: null,
  mixins: [RateLimiterMixin],
  rateLimit: {
    numRequests: 5,
    timeInterval: 5000,
  },
-	run({_id, path, itemId}){
-		let node = LibraryNodes.findOne(_id);
+  run({ _id, path, itemId }) {
+    let node = LibraryNodes.findOne(_id);
    assertNodeEditPermission(node, this.userId);
-		return LibraryNodes.update(_id, {
-			$pull: {[path.join('.')]: {_id: itemId}},
-		}, {
-			selector: {type: node.type},
-			getAutoValues: false,
-		});
-	}
+    return LibraryNodes.update(_id, {
+      $pull: { [path.join('.')]: { _id: itemId } },
+    }, {
+      selector: { type: node.type },
+      getAutoValues: false,
+    });
+  }
 });

 const softRemoveLibraryNode = new ValidatedMethod({
-	name: 'libraryNodes.softRemove',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'libraryNodes.softRemove',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
  mixins: [RateLimiterMixin],
  rateLimit: {
    numRequests: 5,
    timeInterval: 5000,
  },
-	run({_id}){
-		let node = LibraryNodes.findOne(_id);
+  run({ _id }) {
+    let node = LibraryNodes.findOne(_id);
    assertNodeEditPermission(node, this.userId);
-		softRemove({_id, collection: LibraryNodes});
-	}
+    softRemove({ _id, collection: LibraryNodes });
+  }
 });

 const restoreLibraryNode = new ValidatedMethod({
-	name: 'libraryNodes.restore',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'libraryNodes.restore',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
  mixins: [RateLimiterMixin],
  rateLimit: {
    numRequests: 5,
    timeInterval: 5000,
  },
-	run({_id}){
+  run({ _id }) {
    // Permissions
    let node = LibraryNodes.findOne(_id);
    assertNodeEditPermission(node, this.userId);
    // Do work
-    restore({_id, collection: LibraryNodes});
-	}
+    restore({ _id, collection: LibraryNodes });
+  }
 });

 export default LibraryNodes;
 export {
-	LibraryNodeSchema,
-	insertNode,
-	updateLibraryNode,
-	pullFromLibraryNode,
-	pushToLibraryNode,
-	softRemoveLibraryNode,
+  LibraryNodeSchema,
+  insertNode,
+  updateLibraryNode,
+  pullFromLibraryNode,
+  pushToLibraryNode,
+  softRemoveLibraryNode,
  restoreLibraryNode,
 };
--- a/app/imports/api/library/methods/duplicateLibraryNode.js
+++ b/app/imports/api/library/methods/duplicateLibraryNode.js
@@ -4,13 +4,13 @@ import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import LibraryNodes from '/imports/api/library/LibraryNodes.js';
 import { assertDocEditPermission } from '/imports/api/sharing/sharingPermissions.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
@@ -20,7 +20,7 @@ const DUPLICATE_CHILDREN_LIMIT = 50;

 const duplicateLibraryNode = new ValidatedMethod({
  name: 'libraryNodes.duplicate',
-	validate: new SimpleSchema({
+  validate: new SimpleSchema({
    _id: {
      type: String,
      regEx: SimpleSchema.RegEx.Id,
@@ -31,7 +31,7 @@ const duplicateLibraryNode = new ValidatedMethod({
    numRequests: 5,
    timeInterval: 5000,
  },
-  run({_id}) {
+  run({ _id }) {
    let libraryNode = LibraryNodes.findOne(_id);
    assertDocEditPermission(libraryNode, this.userId);

@@ -40,16 +40,16 @@ const duplicateLibraryNode = new ValidatedMethod({
    libraryNode._id = libraryNodeId;

    let nodes = LibraryNodes.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();

-    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`,
        });
@@ -58,21 +58,21 @@ const duplicateLibraryNode = new ValidatedMethod({

    // re-map all the ancestors
    setLineageOfDocs({
-			docArray: nodes,
-			newAncestry : [
+      docArray: nodes,
+      newAncestry: [
        ...libraryNode.ancestors,
-        {id: libraryNodeId, collection: 'libraryNodes'}
+        { id: libraryNodeId, collection: 'libraryNodes' }
      ],
-			oldParent : {id: _id, collection: 'libraryNodes'},
-		});
+      oldParent: { id: _id, collection: 'libraryNodes' },
+    });

    // Give the docs new IDs without breaking internal references
-    renewDocIds({docArray: nodes});
+    renewDocIds({ docArray: nodes });

    // Order the root node
    libraryNode.order += 0.5;

-		LibraryNodes.batchInsert([libraryNode, ...nodes]);
+    LibraryNodes.batchInsert([libraryNode, ...nodes]);

    // Tree structure changed by inserts, reorder the tree
    reorderDocs({