generaltranslation 8.2.11 → 8.2.13

package/dist/backwards-compatability/dataConversion.js

@@ -0,0 +1,207 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { isOldJsxChildren, isNewVariableObject, isOldVariableObject, } from './typeChecking';
+/**
+ * Convert request data from old format to new format
+ */
+export function getNewJsxChild(child) {
+    // string (end case)
+    if (typeof child === 'string') {
+        return child;
+    }
+    // VariableObject
+    if (isOldVariableObject(child)) {
+        return getNewVariableObject(child);
+    }
+    // JsxElement
+    return getNewJsxElement(child);
+}
+export function getNewJsxChildren(children) {
+    // string (end case)
+    if (typeof children === 'string') {
+        return children;
+    }
+    // Array
+    if (Array.isArray(children)) {
+        return children.map(getNewJsxChild);
+    }
+    // Object
+    return getNewJsxChild(children);
+}
+export function getNewJsxElement(element) {
+    var _a;
+    // string (end case)
+    if (typeof element === 'string') {
+        return element;
+    }
+    // type
+    var t = undefined;
+    if (element.type != null) {
+        t = element.type;
+    }
+    // children
+    var c = undefined;
+    if (((_a = element.props) === null || _a === void 0 ? void 0 : _a.children) != null) {
+        c = getNewJsxChildren(element.props.children);
+    }
+    return __assign(__assign(__assign({}, (t && { t: t })), (c && { c: c })), { d: getNewGTProp(element.props['data-_gt']), i: element.props['data-_gt'].id });
+}
+export function getNewBranchType(branch) {
+    if (branch === 'branch') {
+        return 'b';
+    }
+    return 'p';
+}
+export function getNewVariableType(variable) {
+    switch (variable) {
+        case 'number':
+            return 'n';
+        case 'variable':
+            return 'v';
+        case 'datetime':
+            return 'd';
+        case 'currency':
+            return 'c';
+        default:
+            return 'v';
+    }
+}
+export function getNewVariableObject(variable) {
+    // variable type
+    var v = undefined;
+    if (variable.variable != null) {
+        v = getNewVariableType(variable.variable);
+    }
+    // variable id
+    var i = undefined;
+    if (variable.id != null) {
+        i = variable.id;
+    }
+    return __assign(__assign({ k: variable.key }, (v && { v: v })), (i && { i: i }));
+}
+export function getNewGTProp(dataGT) {
+    // branches
+    var b = undefined;
+    if (dataGT.branches) {
+        b = Object.fromEntries(Object.entries(dataGT.branches).map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return [
+                key,
+                getNewJsxChildren(value),
+            ];
+        }));
+    }
+    // transformation
+    var t;
+    if (dataGT.transformation) {
+        t = getNewBranchType(dataGT.transformation);
+    }
+    return __assign(__assign({}, (b && { b: b })), (t && { t: t }));
+}
+/**
+ * Convert response data from current format to old format
+ */
+export function getOldJsxChild(child) {
+    // string (end case)
+    if (typeof child === 'string') {
+        return child;
+    }
+    // VariableObject
+    if (isNewVariableObject(child)) {
+        return getOldVariableObject(child);
+    }
+    // JsxElement
+    return getOldJsxElement(child);
+}
+export function getOldJsxChildren(children) {
+    // if children is already old, return it
+    if (isOldJsxChildren(children)) {
+        return children;
+    }
+    // string (end case)
+    if (typeof children === 'string') {
+        return children;
+    }
+    // Array
+    if (Array.isArray(children)) {
+        return children.map(getOldJsxChild);
+    }
+    // Object
+    return getOldJsxChild(children);
+}
+export function getOldJsxElement(element) {
+    // type (can assume that type will exist here)
+    var type = element.t;
+    // children
+    var children = undefined;
+    if (element.c != null) {
+        children = getOldJsxChildren(element.c);
+    }
+    // data-_gt (can assume id will exist here)
+    var dataGT = getOldGTProp(element.d || {}, element.i);
+    return {
+        type: type,
+        props: { children: children, 'data-_gt': dataGT },
+    };
+}
+export function getOldBranchType(branch) {
+    if (branch === 'b') {
+        return 'branch';
+    }
+    return 'plural';
+}
+export function getOldVariableType(variable) {
+    switch (variable) {
+        case 'n':
+            return 'number';
+        case 'v':
+            return 'variable';
+        case 'd':
+            return 'datetime';
+        case 'c':
+            return 'currency';
+        default:
+            return 'variable';
+    }
+}
+export function getOldVariableObject(variable) {
+    // variable type
+    var v = undefined;
+    if (variable.v != null) {
+        v = getOldVariableType(variable.v);
+    }
+    // variable id
+    var i = undefined;
+    if (variable.i != null) {
+        i = variable.i;
+    }
+    return __assign(__assign({ key: variable.k }, (v && { variable: v })), (i && { id: i }));
+}
+export function getOldGTProp(dataGT, i) {
+    // transformation
+    var transformation = undefined;
+    if (dataGT.t != null) {
+        transformation = getOldBranchType(dataGT.t);
+    }
+    // branches
+    var branches = undefined;
+    if (dataGT.b != null) {
+        branches = Object.fromEntries(Object.entries(dataGT.b).map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return [
+                key,
+                getOldJsxChildren(value),
+            ];
+        }));
+    }
+    return __assign(__assign({ id: i }, (transformation && { transformation: transformation })), (branches && { branches: branches }));
+}

package/dist/backwards-compatability/oldHashJsxChildren.d.ts

@@ -0,0 +1,23 @@
+import { OldJsxChildren } from './oldTypes';
+/**
+ * Calculates a unique hash for a given string using SHA-256.
+ *
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The resulting hash as a hexadecimal string.
+ */
+export declare function oldHashString(string: string): string;
+/**
+ * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.
+ *
+ * @param {any} childrenAsObjects - The children objects to be hashed.
+ * @param {string} context - The context for the children.
+ * @param {string} id - The ID for the JSX children object.
+ * @param {function} hashFunction - Custom hash function.
+ * @returns {string} - The unique hash of the children.
+ */
+export declare function oldHashJsxChildren({ source, context, id, dataFormat, }: {
+    source: OldJsxChildren;
+    context?: string;
+    id?: string;
+    dataFormat: string;
+}, hashFunction?: (string: string) => string): string;

package/dist/backwards-compatability/oldHashJsxChildren.js

@@ -0,0 +1,79 @@
+// Functions provided to other GT libraries
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { stableStringify as stringify } from '../utils/stableStringify';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+// ----- FUNCTIONS ----- //
+/**
+ * Calculates a unique hash for a given string using SHA-256.
+ *
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The resulting hash as a hexadecimal string.
+ */
+export function oldHashString(string) {
+    return bytesToHex(sha256(utf8ToBytes(string)));
+}
+/**
+ * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.
+ *
+ * @param {any} childrenAsObjects - The children objects to be hashed.
+ * @param {string} context - The context for the children.
+ * @param {string} id - The ID for the JSX children object.
+ * @param {function} hashFunction - Custom hash function.
+ * @returns {string} - The unique hash of the children.
+ */
+export function oldHashJsxChildren(_a, hashFunction) {
+    var source = _a.source, context = _a.context, id = _a.id, dataFormat = _a.dataFormat;
+    if (hashFunction === void 0) { hashFunction = oldHashString; }
+    var unhashedKey = stringify(__assign(__assign(__assign({ source: sanitizeJsxChildren(source) }, (id && { id: id })), (context && { context: context })), (dataFormat && { dataFormat: dataFormat })));
+    return hashFunction(unhashedKey);
+}
+var sanitizeChild = function (child) {
+    var _a, _b, _c, _d;
+    if (child && typeof child === 'object') {
+        if ('props' in child) {
+            var newChild = {};
+            var dataGt = (_a = child === null || child === void 0 ? void 0 : child.props) === null || _a === void 0 ? void 0 : _a['data-_gt'];
+            if (dataGt === null || dataGt === void 0 ? void 0 : dataGt.branches) {
+                // The only thing that prevents sanitizeJsx from being stable is
+                // the order of the keys in the branches object.
+                // We don't sort them because stable-stringify sorts them anyways
+                newChild.branches = Object.fromEntries(Object.entries(dataGt.branches).map(function (_a) {
+                    var key = _a[0], value = _a[1];
+                    return [
+                        key,
+                        sanitizeJsxChildren(value),
+                    ];
+                }));
+            }
+            if ((_b = child === null || child === void 0 ? void 0 : child.props) === null || _b === void 0 ? void 0 : _b.children) {
+                newChild.children = sanitizeJsxChildren(child.props.children);
+            }
+            if ((_d = (_c = child === null || child === void 0 ? void 0 : child.props) === null || _c === void 0 ? void 0 : _c['data-_gt']) === null || _d === void 0 ? void 0 : _d.transformation) {
+                newChild.transformation = child.props['data-_gt'].transformation;
+            }
+            return newChild;
+        }
+        if ('key' in child) {
+            return __assign({ key: child.key }, (child.variable && {
+                variable: child.variable,
+            }));
+        }
+    }
+    return child;
+};
+function sanitizeJsxChildren(childrenAsObjects) {
+    return Array.isArray(childrenAsObjects)
+        ? childrenAsObjects.map(sanitizeChild)
+        : sanitizeChild(childrenAsObjects);
+}

package/dist/backwards-compatability/oldTypes.d.ts

@@ -0,0 +1,21 @@
+export type OldBranchType = 'branch' | 'plural';
+export type OldGTProp = {
+    id: number;
+    transformation?: OldBranchType;
+    branches?: Record<string, OldJsxChildren>;
+};
+export type OldJsxElement = {
+    type: string;
+    props: {
+        children?: OldJsxChildren;
+        'data-_gt': OldGTProp;
+    };
+};
+export type OldVariableType = 'number' | 'variable' | 'datetime' | 'currency';
+export type OldVariableObject = {
+    variable?: OldVariableType;
+    key: string;
+    id?: number;
+};
+export type OldJsxChild = OldJsxElement | OldVariableObject | string;
+export type OldJsxChildren = OldJsxChild | OldJsxChild[];

package/dist/backwards-compatability/oldTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/backwards-compatability/typeChecking.d.ts

@@ -0,0 +1,21 @@
+import { JsxChild, JsxChildren } from '../types';
+import { OldJsxChild, OldJsxChildren, OldVariableObject } from './oldTypes.js';
+import { Variable as VariableObject } from '../types';
+/**
+ * Checks if a JSX child is an old variable object format
+ * @param child - The JSX child to check.
+ * @returns True if the child is an old variable object (has 'key' property)
+ */
+export declare function isOldVariableObject(child: OldJsxChild | JsxChild): child is OldVariableObject;
+/**
+ * Checks if a JSX child is a new variable object format
+ * @param child - The JSX child to check.
+ * @returns True if the child is a new variable object (has 'k' property)
+ */
+export declare function isNewVariableObject(child: OldJsxChild | JsxChild): child is VariableObject;
+/**
+ * Checks if JSX children follow the old format
+ * @param children - The JSX children to check (can be string, array, or single child)
+ * @returns True if all children are in the old format.
+ */
+export declare function isOldJsxChildren(children: OldJsxChildren | JsxChildren): children is OldJsxChildren;

package/dist/backwards-compatability/typeChecking.js

@@ -0,0 +1,61 @@
+/**
+ * Checks if a JSX child is an old variable object format
+ * @param child - The JSX child to check.
+ * @returns True if the child is an old variable object (has 'key' property)
+ */
+export function isOldVariableObject(child) {
+    return typeof child === 'object' && child != null && 'key' in child;
+}
+/**
+ * Checks if a JSX child is a new variable object format
+ * @param child - The JSX child to check.
+ * @returns True if the child is a new variable object (has 'k' property)
+ */
+export function isNewVariableObject(child) {
+    return typeof child === 'object' && child != null && 'k' in child;
+}
+/**
+ * Checks if a JSX child is an old JSX element format
+ * @param child - The JSX child to check.
+ * @returns True if the child is an old JSX element (has 'type' and 'props' properties)
+ */
+function isOldJsxElement(child) {
+    return (typeof child === 'object' &&
+        child != null &&
+        'type' in child &&
+        'props' in child);
+}
+/**
+ * Checks if a JSX child follows the old format (string, old variable object, or old JSX element)
+ * @param child - The JSX child to check.
+ * @returns True if the child is in the old format.
+ */
+function isOldJsxChild(child) {
+    // string
+    if (typeof child === 'string') {
+        return true;
+    }
+    // variable object
+    if (isOldVariableObject(child)) {
+        return true;
+    }
+    // element
+    return isOldJsxElement(child);
+}
+/**
+ * Checks if JSX children follow the old format
+ * @param children - The JSX children to check (can be string, array, or single child)
+ * @returns True if all children are in the old format.
+ */
+export function isOldJsxChildren(children) {
+    // string
+    if (typeof children === 'string') {
+        return true;
+    }
+    // array
+    if (Array.isArray(children)) {
+        return !children.some(function (child) { return !isOldJsxChild(child); });
+    }
+    // object
+    return isOldJsxChild(children);
+}

package/dist/{base64-CUcEPEC5.cjs → base64-2fu94Klt.cjs}

@@ -20,8 +20,8 @@ const SUPPORTED_TRANSFORMATIONS = {
 };
 /**
 * This function checks if a file format transformation is supported during translation
-* @param from - The source file format
-* @param to - The target file format
+* @param from - The source file format.
+* @param to - The target file format.
 * @returns True if the transformation is supported, false otherwise
 */
 function isSupportedFileFormatTransform(from, to) {
@@ -108,4 +108,4 @@ Object.defineProperty(exports, "validateFileFormatTransforms", {
 	}
 });
 
-//# sourceMappingURL=base64-CUcEPEC5.cjs.map
+//# sourceMappingURL=base64-2fu94Klt.cjs.map

package/dist/base64-2fu94Klt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64-2fu94Klt.cjs","names":[],"sources":["../src/settings/settingsUrls.ts","../src/utils/isSupportedFileFormatTransform.ts","../src/translate/utils/validateFileFormatTransform.ts","../src/utils/base64.ts"],"sourcesContent":["export const defaultCacheUrl = 'https://cdn.gtx.dev' as const;\nexport const defaultBaseUrl = 'https://api2.gtx.dev' as const;\nexport const defaultRuntimeApiUrl = 'https://runtime2.gtx.dev' as const;\n","import type { FileFormat } from '../types-dir/api/file';\n\nconst SUPPORTED_TRANSFORMATIONS = {\n  GTJSON: ['GTJSON'],\n  JSON: ['JSON'],\n  PO: ['PO'],\n  // POT templates can produce translated PO catalog files.\n  POT: ['POT', 'PO'],\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: ['TWILIO_CONTENT_JSON'],\n} as const satisfies Record<FileFormat, FileFormat[]>;\n\n/**\n * This function checks if a file format transformation is supported during translation\n * @param from - The source file format.\n * @param to - The target file format.\n * @returns True if the transformation is supported, false otherwise\n */\nexport function isSupportedFileFormatTransform(\n  from: FileFormat,\n  to: FileFormat\n): boolean {\n  const toFormats: FileFormat[] | undefined = SUPPORTED_TRANSFORMATIONS[from];\n  return toFormats?.includes(to) ?? false;\n}\n","import type { FileFormat } from '../../types-dir/api/file';\nimport { isSupportedFileFormatTransform } from '../../utils/isSupportedFileFormatTransform';\n\nexport type FileFormatTransformInput = {\n  fileFormat?: FileFormat;\n  transformFormat?: FileFormat;\n  fileName?: string;\n  fileId?: string;\n};\n\n/**\n * Returns a user-facing validation error when a requested file format transform\n * is missing source format context or is not currently supported.\n */\nexport function getFileFormatTransformError(\n  file: FileFormatTransformInput\n): string | undefined {\n  if (!file.transformFormat) return undefined;\n  const fileLabel = file.fileName ?? file.fileId ?? 'unknown file';\n  if (!file.fileFormat) {\n    return `fileFormat is required when transformFormat is provided for ${fileLabel}`;\n  }\n  if (!isSupportedFileFormatTransform(file.fileFormat, file.transformFormat)) {\n    return `Unsupported file format transform: ${file.fileFormat} -> ${file.transformFormat}`;\n  }\n  return undefined;\n}\n\n/**\n * Validates file format transforms before sending upload/enqueue requests.\n */\nexport function validateFileFormatTransforms(\n  files: FileFormatTransformInput[]\n): void {\n  for (const file of files) {\n    const error = getFileFormatTransformError(file);\n    if (error) throw new Error(error);\n  }\n}\n","// Encode a string to base64\nexport function encode(data: string): string {\n  if (typeof Buffer !== 'undefined') {\n    // Node.js path.\n    return Buffer.from(data, 'utf8').toString('base64');\n  }\n  // Browser path.\n  const bytes = new TextEncoder().encode(data);\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n\n// Decode a base64 string to a string\nexport function decode(base64: string): string {\n  if (typeof Buffer !== 'undefined') {\n    // Node.js path.\n    return Buffer.from(base64, 'base64').toString('utf8');\n  }\n  // Browser path.\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return new TextDecoder().decode(bytes);\n}\n"],"mappings":";AAAA,MAAa,kBAAkB;AAC/B,MAAa,iBAAiB;AAC9B,MAAa,uBAAuB;;;ACApC,MAAM,4BAA4B;CAChC,QAAQ,CAAC,SAAS;CAClB,MAAM,CAAC,OAAO;CACd,IAAI,CAAC,KAAK;CAEV,KAAK,CAAC,OAAO,KAAK;CAClB,MAAM,CAAC,OAAO;CACd,KAAK,CAAC,MAAM;CACZ,IAAI,CAAC,KAAK;CACV,IAAI,CAAC,KAAK;CACV,IAAI,CAAC,KAAK;CACV,MAAM,CAAC,OAAO;CACd,KAAK,CAAC,MAAM;CACZ,qBAAqB,CAAC,sBAAsB;CAC7C;;;;;;;AAQD,SAAgB,+BACd,MACA,IACS;AAET,QAD4C,0BAA0B,OACpD,SAAS,GAAG,IAAI;;;;;;;;ACfpC,SAAgB,4BACd,MACoB;AACpB,KAAI,CAAC,KAAK,gBAAiB,QAAO,KAAA;CAClC,MAAM,YAAY,KAAK,YAAY,KAAK,UAAU;AAClD,KAAI,CAAC,KAAK,WACR,QAAO,+DAA+D;AAExE,KAAI,CAAC,+BAA+B,KAAK,YAAY,KAAK,gBAAgB,CACxE,QAAO,sCAAsC,KAAK,WAAW,MAAM,KAAK;;;;;AAQ5E,SAAgB,6BACd,OACM;AACN,MAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,QAAQ,4BAA4B,KAAK;AAC/C,MAAI,MAAO,OAAM,IAAI,MAAM,MAAM;;;;;ACnCrC,SAAgB,OAAO,MAAsB;AAC3C,KAAI,OAAO,WAAW,YAEpB,QAAO,OAAO,KAAK,MAAM,OAAO,CAAC,SAAS,SAAS;CAGrD,MAAM,QAAQ,IAAI,aAAa,CAAC,OAAO,KAAK;CAC5C,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAChC,WAAU,OAAO,aAAa,MAAM,GAAG;AAEzC,QAAO,KAAK,OAAO;;AAIrB,SAAgB,OAAO,QAAwB;AAC7C,KAAI,OAAO,WAAW,YAEpB,QAAO,OAAO,KAAK,QAAQ,SAAS,CAAC,SAAS,OAAO;CAGvD,MAAM,SAAS,KAAK,OAAO;CAC3B,MAAM,QAAQ,IAAI,WAAW,OAAO,OAAO;AAC3C,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,OAAM,KAAK,OAAO,WAAW,EAAE;AAEjC,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM"}

package/dist/{base64-C1sogiix.mjs → base64-DH0STixb.mjs}

@@ -20,8 +20,8 @@ const SUPPORTED_TRANSFORMATIONS = {
 };
 /**
 * This function checks if a file format transformation is supported during translation
-* @param from - The source file format
-* @param to - The target file format
+* @param from - The source file format.
+* @param to - The target file format.
 * @returns True if the transformation is supported, false otherwise
 */
 function isSupportedFileFormatTransform(from, to) {
@@ -67,4 +67,4 @@ function decode(base64) {
 //#endregion
 export { defaultBaseUrl as a, isSupportedFileFormatTransform as i, encode as n, defaultCacheUrl as o, validateFileFormatTransforms as r, defaultRuntimeApiUrl as s, decode as t };
 
-//# sourceMappingURL=base64-C1sogiix.mjs.map
+//# sourceMappingURL=base64-DH0STixb.mjs.map

package/dist/base64-DH0STixb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64-DH0STixb.mjs","names":[],"sources":["../src/settings/settingsUrls.ts","../src/utils/isSupportedFileFormatTransform.ts","../src/translate/utils/validateFileFormatTransform.ts","../src/utils/base64.ts"],"sourcesContent":["export const defaultCacheUrl = 'https://cdn.gtx.dev' as const;\nexport const defaultBaseUrl = 'https://api2.gtx.dev' as const;\nexport const defaultRuntimeApiUrl = 'https://runtime2.gtx.dev' as const;\n","import type { FileFormat } from '../types-dir/api/file';\n\nconst SUPPORTED_TRANSFORMATIONS = {\n  GTJSON: ['GTJSON'],\n  JSON: ['JSON'],\n  PO: ['PO'],\n  // POT templates can produce translated PO catalog files.\n  POT: ['POT', 'PO'],\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: ['TWILIO_CONTENT_JSON'],\n} as const satisfies Record<FileFormat, FileFormat[]>;\n\n/**\n * This function checks if a file format transformation is supported during translation\n * @param from - The source file format.\n * @param to - The target file format.\n * @returns True if the transformation is supported, false otherwise\n */\nexport function isSupportedFileFormatTransform(\n  from: FileFormat,\n  to: FileFormat\n): boolean {\n  const toFormats: FileFormat[] | undefined = SUPPORTED_TRANSFORMATIONS[from];\n  return toFormats?.includes(to) ?? false;\n}\n","import type { FileFormat } from '../../types-dir/api/file';\nimport { isSupportedFileFormatTransform } from '../../utils/isSupportedFileFormatTransform';\n\nexport type FileFormatTransformInput = {\n  fileFormat?: FileFormat;\n  transformFormat?: FileFormat;\n  fileName?: string;\n  fileId?: string;\n};\n\n/**\n * Returns a user-facing validation error when a requested file format transform\n * is missing source format context or is not currently supported.\n */\nexport function getFileFormatTransformError(\n  file: FileFormatTransformInput\n): string | undefined {\n  if (!file.transformFormat) return undefined;\n  const fileLabel = file.fileName ?? file.fileId ?? 'unknown file';\n  if (!file.fileFormat) {\n    return `fileFormat is required when transformFormat is provided for ${fileLabel}`;\n  }\n  if (!isSupportedFileFormatTransform(file.fileFormat, file.transformFormat)) {\n    return `Unsupported file format transform: ${file.fileFormat} -> ${file.transformFormat}`;\n  }\n  return undefined;\n}\n\n/**\n * Validates file format transforms before sending upload/enqueue requests.\n */\nexport function validateFileFormatTransforms(\n  files: FileFormatTransformInput[]\n): void {\n  for (const file of files) {\n    const error = getFileFormatTransformError(file);\n    if (error) throw new Error(error);\n  }\n}\n","// Encode a string to base64\nexport function encode(data: string): string {\n  if (typeof Buffer !== 'undefined') {\n    // Node.js path.\n    return Buffer.from(data, 'utf8').toString('base64');\n  }\n  // Browser path.\n  const bytes = new TextEncoder().encode(data);\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n\n// Decode a base64 string to a string\nexport function decode(base64: string): string {\n  if (typeof Buffer !== 'undefined') {\n    // Node.js path.\n    return Buffer.from(base64, 'base64').toString('utf8');\n  }\n  // Browser path.\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return new TextDecoder().decode(bytes);\n}\n"],"mappings":";AAAA,MAAa,kBAAkB;AAC/B,MAAa,iBAAiB;AAC9B,MAAa,uBAAuB;;;ACApC,MAAM,4BAA4B;CAChC,QAAQ,CAAC,SAAS;CAClB,MAAM,CAAC,OAAO;CACd,IAAI,CAAC,KAAK;CAEV,KAAK,CAAC,OAAO,KAAK;CAClB,MAAM,CAAC,OAAO;CACd,KAAK,CAAC,MAAM;CACZ,IAAI,CAAC,KAAK;CACV,IAAI,CAAC,KAAK;CACV,IAAI,CAAC,KAAK;CACV,MAAM,CAAC,OAAO;CACd,KAAK,CAAC,MAAM;CACZ,qBAAqB,CAAC,sBAAsB;CAC7C;;;;;;;AAQD,SAAgB,+BACd,MACA,IACS;AAET,QAD4C,0BAA0B,OACpD,SAAS,GAAG,IAAI;;;;;;;;ACfpC,SAAgB,4BACd,MACoB;AACpB,KAAI,CAAC,KAAK,gBAAiB,QAAO,KAAA;CAClC,MAAM,YAAY,KAAK,YAAY,KAAK,UAAU;AAClD,KAAI,CAAC,KAAK,WACR,QAAO,+DAA+D;AAExE,KAAI,CAAC,+BAA+B,KAAK,YAAY,KAAK,gBAAgB,CACxE,QAAO,sCAAsC,KAAK,WAAW,MAAM,KAAK;;;;;AAQ5E,SAAgB,6BACd,OACM;AACN,MAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,QAAQ,4BAA4B,KAAK;AAC/C,MAAI,MAAO,OAAM,IAAI,MAAM,MAAM;;;;;ACnCrC,SAAgB,OAAO,MAAsB;AAC3C,KAAI,OAAO,WAAW,YAEpB,QAAO,OAAO,KAAK,MAAM,OAAO,CAAC,SAAS,SAAS;CAGrD,MAAM,QAAQ,IAAI,aAAa,CAAC,OAAO,KAAK;CAC5C,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAChC,WAAU,OAAO,aAAa,MAAM,GAAG;AAEzC,QAAO,KAAK,OAAO;;AAIrB,SAAgB,OAAO,QAAwB;AAC7C,KAAI,OAAO,WAAW,YAEpB,QAAO,OAAO,KAAK,QAAQ,SAAS,CAAC,SAAS,OAAO;CAGvD,MAAM,SAAS,KAAK,OAAO;CAC3B,MAAM,QAAQ,IAAI,WAAW,OAAO,OAAO;AAC3C,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,OAAM,KAAK,OAAO,WAAW,EAAE;AAEjC,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM"}

package/dist/cache/IntlCache.d.ts

@@ -0,0 +1,26 @@
+import { ConstructorType, CustomIntlConstructors } from './types';
+/**
+ * Cache for Intl and custom format instances to avoid repeated instantiation
+ * Uses a two-level structure: constructor name -> cache key -> instance.
+ */
+declare class IntlCache {
+    private cache;
+    constructor();
+    /**
+     * Generates a consistent cache key from locales and options.
+     * Handles all LocalesArgument types (string, Locale, array, undefined).
+     */
+    private _generateKey;
+    /**
+     * Gets a cached Intl instance or creates a new one if not found
+     * @param constructor The name of the Intl constructor to use.
+     * @param args Constructor arguments (locales, options).
+     * @returns Cached or newly created Intl instance.
+     */
+    get<K extends keyof CustomIntlConstructors>(constructor: K, ...args: ConstructorParameters<CustomIntlConstructors[K]>): InstanceType<ConstructorType<K>>;
+}
+/**
+ * Global instance of the Intl cache for use throughout the application
+ */
+export declare const intlCache: IntlCache;
+export {};

package/dist/cache/IntlCache.js

@@ -0,0 +1,84 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { libraryDefaultLocale } from '../settings/settings';
+import { CutoffFormatConstructor } from '../formatting/custom-formats/CutoffFormat/CutoffFormat';
+/**
+ * Object mapping constructor names to their respective constructor functions
+ * Includes all native Intl constructors plus custom ones like CutoffFormat
+ */
+var CustomIntl = {
+    Collator: Intl.Collator,
+    DateTimeFormat: Intl.DateTimeFormat,
+    DisplayNames: Intl.DisplayNames,
+    ListFormat: Intl.ListFormat,
+    Locale: Intl.Locale,
+    NumberFormat: Intl.NumberFormat,
+    PluralRules: Intl.PluralRules,
+    RelativeTimeFormat: Intl.RelativeTimeFormat,
+    Segmenter: Intl.Segmenter,
+    CutoffFormat: CutoffFormatConstructor,
+};
+/**
+ * Cache for Intl and custom format instances to avoid repeated instantiation
+ * Uses a two-level structure: constructor name -> cache key -> instance.
+ */
+var IntlCache = /** @class */ (function () {
+    function IntlCache() {
+        this.cache = {};
+    }
+    /**
+     * Generates a consistent cache key from locales and options.
+     * Handles all LocalesArgument types (string, Locale, array, undefined).
+     */
+    IntlCache.prototype._generateKey = function (locales, options) {
+        if (options === void 0) { options = {}; }
+        // Normalize locales to string representation
+        var localeKey = !locales
+            ? 'undefined'
+            : Array.isArray(locales)
+                ? locales.map(function (l) { return String(l); }).join(',')
+                : String(locales);
+        // Sort option keys to ensure consistent key generation regardless of property order
+        var sortedOptions = options
+            ? JSON.stringify(options, Object.keys(options).sort())
+            : '{}';
+        return "".concat(localeKey, ":").concat(sortedOptions);
+    };
+    /**
+     * Gets a cached Intl instance or creates a new one if not found
+     * @param constructor The name of the Intl constructor to use.
+     * @param args Constructor arguments (locales, options).
+     * @returns Cached or newly created Intl instance.
+     */
+    IntlCache.prototype.get = function (constructor) {
+        var _a;
+        var _b;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var _c = args[0], locales = _c === void 0 ? libraryDefaultLocale : _c, _d = args[1], options = _d === void 0 ? {} : _d;
+        var key = this._generateKey(locales, options);
+        var intlObject = (_b = this.cache[constructor]) === null || _b === void 0 ? void 0 : _b[key];
+        if (intlObject === undefined) {
+            // Create new instance and cache it
+            intlObject = new ((_a = CustomIntl[constructor]).bind.apply(_a, __spreadArray([void 0], args, false)))();
+            if (!this.cache[constructor])
+                this.cache[constructor] = {};
+            this.cache[constructor][key] = intlObject;
+        }
+        return intlObject;
+    };
+    return IntlCache;
+}());
+/**
+ * Global instance of the Intl cache for use throughout the application
+ */
+export var intlCache = new IntlCache();

package/dist/cache/types.d.ts

@@ -0,0 +1,32 @@
+import { CutoffFormatConstructor } from '../formatting/custom-formats/CutoffFormat/CutoffFormat';
+/**
+ * Extracts only the constructor functions from the Intl namespace,
+ * filtering out static methods like getCanonicalLocales and supportedValuesOf
+ */
+type IntlConstructors = {
+    [K in keyof typeof Intl as (typeof Intl)[K] extends new (...args: any[]) => any ? K : never]: (typeof Intl)[K];
+};
+/**
+ * Extended interface that includes all native Intl constructors plus custom ones
+ */
+export interface CustomIntlConstructors extends IntlConstructors {
+    CutoffFormat: typeof CutoffFormatConstructor;
+}
+/**
+ * Helper type to represent a constructor function for a given Intl constructor key
+ */
+export type ConstructorType<K extends keyof CustomIntlConstructors> = new (...args: ConstructorParameters<CustomIntlConstructors[K]>) => InstanceType<CustomIntlConstructors[K]>;
+/**
+ * Type for the cache object structure - each constructor gets its own Record
+ * mapping cache keys to instances of that specific constructor type
+ */
+export type IntlCacheObject = {
+    [K in keyof CustomIntlConstructors]?: Record<string, InstanceType<ConstructorType<K>>>;
+};
+/**
+ * Type for the CustomIntl object that maps constructor names to constructor functions
+ */
+export type CustomIntlType = {
+    [K in keyof CustomIntlConstructors]: ConstructorType<K>;
+};
+export {};

package/dist/cache/types.js

@@ -0,0 +1 @@
+export {};