generaltranslation 8.2.12 → 8.2.13

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # generaltranslation
 
+## 8.2.13
+
+### Patch Changes
+
+- [#1379](https://github.com/generaltranslation/gt/pull/1379) [`e88fd39`](https://github.com/generaltranslation/gt/commit/e88fd399683868d5af1fe2b0ba2974fe5b17d7a7) Thanks [@bgub](https://github.com/bgub)! - Tighten public and API metadata types, and handle metadata entries without hashes in the CLI.
+
+- [#1387](https://github.com/generaltranslation/gt/pull/1387) [`95f852a`](https://github.com/generaltranslation/gt/commit/95f852ae086ac79d2c446f4d3072d8fd18688796) Thanks [@bgub](https://github.com/bgub)! - Reduce explicit any usage in core and Next.js types.
+
 ## 8.2.12
 
 ### Patch Changes

package/dist/LocaleConfig.d.ts

@@ -0,0 +1,59 @@
+import { CustomMapping, FormatVariables } from './types';
+import { CutoffFormatOptions } from './formatting/custom-formats/CutoffFormat/types';
+import { StringFormat } from './types-dir/jsx/content';
+export type LocaleConfigConstructorParams = {
+    defaultLocale?: string;
+    locales?: string[];
+    customMapping?: CustomMapping;
+};
+type LocalesOption = {
+    locales?: string | string[];
+};
+type WithLocales<T = object> = T & LocalesOption;
+/**
+ * LocaleConfig contains the locale and formatting primitives exposed through
+ * the core entrypoint.
+ *
+ * It intentionally does not store project IDs, API keys, runtime URLs, or any
+ * translation credentials. It only stores locale metadata needed to resolve
+ * aliases, choose formatting fallbacks, and format values with Intl.
+ */
+export declare class LocaleConfig {
+    readonly defaultLocale: string;
+    readonly locales: string[];
+    readonly customMapping?: CustomMapping;
+    constructor({ defaultLocale, locales, customMapping, }?: LocaleConfigConstructorParams);
+    private get translationLocales();
+    private resolveCanonicalLocaleList;
+    private resolveCanonicalLocaleArgs;
+    private toLocaleList;
+    private getFormattingLocales;
+    formatNum(value: number, targetLocale?: string, options?: WithLocales<Intl.NumberFormatOptions>): string;
+    formatDateTime(value: Date, targetLocale?: string, options?: WithLocales<Intl.DateTimeFormatOptions>): string;
+    formatCurrency(value: number, currency: string, targetLocale?: string, options?: WithLocales<Intl.NumberFormatOptions>): string;
+    formatRelativeTime(value: number, unit: Intl.RelativeTimeFormatUnit, targetLocale?: string, options?: WithLocales<Intl.RelativeTimeFormatOptions>): string;
+    formatRelativeTimeFromDate(date: Date, targetLocale?: string, options?: WithLocales<Intl.RelativeTimeFormatOptions & {
+        baseDate?: Date;
+    }>): string;
+    formatCutoff(value: string, targetLocale?: string, options?: WithLocales<CutoffFormatOptions>): string;
+    formatMessage(message: string, targetLocale?: string, options?: WithLocales<{
+        variables?: FormatVariables;
+        dataFormat?: StringFormat;
+    }>): string;
+    formatList(array: Array<string | number>, targetLocale?: string, options?: WithLocales<Intl.ListFormatOptions>): string;
+    formatListToParts<T>(array: Array<T>, targetLocale?: string, options?: WithLocales<Intl.ListFormatOptions>): (string | T)[];
+    getLocaleName(locale: string): string;
+    getLocaleEmoji(locale: string): string;
+    getLocaleProperties(locale: string): import("./types").LocaleProperties;
+    requiresTranslation(targetLocale: string, sourceLocale?: string, approvedLocales?: string[] | undefined): boolean;
+    determineLocale(locales: string | string[], approvedLocales?: string[]): string | undefined;
+    getLocaleDirection(locale: string): "ltr" | "rtl";
+    isValidLocale(locale: string): boolean;
+    resolveCanonicalLocale(locale: string): string;
+    resolveAliasLocale(locale: string): string;
+    standardizeLocale(locale: string): string;
+    isSameDialect(...locales: (string | string[])[]): boolean;
+    isSameLanguage(...locales: (string | string[])[]): boolean;
+    isSupersetLocale(superLocale: string, subLocale: string): boolean;
+}
+export {};

package/dist/LocaleConfig.js

@@ -0,0 +1,225 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { _formatCurrency, _formatCutoff, _formatDateTime, _formatList, _formatListToParts, _formatMessageICU, _formatMessageString, _formatNum, _formatRelativeTime, _formatRelativeTimeFromDate, } from './formatting/format';
+import _requiresTranslation from './locales/requiresTranslation';
+import _determineLocale from './locales/determineLocale';
+import _isSameLanguage from './locales/isSameLanguage';
+import _getLocaleProperties from './locales/getLocaleProperties';
+import _getLocaleEmoji from './locales/getLocaleEmoji';
+import { _isValidLocale, _standardizeLocale } from './locales/isValidLocale';
+import { _getLocaleName } from './locales/getLocaleName';
+import { _getLocaleDirection } from './locales/getLocaleDirection';
+import { libraryDefaultLocale } from './settings/settings';
+import _isSameDialect from './locales/isSameDialect';
+import _isSupersetLocale from './locales/isSupersetLocale';
+import { _resolveAliasLocale } from './locales/resolveAliasLocale';
+import { _resolveCanonicalLocale } from './locales/resolveCanonicalLocale';
+/**
+ * LocaleConfig contains the locale and formatting primitives exposed through
+ * the core entrypoint.
+ *
+ * It intentionally does not store project IDs, API keys, runtime URLs, or any
+ * translation credentials. It only stores locale metadata needed to resolve
+ * aliases, choose formatting fallbacks, and format values with Intl.
+ */
+var LocaleConfig = /** @class */ (function () {
+    function LocaleConfig(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.defaultLocale, defaultLocale = _c === void 0 ? libraryDefaultLocale : _c, _d = _b.locales, locales = _d === void 0 ? [] : _d, customMapping = _b.customMapping;
+        this.defaultLocale = defaultLocale;
+        this.locales = locales;
+        this.customMapping = customMapping;
+    }
+    Object.defineProperty(LocaleConfig.prototype, "translationLocales", {
+        get: function () {
+            return this.locales.length ? this.locales : undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LocaleConfig.prototype.resolveCanonicalLocaleList = function (locales) {
+        var _this = this;
+        return locales.map(function (locale) { return _this.resolveCanonicalLocale(locale); });
+    };
+    LocaleConfig.prototype.resolveCanonicalLocaleArgs = function (locales) {
+        var _this = this;
+        return locales.map(function (locale) {
+            return Array.isArray(locale)
+                ? _this.resolveCanonicalLocaleList(locale)
+                : _this.resolveCanonicalLocale(locale);
+        });
+    };
+    LocaleConfig.prototype.toLocaleList = function (locales) {
+        return Array.isArray(locales) ? locales : [locales];
+    };
+    LocaleConfig.prototype.getFormattingLocales = function (targetLocale, locales) {
+        var _this = this;
+        var localeList = locales !== undefined
+            ? this.toLocaleList(locales)
+            : [targetLocale, this.defaultLocale, libraryDefaultLocale];
+        return localeList
+            .filter(function (locale) { return !!locale; })
+            .map(function (locale) { return _this.resolveCanonicalLocale(locale); });
+    };
+    LocaleConfig.prototype.formatNum = function (value, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, intlOptions = __rest(options, ["locales"]);
+        return _formatNum({
+            value: value,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.formatDateTime = function (value, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, intlOptions = __rest(options, ["locales"]);
+        return _formatDateTime({
+            value: value,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.formatCurrency = function (value, currency, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, intlOptions = __rest(options, ["locales"]);
+        return _formatCurrency({
+            value: value,
+            currency: currency,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.formatRelativeTime = function (value, unit, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, intlOptions = __rest(options, ["locales"]);
+        return _formatRelativeTime({
+            value: value,
+            unit: unit,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.formatRelativeTimeFromDate = function (date, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, baseDate = options.baseDate, intlOptions = __rest(options, ["locales", "baseDate"]);
+        return _formatRelativeTimeFromDate({
+            date: date,
+            baseDate: baseDate !== null && baseDate !== void 0 ? baseDate : new Date(),
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.formatCutoff = function (value, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, formatOptions = __rest(options, ["locales"]);
+        return _formatCutoff({
+            value: value,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: formatOptions,
+        });
+    };
+    LocaleConfig.prototype.formatMessage = function (message, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, variables = options.variables, dataFormat = options.dataFormat;
+        if (dataFormat === 'STRING')
+            return _formatMessageString(message);
+        return _formatMessageICU(message, this.getFormattingLocales(targetLocale, locales), variables);
+    };
+    LocaleConfig.prototype.formatList = function (array, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, intlOptions = __rest(options, ["locales"]);
+        return _formatList({
+            value: array,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.formatListToParts = function (array, targetLocale, options) {
+        if (options === void 0) { options = {}; }
+        var locales = options.locales, intlOptions = __rest(options, ["locales"]);
+        return _formatListToParts({
+            value: array,
+            locales: this.getFormattingLocales(targetLocale, locales),
+            options: intlOptions,
+        });
+    };
+    LocaleConfig.prototype.getLocaleName = function (locale) {
+        return _getLocaleName(locale, this.defaultLocale, this.customMapping);
+    };
+    LocaleConfig.prototype.getLocaleEmoji = function (locale) {
+        return _getLocaleEmoji(locale, this.customMapping);
+    };
+    LocaleConfig.prototype.getLocaleProperties = function (locale) {
+        return _getLocaleProperties(locale, this.defaultLocale, this.customMapping);
+    };
+    LocaleConfig.prototype.requiresTranslation = function (targetLocale, sourceLocale, approvedLocales) {
+        if (sourceLocale === void 0) { sourceLocale = this.defaultLocale; }
+        if (approvedLocales === void 0) { approvedLocales = this.translationLocales; }
+        return _requiresTranslation(this.resolveCanonicalLocale(sourceLocale), this.resolveCanonicalLocale(targetLocale), approvedLocales
+            ? this.resolveCanonicalLocaleList(approvedLocales)
+            : undefined, this.customMapping);
+    };
+    LocaleConfig.prototype.determineLocale = function (locales, approvedLocales) {
+        var _this = this;
+        var _a;
+        if (approvedLocales === void 0) { approvedLocales = this.locales; }
+        var approvedLocalePairs = approvedLocales.map(function (locale) { return ({
+            locale: locale,
+            canonicalLocale: _this.resolveCanonicalLocale(locale),
+        }); });
+        var resolvedLocale = _determineLocale(Array.isArray(locales)
+            ? this.resolveCanonicalLocaleList(locales)
+            : this.resolveCanonicalLocale(locales), approvedLocalePairs.map(function (_a) {
+            var canonicalLocale = _a.canonicalLocale;
+            return canonicalLocale;
+        }), this.customMapping);
+        if (!resolvedLocale)
+            return undefined;
+        return (((_a = approvedLocalePairs.find(function (_a) {
+            var canonicalLocale = _a.canonicalLocale;
+            return canonicalLocale === resolvedLocale;
+        })) === null || _a === void 0 ? void 0 : _a.locale) || this.resolveAliasLocale(resolvedLocale));
+    };
+    LocaleConfig.prototype.getLocaleDirection = function (locale) {
+        return _getLocaleDirection(this.resolveCanonicalLocale(locale));
+    };
+    LocaleConfig.prototype.isValidLocale = function (locale) {
+        return _isValidLocale(locale, this.customMapping);
+    };
+    LocaleConfig.prototype.resolveCanonicalLocale = function (locale) {
+        return _resolveCanonicalLocale(locale, this.customMapping);
+    };
+    LocaleConfig.prototype.resolveAliasLocale = function (locale) {
+        return _resolveAliasLocale(locale, this.customMapping);
+    };
+    LocaleConfig.prototype.standardizeLocale = function (locale) {
+        return _standardizeLocale(locale);
+    };
+    LocaleConfig.prototype.isSameDialect = function () {
+        var locales = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            locales[_i] = arguments[_i];
+        }
+        return _isSameDialect.apply(void 0, this.resolveCanonicalLocaleArgs(locales));
+    };
+    LocaleConfig.prototype.isSameLanguage = function () {
+        var locales = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            locales[_i] = arguments[_i];
+        }
+        return _isSameLanguage.apply(void 0, this.resolveCanonicalLocaleArgs(locales));
+    };
+    LocaleConfig.prototype.isSupersetLocale = function (superLocale, subLocale) {
+        return _isSupersetLocale(this.resolveCanonicalLocale(superLocale), this.resolveCanonicalLocale(subLocale));
+    };
+    return LocaleConfig;
+}());
+export { LocaleConfig };

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

@@ -0,0 +1,23 @@
+import { Variable as VariableObject, VariableType } from '../types';
+import { OldBranchType, OldGTProp, OldJsxChild, OldJsxChildren, OldJsxElement, OldVariableObject, OldVariableType } from './oldTypes.js';
+import { GTProp, JsxChild, JsxChildren, JsxElement } from '../types';
+/**
+ * Convert request data from old format to new format
+ */
+export declare function getNewJsxChild(child: OldJsxChild): JsxChild;
+export declare function getNewJsxChildren(children: OldJsxChildren): JsxChildren;
+export declare function getNewJsxElement(element: OldJsxElement): JsxElement;
+export declare function getNewBranchType(branch: OldBranchType): 'b' | 'p';
+export declare function getNewVariableType(variable: OldVariableType): VariableType;
+export declare function getNewVariableObject(variable: OldVariableObject): VariableObject;
+export declare function getNewGTProp(dataGT: OldGTProp): GTProp;
+/**
+ * Convert response data from current format to old format
+ */
+export declare function getOldJsxChild(child: JsxChild): OldJsxChild;
+export declare function getOldJsxChildren(children: JsxChildren | OldJsxChildren): OldJsxChildren;
+export declare function getOldJsxElement(element: JsxElement): OldJsxElement;
+export declare function getOldBranchType(branch: 'b' | 'p'): OldBranchType;
+export declare function getOldVariableType(variable: VariableType): OldVariableType;
+export declare function getOldVariableObject(variable: VariableObject): OldVariableObject;
+export declare function getOldGTProp(dataGT: GTProp, i: number): OldGTProp;

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;