eslint-plugin-jsdoc 63.3.3 → 64.0.1

package/dist/rules/typeFormatting.cjs

@@ -1,607 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.cjs"));
-var _jsdocUtils = require("../jsdocUtils.cjs");
-var _jsdoccomment = require("@es-joy/jsdoccomment");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const digitRegex = /^(\d+(\.\d*)?|\.\d+)([eE][\-+]?\d+)?$/v;
-var _default = exports.default = (0, _iterateJsdoc.default)(({
-  context,
-  indent,
-  jsdoc,
-  settings,
-  utils
-  // eslint-disable-next-line complexity -- Todo
-}) => {
-  const {
-    arrayBrackets = 'square',
-    arrowFunctionPostReturnMarkerSpacing = ' ',
-    arrowFunctionPreReturnMarkerSpacing = ' ',
-    enableFixer = true,
-    functionOrClassParameterSpacing = ' ',
-    functionOrClassPostGenericSpacing = '',
-    functionOrClassPostReturnMarkerSpacing = ' ',
-    functionOrClassPreReturnMarkerSpacing = '',
-    functionOrClassTypeParameterSpacing = ' ',
-    genericAndTupleElementSpacing = ' ',
-    genericDot = false,
-    keyValuePostColonSpacing = ' ',
-    keyValuePostKeySpacing = '',
-    keyValuePostOptionalSpacing = '',
-    keyValuePostVariadicSpacing = '',
-    methodQuotes = 'double',
-    objectFieldIndent = '',
-    objectFieldQuote = null,
-    objectFieldSeparator = 'comma',
-    objectFieldSeparatorOptionalLinebreak = true,
-    objectFieldSeparatorTrailingPunctuation = false,
-    objectTypeBracketSpacing = '',
-    parameterDefaultValueSpacing = ' ',
-    postMethodNameSpacing = '',
-    postNewSpacing = ' ',
-    // propertyQuotes = null,
-    separatorForSingleObjectField = false,
-    stringQuotes = 'double',
-    trailingPunctuationMultilineOnly = false,
-    typeBracketSpacing = '',
-    unionSpacing = ' '
-  } = context.options[0] || {};
-  const {
-    mode
-  } = settings;
-
-  /**
-   * @param {import('@es-joy/jsdoccomment').JsdocTagWithInline} tag
-   */
-  const checkTypeFormats = tag => {
-    const potentialType = tag.type;
-    let parsedType;
-    try {
-      parsedType = mode === 'permissive' ? (0, _jsdoccomment.tryParse)(/** @type {string} */potentialType) : (0, _jsdoccomment.parse)(/** @type {string} */potentialType, mode);
-    } catch {
-      return;
-    }
-    const fix = () => {
-      (0, _jsdocUtils.rewireByParsedType)(jsdoc, tag, parsedType, indent, typeBracketSpacing);
-    };
-
-    /** @type {string[]} */
-    const errorMessages = [];
-    if (typeBracketSpacing && (!tag.type.startsWith(typeBracketSpacing) || !tag.type.endsWith(typeBracketSpacing))) {
-      errorMessages.push(`Must have initial and final "${typeBracketSpacing}" spacing`);
-    } else if (!typeBracketSpacing && (/^\s/v.test(tag.type) || /\s$/v.test(tag.type))) {
-      errorMessages.push('Must have no initial spacing');
-    }
-
-    // eslint-disable-next-line complexity -- Todo
-    (0, _jsdoccomment.traverse)(parsedType, nde => {
-      let errorMessage = '';
-
-      /**
-       * @param {Partial<import('jsdoc-type-pratt-parser').FunctionResult['meta']> & {
-       *   postNewSpacing?: string,
-       *   postMethodNameSpacing?: string
-       * }} meta
-       * @returns {Required<import('jsdoc-type-pratt-parser').FunctionResult['meta']> & {
-       *   postNewSpacing?: string,
-       *   postMethodNameSpacing?: string
-       * }}
-       */
-      const conditionalAdds = meta => {
-        const typNode =
-        /**
-         * @type {import('jsdoc-type-pratt-parser').FunctionResult|
-         *   import('jsdoc-type-pratt-parser').CallSignatureResult|
-         *   import('jsdoc-type-pratt-parser').ComputedMethodResult|
-         *   import('jsdoc-type-pratt-parser').ConstructorSignatureResult|
-         *   import('jsdoc-type-pratt-parser').MethodSignatureResult
-         * }
-         */
-        nde;
-
-        /**
-         * @type {Required<import('jsdoc-type-pratt-parser').FunctionResult['meta']> & {
-         *   postNewSpacing?: string,
-         *   postMethodNameSpacing?: string
-         * }}
-         */
-        const newMeta = {
-          parameterSpacing: meta.parameterSpacing ?? typNode.meta?.parameterSpacing ?? ' ',
-          postGenericSpacing: meta.postGenericSpacing ?? typNode.meta?.postGenericSpacing ?? '',
-          postReturnMarkerSpacing: meta.postReturnMarkerSpacing ?? typNode.meta?.postReturnMarkerSpacing ?? ' ',
-          preReturnMarkerSpacing: meta.preReturnMarkerSpacing ?? typNode.meta?.preReturnMarkerSpacing ?? '',
-          typeParameterSpacing: meta.typeParameterSpacing ?? typNode.meta?.typeParameterSpacing ?? ' '
-        };
-        if (typNode.type === 'JsdocTypeConstructorSignature') {
-          newMeta.postNewSpacing = meta.postNewSpacing;
-        }
-        if (typNode.type === 'JsdocTypeMethodSignature') {
-          newMeta.postMethodNameSpacing = meta.postMethodNameSpacing ?? typNode.meta?.postMethodNameSpacing ?? '';
-        }
-        return newMeta;
-      };
-      switch (nde.type) {
-        case 'JsdocTypeConstructorSignature':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').ConstructorSignatureResult} */nde;
-            /* c8 ignore next -- Guard */
-            if ((typeNode.meta?.postNewSpacing ?? ' ') !== postNewSpacing) {
-              typeNode.meta =
-              /**
-               * @type {Required<import('jsdoc-type-pratt-parser').FunctionResult['meta']> & {
-               *   postNewSpacing: string,
-               * }}
-               */
-              conditionalAdds({
-                postNewSpacing
-              });
-              errorMessage = `Post-\`new\` spacing should be "${postNewSpacing}"`;
-              break;
-            }
-          }
-        case 'JsdocTypeFunction':
-          {
-            const typeNode =
-            /**
-             * @type {import('jsdoc-type-pratt-parser').FunctionResult}
-             */
-            nde;
-            if ('arrow' in typeNode && typeNode.arrow) {
-              /* c8 ignore next -- Guard */
-              if ((typeNode.meta?.postReturnMarkerSpacing ?? ' ') !== arrowFunctionPostReturnMarkerSpacing) {
-                typeNode.meta =
-                /**
-                 * @type {Required<import('jsdoc-type-pratt-parser').FunctionResult['meta']> & {
-                 *   postNewSpacing: string,
-                 * }}
-                 */
-                conditionalAdds({
-                  postReturnMarkerSpacing: arrowFunctionPostReturnMarkerSpacing,
-                  /* c8 ignore next -- Guard */
-                  preReturnMarkerSpacing: typeNode.meta?.preReturnMarkerSpacing ?? ' '
-                });
-                errorMessage = `Post-return-marker spacing should be "${arrowFunctionPostReturnMarkerSpacing}"`;
-                break;
-                /* c8 ignore next -- Guard */
-              } else if ((typeNode.meta?.preReturnMarkerSpacing ?? ' ') !== arrowFunctionPreReturnMarkerSpacing) {
-                typeNode.meta =
-                /**
-                 * @type {Required<import('jsdoc-type-pratt-parser').FunctionResult['meta']> & {
-                 *   postNewSpacing: string,
-                 * }}
-                 */
-                conditionalAdds({
-                  /* c8 ignore next -- Guard */
-                  postReturnMarkerSpacing: typeNode.meta?.postReturnMarkerSpacing ?? ' ',
-                  preReturnMarkerSpacing: arrowFunctionPreReturnMarkerSpacing
-                });
-                errorMessage = `Pre-return-marker spacing should be "${arrowFunctionPreReturnMarkerSpacing}"`;
-                break;
-              }
-              break;
-            }
-          }
-        case 'JsdocTypeCallSignature':
-        case 'JsdocTypeComputedMethod':
-        case 'JsdocTypeMethodSignature':
-          {
-            const typeNode =
-            /**
-             * @type {import('jsdoc-type-pratt-parser').FunctionResult|
-             *   import('jsdoc-type-pratt-parser').CallSignatureResult|
-             *   import('jsdoc-type-pratt-parser').ComputedMethodResult|
-             *   import('jsdoc-type-pratt-parser').ConstructorSignatureResult|
-             *   import('jsdoc-type-pratt-parser').MethodSignatureResult
-             * }
-             */
-            nde;
-            if (typeNode.type === 'JsdocTypeMethodSignature' && (typeNode.meta?.postMethodNameSpacing ?? '') !== postMethodNameSpacing) {
-              typeNode.meta = {
-                quote: typeNode.meta.quote,
-                ...conditionalAdds({
-                  postMethodNameSpacing
-                })
-              };
-              errorMessage = `Post-method-name spacing should be "${postMethodNameSpacing}"`;
-              break;
-            } else if (typeNode.type === 'JsdocTypeMethodSignature' && typeNode.meta.quote !== undefined && typeNode.meta.quote !== methodQuotes) {
-              typeNode.meta = {
-                ...conditionalAdds({
-                  postMethodNameSpacing: typeNode.meta.postMethodNameSpacing ?? ''
-                }),
-                quote: methodQuotes
-              };
-              errorMessage = `Method quoting style should be "${methodQuotes}"`;
-              break;
-            }
-            if ((typeNode.meta?.parameterSpacing ?? ' ') !== functionOrClassParameterSpacing) {
-              typeNode.meta = conditionalAdds({
-                parameterSpacing: functionOrClassParameterSpacing
-              });
-              errorMessage = `Parameter spacing should be "${functionOrClassParameterSpacing}"`;
-            } else if ((typeNode.meta?.postGenericSpacing ?? '') !== functionOrClassPostGenericSpacing) {
-              typeNode.meta = conditionalAdds({
-                postGenericSpacing: functionOrClassPostGenericSpacing
-              });
-              errorMessage = `Post-generic spacing should be "${functionOrClassPostGenericSpacing}"`;
-            } else if ((typeNode.meta?.postReturnMarkerSpacing ?? ' ') !== functionOrClassPostReturnMarkerSpacing) {
-              typeNode.meta = conditionalAdds({
-                postReturnMarkerSpacing: functionOrClassPostReturnMarkerSpacing
-              });
-              errorMessage = `Post-return-marker spacing should be "${functionOrClassPostReturnMarkerSpacing}"`;
-            } else if ((typeNode.meta?.preReturnMarkerSpacing ?? '') !== functionOrClassPreReturnMarkerSpacing) {
-              typeNode.meta = conditionalAdds({
-                preReturnMarkerSpacing: functionOrClassPreReturnMarkerSpacing
-              });
-              errorMessage = `Pre-return-marker spacing should be "${functionOrClassPreReturnMarkerSpacing}"`;
-            } else if ((typeNode.meta?.typeParameterSpacing ?? ' ') !== functionOrClassTypeParameterSpacing) {
-              typeNode.meta = conditionalAdds({
-                typeParameterSpacing: functionOrClassTypeParameterSpacing
-              });
-              errorMessage = `Type parameter spacing should be "${functionOrClassTypeParameterSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeGeneric':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').GenericResult} */nde;
-            if ('value' in typeNode.left && typeNode.left.value === 'Array') {
-              if (typeNode.meta.brackets !== arrayBrackets) {
-                typeNode.meta.brackets = arrayBrackets;
-                errorMessage = `Array bracket style should be ${arrayBrackets}`;
-              }
-            } else if (typeNode.meta.dot !== genericDot) {
-              typeNode.meta.dot = genericDot;
-              errorMessage = `Dot usage should be ${genericDot}`;
-            } else if ((typeNode.meta.elementSpacing ?? ' ') !== genericAndTupleElementSpacing) {
-              typeNode.meta.elementSpacing = genericAndTupleElementSpacing;
-              errorMessage = `Element spacing should be "${genericAndTupleElementSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeKeyValue':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').KeyValueResult} */nde;
-            /* c8 ignore next -- Guard */
-            if ((typeNode.meta?.postKeySpacing ?? '') !== keyValuePostKeySpacing) {
-              typeNode.meta = {
-                /* c8 ignore next -- Guard */
-                postColonSpacing: typeNode.meta?.postColonSpacing ?? ' ',
-                postKeySpacing: keyValuePostKeySpacing,
-                /* c8 ignore next 2 -- Guard */
-                postOptionalSpacing: typeNode.meta?.postOptionalSpacing ?? '',
-                postVariadicSpacing: typeNode.meta?.postVariadicSpacing ?? ''
-              };
-              errorMessage = `Post key spacing should be "${keyValuePostKeySpacing}"`;
-              /* c8 ignore next -- Guard */
-            } else if ((typeNode.meta?.postColonSpacing ?? ' ') !== keyValuePostColonSpacing) {
-              typeNode.meta = {
-                postColonSpacing: keyValuePostColonSpacing,
-                /* c8 ignore next 3 -- Guard */
-                postKeySpacing: typeNode.meta?.postKeySpacing ?? '',
-                postOptionalSpacing: typeNode.meta?.postOptionalSpacing ?? '',
-                postVariadicSpacing: typeNode.meta?.postVariadicSpacing ?? ''
-              };
-              errorMessage = `Post colon spacing should be "${keyValuePostColonSpacing}"`;
-              /* c8 ignore next -- Guard */
-            } else if ((typeNode.meta?.postOptionalSpacing ?? '') !== keyValuePostOptionalSpacing) {
-              typeNode.meta = {
-                /* c8 ignore next 2 -- Guard */
-                postColonSpacing: typeNode.meta?.postColonSpacing ?? ' ',
-                postKeySpacing: typeNode.meta?.postKeySpacing ?? '',
-                postOptionalSpacing: keyValuePostOptionalSpacing,
-                /* c8 ignore next -- Guard */
-                postVariadicSpacing: typeNode.meta?.postVariadicSpacing ?? ''
-              };
-              errorMessage = `Post optional (\`?\`) spacing should be "${keyValuePostOptionalSpacing}"`;
-              /* c8 ignore next -- Guard */
-            } else if (typeNode.variadic && (typeNode.meta?.postVariadicSpacing ?? '') !== keyValuePostVariadicSpacing) {
-              typeNode.meta = {
-                /* c8 ignore next 3 -- Guard */
-                postColonSpacing: typeNode.meta?.postColonSpacing ?? ' ',
-                postKeySpacing: typeNode.meta?.postKeySpacing ?? '',
-                postOptionalSpacing: typeNode.meta?.postOptionalSpacing ?? '',
-                postVariadicSpacing: keyValuePostVariadicSpacing
-              };
-              errorMessage = `Post variadic (\`...\`) spacing should be "${keyValuePostVariadicSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeObject':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').ObjectResult} */nde;
-            /* c8 ignore next -- Guard */
-            const separator = typeNode.meta.separator ?? 'comma';
-            if (separator !== objectFieldSeparator && (!objectFieldSeparatorOptionalLinebreak || !(objectFieldSeparator.endsWith('-linebreak') && objectFieldSeparator.startsWith(separator))) || (typeNode.meta.separatorForSingleObjectField ?? false) !== separatorForSingleObjectField || (typeNode.meta.propertyIndent ?? '') !== objectFieldIndent && separator.endsWith('-linebreak') || (/* c8 ignore next 5 -- jsdoc-type-pratt-parser doesn't encode as should */
-            (typeNode.meta.trailingPunctuation ?? false) !== objectFieldSeparatorTrailingPunctuation && (typeNode.meta.trailingPunctuation && (!trailingPunctuationMultilineOnly || !(0, _jsdoccomment.stringify)(typeNode).includes('\n')) || !typeNode.meta.trailingPunctuation && (!trailingPunctuationMultilineOnly || (0, _jsdoccomment.stringify)(typeNode).includes('\n'))))) {
-              typeNode.meta.separator = objectFieldSeparatorOptionalLinebreak && !separator.endsWith('and-linebreak') ? objectFieldSeparator.replace(/-and-linebreak$/v, '') : objectFieldSeparator;
-              typeNode.meta.separatorForSingleObjectField = separatorForSingleObjectField;
-              typeNode.meta.propertyIndent = objectFieldIndent;
-              typeNode.meta.trailingPunctuation = objectFieldSeparatorTrailingPunctuation;
-              errorMessage = `Inconsistent ${objectFieldSeparator} separator usage`;
-            } else if ((typeNode.meta.bracketSpacing ?? '') !== objectTypeBracketSpacing) {
-              typeNode.meta.bracketSpacing = objectTypeBracketSpacing;
-              // This might not be the cause
-              // errorMessage = `Object type bracket spacing should be "${objectTypeBracketSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeObjectField':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').ObjectFieldResult} */nde;
-            if ((objectFieldQuote || typeof typeNode.key === 'string' && (/^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*$/v.test(typeNode.key) || digitRegex.test(typeNode.key))) && typeNode.meta.quote !== (objectFieldQuote ?? undefined) && (typeof typeNode.key !== 'string' || !digitRegex.test(typeNode.key))) {
-              typeNode.meta.quote = objectFieldQuote ?? undefined;
-              errorMessage = `Inconsistent object field quotes ${objectFieldQuote}`;
-            } else if ((typeNode.meta?.postKeySpacing ?? '') !== keyValuePostKeySpacing) {
-              typeNode.meta.postKeySpacing = keyValuePostKeySpacing;
-              errorMessage = `Post key spacing should be "${keyValuePostKeySpacing}"`;
-            } else if ((typeNode.meta?.postColonSpacing ?? ' ') !== keyValuePostColonSpacing) {
-              typeNode.meta.postColonSpacing = keyValuePostColonSpacing;
-              errorMessage = `Post colon spacing should be "${keyValuePostColonSpacing}"`;
-            } else if ((typeNode.meta?.postOptionalSpacing ?? '') !== keyValuePostOptionalSpacing) {
-              typeNode.meta.postOptionalSpacing = keyValuePostOptionalSpacing;
-              errorMessage = `Post optional (\`?\`) spacing should be "${keyValuePostOptionalSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeStringValue':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').StringValueResult} */nde;
-            if (typeNode.meta.quote !== stringQuotes) {
-              typeNode.meta.quote = stringQuotes;
-              errorMessage = `Inconsistent ${stringQuotes} string quotes usage`;
-            }
-            break;
-          }
-
-        // Only suitable for namepaths (and would need changes); see https://github.com/gajus/eslint-plugin-jsdoc/issues/1524
-        // case 'JsdocTypeProperty': {
-        //   const typeNode = /** @type {import('jsdoc-type-pratt-parser').PropertyResult} */ (nde);
-
-        //   if ((propertyQuotes ||
-        //     (typeof typeNode.value === 'string' && !(/\s/v).test(typeNode.value))) &&
-        //     typeNode.meta.quote !== (propertyQuotes ?? undefined)
-        //   ) {
-        //     typeNode.meta.quote = propertyQuotes ?? undefined;
-        //     errorMessage = `Inconsistent ${propertyQuotes} property quotes usage`;
-        //   }
-
-        //   break;
-        // }
-
-        case 'JsdocTypeTuple':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').TupleResult} */nde;
-            /* c8 ignore next -- Guard */
-            if ((typeNode.meta?.elementSpacing ?? ' ') !== genericAndTupleElementSpacing) {
-              typeNode.meta = {
-                elementSpacing: genericAndTupleElementSpacing
-              };
-              errorMessage = `Element spacing should be "${genericAndTupleElementSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeTypeParameter':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').TypeParameterResult} */nde;
-            /* c8 ignore next -- Guard */
-            if (typeNode.defaultValue && (typeNode.meta?.defaultValueSpacing ?? ' ') !== parameterDefaultValueSpacing) {
-              typeNode.meta = {
-                defaultValueSpacing: parameterDefaultValueSpacing
-              };
-              errorMessage = `Default value spacing should be "${parameterDefaultValueSpacing}"`;
-            }
-            break;
-          }
-        case 'JsdocTypeUnion':
-          {
-            const typeNode = /** @type {import('jsdoc-type-pratt-parser').UnionResult} */nde;
-            /* c8 ignore next -- Guard */
-            if ((typeNode.meta?.spacing ?? ' ') !== unionSpacing) {
-              typeNode.meta = {
-                spacing: unionSpacing
-              };
-              errorMessage = `Inconsistent "${unionSpacing}" union spacing usage`;
-            }
-            break;
-          }
-        default:
-          break;
-      }
-      if (errorMessage) {
-        errorMessages.push(errorMessage);
-      }
-    });
-    const differentResult = tag.type !== typeBracketSpacing + (0, _jsdoccomment.stringify)(parsedType) + typeBracketSpacing;
-    if (errorMessages.length && differentResult) {
-      for (const errorMessage of errorMessages) {
-        utils.reportJSDoc(errorMessage, tag, enableFixer ? fix : null);
-      }
-      // Stringification may have been equal previously (and thus no error reported)
-      //   because the stringification doesn't preserve everything
-    } else if (differentResult) {
-      utils.reportJSDoc('There was an error with type formatting', tag, enableFixer ? fix : null);
-    }
-  };
-  const tags = utils.getPresentTags(['param', 'property', 'returns', 'this', 'throws', 'type', 'typedef', 'yields']);
-  for (const tag of tags) {
-    if (tag.type) {
-      checkTypeFormats(tag);
-    }
-  }
-}, {
-  iterateAllJsdocs: true,
-  meta: {
-    docs: {
-      description: 'Formats JSDoc type values.',
-      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/type-formatting.md#repos-sticky-header'
-    },
-    fixable: 'code',
-    schema: [{
-      additionalProperties: false,
-      properties: {
-        arrayBrackets: {
-          description: 'Determines how array generics are represented. Set to `angle` for the style `Array<type>` or `square` for the style `type[]`. Defaults to "square".',
-          enum: ['angle', 'square'],
-          type: 'string'
-        },
-        arrowFunctionPostReturnMarkerSpacing: {
-          description: 'The space character (if any) to use after return markers (`=>`). Defaults to " ".',
-          type: 'string'
-        },
-        arrowFunctionPreReturnMarkerSpacing: {
-          description: 'The space character (if any) to use before return markers (`=>`). Defaults to " ".',
-          type: 'string'
-        },
-        enableFixer: {
-          description: 'Whether to enable the fixer. Defaults to `true`.',
-          type: 'boolean'
-        },
-        functionOrClassParameterSpacing: {
-          description: 'The space character (if any) to use between function or class parameters. Defaults to " ".',
-          type: 'string'
-        },
-        functionOrClassPostGenericSpacing: {
-          description: 'The space character (if any) to use after a generic expression in a function or class. Defaults to "".',
-          type: 'string'
-        },
-        functionOrClassPostReturnMarkerSpacing: {
-          description: 'The space character (if any) to use after return markers (`:`). Defaults to "".',
-          type: 'string'
-        },
-        functionOrClassPreReturnMarkerSpacing: {
-          description: 'The space character (if any) to use before return markers (`:`). Defaults to "".',
-          type: 'string'
-        },
-        functionOrClassTypeParameterSpacing: {
-          description: 'The space character (if any) to use between type parameters in a function or class. Defaults to " ".',
-          type: 'string'
-        },
-        genericAndTupleElementSpacing: {
-          description: 'The space character (if any) to use between elements in generics and tuples. Defaults to " ".',
-          type: 'string'
-        },
-        genericDot: {
-          description: 'Boolean value of whether to use a dot before the angled brackets of a generic (e.g., `SomeType.<AnotherType>`). Defaults to `false`.',
-          type: 'boolean'
-        },
-        keyValuePostColonSpacing: {
-          description: 'The amount of spacing (if any) after the colon of a key-value or object-field pair. Defaults to " ".',
-          type: 'string'
-        },
-        keyValuePostKeySpacing: {
-          description: 'The amount of spacing (if any) immediately after keys in a key-value or object-field pair. Defaults to "".',
-          type: 'string'
-        },
-        keyValuePostOptionalSpacing: {
-          description: 'The amount of spacing (if any) after the optional operator (`?`) in a key-value or object-field pair. Defaults to "".',
-          type: 'string'
-        },
-        keyValuePostVariadicSpacing: {
-          description: 'The amount of spacing (if any) after a variadic operator (`...`) in a key-value pair. Defaults to "".',
-          type: 'string'
-        },
-        methodQuotes: {
-          description: 'The style of quotation mark for surrounding method names when quoted. Defaults to `double`',
-          enum: ['double', 'single'],
-          type: 'string'
-        },
-        objectFieldIndent: {
-          description: `A string indicating the whitespace to be added on each line preceding an
-object property-value field. Defaults to the empty string.`,
-          type: 'string'
-        },
-        objectFieldQuote: {
-          description: `Whether and how object field properties should be quoted (e.g., \`{"a": string}\`).
-Set to \`single\`, \`double\`, or \`null\`. Defaults to \`null\` (no quotes unless
-required due to special characters within the field). Digits will be kept as is,
-regardless of setting (they can either represent a digit or a string digit).`,
-          enum: ['double', 'single', null]
-        },
-        objectFieldSeparator: {
-          description: `For object properties, specify whether a "semicolon", "comma", "linebreak",
-"semicolon-and-linebreak", or "comma-and-linebreak" should be used after
-each object property-value pair.
-
-Defaults to \`"comma"\`.`,
-          enum: ['comma', 'comma-and-linebreak', 'linebreak', 'semicolon', 'semicolon-and-linebreak'],
-          type: 'string'
-        },
-        objectFieldSeparatorOptionalLinebreak: {
-          description: `Whether \`objectFieldSeparator\` set to \`"semicolon-and-linebreak"\` or
-\`"comma-and-linebreak"\` should be allowed to optionally drop the linebreak.
-
-Defaults to \`true\`.`,
-          type: 'boolean'
-        },
-        objectFieldSeparatorTrailingPunctuation: {
-          description: `If \`separatorForSingleObjectField\` is not in effect (i.e., if it is \`false\`
-or there are multiple property-value object fields present), this property
-will determine whether to add punctuation corresponding to the
-\`objectFieldSeparator\` (e.g., a semicolon) to the final object field.
-Defaults to \`false\`.`,
-          type: 'boolean'
-        },
-        objectTypeBracketSpacing: {
-          description: 'The space character (if any) to add after an object\'s initial curly bracket and before its ending curly bracket',
-          type: 'string'
-        },
-        parameterDefaultValueSpacing: {
-          description: 'The space character (if any) to use between the equal signs of a default value. Defaults to " ".',
-          type: 'string'
-        },
-        postMethodNameSpacing: {
-          description: 'The space character (if any) to add after a method name. Defaults to "".',
-          type: 'string'
-        },
-        postNewSpacing: {
-          description: 'The space character (if any) to add after "new" in a constructor. Defaults to " ".',
-          type: 'string'
-        },
-        //           propertyQuotes: {
-        //             description: `Whether and how namepath properties should be quoted (e.g., \`ab."cd"."ef"\`).
-        // Set to \`single\`, \`double\`, or \`null\`. Defaults to \`null\` (no quotes unless
-        // required due to whitespace within the property).`,
-        //             enum: [
-        //               'double',
-        //               'single',
-        //               null,
-        //             ],
-        //           },
-        separatorForSingleObjectField: {
-          description: `Whether to apply the \`objectFieldSeparator\` (e.g., a semicolon) when there
-is only one property-value object field present. Defaults to \`false\`.`,
-          type: 'boolean'
-        },
-        stringQuotes: {
-          description: `How string literals should be quoted (e.g., \`"abc"\`). Set to \`single\`
-or \`double\`. Defaults to 'double'.`,
-          enum: ['double', 'single'],
-          type: 'string'
-        },
-        trailingPunctuationMultilineOnly: {
-          description: 'If `objectFieldSeparatorTrailingPunctuation` is set, this will determine whether the trailing puncutation is only added when the type is multiline',
-          type: 'boolean'
-        },
-        typeBracketSpacing: {
-          description: `A string of spaces that will be added immediately after the type's initial
-curly bracket and immediately before its ending curly bracket. Defaults
-to the empty string.`,
-          type: 'string'
-        },
-        unionSpacing: {
-          description: 'Determines the spacing to add to unions (`|`). Defaults to a single space (`" "`).',
-          type: 'string'
-        }
-      },
-      type: 'object'
-    }],
-    type: 'suggestion'
-  }
-});
-module.exports = exports.default;
-//# sourceMappingURL=typeFormatting.cjs.map