@notask/unity-cli-tools 1.1.2 → 2.0.0

package/dist/cjs/unityHub.js

@@ -9,7 +9,8 @@ const path_1 = __importDefault(require("path"));
 const unity_js_1 = require("./types/unity.js");
 const commandExecutor_js_1 = require("./utils/commandExecutor.js");
 const unity_changeset_1 = require("unity-changeset");
-const hubEventEmitter_ts_1 = require("./events/hubEventEmitter.js");
+const hubEventEmitter_js_1 = require("./events/hubEventEmitter.js");
+const index_js_1 = require("./errors/index.js");
 class UnityHub {
     static CONFIG_PATHS = {
         win32: {
@@ -56,122 +57,124 @@ class UnityHub {
         const isAvailable = await UnityHub.isUnityHubAvailable();
         if (!isAvailable) {
             console.error("Unity Hub is not available.");
-            return {
-                success: false,
-                stdout: "",
-                stderr: "Unity Hub is not available.",
-                exitCode: -1,
-            };
-        }
-        try {
-            const hubArgs = [this.platform !== "linux" ? "--" : "", "--headless", ...args].filter(Boolean);
-            console.debug(`Executing Unity Hub command: ${this.hubPath} ${hubArgs.join(" ")}`);
-            return await (0, commandExecutor_js_1.executeCommand)(this.hubPath, hubArgs, options);
-        }
-        catch (error) {
-            console.error("Error executing Unity Hub command:", error);
-            return {
-                success: false,
-                stdout: "",
-                stderr: String(error),
-                exitCode: -1,
-            };
+            return (0, index_js_1.err)(new index_js_1.UnityHubNotFoundError("Unity Hub is not available", { hubPath: this.hubPath }));
         }
+        const hubArgs = [this.platform !== "linux" ? "--" : "", "--headless", ...args].filter(Boolean);
+        console.debug(`Executing Unity Hub command: ${this.hubPath} ${hubArgs.join(" ")}`);
+        return await (0, commandExecutor_js_1.executeCommand)(this.hubPath, hubArgs, options);
     }
     static async getInstallPath() {
-        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-g"], {
+        const result = await this.execUnityHubCommand(["install-path", "-g"], {
             reject: false,
         });
-        if (stderr) {
-            throw new Error(`Error getting install path: ${stderr}`);
+        if (!result.success) {
+            return result;
+        }
+        if (result.value.stderr) {
+            return (0, index_js_1.err)(new index_js_1.UnityCommandError(`Error getting install path: ${result.value.stderr}`, result.value.stdout, result.value.stderr, result.value.exitCode));
         }
-        return stdout;
+        return (0, index_js_1.ok)(result.value.stdout.trim());
     }
     static async setInstallPath(path) {
-        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-s", path], {
+        const result = await this.execUnityHubCommand(["install-path", "-s", path], {
             reject: false,
         });
-        if (stderr) {
-            throw new Error(`Error setting install path: ${stderr}`);
+        if (!result.success) {
+            return result;
+        }
+        if (result.value.stderr) {
+            return (0, index_js_1.err)(new index_js_1.UnityCommandError(`Error setting install path: ${result.value.stderr}`, result.value.stdout, result.value.stderr, result.value.exitCode));
         }
-        console.debug(`Install path set to: ${stdout}`);
+        console.debug(`Install path set to: ${result.value.stdout}`);
+        return (0, index_js_1.ok)(undefined);
     }
     static async getUnityInstallations(filter = "i") {
         if (!["i", "a", "r"].includes(filter)) {
-            throw new Error(`Invalid filter "${filter}". Use "i" for installed, "a" for all, or "r" for available releases.`);
+            return (0, index_js_1.err)(new index_js_1.InvalidArgumentError(`Invalid filter "${filter}". Use "i" for installed, "a" for all, or "r" for available releases.`, { filter, validFilters: ["i", "a", "r"] }));
         }
-        const { stdout, stderr } = await this.execUnityHubCommand(["editors", `-${filter}`], {
+        const result = await this.execUnityHubCommand(["editors", `-${filter}`], {
             reject: false,
         });
+        if (!result.success) {
+            return result;
+        }
+        const { stdout, stderr } = result.value;
         const isSuccess = stdout.includes(", installed at");
-        if (stderr)
-            throw new Error(`Get installations command warning/error: ${stderr}`);
-        if (!isSuccess)
-            throw new Error(`Consider install a Unity version using Unity Hub.`);
+        if (stderr) {
+            return (0, index_js_1.err)(new index_js_1.UnityCommandError(`Get installations command warning/error: ${stderr}`, stdout, stderr, result.value.exitCode));
+        }
+        if (!isSuccess) {
+            return (0, index_js_1.err)(new index_js_1.UnityInstallationError("No Unity installations found. Consider installing a Unity version using Unity Hub.", {
+                filter,
+            }));
+        }
         const lines = stdout.split(/\r\n|\n/);
         const installations = {};
         lines.forEach((line) => {
             const [version, unityPath] = line.split(", installed at").map((entry) => entry.trim());
-            installations[version] = unityPath;
+            if (version && unityPath) {
+                installations[version] = unityPath;
+            }
         });
-        if (Object.keys(installations).length <= 0)
-            throw new Error("No unity installations found.");
-        return installations;
+        if (Object.keys(installations).length <= 0) {
+            return (0, index_js_1.err)(new index_js_1.UnityInstallationError("No Unity installations found.", { filter }));
+        }
+        return (0, index_js_1.ok)(installations);
     }
     static async addModule(editorVersion, modules, childModules = true) {
-        try {
-            console.debug(`Adding module ${modules} to Unity ${editorVersion}`);
-            const args = ["install-modules", "-v", editorVersion];
-            if (modules.length > 0) {
-                args.push(...["--module", modules.join(" ")]);
-                if (childModules) {
-                    args.push("--child-modules");
-                }
-            }
-            else {
-                throw new Error("No module IDs provided.");
-            }
-            const installerEmitter = new hubEventEmitter_ts_1.UnityHubInstallerEvent();
-            this.execUnityHubCommand(args, {
-                reject: false,
-                onStdout: (data) => installerEmitter.Progress(data),
-            }).catch((error) => {
-                console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
-            });
-            return installerEmitter;
+        if (modules.length === 0) {
+            return (0, index_js_1.err)(new index_js_1.InvalidArgumentError("No module IDs provided.", { editorVersion, modules }));
         }
-        catch (error) {
-            console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
-            throw error;
+        console.debug(`Adding module ${modules} to Unity ${editorVersion}`);
+        const args = ["install-modules", "-v", editorVersion, "--module", modules.join(" ")];
+        if (childModules) {
+            args.push("--child-modules");
         }
+        const installerEmitter = new hubEventEmitter_js_1.UnityHubInstallerEvent();
+        this.execUnityHubCommand(args, {
+            reject: false,
+            onStdout: (data) => installerEmitter.Progress(data),
+        })
+            .then((result) => {
+            if (!result.success) {
+                console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, result.error);
+            }
+        })
+            .catch((error) => {
+            console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
+        });
+        return (0, index_js_1.ok)(installerEmitter);
     }
     static async addEditor(version, modules = [], architecture) {
         try {
             const data = await (0, unity_changeset_1.getUnityChangeset)(version);
-            const args = ["install", "-v", version];
-            args.push("--changeset", data.changeset);
+            const args = ["install", "-v", version, "--changeset", data.changeset];
             if (modules.length > 0) {
-                args.push("--module");
-                args.push(modules.join(" "));
+                args.push("--module", modules.join(" "));
             }
             if (!architecture) {
                 const arch = os_1.default.arch() || process.arch;
-                const defaultArchitecture = arch === "arm64" || arch === "arm" ? unity_js_1.EditorArchitecture.arm64 : unity_js_1.EditorArchitecture.x86_64;
-                architecture = defaultArchitecture;
+                architecture = arch === "arm64" || arch === "arm" ? unity_js_1.EditorArchitecture.arm64 : unity_js_1.EditorArchitecture.x86_64;
             }
             args.push("--architecture", architecture);
-            const installerEmitter = new hubEventEmitter_ts_1.UnityHubInstallerEvent();
+            const installerEmitter = new hubEventEmitter_js_1.UnityHubInstallerEvent();
             this.execUnityHubCommand(args, {
                 reject: false,
                 onStdout: (data) => installerEmitter.Progress(data),
-            }).catch((error) => {
+            })
+                .then((result) => {
+                if (!result.success) {
+                    console.error(`Error installing Unity ${version}:`, result.error);
+                }
+            })
+                .catch((error) => {
                 console.error(`Error installing Unity ${version}:`, error);
             });
-            return installerEmitter;
+            return (0, index_js_1.ok)(installerEmitter);
         }
         catch (error) {
             console.error(error);
-            throw error;
+            return (0, index_js_1.err)(new index_js_1.UnityInstallationError(`Failed to install Unity ${version}: ${String(error)}`, { version, modules, architecture }));
         }
     }
     static async getProjects() {
@@ -179,19 +182,20 @@ class UnityHub {
             const projectsPath = this.getProjectsPath();
             if (!projectsPath || !fs_extra_1.default.existsSync(projectsPath)) {
                 console.debug(`Projects file not found at: ${projectsPath}`);
-                return [];
+                return (0, index_js_1.err)(new index_js_1.UnityProjectError(`Projects file not found at: ${projectsPath}`, { projectsPath }));
             }
             const projectsData = await fs_extra_1.default.readJson(projectsPath);
             const projects = Object.values(projectsData.data);
-            return projects.map((project) => ({
+            const mappedProjects = projects.map((project) => ({
                 name: project.title,
                 path: project.path,
                 version: project.version,
             }));
+            return (0, index_js_1.ok)(mappedProjects);
         }
         catch (error) {
             console.error("Error getting recent projects:", error);
-            return [];
+            return (0, index_js_1.err)(new index_js_1.UnityProjectError(`Failed to get projects: ${String(error)}`));
         }
     }
     static async getDefaultProjectsDirectory() {
@@ -199,14 +203,14 @@ class UnityHub {
             const projectDirPath = this.getProjectDirPath();
             if (!projectDirPath || !fs_extra_1.default.existsSync(projectDirPath)) {
                 console.debug(`Project directory file not found at: ${projectDirPath}`);
-                return null;
+                return (0, index_js_1.ok)(null);
             }
             const projectDirData = await fs_extra_1.default.readJson(projectDirPath);
-            return projectDirData.directoryPath ?? null;
+            return (0, index_js_1.ok)(projectDirData.directoryPath ?? null);
         }
         catch (error) {
             console.error("Error getting default project directory:", error);
-            return null;
+            return (0, index_js_1.err)(new index_js_1.UnityProjectError(`Failed to get default project directory: ${String(error)}`));
         }
     }
 }

package/dist/cjs/utils/commandExecutor.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCommand = executeCommand;
 const execa_1 = require("execa");
+const index_js_1 = require("../errors/index.js");
+const index_js_2 = require("../errors/index.js");
 async function executeCommand(executable, args, options = {}) {
     try {
         const streamOutput = options.onStdout || options.onStderr;
@@ -40,19 +42,16 @@ async function executeCommand(executable, args, options = {}) {
             }
         }
         const { stdout, stderr, exitCode } = await subprocess;
-        return {
-            success: true,
+        return (0, index_js_1.ok)({
             stdout,
             stderr,
             exitCode,
-        };
+        });
     }
     catch (error) {
-        return {
-            success: false,
-            stdout: error.stdout ?? "",
-            stderr: error.stderr ?? String(error),
-            exitCode: error.exitCode,
-        };
+        const stdout = error.stdout ?? "";
+        const stderr = error.stderr ?? String(error);
+        const exitCode = error.exitCode;
+        return (0, index_js_1.err)(new index_js_2.UnityCommandError(`Command execution failed: ${executable} ${args.join(" ")}`, stdout, stderr, exitCode, { executable, args }));
     }
 }

package/dist/esm/errors/Result.d.ts

@@ -0,0 +1,21 @@
+import { UnityError } from "./UnityError.js";
+export interface Success<T> {
+    readonly success: true;
+    readonly value: T;
+}
+export interface Failure<E extends UnityError> {
+    readonly success: false;
+    readonly error: E;
+}
+export type Result<T, E extends UnityError = UnityError> = Success<T> | Failure<E>;
+export declare function ok<T>(value: T): Success<T>;
+export declare function err<E extends UnityError>(error: E): Failure<E>;
+export declare function isOk<T, E extends UnityError>(result: Result<T, E>): result is Success<T>;
+export declare function isErr<T, E extends UnityError>(result: Result<T, E>): result is Failure<E>;
+export declare function unwrap<T, E extends UnityError>(result: Result<T, E>): T;
+export declare function unwrapOr<T, E extends UnityError>(result: Result<T, E>, defaultValue: T): T;
+export declare function map<T, U, E extends UnityError>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+export declare function mapErr<T, E extends UnityError, F extends UnityError>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+export declare function andThen<T, U, E extends UnityError>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+export declare function firstOk<T, E extends UnityError>(results: Result<T, E>[]): Result<T, E>;
+export declare function combine<T, E extends UnityError>(results: Result<T, E>[]): Result<T[], E>;

package/dist/esm/errors/Result.js

@@ -0,0 +1,63 @@
+export function ok(value) {
+    return { success: true, value };
+}
+export function err(error) {
+    return { success: false, error };
+}
+export function isOk(result) {
+    return result.success === true;
+}
+export function isErr(result) {
+    return result.success === false;
+}
+export function unwrap(result) {
+    if (isOk(result)) {
+        return result.value;
+    }
+    throw result.error;
+}
+export function unwrapOr(result, defaultValue) {
+    if (isOk(result)) {
+        return result.value;
+    }
+    return defaultValue;
+}
+export function map(result, fn) {
+    if (isOk(result)) {
+        return ok(fn(result.value));
+    }
+    return result;
+}
+export function mapErr(result, fn) {
+    if (isErr(result)) {
+        return err(fn(result.error));
+    }
+    return result;
+}
+export function andThen(result, fn) {
+    if (isOk(result)) {
+        return fn(result.value);
+    }
+    return result;
+}
+export function firstOk(results) {
+    if (results.length === 0) {
+        throw new Error("Cannot call firstOk on empty array");
+    }
+    for (const result of results) {
+        if (isOk(result)) {
+            return result;
+        }
+    }
+    return results[results.length - 1];
+}
+export function combine(results) {
+    const values = [];
+    for (const result of results) {
+        if (isErr(result)) {
+            return result;
+        }
+        values.push(result.value);
+    }
+    return ok(values);
+}

package/dist/esm/errors/UnityError.d.ts

@@ -0,0 +1,36 @@
+export declare abstract class UnityError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: string, context?: Record<string, unknown>);
+}
+export declare class UnityHubNotFoundError extends UnityError {
+    constructor(message?: string, context?: Record<string, unknown>);
+}
+export declare class UnityEditorNotFoundError extends UnityError {
+    constructor(version: string, path?: string);
+}
+export declare class UnityCommandError extends UnityError {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode?: number;
+    constructor(message: string, stdout?: string, stderr?: string, exitCode?: number, context?: Record<string, unknown>);
+}
+export declare class UnityInstallationError extends UnityError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+export declare class UnityProjectError extends UnityError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+export declare class UnityLicenseError extends UnityError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+export declare class UnityPackageError extends UnityError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+export declare class UnityTestError extends UnityError {
+    readonly testOutput: string;
+    constructor(message: string, testOutput?: string, context?: Record<string, unknown>);
+}
+export declare class InvalidArgumentError extends UnityError {
+    constructor(message: string, context?: Record<string, unknown>);
+}

package/dist/esm/errors/UnityError.js

@@ -0,0 +1,64 @@
+export class UnityError extends Error {
+    code;
+    context;
+    constructor(message, code, context) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.context = context;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+export class UnityHubNotFoundError extends UnityError {
+    constructor(message = "Unity Hub is not available", context) {
+        super(message, "UNITY_HUB_NOT_FOUND", context);
+    }
+}
+export class UnityEditorNotFoundError extends UnityError {
+    constructor(version, path) {
+        super(`Unity Editor version ${version} not found${path ? ` at path: ${path}` : ""}`, "UNITY_EDITOR_NOT_FOUND", { version, path });
+    }
+}
+export class UnityCommandError extends UnityError {
+    stdout;
+    stderr;
+    exitCode;
+    constructor(message, stdout = "", stderr = "", exitCode, context) {
+        super(message, "UNITY_COMMAND_ERROR", context);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.exitCode = exitCode;
+    }
+}
+export class UnityInstallationError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_INSTALLATION_ERROR", context);
+    }
+}
+export class UnityProjectError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_PROJECT_ERROR", context);
+    }
+}
+export class UnityLicenseError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_LICENSE_ERROR", context);
+    }
+}
+export class UnityPackageError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_PACKAGE_ERROR", context);
+    }
+}
+export class UnityTestError extends UnityError {
+    testOutput;
+    constructor(message, testOutput = "", context) {
+        super(message, "UNITY_TEST_ERROR", context);
+        this.testOutput = testOutput;
+    }
+}
+export class InvalidArgumentError extends UnityError {
+    constructor(message, context) {
+        super(message, "INVALID_ARGUMENT", context);
+    }
+}

package/dist/esm/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Result.js";
+export * from "./UnityError.js";

package/dist/esm/errors/index.js

@@ -0,0 +1,2 @@
+export * from "./Result.js";
+export * from "./UnityError.js";

package/dist/esm/events/hubEventEmitter.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { InstallerEventType, InstallerEvent } from "../types/unity.ts";
+import { InstallerEventType, InstallerEvent } from "../types/unity.js";
 export interface InstallerEmitter extends EventEmitter {
     on(event: InstallerEventType.Progress, listener: (info: InstallerEvent[]) => void): this;
     on(event: InstallerEventType.Error, listener: (error: Error) => void): this;

package/dist/esm/events/hubEventParser.d.ts

@@ -1,6 +1,20 @@
-import { InstallerEvent } from "../types/unity.ts";
+import { InstallerEvent } from "../types/unity.js";
+import { ParserConfig, ParseResult, Pattern } from "./patterns/index.js";
 export declare class UnityHubEventParser {
-    private static errorPatterns;
+    private static patternRegistry;
+    private static statusNormalizer;
+    private static config;
+    private static initialize;
     static parseUnityHubEvent(event: string): InstallerEvent[];
-    private static checkForErrors;
+    static parseWithDetails(event: string): ParseResult;
+    static setLocale(locale: string): void;
+    static getLocale(): string;
+    static registerCustomPattern(pattern: Pattern): void;
+    static addStatusNormalization(statusText: string, status: any, locale?: string): void;
+    static getUnknownStatuses(): string[];
+    static clearUnknownStatuses(): void;
+    static configure(config: Partial<ParserConfig>): void;
+    static getConfig(): Readonly<ParserConfig>;
+    static reset(): void;
+    static getPatternNames(): string[];
 }

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