@uipath/solutionpackager-tool-core 0.0.26

package/dist/i18n/i18n-manager.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Core localization manager with translation registry, locale switching,
+ * and interpolation support. Zero dependencies, type-safe design.
+ */
+/**
+ * Translation catalog type - nested object with string leaves.
+ */
+export type TranslationCatalog = Record<string, unknown>;
+/**
+ * Interpolation parameter type.
+ */
+export type InterpolationParams = Record<string, string | number>;
+/**
+ * Core i18n manager class. Handles translation storage, locale switching,
+ * key resolution, and string interpolation.
+ */
+export declare class I18nManager {
+    /**
+     * In-memory translation registry. All locales stored here.
+     */
+    private static translations;
+    /**
+     * Currently active locale code (e.g., 'en', 'fr', 'de').
+     */
+    private static currentLocale;
+    /**
+     * Default fallback locale when translations are missing.
+     */
+    private static fallbackLocale;
+    /**
+     * Register translations for a specific locale.
+     * Merges with existing translations if locale already registered.
+     *
+     * @param locale - Locale code (e.g., 'en', 'fr', 'de')
+     * @param catalog - Translation catalog object
+     */
+    static registerTranslations(locale: string, catalog: TranslationCatalog): void;
+    /**
+     * Set the active locale. Normalizes locale codes (e.g., 'en-US' → 'en').
+     *
+     * @param locale - Locale code or culture code
+     * @returns Normalized locale code that was set
+     */
+    static setLocale(locale: string): string;
+    /**
+     * Get the currently active locale.
+     *
+     * @returns Current locale code
+     */
+    static getLocale(): string;
+    /**
+     * Set the fallback locale used when translations are missing.
+     *
+     * @param locale - Fallback locale code
+     */
+    static setFallbackLocale(locale: string): void;
+    /**
+     * Translate a key to a localized string.
+     *
+     * @param key - Translation key in dot notation (e.g., 'tool-core.errors.fileNotFound')
+     * @param params - Interpolation parameters for {placeholder} replacement
+     * @param locale - Optional locale override (uses current locale if not specified)
+     * @returns Translated and interpolated string
+     */
+    static t(key: string, params?: InterpolationParams, locale?: string): string;
+    /**
+     * Check if a translation key exists in the current or fallback locale.
+     *
+     * @param key - Translation key to check
+     * @param locale - Optional locale override
+     * @returns True if key exists
+     */
+    static has(key: string, locale?: string): boolean;
+    /**
+     * Get all registered locale codes.
+     *
+     * @returns Array of locale codes
+     */
+    static getAvailableLocales(): string[];
+    /**
+     * Clear all registered translations (useful for testing).
+     */
+    static clearTranslations(): void;
+    /**
+     * Get a translation value from the registry by key and locale.
+     *
+     * @param key - Dot-notation key
+     * @param locale - Locale code
+     * @returns Translation value or undefined if not found
+     */
+    private static getTranslationValue;
+    /**
+     * Interpolate parameters into a translation string.
+     * Replaces {param} placeholders with values from params object.
+     *
+     * @param template - String with {placeholder} syntax
+     * @param params - Parameter values
+     * @returns Interpolated string
+     */
+    private static interpolate;
+    /**
+     * Normalize a locale code to a standard format.
+     * Converts 'en-US' → 'en', 'fr_FR' → 'fr', etc.
+     * Special cases: 'es-MX', 'pt-BR', 'zh-CN', 'zh-TW' are preserved.
+     *
+     * @param locale - Input locale or culture code
+     * @returns Normalized locale code
+     */
+    private static normalizeLocale;
+    /**
+     * Deep merge two objects. Used for merging translation catalogs.
+     *
+     * @param target - Target object
+     * @param source - Source object to merge
+     * @returns Merged object
+     */
+    private static deepMerge;
+}
+/**
+ * Convenience function for translating keys.
+ * Alias for I18nManager.t()
+ *
+ * @param key - Translation key
+ * @param params - Interpolation parameters
+ * @param locale - Optional locale override
+ * @returns Translated string
+ */
+export declare function translate(key: string, params?: InterpolationParams, locale?: string): string;

package/dist/i18n/i18n-manager.js

@@ -0,0 +1,104 @@
+import { isPluralForm, selectPluralForm } from "./types.js";
+class I18nManager {
+    static translations = {};
+    static currentLocale = "en";
+    static fallbackLocale = "en";
+    static registerTranslations(locale, catalog) {
+        if (!I18nManager.translations[locale]) I18nManager.translations[locale] = {};
+        I18nManager.translations[locale] = I18nManager.deepMerge(I18nManager.translations[locale], catalog);
+    }
+    static setLocale(locale) {
+        const normalized = I18nManager.normalizeLocale(locale);
+        if (I18nManager.translations[normalized]) {
+            I18nManager.currentLocale = normalized;
+            return normalized;
+        }
+        const baseLocale = normalized.split("-")[0];
+        if (baseLocale !== normalized && I18nManager.translations[baseLocale]) {
+            I18nManager.currentLocale = baseLocale;
+            return baseLocale;
+        }
+        console.warn(`Locale '${locale}' not found in registered translations. Using current locale '${I18nManager.currentLocale}'.`);
+        return I18nManager.currentLocale;
+    }
+    static getLocale() {
+        return I18nManager.currentLocale;
+    }
+    static setFallbackLocale(locale) {
+        I18nManager.fallbackLocale = I18nManager.normalizeLocale(locale);
+    }
+    static t(key, params, locale) {
+        const targetLocale = locale ? I18nManager.normalizeLocale(locale) : I18nManager.currentLocale;
+        let value = I18nManager.getTranslationValue(key, targetLocale);
+        if (void 0 === value && targetLocale !== I18nManager.fallbackLocale) value = I18nManager.getTranslationValue(key, I18nManager.fallbackLocale);
+        if (void 0 === value) {
+            console.warn(`Translation not found for key '${key}' in locale '${targetLocale}'`);
+            return key;
+        }
+        if (isPluralForm(value) && params && "count" in params) {
+            const count = "number" == typeof params.count ? params.count : Number(params.count);
+            value = selectPluralForm(value, count);
+        } else if (isPluralForm(value)) value = value.other;
+        if ("string" != typeof value) {
+            console.error(`Invalid translation value for key '${key}': expected string, got ${typeof value}`);
+            return key;
+        }
+        return params ? I18nManager.interpolate(value, params) : value;
+    }
+    static has(key, locale) {
+        const targetLocale = locale ? I18nManager.normalizeLocale(locale) : I18nManager.currentLocale;
+        const value = I18nManager.getTranslationValue(key, targetLocale);
+        if (void 0 !== value) return true;
+        if (targetLocale !== I18nManager.fallbackLocale) return void 0 !== I18nManager.getTranslationValue(key, I18nManager.fallbackLocale);
+        return false;
+    }
+    static getAvailableLocales() {
+        return Object.keys(I18nManager.translations);
+    }
+    static clearTranslations() {
+        I18nManager.translations = {};
+        I18nManager.currentLocale = "en";
+    }
+    static getTranslationValue(key, locale) {
+        const catalog = I18nManager.translations[locale];
+        if (!catalog) return;
+        const keys = key.split(".");
+        let value = catalog;
+        for (const k of keys)if (!value || "object" != typeof value || !(k in value)) return;
+        else value = value[k];
+        return value;
+    }
+    static interpolate(template, params) {
+        return template.replace(/\{(\w+)\}/g, (_, key)=>{
+            const value = params[key];
+            return void 0 !== value ? String(value) : `{${key}}`;
+        });
+    }
+    static normalizeLocale(locale) {
+        const normalized = locale.toLowerCase().replace(/_/g, "-");
+        const specialLocales = [
+            "es-mx",
+            "pt-br",
+            "zh-cn",
+            "zh-tw"
+        ];
+        if (specialLocales.includes(normalized)) return normalized;
+        return normalized.split("-")[0];
+    }
+    static deepMerge(target, source) {
+        const result = {
+            ...target
+        };
+        for (const key of Object.keys(source)){
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (sourceValue && "object" == typeof sourceValue && !Array.isArray(sourceValue) && targetValue && "object" == typeof targetValue && !Array.isArray(targetValue)) result[key] = I18nManager.deepMerge(targetValue, sourceValue);
+            else result[key] = sourceValue;
+        }
+        return result;
+    }
+}
+function translate(key, params, locale) {
+    return I18nManager.t(key, params, locale);
+}
+export { I18nManager, translate };

package/dist/i18n/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * i18n module entry point.
+ * Registers all locales and exports translation utilities.
+ */
+import { I18nManager } from "./i18n-manager.js";
+import { type TranslationKeys } from "./locales/en.js";
+import { TranslationService, translate } from "./translation-service.js";
+import type { Path, TranslationParams } from "./types.js";
+/**
+ * Translation key type - derived from English base translations.
+ */
+export type TranslationKey = Path<TranslationKeys>;
+export type { Path as TranslationPath } from "./types.js";
+export type { TranslationKeys, TranslationParams };
+export { I18nManager, TranslationService, translate };

package/dist/i18n/index.js

@@ -0,0 +1,34 @@
+import { I18nManager } from "./i18n-manager.js";
+import { de } from "./locales/de.js";
+import { en } from "./locales/en.js";
+import { es } from "./locales/es.js";
+import { es_MX } from "./locales/es-MX.js";
+import { fr } from "./locales/fr.js";
+import { ja } from "./locales/ja.js";
+import { ko } from "./locales/ko.js";
+import { pt } from "./locales/pt.js";
+import { pt_BR } from "./locales/pt-BR.js";
+import { ro } from "./locales/ro.js";
+import { ru } from "./locales/ru.js";
+import { tr } from "./locales/tr.js";
+import { zh_CN } from "./locales/zh-CN.js";
+import { zh_TW } from "./locales/zh-TW.js";
+import { zu } from "./locales/zu.js";
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de);
+I18nManager.registerTranslations("es", es);
+I18nManager.registerTranslations("es-mx", es_MX);
+I18nManager.registerTranslations("fr", fr);
+I18nManager.registerTranslations("ja", ja);
+I18nManager.registerTranslations("ko", ko);
+I18nManager.registerTranslations("pt", pt);
+I18nManager.registerTranslations("pt-br", pt_BR);
+I18nManager.registerTranslations("ro", ro);
+I18nManager.registerTranslations("ru", ru);
+I18nManager.registerTranslations("tr", tr);
+I18nManager.registerTranslations("zh-cn", zh_CN);
+I18nManager.registerTranslations("zh-tw", zh_TW);
+I18nManager.registerTranslations("zu", zu);
+I18nManager.setLocale("en");
+export { TranslationService, translate } from "./translation-service.js";
+export { I18nManager };

package/dist/i18n/locales/de.d.ts

@@ -0,0 +1,37 @@
+export declare const de: {
+    toolCore: {
+        errors: {
+            internal: string;
+            fileNotFound: string;
+            fileReadFailed: string;
+            fileWriteFailed: string;
+            directoryNotFound: string;
+            invalidPath: string;
+            operationCanceled: string;
+            invalidParameter: string;
+        };
+        progress: {
+            copying: string;
+            building: string;
+            packaging: string;
+            validating: string;
+            analyzing: string;
+            restoring: string;
+        };
+        validation: {
+            requiredField: string;
+            invalidValue: string;
+            pathNotFound: string;
+            fileRequired: string;
+            directoryRequired: string;
+        };
+        info: {
+            operationComplete: string;
+            filesProcessed: {
+                zero: string;
+                one: string;
+                other: string;
+            };
+        };
+    };
+};

package/dist/i18n/locales/de.js

@@ -0,0 +1,38 @@
+const de = {
+    toolCore: {
+        errors: {
+            internal: "Internal error: {message}",
+            fileNotFound: "File not found: {path}",
+            fileReadFailed: "Failed to read file: {path}",
+            fileWriteFailed: "Failed to write file: {path}",
+            directoryNotFound: "Directory not found: {path}",
+            invalidPath: "{path} is not a valid path",
+            operationCanceled: "Operation was canceled",
+            invalidParameter: "Invalid parameter: {parameter}"
+        },
+        progress: {
+            copying: "Copying files...",
+            building: "Building project...",
+            packaging: "Creating package...",
+            validating: "Validating...",
+            analyzing: "Analyzing...",
+            restoring: "Restoring dependencies..."
+        },
+        validation: {
+            requiredField: "{field} is required",
+            invalidValue: "Invalid value for {field}",
+            pathNotFound: "Path not found: {path}",
+            fileRequired: "File is required: {path}",
+            directoryRequired: "Directory is required: {path}"
+        },
+        info: {
+            operationComplete: "Operation completed successfully",
+            filesProcessed: {
+                zero: "No files processed",
+                one: "{count} file processed",
+                other: "{count} files processed"
+            }
+        }
+    }
+};
+export { de };

package/dist/i18n/locales/en.d.ts

@@ -0,0 +1,43 @@
+/**
+ * English base translations for tool-core package.
+ * This file serves as the type source for all translations.
+ * All translation keys must be defined here first.
+ */
+export declare const en: {
+    readonly toolCore: {
+        readonly errors: {
+            readonly internal: "Internal error: {message}";
+            readonly fileNotFound: "File not found: {path}";
+            readonly fileReadFailed: "Failed to read file: {path}";
+            readonly fileWriteFailed: "Failed to write file: {path}";
+            readonly directoryNotFound: "Directory not found: {path}";
+            readonly invalidPath: "{path} is not a valid path";
+            readonly operationCanceled: "Operation was canceled";
+            readonly invalidParameter: "Invalid parameter: {parameter}";
+        };
+        readonly progress: {
+            readonly copying: "Copying files...";
+            readonly building: "Building project...";
+            readonly packaging: "Creating package...";
+            readonly validating: "Validating...";
+            readonly analyzing: "Analyzing...";
+            readonly restoring: "Restoring dependencies...";
+        };
+        readonly validation: {
+            readonly requiredField: "{field} is required";
+            readonly invalidValue: "Invalid value for {field}";
+            readonly pathNotFound: "Path not found: {path}";
+            readonly fileRequired: "File is required: {path}";
+            readonly directoryRequired: "Directory is required: {path}";
+        };
+        readonly info: {
+            readonly operationComplete: "Operation completed successfully";
+            readonly filesProcessed: {
+                readonly zero: "No files processed";
+                readonly one: "{count} file processed";
+                readonly other: "{count} files processed";
+            };
+        };
+    };
+};
+export type TranslationKeys = typeof en;

package/dist/i18n/locales/en.js

@@ -0,0 +1,38 @@
+const en = {
+    toolCore: {
+        errors: {
+            internal: "Internal error: {message}",
+            fileNotFound: "File not found: {path}",
+            fileReadFailed: "Failed to read file: {path}",
+            fileWriteFailed: "Failed to write file: {path}",
+            directoryNotFound: "Directory not found: {path}",
+            invalidPath: "{path} is not a valid path",
+            operationCanceled: "Operation was canceled",
+            invalidParameter: "Invalid parameter: {parameter}"
+        },
+        progress: {
+            copying: "Copying files...",
+            building: "Building project...",
+            packaging: "Creating package...",
+            validating: "Validating...",
+            analyzing: "Analyzing...",
+            restoring: "Restoring dependencies..."
+        },
+        validation: {
+            requiredField: "{field} is required",
+            invalidValue: "Invalid value for {field}",
+            pathNotFound: "Path not found: {path}",
+            fileRequired: "File is required: {path}",
+            directoryRequired: "Directory is required: {path}"
+        },
+        info: {
+            operationComplete: "Operation completed successfully",
+            filesProcessed: {
+                zero: "No files processed",
+                one: "{count} file processed",
+                other: "{count} files processed"
+            }
+        }
+    }
+};
+export { en };

package/dist/i18n/locales/es-MX.d.ts

@@ -0,0 +1,37 @@
+export declare const es_MX: {
+    toolCore: {
+        errors: {
+            internal: string;
+            fileNotFound: string;
+            fileReadFailed: string;
+            fileWriteFailed: string;
+            directoryNotFound: string;
+            invalidPath: string;
+            operationCanceled: string;
+            invalidParameter: string;
+        };
+        progress: {
+            copying: string;
+            building: string;
+            packaging: string;
+            validating: string;
+            analyzing: string;
+            restoring: string;
+        };
+        validation: {
+            requiredField: string;
+            invalidValue: string;
+            pathNotFound: string;
+            fileRequired: string;
+            directoryRequired: string;
+        };
+        info: {
+            operationComplete: string;
+            filesProcessed: {
+                zero: string;
+                one: string;
+                other: string;
+            };
+        };
+    };
+};

package/dist/i18n/locales/es-MX.js

@@ -0,0 +1,38 @@
+const es_MX = {
+    toolCore: {
+        errors: {
+            internal: "Internal error: {message}",
+            fileNotFound: "File not found: {path}",
+            fileReadFailed: "Failed to read file: {path}",
+            fileWriteFailed: "Failed to write file: {path}",
+            directoryNotFound: "Directory not found: {path}",
+            invalidPath: "{path} is not a valid path",
+            operationCanceled: "Operation was canceled",
+            invalidParameter: "Invalid parameter: {parameter}"
+        },
+        progress: {
+            copying: "Copying files...",
+            building: "Building project...",
+            packaging: "Creating package...",
+            validating: "Validating...",
+            analyzing: "Analyzing...",
+            restoring: "Restoring dependencies..."
+        },
+        validation: {
+            requiredField: "{field} is required",
+            invalidValue: "Invalid value for {field}",
+            pathNotFound: "Path not found: {path}",
+            fileRequired: "File is required: {path}",
+            directoryRequired: "Directory is required: {path}"
+        },
+        info: {
+            operationComplete: "Operation completed successfully",
+            filesProcessed: {
+                zero: "No files processed",
+                one: "{count} file processed",
+                other: "{count} files processed"
+            }
+        }
+    }
+};
+export { es_MX };

package/dist/i18n/locales/es.d.ts

@@ -0,0 +1,37 @@
+export declare const es: {
+    toolCore: {
+        errors: {
+            internal: string;
+            fileNotFound: string;
+            fileReadFailed: string;
+            fileWriteFailed: string;
+            directoryNotFound: string;
+            invalidPath: string;
+            operationCanceled: string;
+            invalidParameter: string;
+        };
+        progress: {
+            copying: string;
+            building: string;
+            packaging: string;
+            validating: string;
+            analyzing: string;
+            restoring: string;
+        };
+        validation: {
+            requiredField: string;
+            invalidValue: string;
+            pathNotFound: string;
+            fileRequired: string;
+            directoryRequired: string;
+        };
+        info: {
+            operationComplete: string;
+            filesProcessed: {
+                zero: string;
+                one: string;
+                other: string;
+            };
+        };
+    };
+};

package/dist/i18n/locales/es.js

@@ -0,0 +1,38 @@
+const es = {
+    toolCore: {
+        errors: {
+            internal: "Internal error: {message}",
+            fileNotFound: "File not found: {path}",
+            fileReadFailed: "Failed to read file: {path}",
+            fileWriteFailed: "Failed to write file: {path}",
+            directoryNotFound: "Directory not found: {path}",
+            invalidPath: "{path} is not a valid path",
+            operationCanceled: "Operation was canceled",
+            invalidParameter: "Invalid parameter: {parameter}"
+        },
+        progress: {
+            copying: "Copying files...",
+            building: "Building project...",
+            packaging: "Creating package...",
+            validating: "Validating...",
+            analyzing: "Analyzing...",
+            restoring: "Restoring dependencies..."
+        },
+        validation: {
+            requiredField: "{field} is required",
+            invalidValue: "Invalid value for {field}",
+            pathNotFound: "Path not found: {path}",
+            fileRequired: "File is required: {path}",
+            directoryRequired: "Directory is required: {path}"
+        },
+        info: {
+            operationComplete: "Operation completed successfully",
+            filesProcessed: {
+                zero: "No files processed",
+                one: "{count} file processed",
+                other: "{count} files processed"
+            }
+        }
+    }
+};
+export { es };

package/dist/i18n/locales/fr.d.ts

@@ -0,0 +1,37 @@
+export declare const fr: {
+    toolCore: {
+        errors: {
+            internal: string;
+            fileNotFound: string;
+            fileReadFailed: string;
+            fileWriteFailed: string;
+            directoryNotFound: string;
+            invalidPath: string;
+            operationCanceled: string;
+            invalidParameter: string;
+        };
+        progress: {
+            copying: string;
+            building: string;
+            packaging: string;
+            validating: string;
+            analyzing: string;
+            restoring: string;
+        };
+        validation: {
+            requiredField: string;
+            invalidValue: string;
+            pathNotFound: string;
+            fileRequired: string;
+            directoryRequired: string;
+        };
+        info: {
+            operationComplete: string;
+            filesProcessed: {
+                zero: string;
+                one: string;
+                other: string;
+            };
+        };
+    };
+};

package/dist/i18n/locales/fr.js

@@ -0,0 +1,38 @@
+const fr = {
+    toolCore: {
+        errors: {
+            internal: "Internal error: {message}",
+            fileNotFound: "File not found: {path}",
+            fileReadFailed: "Failed to read file: {path}",
+            fileWriteFailed: "Failed to write file: {path}",
+            directoryNotFound: "Directory not found: {path}",
+            invalidPath: "{path} is not a valid path",
+            operationCanceled: "Operation was canceled",
+            invalidParameter: "Invalid parameter: {parameter}"
+        },
+        progress: {
+            copying: "Copying files...",
+            building: "Building project...",
+            packaging: "Creating package...",
+            validating: "Validating...",
+            analyzing: "Analyzing...",
+            restoring: "Restoring dependencies..."
+        },
+        validation: {
+            requiredField: "{field} is required",
+            invalidValue: "Invalid value for {field}",
+            pathNotFound: "Path not found: {path}",
+            fileRequired: "File is required: {path}",
+            directoryRequired: "Directory is required: {path}"
+        },
+        info: {
+            operationComplete: "Operation completed successfully",
+            filesProcessed: {
+                zero: "No files processed",
+                one: "{count} file processed",
+                other: "{count} files processed"
+            }
+        }
+    }
+};
+export { fr };