refactor(eslint): code adaptions to respect "member-ordering" rule

- https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/member-ordering.md BREAKING CHANGE: Switch linting from `tslint` to `eslint`.
intershop · Jan 17, 2022 · dc2af27 · dc2af27
1 parent 6e11d11
commit dc2af27
Show file tree

Hide file tree

Showing 6 changed files with 189 additions and 188 deletions.
diff --git a/src/app/core/models/category-tree/category-tree.helper.ts b/src/app/core/models/category-tree/category-tree.helper.ts
@@ -52,10 +52,6 @@ export class CategoryTreeHelper {
     };
   }
 
-  private static removeDuplicates<T>(input: T[]): T[] {
-    return input.filter((value, index, array) => array.indexOf(value) === index);
-  }
-
   /**
    * Select {@link Category} for update
    */
@@ -66,63 +62,17 @@ export class CategoryTreeHelper {
     return current;
   }
 
-  private static mergeEdges(
-    current: { [id: string]: string[] },
-    incoming: { [id: string]: string[] }
-  ): { [id: string]: string[] } {
-    const edges = { ...current };
-    Object.keys(incoming).forEach(key => {
-      if (current[key]) {
-        let master: string[];
-        let slave: string[];
-
-        // node with more available edges is trustworthy
-        if (incoming[key] && incoming[key].length > current[key].length) {
-          master = incoming[key];
-          slave = current[key];
-        } else {
-          master = current[key];
-          slave = incoming[key];
-        }
-
-        // add edges from both and remove duplicates
-        edges[key] = CategoryTreeHelper.removeDuplicates([...master, ...slave]);
-      } else {
-        edges[key] = [...incoming[key]];
-      }
-    });
-    return edges;
-  }
-
-  private static mergeRootIDs(current: string[], incoming: string[]): string[] {
-    // node with more available rootIDs is trustworthy
-    if (incoming && incoming.length > current.length) {
-      return CategoryTreeHelper.removeDuplicates([...incoming, ...current]);
-    } else {
-      return CategoryTreeHelper.removeDuplicates([...current, ...incoming]);
-    }
-  }
-
-  private static mergeNodes(
-    current: { [id: string]: Category },
-    incoming: { [id: string]: Category }
-  ): { [id: string]: Category } {
-    const nodes = { ...current };
-    Object.keys(incoming).forEach(key => {
-      nodes[key] = { ...CategoryTreeHelper.updateStrategy(current[key], incoming[key]) };
-    });
-    return nodes;
-  }
-
-  private static mergeCategoryRefs(
-    current: { [id: string]: string },
-    incoming: { [id: string]: Category }
-  ): { [id: string]: string } {
-    const refs = { ...current };
-    Object.keys(incoming).forEach(key => {
-      refs[incoming[key]?.categoryRef] = key;
-    });
-    return refs;
+  /**
+   * Perform check for equality. Order of items is ignored.
+   */
+  static equals(tree1: CategoryTree, tree2: CategoryTree): boolean {
+    return (
+      tree1 &&
+      tree2 &&
+      CategoryTreeHelper.rootIdsEqual(tree1.rootIds, tree2.rootIds) &&
+      CategoryTreeHelper.edgesEqual(tree1.edges, tree2.edges) &&
+      CategoryTreeHelper.categoriesEqual(tree1.nodes, tree2.nodes)
+    );
   }
 
   /**
@@ -167,6 +117,65 @@ export class CategoryTreeHelper {
     };
   }
 
+  private static mergeRootIDs(current: string[], incoming: string[]): string[] {
+    // node with more available rootIDs is trustworthy
+    if (incoming && incoming.length > current.length) {
+      return CategoryTreeHelper.removeDuplicates([...incoming, ...current]);
+    } else {
+      return CategoryTreeHelper.removeDuplicates([...current, ...incoming]);
+    }
+  }
+
+  private static mergeNodes(
+    current: { [id: string]: Category },
+    incoming: { [id: string]: Category }
+  ): { [id: string]: Category } {
+    const nodes = { ...current };
+    Object.keys(incoming).forEach(key => {
+      nodes[key] = { ...CategoryTreeHelper.updateStrategy(current[key], incoming[key]) };
+    });
+    return nodes;
+  }
+
+  private static mergeCategoryRefs(
+    current: { [id: string]: string },
+    incoming: { [id: string]: Category }
+  ): { [id: string]: string } {
+    const refs = { ...current };
+    Object.keys(incoming).forEach(key => {
+      refs[incoming[key]?.categoryRef] = key;
+    });
+    return refs;
+  }
+
+  private static mergeEdges(
+    current: { [id: string]: string[] },
+    incoming: { [id: string]: string[] }
+  ): { [id: string]: string[] } {
+    const edges = { ...current };
+    Object.keys(incoming).forEach(key => {
+      if (current[key]) {
+        let master: string[];
+        let slave: string[];
+
+        // node with more available edges is trustworthy
+        if (incoming[key] && incoming[key].length > current[key].length) {
+          master = incoming[key];
+          slave = current[key];
+        } else {
+          master = current[key];
+          slave = incoming[key];
+        }
+
+        // add edges from both and remove duplicates
+        edges[key] = CategoryTreeHelper.removeDuplicates([...master, ...slave]);
+      } else {
+        edges[key] = [...incoming[key]];
+      }
+    });
+    return edges;
+  }
+
   private static rootIdsEqual(t1: string[], t2: string[]) {
     return t1.length === t2.length && t1.every(e => t2.includes(e));
   }
@@ -185,16 +194,7 @@ export class CategoryTreeHelper {
     );
   }
 
-  /**
-   * Perform check for equality. Order of items is ignored.
-   */
-  static equals(tree1: CategoryTree, tree2: CategoryTree): boolean {
-    return (
-      tree1 &&
-      tree2 &&
-      CategoryTreeHelper.rootIdsEqual(tree1.rootIds, tree2.rootIds) &&
-      CategoryTreeHelper.edgesEqual(tree1.edges, tree2.edges) &&
-      CategoryTreeHelper.categoriesEqual(tree1.nodes, tree2.nodes)
-    );
+  private static removeDuplicates<T>(input: T[]): T[] {
+    return input.filter((value, index, array) => array.indexOf(value) === index);
   }
 }
diff --git a/src/app/core/models/content-page-tree/content-page-tree.helper.ts b/src/app/core/models/content-page-tree/content-page-tree.helper.ts
@@ -44,6 +44,30 @@ export class ContentPageTreeHelper {
     };
   }
 
+  /**
+   * Merge two trees to a new tree.
+   * Updates nodes according to updateStrategy.
+   */
+  static merge(current: ContentPageTree, incoming: ContentPageTree): ContentPageTree {
+    if (!current || !incoming) {
+      throw new Error('falsy input');
+    }
+
+    return {
+      edges: ContentPageTreeHelper.mergeEdges(current.edges, incoming.edges),
+      nodes: ContentPageTreeHelper.mergeNodes(current.nodes, incoming.nodes),
+      rootIds: ContentPageTreeHelper.mergeRootIDs(current.rootIds, incoming.rootIds),
+    };
+  }
+
+  /**
+   * Helper method for adding a single element to a tree.
+   */
+  static add(tree: ContentPageTree, element: ContentPageTreeElement): ContentPageTree {
+    const singleContentPageTree = ContentPageTreeHelper.single(element);
+    return ContentPageTreeHelper.merge(tree, singleContentPageTree);
+  }
+
   private static removeDuplicates<T>(input: T[]): T[] {
     return input.filter((value, index, array) => array.indexOf(value) === index);
   }
@@ -95,28 +119,4 @@ export class ContentPageTreeHelper {
       return ContentPageTreeHelper.removeDuplicates([...current, ...incoming]);
     }
   }
-
-  /**
-   * Merge two trees to a new tree.
-   * Updates nodes according to updateStrategy.
-   */
-  static merge(current: ContentPageTree, incoming: ContentPageTree): ContentPageTree {
-    if (!current || !incoming) {
-      throw new Error('falsy input');
-    }
-
-    return {
-      edges: ContentPageTreeHelper.mergeEdges(current.edges, incoming.edges),
-      nodes: ContentPageTreeHelper.mergeNodes(current.nodes, incoming.nodes),
-      rootIds: ContentPageTreeHelper.mergeRootIDs(current.rootIds, incoming.rootIds),
-    };
-  }
-
-  /**
-   * Helper method for adding a single element to a tree.
-   */
-  static add(tree: ContentPageTree, element: ContentPageTreeElement): ContentPageTree {
-    const singleContentPageTree = ContentPageTreeHelper.single(element);
-    return ContentPageTreeHelper.merge(tree, singleContentPageTree);
-  }
 }
diff --git a/src/app/core/models/price/price.helper.ts b/src/app/core/models/price/price.helper.ts
@@ -3,21 +3,6 @@ import { PriceItem } from 'ish-core/models/price-item/price-item.model';
 import { Price } from './price.model';
 
 export class PriceHelper {
-  private static sanityChecks(p1: Price, p2: Price) {
-    if (!p1 || !p2) {
-      throw new Error('cannot handle undefined inputs');
-    }
-    if (!Number.isFinite(p1.value) || !Number.isFinite(p2.value)) {
-      throw new Error('cannot handle undefined values');
-    }
-    if (!p1.currency || !p2.currency) {
-      throw new Error('cannot handle undefined currency');
-    }
-    if (p1.currency !== p2.currency) {
-      throw new Error('currency mismatch');
-    }
-  }
-
   static diff(p1: Price, p2: Price): Price {
     PriceHelper.sanityChecks(p1, p2);
     return {
@@ -77,4 +62,19 @@ export class PriceHelper {
     }
     return { currency, value, type: 'Money' };
   }
+
+  private static sanityChecks(p1: Price, p2: Price) {
+    if (!p1 || !p2) {
+      throw new Error('cannot handle undefined inputs');
+    }
+    if (!Number.isFinite(p1.value) || !Number.isFinite(p2.value)) {
+      throw new Error('cannot handle undefined values');
+    }
+    if (!p1.currency || !p2.currency) {
+      throw new Error('cannot handle undefined currency');
+    }
+    if (p1.currency !== p2.currency) {
+      throw new Error('currency mismatch');
+    }
+  }
 }