@notask/unity-cli-tools 1.1.2 → 2.0.0

package/dist/esm/events/patterns/implementations/bracketModulePattern.js

@@ -0,0 +1,53 @@
+import { InstallerStatus } from "../../../types/unity.js";
+export class BracketModulePattern {
+    name = "BracketModulePattern";
+    priority = 80;
+    locale;
+    statusNormalizer;
+    pattern = /^\s*[\[\(]([^\]\)]+)[\]\)]\s+(.+?)(?:\s+(\d+(?:\.\d+)?)\s*%)?\.{0,3}\s*$/;
+    constructor(statusNormalizer, locale) {
+        this.statusNormalizer = statusNormalizer;
+        this.locale = locale;
+    }
+    match(line, locale) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            return null;
+        }
+        const match = trimmedLine.match(this.pattern);
+        if (!match) {
+            return null;
+        }
+        const [, moduleName, statusText, progressStr] = match;
+        if (!moduleName || !statusText) {
+            return null;
+        }
+        const effectiveLocale = locale || this.locale;
+        const normalizedStatus = this.statusNormalizer.normalize(statusText, effectiveLocale);
+        if (!normalizedStatus) {
+            return {
+                module: moduleName.trim(),
+                status: statusText.trim(),
+                progress: progressStr ? parseFloat(progressStr) : null,
+                confidence: 40,
+            };
+        }
+        let progress = null;
+        if (progressStr) {
+            const parsed = parseFloat(progressStr);
+            if (!isNaN(parsed) && parsed >= 0 && parsed <= 100) {
+                progress = parsed;
+            }
+        }
+        else if (normalizedStatus === InstallerStatus.Downloading ||
+            normalizedStatus === InstallerStatus.Installing) {
+            progress = 0;
+        }
+        return {
+            module: moduleName.trim(),
+            status: normalizedStatus,
+            progress,
+            confidence: 85,
+        };
+    }
+}

package/dist/esm/events/patterns/implementations/errorPattern.d.ts

@@ -0,0 +1,22 @@
+import { Pattern, PatternMatch } from "../types.js";
+declare enum ErrorSeverity {
+    Critical = "critical",
+    Error = "error",
+    Warning = "warning"
+}
+export declare class ErrorPattern implements Pattern {
+    readonly name = "ErrorPattern";
+    readonly priority = 90;
+    readonly locale?: string;
+    private criticalPatterns;
+    private errorPatterns;
+    private warningPatterns;
+    private localizedErrorPatterns;
+    constructor(locale?: string);
+    match(line: string, locale?: string): PatternMatch | null;
+    private matchesAnyPattern;
+    private createErrorMatch;
+    addErrorPattern(pattern: RegExp, severity?: ErrorSeverity): void;
+    addLocalizedPatterns(locale: string, patterns: RegExp[]): void;
+}
+export {};

package/dist/esm/events/patterns/implementations/errorPattern.js

@@ -0,0 +1,95 @@
+import { InstallerStatus } from "../../../types/unity.js";
+var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["Critical"] = "critical";
+    ErrorSeverity["Error"] = "error";
+    ErrorSeverity["Warning"] = "warning";
+})(ErrorSeverity || (ErrorSeverity = {}));
+export class ErrorPattern {
+    name = "ErrorPattern";
+    priority = 90;
+    locale;
+    criticalPatterns = [
+        /\b(?:fatal|critical|emergency)\b/i,
+        /\bexception\b/i,
+        /\bstack\s*trace\b/i,
+        /\bcrash(?:ed)?\b/i,
+    ];
+    errorPatterns = [
+        /\berror\s*:/i,
+        /\berror\b/i,
+        /\bfailed\b/i,
+        /\bcannot\b/i,
+        /\bunable\s+to\b/i,
+        /\bcould\s+not\b/i,
+        /\bfailure\b/i,
+    ];
+    warningPatterns = [/\bwarning\s*:/i, /\bwarning\b/i, /\bcaution\b/i];
+    localizedErrorPatterns = new Map([
+        ["ja", [/エラー/, /失敗/, /例外/, /できません/]],
+        ["de", [/fehler/i, /fehlgeschlagen/i, /ausnahme/i, /kann\s+nicht/i]],
+        ["fr", [/erreur/i, /échec/i, /échoué/i, /exception/i, /impossible/i]],
+        ["es", [/error/i, /fallo/i, /fallido/i, /excepción/i, /no\s+se\s+puede/i]],
+        ["zh-Hans", [/错误/, /失败/, /异常/, /无法/]],
+        ["zh-Hant", [/錯誤/, /失敗/, /異常/, /無法/]],
+        ["ko", [/오류/, /실패/, /예외/, /할\s*수\s*없습니다/]],
+    ]);
+    constructor(locale) {
+        this.locale = locale;
+    }
+    match(line, locale) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            return null;
+        }
+        const effectiveLocale = locale || this.locale;
+        if (this.matchesAnyPattern(trimmedLine, this.criticalPatterns)) {
+            return this.createErrorMatch(trimmedLine, ErrorSeverity.Critical, 95);
+        }
+        if (this.matchesAnyPattern(trimmedLine, this.errorPatterns)) {
+            return this.createErrorMatch(trimmedLine, ErrorSeverity.Error, 90);
+        }
+        if (effectiveLocale && this.localizedErrorPatterns.has(effectiveLocale)) {
+            const patterns = this.localizedErrorPatterns.get(effectiveLocale);
+            if (this.matchesAnyPattern(trimmedLine, patterns)) {
+                return this.createErrorMatch(trimmedLine, ErrorSeverity.Error, 88);
+            }
+        }
+        if (this.matchesAnyPattern(trimmedLine, this.warningPatterns)) {
+            return this.createErrorMatch(trimmedLine, ErrorSeverity.Warning, 70);
+        }
+        return null;
+    }
+    matchesAnyPattern(line, patterns) {
+        return patterns.some((pattern) => pattern.test(line));
+    }
+    createErrorMatch(line, severity, confidence) {
+        const bracketMatch = line.match(/^\s*[\[\(]([^\]\)]+)[\]\)]/);
+        const module = bracketMatch ? bracketMatch[1].trim() : "UnityHub";
+        return {
+            module,
+            status: InstallerStatus.Error,
+            error: line.trim(),
+            confidence,
+        };
+    }
+    addErrorPattern(pattern, severity = ErrorSeverity.Error) {
+        switch (severity) {
+            case ErrorSeverity.Critical:
+                this.criticalPatterns.push(pattern);
+                break;
+            case ErrorSeverity.Error:
+                this.errorPatterns.push(pattern);
+                break;
+            case ErrorSeverity.Warning:
+                this.warningPatterns.push(pattern);
+                break;
+        }
+    }
+    addLocalizedPatterns(locale, patterns) {
+        if (!this.localizedErrorPatterns.has(locale)) {
+            this.localizedErrorPatterns.set(locale, []);
+        }
+        this.localizedErrorPatterns.get(locale).push(...patterns);
+    }
+}

package/dist/esm/events/patterns/implementations/fallbackPattern.d.ts

@@ -0,0 +1,13 @@
+import { Pattern, PatternMatch } from "../types.js";
+import { StatusNormalizer } from "../statusNormalizer.js";
+export declare class FallbackPattern implements Pattern {
+    readonly name = "FallbackPattern";
+    readonly priority = 20;
+    readonly locale?: string;
+    private statusNormalizer;
+    constructor(statusNormalizer: StatusNormalizer, locale?: string);
+    match(line: string, locale?: string): PatternMatch | null;
+    private findStatusInLine;
+    private extractModuleName;
+    private escapeRegex;
+}

package/dist/esm/events/patterns/implementations/fallbackPattern.js

@@ -0,0 +1,59 @@
+export class FallbackPattern {
+    name = "FallbackPattern";
+    priority = 20;
+    locale;
+    statusNormalizer;
+    constructor(statusNormalizer, locale) {
+        this.statusNormalizer = statusNormalizer;
+        this.locale = locale;
+    }
+    match(line, locale) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            return null;
+        }
+        const effectiveLocale = locale || this.locale;
+        const progressMatch = trimmedLine.match(/(\d+(?:\.\d+)?)\s*%/);
+        const progress = progressMatch ? parseFloat(progressMatch[1]) : null;
+        const statusMatch = this.findStatusInLine(trimmedLine, effectiveLocale);
+        if (!statusMatch) {
+            return null;
+        }
+        const moduleName = this.extractModuleName(trimmedLine, statusMatch.statusText);
+        return {
+            module: moduleName || "Unknown",
+            status: statusMatch.status,
+            progress,
+            confidence: 30,
+        };
+    }
+    findStatusInLine(line, locale) {
+        const normalizations = this.statusNormalizer.getNormalizationsForLocale(locale);
+        const sortedNormalizations = Array.from(normalizations.entries()).sort((a, b) => b[0].length - a[0].length);
+        for (const [statusText, status] of sortedNormalizations) {
+            const pattern = new RegExp(`\\b${this.escapeRegex(statusText)}\\b`, "i");
+            if (pattern.test(line)) {
+                return { status, statusText };
+            }
+        }
+        return null;
+    }
+    extractModuleName(line, statusText) {
+        let cleanLine = line.replace(new RegExp(`\\b${this.escapeRegex(statusText)}\\b`, "gi"), "");
+        cleanLine = cleanLine.replace(/\d+(?:\.\d+)?\s*%/, "");
+        cleanLine = cleanLine.replace(/[:\-\[\]\(\)]/g, " ");
+        cleanLine = cleanLine.trim();
+        const words = cleanLine.split(/\s+/).filter((w) => w.length > 0);
+        if (words.length === 0) {
+            return null;
+        }
+        const capitalizedWords = words.filter((w) => /^[A-Z]/.test(w));
+        if (capitalizedWords.length > 0) {
+            return capitalizedWords.join(" ");
+        }
+        return words.join(" ");
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+}

package/dist/esm/events/patterns/implementations/index.d.ts

@@ -0,0 +1,3 @@
+export { BracketModulePattern } from "./bracketModulePattern.js";
+export { ErrorPattern } from "./errorPattern.js";
+export { FallbackPattern } from "./fallbackPattern.js";

package/dist/esm/events/patterns/implementations/index.js

@@ -0,0 +1,3 @@
+export { BracketModulePattern } from "./bracketModulePattern.js";
+export { ErrorPattern } from "./errorPattern.js";
+export { FallbackPattern } from "./fallbackPattern.js";

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

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { StatusNormalizer } from "./statusNormalizer.js";
+export { PatternRegistry } from "./patternRegistry.js";
+export * from "./implementations/index.js";

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

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { StatusNormalizer } from "./statusNormalizer.js";
+export { PatternRegistry } from "./patternRegistry.js";
+export * from "./implementations/index.js";

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

@@ -0,0 +1,14 @@
+import { Pattern, PatternMatch } from "./types.js";
+export declare class PatternRegistry {
+    private patterns;
+    register(pattern: Pattern): void;
+    registerAll(patterns: Pattern[]): void;
+    unregister(patternName: string): boolean;
+    getPatterns(locale?: string): Pattern[];
+    match(line: string, locale?: string, minConfidence?: number): PatternMatch | null;
+    matchAll(line: string, locale?: string): PatternMatch[];
+    getPatternNames(): string[];
+    clear(): void;
+    count(): number;
+    private sortPatterns;
+}

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

@@ -0,0 +1,65 @@
+export class PatternRegistry {
+    patterns = [];
+    register(pattern) {
+        this.patterns.push(pattern);
+        this.sortPatterns();
+    }
+    registerAll(patterns) {
+        this.patterns.push(...patterns);
+        this.sortPatterns();
+    }
+    unregister(patternName) {
+        const initialLength = this.patterns.length;
+        this.patterns = this.patterns.filter((p) => p.name !== patternName);
+        return this.patterns.length < initialLength;
+    }
+    getPatterns(locale) {
+        if (!locale) {
+            return [...this.patterns];
+        }
+        return this.patterns.filter((p) => !p.locale || p.locale === locale);
+    }
+    match(line, locale, minConfidence = 0) {
+        const applicablePatterns = this.getPatterns(locale);
+        for (const pattern of applicablePatterns) {
+            try {
+                const match = pattern.match(line, locale);
+                if (match && match.confidence >= minConfidence) {
+                    return match;
+                }
+            }
+            catch (error) {
+                console.error(`Error in pattern "${pattern.name}":`, error);
+            }
+        }
+        return null;
+    }
+    matchAll(line, locale) {
+        const applicablePatterns = this.getPatterns(locale);
+        const matches = [];
+        for (const pattern of applicablePatterns) {
+            try {
+                const match = pattern.match(line, locale);
+                if (match) {
+                    matches.push(match);
+                }
+            }
+            catch (error) {
+                console.error(`Error in pattern "${pattern.name}":`, error);
+            }
+        }
+        return matches.sort((a, b) => b.confidence - a.confidence);
+    }
+    getPatternNames() {
+        return this.patterns.map((p) => p.name);
+    }
+    clear() {
+        this.patterns = [];
+    }
+    count() {
+        return this.patterns.length;
+    }
+    sortPatterns() {
+        this.patterns.sort((a, b) => b.priority - a.priority);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { InstallerStatus } from "../../types/unity.js";
+import { StatusNormalization } from "./types.js";
+export declare class StatusNormalizer {
+    private normalizations;
+    private localeNormalizations;
+    private unknownStatuses;
+    constructor();
+    private initializeDefaultNormalizations;
+    addNormalization(normalization: StatusNormalization): void;
+    normalize(statusText: string, locale?: string): InstallerStatus | null;
+    isKnownStatus(statusText: string, locale?: string): boolean;
+    getUnknownStatuses(): string[];
+    clearUnknownStatuses(): void;
+    getNormalizationsForLocale(locale?: string): Map<string, InstallerStatus>;
+}

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,4 +1,5 @@
-export { default as UnityHub } from "./unityHub.ts";
-export { default as UnityEditor } from "./unityEditor.ts";
-export { UnityHubInstallerEvent } from "./events/hubEventEmitter.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";