@notask/unity-cli-tools 1.2.0-rc.1 → 2.0.0

package/dist/esm/events/patterns/statusNormalizer.js

@@ -0,0 +1,276 @@
+import { InstallerStatus } from "../../types/unity.js";
+export class StatusNormalizer {
+    normalizations = new Map();
+    localeNormalizations = new Map();
+    unknownStatuses = new Set();
+    constructor() {
+        this.initializeDefaultNormalizations();
+    }
+    initializeDefaultNormalizations() {
+        this.addNormalization({
+            text: "queued for download",
+            status: InstallerStatus.Queued,
+        });
+        this.addNormalization({
+            text: "download queued",
+            status: InstallerStatus.Queued,
+        });
+        this.addNormalization({
+            text: "validating download",
+            status: InstallerStatus.Validating,
+        });
+        this.addNormalization({
+            text: "validating",
+            status: InstallerStatus.Validating,
+        });
+        this.addNormalization({
+            text: "in progress",
+            status: InstallerStatus.InProgress,
+        });
+        this.addNormalization({
+            text: "downloading",
+            status: InstallerStatus.Downloading,
+        });
+        this.addNormalization({
+            text: "download in progress",
+            status: InstallerStatus.Downloading,
+        });
+        this.addNormalization({
+            text: "queued for install",
+            status: InstallerStatus.QueuedInstall,
+        });
+        this.addNormalization({
+            text: "install queued",
+            status: InstallerStatus.QueuedInstall,
+        });
+        this.addNormalization({
+            text: "validation installation",
+            status: InstallerStatus.ValidatingInstall,
+        });
+        this.addNormalization({
+            text: "validating installation",
+            status: InstallerStatus.ValidatingInstall,
+        });
+        this.addNormalization({
+            text: "installing",
+            status: InstallerStatus.Installing,
+        });
+        this.addNormalization({
+            text: "install in progress",
+            status: InstallerStatus.Installing,
+        });
+        this.addNormalization({
+            text: "verifying",
+            status: InstallerStatus.Verifying,
+        });
+        this.addNormalization({
+            text: "installed successfully",
+            status: InstallerStatus.Installed,
+        });
+        this.addNormalization({
+            text: "installed",
+            status: InstallerStatus.Installed,
+        });
+        this.addNormalization({
+            text: "complete",
+            status: InstallerStatus.Installed,
+        });
+        this.addNormalization({
+            text: "completed",
+            status: InstallerStatus.Installed,
+        });
+        this.addNormalization({
+            text: "ダウンロード中",
+            status: InstallerStatus.Downloading,
+            locale: "ja",
+        });
+        this.addNormalization({
+            text: "インストール中",
+            status: InstallerStatus.Installing,
+            locale: "ja",
+        });
+        this.addNormalization({
+            text: "検証中",
+            status: InstallerStatus.Verifying,
+            locale: "ja",
+        });
+        this.addNormalization({
+            text: "完了",
+            status: InstallerStatus.Installed,
+            locale: "ja",
+        });
+        this.addNormalization({
+            text: "wird heruntergeladen",
+            status: InstallerStatus.Downloading,
+            locale: "de",
+        });
+        this.addNormalization({
+            text: "wird installiert",
+            status: InstallerStatus.Installing,
+            locale: "de",
+        });
+        this.addNormalization({
+            text: "wird überprüft",
+            status: InstallerStatus.Verifying,
+            locale: "de",
+        });
+        this.addNormalization({
+            text: "erfolgreich installiert",
+            status: InstallerStatus.Installed,
+            locale: "de",
+        });
+        this.addNormalization({
+            text: "téléchargement en cours",
+            status: InstallerStatus.Downloading,
+            locale: "fr",
+        });
+        this.addNormalization({
+            text: "installation en cours",
+            status: InstallerStatus.Installing,
+            locale: "fr",
+        });
+        this.addNormalization({
+            text: "vérification",
+            status: InstallerStatus.Verifying,
+            locale: "fr",
+        });
+        this.addNormalization({
+            text: "installé avec succès",
+            status: InstallerStatus.Installed,
+            locale: "fr",
+        });
+        this.addNormalization({
+            text: "descargando",
+            status: InstallerStatus.Downloading,
+            locale: "es",
+        });
+        this.addNormalization({
+            text: "instalando",
+            status: InstallerStatus.Installing,
+            locale: "es",
+        });
+        this.addNormalization({
+            text: "verificando",
+            status: InstallerStatus.Verifying,
+            locale: "es",
+        });
+        this.addNormalization({
+            text: "instalado correctamente",
+            status: InstallerStatus.Installed,
+            locale: "es",
+        });
+        this.addNormalization({
+            text: "正在下载",
+            status: InstallerStatus.Downloading,
+            locale: "zh-Hans",
+        });
+        this.addNormalization({
+            text: "正在安装",
+            status: InstallerStatus.Installing,
+            locale: "zh-Hans",
+        });
+        this.addNormalization({
+            text: "正在验证",
+            status: InstallerStatus.Verifying,
+            locale: "zh-Hans",
+        });
+        this.addNormalization({
+            text: "安装成功",
+            status: InstallerStatus.Installed,
+            locale: "zh-Hans",
+        });
+        this.addNormalization({
+            text: "正在下載",
+            status: InstallerStatus.Downloading,
+            locale: "zh-Hant",
+        });
+        this.addNormalization({
+            text: "正在安裝",
+            status: InstallerStatus.Installing,
+            locale: "zh-Hant",
+        });
+        this.addNormalization({
+            text: "正在驗證",
+            status: InstallerStatus.Verifying,
+            locale: "zh-Hant",
+        });
+        this.addNormalization({
+            text: "安裝成功",
+            status: InstallerStatus.Installed,
+            locale: "zh-Hant",
+        });
+        this.addNormalization({
+            text: "다운로드 중",
+            status: InstallerStatus.Downloading,
+            locale: "ko",
+        });
+        this.addNormalization({
+            text: "설치 중",
+            status: InstallerStatus.Installing,
+            locale: "ko",
+        });
+        this.addNormalization({
+            text: "확인 중",
+            status: InstallerStatus.Verifying,
+            locale: "ko",
+        });
+        this.addNormalization({
+            text: "설치 완료",
+            status: InstallerStatus.Installed,
+            locale: "ko",
+        });
+    }
+    addNormalization(normalization) {
+        const key = normalization.text.toLowerCase().trim();
+        if (normalization.locale) {
+            if (!this.localeNormalizations.has(normalization.locale)) {
+                this.localeNormalizations.set(normalization.locale, new Map());
+            }
+            this.localeNormalizations.get(normalization.locale).set(key, normalization.status);
+        }
+        else {
+            this.normalizations.set(key, normalization.status);
+        }
+    }
+    normalize(statusText, locale) {
+        const cleanText = statusText.toLowerCase().trim();
+        if (locale && this.localeNormalizations.has(locale)) {
+            const localeMap = this.localeNormalizations.get(locale);
+            if (localeMap.has(cleanText)) {
+                return localeMap.get(cleanText);
+            }
+        }
+        if (this.normalizations.has(cleanText)) {
+            return this.normalizations.get(cleanText);
+        }
+        for (const enumValue of Object.values(InstallerStatus)) {
+            if (enumValue.toLowerCase() === cleanText) {
+                return enumValue;
+            }
+        }
+        this.unknownStatuses.add(statusText);
+        return null;
+    }
+    isKnownStatus(statusText, locale) {
+        return this.normalize(statusText, locale) !== null;
+    }
+    getUnknownStatuses() {
+        return Array.from(this.unknownStatuses);
+    }
+    clearUnknownStatuses() {
+        this.unknownStatuses.clear();
+    }
+    getNormalizationsForLocale(locale) {
+        if (!locale) {
+            return new Map(this.normalizations);
+        }
+        const result = new Map(this.normalizations);
+        if (this.localeNormalizations.has(locale)) {
+            const localeMap = this.localeNormalizations.get(locale);
+            for (const [key, value] of localeMap) {
+                result.set(key, value);
+            }
+        }
+        return result;
+    }
+}

package/dist/esm/events/patterns/types.d.ts

@@ -0,0 +1,30 @@
+import { InstallerEvent, InstallerStatus } from "../../types/unity.js";
+export interface PatternMatch {
+    module: string;
+    status: InstallerStatus;
+    progress?: number | null;
+    error?: string | null;
+    confidence: number;
+}
+export interface Pattern {
+    priority: number;
+    locale?: string;
+    name: string;
+    match(line: string, locale?: string): PatternMatch | null;
+}
+export interface StatusNormalization {
+    text: string;
+    status: InstallerStatus;
+    locale?: string;
+}
+export interface ParserConfig {
+    locale: string;
+    logUnknownStatuses: boolean;
+    minConfidence: number;
+    useFallbackPatterns: boolean;
+}
+export interface ParseResult {
+    events: InstallerEvent[];
+    unknownStatuses: string[];
+    unparsedLines: string[];
+}

package/dist/esm/events/patterns/types.js

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

package/dist/esm/index.d.ts

@@ -1,6 +1,5 @@
-export { default as UnityHub } from "./unityHub.ts";
-export { default as UnityEditor } from "./unityEditor.ts";
-export { default as UnityTemplates } from "./unityTemplates.ts";
-export { UnityHubInstallerEvent } from "./events/hubEventEmitter.ts";
-export { UnityConfig } from "./configs/unityConfig.ts";
-export * from "./types/unity.ts";
+export { default as UnityHub } from "./unityHub.js";
+export { default as UnityEditor } from "./unityEditor.js";
+export { UnityHubInstallerEvent } from "./events/hubEventEmitter.js";
+export * from "./types/unity.js";
+export * from "./errors/index.js";

package/dist/esm/index.js

@@ -1,6 +1,5 @@
 export { default as UnityHub } from "./unityHub.js";
 export { default as UnityEditor } from "./unityEditor.js";
-export { default as UnityTemplates } from "./unityTemplates.js";
 export { UnityHubInstallerEvent } from "./events/hubEventEmitter.js";
-export { UnityConfig } from "./configs/unityConfig.js";
 export * from "./types/unity.js";
+export * from "./errors/index.js";

package/dist/esm/unityEditor.d.ts

@@ -1,21 +1,17 @@
 import { ProjectInfo, TestMode, UnityBuildTarget, UnityEditorInfo } from "./types/unity.js";
-import { CommandOptions, CommandResult } from "./utils/commandExecutor.js";
+import { CommandOptions, CommandOutput } from "./utils/commandExecutor.js";
+import { Result, UnityEditorNotFoundError, UnityCommandError, UnityTestError, UnityLicenseError, UnityPackageError, UnityProjectError } from "./errors/index.js";
 declare class UnityEditor {
     static getUnityExecutablePath(version: string): string;
-    static getUnityTemplatesPath(version: string): string;
     static isUnityVersionInstalled(version: string): Promise<boolean>;
-    static execUnityEditorCommand(editorInfo: UnityEditorInfo, args: string[], options?: CommandOptions): Promise<CommandResult>;
-    static executeMethod(projectInfo: ProjectInfo, method: string, args?: string[], options?: CommandOptions): Promise<CommandResult>;
-    static runTests(projectInfo: ProjectInfo, testPlatform?: TestMode | UnityBuildTarget, testCategory?: string): Promise<{
-        success: boolean;
-        output: string;
-    }>;
-    static activateLicense(projectInfo: ProjectInfo, serial: string, username: string, password: string): Promise<boolean>;
-    static returnLicense(projectInfo: ProjectInfo): Promise<boolean>;
-    static exportPackage(projectInfo: ProjectInfo, assetPaths: string[], outputPath: string): Promise<boolean>;
-    static importPackage(projectInfo: ProjectInfo, packagePath: string): Promise<boolean>;
-    static createProject(projectInfo: ProjectInfo, quit?: boolean, useHub?: boolean): Promise<boolean>;
-    static createProjectFromTemplate(projectInfo: ProjectInfo, templatePath: string, quit?: boolean, useHub?: boolean): Promise<boolean>;
-    static openProject(projectInfo: ProjectInfo, useHub?: boolean, batchmode?: boolean, waitForExit?: boolean): Promise<boolean>;
+    static execUnityEditorCommand(editorInfo: UnityEditorInfo, args: string[], options?: CommandOptions): Promise<Result<CommandOutput, UnityEditorNotFoundError | UnityCommandError>>;
+    static executeMethod(projectInfo: ProjectInfo, method: string, args?: string[], options?: CommandOptions): Promise<Result<CommandOutput, UnityEditorNotFoundError | UnityCommandError>>;
+    static runTests(projectInfo: ProjectInfo, testPlatform?: TestMode | UnityBuildTarget, testCategory?: string): Promise<Result<string, UnityEditorNotFoundError | UnityCommandError | UnityTestError>>;
+    static activateLicense(projectInfo: ProjectInfo, serial: string, username: string, password: string): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityLicenseError>>;
+    static returnLicense(projectInfo: ProjectInfo): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityLicenseError>>;
+    static exportPackage(projectInfo: ProjectInfo, assetPaths: string[], outputPath: string): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityPackageError>>;
+    static importPackage(projectInfo: ProjectInfo, packagePath: string): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityPackageError>>;
+    static createProject(projectInfo: ProjectInfo, waitForExit?: boolean): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityProjectError>>;
+    static openProject(projectInfo: ProjectInfo, useHub?: boolean, batchmode?: boolean, waitForExit?: boolean): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityProjectError>>;
 }
 export default UnityEditor;