gt 2.14.35 → 2.14.36

package/dist/react/jsx/wrapJsx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapJsx.js","names":[],"sources":["../../../src/react/jsx/wrapJsx.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { isStaticExpression, isStaticValue } from './evaluateJsx.js';\nimport { ImportItem } from './utils/parseAst.js';\nimport { warnTernarySync } from '../../console/index.js';\n/**\n * Recursively wraps a JSX element with a <T> component and unique id\n * @param node - The JSX element to wrap\n * @param updates - The updates array\n * @param errors - The errors array\n * @param file - The file name\n * @param options - Optional component names for T and Var\n */\nexport interface WrapResult {\n  node: t.JSXElement | t.JSXFragment;\n  // Whether the node has meaningful content (aka, whether the node should be wrapped in a T)\n  hasMeaningfulContent: boolean;\n  // Whether the node has already been wrapped in a T\n  wrappedInT: boolean;\n}\n\nfunction wrapJsxExpression(\n  node: t.JSXExpressionContainer,\n  options: {\n    createIds: boolean;\n    TComponent?: string;\n    VarComponent?: string;\n    idPrefix: string;\n    idCount: number;\n    usedImports: ImportItem[];\n    modified: boolean;\n    warnings: string[];\n    file: string;\n  },\n  isMeaningful: (node: t.Node) => boolean,\n  mark: boolean\n): {\n  node: t.JSXElement | t.JSXExpressionContainer;\n  hasMeaningfulContent: boolean;\n  wrappedInT: boolean;\n} {\n  const expression = t.isParenthesizedExpression(node.expression)\n    ? node.expression.expression\n    : node.expression;\n\n  // Ignore template literals containing quasis - they should not be counted as meaningful\n  if (t.isTemplateLiteral(expression) && expression.expressions.length > 0) {\n    return {\n      node,\n      hasMeaningfulContent: false,\n      wrappedInT: false,\n    };\n  }\n\n  // Handle both JSX Elements and Fragments\n  if (\n    t.isJSXElement(expression) ||\n    t.isJSXFragment(expression) ||\n    t.isStringLiteral(expression) ||\n    t.isJSXText(expression) ||\n    t.isTemplateLiteral(expression)\n  ) {\n    if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {\n      const result = wrapJsxElement(expression, options, isMeaningful, mark);\n      // re-wrap the result in a JSXExpressionContainer\n      if (t.isParenthesizedExpression(node.expression)) {\n        node.expression.expression = result.node;\n      } else {\n        node.expression = result.node;\n      }\n      return {\n        node,\n        hasMeaningfulContent: result.hasMeaningfulContent,\n        wrappedInT: result.wrappedInT,\n      };\n    }\n    return {\n      node,\n      hasMeaningfulContent: isMeaningful(expression),\n      wrappedInT: false,\n    };\n  }\n  // Handle conditional expressions (ternary)\n  else if (t.isConditionalExpression(expression)) {\n    const consequent = t.isParenthesizedExpression(expression.consequent)\n      ? expression.consequent.expression\n      : expression.consequent;\n    const alternate = t.isParenthesizedExpression(expression.alternate)\n      ? expression.alternate.expression\n      : expression.alternate;\n\n    // Handle consequent\n    if (t.isJSXElement(consequent) || t.isJSXFragment(consequent)) {\n      const result = handleJsxElement(consequent, options, isMeaningful);\n\n      // Re-insert into parenthesized expression if necessary\n      if (t.isParenthesizedExpression(expression.consequent)) {\n        expression.consequent.expression = result.node;\n      } else {\n        expression.consequent = result.node;\n      }\n\n      // Warn about ternary (should use branch instead)\n      if (result.wrappedInT && !mark) {\n        options.warnings.push(\n          warnTernarySync(\n            options.file,\n            `${consequent.loc?.start?.line}:${consequent.loc?.start?.column}`\n          )\n        );\n      }\n    } else if (\n      t.isConditionalExpression(consequent) ||\n      t.isLogicalExpression(consequent)\n    ) {\n      // Recursively handle nested ternary in consequent\n      const consequentResult = wrapJsxExpression(\n        t.jsxExpressionContainer(consequent),\n        options,\n        isMeaningful,\n        mark\n      );\n      if (\n        t.isJSXExpressionContainer(consequentResult.node) &&\n        t.isExpression(consequentResult.node.expression)\n      ) {\n        expression.consequent = consequentResult.node.expression;\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.consequent)) {\n          expression.consequent.expression = consequentResult.node.expression;\n        } else {\n          expression.consequent = consequentResult.node.expression;\n        }\n      }\n    } else if (\n      t.isTemplateLiteral(consequent) &&\n      consequent.expressions.length > 0\n    ) {\n      // Ignore template literals in consequent with expressions (${}), don't wrap them\n      // Do nothing\n    } else {\n      if (isStaticValue(consequent) && isMeaningful(consequent)) {\n        const wrapped = wrapExpressionWithT(consequent, options, false);\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.consequent)) {\n          expression.consequent.expression = wrapped;\n        } else {\n          expression.consequent = wrapped;\n        }\n      }\n    }\n\n    // Handle alternate\n    if (t.isJSXElement(alternate) || t.isJSXFragment(alternate)) {\n      const result = handleJsxElement(alternate, options, isMeaningful);\n\n      // Re-insert into parenthesized expression if necessary\n      if (t.isParenthesizedExpression(expression.alternate)) {\n        expression.alternate.expression = result.node;\n      } else {\n        expression.alternate = result.node;\n      }\n    } else if (\n      t.isConditionalExpression(alternate) ||\n      t.isLogicalExpression(alternate)\n    ) {\n      // Recursively handle nested ternary in alternate\n      const alternateResult = wrapJsxExpression(\n        t.jsxExpressionContainer(alternate),\n        options,\n        isMeaningful,\n        mark\n      );\n      if (\n        t.isJSXExpressionContainer(alternateResult.node) &&\n        t.isExpression(alternateResult.node.expression)\n      ) {\n        expression.alternate = alternateResult.node.expression;\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.alternate)) {\n          expression.alternate.expression = alternateResult.node.expression;\n        } else {\n          expression.alternate = alternateResult.node.expression;\n        }\n      }\n    } else if (\n      t.isTemplateLiteral(alternate) &&\n      alternate.expressions.length > 0\n    ) {\n      // Ignore template literals in alternate with expressions (${}), don't wrap them\n      // Do nothing\n    } else {\n      if (isStaticValue(alternate) && isMeaningful(alternate)) {\n        const wrapped = wrapExpressionWithT(alternate, options, false);\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.alternate)) {\n          expression.alternate.expression = wrapped;\n        } else {\n          expression.alternate = wrapped;\n        }\n      }\n    }\n  }\n  // Handle logical expressions (&& and ||)\n  else if (t.isLogicalExpression(expression)) {\n    const left = t.isParenthesizedExpression(expression.left)\n      ? expression.left.expression\n      : expression.left;\n    const right = t.isParenthesizedExpression(expression.right)\n      ? expression.right.expression\n      : expression.right;\n\n    if (t.isJSXElement(left) || t.isJSXFragment(left)) {\n      const result = handleJsxElement(left, options, isMeaningful);\n\n      // Re-insert into parenthesized expression if necessary\n      if (t.isParenthesizedExpression(expression.left)) {\n        expression.left.expression = result.node;\n      } else {\n        expression.left = result.node;\n      }\n    } else if (t.isLogicalExpression(left) || t.isConditionalExpression(left)) {\n      // Recursively handle nested logical expressions\n      const leftResult = wrapJsxExpression(\n        t.jsxExpressionContainer(left),\n        options,\n        isMeaningful,\n        mark\n      );\n      if (\n        t.isJSXExpressionContainer(leftResult.node) &&\n        t.isExpression(leftResult.node.expression)\n      ) {\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.left)) {\n          expression.left.expression = leftResult.node.expression;\n        } else {\n          expression.left = leftResult.node.expression;\n        }\n      }\n    } else if (t.isTemplateLiteral(left) && left.expressions.length > 0) {\n      // Ignore template literals with expressions (${}) in left side of logical expression\n      // Do nothing - don't wrap them\n    } else {\n      if (\n        isStaticValue(left) &&\n        isMeaningful(left) &&\n        expression.operator !== '&&'\n      ) {\n        const wrapped = wrapExpressionWithT(left, options, false);\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.left)) {\n          expression.left.expression = wrapped;\n        } else {\n          expression.left = wrapped;\n        }\n      }\n    }\n\n    if (t.isJSXElement(right) || t.isJSXFragment(right)) {\n      const result = handleJsxElement(right, options, isMeaningful);\n\n      // Re-insert into parenthesized expression if necessary\n      if (t.isParenthesizedExpression(expression.right)) {\n        expression.right.expression = result.node;\n      } else {\n        expression.right = result.node;\n      }\n    } else if (\n      t.isLogicalExpression(right) ||\n      t.isConditionalExpression(right)\n    ) {\n      // Recursively handle nested logical expressions\n      const rightResult = wrapJsxExpression(\n        t.jsxExpressionContainer(right),\n        options,\n        isMeaningful,\n        mark\n      );\n      if (\n        t.isJSXExpressionContainer(rightResult.node) &&\n        t.isExpression(rightResult.node.expression)\n      ) {\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.right)) {\n          expression.right.expression = rightResult.node.expression;\n        } else {\n          expression.right = rightResult.node.expression;\n        }\n      }\n    } else if (t.isTemplateLiteral(right) && right.expressions.length > 0) {\n      // Ignore template literals with expressions (${}) in right side of logical expression\n      // Do nothing - don't wrap them\n    } else {\n      if (\n        isStaticValue(right) &&\n        isMeaningful(right) &&\n        expression.operator !== '||'\n      ) {\n        const wrapped = wrapExpressionWithT(right, options, false);\n        // Re-insert into parenthesized expression if necessary\n        if (t.isParenthesizedExpression(expression.right)) {\n          expression.right.expression = wrapped;\n        } else {\n          expression.right = wrapped;\n        }\n      }\n    }\n  }\n  const staticCheck = isStaticExpression(expression);\n  // If the expression is not derivable or if it's already wrapped in T,\n  // wrap with Var\n  if (!staticCheck.isStatic) {\n    return {\n      node: wrapWithVar(node, options, mark),\n      hasMeaningfulContent: false,\n      wrappedInT: false,\n    };\n  }\n\n  // If it's a derivable expression, check if it's meaningful\n  return {\n    node,\n    hasMeaningfulContent: false,\n    wrappedInT: false,\n  };\n}\n\n/**\n * Recursively traverse a JSX element and wrap variables with a <Var> component\n * @param node - The JSX element to wrap\n * @param options - Optional component names for T and Var\n * @param isMeaningful - A function to determine if a node is meaningful\n * @returns The wrapped JSX element\n */\nexport function wrapJsxElement(\n  node: t.JSXElement | t.JSXFragment,\n  options: {\n    createIds: boolean;\n    TComponent?: string;\n    VarComponent?: string;\n    idPrefix: string;\n    idCount: number;\n    usedImports: ImportItem[];\n    modified: boolean;\n    warnings: string[];\n    file: string;\n  },\n  isMeaningful: (node: t.Node) => boolean,\n  mark: boolean\n): WrapResult {\n  const TComponentName = options.TComponent || 'T';\n  const VarComponentName = options.VarComponent || 'Var';\n\n  // Handle both JSX Elements and Fragments\n  if (t.isJSXElement(node) || t.isJSXFragment(node)) {\n    // For elements, check if it's already a T or Var component\n    if (t.isJSXElement(node)) {\n      const name = node.openingElement.name;\n      if (\n        t.isJSXIdentifier(name) &&\n        (name.name === TComponentName || name.name === VarComponentName)\n      ) {\n        return {\n          node,\n          hasMeaningfulContent: false,\n          wrappedInT: name.name === TComponentName,\n        };\n      }\n    }\n\n    // Process children recursively (DFS postorder)\n    let hasMeaningfulContent = false;\n    let wrappedInT = false;\n    const processedChildren = node.children.map((child) => {\n      if (t.isJSXElement(child) || t.isJSXFragment(child)) {\n        const result = wrapJsxElement(child, options, isMeaningful, mark);\n        hasMeaningfulContent =\n          hasMeaningfulContent || result.hasMeaningfulContent;\n        wrappedInT = wrappedInT || result.wrappedInT;\n        return result.node;\n      }\n      if (t.isJSXExpressionContainer(child)) {\n        const result = wrapJsxExpression(child, options, isMeaningful, mark);\n        wrappedInT = wrappedInT || result.wrappedInT;\n        hasMeaningfulContent =\n          hasMeaningfulContent || result.hasMeaningfulContent;\n\n        // Expressions are never meaningful because they will either:\n        // 1. be sub-wrapped in a T (if they contain meaningful content)\n        // 2. be wrapped in a Var (if they are not marked as derivable)\n        return result.node;\n      }\n      const isMeaningfulVal = isMeaningful(child);\n      if (isMeaningfulVal) {\n        hasMeaningfulContent = true;\n      }\n      return child;\n    });\n\n    node.children = processedChildren;\n    return {\n      node,\n      hasMeaningfulContent: hasMeaningfulContent,\n      wrappedInT: wrappedInT,\n    };\n  }\n  // For any other node types, return as-is\n  return {\n    node,\n    hasMeaningfulContent: false,\n    wrappedInT: false,\n  };\n}\n\n/**\n * Wraps a JSX element with a <T> component and unique id\n * @param rootNode - The JSX element to wrap\n * @param options - Optional component names for T and Var\n * @param isMeaningful - A function to determine if a node is meaningful\n * @returns The wrapped JSX element\n */\nexport function handleJsxElement(\n  rootNode: t.JSXElement | t.JSXFragment,\n  options: {\n    createIds: boolean;\n    usedImports: ImportItem[];\n    TComponent?: string;\n    VarComponent?: string;\n    idPrefix: string;\n    idCount: number;\n    modified: boolean;\n    warnings: string[];\n    file: string;\n  },\n  isMeaningful: (node: t.Node) => boolean\n): WrapResult {\n  const result = wrapJsxElement(rootNode, options, isMeaningful, true);\n\n  // Only wrap with T at the root level if there's meaningful content\n  if (result.hasMeaningfulContent) {\n    const output = wrapJsxElement(result.node, options, isMeaningful, false);\n    const node = wrapWithT(output.node, options, false);\n    return {\n      node,\n      hasMeaningfulContent: true,\n      wrappedInT: true,\n    };\n  }\n\n  return {\n    node: result.node,\n    hasMeaningfulContent: false,\n    wrappedInT: result.wrappedInT,\n  };\n}\n\nfunction wrapWithT(\n  node: t.JSXElement | t.JSXFragment,\n  options: {\n    createIds: boolean;\n    TComponent?: string;\n    VarComponent?: string;\n    idPrefix: string;\n    idCount: number;\n    usedImports: ImportItem[];\n    modified: boolean;\n    file: string;\n    warnings: string[];\n  },\n  mark: boolean\n) {\n  if (mark) {\n    return node;\n  }\n  const TComponentName = options.TComponent || 'T';\n  const uniqueId = `${options.idPrefix}.${options.idCount}`;\n  options.modified = true;\n  options.idCount++;\n  if (!options.usedImports.includes(TComponentName)) {\n    options.usedImports.push(TComponentName);\n  }\n  if (options.createIds) {\n    return t.jsxElement(\n      t.jsxOpeningElement(\n        t.jsxIdentifier(TComponentName),\n        [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))],\n        false\n      ),\n      t.jsxClosingElement(t.jsxIdentifier(TComponentName)),\n      [node],\n      false\n    );\n  }\n  return t.jsxElement(\n    t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false),\n    t.jsxClosingElement(t.jsxIdentifier(TComponentName)),\n    [node],\n    false\n  );\n}\n\nfunction wrapExpressionWithT(\n  node: t.Expression,\n  options: {\n    createIds: boolean;\n    TComponent?: string;\n    VarComponent?: string;\n    idPrefix: string;\n    idCount: number;\n    usedImports: ImportItem[];\n    modified: boolean;\n    file: string;\n    warnings: string[];\n  },\n  mark: boolean\n) {\n  if (mark) {\n    return node;\n  }\n  const TComponentName = options.TComponent || 'T';\n  const uniqueId = `${options.idPrefix}.${options.idCount}`;\n  options.modified = true;\n  options.idCount++;\n  if (!options.usedImports.includes(TComponentName)) {\n    options.usedImports.push(TComponentName);\n  }\n  if (options.createIds) {\n    return t.jsxElement(\n      t.jsxOpeningElement(\n        t.jsxIdentifier(TComponentName),\n        [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))],\n        false\n      ),\n      t.jsxClosingElement(t.jsxIdentifier(TComponentName)),\n      [t.jsxExpressionContainer(node)],\n      false\n    );\n  }\n  return t.jsxElement(\n    t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false),\n    t.jsxClosingElement(t.jsxIdentifier(TComponentName)),\n    [t.jsxExpressionContainer(node)],\n    false\n  );\n}\n\nfunction wrapWithVar(\n  node: t.JSXElement | t.JSXExpressionContainer,\n  options: {\n    TComponent?: string;\n    VarComponent?: string;\n    usedImports: ImportItem[];\n    modified: boolean;\n    file: string;\n    warnings: string[];\n  },\n  mark: boolean\n) {\n  if (mark) {\n    return node;\n  }\n  const VarComponentName = options.VarComponent || 'Var';\n  options.modified = true;\n  if (!options.usedImports.includes(VarComponentName)) {\n    options.usedImports.push(VarComponentName);\n  }\n  return t.jsxElement(\n    t.jsxOpeningElement(t.jsxIdentifier(VarComponentName), [], false),\n    t.jsxClosingElement(t.jsxIdentifier(VarComponentName)),\n    [node],\n    false\n  );\n}\n"],"mappings":"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"}

package/dist/react/parse/addVitePlugin/index.js

@@ -1,41 +1,47 @@
-import findFilepath from '../../../fs/findFilepath.js';
-import { logger } from '../../../console/logger.js';
-import { installCompiler } from './installCompiler.js';
-import { updateViteConfig } from './updateViteConfig.js';
-import { exitSync } from '../../../console/logging.js';
-const VITE_CONFIG_PATH_BASE = './vite.config.';
+import { logger } from "../../../console/logger.js";
+import { exitSync } from "../../../console/logging.js";
+import findFilepath from "../../../fs/findFilepath.js";
+import { installCompiler } from "./installCompiler.js";
+import { updateViteConfig } from "./updateViteConfig.js";
+//#region src/react/parse/addVitePlugin/index.ts
+const VITE_CONFIG_PATH_BASE = "./vite.config.";
 /**
- * Adds the gt compiler plugin to the vite config file
- */
-export async function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }) {
-    // Resolve file path
-    const viteConfigPath = findFilepath([
-        VITE_CONFIG_PATH_BASE + 'js',
-        VITE_CONFIG_PATH_BASE + 'ts',
-        VITE_CONFIG_PATH_BASE + 'mjs',
-        VITE_CONFIG_PATH_BASE + 'mts',
-        VITE_CONFIG_PATH_BASE + 'cjs',
-        VITE_CONFIG_PATH_BASE + 'cts',
-    ]);
-    if (!viteConfigPath) {
-        logger.error(`No ${VITE_CONFIG_PATH_BASE}[js|ts|mjs|mts|cjs|cts] file found. Add the @generaltranslation/compiler plugin to your vite configuration file:
+* Adds the gt compiler plugin to the vite config file
+*/
+async function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson }) {
+	const viteConfigPath = findFilepath([
+		VITE_CONFIG_PATH_BASE + "js",
+		VITE_CONFIG_PATH_BASE + "ts",
+		VITE_CONFIG_PATH_BASE + "mjs",
+		VITE_CONFIG_PATH_BASE + "mts",
+		VITE_CONFIG_PATH_BASE + "cjs",
+		VITE_CONFIG_PATH_BASE + "cts"
+	]);
+	if (!viteConfigPath) {
+		logger.error(`No ${VITE_CONFIG_PATH_BASE}[js|ts|mjs|mts|cjs|cts] file found. Add the @generaltranslation/compiler plugin to your vite configuration file:
       import { vite as gtCompiler } from '@generaltranslation/compiler';
       export default defineConfig({
         plugins: [gtCompiler()],
       });
       `);
-        exitSync(1);
-    }
-    // Install @generaltranslation/compiler if not installed
-    await installCompiler({ packageJson });
-    // Update the config file
-    await updateViteConfig({
-        errors,
-        warnings,
-        filesUpdated,
-        viteConfigPath,
-        packageJson,
-        tsconfigJson,
-    });
-    return { errors, warnings, filesUpdated };
+		exitSync(1);
+	}
+	await installCompiler({ packageJson });
+	await updateViteConfig({
+		errors,
+		warnings,
+		filesUpdated,
+		viteConfigPath,
+		packageJson,
+		tsconfigJson
+	});
+	return {
+		errors,
+		warnings,
+		filesUpdated
+	};
 }
+//#endregion
+export { addVitePlugin };
+
+//# sourceMappingURL=index.js.map

package/dist/react/parse/addVitePlugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/react/parse/addVitePlugin/index.ts"],"sourcesContent":["import findFilepath from '../../../fs/findFilepath.js';\nimport { logger } from '../../../console/logger.js';\nimport { installCompiler } from './installCompiler.js';\nimport { updateViteConfig } from './updateViteConfig.js';\nimport { exitSync } from '../../../console/logging.js';\n\nconst VITE_CONFIG_PATH_BASE = './vite.config.';\n/**\n * Adds the gt compiler plugin to the vite config file\n */\nexport async function addVitePlugin({\n  errors,\n  warnings,\n  filesUpdated,\n  packageJson,\n  tsconfigJson,\n}: {\n  errors: string[];\n  warnings: string[];\n  filesUpdated: string[];\n  packageJson?: {\n    type?: string;\n    dependencies?: Record<string, string>;\n    devDependencies?: Record<string, string>;\n  };\n  tsconfigJson?: { compilerOptions?: { module?: string } };\n}) {\n  // Resolve file path\n  const viteConfigPath = findFilepath([\n    VITE_CONFIG_PATH_BASE + 'js',\n    VITE_CONFIG_PATH_BASE + 'ts',\n    VITE_CONFIG_PATH_BASE + 'mjs',\n    VITE_CONFIG_PATH_BASE + 'mts',\n    VITE_CONFIG_PATH_BASE + 'cjs',\n    VITE_CONFIG_PATH_BASE + 'cts',\n  ]);\n  if (!viteConfigPath) {\n    logger.error(\n      `No ${VITE_CONFIG_PATH_BASE}[js|ts|mjs|mts|cjs|cts] file found. Add the @generaltranslation/compiler plugin to your vite configuration file:\n      import { vite as gtCompiler } from '@generaltranslation/compiler';\n      export default defineConfig({\n        plugins: [gtCompiler()],\n      });\n      `\n    );\n    exitSync(1);\n  }\n\n  // Install @generaltranslation/compiler if not installed\n  await installCompiler({ packageJson });\n\n  // Update the config file\n  await updateViteConfig({\n    errors,\n    warnings,\n    filesUpdated,\n    viteConfigPath,\n    packageJson,\n    tsconfigJson,\n  });\n\n  return { errors, warnings, filesUpdated };\n}\n"],"mappings":";;;;;;AAMA,MAAM,wBAAwB;;;;AAI9B,eAAsB,cAAc,EAClC,QACA,UACA,cACA,aACA,gBAWC;CAED,MAAM,iBAAiB,aAAa;EAClC,wBAAwB;EACxB,wBAAwB;EACxB,wBAAwB;EACxB,wBAAwB;EACxB,wBAAwB;EACxB,wBAAwB;EACzB,CAAC;AACF,KAAI,CAAC,gBAAgB;AACnB,SAAO,MACL,MAAM,sBAAsB;;;;;QAM7B;AACD,WAAS,EAAE;;AAIb,OAAM,gBAAgB,EAAE,aAAa,CAAC;AAGtC,OAAM,iBAAiB;EACrB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;AAEF,QAAO;EAAE;EAAQ;EAAU;EAAc"}

package/dist/react/parse/addVitePlugin/installCompiler.js

@@ -1,22 +1,20 @@
-import { logger } from '../../../console/logger.js';
-import { installPackage } from '../../../utils/installPackage.js';
-import { isPackageInstalled } from '../../../utils/packageJson.js';
-import { getPackageManager } from '../../../utils/packageManager.js';
-import chalk from 'chalk';
+import { logger } from "../../../console/logger.js";
+import { isPackageInstalled } from "../../../utils/packageJson.js";
+import { getPackageManager } from "../../../utils/packageManager.js";
+import { installPackage } from "../../../utils/installPackage.js";
+import chalk from "chalk";
+//#region src/react/parse/addVitePlugin/installCompiler.ts
 /**
- * Installs @generaltranslation/compiler if not installed
- */
-export async function installCompiler({ packageJson, }) {
-    // Check if installed
-    if (isPackageInstalled('@generaltranslation/compiler', packageJson || {})) {
-        return;
-    }
-    // Animation
-    const spinner = logger.createSpinner();
-    spinner.start(`Installing @generaltranslation/compiler...`);
-    // Install
-    const packageManager = await getPackageManager();
-    await installPackage('@generaltranslation/compiler', packageManager, true);
-    // Animation
-    spinner.stop(chalk.green('Installed @generaltranslation/compiler.'));
+* Installs @generaltranslation/compiler if not installed
+*/
+async function installCompiler({ packageJson }) {
+	if (isPackageInstalled("@generaltranslation/compiler", packageJson || {})) return;
+	const spinner = logger.createSpinner();
+	spinner.start(`Installing @generaltranslation/compiler...`);
+	await installPackage("@generaltranslation/compiler", await getPackageManager(), true);
+	spinner.stop(chalk.green("Installed @generaltranslation/compiler."));
 }
+//#endregion
+export { installCompiler };
+
+//# sourceMappingURL=installCompiler.js.map

package/dist/react/parse/addVitePlugin/installCompiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"installCompiler.js","names":[],"sources":["../../../../src/react/parse/addVitePlugin/installCompiler.ts"],"sourcesContent":["import { logger } from '../../../console/logger.js';\nimport { installPackage } from '../../../utils/installPackage.js';\nimport { isPackageInstalled } from '../../../utils/packageJson.js';\nimport { getPackageManager } from '../../../utils/packageManager.js';\nimport chalk from 'chalk';\n\n/**\n * Installs @generaltranslation/compiler if not installed\n */\nexport async function installCompiler({\n  packageJson,\n}: {\n  packageJson?: { type?: string };\n}) {\n  // Check if installed\n  if (isPackageInstalled('@generaltranslation/compiler', packageJson || {})) {\n    return;\n  }\n\n  // Animation\n  const spinner = logger.createSpinner();\n  spinner.start(`Installing @generaltranslation/compiler...`);\n\n  // Install\n  const packageManager = await getPackageManager();\n  await installPackage('@generaltranslation/compiler', packageManager, true);\n\n  // Animation\n  spinner.stop(chalk.green('Installed @generaltranslation/compiler.'));\n}\n"],"mappings":";;;;;;;;;AASA,eAAsB,gBAAgB,EACpC,eAGC;AAED,KAAI,mBAAmB,gCAAgC,eAAe,EAAE,CAAC,CACvE;CAIF,MAAM,UAAU,OAAO,eAAe;AACtC,SAAQ,MAAM,6CAA6C;AAI3D,OAAM,eAAe,gCAAgC,MADxB,mBAAmB,EACqB,KAAK;AAG1E,SAAQ,KAAK,MAAM,MAAM,0CAA0C,CAAC"}

package/dist/react/parse/addVitePlugin/updateViteConfig.js

@@ -1,120 +1,116 @@
-import { logger } from '../../../console/logger.js';
-import fs from 'node:fs';
-import chalk from 'chalk';
-import generateModule from '@babel/generator';
-import { parse } from '@babel/parser';
-import { needsCJS } from '../../../utils/parse/needsCJS.js';
-import { addCompilerImport } from './utils/addCompilerImport.js';
-import { checkCompilerImport } from './utils/checkCompilerImport.js';
-import { checkPluginInvocation } from './utils/checkPluginInvocation.js';
-import { addPluginInvocation } from './utils/addPluginInvocation.js';
-import { exitSync } from '../../../console/logging.js';
-// Handle CommonJS/ESM interop
+import { logger } from "../../../console/logger.js";
+import { exitSync } from "../../../console/logging.js";
+import { needsCJS } from "../../../utils/parse/needsCJS.js";
+import { addCompilerImport } from "./utils/addCompilerImport.js";
+import { checkCompilerImport } from "./utils/checkCompilerImport.js";
+import { checkPluginInvocation } from "./utils/checkPluginInvocation.js";
+import { addPluginInvocation } from "./utils/addPluginInvocation.js";
+import chalk from "chalk";
+import fs from "node:fs";
+import { parse } from "@babel/parser";
+import generateModule from "@babel/generator";
+//#region src/react/parse/addVitePlugin/updateViteConfig.ts
 const generate = generateModule.default || generateModule;
 /**
- * - Reads the vite config file
- * - Updates the ast to add the gt compiler plugin
- * - Writes the file back to the filesystem
- */
-export async function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }) {
-    // Animation
-    const spinner = logger.createSpinner();
-    spinner.start(`Adding gt compiler plugin to ${viteConfigPath}...`);
-    // Read the file
-    let code;
-    try {
-        code = await fs.promises.readFile(viteConfigPath, 'utf8');
-    }
-    catch (error) {
-        logger.error(`Error: Failed to read ${viteConfigPath}: ${error}`);
-        exitSync(1);
-    }
-    // Update the ast
-    let updatedCode, success;
-    try {
-        ({ updatedCode, success } = await updateViteConfigAst({
-            code,
-            errors,
-            warnings,
-            viteConfigPath,
-            packageJson,
-            tsconfigJson,
-        }));
-    }
-    catch (error) {
-        logger.error(`Error: Failed to update ${viteConfigPath}: ${error}`);
-        exitSync(1);
-    }
-    // Write the file
-    try {
-        await fs.promises.writeFile(viteConfigPath, updatedCode);
-        filesUpdated.push(viteConfigPath);
-    }
-    catch (error) {
-        logger.error(`Error: Failed to write ${viteConfigPath}: ${error}`);
-        exitSync(1);
-    }
-    // Animation
-    spinner.stop(success
-        ? chalk.green(`Success! Added gt compiler plugin to ${viteConfigPath}`)
-        : chalk.red(`Failed to add gt compiler plugin to ${viteConfigPath}. Continuing setup...`));
+* - Reads the vite config file
+* - Updates the ast to add the gt compiler plugin
+* - Writes the file back to the filesystem
+*/
+async function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson }) {
+	const spinner = logger.createSpinner();
+	spinner.start(`Adding gt compiler plugin to ${viteConfigPath}...`);
+	let code;
+	try {
+		code = await fs.promises.readFile(viteConfigPath, "utf8");
+	} catch (error) {
+		logger.error(`Error: Failed to read ${viteConfigPath}: ${error}`);
+		exitSync(1);
+	}
+	let updatedCode, success;
+	try {
+		({updatedCode, success} = await updateViteConfigAst({
+			code,
+			errors,
+			warnings,
+			viteConfigPath,
+			packageJson,
+			tsconfigJson
+		}));
+	} catch (error) {
+		logger.error(`Error: Failed to update ${viteConfigPath}: ${error}`);
+		exitSync(1);
+	}
+	try {
+		await fs.promises.writeFile(viteConfigPath, updatedCode);
+		filesUpdated.push(viteConfigPath);
+	} catch (error) {
+		logger.error(`Error: Failed to write ${viteConfigPath}: ${error}`);
+		exitSync(1);
+	}
+	spinner.stop(success ? chalk.green(`Success! Added gt compiler plugin to ${viteConfigPath}`) : chalk.red(`Failed to add gt compiler plugin to ${viteConfigPath}. Continuing setup...`));
 }
 /**
- * Orchestrates AST manipulation
- * @param code - The code to update
- * @param errors - The errors to update
- * @param warnings - The warnings to update
- * @param viteConfigPath - The path to the vite config file
- * @param packageJson - The package.json file
- * @param tsconfigJson - The tsconfig.json file
- * @returns
- */
-async function updateViteConfigAst({ code, warnings, viteConfigPath, packageJson, tsconfigJson, }) {
-    // Parse the code
-    const ast = parse(code, {
-        sourceType: 'module',
-        plugins: ['jsx', 'typescript'],
-    });
-    // Get cjs or esm
-    const cjsEnabled = needsCJS({
-        ast,
-        warnings,
-        filepath: viteConfigPath,
-        packageJson,
-        tsconfigJson,
-    });
-    // Check if the compiler import is already present
-    let { hasCompilerImport, alias, namespaces } = checkCompilerImport(ast);
-    // Add the import declaration
-    if (!hasCompilerImport) {
-        addCompilerImport({ ast, cjsEnabled });
-        hasCompilerImport = true;
-        alias = 'gtCompiler';
-        namespaces = [];
-    }
-    // Check if plugin is already present
-    let pluginAlreadyPresent = false;
-    if (hasCompilerImport) {
-        pluginAlreadyPresent = checkPluginInvocation({ ast, alias, namespaces });
-    }
-    // Insert plugin invocation
-    let success = false;
-    if (!pluginAlreadyPresent) {
-        success = addPluginInvocation({ ast, alias, namespaces });
-        if (!success) {
-            warnings.push(`Failed to add gt compiler plugin to ${viteConfigPath}. Add the plugin manually:
+* Orchestrates AST manipulation
+* @param code - The code to update
+* @param errors - The errors to update
+* @param warnings - The warnings to update
+* @param viteConfigPath - The path to the vite config file
+* @param packageJson - The package.json file
+* @param tsconfigJson - The tsconfig.json file
+* @returns
+*/
+async function updateViteConfigAst({ code, warnings, viteConfigPath, packageJson, tsconfigJson }) {
+	const ast = parse(code, {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"]
+	});
+	const cjsEnabled = needsCJS({
+		ast,
+		warnings,
+		filepath: viteConfigPath,
+		packageJson,
+		tsconfigJson
+	});
+	let { hasCompilerImport, alias, namespaces } = checkCompilerImport(ast);
+	if (!hasCompilerImport) {
+		addCompilerImport({
+			ast,
+			cjsEnabled
+		});
+		hasCompilerImport = true;
+		alias = "gtCompiler";
+		namespaces = [];
+	}
+	let pluginAlreadyPresent = false;
+	if (hasCompilerImport) pluginAlreadyPresent = checkPluginInvocation({
+		ast,
+		alias,
+		namespaces
+	});
+	let success = false;
+	if (!pluginAlreadyPresent) {
+		success = addPluginInvocation({
+			ast,
+			alias,
+			namespaces
+		});
+		if (!success) warnings.push(`Failed to add gt compiler plugin to ${viteConfigPath}. Add the plugin manually:
 import { vite as gtCompiler } from '@generaltranslation/compiler';
 export default defineConfig({
   plugins: [gtCompiler()],
 });`);
-        }
-    }
-    // Generate the modified code
-    const output = generate(ast, {
-        retainLines: true,
-        retainFunctionParens: true,
-        comments: true,
-        compact: 'auto',
-    }, code);
-    return { updatedCode: output.code, success };
+	}
+	return {
+		updatedCode: generate(ast, {
+			retainLines: true,
+			retainFunctionParens: true,
+			comments: true,
+			compact: "auto"
+		}, code).code,
+		success
+	};
 }
+//#endregion
+export { updateViteConfig };
+
+//# sourceMappingURL=updateViteConfig.js.map

package/dist/react/parse/addVitePlugin/updateViteConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateViteConfig.js","names":[],"sources":["../../../../src/react/parse/addVitePlugin/updateViteConfig.ts"],"sourcesContent":["import { logger } from '../../../console/logger.js';\nimport fs from 'node:fs';\nimport chalk from 'chalk';\nimport generateModule from '@babel/generator';\nimport { parse } from '@babel/parser';\nimport { needsCJS } from '../../../utils/parse/needsCJS.js';\nimport { addCompilerImport } from './utils/addCompilerImport.js';\nimport { checkCompilerImport } from './utils/checkCompilerImport.js';\nimport { checkPluginInvocation } from './utils/checkPluginInvocation.js';\nimport { addPluginInvocation } from './utils/addPluginInvocation.js';\nimport { exitSync } from '../../../console/logging.js';\n\n// Handle CommonJS/ESM interop\nconst generate = generateModule.default || generateModule;\n\n/**\n * - Reads the vite config file\n * - Updates the ast to add the gt compiler plugin\n * - Writes the file back to the filesystem\n */\nexport async function updateViteConfig({\n  errors,\n  warnings,\n  filesUpdated,\n  viteConfigPath,\n  packageJson,\n  tsconfigJson,\n}: {\n  errors: string[];\n  warnings: string[];\n  filesUpdated: string[];\n  viteConfigPath: string;\n  packageJson?: { type?: string };\n  tsconfigJson?: { compilerOptions?: { module?: string } };\n}) {\n  // Animation\n  const spinner = logger.createSpinner();\n  spinner.start(`Adding gt compiler plugin to ${viteConfigPath}...`);\n\n  // Read the file\n  let code;\n  try {\n    code = await fs.promises.readFile(viteConfigPath, 'utf8');\n  } catch (error) {\n    logger.error(`Error: Failed to read ${viteConfigPath}: ${error}`);\n    exitSync(1);\n  }\n\n  // Update the ast\n  let updatedCode, success;\n  try {\n    ({ updatedCode, success } = await updateViteConfigAst({\n      code,\n      errors,\n      warnings,\n      viteConfigPath,\n      packageJson,\n      tsconfigJson,\n    }));\n  } catch (error) {\n    logger.error(`Error: Failed to update ${viteConfigPath}: ${error}`);\n    exitSync(1);\n  }\n\n  // Write the file\n  try {\n    await fs.promises.writeFile(viteConfigPath, updatedCode);\n    filesUpdated.push(viteConfigPath);\n  } catch (error) {\n    logger.error(`Error: Failed to write ${viteConfigPath}: ${error}`);\n    exitSync(1);\n  }\n\n  // Animation\n  spinner.stop(\n    success\n      ? chalk.green(`Success! Added gt compiler plugin to ${viteConfigPath}`)\n      : chalk.red(\n          `Failed to add gt compiler plugin to ${viteConfigPath}. Continuing setup...`\n        )\n  );\n}\n\n/**\n * Orchestrates AST manipulation\n * @param code - The code to update\n * @param errors - The errors to update\n * @param warnings - The warnings to update\n * @param viteConfigPath - The path to the vite config file\n * @param packageJson - The package.json file\n * @param tsconfigJson - The tsconfig.json file\n * @returns\n */\nasync function updateViteConfigAst({\n  code,\n  warnings,\n  viteConfigPath,\n  packageJson,\n  tsconfigJson,\n}: {\n  code: string;\n  errors: string[];\n  warnings: string[];\n  viteConfigPath: string;\n  packageJson?: { type?: string };\n  tsconfigJson?: { compilerOptions?: { module?: string } };\n}): Promise<{ updatedCode: string; success: boolean }> {\n  // Parse the code\n  const ast = parse(code, {\n    sourceType: 'module',\n    plugins: ['jsx', 'typescript'],\n  });\n\n  // Get cjs or esm\n  const cjsEnabled = needsCJS({\n    ast,\n    warnings,\n    filepath: viteConfigPath,\n    packageJson,\n    tsconfigJson,\n  });\n\n  // Check if the compiler import is already present\n  let { hasCompilerImport, alias, namespaces } = checkCompilerImport(ast);\n\n  // Add the import declaration\n  if (!hasCompilerImport) {\n    addCompilerImport({ ast, cjsEnabled });\n    hasCompilerImport = true;\n    alias = 'gtCompiler';\n    namespaces = [];\n  }\n\n  // Check if plugin is already present\n  let pluginAlreadyPresent = false;\n  if (hasCompilerImport) {\n    pluginAlreadyPresent = checkPluginInvocation({ ast, alias, namespaces });\n  }\n\n  // Insert plugin invocation\n  let success = false;\n  if (!pluginAlreadyPresent) {\n    success = addPluginInvocation({ ast, alias, namespaces });\n    if (!success) {\n      warnings.push(\n        `Failed to add gt compiler plugin to ${viteConfigPath}. Add the plugin manually:\nimport { vite as gtCompiler } from '@generaltranslation/compiler';\nexport default defineConfig({\n  plugins: [gtCompiler()],\n});`\n      );\n    }\n  }\n\n  // Generate the modified code\n  const output = generate(\n    ast,\n    {\n      retainLines: true,\n      retainFunctionParens: true,\n      comments: true,\n      compact: 'auto',\n    },\n    code\n  );\n\n  return { updatedCode: output.code, success };\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,WAAW,eAAe,WAAW;;;;;;AAO3C,eAAsB,iBAAiB,EACrC,QACA,UACA,cACA,gBACA,aACA,gBAQC;CAED,MAAM,UAAU,OAAO,eAAe;AACtC,SAAQ,MAAM,gCAAgC,eAAe,KAAK;CAGlE,IAAI;AACJ,KAAI;AACF,SAAO,MAAM,GAAG,SAAS,SAAS,gBAAgB,OAAO;UAClD,OAAO;AACd,SAAO,MAAM,yBAAyB,eAAe,IAAI,QAAQ;AACjE,WAAS,EAAE;;CAIb,IAAI,aAAa;AACjB,KAAI;AACF,GAAC,CAAE,aAAa,WAAY,MAAM,oBAAoB;GACpD;GACA;GACA;GACA;GACA;GACA;GACD,CAAC;UACK,OAAO;AACd,SAAO,MAAM,2BAA2B,eAAe,IAAI,QAAQ;AACnE,WAAS,EAAE;;AAIb,KAAI;AACF,QAAM,GAAG,SAAS,UAAU,gBAAgB,YAAY;AACxD,eAAa,KAAK,eAAe;UAC1B,OAAO;AACd,SAAO,MAAM,0BAA0B,eAAe,IAAI,QAAQ;AAClE,WAAS,EAAE;;AAIb,SAAQ,KACN,UACI,MAAM,MAAM,wCAAwC,iBAAiB,GACrE,MAAM,IACJ,uCAAuC,eAAe,uBACvD,CACN;;;;;;;;;;;;AAaH,eAAe,oBAAoB,EACjC,MACA,UACA,gBACA,aACA,gBAQqD;CAErD,MAAM,MAAM,MAAM,MAAM;EACtB,YAAY;EACZ,SAAS,CAAC,OAAO,aAAa;EAC/B,CAAC;CAGF,MAAM,aAAa,SAAS;EAC1B;EACA;EACA,UAAU;EACV;EACA;EACD,CAAC;CAGF,IAAI,EAAE,mBAAmB,OAAO,eAAe,oBAAoB,IAAI;AAGvE,KAAI,CAAC,mBAAmB;AACtB,oBAAkB;GAAE;GAAK;GAAY,CAAC;AACtC,sBAAoB;AACpB,UAAQ;AACR,eAAa,EAAE;;CAIjB,IAAI,uBAAuB;AAC3B,KAAI,kBACF,wBAAuB,sBAAsB;EAAE;EAAK;EAAO;EAAY,CAAC;CAI1E,IAAI,UAAU;AACd,KAAI,CAAC,sBAAsB;AACzB,YAAU,oBAAoB;GAAE;GAAK;GAAO;GAAY,CAAC;AACzD,MAAI,CAAC,QACH,UAAS,KACP,uCAAuC,eAAe;;;;KAKvD;;AAgBL,QAAO;EAAE,aAXM,SACb,KACA;GACE,aAAa;GACb,sBAAsB;GACtB,UAAU;GACV,SAAS;GACV,EACD,KAG0B,CAAC;EAAM;EAAS"}

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.js

@@ -1,34 +1,31 @@
-import * as t from '@babel/types';
+import * as t from "@babel/types";
+//#region src/react/parse/addVitePlugin/utils/addCompilerImport.ts
 /**
- * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
- */
-export function addCompilerImport({ ast, cjsEnabled, }) {
-    if (cjsEnabled) {
-        handleCjsImport(ast);
-    }
-    else {
-        handleEsmImport(ast);
-    }
+* Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
+*/
+function addCompilerImport({ ast, cjsEnabled }) {
+	if (cjsEnabled) handleCjsImport(ast);
+	else handleEsmImport(ast);
 }
 /**
- * Adds a CJS import declaration for the @generaltranslation/compiler package
- * @param ast - The ast of the file
- * const gtCompiler = require('@generaltranslation/compiler').vite;
- */
+* Adds a CJS import declaration for the @generaltranslation/compiler package
+* @param ast - The ast of the file
+* const gtCompiler = require('@generaltranslation/compiler').vite;
+*/
 function handleCjsImport(ast) {
-    const variableDeclaration = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier('gtCompiler'), t.memberExpression(t.callExpression(t.identifier('require'), [
-            t.stringLiteral('@generaltranslation/compiler'),
-        ]), t.identifier('vite'))),
-    ]);
-    ast.program.body.unshift(variableDeclaration);
+	const variableDeclaration = t.variableDeclaration("const", [t.variableDeclarator(t.identifier("gtCompiler"), t.memberExpression(t.callExpression(t.identifier("require"), [t.stringLiteral("@generaltranslation/compiler")]), t.identifier("vite")))]);
+	ast.program.body.unshift(variableDeclaration);
 }
 /**
- * Adds an ESM import declaration for the @generaltranslation/compiler package
- * @param ast - The ast of the file
- * import { vite as gtCompiler } from '@generaltranslation/compiler';
- */
+* Adds an ESM import declaration for the @generaltranslation/compiler package
+* @param ast - The ast of the file
+* import { vite as gtCompiler } from '@generaltranslation/compiler';
+*/
 function handleEsmImport(ast) {
-    const importDeclaration = t.importDeclaration([t.importSpecifier(t.identifier('gtCompiler'), t.identifier('vite'))], t.stringLiteral('@generaltranslation/compiler'));
-    ast.program.body.unshift(importDeclaration);
+	const importDeclaration = t.importDeclaration([t.importSpecifier(t.identifier("gtCompiler"), t.identifier("vite"))], t.stringLiteral("@generaltranslation/compiler"));
+	ast.program.body.unshift(importDeclaration);
 }
+//#endregion
+export { addCompilerImport };
+
+//# sourceMappingURL=addCompilerImport.js.map

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addCompilerImport.js","names":[],"sources":["../../../../../src/react/parse/addVitePlugin/utils/addCompilerImport.ts"],"sourcesContent":["import { ParseResult } from '@babel/parser';\nimport * as t from '@babel/types';\n\n/**\n * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package\n */\nexport function addCompilerImport({\n  ast,\n  cjsEnabled,\n}: {\n  ast: ParseResult<t.File>;\n  cjsEnabled: boolean;\n}) {\n  if (cjsEnabled) {\n    handleCjsImport(ast);\n  } else {\n    handleEsmImport(ast);\n  }\n}\n\n/**\n * Adds a CJS import declaration for the @generaltranslation/compiler package\n * @param ast - The ast of the file\n * const gtCompiler = require('@generaltranslation/compiler').vite;\n */\nfunction handleCjsImport(ast: ParseResult<t.File>) {\n  const variableDeclaration = t.variableDeclaration('const', [\n    t.variableDeclarator(\n      t.identifier('gtCompiler'),\n      t.memberExpression(\n        t.callExpression(t.identifier('require'), [\n          t.stringLiteral('@generaltranslation/compiler'),\n        ]),\n        t.identifier('vite')\n      )\n    ),\n  ]);\n  ast.program.body.unshift(variableDeclaration);\n}\n\n/**\n * Adds an ESM import declaration for the @generaltranslation/compiler package\n * @param ast - The ast of the file\n * import { vite as gtCompiler } from '@generaltranslation/compiler';\n */\nfunction handleEsmImport(ast: ParseResult<t.File>) {\n  const importDeclaration = t.importDeclaration(\n    [t.importSpecifier(t.identifier('gtCompiler'), t.identifier('vite'))],\n    t.stringLiteral('@generaltranslation/compiler')\n  );\n  ast.program.body.unshift(importDeclaration);\n}\n"],"mappings":";;;;;AAMA,SAAgB,kBAAkB,EAChC,KACA,cAIC;AACD,KAAI,WACF,iBAAgB,IAAI;KAEpB,iBAAgB,IAAI;;;;;;;AASxB,SAAS,gBAAgB,KAA0B;CACjD,MAAM,sBAAsB,EAAE,oBAAoB,SAAS,CACzD,EAAE,mBACA,EAAE,WAAW,aAAa,EAC1B,EAAE,iBACA,EAAE,eAAe,EAAE,WAAW,UAAU,EAAE,CACxC,EAAE,cAAc,+BAA+B,CAChD,CAAC,EACF,EAAE,WAAW,OAAO,CACrB,CACF,CACF,CAAC;AACF,KAAI,QAAQ,KAAK,QAAQ,oBAAoB;;;;;;;AAQ/C,SAAS,gBAAgB,KAA0B;CACjD,MAAM,oBAAoB,EAAE,kBAC1B,CAAC,EAAE,gBAAgB,EAAE,WAAW,aAAa,EAAE,EAAE,WAAW,OAAO,CAAC,CAAC,EACrE,EAAE,cAAc,+BAA+B,CAChD;AACD,KAAI,QAAQ,KAAK,QAAQ,kBAAkB"}

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.js

@@ -1,48 +1,34 @@
-import * as t from '@babel/types';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
+import * as t from "@babel/types";
+import traverseModule from "@babel/traverse";
+//#region src/react/parse/addVitePlugin/utils/addPluginInvocation.ts
 const traverse = traverseModule.default || traverseModule;
 /**
- * Adds the plugin invocation to the vite config file
- * Naive solution: look for an object with a plugins property only inside of a defineConfig call
- */
-export function addPluginInvocation({ ast, alias, namespaces, }) {
-    let addedPlugin = false;
-    if (namespaces.length === 0 && !alias) {
-        return false;
-    }
-    const pluginInvocation = alias
-        ? t.callExpression(t.identifier(alias), [])
-        : t.callExpression(t.memberExpression(t.identifier(namespaces[0]), t.identifier('vite')), []);
-    traverse(ast, {
-        CallExpression(path) {
-            if (!t.isIdentifier(path.node.callee, { name: 'defineConfig' }) ||
-                !path.node.arguments.length ||
-                !t.isObjectExpression(path.node.arguments[0])) {
-                return;
-            }
-            for (const property of path.node.arguments[0].properties) {
-                if (!t.isObjectProperty(property) || !isPluginsProperty(property))
-                    continue;
-                if (t.isArrayExpression(property.value)) {
-                    // Add to array: [react()] -> [react(), gtCompiler()]
-                    property.value.elements.push(pluginInvocation);
-                    addedPlugin = true;
-                }
-                else {
-                    // Spread the array: someList -> [...someList, gtCompiler()]
-                    property.value = t.arrayExpression([
-                        t.spreadElement(property.value),
-                        pluginInvocation,
-                    ]);
-                    addedPlugin = true;
-                }
-            }
-        },
-    });
-    return addedPlugin;
+* Adds the plugin invocation to the vite config file
+* Naive solution: look for an object with a plugins property only inside of a defineConfig call
+*/
+function addPluginInvocation({ ast, alias, namespaces }) {
+	let addedPlugin = false;
+	if (namespaces.length === 0 && !alias) return false;
+	const pluginInvocation = alias ? t.callExpression(t.identifier(alias), []) : t.callExpression(t.memberExpression(t.identifier(namespaces[0]), t.identifier("vite")), []);
+	traverse(ast, { CallExpression(path) {
+		if (!t.isIdentifier(path.node.callee, { name: "defineConfig" }) || !path.node.arguments.length || !t.isObjectExpression(path.node.arguments[0])) return;
+		for (const property of path.node.arguments[0].properties) {
+			if (!t.isObjectProperty(property) || !isPluginsProperty(property)) continue;
+			if (t.isArrayExpression(property.value)) {
+				property.value.elements.push(pluginInvocation);
+				addedPlugin = true;
+			} else {
+				property.value = t.arrayExpression([t.spreadElement(property.value), pluginInvocation]);
+				addedPlugin = true;
+			}
+		}
+	} });
+	return addedPlugin;
 }
 function isPluginsProperty(node) {
-    return (t.isIdentifier(node.key, { name: 'plugins' }) ||
-        t.isStringLiteral(node.key, { value: 'plugins' }));
+	return t.isIdentifier(node.key, { name: "plugins" }) || t.isStringLiteral(node.key, { value: "plugins" });
 }
+//#endregion
+export { addPluginInvocation };
+
+//# sourceMappingURL=addPluginInvocation.js.map

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addPluginInvocation.js","names":[],"sources":["../../../../../src/react/parse/addVitePlugin/utils/addPluginInvocation.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { ParseResult } from '@babel/parser';\nimport traverseModule from '@babel/traverse';\n\n// Handle CommonJS/ESM interop\nconst traverse = traverseModule.default || traverseModule;\n\n/**\n * Adds the plugin invocation to the vite config file\n * Naive solution: look for an object with a plugins property only inside of a defineConfig call\n */\nexport function addPluginInvocation({\n  ast,\n  alias,\n  namespaces,\n}: {\n  ast: ParseResult<t.File>;\n  alias: string | null;\n  namespaces: string[];\n}): boolean {\n  let addedPlugin = false;\n  if (namespaces.length === 0 && !alias) {\n    return false;\n  }\n  const pluginInvocation = alias\n    ? t.callExpression(t.identifier(alias), [])\n    : t.callExpression(\n        t.memberExpression(t.identifier(namespaces[0]), t.identifier('vite')),\n        []\n      );\n\n  traverse(ast, {\n    CallExpression(path) {\n      if (\n        !t.isIdentifier(path.node.callee, { name: 'defineConfig' }) ||\n        !path.node.arguments.length ||\n        !t.isObjectExpression(path.node.arguments[0])\n      ) {\n        return;\n      }\n      for (const property of path.node.arguments[0].properties) {\n        if (!t.isObjectProperty(property) || !isPluginsProperty(property))\n          continue;\n        if (t.isArrayExpression(property.value)) {\n          // Add to array: [react()] -> [react(), gtCompiler()]\n          property.value.elements.push(pluginInvocation);\n          addedPlugin = true;\n        } else {\n          // Spread the array: someList -> [...someList, gtCompiler()]\n          property.value = t.arrayExpression([\n            t.spreadElement(property.value as t.Expression),\n            pluginInvocation,\n          ]);\n          addedPlugin = true;\n        }\n      }\n    },\n  });\n  return addedPlugin;\n}\n\nfunction isPluginsProperty(node: t.ObjectProperty) {\n  return (\n    t.isIdentifier(node.key, { name: 'plugins' }) ||\n    t.isStringLiteral(node.key, { value: 'plugins' })\n  );\n}\n"],"mappings":";;;AAKA,MAAM,WAAW,eAAe,WAAW;;;;;AAM3C,SAAgB,oBAAoB,EAClC,KACA,OACA,cAKU;CACV,IAAI,cAAc;AAClB,KAAI,WAAW,WAAW,KAAK,CAAC,MAC9B,QAAO;CAET,MAAM,mBAAmB,QACrB,EAAE,eAAe,EAAE,WAAW,MAAM,EAAE,EAAE,CAAC,GACzC,EAAE,eACA,EAAE,iBAAiB,EAAE,WAAW,WAAW,GAAG,EAAE,EAAE,WAAW,OAAO,CAAC,EACrE,EAAE,CACH;AAEL,UAAS,KAAK,EACZ,eAAe,MAAM;AACnB,MACE,CAAC,EAAE,aAAa,KAAK,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC,IAC3D,CAAC,KAAK,KAAK,UAAU,UACrB,CAAC,EAAE,mBAAmB,KAAK,KAAK,UAAU,GAAG,CAE7C;AAEF,OAAK,MAAM,YAAY,KAAK,KAAK,UAAU,GAAG,YAAY;AACxD,OAAI,CAAC,EAAE,iBAAiB,SAAS,IAAI,CAAC,kBAAkB,SAAS,CAC/D;AACF,OAAI,EAAE,kBAAkB,SAAS,MAAM,EAAE;AAEvC,aAAS,MAAM,SAAS,KAAK,iBAAiB;AAC9C,kBAAc;UACT;AAEL,aAAS,QAAQ,EAAE,gBAAgB,CACjC,EAAE,cAAc,SAAS,MAAsB,EAC/C,iBACD,CAAC;AACF,kBAAc;;;IAIrB,CAAC;AACF,QAAO;;AAGT,SAAS,kBAAkB,MAAwB;AACjD,QACE,EAAE,aAAa,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC,IAC7C,EAAE,gBAAgB,KAAK,KAAK,EAAE,OAAO,WAAW,CAAC"}