gt 2.14.35 → 2.14.36

package/dist/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.js

@@ -1,122 +1,85 @@
-import * as t from '@babel/types';
-import { isStaticExpression } from '../../../evaluateJsx.js';
-import { warnInvalidMaxCharsSync } from '../../../../../console/index.js';
-import { warnInvalidFormatSync } from '../../../../../console/index.js';
-import { warnNonStaticExpressionSync } from '../../../../../console/index.js';
-import { GT_ATTRIBUTES_WITH_SUGAR } from '../../constants.js';
-import { containsDeriveCall } from '../derivation/containsDeriveCall.js';
-import generateModule from '@babel/generator';
-import { mapAttributeName } from '../../mapAttributeName.js';
-import pathModule from 'node:path';
-import { isNumberLiteral } from '../../isNumberLiteral.js';
-import { extractSourceCode } from '../../extractSourceCode.js';
-import { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';
-// Handle CommonJS/ESM interop
+import "../../../../../utils/constants.js";
+import { isStaticExpression } from "../../../evaluateJsx.js";
+import { GT_ATTRIBUTES_WITH_SUGAR } from "../../constants.js";
+import { warnInvalidFormatSync, warnInvalidMaxCharsSync, warnNonStaticExpressionSync } from "../../../../../console/index.js";
+import { mapAttributeName } from "../../mapAttributeName.js";
+import { isNumberLiteral } from "../../isNumberLiteral.js";
+import { containsDeriveCall } from "../derivation/containsDeriveCall.js";
+import { extractSourceCode } from "../../extractSourceCode.js";
+import path from "node:path";
+import * as t from "@babel/types";
+import generateModule from "@babel/generator";
+//#region src/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.ts
 const generate = generateModule.default || generateModule;
 /**
- * Extracts inline metadata from a string entry
- * @param metadata - The metadata record to inject the data into
- * @param entry - The string entry to extract the metadata from
- * @param output - The output to use
- * @param config - The configuration to use
- * @returns The inline metadata
- *
- * @note - this function does not automatically append the index to the id, this must be done manually in the caller.
- *
- */
-export function extractStringEntryMetadata({ options, output, config, nodeLoc, surroundingLineCount = SURROUNDING_LINE_COUNT, }) {
-    // extract filepath for entry
-    const relativeFilepath = pathModule.relative(process.cwd(), config.file);
-    // extract inline metadata
-    const inlineMetadata = extractInlineMetadata({
-        options,
-        output,
-        config,
-    });
-    // extract surrounding lines from source file
-    let sourceCode;
-    if (config.includeSourceCodeContext &&
-        nodeLoc?.start?.line &&
-        nodeLoc?.end?.line) {
-        const entry = extractSourceCode(config.file, nodeLoc.start.line, nodeLoc.end.line, surroundingLineCount);
-        if (entry && relativeFilepath) {
-            sourceCode = { [relativeFilepath]: [entry] };
-        }
-    }
-    return {
-        ...inlineMetadata,
-        filePaths: relativeFilepath ? [relativeFilepath] : undefined,
-        ...(sourceCode && { sourceCode }),
-    };
+* Extracts inline metadata from a string entry
+* @param metadata - The metadata record to inject the data into
+* @param entry - The string entry to extract the metadata from
+* @param output - The output to use
+* @param config - The configuration to use
+* @returns The inline metadata
+*
+* @note - this function does not automatically append the index to the id, this must be done manually in the caller.
+*
+*/
+function extractStringEntryMetadata({ options, output, config, nodeLoc, surroundingLineCount = 5 }) {
+	const relativeFilepath = path.relative(process.cwd(), config.file);
+	const inlineMetadata = extractInlineMetadata({
+		options,
+		output,
+		config
+	});
+	let sourceCode;
+	if (config.includeSourceCodeContext && nodeLoc?.start?.line && nodeLoc?.end?.line) {
+		const entry = extractSourceCode(config.file, nodeLoc.start.line, nodeLoc.end.line, surroundingLineCount);
+		if (entry && relativeFilepath) sourceCode = { [relativeFilepath]: [entry] };
+	}
+	return {
+		...inlineMetadata,
+		filePaths: relativeFilepath ? [relativeFilepath] : void 0,
+		...sourceCode && { sourceCode }
+	};
 }
-// ----- Helper Functions ----- //
 /**
- * Extracts inline metadata specified e.g. gt('Hello', { $context: 'greeting' })
- * @param options - The options to extract the metadata from
- * @param output - The output to use
- * @param config - The configuration to use
- * @param index - The index of the string entry
- * @returns The inline metadata
- */
-function extractInlineMetadata({ options, output, config, }) {
-    const metadata = {};
-    let contextDeriveExpr;
-    if (options && options.type === 'ObjectExpression') {
-        options.properties.forEach((prop) => {
-            if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier') {
-                const attribute = prop.key.name;
-                if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
-                    t.isExpression(prop.value)) {
-                    const result = isStaticExpression(prop.value);
-                    if (!result.isStatic) {
-                        const mappedKey = mapAttributeName(attribute);
-                        if (mappedKey === 'context' && containsDeriveCall(prop.value)) {
-                            contextDeriveExpr = prop.value;
-                        }
-                        else {
-                            output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                        }
-                    }
-                    if (result.isStatic &&
-                        result.value != null &&
-                        !config.ignoreInlineMetadata) {
-                        const mappedKey = mapAttributeName(attribute);
-                        if (mappedKey === 'maxChars') {
-                            // Handle maxChars attribute
-                            if ((typeof result.value === 'string' &&
-                                (isNaN(Number(result.value)) ||
-                                    !isNumberLiteral(prop.value))) ||
-                                !Number.isInteger(Number(result.value))) {
-                                output.errors.push(warnInvalidMaxCharsSync(config.file, generate(prop).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                            }
-                            else if (typeof result.value === 'string') {
-                                // Add the maxChars value to the metadata
-                                metadata[mappedKey] = Math.abs(Number(result.value));
-                            }
-                        }
-                        else if (mappedKey === 'format') {
-                            // Handle format attribute - validate allowed values
-                            const validFormats = ['ICU', 'STRING', 'I18NEXT'];
-                            if (typeof result.value === 'string' &&
-                                validFormats.includes(result.value)) {
-                                metadata[mappedKey] = result.value;
-                            }
-                            else {
-                                output.warnings.add(warnInvalidFormatSync(config.file, String(result.value), `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                            }
-                        }
-                        else {
-                            // Add the $context or $id or other attributes value to the metadata
-                            // TODO: why are we including everything? arent we only interested in relevant inline metadata?
-                            metadata[mappedKey] = result.value;
-                        }
-                    }
-                }
-            }
-        });
-    }
-    return {
-        ...metadata,
-        ...(contextDeriveExpr && { contextDeriveExpr }),
-    };
+* Extracts inline metadata specified e.g. gt('Hello', { $context: 'greeting' })
+* @param options - The options to extract the metadata from
+* @param output - The output to use
+* @param config - The configuration to use
+* @param index - The index of the string entry
+* @returns The inline metadata
+*/
+function extractInlineMetadata({ options, output, config }) {
+	const metadata = {};
+	let contextDeriveExpr;
+	if (options && options.type === "ObjectExpression") options.properties.forEach((prop) => {
+		if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
+			const attribute = prop.key.name;
+			if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) && t.isExpression(prop.value)) {
+				const result = isStaticExpression(prop.value);
+				if (!result.isStatic) if (mapAttributeName(attribute) === "context" && containsDeriveCall(prop.value)) contextDeriveExpr = prop.value;
+				else output.errors.push(warnNonStaticExpressionSync(config.file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+				if (result.isStatic && result.value != null && !config.ignoreInlineMetadata) {
+					const mappedKey = mapAttributeName(attribute);
+					if (mappedKey === "maxChars") {
+						if (typeof result.value === "string" && (isNaN(Number(result.value)) || !isNumberLiteral(prop.value)) || !Number.isInteger(Number(result.value))) output.errors.push(warnInvalidMaxCharsSync(config.file, generate(prop).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+						else if (typeof result.value === "string") metadata[mappedKey] = Math.abs(Number(result.value));
+					} else if (mappedKey === "format") if (typeof result.value === "string" && [
+						"ICU",
+						"STRING",
+						"I18NEXT"
+					].includes(result.value)) metadata[mappedKey] = result.value;
+					else output.warnings.add(warnInvalidFormatSync(config.file, String(result.value), `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
+					else metadata[mappedKey] = result.value;
+				}
+			}
+		}
+	});
+	return {
+		...metadata,
+		...contextDeriveExpr && { contextDeriveExpr }
+	};
 }
+//#endregion
+export { extractStringEntryMetadata };
+
+//# sourceMappingURL=extractStringEntryMetadata.js.map

package/dist/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractStringEntryMetadata.js","names":["pathModule"],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTranslationCall/extractStringEntryMetadata.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { ParsingConfig } from '../types.js';\nimport { ParsingOutput } from '../types.js';\nimport { isStaticExpression } from '../../../evaluateJsx.js';\nimport { warnInvalidMaxCharsSync } from '../../../../../console/index.js';\nimport { warnInvalidFormatSync } from '../../../../../console/index.js';\nimport { warnNonStaticExpressionSync } from '../../../../../console/index.js';\nimport { GT_ATTRIBUTES_WITH_SUGAR } from '../../constants.js';\nimport { containsDeriveCall } from '../derivation/containsDeriveCall.js';\nimport generateModule from '@babel/generator';\nimport { mapAttributeName } from '../../mapAttributeName.js';\nimport pathModule from 'node:path';\nimport { isNumberLiteral } from '../../isNumberLiteral.js';\nimport { extractSourceCode } from '../../extractSourceCode.js';\nimport type { SourceCode } from '../../extractSourceCode.js';\nimport { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';\n\n// Handle CommonJS/ESM interop\nconst generate = generateModule.default || generateModule;\n\n/**\n * Metadata record type\n */\nexport type InlineMetadata = {\n  maxChars?: number;\n  context?: string;\n  id?: string;\n  hash?: string;\n  format?: string;\n  filePaths?: string[];\n  sourceCode?: Record<string, SourceCode[]>;\n  contextDeriveExpr?: t.Expression;\n};\n\n/**\n * Extracts inline metadata from a string entry\n * @param metadata - The metadata record to inject the data into\n * @param entry - The string entry to extract the metadata from\n * @param output - The output to use\n * @param config - The configuration to use\n * @returns The inline metadata\n *\n * @note - this function does not automatically append the index to the id, this must be done manually in the caller.\n *\n */\nexport function extractStringEntryMetadata({\n  options,\n  output,\n  config,\n  nodeLoc,\n  surroundingLineCount = SURROUNDING_LINE_COUNT,\n}: {\n  options?: t.CallExpression['arguments'][number];\n  output: ParsingOutput;\n  config: ParsingConfig;\n  nodeLoc?: {\n    start?: { line: number } | null;\n    end?: { line: number } | null;\n  } | null;\n  surroundingLineCount?: number;\n}): InlineMetadata {\n  // extract filepath for entry\n  const relativeFilepath = pathModule.relative(process.cwd(), config.file);\n\n  // extract inline metadata\n  const inlineMetadata = extractInlineMetadata({\n    options,\n    output,\n    config,\n  });\n\n  // extract surrounding lines from source file\n  let sourceCode: Record<string, SourceCode[]> | undefined;\n  if (\n    config.includeSourceCodeContext &&\n    nodeLoc?.start?.line &&\n    nodeLoc?.end?.line\n  ) {\n    const entry = extractSourceCode(\n      config.file,\n      nodeLoc.start.line,\n      nodeLoc.end.line,\n      surroundingLineCount\n    );\n    if (entry && relativeFilepath) {\n      sourceCode = { [relativeFilepath]: [entry] };\n    }\n  }\n\n  return {\n    ...inlineMetadata,\n    filePaths: relativeFilepath ? [relativeFilepath] : undefined,\n    ...(sourceCode && { sourceCode }),\n  };\n}\n\n// ----- Helper Functions ----- //\n\n/**\n * Extracts inline metadata specified e.g. gt('Hello', { $context: 'greeting' })\n * @param options - The options to extract the metadata from\n * @param output - The output to use\n * @param config - The configuration to use\n * @param index - The index of the string entry\n * @returns The inline metadata\n */\nfunction extractInlineMetadata({\n  options,\n  output,\n  config,\n}: {\n  options?: t.CallExpression['arguments'][number];\n  output: ParsingOutput;\n  config: ParsingConfig;\n}): InlineMetadata {\n  const metadata: Record<string, string | number | string[]> = {};\n  let contextDeriveExpr: t.Expression | undefined;\n  if (options && options.type === 'ObjectExpression') {\n    options.properties.forEach((prop) => {\n      if (prop.type === 'ObjectProperty' && prop.key.type === 'Identifier') {\n        const attribute = prop.key.name;\n        if (\n          GT_ATTRIBUTES_WITH_SUGAR.includes(\n            attribute as (typeof GT_ATTRIBUTES_WITH_SUGAR)[number]\n          ) &&\n          t.isExpression(prop.value)\n        ) {\n          const result = isStaticExpression(prop.value);\n          if (!result.isStatic) {\n            const mappedKey = mapAttributeName(attribute);\n            if (mappedKey === 'context' && containsDeriveCall(prop.value)) {\n              contextDeriveExpr = prop.value;\n            } else {\n              output.errors.push(\n                warnNonStaticExpressionSync(\n                  config.file,\n                  attribute,\n                  generate(prop.value).code,\n                  `${prop.loc?.start?.line}:${prop.loc?.start?.column}`\n                )\n              );\n            }\n          }\n          if (\n            result.isStatic &&\n            result.value != null &&\n            !config.ignoreInlineMetadata\n          ) {\n            const mappedKey = mapAttributeName(attribute);\n            if (mappedKey === 'maxChars') {\n              // Handle maxChars attribute\n              if (\n                (typeof result.value === 'string' &&\n                  (isNaN(Number(result.value)) ||\n                    !isNumberLiteral(prop.value))) ||\n                !Number.isInteger(Number(result.value))\n              ) {\n                output.errors.push(\n                  warnInvalidMaxCharsSync(\n                    config.file,\n                    generate(prop).code,\n                    `${prop.loc?.start?.line}:${prop.loc?.start?.column}`\n                  )\n                );\n              } else if (typeof result.value === 'string') {\n                // Add the maxChars value to the metadata\n                metadata[mappedKey] = Math.abs(Number(result.value));\n              }\n            } else if (mappedKey === 'format') {\n              // Handle format attribute - validate allowed values\n              const validFormats = ['ICU', 'STRING', 'I18NEXT'];\n              if (\n                typeof result.value === 'string' &&\n                validFormats.includes(result.value)\n              ) {\n                metadata[mappedKey] = result.value;\n              } else {\n                output.warnings.add(\n                  warnInvalidFormatSync(\n                    config.file,\n                    String(result.value),\n                    `${prop.loc?.start?.line}:${prop.loc?.start?.column}`\n                  )\n                );\n              }\n            } else {\n              // Add the $context or $id or other attributes value to the metadata\n              // TODO: why are we including everything? arent we only interested in relevant inline metadata?\n              metadata[mappedKey] = result.value;\n            }\n          }\n        }\n      }\n    });\n  }\n\n  return {\n    ...metadata,\n    ...(contextDeriveExpr && { contextDeriveExpr }),\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,MAAM,WAAW,eAAe,WAAW;;;;;;;;;;;;AA2B3C,SAAgB,2BAA2B,EACzC,SACA,QACA,QACA,SACA,uBAAA,KAUiB;CAEjB,MAAM,mBAAmBA,KAAW,SAAS,QAAQ,KAAK,EAAE,OAAO,KAAK;CAGxE,MAAM,iBAAiB,sBAAsB;EAC3C;EACA;EACA;EACD,CAAC;CAGF,IAAI;AACJ,KACE,OAAO,4BACP,SAAS,OAAO,QAChB,SAAS,KAAK,MACd;EACA,MAAM,QAAQ,kBACZ,OAAO,MACP,QAAQ,MAAM,MACd,QAAQ,IAAI,MACZ,qBACD;AACD,MAAI,SAAS,iBACX,cAAa,GAAG,mBAAmB,CAAC,MAAM,EAAE;;AAIhD,QAAO;EACL,GAAG;EACH,WAAW,mBAAmB,CAAC,iBAAiB,GAAG,KAAA;EACnD,GAAI,cAAc,EAAE,YAAY;EACjC;;;;;;;;;;AAaH,SAAS,sBAAsB,EAC7B,SACA,QACA,UAKiB;CACjB,MAAM,WAAuD,EAAE;CAC/D,IAAI;AACJ,KAAI,WAAW,QAAQ,SAAS,mBAC9B,SAAQ,WAAW,SAAS,SAAS;AACnC,MAAI,KAAK,SAAS,oBAAoB,KAAK,IAAI,SAAS,cAAc;GACpE,MAAM,YAAY,KAAK,IAAI;AAC3B,OACE,yBAAyB,SACvB,UACD,IACD,EAAE,aAAa,KAAK,MAAM,EAC1B;IACA,MAAM,SAAS,mBAAmB,KAAK,MAAM;AAC7C,QAAI,CAAC,OAAO,SAEV,KADkB,iBAAiB,UACtB,KAAK,aAAa,mBAAmB,KAAK,MAAM,CAC3D,qBAAoB,KAAK;QAEzB,QAAO,OAAO,KACZ,4BACE,OAAO,MACP,WACA,SAAS,KAAK,MAAM,CAAC,MACrB,GAAG,KAAK,KAAK,OAAO,KAAK,GAAG,KAAK,KAAK,OAAO,SAC9C,CACF;AAGL,QACE,OAAO,YACP,OAAO,SAAS,QAChB,CAAC,OAAO,sBACR;KACA,MAAM,YAAY,iBAAiB,UAAU;AAC7C,SAAI,cAAc;UAGb,OAAO,OAAO,UAAU,aACtB,MAAM,OAAO,OAAO,MAAM,CAAC,IAC1B,CAAC,gBAAgB,KAAK,MAAM,KAChC,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,CAAC,CAEvC,QAAO,OAAO,KACZ,wBACE,OAAO,MACP,SAAS,KAAK,CAAC,MACf,GAAG,KAAK,KAAK,OAAO,KAAK,GAAG,KAAK,KAAK,OAAO,SAC9C,CACF;eACQ,OAAO,OAAO,UAAU,SAEjC,UAAS,aAAa,KAAK,IAAI,OAAO,OAAO,MAAM,CAAC;gBAE7C,cAAc,SAGvB,KACE,OAAO,OAAO,UAAU,YACxB;MAHoB;MAAO;MAAU;MAGzB,CAAC,SAAS,OAAO,MAAM,CAEnC,UAAS,aAAa,OAAO;SAE7B,QAAO,SAAS,IACd,sBACE,OAAO,MACP,OAAO,OAAO,MAAM,EACpB,GAAG,KAAK,KAAK,OAAO,KAAK,GAAG,KAAK,KAAK,OAAO,SAC9C,CACF;SAKH,UAAS,aAAa,OAAO;;;;GAKrC;AAGJ,QAAO;EACL,GAAG;EACH,GAAI,qBAAqB,EAAE,mBAAmB;EAC/C"}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleDeriveTranslationCall.js

@@ -1,21 +1,26 @@
-import { deriveExpression } from '../derivation/index.js';
+import { deriveExpression } from "../derivation/index.js";
+//#region src/react/jsx/utils/stringParsing/processTranslationCall/handleDeriveTranslationCall.ts
 /**
- * For the processTranslationCall function, this function handles the case where a string with derive is used.
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param tPath - The path to the argument
- * @param config - The configuration to use
- * @param output - The output to use
- * @param index - Current index in array of strings being extracted
- */
-export function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, contextVariants, }) {
-    deriveExpression({
-        tPath,
-        expr: arg,
-        metadata,
-        config,
-        output,
-        index,
-        contextVariants,
-    });
+* For the processTranslationCall function, this function handles the case where a string with derive is used.
+* @param arg - The argument to parse
+* @param metadata - The metadata to use
+* @param tPath - The path to the argument
+* @param config - The configuration to use
+* @param output - The output to use
+* @param index - Current index in array of strings being extracted
+*/
+function handleDeriveTranslationCall({ arg, metadata, tPath, config, output, index, contextVariants }) {
+	deriveExpression({
+		tPath,
+		expr: arg,
+		metadata,
+		config,
+		output,
+		index,
+		contextVariants
+	});
 }
+//#endregion
+export { handleDeriveTranslationCall };
+
+//# sourceMappingURL=handleDeriveTranslationCall.js.map

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleDeriveTranslationCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleDeriveTranslationCall.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTranslationCall/handleDeriveTranslationCall.ts"],"sourcesContent":["import { NodePath } from '@babel/traverse';\nimport * as t from '@babel/types';\nimport { ParsingConfig } from '../types.js';\nimport { ParsingOutput } from '../types.js';\nimport { deriveExpression } from '../derivation/index.js';\nimport { InlineMetadata } from './extractStringEntryMetadata.js';\n\n/**\n * For the processTranslationCall function, this function handles the case where a string with derive is used.\n * @param arg - The argument to parse\n * @param metadata - The metadata to use\n * @param tPath - The path to the argument\n * @param config - The configuration to use\n * @param output - The output to use\n * @param index - Current index in array of strings being extracted\n */\nexport function handleDeriveTranslationCall({\n  arg,\n  metadata,\n  tPath,\n  config,\n  output,\n  index,\n  contextVariants,\n}: {\n  arg: t.Expression;\n  metadata: InlineMetadata;\n  tPath: NodePath;\n  config: ParsingConfig;\n  output: ParsingOutput;\n  index?: number;\n  contextVariants?: string[];\n}): void {\n  deriveExpression({\n    tPath,\n    expr: arg,\n    metadata,\n    config,\n    output,\n    index,\n    contextVariants,\n  });\n}\n"],"mappings":";;;;;;;;;;;AAgBA,SAAgB,4BAA4B,EAC1C,KACA,UACA,OACA,QACA,QACA,OACA,mBASO;AACP,kBAAiB;EACf;EACA,MAAM;EACN;EACA;EACA;EACA;EACA;EACD,CAAC"}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleInvalidTranslationCall.js

@@ -1,24 +1,21 @@
-import * as t from '@babel/types';
-import { warnNonStringSync, warnTemplateLiteralSync, } from '../../../../../console/index.js';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
+import { warnNonStringSync, warnTemplateLiteralSync } from "../../../../../console/index.js";
+import * as t from "@babel/types";
+import generateModule from "@babel/generator";
+//#region src/react/jsx/utils/stringParsing/processTranslationCall/handleInvalidTranslationCall.ts
 const generate = generateModule.default || generateModule;
 /**
- * For the processTranslationCall function, this function handles the case where a other translation call is used.
- * Error is pushed if the other translation call is used.
- * @param arg - The argument to parse
- * @param config - The configuration to use
- * @param output - The output to use
- */
-export function handleInvalidTranslationCall({ arg, config, output, }) {
-    if (config.ignoreDynamicContent)
-        return;
-    if (t.isTemplateLiteral(arg)) {
-        // Specific error for template literals
-        output.errors.push(warnTemplateLiteralSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-    }
-    else {
-        // Generic error
-        output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-    }
+* For the processTranslationCall function, this function handles the case where a other translation call is used.
+* Error is pushed if the other translation call is used.
+* @param arg - The argument to parse
+* @param config - The configuration to use
+* @param output - The output to use
+*/
+function handleInvalidTranslationCall({ arg, config, output }) {
+	if (config.ignoreDynamicContent) return;
+	if (t.isTemplateLiteral(arg)) output.errors.push(warnTemplateLiteralSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+	else output.errors.push(warnNonStringSync(config.file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
 }
+//#endregion
+export { handleInvalidTranslationCall };
+
+//# sourceMappingURL=handleInvalidTranslationCall.js.map

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleInvalidTranslationCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleInvalidTranslationCall.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTranslationCall/handleInvalidTranslationCall.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { ParsingConfig, ParsingOutput } from '../types.js';\nimport {\n  warnNonStringSync,\n  warnTemplateLiteralSync,\n} from '../../../../../console/index.js';\nimport generateModule from '@babel/generator';\n\n// Handle CommonJS/ESM interop\nconst generate = generateModule.default || generateModule;\n\n/**\n * For the processTranslationCall function, this function handles the case where a other translation call is used.\n * Error is pushed if the other translation call is used.\n * @param arg - The argument to parse\n * @param config - The configuration to use\n * @param output - The output to use\n */\nexport function handleInvalidTranslationCall({\n  arg,\n  config,\n  output,\n}: {\n  arg: t.ArgumentPlaceholder | t.SpreadElement | t.Expression;\n  config: ParsingConfig;\n  output: ParsingOutput;\n}): void {\n  if (config.ignoreDynamicContent) return;\n\n  if (t.isTemplateLiteral(arg)) {\n    // Specific error for template literals\n    output.errors.push(\n      warnTemplateLiteralSync(\n        config.file,\n        generate(arg).code,\n        `${arg.loc?.start?.line}:${arg.loc?.start?.column}`\n      )\n    );\n  } else {\n    // Generic error\n    output.errors.push(\n      warnNonStringSync(\n        config.file,\n        generate(arg).code,\n        `${arg.loc?.start?.line}:${arg.loc?.start?.column}`\n      )\n    );\n  }\n}\n"],"mappings":";;;;AASA,MAAM,WAAW,eAAe,WAAW;;;;;;;;AAS3C,SAAgB,6BAA6B,EAC3C,KACA,QACA,UAKO;AACP,KAAI,OAAO,qBAAsB;AAEjC,KAAI,EAAE,kBAAkB,IAAI,CAE1B,QAAO,OAAO,KACZ,wBACE,OAAO,MACP,SAAS,IAAI,CAAC,MACd,GAAG,IAAI,KAAK,OAAO,KAAK,GAAG,IAAI,KAAK,OAAO,SAC5C,CACF;KAGD,QAAO,OAAO,KACZ,kBACE,OAAO,MACP,SAAS,IAAI,CAAC,MACd,GAAG,IAAI,KAAK,OAAO,KAAK,GAAG,IAAI,KAAK,OAAO,SAC5C,CACF"}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.js

@@ -1,52 +1,47 @@
-import { isValidIcu } from '../../../evaluateJsx.js';
-import { warnInvalidIcuSync } from '../../../../../console/index.js';
-import { randomUUID } from 'node:crypto';
+import { isValidIcu } from "../../../evaluateJsx.js";
+import { warnInvalidIcuSync } from "../../../../../console/index.js";
+import { randomUUID } from "node:crypto";
+//#region src/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.ts
 /**
- * For the processTranslationCall function, this function handles the case where a string literal or template literal is used.
- * @param arg - The argument to parse
- * @param metadata - The metadata to use
- * @param config - The configuration to use
- * @param output - The output to use
- * @param index - The index of the argument
- * @param contextVariants - Optional derive context variants for cross-product
- */
-export function handleLiteralTranslationCall({ arg, metadata, config, output, index, contextVariants, }) {
-    // ignore dynamic content flag is triggered, check strings are valid ICU
-    const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
-    // Validate is ICU — skip for non-ICU formats
-    if (!config.ignoreInvalidIcu &&
-        (!metadata.format || metadata.format === 'ICU')) {
-        const { isValid, error } = isValidIcu(source);
-        if (!isValid) {
-            output.warnings.add(warnInvalidIcuSync(config.file, source, error ?? 'Unknown error', `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            return;
-        }
-    }
-    if (contextVariants) {
-        const staticId = `derive-temp-id-${randomUUID()}`;
-        for (const context of contextVariants) {
-            output.updates.push({
-                dataFormat: (metadata.format || 'ICU'),
-                source,
-                metadata: {
-                    ...metadata,
-                    context,
-                    ...(metadata.id &&
-                        index != null && { id: `${metadata.id}.${index}` }),
-                    staticId,
-                },
-            });
-        }
-    }
-    else {
-        output.updates.push({
-            dataFormat: (metadata.format || 'ICU'),
-            source,
-            metadata: {
-                ...metadata,
-                // Add the index if an id and index is provided (for handling when registering an array of strings)
-                ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),
-            },
-        });
-    }
+* For the processTranslationCall function, this function handles the case where a string literal or template literal is used.
+* @param arg - The argument to parse
+* @param metadata - The metadata to use
+* @param config - The configuration to use
+* @param output - The output to use
+* @param index - The index of the argument
+* @param contextVariants - Optional derive context variants for cross-product
+*/
+function handleLiteralTranslationCall({ arg, metadata, config, output, index, contextVariants }) {
+	const source = arg.type === "StringLiteral" ? arg.value : arg.quasis[0].value.raw;
+	if (!config.ignoreInvalidIcu && (!metadata.format || metadata.format === "ICU")) {
+		const { isValid, error } = isValidIcu(source);
+		if (!isValid) {
+			output.warnings.add(warnInvalidIcuSync(config.file, source, error ?? "Unknown error", `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
+			return;
+		}
+	}
+	if (contextVariants) {
+		const staticId = `derive-temp-id-${randomUUID()}`;
+		for (const context of contextVariants) output.updates.push({
+			dataFormat: metadata.format || "ICU",
+			source,
+			metadata: {
+				...metadata,
+				context,
+				...metadata.id && index != null && { id: `${metadata.id}.${index}` },
+				staticId
+			}
+		});
+	} else output.updates.push({
+		dataFormat: metadata.format || "ICU",
+		source,
+		metadata: {
+			...metadata,
+			...metadata.id && index != null && { id: `${metadata.id}.${index}` }
+		}
+	});
 }
+//#endregion
+export { handleLiteralTranslationCall };
+
+//# sourceMappingURL=handleLiteralTranslationCall.js.map

package/dist/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleLiteralTranslationCall.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTranslationCall/handleLiteralTranslationCall.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport type { DataFormat } from '@generaltranslation/format/types';\nimport { ParsingConfig } from '../types.js';\nimport { ParsingOutput } from '../types.js';\nimport { isValidIcu } from '../../../evaluateJsx.js';\nimport { warnInvalidIcuSync } from '../../../../../console/index.js';\nimport { InlineMetadata } from './extractStringEntryMetadata.js';\nimport { randomUUID } from 'node:crypto';\n\n/**\n * For the processTranslationCall function, this function handles the case where a string literal or template literal is used.\n * @param arg - The argument to parse\n * @param metadata - The metadata to use\n * @param config - The configuration to use\n * @param output - The output to use\n * @param index - The index of the argument\n * @param contextVariants - Optional derive context variants for cross-product\n */\nexport function handleLiteralTranslationCall({\n  arg,\n  metadata,\n  config,\n  output,\n  index,\n  contextVariants,\n}: {\n  arg: t.StringLiteral | t.TemplateLiteral;\n  metadata: InlineMetadata;\n  config: ParsingConfig;\n  output: ParsingOutput;\n  index?: number;\n  contextVariants?: string[];\n}): void {\n  // ignore dynamic content flag is triggered, check strings are valid ICU\n  const source =\n    arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;\n\n  // Validate is ICU — skip for non-ICU formats\n  if (\n    !config.ignoreInvalidIcu &&\n    (!metadata.format || metadata.format === 'ICU')\n  ) {\n    const { isValid, error } = isValidIcu(source);\n    if (!isValid) {\n      output.warnings.add(\n        warnInvalidIcuSync(\n          config.file,\n          source,\n          error ?? 'Unknown error',\n          `${arg.loc?.start?.line}:${arg.loc?.start?.column}`\n        )\n      );\n      return;\n    }\n  }\n\n  if (contextVariants) {\n    const staticId = `derive-temp-id-${randomUUID()}`;\n    for (const context of contextVariants) {\n      output.updates.push({\n        dataFormat: (metadata.format || 'ICU') as DataFormat,\n        source,\n        metadata: {\n          ...metadata,\n          context,\n          ...(metadata.id &&\n            index != null && { id: `${metadata.id}.${index}` }),\n          staticId,\n        },\n      });\n    }\n  } else {\n    output.updates.push({\n      dataFormat: (metadata.format || 'ICU') as DataFormat,\n      source,\n      metadata: {\n        ...metadata,\n        // Add the index if an id and index is provided (for handling when registering an array of strings)\n        ...(metadata.id && index != null && { id: `${metadata.id}.${index}` }),\n      },\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAgB,6BAA6B,EAC3C,KACA,UACA,QACA,QACA,OACA,mBAQO;CAEP,MAAM,SACJ,IAAI,SAAS,kBAAkB,IAAI,QAAQ,IAAI,OAAO,GAAG,MAAM;AAGjE,KACE,CAAC,OAAO,qBACP,CAAC,SAAS,UAAU,SAAS,WAAW,QACzC;EACA,MAAM,EAAE,SAAS,UAAU,WAAW,OAAO;AAC7C,MAAI,CAAC,SAAS;AACZ,UAAO,SAAS,IACd,mBACE,OAAO,MACP,QACA,SAAS,iBACT,GAAG,IAAI,KAAK,OAAO,KAAK,GAAG,IAAI,KAAK,OAAO,SAC5C,CACF;AACD;;;AAIJ,KAAI,iBAAiB;EACnB,MAAM,WAAW,kBAAkB,YAAY;AAC/C,OAAK,MAAM,WAAW,gBACpB,QAAO,QAAQ,KAAK;GAClB,YAAa,SAAS,UAAU;GAChC;GACA,UAAU;IACR,GAAG;IACH;IACA,GAAI,SAAS,MACX,SAAS,QAAQ,EAAE,IAAI,GAAG,SAAS,GAAG,GAAG,SAAS;IACpD;IACD;GACF,CAAC;OAGJ,QAAO,QAAQ,KAAK;EAClB,YAAa,SAAS,UAAU;EAChC;EACA,UAAU;GACR,GAAG;GAEH,GAAI,SAAS,MAAM,SAAS,QAAQ,EAAE,IAAI,GAAG,SAAS,GAAG,GAAG,SAAS;GACtE;EACF,CAAC"}

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.js

@@ -1,61 +1,56 @@
-import { routeTranslationCall } from './routeTranslationCall.js';
-import { extractStringEntryMetadata } from './extractStringEntryMetadata.js';
-import { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';
-import { handleDerivation } from '../derivation/handleDerivation.js';
-import { nodeToStrings } from '../../parseString.js';
+import "../../../../../utils/constants.js";
+import { nodeToStrings } from "../../parseString.js";
+import { handleDerivation } from "../derivation/handleDerivation.js";
+import { routeTranslationCall } from "./routeTranslationCall.js";
+import { extractStringEntryMetadata } from "./extractStringEntryMetadata.js";
+//#region src/react/jsx/utils/stringParsing/processTranslationCall/index.ts
 /**
- * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
- * Extracts the translatable string content and metadata, then adds it to the updates array.
- *
- * Handles:
- * - String literals: t('hello')
- * - Template literals without expressions: t(`hello`)
- * - Metadata extraction from options object
- * - Error reporting for non-derivable expressions and template literals with expressions
- *
- * @param tPath - The path to the translation call
- * @param config - The configuration to use
- * @param output - The output to use
- */
-export function processTranslationCall(tPath, config, output) {
-    if (tPath.parent.type !== 'CallExpression' ||
-        tPath.parent.arguments.length === 0) {
-        return;
-    }
-    // Get arg and options
-    const arg = tPath.parent.arguments[0];
-    const options = tPath.parent.arguments.at(1);
-    // get metadata and id from options
-    const metadata = extractStringEntryMetadata({
-        options,
-        output,
-        config,
-        nodeLoc: tPath.parent.loc,
-        surroundingLineCount: SURROUNDING_LINE_COUNT,
-    });
-    // Resolve derive context variants if present
-    let contextVariants;
-    if (metadata.contextDeriveExpr) {
-        const contextNode = handleDerivation({
-            expr: metadata.contextDeriveExpr,
-            tPath,
-            file: config.file,
-            parsingOptions: config.parsingOptions,
-            errors: output.errors,
-            warnings: output.warnings,
-        });
-        if (contextNode) {
-            contextVariants = nodeToStrings(contextNode);
-        }
-        delete metadata.contextDeriveExpr;
-    }
-    // Route tx call to appropriate handler
-    routeTranslationCall({
-        tPath,
-        config,
-        output,
-        arg,
-        metadata,
-        contextVariants,
-    });
+* Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
+* Extracts the translatable string content and metadata, then adds it to the updates array.
+*
+* Handles:
+* - String literals: t('hello')
+* - Template literals without expressions: t(`hello`)
+* - Metadata extraction from options object
+* - Error reporting for non-derivable expressions and template literals with expressions
+*
+* @param tPath - The path to the translation call
+* @param config - The configuration to use
+* @param output - The output to use
+*/
+function processTranslationCall(tPath, config, output) {
+	if (tPath.parent.type !== "CallExpression" || tPath.parent.arguments.length === 0) return;
+	const arg = tPath.parent.arguments[0];
+	const metadata = extractStringEntryMetadata({
+		options: tPath.parent.arguments.at(1),
+		output,
+		config,
+		nodeLoc: tPath.parent.loc,
+		surroundingLineCount: 5
+	});
+	let contextVariants;
+	if (metadata.contextDeriveExpr) {
+		const contextNode = handleDerivation({
+			expr: metadata.contextDeriveExpr,
+			tPath,
+			file: config.file,
+			parsingOptions: config.parsingOptions,
+			errors: output.errors,
+			warnings: output.warnings
+		});
+		if (contextNode) contextVariants = nodeToStrings(contextNode);
+		delete metadata.contextDeriveExpr;
+	}
+	routeTranslationCall({
+		tPath,
+		config,
+		output,
+		arg,
+		metadata,
+		contextVariants
+	});
 }
+//#endregion
+export { processTranslationCall };
+
+//# sourceMappingURL=index.js.map

package/dist/react/jsx/utils/stringParsing/processTranslationCall/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTranslationCall/index.ts"],"sourcesContent":["import { NodePath } from '@babel/traverse';\nimport { ParsingConfig } from '../types.js';\nimport { ParsingOutput } from '../types.js';\nimport { routeTranslationCall } from './routeTranslationCall.js';\nimport { extractStringEntryMetadata } from './extractStringEntryMetadata.js';\nimport { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';\nimport { handleDerivation } from '../derivation/handleDerivation.js';\nimport { nodeToStrings } from '../../parseString.js';\n\n/**\n * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).\n * Extracts the translatable string content and metadata, then adds it to the updates array.\n *\n * Handles:\n * - String literals: t('hello')\n * - Template literals without expressions: t(`hello`)\n * - Metadata extraction from options object\n * - Error reporting for non-derivable expressions and template literals with expressions\n *\n * @param tPath - The path to the translation call\n * @param config - The configuration to use\n * @param output - The output to use\n */\nexport function processTranslationCall(\n  tPath: NodePath,\n  config: ParsingConfig,\n  output: ParsingOutput\n): void {\n  if (\n    tPath.parent.type !== 'CallExpression' ||\n    tPath.parent.arguments.length === 0\n  ) {\n    return;\n  }\n\n  // Get arg and options\n  const arg = tPath.parent.arguments[0];\n  const options = tPath.parent.arguments.at(1);\n\n  // get metadata and id from options\n  const metadata = extractStringEntryMetadata({\n    options,\n    output,\n    config,\n    nodeLoc: tPath.parent.loc,\n    surroundingLineCount: SURROUNDING_LINE_COUNT,\n  });\n\n  // Resolve derive context variants if present\n  let contextVariants: string[] | undefined;\n  if (metadata.contextDeriveExpr) {\n    const contextNode = handleDerivation({\n      expr: metadata.contextDeriveExpr,\n      tPath,\n      file: config.file,\n      parsingOptions: config.parsingOptions,\n      errors: output.errors,\n      warnings: output.warnings,\n    });\n    if (contextNode) {\n      contextVariants = nodeToStrings(contextNode);\n    }\n    delete metadata.contextDeriveExpr;\n  }\n\n  // Route tx call to appropriate handler\n  routeTranslationCall({\n    tPath,\n    config,\n    output,\n    arg,\n    metadata,\n    contextVariants,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,uBACd,OACA,QACA,QACM;AACN,KACE,MAAM,OAAO,SAAS,oBACtB,MAAM,OAAO,UAAU,WAAW,EAElC;CAIF,MAAM,MAAM,MAAM,OAAO,UAAU;CAInC,MAAM,WAAW,2BAA2B;EAC1C,SAJc,MAAM,OAAO,UAAU,GAAG,EAIjC;EACP;EACA;EACA,SAAS,MAAM,OAAO;EACtB,sBAAA;EACD,CAAC;CAGF,IAAI;AACJ,KAAI,SAAS,mBAAmB;EAC9B,MAAM,cAAc,iBAAiB;GACnC,MAAM,SAAS;GACf;GACA,MAAM,OAAO;GACb,gBAAgB,OAAO;GACvB,QAAQ,OAAO;GACf,UAAU,OAAO;GAClB,CAAC;AACF,MAAI,YACF,mBAAkB,cAAc,YAAY;AAE9C,SAAO,SAAS;;AAIlB,sBAAqB;EACnB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC"}