orcas-angular 1.0.4 → 1.0.5

package/fesm2022/orcas-angular.mjs

@@ -0,0 +1,1608 @@
+import * as i0 from '@angular/core';
+import { Injectable, computed, inject, signal, Pipe, InjectionToken, HostListener, Directive, effect, input, booleanAttribute, output, ViewChild, Component } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import * as i1 from '@angular/router';
+import { NavigationEnd } from '@angular/router';
+import * as i2 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { lastValueFrom } from 'rxjs';
+
+class Async {
+    static async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    static async until(check, timeoutMs = 10000, frequencyMs = 100) {
+        let timePassed = 0;
+        while (!check() && timePassed < timeoutMs) {
+            await Async.delay(frequencyMs);
+            timePassed += frequencyMs;
+            if (timePassed >= timeoutMs)
+                throw new Error('Timeout while waiting for condition');
+        }
+    }
+}
+
+class CancellationTokenInternal {
+    _isCancelled = false;
+    constructor(isCancelled = false) {
+        this._isCancelled = isCancelled;
+    }
+    /**
+     * Gets whether cancellation has been requested
+     */
+    isCancelled() {
+        return this._isCancelled;
+    }
+    /**
+     * Throws an error if cancellation has been requested
+     */
+    throwIfCancelled() {
+        if (this._isCancelled) {
+            throw new CancellationError('Operation was cancelled');
+        }
+    }
+    /**
+     * Internal method to cancel the token
+     */
+    cancel() {
+        this._isCancelled = true;
+    }
+    /**
+     * A token that is never cancelled
+     */
+    static None = new CancellationTokenInternal(false);
+    /**
+     * A token that is already cancelled
+     */
+    static Cancelled = new CancellationTokenInternal(true);
+}
+/**
+ * Error thrown when an operation is cancelled
+ */
+class CancellationError extends Error {
+    constructor(message = 'Operation was cancelled') {
+        super(message);
+        this.name = 'CancellationError';
+    }
+}
+/**
+ * Source for creating and managing cancellation tokens
+ */
+class CancellationTokenSource {
+    _token = new CancellationTokenInternal();
+    /**
+     * Gets the token currently associated with this source
+     */
+    get token() {
+        return this._token;
+    }
+    /**
+     * Cancels the current token and creates a new one
+     */
+    newUnique(timeoutMs = -1) {
+        this._token.cancel();
+        this._token = new CancellationTokenInternal();
+        if (timeoutMs != -1)
+            setTimeout(() => this._token.cancel(), timeoutMs);
+        return this._token;
+    }
+    /**
+     * Cancels the current token
+     */
+    cancel() {
+        this._token.cancel();
+    }
+}
+
+class ConsoleHook {
+    static commands = {};
+    static initialize() {
+        if (!window.r)
+            window.r = ConsoleHook.run.bind(ConsoleHook);
+    }
+    static register(commandName, method) {
+        ConsoleHook.initialize();
+        ConsoleHook.commands[commandName] = method;
+    }
+    static run(input, ...additionalParams) {
+        const [commandName, ...params] = input.split(' ');
+        const command = ConsoleHook.commands[commandName];
+        if (command) {
+            return command(...params, ...additionalParams);
+        }
+        else {
+            console.error(`Custom command "${commandName}" not found.`);
+        }
+    }
+}
+
+class ServicesInit {
+    injector;
+    constructor(injector) {
+        this.injector = injector;
+    }
+    async init(serviceClass, ...params) {
+        let className = `${serviceClass.name || 'unknown'}`;
+        const instance = this.injector.get(serviceClass);
+        if (!instance)
+            throw new Error(`Service not found: ${className}`);
+        const hasInit = typeof instance.init === 'function';
+        if (params.length > 0 && !hasInit)
+            throw new Error(`Service ${className} has no init method but initialization parameters were provided.`);
+        if (hasInit)
+            await instance.init(...params);
+        return instance;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ServicesInit, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ServicesInit, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ServicesInit, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class LocalizationService {
+    defaultLanguage = 'en';
+    storageKey = 'orcas-language';
+    translations = {};
+    loaded = false;
+    $language;
+    $currentLang = computed(() => this.$language(), ...(ngDevMode ? [{ debugName: "$currentLang" }] : []));
+    http = inject(HttpClient);
+    constructor() {
+        this.$language = signal(this.getStoredLanguage(), ...(ngDevMode ? [{ debugName: "$language" }] : []));
+    }
+    async init(jsonPath = 'assets/translations.json', defaultLanguage = 'en', storageKey = 'orcas-language') {
+        this.defaultLanguage = defaultLanguage;
+        this.storageKey = storageKey;
+        this.$language.set(this.getStoredLanguage());
+        try {
+            this.translations = await this.http.get(jsonPath).toPromise();
+            this.loaded = true;
+        }
+        catch (err) {
+            console.error('Failed to load translations:', err);
+        }
+    }
+    getLanguage() {
+        return this.$language();
+    }
+    getDefaultLanguage() {
+        return this.defaultLanguage;
+    }
+    setActiveLanguage(lang) {
+        if (lang !== this.$language()) {
+            localStorage.setItem(this.storageKey, lang);
+            this.$language.set(lang);
+        }
+    }
+    translate(key, params, language) {
+        const lang = language || this.getLanguage();
+        if (!this.loaded) {
+            console.error('Localization: Translations not loaded yet!');
+            return key;
+        }
+        let translation = null;
+        // Handle pluralization: try singular suffix __1 first if count is 1
+        if (params && params.count === 1)
+            translation = this.resolveKey(`${key}__1`);
+        if (!translation)
+            translation = this.resolveKey(key);
+        if (!translation) {
+            console.warn(`Localization: Key not found for "${key}".`);
+            return key;
+        }
+        let translatedText = translation[lang];
+        if (!translatedText) {
+            console.warn(`Localization: Key "${key}" not found for language "${lang}". Falling back to default language.`);
+            translatedText = translation[this.defaultLanguage];
+        }
+        if (!translatedText) {
+            console.error(`Localization: Key "${key}" not found for default language "${this.defaultLanguage}".`);
+            return key;
+        }
+        if (params) {
+            if (Array.isArray(params))
+                return this.replaceArrayParams(translatedText, params);
+            else
+                return this.replaceObjectParams(translatedText, params);
+        }
+        return translatedText;
+    }
+    resolveKey(key) {
+        const keys = key.split('.');
+        let translation = this.translations;
+        for (const k of keys) {
+            if (!translation[k])
+                return null;
+            translation = translation[k];
+        }
+        return translation;
+    }
+    getStoredLanguage() {
+        return localStorage.getItem(this.storageKey) || this.defaultLanguage;
+    }
+    replaceArrayParams(text, params) {
+        let result = text;
+        params.forEach((param, index) => {
+            result = result.replace(new RegExp(`\\{\\{${index}\\}\\}`, 'g'), param.toString());
+        });
+        return result;
+    }
+    replaceObjectParams(text, params) {
+        let result = text;
+        Object.keys(params).forEach(key => {
+            result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), params[key].toString());
+        });
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalizationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalizationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class LocalizePipe {
+    localizationService;
+    lastLanguage = '';
+    lastKey = '';
+    lastParams;
+    lastResult = '';
+    constructor(localizationService) {
+        this.localizationService = localizationService;
+    }
+    transform(key, params) {
+        if (this.localizationService.$currentLang() !== this.lastLanguage
+            || key !== this.lastKey
+            || params !== this.lastParams) {
+            this.lastLanguage = this.localizationService.$currentLang();
+            this.lastKey = key;
+            this.lastParams = params;
+            this.lastResult = this.localizationService.translate(key, params);
+        }
+        return this.lastResult;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalizePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.0", ngImport: i0, type: LocalizePipe, isStandalone: true, name: "localize", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localize',
+                    standalone: true,
+                    pure: false
+                }]
+        }], ctorParameters: () => [{ type: LocalizationService }] });
+
+/**
+ * Echo - A flexible logging library
+ * TypeScript port of Echo.cs core functionality (excluding Unity-specific features)
+ */
+// ============================================================================
+// Enums
+// ============================================================================
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["None"] = 0] = "None";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Warn"] = 2] = "Warn";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Debug"] = 4] = "Debug";
+})(LogLevel || (LogLevel = {}));
+var LogMode;
+(function (LogMode) {
+    LogMode[LogMode["Always"] = 0] = "Always";
+    LogMode[LogMode["Once"] = 1] = "Once";
+})(LogMode || (LogMode = {}));
+var SystemColor;
+(function (SystemColor) {
+    SystemColor[SystemColor["None"] = 0] = "None";
+    SystemColor[SystemColor["LabelOnly"] = 1] = "LabelOnly";
+    SystemColor[SystemColor["LabelAndMessage"] = 2] = "LabelAndMessage";
+})(SystemColor || (SystemColor = {}));
+// ============================================================================
+// Configuration
+// ============================================================================
+class LogWriterConfig {
+    timestamp = true;
+    levelLabels = true;
+    levelColors = true;
+    systemColor = SystemColor.LabelOnly;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+class Helpers {
+    static fnv1a32(str, hash = 2166136261) {
+        for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+        return hash >>> 0; // Convert to unsigned 32-bit integer
+    }
+    static getElementFromHash(collection, stringToHash) {
+        const hash = Helpers.fnv1a32(stringToHash);
+        const index = hash % collection.length;
+        return collection[index];
+    }
+}
+class WritersHelpers {
+    static getLevelLabel(level) {
+        switch (level) {
+            case LogLevel.Debug: return "DEBUG";
+            case LogLevel.Info: return "INFO";
+            case LogLevel.Warn: return "WARN";
+            case LogLevel.Error: return "ERROR";
+            default: return "???";
+        }
+    }
+    static systemColors = [
+        "\x1b[31m", // Red
+        "\x1b[32m", // Green
+        "\x1b[34m", // Blue
+        "\x1b[33m", // Yellow
+        "\x1b[36m", // Cyan
+        "\x1b[35m" // Magenta
+    ];
+    static levelColors = new Map([
+        [LogLevel.Debug, "\x1b[37m"], // White
+        [LogLevel.Info, "\x1b[36m"], // Cyan
+        [LogLevel.Warn, "\x1b[33m"], // Yellow
+        [LogLevel.Error, "\x1b[31m"] // Red
+    ]);
+    static resetColor = "\x1b[0m";
+    static grayColor = "\x1b[90m";
+}
+// ============================================================================
+// Internal Classes
+// ============================================================================
+class HashesManager {
+    hashes = new Set();
+    tryAdd(system, message) {
+        let hash = Helpers.fnv1a32(message);
+        hash = Helpers.fnv1a32(system, hash);
+        if (this.hashes.has(hash)) {
+            return false;
+        }
+        this.hashes.add(hash);
+        return true;
+    }
+    clear() {
+        this.hashes.clear();
+    }
+}
+class LoggerCore {
+    logWriter;
+    echoSettings;
+    hashes;
+    constructor(config, hashes, logger) {
+        if (!config)
+            throw new Error("config cannot be null");
+        if (!hashes)
+            throw new Error("hashes cannot be null");
+        if (!logger)
+            throw new Error("logger cannot be null");
+        this.echoSettings = config;
+        this.hashes = hashes;
+        this.logWriter = logger;
+    }
+    isEnabled(system, level) {
+        return level <= this.echoSettings.getSystemLevel(system);
+    }
+    shouldLogOnce(system, message) {
+        return this.hashes.tryAdd(system, message);
+    }
+    clearHashes() {
+        this.hashes.clear();
+    }
+    write(level, mode, system, message) {
+        if (mode === LogMode.Always || this.shouldLogOnce(system, message)) {
+            this.logWriter.writeLog(level, system, message);
+        }
+    }
+    writeIfEnabled(level, mode, system, message) {
+        if (this.isEnabled(system, level)) {
+            this.write(level, mode, system, message);
+        }
+    }
+    writeIfEnabled1(level, mode, system, format, param1) {
+        if (this.isEnabled(system, level)) {
+            const message = this.formatString1(format, param1);
+            this.write(level, mode, system, message);
+        }
+    }
+    writeIfEnabled2(level, mode, system, format, param1, param2) {
+        if (this.isEnabled(system, level)) {
+            const message = this.formatString2(format, param1, param2);
+            this.write(level, mode, system, message);
+        }
+    }
+    writeIfEnabled3(level, mode, system, format, param1, param2, param3) {
+        if (this.isEnabled(system, level)) {
+            const message = this.formatString3(format, param1, param2, param3);
+            this.write(level, mode, system, message);
+        }
+    }
+    writeIfEnabled4(level, mode, system, format, param1, param2, param3, param4) {
+        if (this.isEnabled(system, level)) {
+            const message = this.formatString4(format, param1, param2, param3, param4);
+            this.write(level, mode, system, message);
+        }
+    }
+    formatString1(format, param1) {
+        return format.replace(/\{0\}/g, String(param1));
+    }
+    formatString2(format, param1, param2) {
+        return format.replace(/\{0\}/g, String(param1)).replace(/\{1\}/g, String(param2));
+    }
+    formatString3(format, param1, param2, param3) {
+        return format.replace(/\{0\}/g, String(param1)).replace(/\{1\}/g, String(param2)).replace(/\{2\}/g, String(param3));
+    }
+    formatString4(format, param1, param2, param3, param4) {
+        return format.replace(/\{0\}/g, String(param1)).replace(/\{1\}/g, String(param2)).replace(/\{2\}/g, String(param3)).replace(/\{3\}/g, String(param4));
+    }
+}
+// ============================================================================
+// Public Classes
+// ============================================================================
+class EchoSettings {
+    systemLevels = new Map();
+    _defaultLevel = LogLevel.Warn;
+    updateCallbacks = [];
+    get defaultLevel() {
+        return this._defaultLevel;
+    }
+    onUpdated(callback) {
+        this.updateCallbacks.push(callback);
+    }
+    triggerUpdate() {
+        for (const callback of this.updateCallbacks) {
+            callback();
+        }
+    }
+    setSystemLevel(system, level) {
+        this.throwIfInvalidSystem(system);
+        this.systemLevels.set(system, level);
+        this.triggerUpdate();
+    }
+    clearSystemLevel(system) {
+        this.throwIfInvalidSystem(system);
+        if (this.systemLevels.delete(system)) {
+            this.triggerUpdate();
+        }
+    }
+    getSystemLevel(system) {
+        this.throwIfInvalidSystem(system);
+        return this.systemLevels.get(system) ?? this._defaultLevel;
+    }
+    tryGetSystemLevel(system) {
+        this.throwIfInvalidSystem(system);
+        const level = this.systemLevels.get(system);
+        return level !== undefined ? { success: true, level } : { success: false };
+    }
+    clearSystemLevels() {
+        this.systemLevels.clear();
+        this.triggerUpdate();
+    }
+    setDefaultLevel(level) {
+        this._defaultLevel = level;
+        this.triggerUpdate();
+    }
+    getAllSystemLevels() {
+        return this.systemLevels;
+    }
+    throwIfInvalidSystem(system) {
+        if (!system || system.length === 0) {
+            throw new Error("System name cannot be null or empty.");
+        }
+    }
+}
+class EchoLogger {
+    loggerCore;
+    constructor(loggerCore) {
+        if (!loggerCore)
+            throw new Error("loggerCore cannot be null");
+        this.loggerCore = loggerCore;
+    }
+    // Debug Methods
+    debug(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Debug, LogMode.Always, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Debug, LogMode.Always, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Debug, LogMode.Always, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Debug, LogMode.Always, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Debug, LogMode.Always, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    debug1(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Debug, LogMode.Once, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Debug, LogMode.Once, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Debug, LogMode.Once, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Debug, LogMode.Once, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Debug, LogMode.Once, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    // Info Methods
+    info(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Info, LogMode.Always, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Info, LogMode.Always, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Info, LogMode.Always, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Info, LogMode.Always, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Info, LogMode.Always, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    info1(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Info, LogMode.Once, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Info, LogMode.Once, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Info, LogMode.Once, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Info, LogMode.Once, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Info, LogMode.Once, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    // Warn Methods
+    warn(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Warn, LogMode.Always, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Warn, LogMode.Always, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Warn, LogMode.Always, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Warn, LogMode.Always, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Warn, LogMode.Always, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    warn1(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Warn, LogMode.Once, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Warn, LogMode.Once, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Warn, LogMode.Once, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Warn, LogMode.Once, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Warn, LogMode.Once, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    // Error Methods
+    error(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Error, LogMode.Always, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Error, LogMode.Always, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Error, LogMode.Always, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Error, LogMode.Always, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Error, LogMode.Always, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    error1(system, formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Error, LogMode.Once, system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Error, LogMode.Once, system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Error, LogMode.Once, system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Error, LogMode.Once, system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Error, LogMode.Once, system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+}
+class EchoSystemLogger {
+    loggerCore;
+    system;
+    constructor(loggerCore, system) {
+        if (!loggerCore)
+            throw new Error("loggerCore cannot be null");
+        if (!system)
+            throw new Error("system cannot be null");
+        this.loggerCore = loggerCore;
+        this.system = system;
+    }
+    // Debug Methods
+    debug(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Debug, LogMode.Always, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Debug, LogMode.Always, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Debug, LogMode.Always, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Debug, LogMode.Always, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Debug, LogMode.Always, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    debug1(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Debug, LogMode.Once, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Debug, LogMode.Once, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Debug, LogMode.Once, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Debug, LogMode.Once, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Debug, LogMode.Once, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    // Info Methods
+    info(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Info, LogMode.Always, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Info, LogMode.Always, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Info, LogMode.Always, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Info, LogMode.Always, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Info, LogMode.Always, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    info1(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Info, LogMode.Once, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Info, LogMode.Once, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Info, LogMode.Once, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Info, LogMode.Once, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Info, LogMode.Once, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    // Warn Methods
+    warn(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Warn, LogMode.Always, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Warn, LogMode.Always, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Warn, LogMode.Always, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Warn, LogMode.Always, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Warn, LogMode.Always, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    warn1(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Warn, LogMode.Once, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Warn, LogMode.Once, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Warn, LogMode.Once, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Warn, LogMode.Once, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Warn, LogMode.Once, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    // Error Methods
+    error(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Error, LogMode.Always, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Error, LogMode.Always, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Error, LogMode.Always, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Error, LogMode.Always, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Error, LogMode.Always, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+    error1(formatOrMessage, param1, param2, param3, param4) {
+        if (param1 === undefined) {
+            this.loggerCore.writeIfEnabled(LogLevel.Error, LogMode.Once, this.system, formatOrMessage);
+        }
+        else if (param2 === undefined) {
+            this.loggerCore.writeIfEnabled1(LogLevel.Error, LogMode.Once, this.system, formatOrMessage, param1);
+        }
+        else if (param3 === undefined) {
+            this.loggerCore.writeIfEnabled2(LogLevel.Error, LogMode.Once, this.system, formatOrMessage, param1, param2);
+        }
+        else if (param4 === undefined) {
+            this.loggerCore.writeIfEnabled3(LogLevel.Error, LogMode.Once, this.system, formatOrMessage, param1, param2, param3);
+        }
+        else {
+            this.loggerCore.writeIfEnabled4(LogLevel.Error, LogMode.Once, this.system, formatOrMessage, param1, param2, param3, param4);
+        }
+    }
+}
+class Echo {
+    loggerCore;
+    loggers = new Map();
+    _settings;
+    constructor(writer) {
+        if (!writer)
+            throw new Error("writer cannot be null");
+        const hashes = new HashesManager();
+        this._settings = new EchoSettings();
+        this.loggerCore = new LoggerCore(this._settings, hashes, writer);
+    }
+    getLogger() {
+        const key = "";
+        if (!this.loggers.has(key)) {
+            this.loggers.set(key, new EchoLogger(this.loggerCore));
+        }
+        return this.loggers.get(key);
+    }
+    getSystemLogger(system) {
+        if (!system || system.length === 0) {
+            throw new Error("System name cannot be null or empty.");
+        }
+        if (!this.loggers.has(system)) {
+            this.loggers.set(system, new EchoSystemLogger(this.loggerCore, system));
+        }
+        return this.loggers.get(system);
+    }
+    get settings() {
+        return this._settings;
+    }
+}
+// ============================================================================
+// Built-in Log Writers
+// ============================================================================
+class ConsoleLogWriter {
+    config;
+    constructor(config) {
+        if (!config)
+            throw new Error("config cannot be null");
+        this.config = config;
+    }
+    writeLog(level, system, message) {
+        let output = "";
+        if (this.config.timestamp) {
+            const now = new Date();
+            const timestamp = this.formatTimestamp(now);
+            output += `${WritersHelpers.grayColor}[${timestamp}]${WritersHelpers.resetColor} `;
+        }
+        if (this.config.levelLabels) {
+            const levelLabel = WritersHelpers.getLevelLabel(level);
+            if (this.config.levelColors) {
+                const color = WritersHelpers.levelColors.get(level) ?? "";
+                output += `${color}[${levelLabel}]${WritersHelpers.resetColor} `;
+            }
+            else {
+                output += `[${levelLabel}] `;
+            }
+        }
+        const systemColor = this.config.systemColor === SystemColor.LabelOnly ||
+            this.config.systemColor === SystemColor.LabelAndMessage
+            ? Helpers.getElementFromHash(WritersHelpers.systemColors, system)
+            : "";
+        if (systemColor) {
+            output += `${systemColor}[${system}]${WritersHelpers.resetColor} `;
+        }
+        else {
+            output += `[${system}] `;
+        }
+        if (this.config.systemColor === SystemColor.LabelAndMessage && systemColor) {
+            output += `${systemColor}${message}${WritersHelpers.resetColor}`;
+        }
+        else {
+            output += message;
+        }
+        console.log(output);
+    }
+    formatTimestamp(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    }
+}
+// ============================================================================
+// Public API Helpers
+// ============================================================================
+class EchoConsole {
+    static new(config) {
+        const writerConfig = config ?? new LogWriterConfig();
+        const writer = new ConsoleLogWriter(writerConfig);
+        return new Echo(writer);
+    }
+}
+
+/**
+ * Constants for Echo logging system names.
+ * Using constants ensures consistency and prevents typos.
+ */
+class LogSystems {
+    /** System for profiling and performance measurements */
+    static PROFILING = 'Profiling';
+    /** System for general application logs */
+    static GENERAL = 'General';
+    /** System for Git-related operations */
+    static GIT = 'Git';
+    /** System for UI and visual operations */
+    static UI = 'UI';
+    /** System for repository operations */
+    static REPOSITORY = 'Repository';
+}
+
+/**
+ * Echo provider for Angular dependency injection.
+ * Provides a singleton Echo instance with console writer.
+ */
+/**
+ * Injection token for Echo logger instance
+ */
+const ECHO = new InjectionToken('Echo Logger Instance');
+/**
+ * Factory function to create Echo instance
+ */
+function echoFactory() {
+    return EchoConsole.new();
+}
+/**
+ * Provider for Echo logger
+ * Use this in your module providers or inject it in services
+ */
+const ECHO_PROVIDER = {
+    provide: ECHO,
+    useFactory: echoFactory
+};
+
+class NavigationStackService {
+    router;
+    location;
+    history = [];
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+        this.router.events.subscribe((event) => {
+            if (event instanceof NavigationEnd)
+                this.history.push(event.urlAfterRedirects);
+        });
+    }
+    goBack() {
+        this.history.pop();
+        if (this.history.length > 0)
+            this.location.back();
+        else
+            this.router.navigateByUrl("/").then();
+        this.history.pop();
+    }
+    getBack() {
+        if (this.history.length > 1)
+            return this.history[this.history.length - 2];
+        return '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: NavigationStackService, deps: [{ token: i1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: NavigationStackService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: NavigationStackService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.Location }] });
+
+class BackOnClickDirective {
+    navigationStack;
+    constructor(navigationStack) {
+        this.navigationStack = navigationStack;
+    }
+    onClick(event) {
+        if (event)
+            event.preventDefault();
+        this.navigationStack.goBack();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BackOnClickDirective, deps: [{ token: NavigationStackService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.0", type: BackOnClickDirective, isStandalone: true, selector: "[back-on-click]", host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BackOnClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[back-on-click]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: NavigationStackService }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+
+class FilesService {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: FilesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: FilesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: FilesService, decorators: [{
+            type: Injectable
+        }] });
+
+var Status;
+(function (Status) {
+    Status[Status["NotInitialized"] = 0] = "NotInitialized";
+    Status[Status["Loading"] = 1] = "Loading";
+    Status[Status["Idle"] = 2] = "Idle";
+    Status[Status["Saving"] = 3] = "Saving";
+})(Status || (Status = {}));
+class FileBoxService {
+    files = inject(FilesService);
+    status = Status.NotInitialized;
+    path = '';
+    saveEnqueued = false;
+    $dataWritable = signal({}, ...(ngDevMode ? [{ debugName: "$dataWritable" }] : []));
+    $data = computed(() => {
+        if (this.status === Status.NotInitialized)
+            console.error('Service is not initialized.');
+        else if (this.status === Status.Loading)
+            console.error('Service is loading.');
+        return this.$dataWritable();
+    }, ...(ngDevMode ? [{ debugName: "$data" }] : []));
+    async init(path) {
+        if (this.status !== Status.NotInitialized) {
+            console.error('Service is already initialized.');
+            return;
+        }
+        this.path = path;
+        try {
+            this.status = Status.Loading;
+            if (await this.files.hasInStorage(this.path)) {
+                const fileContent = await this.files.readFromStorage(this.path);
+                this.$dataWritable.set(JSON.parse(fileContent));
+            }
+        }
+        catch (error) {
+            console.error('Failed to load file:', error);
+            this.$dataWritable.set({});
+        }
+        finally {
+            this.status = Status.Idle;
+        }
+    }
+    has(key) {
+        return key in this.$data();
+    }
+    set(key, value) {
+        this.checkType(value);
+        const newData = { ...this.$dataWritable() };
+        newData[key] = value;
+        this.$dataWritable.set(newData);
+    }
+    setAll(data) {
+        this.$dataWritable.set(data);
+    }
+    remove(key) {
+        const newData = { ...this.$dataWritable() };
+        delete newData[key];
+        this.$dataWritable.set(newData);
+    }
+    checkType(value) {
+        if (value instanceof Function)
+            throw new Error('Cannot save functions.');
+        if (value instanceof Promise)
+            throw new Error('Cannot save promises.');
+    }
+    async save() {
+        if (this.saveEnqueued)
+            return;
+        this.saveEnqueued = true;
+        while (this.status === Status.Saving)
+            await Async.delay(100);
+        this.saveEnqueued = false;
+        try {
+            this.status = Status.Saving;
+            const dataString = JSON.stringify(this.$data());
+            await this.files.writeToStorage(this.path, dataString);
+        }
+        catch (error) {
+            console.error('Failed to save file:', error);
+        }
+        finally {
+            this.status = Status.Idle;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: FileBoxService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: FileBoxService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: FileBoxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class KeySignals {
+    SEPARATOR = '|';
+    getCanonicalKey(path) {
+        return path.join(this.SEPARATOR);
+    }
+    getNewSignal(defaultValue, ...path) {
+        return computed(() => this.getValue(defaultValue, ...path));
+    }
+    getValue(defaultValue, ...path) {
+        const key = this.getCanonicalKey(path);
+        const data = this.$data();
+        return key in data ? data[key] : defaultValue;
+    }
+    async set(value, ...path) {
+        const key = this.getCanonicalKey(path);
+        await this.setRawValue(key, value);
+    }
+    /**
+     * Clears all keys that start with the given prefix.
+     */
+    async clearByPrefix(...pathPrefix) {
+        const prefix = this.getCanonicalKey(pathPrefix) + this.SEPARATOR;
+        const data = this.$data();
+        const updatedData = { ...data };
+        let changed = false;
+        for (const key in updatedData) {
+            if (key.startsWith(prefix)) {
+                delete updatedData[key];
+                changed = true;
+            }
+        }
+        if (changed) {
+            await this.setMultipleRawValues(updatedData);
+        }
+    }
+}
+
+class SettingsSignalsService extends KeySignals {
+    filebox = inject(FileBoxService);
+    $data() {
+        return this.filebox.$data();
+    }
+    async setRawValue(key, value) {
+        this.filebox.set(key, value);
+        await this.filebox.save();
+    }
+    async setMultipleRawValues(values) {
+        this.filebox.setAll(values);
+        await this.filebox.save();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: SettingsSignalsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: SettingsSignalsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: SettingsSignalsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SettingsService {
+    fileboxService = inject(FileBoxService);
+    sss = inject(SettingsSignalsService);
+    SETTINGS_KEY = "app-settings";
+    getNewSignal(defaultValue, ...path) {
+        return this.sss.getNewSignal(defaultValue, this.SETTINGS_KEY, ...path);
+    }
+    async set(value, ...path) {
+        await this.sss.set(value, this.SETTINGS_KEY, ...path);
+    }
+    async save() {
+        await this.fileboxService.save();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: SettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: SettingsService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+class TauriFilesService extends FilesService {
+    static _isTauri = null;
+    static isSupported() {
+        if (this._isTauri !== null)
+            return this._isTauri;
+        try {
+            // Check for window.__TAURI_INTERNALS__ which is usually present in v2
+            this._isTauri = !!(window.__TAURI_INTERNALS__);
+        }
+        catch {
+            this._isTauri = false;
+        }
+        return this._isTauri;
+    }
+    async init() {
+        // No special initialization needed for Tauri FS plugin beyond what is handled lazily
+    }
+    async joinStoragePath(filePath) {
+        const { appLocalDataDir, join } = await import('@tauri-apps/api/path');
+        const dataDir = await appLocalDataDir();
+        return await join(dataDir, filePath);
+    }
+    async hasInStorage(filePath) {
+        try {
+            const { exists } = await import('@tauri-apps/plugin-fs');
+            const { BaseDirectory } = await import('@tauri-apps/api/path');
+            return await exists(filePath, { baseDir: BaseDirectory.AppLocalData });
+        }
+        catch (error) {
+            console.error('TauriFilesService.hasInStorage error:', error);
+            return false;
+        }
+    }
+    async readFromStorage(filePath) {
+        const { readTextFile } = await import('@tauri-apps/plugin-fs');
+        const { BaseDirectory } = await import('@tauri-apps/api/path');
+        return await readTextFile(filePath, { baseDir: BaseDirectory.AppLocalData });
+    }
+    async writeToStorage(filePath, data) {
+        const { writeTextFile } = await import('@tauri-apps/plugin-fs');
+        const { BaseDirectory } = await import('@tauri-apps/api/path');
+        await writeTextFile(filePath, data, { baseDir: BaseDirectory.AppLocalData });
+    }
+    async hasInProject(filePath) {
+        try {
+            const response = await fetch(filePath, { method: 'HEAD' });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readFromProject(filePath) {
+        const response = await fetch(filePath);
+        if (!response.ok) {
+            throw new Error(`Failed to read project file: ${filePath} (${response.status})`);
+        }
+        return await response.text();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: TauriFilesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: TauriFilesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: TauriFilesService, decorators: [{
+            type: Injectable
+        }] });
+
+class CapacitorFilesService extends FilesService {
+    static isSupported() {
+        // Capacitor is not yet implemented, so returning false
+        return false;
+    }
+    async init() {
+        throw new Error('CapacitorFilesService not implemented');
+    }
+    async joinStoragePath(filePath) {
+        return null;
+    }
+    async hasInStorage(filePath) {
+        throw new Error('Method not implemented.');
+    }
+    async readFromStorage(filePath) {
+        throw new Error('Method not implemented.');
+    }
+    async writeToStorage(filePath, data) {
+        throw new Error('Method not implemented.');
+    }
+    async hasInProject(filePath) {
+        throw new Error('Method not implemented.');
+    }
+    async readFromProject(filePath) {
+        throw new Error('Method not implemented.');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: CapacitorFilesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: CapacitorFilesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: CapacitorFilesService, decorators: [{
+            type: Injectable
+        }] });
+
+class LocalStorageFilesService extends FilesService {
+    http = inject(HttpClient);
+    static isSupported() {
+        return typeof window !== 'undefined' && !!window.localStorage;
+    }
+    async init() {
+        // LocalStorage is ready immediately
+    }
+    async joinStoragePath(filePath) {
+        return null;
+    }
+    async hasInStorage(filePath) {
+        return localStorage.getItem(filePath) !== null;
+    }
+    async readFromStorage(filePath) {
+        const data = localStorage.getItem(filePath);
+        if (data === null)
+            throw new Error(`File not found in localStorage: ${filePath}`);
+        return data;
+    }
+    async writeToStorage(filePath, data) {
+        localStorage.setItem(filePath, data);
+    }
+    async hasInProject(filePath) {
+        try {
+            // In a browser, we check if we can fetch it via HTTP
+            await lastValueFrom(this.http.head(filePath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readFromProject(filePath) {
+        return await lastValueFrom(this.http.get(filePath, { responseType: 'text' }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalStorageFilesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalStorageFilesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: LocalStorageFilesService, decorators: [{
+            type: Injectable
+        }] });
+
+var ThemeType;
+(function (ThemeType) {
+    ThemeType["Unset"] = "";
+    ThemeType["Light"] = "light";
+    ThemeType["Dark"] = "dark";
+})(ThemeType || (ThemeType = {}));
+class ThemeService {
+    settings = inject(SettingsService);
+    $theme = this.settings.getNewSignal(ThemeType.Unset, 'theme');
+    $darkMode = computed(() => {
+        const theme = this.$theme();
+        let isDarkMode = theme === ThemeType.Unset
+            ? window.matchMedia('(prefers-color-scheme: dark)').matches
+            : theme === ThemeType.Dark;
+        return isDarkMode;
+    }, ...(ngDevMode ? [{ debugName: "$darkMode" }] : []));
+    effectSetDarkMode = effect(async () => {
+        document.documentElement.classList.toggle('dark', this.$darkMode());
+    }, ...(ngDevMode ? [{ debugName: "effectSetDarkMode" }] : []));
+    async setTheme(theme) {
+        await this.settings.set(theme, 'theme');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ContextMenuComponent {
+    elementRef;
+    $isSubmenu = input(false, { ...(ngDevMode ? { debugName: "$isSubmenu" } : {}), transform: booleanAttribute });
+    $isVisible = signal(false, ...(ngDevMode ? [{ debugName: "$isVisible" }] : []));
+    $isMeasuring = signal(false, ...(ngDevMode ? [{ debugName: "$isMeasuring" }] : []));
+    $x = signal(0, ...(ngDevMode ? [{ debugName: "$x" }] : []));
+    $y = signal(0, ...(ngDevMode ? [{ debugName: "$y" }] : []));
+    container;
+    close = output();
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    onDocumentClick(event) {
+        if (this.$isSubmenu())
+            return;
+        // If visible and click is outside, close
+        if (this.$isVisible() && !this.elementRef.nativeElement.contains(event.target)) {
+            this.closeMenu();
+        }
+    }
+    show(x, y) {
+        if (this.$isSubmenu())
+            return;
+        this.$x.set(x);
+        this.$y.set(y);
+        this.$isMeasuring.set(true);
+        this.$isVisible.set(true);
+        // Wait for DOM to render the menu so we can measure it
+        setTimeout(() => {
+            if (this.container) {
+                const rect = this.container.nativeElement.getBoundingClientRect();
+                const width = rect.width;
+                const height = rect.height;
+                const windowWidth = window.innerWidth;
+                const windowHeight = window.innerHeight;
+                let newX = x;
+                let newY = y;
+                if (x + width > windowWidth)
+                    newX = x - width;
+                if (y + height > windowHeight)
+                    newY = y - height;
+                // Final safety check to ensure it doesn't go off the top/left edges
+                this.$x.set(Math.max(0, newX));
+                this.$y.set(Math.max(0, newY));
+            }
+            this.$isMeasuring.set(false);
+        }, 0);
+    }
+    hide() {
+        this.$isVisible.set(false);
+        this.$isMeasuring.set(false);
+    }
+    closeMenu() {
+        this.hide();
+        this.close.emit();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextMenuComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.0", type: ContextMenuComponent, isStandalone: true, selector: "context-menu", inputs: { $isSubmenu: { classPropertyName: "$isSubmenu", publicName: "$isSubmenu", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { close: "close" }, host: { listeners: { "document:mousedown": "onDocumentClick($event)" } }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], ngImport: i0, template: `
+    @if ($isVisible() || $isSubmenu()) {
+    <div 
+      #container
+      [class.fixed]="!$isSubmenu()"
+      [class.absolute]="$isSubmenu()"
+      [class.left-full]="$isSubmenu()"
+      [class.top-0]="$isSubmenu()"
+      [class.ml-[-2px]]="$isSubmenu()"
+      class="bg-white dark:bg-[#2a2a2a] border border-light-border dark:border-dark-border rounded shadow-lg z-50 min-w-[200px] text-light-text-primary dark:text-dark-text-primary py-1"
+      [style.left.px]="!$isSubmenu() ? $x() : null" 
+      [style.top.px]="!$isSubmenu() ? $y() : null" 
+      [style.visibility]="$isMeasuring() ? 'hidden' : 'visible'"
+      (click)="$event.stopPropagation()">
+      <ng-content></ng-content>
+    </div>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'context-menu',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    @if ($isVisible() || $isSubmenu()) {
+    <div 
+      #container
+      [class.fixed]="!$isSubmenu()"
+      [class.absolute]="$isSubmenu()"
+      [class.left-full]="$isSubmenu()"
+      [class.top-0]="$isSubmenu()"
+      [class.ml-[-2px]]="$isSubmenu()"
+      class="bg-white dark:bg-[#2a2a2a] border border-light-border dark:border-dark-border rounded shadow-lg z-50 min-w-[200px] text-light-text-primary dark:text-dark-text-primary py-1"
+      [style.left.px]="!$isSubmenu() ? $x() : null" 
+      [style.top.px]="!$isSubmenu() ? $y() : null" 
+      [style.visibility]="$isMeasuring() ? 'hidden' : 'visible'"
+      (click)="$event.stopPropagation()">
+      <ng-content></ng-content>
+    </div>
+    }
+  `
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { $isSubmenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "$isSubmenu", required: false }] }], container: [{
+                type: ViewChild,
+                args: ['container']
+            }], close: [{ type: i0.Output, args: ["close"] }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:mousedown', ['$event']]
+            }] } });
+
+class ContextHeaderComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.0", type: ContextHeaderComponent, isStandalone: true, selector: "context-header", ngImport: i0, template: `
+    <div 
+      class="px-3 py-1.5 text-xs font-semibold text-light-text-secondary dark:text-dark-text-secondary truncate border-b border-light-border dark:border-dark-border mb-1">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'context-header',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div 
+      class="px-3 py-1.5 text-xs font-semibold text-light-text-secondary dark:text-dark-text-secondary truncate border-b border-light-border dark:border-dark-border mb-1">
+      <ng-content></ng-content>
+    </div>
+  `
+                }]
+        }] });
+
+class ContextButtonComponent {
+    danger = input(false, { ...(ngDevMode ? { debugName: "danger" } : {}), transform: booleanAttribute });
+    disabled = input(false, { ...(ngDevMode ? { debugName: "disabled" } : {}), transform: booleanAttribute });
+    hasSubmenu = input(false, { ...(ngDevMode ? { debugName: "hasSubmenu" } : {}), transform: booleanAttribute });
+    $showSubmenu = signal(false, ...(ngDevMode ? [{ debugName: "$showSubmenu" }] : []));
+    onMouseEnter() {
+        if (this.hasSubmenu() && !this.disabled()) {
+            this.$showSubmenu.set(true);
+        }
+    }
+    onMouseLeave() {
+        if (this.hasSubmenu() && !this.disabled()) {
+            this.$showSubmenu.set(false);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.0", type: ContextButtonComponent, isStandalone: true, selector: "context-button", inputs: { danger: { classPropertyName: "danger", publicName: "danger", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, hasSubmenu: { classPropertyName: "hasSubmenu", publicName: "hasSubmenu", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    <div class="relative" (mouseenter)="onMouseEnter()" (mouseleave)="onMouseLeave()">
+      <button 
+        class="w-full text-left px-3 py-2 text-sm transition-colors duration-100 flex items-center justify-between gap-2"
+        [class.hover:bg-light-bg-secondary]="!disabled()"
+        [class.dark:hover:bg-[#383838]]="!disabled()"
+        [class.text-red-500]="danger() && !disabled()"
+        [class.hover:bg-red-500]="danger() && !disabled()"
+        [class.hover:text-white]="danger() && !disabled()"
+        [class.opacity-50]="disabled()"
+        [class.cursor-not-allowed]="disabled()"
+        [disabled]="disabled()">
+        <div class="flex items-center gap-2">
+          <ng-content select="[icon]"></ng-content>
+          <ng-content></ng-content>
+        </div>
+        @if (hasSubmenu()) {
+          <span class="text-[10px] text-light-text-secondary opacity-50">▶</span>
+        }
+      </button>
+
+      @if (hasSubmenu() && $showSubmenu() && !disabled()) {
+        <div class="absolute left-full top-0 ml-[-2px] z-[60]">
+          <ng-content select="context-menu"></ng-content>
+        </div>
+      }
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'context-button',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div class="relative" (mouseenter)="onMouseEnter()" (mouseleave)="onMouseLeave()">
+      <button 
+        class="w-full text-left px-3 py-2 text-sm transition-colors duration-100 flex items-center justify-between gap-2"
+        [class.hover:bg-light-bg-secondary]="!disabled()"
+        [class.dark:hover:bg-[#383838]]="!disabled()"
+        [class.text-red-500]="danger() && !disabled()"
+        [class.hover:bg-red-500]="danger() && !disabled()"
+        [class.hover:text-white]="danger() && !disabled()"
+        [class.opacity-50]="disabled()"
+        [class.cursor-not-allowed]="disabled()"
+        [disabled]="disabled()">
+        <div class="flex items-center gap-2">
+          <ng-content select="[icon]"></ng-content>
+          <ng-content></ng-content>
+        </div>
+        @if (hasSubmenu()) {
+          <span class="text-[10px] text-light-text-secondary opacity-50">▶</span>
+        }
+      </button>
+
+      @if (hasSubmenu() && $showSubmenu() && !disabled()) {
+        <div class="absolute left-full top-0 ml-[-2px] z-[60]">
+          <ng-content select="context-menu"></ng-content>
+        </div>
+      }
+    </div>
+  `
+                }]
+        }], propDecorators: { danger: [{ type: i0.Input, args: [{ isSignal: true, alias: "danger", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], hasSubmenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "hasSubmenu", required: false }] }] } });
+
+class ContextMenuTriggerDirective {
+    elementRef;
+    appContextMenu = input.required(...(ngDevMode ? [{ debugName: "appContextMenu" }] : []));
+    beforeOpen = output();
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    onContextMenu(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        // Notify parent to prepare data
+        this.beforeOpen.emit();
+        // Show menu at cursor position
+        this.appContextMenu().show(event.clientX, event.clientY);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextMenuTriggerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.0", type: ContextMenuTriggerDirective, isStandalone: true, selector: "[appContextMenu]", inputs: { appContextMenu: { classPropertyName: "appContextMenu", publicName: "appContextMenu", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { beforeOpen: "beforeOpen" }, host: { listeners: { "contextmenu": "onContextMenu($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: ContextMenuTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appContextMenu]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { appContextMenu: [{ type: i0.Input, args: [{ isSignal: true, alias: "appContextMenu", required: true }] }], beforeOpen: [{ type: i0.Output, args: ["beforeOpen"] }], onContextMenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Async, BackOnClickDirective, CancellationError, CancellationTokenSource, CapacitorFilesService, ConsoleHook, ContextButtonComponent, ContextHeaderComponent, ContextMenuComponent, ContextMenuTriggerDirective, ECHO, ECHO_PROVIDER, Echo, EchoConsole, EchoLogger, EchoSettings, EchoSystemLogger, FileBoxService, FilesService, KeySignals, LocalStorageFilesService, LocalizationService, LocalizePipe, LogLevel, LogSystems, LogWriterConfig, NavigationStackService, ServicesInit, SettingsService, SettingsSignalsService, SystemColor, TauriFilesService, ThemeService, ThemeType, echoFactory };
+//# sourceMappingURL=orcas-angular.mjs.map