gt 2.14.35 → 2.14.37

package/dist/formats/files/supportedFiles.js

@@ -1,24 +1,29 @@
-export const SUPPORTED_FILE_EXTENSIONS = [
-    'json',
-    'pot',
-    'mdx',
-    'md',
-    'ts',
-    'js',
-    'yaml',
-    'html',
-    'txt',
-    'twilioContentJson',
+//#region src/formats/files/supportedFiles.ts
+const SUPPORTED_FILE_EXTENSIONS = [
+	"json",
+	"pot",
+	"mdx",
+	"md",
+	"ts",
+	"js",
+	"yaml",
+	"html",
+	"txt",
+	"twilioContentJson"
 ];
-export const FILE_EXT_TO_EXT_LABEL = {
-    json: 'JSON',
-    pot: 'POT',
-    mdx: 'MDX',
-    md: 'Markdown',
-    ts: 'TypeScript',
-    js: 'JavaScript',
-    yaml: 'YAML',
-    html: 'HTML',
-    txt: 'Text',
-    twilioContentJson: 'Twilio Content JSON',
+const FILE_EXT_TO_EXT_LABEL = {
+	json: "JSON",
+	pot: "POT",
+	mdx: "MDX",
+	md: "Markdown",
+	ts: "TypeScript",
+	js: "JavaScript",
+	yaml: "YAML",
+	html: "HTML",
+	txt: "Text",
+	twilioContentJson: "Twilio Content JSON"
 };
+//#endregion
+export { FILE_EXT_TO_EXT_LABEL, SUPPORTED_FILE_EXTENSIONS };
+
+//# sourceMappingURL=supportedFiles.js.map

package/dist/formats/files/supportedFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supportedFiles.js","names":[],"sources":["../../../src/formats/files/supportedFiles.ts"],"sourcesContent":["export const SUPPORTED_FILE_EXTENSIONS = [\n  'json',\n  'pot',\n  'mdx',\n  'md',\n  'ts',\n  'js',\n  'yaml',\n  'html',\n  'txt',\n  'twilioContentJson',\n] as const;\n\nexport const FILE_EXT_TO_EXT_LABEL = {\n  json: 'JSON',\n  pot: 'POT',\n  mdx: 'MDX',\n  md: 'Markdown',\n  ts: 'TypeScript',\n  js: 'JavaScript',\n  yaml: 'YAML',\n  html: 'HTML',\n  txt: 'Text',\n  twilioContentJson: 'Twilio Content JSON',\n};\n"],"mappings":";AAAA,MAAa,4BAA4B;CACvC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,MAAa,wBAAwB;CACnC,MAAM;CACN,KAAK;CACL,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,MAAM;CACN,MAAM;CACN,KAAK;CACL,mBAAmB;CACpB"}

package/dist/formats/files/transformFormat.js

@@ -1,121 +1,114 @@
-import { isSupportedFileFormatTransform } from 'generaltranslation/internal';
+import { isSupportedFileFormatTransform } from "generaltranslation/internal";
+//#region src/formats/files/transformFormat.ts
 /**
- * Maps CLI config file keys to API file format enum values.
- */
-export const CONFIG_FILE_TYPE_TO_FILE_FORMAT = {
-    json: 'JSON',
-    pot: 'POT',
-    mdx: 'MDX',
-    md: 'MD',
-    ts: 'TS',
-    js: 'JS',
-    yaml: 'YAML',
-    html: 'HTML',
-    txt: 'TXT',
-    twilioContentJson: 'TWILIO_CONTENT_JSON',
+* Maps CLI config file keys to API file format enum values.
+*/
+const CONFIG_FILE_TYPE_TO_FILE_FORMAT = {
+	json: "JSON",
+	pot: "POT",
+	mdx: "MDX",
+	md: "MD",
+	ts: "TS",
+	js: "JS",
+	yaml: "YAML",
+	html: "HTML",
+	txt: "TXT",
+	twilioContentJson: "TWILIO_CONTENT_JSON"
 };
 /**
- * Maps uppercase config aliases to the CLI's canonical lowercase file keys.
- */
-export const FILE_FORMAT_TO_CONFIG_FILE_TYPE = {
-    JSON: 'json',
-    POT: 'pot',
-    MDX: 'mdx',
-    MD: 'md',
-    TS: 'ts',
-    JS: 'js',
-    YAML: 'yaml',
-    HTML: 'html',
-    TXT: 'txt',
-    TWILIO_CONTENT_JSON: 'twilioContentJson',
+* Maps uppercase config aliases to the CLI's canonical lowercase file keys.
+*/
+const FILE_FORMAT_TO_CONFIG_FILE_TYPE = {
+	JSON: "json",
+	POT: "pot",
+	MDX: "mdx",
+	MD: "md",
+	TS: "ts",
+	JS: "js",
+	YAML: "yaml",
+	HTML: "html",
+	TXT: "txt",
+	TWILIO_CONTENT_JSON: "twilioContentJson"
 };
 /**
- * Maps API file format enum values to the extension the CLI should write.
- */
+* Maps API file format enum values to the extension the CLI should write.
+*/
 const FILE_FORMAT_EXTENSIONS = {
-    GTJSON: 'json',
-    JSON: 'json',
-    PO: 'po',
-    POT: 'pot',
-    YAML: 'yaml',
-    MDX: 'mdx',
-    MD: 'md',
-    TS: 'ts',
-    JS: 'js',
-    HTML: 'html',
-    TXT: 'txt',
-    TWILIO_CONTENT_JSON: 'json',
+	GTJSON: "json",
+	JSON: "json",
+	PO: "po",
+	POT: "pot",
+	YAML: "yaml",
+	MDX: "mdx",
+	MD: "md",
+	TS: "ts",
+	JS: "js",
+	HTML: "html",
+	TXT: "txt",
+	TWILIO_CONTENT_JSON: "json"
 };
 /**
- * Converts uppercase file format config keys into the CLI's canonical lowercase keys.
- *
- * This lets users write either `files.POT` or `files.pot` while keeping the
- * rest of the CLI on its existing lowercase file-type convention.
- */
-export function normalizeFilesOptions(files) {
-    const normalized = { ...files };
-    for (const [fileFormat, fileType] of Object.entries(FILE_FORMAT_TO_CONFIG_FILE_TYPE)) {
-        const uppercaseConfig = normalized[fileFormat];
-        if (!normalized[fileType] && uppercaseConfig) {
-            normalized[fileType] = uppercaseConfig;
-        }
-        delete normalized[fileFormat];
-    }
-    return normalized;
+* Converts uppercase file format config keys into the CLI's canonical lowercase keys.
+*
+* This lets users write either `files.POT` or `files.pot` while keeping the
+* rest of the CLI on its existing lowercase file-type convention.
+*/
+function normalizeFilesOptions(files) {
+	const normalized = { ...files };
+	for (const [fileFormat, fileType] of Object.entries(FILE_FORMAT_TO_CONFIG_FILE_TYPE)) {
+		const uppercaseConfig = normalized[fileFormat];
+		if (!normalized[fileType] && uppercaseConfig) normalized[fileType] = uppercaseConfig;
+		delete normalized[fileFormat];
+	}
+	return normalized;
 }
 /**
- * Validates and resolves a configured output format for a source file type.
- *
- * Throws when the requested source -> output format is not supported by
- * `generaltranslation/internal`.
- */
-export function resolveTransformationFormat(fileType, transformationFormat) {
-    if (!transformationFormat)
-        return undefined;
-    // Normalize to uppercase to match the FileFormat enum (e.g. "po" -> "PO")
-    const normalized = transformationFormat.toUpperCase();
-    const fileFormat = CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType];
-    if (!isSupportedFileFormatTransform(fileFormat, normalized)) {
-        throw new Error(`Unsupported file format transform: ${fileFormat} -> ${normalized} in files.${fileType}. ` +
-            `"${normalized}" is not a valid transformationFormat for ${fileFormat} source files.`);
-    }
-    return normalized;
+* Validates and resolves a configured output format for a source file type.
+*
+* Throws when the requested source -> output format is not supported by
+* `generaltranslation/internal`.
+*/
+function resolveTransformationFormat(fileType, transformationFormat) {
+	if (!transformationFormat) return void 0;
+	const normalized = transformationFormat.toUpperCase();
+	const fileFormat = CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType];
+	if (!isSupportedFileFormatTransform(fileFormat, normalized)) throw new Error(`Unsupported file format transform: ${fileFormat} -> ${normalized} in files.${fileType}. "${normalized}" is not a valid transformationFormat for ${fileFormat} source files.`);
+	return normalized;
 }
 /**
- * Returns the API upload/enqueue property for a file type when one is configured.
- */
-export function getTransformFormatProperty(settings, fileType) {
-    const transformFormat = settings.files?.transformFormats?.[fileType];
-    return transformFormat ? { transformFormat } : {};
+* Returns the API upload/enqueue property for a file type when one is configured.
+*/
+function getTransformFormatProperty(settings, fileType) {
+	const transformFormat = settings.files?.transformFormats?.[fileType];
+	return transformFormat ? { transformFormat } : {};
 }
 /**
- * Returns the preferred file extension for a translated file format.
- */
-export function getFileExtensionForFormat(format) {
-    return FILE_FORMAT_EXTENSIONS[format];
+* Returns the preferred file extension for a translated file format.
+*/
+function getFileExtensionForFormat(format) {
+	return FILE_FORMAT_EXTENSIONS[format];
 }
 /**
- * Rewrites a path's extension to match the translated file format.
- */
-export function replaceFileExtensionForFormat(filePath, format) {
-    const extension = getFileExtensionForFormat(format);
-    return /\.[^/.]+$/.test(filePath)
-        ? filePath.replace(/\.[^/.]+$/, `.${extension}`)
-        : `${filePath}.${extension}`;
+* Rewrites a path's extension to match the translated file format.
+*/
+function replaceFileExtensionForFormat(filePath, format) {
+	const extension = getFileExtensionForFormat(format);
+	return /\.[^/.]+$/.test(filePath) ? filePath.replace(/\.[^/.]+$/, `.${extension}`) : `${filePath}.${extension}`;
 }
 /**
- * Detects whether any configured format transform changes the output file type.
- */
-export function hasNonIdentityFileFormatTransform(settings) {
-    return Object.entries(settings.files?.transformFormats || {}).some(([fileType, transformFormat]) => transformFormat &&
-        CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType] !==
-            transformFormat);
+* Detects whether any configured format transform changes the output file type.
+*/
+function hasNonIdentityFileFormatTransform(settings) {
+	return Object.entries(settings.files?.transformFormats || {}).some(([fileType, transformFormat]) => transformFormat && CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType] !== transformFormat);
 }
 /**
- * Returns true when the configured transform for a file type changes its format.
- */
-export function hasNonIdentityFileFormatTransformForType(settings, fileType) {
-    const transformFormat = settings.files?.transformFormats?.[fileType];
-    return !!(transformFormat &&
-        CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType] !== transformFormat);
+* Returns true when the configured transform for a file type changes its format.
+*/
+function hasNonIdentityFileFormatTransformForType(settings, fileType) {
+	const transformFormat = settings.files?.transformFormats?.[fileType];
+	return !!(transformFormat && CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType] !== transformFormat);
 }
+//#endregion
+export { CONFIG_FILE_TYPE_TO_FILE_FORMAT, FILE_FORMAT_TO_CONFIG_FILE_TYPE, getFileExtensionForFormat, getTransformFormatProperty, hasNonIdentityFileFormatTransform, hasNonIdentityFileFormatTransformForType, normalizeFilesOptions, replaceFileExtensionForFormat, resolveTransformationFormat };
+
+//# sourceMappingURL=transformFormat.js.map

package/dist/formats/files/transformFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformFormat.js","names":[],"sources":["../../../src/formats/files/transformFormat.ts"],"sourcesContent":["import type { FileFormat } from '../../types/data.js';\nimport type {\n  FilesOptions,\n  Settings,\n  SupportedFileExtension,\n} from '../../types/index.js';\nimport { isSupportedFileFormatTransform } from 'generaltranslation/internal';\n\n/**\n * Maps CLI config file keys to API file format enum values.\n */\nexport const CONFIG_FILE_TYPE_TO_FILE_FORMAT = {\n  json: 'JSON',\n  pot: 'POT',\n  mdx: 'MDX',\n  md: 'MD',\n  ts: 'TS',\n  js: 'JS',\n  yaml: 'YAML',\n  html: 'HTML',\n  txt: 'TXT',\n  twilioContentJson: 'TWILIO_CONTENT_JSON',\n} as const satisfies Record<SupportedFileExtension, FileFormat>;\n\n/**\n * Maps uppercase config aliases to the CLI's canonical lowercase file keys.\n */\nexport const FILE_FORMAT_TO_CONFIG_FILE_TYPE = {\n  JSON: 'json',\n  POT: 'pot',\n  MDX: 'mdx',\n  MD: 'md',\n  TS: 'ts',\n  JS: 'js',\n  YAML: 'yaml',\n  HTML: 'html',\n  TXT: 'txt',\n  TWILIO_CONTENT_JSON: 'twilioContentJson',\n} as const satisfies Partial<Record<FileFormat, SupportedFileExtension>>;\n\n/**\n * Maps API file format enum values to the extension the CLI should write.\n */\nconst FILE_FORMAT_EXTENSIONS = {\n  GTJSON: 'json',\n  JSON: 'json',\n  PO: 'po',\n  POT: 'pot',\n  YAML: 'yaml',\n  MDX: 'mdx',\n  MD: 'md',\n  TS: 'ts',\n  JS: 'js',\n  HTML: 'html',\n  TXT: 'txt',\n  TWILIO_CONTENT_JSON: 'json',\n} as const satisfies Record<FileFormat, string>;\n\n/**\n * Converts uppercase file format config keys into the CLI's canonical lowercase keys.\n *\n * This lets users write either `files.POT` or `files.pot` while keeping the\n * rest of the CLI on its existing lowercase file-type convention.\n */\nexport function normalizeFilesOptions(files: FilesOptions): FilesOptions {\n  const normalized = { ...files } as FilesOptions & Record<string, unknown>;\n\n  for (const [fileFormat, fileType] of Object.entries(\n    FILE_FORMAT_TO_CONFIG_FILE_TYPE\n  ) as [string, SupportedFileExtension][]) {\n    const uppercaseConfig = normalized[fileFormat] as\n      | FilesOptions[SupportedFileExtension]\n      | undefined;\n    if (!normalized[fileType] && uppercaseConfig) {\n      normalized[fileType] = uppercaseConfig;\n    }\n    delete normalized[fileFormat];\n  }\n\n  return normalized;\n}\n\n/**\n * Validates and resolves a configured output format for a source file type.\n *\n * Throws when the requested source -> output format is not supported by\n * `generaltranslation/internal`.\n */\nexport function resolveTransformationFormat(\n  fileType: SupportedFileExtension,\n  transformationFormat: string | undefined\n): FileFormat | undefined {\n  if (!transformationFormat) return undefined;\n\n  // Normalize to uppercase to match the FileFormat enum (e.g. \"po\" -> \"PO\")\n  const normalized = transformationFormat.toUpperCase() as FileFormat;\n  const fileFormat = CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType];\n\n  if (!isSupportedFileFormatTransform(fileFormat, normalized)) {\n    throw new Error(\n      `Unsupported file format transform: ${fileFormat} -> ${normalized} in files.${fileType}. ` +\n        `\"${normalized}\" is not a valid transformationFormat for ${fileFormat} source files.`\n    );\n  }\n\n  return normalized;\n}\n\n/**\n * Returns the API upload/enqueue property for a file type when one is configured.\n */\nexport function getTransformFormatProperty(\n  settings: Settings,\n  fileType: SupportedFileExtension\n): { transformFormat?: FileFormat } {\n  const transformFormat = settings.files?.transformFormats?.[fileType];\n  return transformFormat ? { transformFormat } : {};\n}\n\n/**\n * Returns the preferred file extension for a translated file format.\n */\nexport function getFileExtensionForFormat(format: FileFormat): string {\n  return FILE_FORMAT_EXTENSIONS[format];\n}\n\n/**\n * Rewrites a path's extension to match the translated file format.\n */\nexport function replaceFileExtensionForFormat(\n  filePath: string,\n  format: FileFormat\n): string {\n  const extension = getFileExtensionForFormat(format);\n  return /\\.[^/.]+$/.test(filePath)\n    ? filePath.replace(/\\.[^/.]+$/, `.${extension}`)\n    : `${filePath}.${extension}`;\n}\n\n/**\n * Detects whether any configured format transform changes the output file type.\n */\nexport function hasNonIdentityFileFormatTransform(settings: Settings): boolean {\n  return Object.entries(settings.files?.transformFormats || {}).some(\n    ([fileType, transformFormat]) =>\n      transformFormat &&\n      CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType as SupportedFileExtension] !==\n        transformFormat\n  );\n}\n\n/**\n * Returns true when the configured transform for a file type changes its format.\n */\nexport function hasNonIdentityFileFormatTransformForType(\n  settings: Settings,\n  fileType: SupportedFileExtension\n): boolean {\n  const transformFormat = settings.files?.transformFormats?.[fileType];\n  return !!(\n    transformFormat &&\n    CONFIG_FILE_TYPE_TO_FILE_FORMAT[fileType] !== transformFormat\n  );\n}\n"],"mappings":";;;;;AAWA,MAAa,kCAAkC;CAC7C,MAAM;CACN,KAAK;CACL,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,MAAM;CACN,MAAM;CACN,KAAK;CACL,mBAAmB;CACpB;;;;AAKD,MAAa,kCAAkC;CAC7C,MAAM;CACN,KAAK;CACL,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,MAAM;CACN,MAAM;CACN,KAAK;CACL,qBAAqB;CACtB;;;;AAKD,MAAM,yBAAyB;CAC7B,QAAQ;CACR,MAAM;CACN,IAAI;CACJ,KAAK;CACL,MAAM;CACN,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,MAAM;CACN,KAAK;CACL,qBAAqB;CACtB;;;;;;;AAQD,SAAgB,sBAAsB,OAAmC;CACvE,MAAM,aAAa,EAAE,GAAG,OAAO;AAE/B,MAAK,MAAM,CAAC,YAAY,aAAa,OAAO,QAC1C,gCACD,EAAwC;EACvC,MAAM,kBAAkB,WAAW;AAGnC,MAAI,CAAC,WAAW,aAAa,gBAC3B,YAAW,YAAY;AAEzB,SAAO,WAAW;;AAGpB,QAAO;;;;;;;;AAST,SAAgB,4BACd,UACA,sBACwB;AACxB,KAAI,CAAC,qBAAsB,QAAO,KAAA;CAGlC,MAAM,aAAa,qBAAqB,aAAa;CACrD,MAAM,aAAa,gCAAgC;AAEnD,KAAI,CAAC,+BAA+B,YAAY,WAAW,CACzD,OAAM,IAAI,MACR,sCAAsC,WAAW,MAAM,WAAW,YAAY,SAAS,KACjF,WAAW,4CAA4C,WAAW,gBACzE;AAGH,QAAO;;;;;AAMT,SAAgB,2BACd,UACA,UACkC;CAClC,MAAM,kBAAkB,SAAS,OAAO,mBAAmB;AAC3D,QAAO,kBAAkB,EAAE,iBAAiB,GAAG,EAAE;;;;;AAMnD,SAAgB,0BAA0B,QAA4B;AACpE,QAAO,uBAAuB;;;;;AAMhC,SAAgB,8BACd,UACA,QACQ;CACR,MAAM,YAAY,0BAA0B,OAAO;AACnD,QAAO,YAAY,KAAK,SAAS,GAC7B,SAAS,QAAQ,aAAa,IAAI,YAAY,GAC9C,GAAG,SAAS,GAAG;;;;;AAMrB,SAAgB,kCAAkC,UAA6B;AAC7E,QAAO,OAAO,QAAQ,SAAS,OAAO,oBAAoB,EAAE,CAAC,CAAC,MAC3D,CAAC,UAAU,qBACV,mBACA,gCAAgC,cAC9B,gBACL;;;;;AAMH,SAAgB,yCACd,UACA,UACS;CACT,MAAM,kBAAkB,SAAS,OAAO,mBAAmB;AAC3D,QAAO,CAAC,EACN,mBACA,gCAAgC,cAAc"}

package/dist/formats/json/extractJson.js

@@ -1,112 +1,85 @@
-import { logger } from '../../console/logger.js';
-import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, validateJsonSchema, } from './utils.js';
-import { flattenJsonWithStringFilter } from './flattenJson.js';
-import { gt } from '../../utils/gt.js';
-import { applyStructuralTransforms } from './transformJson.js';
+import { logger } from "../../console/logger.js";
+import { gt } from "../../utils/gt.js";
+import { flattenJsonWithStringFilter } from "./flattenJson.js";
+import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, validateJsonSchema } from "./utils.js";
+import { applyStructuralTransforms } from "./transformJson.js";
+//#region src/formats/json/extractJson.ts
 /**
- * Extracts translated values from a full JSON file back into composite JSON format.
- * This is the inverse of mergeJson - it takes a merged/reconstructed JSON file
- * and extracts the values for a specific locale into the composite structure
- * that the server expects.
- *
- * @param localContent - The full JSON content from the user's local file
- * @param inputPath - The path to the file (used for matching jsonSchema)
- * @param options - Additional options containing jsonSchema config
- * @param targetLocale - The locale to extract values for
- * @param defaultLocale - The default/source locale
- * @returns The composite JSON string, or null if no extraction needed
- */
-export function extractJson(localContent, inputPath, options, targetLocale, defaultLocale) {
-    const jsonSchema = validateJsonSchema(options, inputPath);
-    if (!jsonSchema) {
-        // No schema
-        return null;
-    }
-    let localJson;
-    try {
-        localJson = JSON.parse(localContent);
-    }
-    catch {
-        logger.error(`Invalid JSON file: ${inputPath}`);
-        return null;
-    }
-    const useCanonicalLocaleKeys = options?.experimentalCanonicalLocaleKeys ?? false;
-    const canonicalTargetLocale = useCanonicalLocaleKeys
-        ? gt.resolveCanonicalLocale(targetLocale)
-        : targetLocale;
-    const canonicalDefaultLocale = useCanonicalLocaleKeys
-        ? gt.resolveCanonicalLocale(defaultLocale)
-        : defaultLocale;
-    if (jsonSchema.structuralTransform && jsonSchema.composite) {
-        applyStructuralTransforms(localJson, jsonSchema.structuralTransform, jsonSchema.composite);
-    }
-    // Handle include-style schemas (simple path-based extraction)
-    if (jsonSchema.include) {
-        const extracted = flattenJsonWithStringFilter(localJson, jsonSchema.include);
-        return JSON.stringify(extracted, null, 2);
-    }
-    if (!jsonSchema.composite) {
-        logger.error('No include or composite property found in JSON schema');
-        return null;
-    }
-    // Handle composite schemas
-    const compositeResult = {};
-    // Generate source object pointers from the local JSON
-    const sourceObjectPointers = generateSourceObjectPointers(jsonSchema.composite, localJson);
-    for (const [sourceObjectPointer, { sourceObjectValue, sourceObjectOptions },] of Object.entries(sourceObjectPointers)) {
-        if (sourceObjectOptions.type === 'array') {
-            if (!Array.isArray(sourceObjectValue)) {
-                logger.warn(`Source object value is not an array at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // Find the matching items for the target locale
-            const matchingTargetLocaleItems = findMatchingItemArray(canonicalTargetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            if (!Object.keys(matchingTargetLocaleItems).length) {
-                logger.warn(`No matching items found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // Also find default locale items
-            const matchingDefaultLocaleItems = findMatchingItemArray(canonicalDefaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
-            const defaultKeys = Object.keys(matchingDefaultLocaleItems);
-            const targetEntries = Object.entries(matchingTargetLocaleItems);
-            // Initialize the nested structure for this source object pointer
-            if (!compositeResult[sourceObjectPointer]) {
-                compositeResult[sourceObjectPointer] = {};
-            }
-            // For each target item, use the default locale's key position
-            for (let i = 0; i < targetEntries.length; i++) {
-                const [, { sourceItem }] = targetEntries[i];
-                // Extract values at the include paths
-                const extractedValues = flattenJsonWithStringFilter(sourceItem, sourceObjectOptions.include);
-                // Use default locale key
-                const outputKey = i < defaultKeys.length ? defaultKeys[i] : targetEntries[i][0];
-                compositeResult[sourceObjectPointer][outputKey] =
-                    extractedValues;
-            }
-        }
-        else {
-            // Object type
-            if (typeof sourceObjectValue !== 'object' || sourceObjectValue === null) {
-                logger.warn(`Source object value is not an object at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            const sourceObjectRecord = sourceObjectValue;
-            // Find the matching item for the target locale
-            const matchingTargetItem = findMatchingItemObject(canonicalTargetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectRecord);
-            if (!matchingTargetItem.sourceItem) {
-                logger.warn(`No matching item found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
-                continue;
-            }
-            // If the source item is a string, use it directly
-            if (typeof matchingTargetItem.sourceItem === 'string') {
-                compositeResult[sourceObjectPointer] = matchingTargetItem.sourceItem;
-                continue;
-            }
-            // Extract values at the include paths
-            const extractedValues = flattenJsonWithStringFilter(matchingTargetItem.sourceItem, sourceObjectOptions.include);
-            // Store the extracted values
-            compositeResult[sourceObjectPointer] = extractedValues;
-        }
-    }
-    return JSON.stringify(compositeResult, null, 2);
+* Extracts translated values from a full JSON file back into composite JSON format.
+* This is the inverse of mergeJson - it takes a merged/reconstructed JSON file
+* and extracts the values for a specific locale into the composite structure
+* that the server expects.
+*
+* @param localContent - The full JSON content from the user's local file
+* @param inputPath - The path to the file (used for matching jsonSchema)
+* @param options - Additional options containing jsonSchema config
+* @param targetLocale - The locale to extract values for
+* @param defaultLocale - The default/source locale
+* @returns The composite JSON string, or null if no extraction needed
+*/
+function extractJson(localContent, inputPath, options, targetLocale, defaultLocale) {
+	const jsonSchema = validateJsonSchema(options, inputPath);
+	if (!jsonSchema) return null;
+	let localJson;
+	try {
+		localJson = JSON.parse(localContent);
+	} catch {
+		logger.error(`Invalid JSON file: ${inputPath}`);
+		return null;
+	}
+	const useCanonicalLocaleKeys = options?.experimentalCanonicalLocaleKeys ?? false;
+	const canonicalTargetLocale = useCanonicalLocaleKeys ? gt.resolveCanonicalLocale(targetLocale) : targetLocale;
+	const canonicalDefaultLocale = useCanonicalLocaleKeys ? gt.resolveCanonicalLocale(defaultLocale) : defaultLocale;
+	if (jsonSchema.structuralTransform && jsonSchema.composite) applyStructuralTransforms(localJson, jsonSchema.structuralTransform, jsonSchema.composite);
+	if (jsonSchema.include) {
+		const extracted = flattenJsonWithStringFilter(localJson, jsonSchema.include);
+		return JSON.stringify(extracted, null, 2);
+	}
+	if (!jsonSchema.composite) {
+		logger.error("No include or composite property found in JSON schema");
+		return null;
+	}
+	const compositeResult = {};
+	const sourceObjectPointers = generateSourceObjectPointers(jsonSchema.composite, localJson);
+	for (const [sourceObjectPointer, { sourceObjectValue, sourceObjectOptions }] of Object.entries(sourceObjectPointers)) if (sourceObjectOptions.type === "array") {
+		if (!Array.isArray(sourceObjectValue)) {
+			logger.warn(`Source object value is not an array at path: ${sourceObjectPointer}`);
+			continue;
+		}
+		const matchingTargetLocaleItems = findMatchingItemArray(canonicalTargetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+		if (!Object.keys(matchingTargetLocaleItems).length) {
+			logger.warn(`No matching items found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
+			continue;
+		}
+		const matchingDefaultLocaleItems = findMatchingItemArray(canonicalDefaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+		const defaultKeys = Object.keys(matchingDefaultLocaleItems);
+		const targetEntries = Object.entries(matchingTargetLocaleItems);
+		if (!compositeResult[sourceObjectPointer]) compositeResult[sourceObjectPointer] = {};
+		for (let i = 0; i < targetEntries.length; i++) {
+			const [, { sourceItem }] = targetEntries[i];
+			const extractedValues = flattenJsonWithStringFilter(sourceItem, sourceObjectOptions.include);
+			const outputKey = i < defaultKeys.length ? defaultKeys[i] : targetEntries[i][0];
+			compositeResult[sourceObjectPointer][outputKey] = extractedValues;
+		}
+	} else {
+		if (typeof sourceObjectValue !== "object" || sourceObjectValue === null) {
+			logger.warn(`Source object value is not an object at path: ${sourceObjectPointer}`);
+			continue;
+		}
+		const matchingTargetItem = findMatchingItemObject(canonicalTargetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+		if (!matchingTargetItem.sourceItem) {
+			logger.warn(`No matching item found for locale ${targetLocale} at path: ${sourceObjectPointer}`);
+			continue;
+		}
+		if (typeof matchingTargetItem.sourceItem === "string") {
+			compositeResult[sourceObjectPointer] = matchingTargetItem.sourceItem;
+			continue;
+		}
+		compositeResult[sourceObjectPointer] = flattenJsonWithStringFilter(matchingTargetItem.sourceItem, sourceObjectOptions.include);
+	}
+	return JSON.stringify(compositeResult, null, 2);
 }
+//#endregion
+export { extractJson };
+
+//# sourceMappingURL=extractJson.js.map

package/dist/formats/json/extractJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractJson.js","names":["sourceObjectRecord"],"sources":["../../../src/formats/json/extractJson.ts"],"sourcesContent":["import { AdditionalOptions } from '../../types/index.js';\nimport { logger } from '../../console/logger.js';\nimport {\n  findMatchingItemArray,\n  findMatchingItemObject,\n  generateSourceObjectPointers,\n  validateJsonSchema,\n} from './utils.js';\nimport { flattenJsonWithStringFilter } from './flattenJson.js';\nimport { gt } from '../../utils/gt.js';\nimport { applyStructuralTransforms } from './transformJson.js';\nimport type { JSONObject, JSONValue } from '../../types/data/json.js';\n\n/**\n * Extracts translated values from a full JSON file back into composite JSON format.\n * This is the inverse of mergeJson - it takes a merged/reconstructed JSON file\n * and extracts the values for a specific locale into the composite structure\n * that the server expects.\n *\n * @param localContent - The full JSON content from the user's local file\n * @param inputPath - The path to the file (used for matching jsonSchema)\n * @param options - Additional options containing jsonSchema config\n * @param targetLocale - The locale to extract values for\n * @param defaultLocale - The default/source locale\n * @returns The composite JSON string, or null if no extraction needed\n */\nexport function extractJson(\n  localContent: string,\n  inputPath: string,\n  options: AdditionalOptions,\n  targetLocale: string,\n  defaultLocale: string\n): string | null {\n  const jsonSchema = validateJsonSchema(options, inputPath);\n  if (!jsonSchema) {\n    // No schema\n    return null;\n  }\n\n  let localJson: JSONValue;\n  try {\n    localJson = JSON.parse(localContent);\n  } catch {\n    logger.error(`Invalid JSON file: ${inputPath}`);\n    return null;\n  }\n\n  const useCanonicalLocaleKeys =\n    options?.experimentalCanonicalLocaleKeys ?? false;\n  const canonicalTargetLocale = useCanonicalLocaleKeys\n    ? gt.resolveCanonicalLocale(targetLocale)\n    : targetLocale;\n  const canonicalDefaultLocale = useCanonicalLocaleKeys\n    ? gt.resolveCanonicalLocale(defaultLocale)\n    : defaultLocale;\n\n  if (jsonSchema.structuralTransform && jsonSchema.composite) {\n    applyStructuralTransforms(\n      localJson,\n      jsonSchema.structuralTransform,\n      jsonSchema.composite\n    );\n  }\n\n  // Handle include-style schemas (simple path-based extraction)\n  if (jsonSchema.include) {\n    const extracted = flattenJsonWithStringFilter(\n      localJson,\n      jsonSchema.include\n    );\n    return JSON.stringify(extracted, null, 2);\n  }\n\n  if (!jsonSchema.composite) {\n    logger.error('No include or composite property found in JSON schema');\n    return null;\n  }\n\n  // Handle composite schemas\n  const compositeResult: Record<string, JSONValue> = {};\n\n  // Generate source object pointers from the local JSON\n  const sourceObjectPointers = generateSourceObjectPointers(\n    jsonSchema.composite,\n    localJson\n  );\n\n  for (const [\n    sourceObjectPointer,\n    { sourceObjectValue, sourceObjectOptions },\n  ] of Object.entries(sourceObjectPointers)) {\n    if (sourceObjectOptions.type === 'array') {\n      if (!Array.isArray(sourceObjectValue)) {\n        logger.warn(\n          `Source object value is not an array at path: ${sourceObjectPointer}`\n        );\n        continue;\n      }\n\n      // Find the matching items for the target locale\n      const matchingTargetLocaleItems = findMatchingItemArray(\n        canonicalTargetLocale,\n        sourceObjectOptions,\n        sourceObjectPointer,\n        sourceObjectValue\n      );\n\n      if (!Object.keys(matchingTargetLocaleItems).length) {\n        logger.warn(\n          `No matching items found for locale ${targetLocale} at path: ${sourceObjectPointer}`\n        );\n        continue;\n      }\n\n      // Also find default locale items\n      const matchingDefaultLocaleItems = findMatchingItemArray(\n        canonicalDefaultLocale,\n        sourceObjectOptions,\n        sourceObjectPointer,\n        sourceObjectValue\n      );\n\n      const defaultKeys = Object.keys(matchingDefaultLocaleItems);\n      const targetEntries = Object.entries(matchingTargetLocaleItems);\n\n      // Initialize the nested structure for this source object pointer\n      if (!compositeResult[sourceObjectPointer]) {\n        compositeResult[sourceObjectPointer] = {};\n      }\n\n      // For each target item, use the default locale's key position\n      for (let i = 0; i < targetEntries.length; i++) {\n        const [, { sourceItem }] = targetEntries[i];\n        // Extract values at the include paths\n        const extractedValues = flattenJsonWithStringFilter(\n          sourceItem,\n          sourceObjectOptions.include\n        );\n\n        // Use default locale key\n        const outputKey =\n          i < defaultKeys.length ? defaultKeys[i] : targetEntries[i][0];\n        (compositeResult[sourceObjectPointer] as JSONObject)[outputKey] =\n          extractedValues;\n      }\n    } else {\n      // Object type\n      if (typeof sourceObjectValue !== 'object' || sourceObjectValue === null) {\n        logger.warn(\n          `Source object value is not an object at path: ${sourceObjectPointer}`\n        );\n        continue;\n      }\n      const sourceObjectRecord = sourceObjectValue as JSONObject;\n\n      // Find the matching item for the target locale\n      const matchingTargetItem = findMatchingItemObject(\n        canonicalTargetLocale,\n        sourceObjectPointer,\n        sourceObjectOptions,\n        sourceObjectRecord\n      );\n\n      if (!matchingTargetItem.sourceItem) {\n        logger.warn(\n          `No matching item found for locale ${targetLocale} at path: ${sourceObjectPointer}`\n        );\n        continue;\n      }\n\n      // If the source item is a string, use it directly\n      if (typeof matchingTargetItem.sourceItem === 'string') {\n        compositeResult[sourceObjectPointer] = matchingTargetItem.sourceItem;\n        continue;\n      }\n\n      // Extract values at the include paths\n      const extractedValues = flattenJsonWithStringFilter(\n        matchingTargetItem.sourceItem as JSONObject,\n        sourceObjectOptions.include\n      );\n\n      // Store the extracted values\n      compositeResult[sourceObjectPointer] = extractedValues;\n    }\n  }\n\n  return JSON.stringify(compositeResult, null, 2);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,YACd,cACA,WACA,SACA,cACA,eACe;CACf,MAAM,aAAa,mBAAmB,SAAS,UAAU;AACzD,KAAI,CAAC,WAEH,QAAO;CAGT,IAAI;AACJ,KAAI;AACF,cAAY,KAAK,MAAM,aAAa;SAC9B;AACN,SAAO,MAAM,sBAAsB,YAAY;AAC/C,SAAO;;CAGT,MAAM,yBACJ,SAAS,mCAAmC;CAC9C,MAAM,wBAAwB,yBAC1B,GAAG,uBAAuB,aAAa,GACvC;CACJ,MAAM,yBAAyB,yBAC3B,GAAG,uBAAuB,cAAc,GACxC;AAEJ,KAAI,WAAW,uBAAuB,WAAW,UAC/C,2BACE,WACA,WAAW,qBACX,WAAW,UACZ;AAIH,KAAI,WAAW,SAAS;EACtB,MAAM,YAAY,4BAChB,WACA,WAAW,QACZ;AACD,SAAO,KAAK,UAAU,WAAW,MAAM,EAAE;;AAG3C,KAAI,CAAC,WAAW,WAAW;AACzB,SAAO,MAAM,wDAAwD;AACrE,SAAO;;CAIT,MAAM,kBAA6C,EAAE;CAGrD,MAAM,uBAAuB,6BAC3B,WAAW,WACX,UACD;AAED,MAAK,MAAM,CACT,qBACA,EAAE,mBAAmB,0BAClB,OAAO,QAAQ,qBAAqB,CACvC,KAAI,oBAAoB,SAAS,SAAS;AACxC,MAAI,CAAC,MAAM,QAAQ,kBAAkB,EAAE;AACrC,UAAO,KACL,gDAAgD,sBACjD;AACD;;EAIF,MAAM,4BAA4B,sBAChC,uBACA,qBACA,qBACA,kBACD;AAED,MAAI,CAAC,OAAO,KAAK,0BAA0B,CAAC,QAAQ;AAClD,UAAO,KACL,sCAAsC,aAAa,YAAY,sBAChE;AACD;;EAIF,MAAM,6BAA6B,sBACjC,wBACA,qBACA,qBACA,kBACD;EAED,MAAM,cAAc,OAAO,KAAK,2BAA2B;EAC3D,MAAM,gBAAgB,OAAO,QAAQ,0BAA0B;AAG/D,MAAI,CAAC,gBAAgB,qBACnB,iBAAgB,uBAAuB,EAAE;AAI3C,OAAK,IAAI,IAAI,GAAG,IAAI,cAAc,QAAQ,KAAK;GAC7C,MAAM,GAAG,EAAE,gBAAgB,cAAc;GAEzC,MAAM,kBAAkB,4BACtB,YACA,oBAAoB,QACrB;GAGD,MAAM,YACJ,IAAI,YAAY,SAAS,YAAY,KAAK,cAAc,GAAG;AAC5D,mBAAgB,qBAAoC,aACnD;;QAEC;AAEL,MAAI,OAAO,sBAAsB,YAAY,sBAAsB,MAAM;AACvE,UAAO,KACL,iDAAiD,sBAClD;AACD;;EAKF,MAAM,qBAAqB,uBACzB,uBACA,qBACA,qBACAA,kBACD;AAED,MAAI,CAAC,mBAAmB,YAAY;AAClC,UAAO,KACL,qCAAqC,aAAa,YAAY,sBAC/D;AACD;;AAIF,MAAI,OAAO,mBAAmB,eAAe,UAAU;AACrD,mBAAgB,uBAAuB,mBAAmB;AAC1D;;AAUF,kBAAgB,uBANQ,4BACtB,mBAAmB,YACnB,oBAAoB,QAIgC;;AAI1D,QAAO,KAAK,UAAU,iBAAiB,MAAM,EAAE"}

package/dist/formats/json/flattenJson.js

@@ -1,52 +1,45 @@
-import { logger } from '../../console/logger.js';
-import { getJSONPathMatches } from './jsonPath.js';
+import { logger } from "../../console/logger.js";
+import { getJSONPathMatches } from "./jsonPath.js";
+//#region src/formats/json/flattenJson.ts
 /**
- * Flattens a JSON object according to a list of JSON paths.
- * @param json - The JSON object to flatten
- * @param jsonPaths - The list of JSON paths to flatten
- * @returns A mapping of json pointers to their values
- */
-export function flattenJson(json, jsonPaths) {
-    const extractedJson = {};
-    for (const jsonPath of jsonPaths) {
-        try {
-            const results = getJSONPathMatches(json, jsonPath);
-            if (!results || results.length === 0) {
-                continue;
-            }
-            results.forEach((result) => {
-                extractedJson[result.pointer] = result.value;
-            });
-        }
-        catch {
-            logger.error(`Error with JSONPath pattern: ${jsonPath}`);
-        }
-    }
-    return extractedJson;
+* Flattens a JSON object according to a list of JSON paths.
+* @param json - The JSON object to flatten
+* @param jsonPaths - The list of JSON paths to flatten
+* @returns A mapping of json pointers to their values
+*/
+function flattenJson(json, jsonPaths) {
+	const extractedJson = {};
+	for (const jsonPath of jsonPaths) try {
+		const results = getJSONPathMatches(json, jsonPath);
+		if (!results || results.length === 0) continue;
+		results.forEach((result) => {
+			extractedJson[result.pointer] = result.value;
+		});
+	} catch {
+		logger.error(`Error with JSONPath pattern: ${jsonPath}`);
+	}
+	return extractedJson;
 }
 /**
- * Flattens a JSON object according to a list of JSON paths, only including strings
- * @param json - The JSON object to flatten
- * @param jsonPaths - The list of JSON paths to flatten
- * @returns A mapping of json pointers to their values
- */
-export function flattenJsonWithStringFilter(json, jsonPaths) {
-    const extractedJson = {};
-    for (const jsonPath of jsonPaths) {
-        try {
-            const results = getJSONPathMatches(json, jsonPath);
-            if (!results || results.length === 0) {
-                continue;
-            }
-            results.forEach((result) => {
-                if (typeof result.value === 'string') {
-                    extractedJson[result.pointer] = result.value;
-                }
-            });
-        }
-        catch {
-            logger.error(`Error with JSONPath pattern: ${jsonPath}`);
-        }
-    }
-    return extractedJson;
+* Flattens a JSON object according to a list of JSON paths, only including strings
+* @param json - The JSON object to flatten
+* @param jsonPaths - The list of JSON paths to flatten
+* @returns A mapping of json pointers to their values
+*/
+function flattenJsonWithStringFilter(json, jsonPaths) {
+	const extractedJson = {};
+	for (const jsonPath of jsonPaths) try {
+		const results = getJSONPathMatches(json, jsonPath);
+		if (!results || results.length === 0) continue;
+		results.forEach((result) => {
+			if (typeof result.value === "string") extractedJson[result.pointer] = result.value;
+		});
+	} catch {
+		logger.error(`Error with JSONPath pattern: ${jsonPath}`);
+	}
+	return extractedJson;
 }
+//#endregion
+export { flattenJson, flattenJsonWithStringFilter };
+
+//# sourceMappingURL=flattenJson.js.map

package/dist/formats/json/flattenJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenJson.js","names":[],"sources":["../../../src/formats/json/flattenJson.ts"],"sourcesContent":["import { logger } from '../../console/logger.js';\nimport type { JSONValue } from '../../types/data/json.js';\nimport { getJSONPathMatches } from './jsonPath.js';\n\n/**\n * Flattens a JSON object according to a list of JSON paths.\n * @param json - The JSON object to flatten\n * @param jsonPaths - The list of JSON paths to flatten\n * @returns A mapping of json pointers to their values\n */\nexport function flattenJson(\n  json: unknown,\n  jsonPaths: string[]\n): Record<string, JSONValue> {\n  const extractedJson: Record<string, JSONValue> = {};\n  for (const jsonPath of jsonPaths) {\n    try {\n      const results = getJSONPathMatches(json as JSONValue, jsonPath);\n      if (!results || results.length === 0) {\n        continue;\n      }\n      results.forEach((result) => {\n        extractedJson[result.pointer] = result.value;\n      });\n    } catch {\n      logger.error(`Error with JSONPath pattern: ${jsonPath}`);\n    }\n  }\n  return extractedJson;\n}\n\n/**\n * Flattens a JSON object according to a list of JSON paths, only including strings\n * @param json - The JSON object to flatten\n * @param jsonPaths - The list of JSON paths to flatten\n * @returns A mapping of json pointers to their values\n */\nexport function flattenJsonWithStringFilter(\n  json: unknown,\n  jsonPaths: string[]\n): Record<string, string> {\n  const extractedJson: Record<string, string> = {};\n  for (const jsonPath of jsonPaths) {\n    try {\n      const results = getJSONPathMatches(json as JSONValue, jsonPath);\n      if (!results || results.length === 0) {\n        continue;\n      }\n      results.forEach((result) => {\n        if (typeof result.value === 'string') {\n          extractedJson[result.pointer] = result.value;\n        }\n      });\n    } catch {\n      logger.error(`Error with JSONPath pattern: ${jsonPath}`);\n    }\n  }\n  return extractedJson;\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,YACd,MACA,WAC2B;CAC3B,MAAM,gBAA2C,EAAE;AACnD,MAAK,MAAM,YAAY,UACrB,KAAI;EACF,MAAM,UAAU,mBAAmB,MAAmB,SAAS;AAC/D,MAAI,CAAC,WAAW,QAAQ,WAAW,EACjC;AAEF,UAAQ,SAAS,WAAW;AAC1B,iBAAc,OAAO,WAAW,OAAO;IACvC;SACI;AACN,SAAO,MAAM,gCAAgC,WAAW;;AAG5D,QAAO;;;;;;;;AAST,SAAgB,4BACd,MACA,WACwB;CACxB,MAAM,gBAAwC,EAAE;AAChD,MAAK,MAAM,YAAY,UACrB,KAAI;EACF,MAAM,UAAU,mBAAmB,MAAmB,SAAS;AAC/D,MAAI,CAAC,WAAW,QAAQ,WAAW,EACjC;AAEF,UAAQ,SAAS,WAAW;AAC1B,OAAI,OAAO,OAAO,UAAU,SAC1B,eAAc,OAAO,WAAW,OAAO;IAEzC;SACI;AACN,SAAO,MAAM,gCAAgC,WAAW;;AAG5D,QAAO"}