generaltranslation 7.1.0 → 7.1.1-alpha.0

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 old format to new 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/oldHashJsxChildren.d.ts

@@ -0,0 +1,23 @@
+import { OldJsxChildren } from './oldTypes';
+/**
+ * Calculates a unique hash for a given string using sha256.
+ *
+ * @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 has 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/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/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;