eslint-plugin-stylistic-compat/dist/rules/object-curly-newline.js

Compatibility version of @stylistic/eslint-plugin for Node.js >= 12 and ESLint v8

'use strict';

var utils = require('../utils.js');
var _someInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/some');
var _Object$values = require('@babel/runtime-corejs3/core-js/object/values');
var _filterInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/filter');
require('@babel/runtime-corejs3/core-js/object/from-entries');
require('@babel/runtime-corejs3/core-js/instance/map');
require('@babel/runtime-corejs3/core-js/object/entries');
require('@babel/runtime-corejs3/core-js/set');
require('@babel/runtime-corejs3/core-js/instance/flags');
require('@babel/runtime-corejs3/core-js/instance/includes');
require('@babel/runtime-corejs3/core-js/instance/starts-with');
require('../vendor.js');
require('@babel/runtime-corejs3/core-js/object/assign');
require('@babel/runtime-corejs3/core-js/object/create');
require('@babel/runtime-corejs3/core-js/object/freeze');
require('@babel/runtime-corejs3/core-js/array/is-array');
require('@babel/runtime-corejs3/core-js/instance/last-index-of');
require('@babel/runtime-corejs3/core-js/instance/slice');
require('@babel/runtime-corejs3/core-js/object/define-properties');
require('@babel/runtime-corejs3/core-js/object/keys');
require('@babel/runtime-corejs3/core-js/instance/index-of');
require('@babel/runtime-corejs3/core-js/instance/at');
require('@babel/runtime-corejs3/core-js/symbol');
require('@babel/runtime-corejs3/core-js/symbol/iterator');
require('@babel/runtime-corejs3/core-js/parse-int');
require('@babel/runtime-corejs3/core-js/parse-float');
require('@babel/runtime-corejs3/core-js/weak-map');
require('@babel/runtime-corejs3/core-js/object/define-property');
require('@babel/runtime-corejs3/core-js/global-this');
require('@babel/runtime-corejs3/core-js/instance/for-each');
require('@babel/runtime-corejs3/core-js/array/from');
require('eslint/use-at-your-own-risk');
require('eslint');
require('@babel/runtime-corejs3/core-js/object/get-own-property-descriptor');
require('@babel/runtime-corejs3/core-js/map');
require('@babel/runtime-corejs3/core-js/instance/find');
require('@babel/runtime-corejs3/core-js/instance/every');
require('@babel/runtime-corejs3/core-js/instance/sort');
require('@babel/runtime-corejs3/core-js/array/of');
require('@babel/runtime-corejs3/core-js/instance/concat');
require('@babel/runtime-corejs3/core-js/instance/entries');
require('@babel/runtime-corejs3/core-js/instance/find-index');
require('@babel/runtime-corejs3/core-js/instance/flat');
require('@babel/runtime-corejs3/core-js/instance/keys');
require('@babel/runtime-corejs3/core-js/instance/values');
require('@babel/runtime-corejs3/core-js/object/get-own-property-names');
require('@babel/runtime-corejs3/core-js/number/is-finite');
require('@babel/runtime-corejs3/core-js/number/is-nan');
require('@babel/runtime-corejs3/core-js/number/parse-float');
require('@babel/runtime-corejs3/core-js/number/parse-int');
require('@babel/runtime-corejs3/core-js/object/is');
require('@babel/runtime-corejs3/core-js/object/is-extensible');
require('@babel/runtime-corejs3/core-js/object/is-frozen');
require('@babel/runtime-corejs3/core-js/object/is-sealed');
require('@babel/runtime-corejs3/core-js/string/from-code-point');
require('@babel/runtime-corejs3/core-js/string/raw');
require('@babel/runtime-corejs3/core-js/instance/code-point-at');
require('@babel/runtime-corejs3/core-js/instance/ends-with');
require('@babel/runtime-corejs3/core-js/instance/pad-end');
require('@babel/runtime-corejs3/core-js/instance/pad-start');
require('@babel/runtime-corejs3/core-js/instance/trim');
require('@babel/runtime-corejs3/core-js/instance/trim-end');
require('@babel/runtime-corejs3/core-js/instance/trim-left');
require('@babel/runtime-corejs3/core-js/instance/trim-right');
require('@babel/runtime-corejs3/core-js/instance/trim-start');
require('@babel/runtime-corejs3/core-js/symbol/for');
require('@babel/runtime-corejs3/core-js/symbol/key-for');
require('@babel/runtime-corejs3/core-js/object/prevent-extensions');
require('@babel/runtime-corejs3/core-js/object/seal');
require('@babel/runtime-corejs3/core-js/object/get-prototype-of');
require('@babel/runtime-corejs3/core-js/symbol/replace');
require('@babel/runtime-corejs3/core-js/instance/bind');
require('@babel/runtime-corejs3/core-js/instance/splice');
require('@babel/runtime-corejs3/core-js/instance/repeat');
require('@babel/runtime-corejs3/core-js/instance/reduce');
require('@babel/runtime-corejs3/core-js/instance/reverse');

const OPTION_VALUE = {
  oneOf: [{
    type: "string",
    enum: ["always", "never"]
  }, {
    type: "object",
    properties: {
      multiline: {
        type: "boolean"
      },
      minProperties: {
        type: "integer",
        minimum: 0
      },
      consistent: {
        type: "boolean"
      }
    },
    additionalProperties: false,
    minProperties: 1
  }]
};
function normalizeOptionValue(value) {
  let multiline = false;
  let minProperties = Number.POSITIVE_INFINITY;
  let consistent = false;
  if (value) {
    if (value === "always") {
      minProperties = 0;
    } else if (value === "never") {
      minProperties = Number.POSITIVE_INFINITY;
    } else {
      multiline = Boolean(value.multiline);
      minProperties = value.minProperties || Number.POSITIVE_INFINITY;
      consistent = Boolean(value.consistent);
    }
  } else {
    consistent = true;
  }
  return {
    multiline,
    minProperties,
    consistent
  };
}
function isObject(value) {
  return typeof value === "object" && value !== null;
}
function isNodeSpecificOption(option) {
  return isObject(option) || typeof option === "string";
}
function normalizeOptions(options) {
  var _context;
  if (isObject(options) && _someInstanceProperty(_context = _Object$values(options)).call(_context, isNodeSpecificOption)) {
    return {
      ObjectExpression: normalizeOptionValue(options.ObjectExpression),
      ObjectPattern: normalizeOptionValue(options.ObjectPattern),
      ImportDeclaration: normalizeOptionValue(options.ImportDeclaration),
      ExportNamedDeclaration: normalizeOptionValue(options.ExportDeclaration),
      TSTypeLiteral: normalizeOptionValue(options.TSTypeLiteral),
      TSInterfaceBody: normalizeOptionValue(options.TSInterfaceBody)
    };
  }
  const value = normalizeOptionValue(options);
  return {
    ObjectExpression: value,
    ObjectPattern: value,
    ImportDeclaration: value,
    ExportNamedDeclaration: value,
    TSTypeLiteral: value,
    TSInterfaceBody: value
  };
}
function areLineBreaksRequired(node, options, first, last) {
  let objectProperties;
  if (node.type === "ObjectExpression" || node.type === "ObjectPattern") {
    objectProperties = node.properties;
  } else if (node.type === "TSTypeLiteral") {
    objectProperties = node.members;
  } else if (node.type === "TSInterfaceBody") {
    objectProperties = node.body;
  } else {
    var _context2;
    objectProperties = _filterInstanceProperty(_context2 = node.specifiers).call(_context2, s => s.type === "ImportSpecifier" || s.type === "ExportSpecifier");
  }
  return objectProperties.length >= options.minProperties || options.multiline && objectProperties.length > 0 && first.loc.start.line !== last.loc.end.line;
}
var _baseRule = utils.createRule({
  name: "object-curly-newline",
  package: "js",
  meta: {
    type: "layout",
    docs: {
      description: "Enforce consistent line breaks after opening and before closing braces"
    },
    fixable: "whitespace",
    schema: [{
      oneOf: [OPTION_VALUE, {
        type: "object",
        properties: {
          ObjectExpression: OPTION_VALUE,
          ObjectPattern: OPTION_VALUE,
          ImportDeclaration: OPTION_VALUE,
          ExportDeclaration: OPTION_VALUE,
          TSTypeLiteral: OPTION_VALUE,
          TSInterfaceBody: OPTION_VALUE
        },
        additionalProperties: false,
        minProperties: 1
      }]
    }],
    messages: {
      unexpectedLinebreakBeforeClosingBrace: "Unexpected line break before this closing brace.",
      unexpectedLinebreakAfterOpeningBrace: "Unexpected line break after this opening brace.",
      expectedLinebreakBeforeClosingBrace: "Expected a line break before this closing brace.",
      expectedLinebreakAfterOpeningBrace: "Expected a line break after this opening brace."
    }
  },
  create(context) {
    const sourceCode = context.sourceCode;
    const normalizedOptions = normalizeOptions(context.options[0]);
    function check(node) {
      var _context3, _context4;
      const options = normalizedOptions[node.type];
      if (node.type === "ImportDeclaration" && !_someInstanceProperty(_context3 = node.specifiers).call(_context3, specifier => specifier.type === "ImportSpecifier") || node.type === "ExportNamedDeclaration" && !_someInstanceProperty(_context4 = node.specifiers).call(_context4, specifier => specifier.type === "ExportSpecifier")) {
        return;
      }
      const openBrace = sourceCode.getFirstToken(node, token => token.value === "{");
      let closeBrace;
      if (node.type === "ObjectPattern" && node.typeAnnotation) closeBrace = sourceCode.getTokenBefore(node.typeAnnotation);else closeBrace = sourceCode.getLastToken(node, token => token.value === "}");
      let first = sourceCode.getTokenAfter(openBrace, {
        includeComments: true
      });
      let last = sourceCode.getTokenBefore(closeBrace, {
        includeComments: true
      });
      const needsLineBreaks = areLineBreaksRequired(node, options, first, last);
      const hasCommentsFirstToken = utils.isCommentToken(first);
      const hasCommentsLastToken = utils.isCommentToken(last);
      first = sourceCode.getTokenAfter(openBrace);
      last = sourceCode.getTokenBefore(closeBrace);
      if (needsLineBreaks) {
        if (utils.isTokenOnSameLine(openBrace, first)) {
          context.report({
            messageId: "expectedLinebreakAfterOpeningBrace",
            node,
            loc: openBrace.loc,
            fix(fixer) {
              if (hasCommentsFirstToken) return null;
              return fixer.insertTextAfter(openBrace, "\n");
            }
          });
        }
        if (utils.isTokenOnSameLine(last, closeBrace)) {
          context.report({
            messageId: "expectedLinebreakBeforeClosingBrace",
            node,
            loc: closeBrace.loc,
            fix(fixer) {
              if (hasCommentsLastToken) return null;
              return fixer.insertTextBefore(closeBrace, "\n");
            }
          });
        }
      } else {
        const consistent = options.consistent;
        const hasLineBreakBetweenOpenBraceAndFirst = !utils.isTokenOnSameLine(openBrace, first);
        const hasLineBreakBetweenCloseBraceAndLast = !utils.isTokenOnSameLine(last, closeBrace);
        if (!consistent && hasLineBreakBetweenOpenBraceAndFirst || consistent && hasLineBreakBetweenOpenBraceAndFirst && !hasLineBreakBetweenCloseBraceAndLast) {
          context.report({
            messageId: "unexpectedLinebreakAfterOpeningBrace",
            node,
            loc: openBrace.loc,
            fix(fixer) {
              if (hasCommentsFirstToken) return null;
              return fixer.removeRange([openBrace.range[1], first.range[0]]);
            }
          });
        }
        if (!consistent && hasLineBreakBetweenCloseBraceAndLast || consistent && !hasLineBreakBetweenOpenBraceAndFirst && hasLineBreakBetweenCloseBraceAndLast) {
          context.report({
            messageId: "unexpectedLinebreakBeforeClosingBrace",
            node,
            loc: closeBrace.loc,
            fix(fixer) {
              if (hasCommentsLastToken) return null;
              return fixer.removeRange([last.range[1], closeBrace.range[0]]);
            }
          });
        }
      }
    }
    return {
      ObjectExpression: check,
      ObjectPattern: check,
      ImportDeclaration: check,
      ExportNamedDeclaration: check,
      TSTypeLiteral: check,
      TSInterfaceBody: check
    };
  }
});

const baseRule = /* @__PURE__ */utils.castRuleModule(_baseRule);
const defaultOptionValue = {
  multiline: false,
  minProperties: Number.POSITIVE_INFINITY,
  consistent: true
};
var objectCurlyNewline = utils.createRule({
  name: "object-curly-newline",
  package: "ts",
  meta: {
    ...baseRule.meta,
    docs: {
      description: "Enforce consistent line breaks after opening and before closing braces"
    }
  },
  defaultOptions: [{
    ObjectExpression: defaultOptionValue,
    ObjectPattern: defaultOptionValue,
    ImportDeclaration: defaultOptionValue,
    ExportDeclaration: defaultOptionValue,
    TSTypeLiteral: defaultOptionValue,
    TSInterfaceBody: defaultOptionValue
  }],
  create(context) {
    const rules = baseRule.create(context);
    return rules;
  }
});

module.exports = objectCurlyNewline;