Add types/rules/jsx-no-literals.d.ts to avoid error TS2309: An export…

… assignment cannot be used in a module with other exported elements.

lib/rules/jsx-no-literals.js

@@ -66,51 +66,13 @@ const commonPropertiesSchema = {
 };
 
 /**
- * @typedef RawElementConfigProperties
- * @property {boolean} [noStrings]
- * @property {string[]} [allowedStrings]
- * @property {boolean} [ignoreProps]
- * @property {boolean} [noAttributeStrings]
- *
- * @typedef RawOverrideConfigProperties
- * @property {boolean} [allowElement]
- * @property {boolean} [applyToNestedElements=true]
- *
- * @typedef {RawElementConfigProperties} RawElementConfig
- * @typedef {RawElementConfigProperties & RawElementConfigProperties} RawOverrideConfig
- *
- * @typedef RawElementOverrides
- * @property {Record<string, RawOverrideConfig>} [elementOverrides]
- *
- * @typedef {RawElementConfig & RawElementOverrides} RawConfig
- *
- * ----------------------------------------------------------------------
- *
- * @typedef ElementConfigType
- * @property {'element'} type
- *
- * @typedef ElementConfigProperties
- * @property {boolean} noStrings
- * @property {Set<string>} allowedStrings
- * @property {boolean} ignoreProps
- * @property {boolean} noAttributeStrings
- *
- * @typedef OverrideConfigProperties
- * @property {'override'} type
- * @property {string} name
- * @property {boolean} allowElement
- * @property {boolean} applyToNestedElements
- *
- * @typedef {ElementConfigType & ElementConfigProperties} ElementConfig
- * @typedef {OverrideConfigProperties & ElementConfigProperties} OverrideConfig
- *
- * @typedef ElementOverrides
- * @property {Record<string, OverrideConfig>} elementOverrides
- *
- * @typedef {ElementConfig & ElementOverrides} Config
- * @typedef {Config | OverrideConfig} ResolvedConfig
+ * @typedef {import("../../types/rules/jsx-no-literals").RawConfig} RawConfig
+ * @typedef {import("../../types/rules/jsx-no-literals").ElementConfig} ElementConfig
+ * @typedef {import("../../types/rules/jsx-no-literals").OverrideConfig} OverrideConfig
+ * @typedef {import("../../types/rules/jsx-no-literals").Config} Config
+ * @typedef {import("../../types/rules/jsx-no-literals").ResolvedConfig} ResolvedConfig
  */
-
+ 
 /**
  * Normalizes the element portion of the config
  * @param {RawConfig} config
@@ -131,10 +93,10 @@ function normalizeElementConfig(config) {
 /**
  * Normalizes the config and applies default values to all config options
  * @param {RawConfig} config
- * @returns {Config}
+ * @returns {import('./jsx-no-literals').Config}
  */
 function normalizeConfig(config) {
-  /** @type {Config} */
+  /** @type {import('./jsx-no-literals').Config} */
   const normalizedConfig = Object.assign(normalizeElementConfig(config), {
     elementOverrides: {},
   });
@@ -344,7 +306,7 @@ module.exports = {
      * Determines whether a given node's value and its immediate parent are
      * viable text nodes that can/should be reported on
      * @param {ASTNode} node
-     * @param {ResolvedConfig} resolvedConfig
+     * @param {import('./jsx-no-literals').ResolvedConfig} resolvedConfig
      * @returns {boolean}
      */
     function isViableTextNode(node, resolvedConfig) {
@@ -376,7 +338,7 @@ module.exports = {
      * need to traverse the ancestor tree to determine if an ancestor's config
      * will also apply to the current node.
      * @param {ASTNode} node
-     * @returns {OverrideConfig | undefined}
+     * @returns {import('./jsx-no-literals').OverrideConfig | undefined}
      */
     function getOverrideConfig(node) {
       if (!hasElementOverrides) {
@@ -410,7 +372,7 @@ module.exports = {
     }
 
     /**
-     * @param {ResolvedConfig} resolvedConfig
+     * @param {import('./jsx-no-literals').ResolvedConfig} resolvedConfig
      * @returns {boolean}
      */
     function shouldAllowElement(resolvedConfig) {
@@ -419,7 +381,7 @@ module.exports = {
 
     /**
      * @param {boolean} ancestorIsJSXElement
-     * @param {ResolvedConfig} resolvedConfig
+     * @param {import('./jsx-no-literals').ResolvedConfig} resolvedConfig
      * @returns {string}
      */
     function defaultMessageId(ancestorIsJSXElement, resolvedConfig) {
@@ -437,7 +399,7 @@ module.exports = {
     /**
      * @param {ASTNode} node
      * @param {string} messageId
-     * @param {ResolvedConfig} resolvedConfig
+     * @param {import('./jsx-no-literals').ResolvedConfig} resolvedConfig
      */
     function reportLiteralNode(node, messageId, resolvedConfig) {
       report(context, messages[messageId], messageId, {

tsconfig.json

@@ -19,5 +19,5 @@
     "alwaysStrict": false,                 /* Parse in strict mode and emit "use strict" for each source file. */
     "resolveJsonModule": true
   },
-  "include": ["lib"],
+  "include": ["lib", "types"],
 }

types/rules/jsx-no-literals.d.ts

@@ -0,0 +1,50 @@
+type RawElementConfig = {
+  noStrings?: boolean;
+  allowedStrings?: string[];
+  ignoreProps?: boolean;
+  noAttributeStrings?: boolean;
+};
+
+type RawOverrideConfig = {
+  allowElement?: boolean;
+  applyToNestedElements?: boolean;
+};
+
+interface RawElementOverrides {
+  elementOverrides?: Record<string, RawOverrideConfig>;
+}
+
+export type RawConfig = RawElementConfig & RawElementOverrides;
+
+interface ElementConfigType {
+  type: 'element';
+}
+
+interface ElementConfigProperties {
+  noStrings: boolean;
+  allowedStrings: Set<string>;
+  ignoreProps: boolean;
+  noAttributeStrings: boolean;
+}
+
+interface OverrideConfigProperties {
+  type: 'override';
+  name: string;
+  allowElement: boolean;
+  applyToNestedElements: boolean;
+}
+
+export type ElementConfig = {
+  type: 'element';
+} & ElementConfigProperties;
+
+export type OverrideConfig = OverrideConfigProperties & ElementConfigProperties;
+
+interface ElementOverrides {
+  elementOverrides: Record<string, OverrideConfig>;
+}
+
+export type Config = ElementConfig & ElementOverrides;
+
+export type ResolvedConfig = Config | OverrideConfig;
+