generaltranslation 8.2.11 → 8.2.13

package/dist/derive/utils/traverseIcu.d.ts

@@ -0,0 +1,20 @@
+import { MessageFormatElement, ParserOptions } from '@formatjs/icu-messageformat-parser';
+type TraverseIcuOptions = ParserOptions & {
+    recurseIntoVisited?: boolean;
+};
+/**
+ * Given an ICU string, traverse the AST and call the visitor function for each element that matches the type T
+ * @param icu - The ICU string to traverse
+ * @param shouldVisit - A function that returns true if the element should be visited
+ * @param visitor - A function that is called for each element that matches the type T
+ * @returns The modified AST of the ICU string.
+ *
+ * @note This function is a heavy operation, use sparingly
+ */
+export declare function traverseIcu<T extends MessageFormatElement>({ icuString, shouldVisit, visitor, options: { recurseIntoVisited, ...otherOptions }, }: {
+    icuString: string;
+    shouldVisit: (element: MessageFormatElement) => element is T;
+    visitor: (element: T) => void;
+    options: TraverseIcuOptions;
+}): MessageFormatElement[];
+export {};

package/dist/derive/utils/traverseIcu.js

@@ -0,0 +1,49 @@
+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 { parse, TYPE, } from '@formatjs/icu-messageformat-parser';
+/**
+ * Given an ICU string, traverse the AST and call the visitor function for each element that matches the type T
+ * @param icu - The ICU string to traverse
+ * @param shouldVisit - A function that returns true if the element should be visited
+ * @param visitor - A function that is called for each element that matches the type T
+ * @returns The modified AST of the ICU string.
+ *
+ * @note This function is a heavy operation, use sparingly
+ */
+export function traverseIcu(_a) {
+    var icuString = _a.icuString, shouldVisit = _a.shouldVisit, visitor = _a.visitor, _b = _a.options, _c = _b.recurseIntoVisited, recurseIntoVisited = _c === void 0 ? true : _c, otherOptions = __rest(_b, ["recurseIntoVisited"]);
+    var ast = parse(icuString, otherOptions);
+    handleChildren(ast);
+    return ast;
+    function handleChildren(children) {
+        children.map(handleChild);
+    }
+    function handleChild(child) {
+        // handle select var
+        var visited = false;
+        if (shouldVisit(child)) {
+            visitor(child);
+            visited = true;
+        }
+        // recurse on children
+        if (!visited || recurseIntoVisited) {
+            if (child.type === TYPE.select || child.type === TYPE.plural) {
+                Object.values(child.options)
+                    .map(function (option) { return option.value; })
+                    .map(handleChildren);
+            }
+            else if (child.type === TYPE.tag) {
+                handleChildren(child.children);
+            }
+        }
+    }
+}

package/dist/derive/utils/types.d.ts

@@ -0,0 +1,23 @@
+import { VAR_IDENTIFIER } from './constants';
+import type { PluralOrSelectOption, LiteralElement, SelectElement } from '@formatjs/icu-messageformat-parser/types.js';
+interface GTIndexedSelectOption extends PluralOrSelectOption {
+    value: Array<LiteralElement>;
+}
+export interface GTIndexedSelectElement extends SelectElement {
+    value: `${typeof VAR_IDENTIFIER}${number}`;
+    options: {
+        other: GTIndexedSelectOption;
+        [key: string]: PluralOrSelectOption;
+    };
+}
+interface GTUnindexedSelectOption extends PluralOrSelectOption {
+    value: Array<LiteralElement>;
+}
+export interface GTUnindexedSelectElement extends SelectElement {
+    value: typeof VAR_IDENTIFIER;
+    options: {
+        other: GTUnindexedSelectOption;
+        [key: string]: PluralOrSelectOption;
+    };
+}
+export {};

package/dist/derive/utils/types.js

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

package/dist/errors/ApiError.d.ts

@@ -0,0 +1,7 @@
+export declare class ApiError extends Error {
+    code: number;
+    message: string;
+    constructor(error: string, code: number, message: string);
+    getCode(): number;
+    getMessage(): string;
+}

package/dist/errors/ApiError.js

@@ -0,0 +1,33 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var ApiError = /** @class */ (function (_super) {
+    __extends(ApiError, _super);
+    function ApiError(error, code, message) {
+        var _this = _super.call(this, error) || this;
+        _this.name = 'ApiError';
+        _this.code = code;
+        _this.message = message;
+        return _this;
+    }
+    ApiError.prototype.getCode = function () {
+        return this.code;
+    };
+    ApiError.prototype.getMessage = function () {
+        return this.message;
+    };
+    return ApiError;
+}(Error));
+export { ApiError };

package/dist/errors/formattingErrors.d.ts

@@ -0,0 +1 @@
+export declare const createInvalidCutoffStyleError: (style: string) => string;

package/dist/errors/formattingErrors.js

@@ -0,0 +1,3 @@
+export var createInvalidCutoffStyleError = function (style) {
+    return "generaltranslation Formatting Error: Invalid cutoff style: ".concat(style, ".");
+};

package/dist/errors.d.ts

@@ -0,0 +1 @@
+export * from './errors/ApiError';

package/dist/errors.js

@@ -0,0 +1 @@
+export * from './errors/ApiError';

package/dist/formatting/custom-formats/CutoffFormat/CutoffFormat.d.ts

@@ -0,0 +1,59 @@
+import { CutoffFormat, CutoffFormatOptions, PostpendedCutoffParts, PrependedCutoffParts, ResolvedCutoffFormatOptions } from './types';
+export declare class CutoffFormatConstructor implements CutoffFormat {
+    private locale;
+    private options;
+    private additionLength;
+    /**
+     * Constructor
+     * @param {Intl.LocalesArgument} locales - The locales to use for formatting.
+     * @param {CutoffFormatOptions} options - The options for formatting.
+     * @param {number} [options.maxChars] - The maximum number of characters to display.
+     * - Undefined values are treated as no cutoff.
+     * - Negative values follow .slice() behavior and terminator will be added before the value.
+     * - 0 will result in an empty string.
+     * - If cutoff results in an empty string, no terminator is added.
+     * @param {CutoffFormatStyle} [options.style='ellipsis'] - The style of the terminator.
+     * @param {string} [options.terminator] - Optional override the terminator to use.
+     * @param {string} [options.separator] - Optional override the separator to use between the terminator and the value.
+     * - If no terminator is provided, then separator is ignored.
+     *
+     * @example
+     * const format = new CutoffFormat('en', { maxChars: 5 });
+     * format.format('Hello, world!'); // 'Hello...'
+     *
+     * const format = new CutoffFormat('en', { maxChars: -3 });
+     * format.format('Hello, world!'); // '...ld!'
+     */
+    constructor(locales: Intl.LocalesArgument, options?: CutoffFormatOptions);
+    /**
+     * Format a value according to the cutoff options, returning a formatted string.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @returns {string} The formatted string with terminator applied if cutoff occurs.
+     *
+     * @example
+     * const formatter = new CutoffFormatConstructor('en', { maxChars: 8, style: 'ellipsis' });
+     * formatter.format('Hello, world!'); // Returns 'Hello, w...'
+     */
+    format(value: string): string;
+    /**
+     * Format a value to parts according to the cutoff options, returning an array of string parts.
+     * This method breaks down the formatted result into individual components for more granular control.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @returns {PrependedCutoffParts | PostpendedCutoffParts} An array of string parts representing the formatted result.
+     *   - For positive maxChars: [cutoffValue, separator?, terminator?]
+     *   - For negative maxChars: [terminator?, separator?, cutoffValue]
+     *   - For no cutoff: [originalValue]
+     *
+     * @example
+     * const formatter = new CutoffFormatConstructor('en', { maxChars: 5, style: 'ellipsis' });
+     * formatter.formatToParts('Hello, world!'); // Returns ['Hello', '...']
+     */
+    formatToParts(value: string): PrependedCutoffParts | PostpendedCutoffParts;
+    /**
+     * Get the resolved options
+     * @returns {ResolvedCutoffFormatOptions} The resolved options.
+     */
+    resolvedOptions(): ResolvedCutoffFormatOptions;
+}

package/dist/formatting/custom-formats/CutoffFormat/CutoffFormat.js

@@ -0,0 +1,147 @@
+import { createInvalidCutoffStyleError } from '../../../errors/formattingErrors';
+import { libraryDefaultLocale } from '../../../settings/settings';
+import { DEFAULT_CUTOFF_FORMAT_STYLE, DEFAULT_TERMINATOR_KEY, TERMINATOR_MAP, } from './constants';
+var CutoffFormatConstructor = /** @class */ (function () {
+    /**
+     * Constructor
+     * @param {Intl.LocalesArgument} locales - The locales to use for formatting.
+     * @param {CutoffFormatOptions} options - The options for formatting.
+     * @param {number} [options.maxChars] - The maximum number of characters to display.
+     * - Undefined values are treated as no cutoff.
+     * - Negative values follow .slice() behavior and terminator will be added before the value.
+     * - 0 will result in an empty string.
+     * - If cutoff results in an empty string, no terminator is added.
+     * @param {CutoffFormatStyle} [options.style='ellipsis'] - The style of the terminator.
+     * @param {string} [options.terminator] - Optional override the terminator to use.
+     * @param {string} [options.separator] - Optional override the separator to use between the terminator and the value.
+     * - If no terminator is provided, then separator is ignored.
+     *
+     * @example
+     * const format = new CutoffFormat('en', { maxChars: 5 });
+     * format.format('Hello, world!'); // 'Hello...'
+     *
+     * const format = new CutoffFormat('en', { maxChars: -3 });
+     * format.format('Hello, world!'); // '...ld!'
+     */
+    function CutoffFormatConstructor(locales, options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b, _c, _d, _e, _f, _g;
+        // Determine locale (this replicates Intl.NumberFormat behavior including silent failure)
+        try {
+            // Normalize locales to string
+            var localesList = !locales
+                ? [libraryDefaultLocale]
+                : Array.isArray(locales)
+                    ? locales.map(function (l) { return String(l); })
+                    : [String(locales)];
+            var canonicalLocales = Intl.getCanonicalLocales(localesList);
+            this.locale = canonicalLocales.length
+                ? canonicalLocales[0]
+                : libraryDefaultLocale;
+        }
+        catch (_h) {
+            this.locale = libraryDefaultLocale;
+        }
+        // Follows Intl.NumberFormat behavior of throwing an error when currency is invalid
+        if (!TERMINATOR_MAP[(_a = options.style) !== null && _a !== void 0 ? _a : DEFAULT_CUTOFF_FORMAT_STYLE]) {
+            throw new Error(createInvalidCutoffStyleError((_b = options.style) !== null && _b !== void 0 ? _b : DEFAULT_CUTOFF_FORMAT_STYLE));
+        }
+        // Resolve terminator options.
+        var style;
+        var presetTerminatorOptions;
+        if (options.maxChars !== undefined) {
+            style = (_c = options.style) !== null && _c !== void 0 ? _c : DEFAULT_CUTOFF_FORMAT_STYLE;
+            // TODO: need more sophisticated locale negotiation if we want to add support for region/script/etc.-specific terminators in the future
+            var languageCode = new Intl.Locale(this.locale).language;
+            presetTerminatorOptions =
+                TERMINATOR_MAP[style][languageCode] ||
+                    TERMINATOR_MAP[style][DEFAULT_TERMINATOR_KEY];
+        }
+        var terminator = (_d = options.terminator) !== null && _d !== void 0 ? _d : presetTerminatorOptions === null || presetTerminatorOptions === void 0 ? void 0 : presetTerminatorOptions.terminator;
+        var separator = terminator != null
+            ? ((_e = options.separator) !== null && _e !== void 0 ? _e : presetTerminatorOptions === null || presetTerminatorOptions === void 0 ? void 0 : presetTerminatorOptions.separator)
+            : undefined;
+        // // Remove terminator and separator if maxChars does have enough space
+        this.additionLength = ((_f = terminator === null || terminator === void 0 ? void 0 : terminator.length) !== null && _f !== void 0 ? _f : 0) + ((_g = separator === null || separator === void 0 ? void 0 : separator.length) !== null && _g !== void 0 ? _g : 0);
+        if (options.maxChars !== undefined &&
+            Math.abs(options.maxChars) < this.additionLength) {
+            terminator = undefined;
+            separator = undefined;
+        }
+        this.options = {
+            maxChars: options.maxChars,
+            style: style,
+            terminator: terminator,
+            separator: separator,
+        };
+    }
+    /**
+     * Format a value according to the cutoff options, returning a formatted string.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @returns {string} The formatted string with terminator applied if cutoff occurs.
+     *
+     * @example
+     * const formatter = new CutoffFormatConstructor('en', { maxChars: 8, style: 'ellipsis' });
+     * formatter.format('Hello, world!'); // Returns 'Hello, w...'
+     */
+    CutoffFormatConstructor.prototype.format = function (value) {
+        return this.formatToParts(value).join('');
+    };
+    /**
+     * Format a value to parts according to the cutoff options, returning an array of string parts.
+     * This method breaks down the formatted result into individual components for more granular control.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @returns {PrependedCutoffParts | PostpendedCutoffParts} An array of string parts representing the formatted result.
+     *   - For positive maxChars: [cutoffValue, separator?, terminator?]
+     *   - For negative maxChars: [terminator?, separator?, cutoffValue]
+     *   - For no cutoff: [originalValue]
+     *
+     * @example
+     * const formatter = new CutoffFormatConstructor('en', { maxChars: 5, style: 'ellipsis' });
+     * formatter.formatToParts('Hello, world!'); // Returns ['Hello', '...']
+     */
+    CutoffFormatConstructor.prototype.formatToParts = function (value) {
+        var _a = this.options, maxChars = _a.maxChars, terminator = _a.terminator, separator = _a.separator;
+        // Slice our value
+        // const additionLength = (terminator?.length ?? 0) + (separator?.length ?? 0);
+        var adjustedChars = maxChars === undefined || Math.abs(maxChars) >= value.length
+            ? maxChars
+            : maxChars >= 0
+                ? Math.max(0, maxChars - this.additionLength)
+                : Math.min(0, maxChars + this.additionLength);
+        var slicedValue = adjustedChars !== undefined && adjustedChars > -1
+            ? value.slice(0, adjustedChars)
+            : value.slice(adjustedChars);
+        // No cutoff, no terminator -> value only
+        if (maxChars == null ||
+            adjustedChars == null ||
+            adjustedChars === 0 ||
+            terminator == null ||
+            value.length <= Math.abs(maxChars)) {
+            return [slicedValue];
+        }
+        // Postpended cutoff.
+        if (adjustedChars > 0) {
+            return separator != null
+                ? [slicedValue, separator, terminator]
+                : [slicedValue, terminator];
+        }
+        // Prepended cutoff.
+        else {
+            return separator != null
+                ? [terminator, separator, slicedValue]
+                : [terminator, slicedValue];
+        }
+    };
+    /**
+     * Get the resolved options
+     * @returns {ResolvedCutoffFormatOptions} The resolved options.
+     */
+    CutoffFormatConstructor.prototype.resolvedOptions = function () {
+        return this.options;
+    };
+    return CutoffFormatConstructor;
+}());
+export { CutoffFormatConstructor };

package/dist/formatting/custom-formats/CutoffFormat/constants.d.ts

@@ -0,0 +1,4 @@
+import { CutoffFormatStyle, ResolvedTerminatorOptions } from './types';
+export declare const DEFAULT_CUTOFF_FORMAT_STYLE: CutoffFormatStyle;
+export declare const DEFAULT_TERMINATOR_KEY = "DEFAULT_TERMINATOR_KEY";
+export declare const TERMINATOR_MAP: Record<CutoffFormatStyle, Record<string | typeof DEFAULT_TERMINATOR_KEY, ResolvedTerminatorOptions>>;

package/dist/formatting/custom-formats/CutoffFormat/constants.js

@@ -0,0 +1,30 @@
+var _a, _b;
+export var DEFAULT_CUTOFF_FORMAT_STYLE = 'ellipsis';
+export var DEFAULT_TERMINATOR_KEY = 'DEFAULT_TERMINATOR_KEY';
+export var TERMINATOR_MAP = {
+    ellipsis: (_a = {
+            fr: {
+                terminator: '…',
+                separator: '\u202F',
+            },
+            zh: {
+                terminator: '……',
+                separator: undefined,
+            },
+            ja: {
+                terminator: '……',
+                separator: undefined,
+            }
+        },
+        _a[DEFAULT_TERMINATOR_KEY] = {
+            terminator: '…',
+            separator: undefined,
+        },
+        _a),
+    none: (_b = {},
+        _b[DEFAULT_TERMINATOR_KEY] = {
+            terminator: undefined,
+            separator: undefined,
+        },
+        _b),
+};

package/dist/formatting/custom-formats/CutoffFormat/types.d.ts

@@ -0,0 +1,48 @@
+/** Type of terminator */
+export type CutoffFormatStyle = 'none' | 'ellipsis';
+/** Terminator options. */
+export interface TerminatorOptions {
+    /** The terminator to use. */
+    terminator?: string;
+    /** An optional separator between the terminator and the value */
+    separator?: string;
+}
+/** Input formatting options (for constructor) */
+export interface CutoffFormatOptions extends TerminatorOptions {
+    /** Cutoff length. */
+    maxChars?: number;
+    /** Type of terminator */
+    style?: CutoffFormatStyle;
+}
+/** Resolved terminator options */
+export interface ResolvedTerminatorOptions extends TerminatorOptions {
+    terminator: string | undefined;
+    separator: string | undefined;
+}
+/** Resolved options (after constructor) */
+export interface ResolvedCutoffFormatOptions extends CutoffFormatOptions, ResolvedTerminatorOptions {
+    maxChars: number | undefined;
+    style: CutoffFormatStyle | undefined;
+    terminator: string | undefined;
+    separator: string | undefined;
+}
+/** Prepended cutoff list */
+export type PrependedCutoffParts = [string] | [ResolvedTerminatorOptions['terminator'], string] | [
+    ResolvedTerminatorOptions['terminator'],
+    ResolvedTerminatorOptions['separator'],
+    string
+];
+/** Postpended cutoff list */
+export type PostpendedCutoffParts = [string] | [string, ResolvedTerminatorOptions['terminator']] | [
+    string,
+    ResolvedTerminatorOptions['separator'],
+    ResolvedTerminatorOptions['terminator']
+];
+/**
+ * Cutoff Class interface
+ */
+export interface CutoffFormat {
+    format: (value: string) => string;
+    resolvedOptions: () => ResolvedCutoffFormatOptions;
+    formatToParts: (value: string) => PrependedCutoffParts | PostpendedCutoffParts;
+}

package/dist/formatting/custom-formats/CutoffFormat/types.js

@@ -0,0 +1,2 @@
+// ========== Base Types ========== //
+export {};

package/dist/formatting/format.d.ts

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