feat(eslint-plugin): [member-ordering] add a required option for required vs. optional member ordering

packages/eslint-plugin/src/rules/member-ordering.ts

@@ -4,7 +4,10 @@ import naturalCompare from 'natural-compare-lite';
 
 import * as util from '../util';
 
-export type MessageIds = 'incorrectGroupOrder' | 'incorrectOrder';
+export type MessageIds =
+  | 'incorrectGroupOrder'
+  | 'incorrectOrder'
+  | 'incorrectRequiredMembersOrder';
 
 type MemberKind =
   | 'call-signature'
@@ -46,6 +49,7 @@ type Order = AlphabeticalOrder | 'as-written';
 interface SortedOrderConfig {
   memberTypes?: MemberType[] | 'never';
   order: Order;
+  required?: 'first' | 'last';
 }
 
 type OrderConfig = MemberType[] | SortedOrderConfig | 'never';
@@ -99,6 +103,10 @@ const objectConfig = (memberTypes: MemberType[]): JSONSchema.JSONSchema4 => ({
         'natural-case-insensitive',
       ],
     },
+    required: {
+      type: 'string',
+      enum: ['first', 'last'],
+    },
   },
   additionalProperties: false,
 });
@@ -376,6 +384,63 @@ function getMemberName(
   }
 }
 
+/**
+ * Returns true if the member is optional based on the member type.
+ *
+ * @param node the node to be evaluated.
+ *
+ * @returns {Boolean} Returns true if the member is optional, false if it is not and undefined if it cannot be optional at all.
+ */
+function isMemberOptional(node: Member): boolean | undefined {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSPropertySignature:
+    case AST_NODE_TYPES.TSMethodSignature:
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.MethodDefinition:
+      return node.optional;
+    case AST_NODE_TYPES.TSConstructSignatureDeclaration:
+    case AST_NODE_TYPES.TSCallSignatureDeclaration:
+    case AST_NODE_TYPES.TSIndexSignature:
+    case AST_NODE_TYPES.StaticBlock:
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Iterates the array in reverse and returns the index of the first element it
+ * finds which passes the predicate function.
+ *
+ * @example
+ * ```js
+ * const isMemberRequired = (member) => !isMemberOptional(member);
+ * // returns 5
+ * findLastIndexOfMember([ req, req, req, optional, req, req, optional ], isMemberRequired)
+ * //                       0    1    2       3      4    5      6
+ * ```
+ * @param {Member[]} members An array of Member nodes containing required and optional items.
+ *
+ * @returns {Number} Returns the index of the element if it finds it or -1 otherwise.
+ */
+function findLastIndex<T>(
+  members: T[],
+  predicate: (member: T) => boolean | undefined | null,
+): number {
+  let idx = members.length - 1;
+
+  while (idx >= 0) {
+    const valid = predicate(members[idx]);
+    if (valid) {
+      return idx;
+    }
+    idx--;
+  }
+
+  return -1;
+}
+
 /**
  * Gets the calculated rank using the provided method definition.
  * The algorithm is as follows:
@@ -525,6 +590,7 @@ export default util.createRule<Options, MessageIds>({
         'Member {{member}} should be declared before member {{beforeMember}}.',
       incorrectGroupOrder:
         'Member {{name}} should be declared before all {{rank}} definitions.',
+      incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`,
     },
     schema: [
       {
@@ -689,6 +755,53 @@ export default util.createRule<Options, MessageIds>({
       }
     }
 
+    /**
+     * Checks if the order of optional and required members is correct based
+     * on the given 'required' parameter.
+     *
+     * @param {Member[]} members Members to be validated.
+     *
+     * @return True if all required and optional members are correctly sorted.
+     */
+    function checkRequiredOrder(
+      members: Member[],
+      required: 'first' | 'last' | undefined,
+    ): boolean {
+      if (!required) {
+        return true;
+      }
+
+      let firstIdx = -1;
+      let lastIdx = -1;
+
+      if (required === 'first') {
+        firstIdx = members.findIndex(member => isMemberOptional(member));
+        lastIdx = findLastIndex<Member>(members, m => !isMemberOptional(m));
+      } else if (required === 'last') {
+        firstIdx = members.findIndex(member => !isMemberOptional(member));
+        lastIdx = findLastIndex<Member>(members, isMemberOptional);
+      }
+
+      // if the array is either all required members or all optional members
+      // then its already in required first order
+      if (firstIdx === -1 || lastIdx === -1) {
+        return true;
+      }
+
+      if (firstIdx < lastIdx) {
+        context.report({
+          messageId: 'incorrectRequiredMembersOrder',
+          loc: members[firstIdx].loc,
+          data: {
+            member: getMemberName(members[firstIdx], context.getSourceCode()),
+            optionalOrRequired: required === 'first' ? 'required' : 'optional',
+          },
+        });
+      }
+
+      return firstIdx > lastIdx;
+    }
+
     /**
      * Validates if all members are correctly sorted.
      *
@@ -707,34 +820,111 @@ export default util.createRule<Options, MessageIds>({
 
       // Standardize config
       let order: Order | undefined;
-      let memberTypes;
+      let memberTypes: string | MemberType[] | undefined;
+      let required: 'first' | 'last' | undefined;
+
+      const memberSets: Array<Member[]> = [];
+
+      // returns true if everything is good and false if an error was reported
+      const checkOrder = (memberSet: Member[]): boolean => {
+        const hasAlphaSort = !!(order && order !== 'as-written');
+
+        // Check order
+        if (Array.isArray(memberTypes)) {
+          const grouped = checkGroupSort(
+            memberSet,
+            memberTypes,
+            supportsModifiers,
+          );
+
+          if (grouped === null) {
+            return false;
+          }
+
+          if (hasAlphaSort) {
+            return !grouped.some(
+              groupMember =>
+                !checkAlphaSort(groupMember, order as AlphabeticalOrder),
+            );
+          }
+        } else if (hasAlphaSort) {
+          return checkAlphaSort(memberSet, order as AlphabeticalOrder);
+        }
+
+        return true;
+      };
 
       if (Array.isArray(orderConfig)) {
         memberTypes = orderConfig;
       } else {
         order = orderConfig.order;
         memberTypes = orderConfig.memberTypes;
+        required = orderConfig.required;
       }
 
-      const hasAlphaSort = !!(order && order !== 'as-written');
+      if (!checkRequiredOrder(members, required)) {
+        return;
+      }
 
-      // Check order
-      if (Array.isArray(memberTypes)) {
-        const grouped = checkGroupSort(members, memberTypes, supportsModifiers);
+      if (required === 'first') {
+        // if the order of required and optional elements is correct,
+        // then check for correct sort and group order within the required and
+        // optional member sets
+        const firstOptionalMemberIndex = members.findIndex(member =>
+          isMemberOptional(member),
+        );
+        const lastRequiredMemberIndex = findLastIndex(
+          members,
+          m => !isMemberOptional(m),
+        );
 
-        if (grouped === null) {
-          return;
+        if (firstOptionalMemberIndex != -1) {
+          const optionalMembers: Member[] = members.slice(
+            firstOptionalMemberIndex,
+          );
+          memberSets.push(optionalMembers);
         }
 
-        if (hasAlphaSort) {
-          grouped.some(
-            groupMember =>
-              !checkAlphaSort(groupMember, order as AlphabeticalOrder),
+        if (lastRequiredMemberIndex != -1) {
+          const requiredMembers: Member[] = members.slice(
+            0,
+            lastRequiredMemberIndex + 1,
           );
+          memberSets.push(requiredMembers);
         }
-      } else if (hasAlphaSort) {
-        checkAlphaSort(members, order as AlphabeticalOrder);
+      } else if (required === 'last') {
+        // if the order of required and optional elements is correct,
+        // then check for correct order within the required and
+        // optional member sets
+        const firstRequiredMemberIndex = members.findIndex(
+          member => !isMemberOptional(member),
+        );
+        const lastOptionalMemberIndex = findLastIndex<Member>(
+          members,
+          isMemberOptional,
+        );
+
+        if (firstRequiredMemberIndex != -1) {
+          const requiredMembers: Member[] = members.slice(
+            firstRequiredMemberIndex,
+          );
+          memberSets.push(requiredMembers);
+        }
+
+        if (lastOptionalMemberIndex != -1) {
+          const optionalMembers: Member[] = members.slice(
+            0,
+            lastOptionalMemberIndex + 1,
+          );
+          memberSets.push(optionalMembers);
+        }
+      }
+
+      if (memberSets.length === 0) {
+        memberSets.push(members);
       }
+
+      memberSets.every(checkOrder);
     }
 
     return {