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

package/dist/esm/events/hubEventParser.js

@@ -1,40 +1,110 @@
-import { InstallerStatus } from "../types/unity.js";
+import { PatternRegistry, StatusNormalizer, BracketModulePattern, ErrorPattern, FallbackPattern, } from "./patterns/index.js";
 export class UnityHubEventParser {
-    static errorPatterns = [/Error:.*/];
+    static patternRegistry;
+    static statusNormalizer;
+    static config = {
+        locale: "en",
+        logUnknownStatuses: true,
+        minConfidence: 30,
+        useFallbackPatterns: true,
+    };
+    static initialize() {
+        if (this.patternRegistry) {
+            return;
+        }
+        this.statusNormalizer = new StatusNormalizer();
+        this.patternRegistry = new PatternRegistry();
+        this.patternRegistry.register(new ErrorPattern(this.config.locale));
+        this.patternRegistry.register(new BracketModulePattern(this.statusNormalizer, this.config.locale));
+        if (this.config.useFallbackPatterns) {
+            this.patternRegistry.register(new FallbackPattern(this.statusNormalizer, this.config.locale));
+        }
+    }
     static parseUnityHubEvent(event) {
+        this.initialize();
+        const result = this.parseWithDetails(event);
+        return result.events;
+    }
+    static parseWithDetails(event) {
+        this.initialize();
         const events = [];
-        const lines = event.split("\n");
+        const unparsedLines = [];
+        const lines = event.split(/\r?\n/);
         for (const line of lines) {
-            const errorLine = this.checkForErrors(line);
-            if (errorLine) {
-                events.push(errorLine);
+            const trimmedLine = line.trim();
+            if (!trimmedLine) {
                 continue;
             }
-        }
-        const pattern = /^\[(?<module>[^\]]+)\]\s+(?<status>.+?)(?:(?:\s+(?<progress>\d+(?:\.\d+)?))%)?\.*$/;
-        for (const line of lines) {
-            const match = line.match(pattern);
-            if (match?.groups) {
-                const { module, status, progress } = match.groups;
+            const match = this.patternRegistry.match(trimmedLine, this.config.locale, this.config.minConfidence);
+            if (match) {
                 events.push({
-                    module: module.trim(),
-                    status: status.replace(/\.\.\.$/, "").trim(),
-                    progress: progress ? parseFloat(progress) : status !== InstallerStatus.Downloading ? null : 0,
+                    module: match.module,
+                    status: match.status,
+                    progress: match.progress,
+                    error: match.error,
                 });
             }
-        }
-        return events;
-    }
-    static checkForErrors(line) {
-        for (const pattern of this.errorPatterns) {
-            if (pattern.test(line)) {
-                return {
-                    module: "UnityHub",
-                    status: InstallerStatus.Error,
-                    error: line.trim(),
-                };
+            else {
+                unparsedLines.push(trimmedLine);
+                if (this.config.logUnknownStatuses) {
+                    console.debug(`UnityHubEventParser: Could not parse line: "${trimmedLine}"`);
+                }
             }
         }
-        return null;
+        return {
+            events,
+            unknownStatuses: this.statusNormalizer.getUnknownStatuses(),
+            unparsedLines,
+        };
+    }
+    static setLocale(locale) {
+        this.config.locale = locale;
+        if (this.patternRegistry) {
+            this.patternRegistry.clear();
+            this.initialize();
+        }
+    }
+    static getLocale() {
+        return this.config.locale;
+    }
+    static registerCustomPattern(pattern) {
+        this.initialize();
+        this.patternRegistry.register(pattern);
+    }
+    static addStatusNormalization(statusText, status, locale) {
+        this.initialize();
+        this.statusNormalizer.addNormalization({ text: statusText, status, locale });
+    }
+    static getUnknownStatuses() {
+        this.initialize();
+        return this.statusNormalizer.getUnknownStatuses();
+    }
+    static clearUnknownStatuses() {
+        this.initialize();
+        this.statusNormalizer.clearUnknownStatuses();
+    }
+    static configure(config) {
+        this.config = { ...this.config, ...config };
+        if (config.locale && this.patternRegistry) {
+            this.patternRegistry.clear();
+            this.initialize();
+        }
+    }
+    static getConfig() {
+        return { ...this.config };
+    }
+    static reset() {
+        this.patternRegistry = undefined;
+        this.statusNormalizer = undefined;
+        this.config = {
+            locale: "en",
+            logUnknownStatuses: true,
+            minConfidence: 30,
+            useFallbackPatterns: true,
+        };
+    }
+    static getPatternNames() {
+        this.initialize();
+        return this.patternRegistry.getPatternNames();
     }
 }

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

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

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>;
+}