generaltranslation 8.2.13 → 8.2.15

package/dist/cache/IntlCache.js

@@ -1,84 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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