export function generateBoxedExpressionIndex()

in packages/dmn-editor/src/boxedExpressions/boxedExpressionIndex.ts [127:402]

• 273 lines of code
• 42 McCabe index (conditional complexity)

export function generateBoxedExpressionIndex(
  expression: AllExpressions,
  parentMap: BoxedExpressionIndex,
  parentExpressionPath: ExpressionPath[]
): BoxedExpressionIndex {
  const map: BoxedExpressionIndex = parentMap ? parentMap : new Map();
  switch (expression?.__$$element) {
    case "conditional":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "conditional", root: expression["@_id"] }],
          cell: expression,
        });
      generateBoxedExpressionIndex(expression.if.expression, map, [
        ...parentExpressionPath,
        { type: "conditional", row: "if", root: expression["@_id"]! },
      ]);
      generateBoxedExpressionIndex(expression.else.expression, map, [
        ...parentExpressionPath,
        { type: "conditional", row: "else", root: expression["@_id"]! },
      ]);
      generateBoxedExpressionIndex(expression.then.expression, map, [
        ...parentExpressionPath,
        { type: "conditional", row: "then", root: expression["@_id"]! },
      ]);
      return map;
    case "context":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "context", root: expression["@_id"] }],
          cell: expression,
        });
      expression.contextEntry?.forEach((ce, row) => {
        const id = ce.variable?.["@_id"] ?? ce?.["@_id"];
        id &&
          ce.variable &&
          map.set(id, {
            expressionPath: [
              ...parentExpressionPath,
              { type: "context", row, column: "variable", root: expression["@_id"]! },
            ],
            cell: ce.variable,
          });
        generateBoxedExpressionIndex(ce.expression, map, [
          ...parentExpressionPath,
          { type: "context", row, column: "expression", root: expression["@_id"]! },
        ]);
      });
      return map;
    case "decisionTable":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "decisionTable", root: expression["@_id"] }],
          cell: expression,
        });
      expression.output.forEach(
        (o, column) =>
          o["@_id"] &&
          map.set(o["@_id"], {
            expressionPath: [
              ...parentExpressionPath,
              { type: "decisionTable", header: "output", row: -1, column, root: expression["@_id"]! },
            ],
            cell: o,
          })
      );
      expression.input?.forEach((i, column) => {
        i["@_id"] &&
          map.set(i["@_id"], {
            expressionPath: [
              ...parentExpressionPath,
              { type: "decisionTable", header: "input", row: -1, column, root: expression["@_id"]! },
            ],
            cell: i,
          });
      });
      expression.rule?.forEach((r, row) => {
        r.outputEntry?.forEach(
          (ro, column) =>
            ro["@_id"] &&
            map.set(ro["@_id"], {
              expressionPath: [
                ...parentExpressionPath,
                { type: "decisionTable", header: "output", row, column, root: expression["@_id"]! },
              ],
              cell: ro,
            })
        );
        r.inputEntry?.forEach(
          (ri, column) =>
            ri["@_id"] &&
            map.set(ri["@_id"], {
              expressionPath: [
                ...parentExpressionPath,
                { type: "decisionTable", header: "input", row, column, root: expression["@_id"]! },
              ],
              cell: ri,
            })
        );
      });
      return map;
    case "every":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "every", root: expression["@_id"] }],
          cell: expression,
        });
      expression["@_id"] &&
        map.set(`${expression["@_id"]}-iteratorVariable`, {
          expressionPath: [...parentExpressionPath, { type: "every", row: "variable", root: expression["@_id"] }],
          cell: expression,
        });
      generateBoxedExpressionIndex(expression.in.expression, map, [
        ...parentExpressionPath,
        { type: "every", row: "in", root: expression["@_id"]! },
      ]);
      generateBoxedExpressionIndex(expression.satisfies.expression, map, [
        ...parentExpressionPath,
        { type: "every", row: "statisfies", root: expression["@_id"]! },
      ]);
      return map;
    case "filter":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "filter", root: expression["@_id"] }],
          cell: expression,
        });
      generateBoxedExpressionIndex(expression.in.expression, map, [
        ...parentExpressionPath,
        { type: "filter", row: "in", root: expression["@_id"]! },
      ]);
      generateBoxedExpressionIndex(expression.match.expression, map, [
        ...parentExpressionPath,
        { type: "filter", row: "match", root: expression["@_id"]! },
      ]);
      return map;
    case "for":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "for", root: expression["@_id"] }],
          cell: expression,
        });
      expression["@_id"] &&
        map.set(`${expression["@_id"]}-iteratorVariable`, {
          expressionPath: [...parentExpressionPath, { type: "for", row: "variable", root: expression["@_id"] }],
          cell: expression,
        });
      generateBoxedExpressionIndex(expression.in.expression, map, [
        ...parentExpressionPath,
        { type: "for", row: "in", root: expression["@_id"]! },
      ]);
      generateBoxedExpressionIndex(expression.return.expression, map, [
        ...parentExpressionPath,
        { type: "for", row: "return", root: expression["@_id"]! },
      ]);
      return map;
    case "functionDefinition":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "functionDefinition", root: expression["@_id"] }],
          cell: expression,
        });

      if (expression.expression?.["@_id"]) {
        generateBoxedExpressionIndex(expression.expression, map, [
          ...parentExpressionPath,
          { type: "functionDefinition", parameterIndex: -1, root: expression["@_id"]! },
        ]);
      }

      map.set(`${expression["@_id"]}-parameters`, {
        expressionPath: [
          ...parentExpressionPath,
          { type: "functionDefinition", parameterIndex: 0, root: expression["@_id"]! },
        ],
        cell: expression.formalParameter ?? [],
      });
      return map;
    case "invocation":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "invocation", root: expression["@_id"] }],
          cell: expression,
        });
      expression.binding?.forEach((b, row) => {
        b.parameter["@_id"] &&
          map.set(b.parameter["@_id"], {
            expressionPath: [
              ...parentExpressionPath,
              { type: "invocation", row, column: "parameter", root: expression["@_id"]! },
            ],
            cell: b.parameter,
          });
        b.expression &&
          generateBoxedExpressionIndex(b.expression, map, [
            ...parentExpressionPath,
            { type: "invocation", row, column: "expression", root: expression["@_id"]! },
          ]);
      });
      // function call
      expression.expression &&
        expression.expression["@_id"] &&
        map.set(expression.expression["@_id"], {
          expressionPath: [
            ...parentExpressionPath,
            { type: "invocation", row: -1, column: "expression", root: expression["@_id"]! },
          ],
          cell: expression.expression,
        });
      return map;
    case "list":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "list", root: expression["@_id"] }],
          cell: expression,
        });
      expression.expression?.forEach((e, row) =>
        generateBoxedExpressionIndex(e, map, [
          ...parentExpressionPath,
          { type: "list", row, root: expression["@_id"]! },
        ])
      );
      return map;
    case "literalExpression":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "literalExpression", root: expression["@_id"] }],
          cell: expression,
        });
      return map;
    case "relation":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "relation", root: expression["@_id"] }],
          cell: expression,
        });
      expression.column?.forEach(
        (c, column) =>
          c["@_id"] &&
          map.set(c["@_id"], {
            expressionPath: [...parentExpressionPath, { type: "relation", row: -1, column, root: expression["@_id"]! }],
            cell: c,
          })
      );
      expression.row?.forEach((r, row) =>
        r.expression?.forEach((re, column) => {
          re["@_id"] &&
            map.set(re["@_id"], {
              expressionPath: [...parentExpressionPath, { type: "relation", row, column, root: expression["@_id"]! }],
              cell: re,
            });
        })
      );
      return map;
    case "some":
      expression["@_id"] &&
        map.set(expression["@_id"], {
          expressionPath: [...parentExpressionPath, { type: "some", root: expression["@_id"] }],
          cell: expression,
        });
      expression["@_id"] &&
        map.set(`${expression["@_id"]}-iteratorVariable`, {
          expressionPath: [...parentExpressionPath, { type: "some", row: "variable", root: expression["@_id"] }],
          cell: expression,
        });
      generateBoxedExpressionIndex(expression.in.expression, map, [
        ...parentExpressionPath,
        { type: "some", row: "in", root: expression["@_id"]! },
      ]);
      generateBoxedExpressionIndex(expression.satisfies.expression, map, [
        ...parentExpressionPath,
        { type: "some", row: "statisfies", root: expression["@_id"]! },
      ]);
      return map;
  }
}