orcas-angular 1.0.3 → 1.0.5

package/types/orcas-angular.d.ts

@@ -0,0 +1,460 @@
+import * as i0 from '@angular/core';
+import { Injector, Signal, PipeTransform, InjectionToken, Provider, ElementRef } from '@angular/core';
+import { Location } from '@angular/common';
+import { Router } from '@angular/router';
+
+declare class Async {
+    static delay(ms: number): Promise<void>;
+    static until(check: () => boolean, timeoutMs?: number, frequencyMs?: number): Promise<void>;
+}
+
+interface CancellationToken {
+    isCancelled(): boolean;
+    throwIfCancelled(): void;
+}
+/**
+ * Error thrown when an operation is cancelled
+ */
+declare class CancellationError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Source for creating and managing cancellation tokens
+ */
+declare class CancellationTokenSource {
+    private _token;
+    /**
+     * Gets the token currently associated with this source
+     */
+    get token(): CancellationToken;
+    /**
+     * Cancels the current token and creates a new one
+     */
+    newUnique(timeoutMs?: number): CancellationToken;
+    /**
+     * Cancels the current token
+     */
+    cancel(): void;
+}
+
+declare class ConsoleHook {
+    private static commands;
+    static initialize(): void;
+    static register(commandName: string, method: Function): void;
+    static run(input: string, ...additionalParams: any[]): any;
+}
+
+declare class ServicesInit {
+    private injector;
+    constructor(injector: Injector);
+    init<T>(serviceClass: any, ...params: unknown[]): Promise<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServicesInit, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServicesInit>;
+}
+
+interface ILocalizationService {
+    /** Emits the current language as a signal */
+    $currentLang: Signal<string>;
+    /** Gets the current active language code */
+    getLanguage(): string;
+    /** Gets the default language code */
+    getDefaultLanguage(): string;
+    /** Sets the current active language */
+    setActiveLanguage(lang: string): void;
+    /** Translates a key, possibly with params and for a specific language */
+    translate(key: string, params?: any, language?: string): string;
+}
+
+declare class LocalizationService implements ILocalizationService {
+    private defaultLanguage;
+    private storageKey;
+    private translations;
+    private loaded;
+    private $language;
+    $currentLang: i0.Signal<string>;
+    private http;
+    constructor();
+    init(jsonPath?: string, defaultLanguage?: string, storageKey?: string): Promise<void>;
+    getLanguage(): string;
+    getDefaultLanguage(): string;
+    setActiveLanguage(lang: string): void;
+    translate(key: string, params?: any, language?: string): string;
+    private resolveKey;
+    private getStoredLanguage;
+    private replaceArrayParams;
+    private replaceObjectParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalizationService>;
+}
+
+declare class LocalizePipe implements PipeTransform {
+    private localizationService;
+    private lastLanguage;
+    private lastKey;
+    private lastParams;
+    private lastResult;
+    constructor(localizationService: LocalizationService);
+    transform(key: string, params?: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize", true>;
+}
+
+/**
+ * Echo - A flexible logging library
+ * TypeScript port of Echo.cs core functionality (excluding Unity-specific features)
+ */
+declare enum LogLevel {
+    None = 0,
+    Error = 1,
+    Warn = 2,
+    Info = 3,
+    Debug = 4
+}
+declare enum LogMode {
+    Always = 0,
+    Once = 1
+}
+declare enum SystemColor {
+    None = 0,
+    LabelOnly = 1,
+    LabelAndMessage = 2
+}
+interface EchoLogWriter {
+    writeLog(level: LogLevel, system: string, message: string): void;
+}
+declare class LogWriterConfig {
+    timestamp: boolean;
+    levelLabels: boolean;
+    levelColors: boolean;
+    systemColor: SystemColor;
+}
+declare class HashesManager {
+    private hashes;
+    tryAdd(system: string, message: string): boolean;
+    clear(): void;
+}
+declare class LoggerCore {
+    private readonly logWriter;
+    private readonly echoSettings;
+    private readonly hashes;
+    constructor(config: EchoSettings, hashes: HashesManager, logger: EchoLogWriter);
+    private isEnabled;
+    private shouldLogOnce;
+    clearHashes(): void;
+    private write;
+    writeIfEnabled(level: LogLevel, mode: LogMode, system: string, message: string): void;
+    writeIfEnabled1<T1>(level: LogLevel, mode: LogMode, system: string, format: string, param1: T1): void;
+    writeIfEnabled2<T1, T2>(level: LogLevel, mode: LogMode, system: string, format: string, param1: T1, param2: T2): void;
+    writeIfEnabled3<T1, T2, T3>(level: LogLevel, mode: LogMode, system: string, format: string, param1: T1, param2: T2, param3: T3): void;
+    writeIfEnabled4<T1, T2, T3, T4>(level: LogLevel, mode: LogMode, system: string, format: string, param1: T1, param2: T2, param3: T3, param4: T4): void;
+    private formatString1;
+    private formatString2;
+    private formatString3;
+    private formatString4;
+}
+declare class EchoSettings {
+    private systemLevels;
+    private _defaultLevel;
+    private updateCallbacks;
+    get defaultLevel(): LogLevel;
+    onUpdated(callback: () => void): void;
+    private triggerUpdate;
+    setSystemLevel(system: string, level: LogLevel): void;
+    clearSystemLevel(system: string): void;
+    getSystemLevel(system: string): LogLevel;
+    tryGetSystemLevel(system: string): {
+        success: boolean;
+        level?: LogLevel;
+    };
+    clearSystemLevels(): void;
+    setDefaultLevel(level: LogLevel): void;
+    getAllSystemLevels(): ReadonlyMap<string, LogLevel>;
+    private throwIfInvalidSystem;
+}
+declare class EchoLogger {
+    private readonly loggerCore;
+    constructor(loggerCore: LoggerCore);
+    debug(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    debug1(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    info(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    info1(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    warn(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    warn1(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    error(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    error1(system: string, formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+}
+declare class EchoSystemLogger {
+    private readonly loggerCore;
+    private readonly system;
+    constructor(loggerCore: LoggerCore, system: string);
+    debug(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    debug1(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    info(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    info1(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    warn(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    warn1(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    error(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+    error1(formatOrMessage: string, param1?: any, param2?: any, param3?: any, param4?: any): void;
+}
+declare class Echo {
+    private readonly loggerCore;
+    private readonly loggers;
+    private readonly _settings;
+    constructor(writer: EchoLogWriter);
+    getLogger(): EchoLogger;
+    getSystemLogger(system: string): EchoSystemLogger;
+    get settings(): EchoSettings;
+}
+declare class EchoConsole {
+    static new(config?: LogWriterConfig): Echo;
+}
+
+/**
+ * Constants for Echo logging system names.
+ * Using constants ensures consistency and prevents typos.
+ */
+declare class LogSystems {
+    /** System for profiling and performance measurements */
+    static readonly PROFILING = "Profiling";
+    /** System for general application logs */
+    static readonly GENERAL = "General";
+    /** System for Git-related operations */
+    static readonly GIT = "Git";
+    /** System for UI and visual operations */
+    static readonly UI = "UI";
+    /** System for repository operations */
+    static readonly REPOSITORY = "Repository";
+}
+
+/**
+ * Echo provider for Angular dependency injection.
+ * Provides a singleton Echo instance with console writer.
+ */
+
+/**
+ * Injection token for Echo logger instance
+ */
+declare const ECHO: InjectionToken<Echo>;
+/**
+ * Factory function to create Echo instance
+ */
+declare function echoFactory(): Echo;
+/**
+ * Provider for Echo logger
+ * Use this in your module providers or inject it in services
+ */
+declare const ECHO_PROVIDER: Provider;
+
+declare class NavigationStackService {
+    private router;
+    private location;
+    private history;
+    constructor(router: Router, location: Location);
+    goBack(): void;
+    getBack(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationStackService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationStackService>;
+}
+
+declare class BackOnClickDirective {
+    private navigationStack;
+    constructor(navigationStack: NavigationStackService);
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackOnClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BackOnClickDirective, "[back-on-click]", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class FilesService {
+    /**
+     * Initializes the service.
+     * This should handle any setup required by the specific implementation.
+     */
+    abstract init(...args: any[]): Promise<void>;
+    /**
+     * Joins a filename with the storage base directory to get a full path.
+     * Returns a string or a Promise of a string depending on implementation.
+     * In some platforms, this may return null if paths are not supported.
+     */
+    abstract joinStoragePath(filePath: string): Promise<string | null>;
+    /**
+     * Checks if a file exists in the platform-specific storage.
+     */
+    abstract hasInStorage(filePath: string): Promise<boolean>;
+    /**
+     * Reads a file from the platform-specific storage.
+     */
+    abstract readFromStorage(filePath: string): Promise<string>;
+    /**
+     * Writes data to a file in the platform-specific storage.
+     */
+    abstract writeToStorage(filePath: string, data: string): Promise<void>;
+    /**
+     * Checks if a file exists in the project's assets/resources.
+     */
+    abstract hasInProject(filePath: string): Promise<boolean>;
+    /**
+     * Reads a file from the project's assets/resources.
+     */
+    abstract readFromProject(filePath: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilesService>;
+}
+
+interface BoxData {
+    [key: string]: any;
+}
+declare class FileBoxService {
+    private files;
+    private status;
+    private path;
+    private saveEnqueued;
+    private $dataWritable;
+    $data: i0.Signal<BoxData>;
+    init(path: string): Promise<void>;
+    has(key: string): boolean;
+    set(key: string, value: any): void;
+    setAll(data: BoxData): void;
+    remove(key: string): void;
+    private checkType;
+    save(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileBoxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileBoxService>;
+}
+
+declare abstract class KeySignals {
+    protected abstract $data(): Record<string, any>;
+    protected abstract setRawValue(key: string, value: any): Promise<void>;
+    protected abstract setMultipleRawValues(values: Record<string, any>): Promise<void>;
+    protected readonly SEPARATOR = "|";
+    getCanonicalKey(path: string[]): string;
+    getNewSignal<T>(defaultValue: T, ...path: string[]): Signal<T>;
+    getValue<T>(defaultValue: T, ...path: string[]): T;
+    set(value: any, ...path: string[]): Promise<void>;
+    /**
+     * Clears all keys that start with the given prefix.
+     */
+    clearByPrefix(...pathPrefix: string[]): Promise<void>;
+}
+
+declare class SettingsSignalsService extends KeySignals {
+    private filebox;
+    protected $data(): Record<string, any>;
+    protected setRawValue(key: string, value: any): Promise<void>;
+    protected setMultipleRawValues(values: Record<string, any>): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsSignalsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsSignalsService>;
+}
+
+declare class SettingsService {
+    private fileboxService;
+    private sss;
+    private readonly SETTINGS_KEY;
+    getNewSignal<T>(defaultValue: T, ...path: string[]): Signal<T>;
+    set(value: any, ...path: string[]): Promise<void>;
+    save(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
+}
+
+declare class TauriFilesService extends FilesService {
+    private static _isTauri;
+    static isSupported(): boolean;
+    init(): Promise<void>;
+    joinStoragePath(filePath: string): Promise<string | null>;
+    hasInStorage(filePath: string): Promise<boolean>;
+    readFromStorage(filePath: string): Promise<string>;
+    writeToStorage(filePath: string, data: string): Promise<void>;
+    hasInProject(filePath: string): Promise<boolean>;
+    readFromProject(filePath: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TauriFilesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TauriFilesService>;
+}
+
+declare class CapacitorFilesService extends FilesService {
+    static isSupported(): boolean;
+    init(): Promise<void>;
+    joinStoragePath(filePath: string): Promise<string | null>;
+    hasInStorage(filePath: string): Promise<boolean>;
+    readFromStorage(filePath: string): Promise<string>;
+    writeToStorage(filePath: string, data: string): Promise<void>;
+    hasInProject(filePath: string): Promise<boolean>;
+    readFromProject(filePath: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CapacitorFilesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CapacitorFilesService>;
+}
+
+declare class LocalStorageFilesService extends FilesService {
+    private http;
+    static isSupported(): boolean;
+    init(): Promise<void>;
+    joinStoragePath(filePath: string): Promise<string | null>;
+    hasInStorage(filePath: string): Promise<boolean>;
+    readFromStorage(filePath: string): Promise<string>;
+    writeToStorage(filePath: string, data: string): Promise<void>;
+    hasInProject(filePath: string): Promise<boolean>;
+    readFromProject(filePath: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageFilesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageFilesService>;
+}
+
+declare enum ThemeType {
+    Unset = "",
+    Light = "light",
+    Dark = "dark"
+}
+declare class ThemeService {
+    private settings;
+    $theme: i0.Signal<ThemeType>;
+    $darkMode: i0.Signal<boolean>;
+    private effectSetDarkMode;
+    setTheme(theme: ThemeType): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class ContextMenuComponent {
+    private elementRef;
+    $isSubmenu: i0.InputSignalWithTransform<boolean, unknown>;
+    $isVisible: i0.WritableSignal<boolean>;
+    $isMeasuring: i0.WritableSignal<boolean>;
+    $x: i0.WritableSignal<number>;
+    $y: i0.WritableSignal<number>;
+    container?: ElementRef<HTMLDivElement>;
+    close: i0.OutputEmitterRef<void>;
+    constructor(elementRef: ElementRef);
+    onDocumentClick(event: MouseEvent): void;
+    show(x: number, y: number): void;
+    hide(): void;
+    private closeMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "context-menu", never, { "$isSubmenu": { "alias": "$isSubmenu"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}
+
+declare class ContextHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextHeaderComponent, "context-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ContextButtonComponent {
+    danger: i0.InputSignalWithTransform<boolean, unknown>;
+    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    hasSubmenu: i0.InputSignalWithTransform<boolean, unknown>;
+    $showSubmenu: i0.WritableSignal<boolean>;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextButtonComponent, "context-button", never, { "danger": { "alias": "danger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hasSubmenu": { "alias": "hasSubmenu"; "required": false; "isSignal": true; }; }, {}, never, ["[icon]", "*", "context-menu"], true, never>;
+}
+
+declare class ContextMenuTriggerDirective {
+    private elementRef;
+    appContextMenu: i0.InputSignal<ContextMenuComponent>;
+    beforeOpen: i0.OutputEmitterRef<void>;
+    constructor(elementRef: ElementRef);
+    onContextMenu(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuTriggerDirective, "[appContextMenu]", never, { "appContextMenu": { "alias": "appContextMenu"; "required": true; "isSignal": true; }; }, { "beforeOpen": "beforeOpen"; }, never, never, true, never>;
+}
+
+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 };
+export type { CancellationToken, EchoLogWriter, ILocalizationService };

package/async/README.md

@@ -1,46 +0,0 @@
-# async
-
-Utilities for working with asynchronous operations.
-
-## Files
-
-### `async.ts`
-
-The `Async` class provides static helper methods for common async patterns:
-
-- **`Async.delay(ms)`** — Returns a `Promise` that resolves after a given number of milliseconds. Useful for introducing deliberate pauses in async flows.
-- **`Async.until(check, timeoutMs?, frequencyMs?)`** — Polls a condition function at a given interval until it returns `true`. Throws a `Error` if the timeout is exceeded. Defaults to a 10-second timeout and 100 ms polling frequency.
-
-### `cancellation-token.ts`
-
-Provides a cooperative cancellation mechanism inspired by .NET's `CancellationToken` pattern:
-
-- **`CancellationToken`** *(interface)* — Read-only token that exposes `isCancelled()` and `throwIfCancelled()`. Passed to async operations to signal cancellation without forcing an abort.
-- **`CancellationTokenSource`** — Owns and controls a `CancellationToken`. Call `cancel()` to signal cancellation, or `newUnique(timeoutMs?)` to cancel the previous token and issue a fresh one (optionally with an auto-cancel timeout).
-- **`CancellationError`** — Error subclass thrown by `throwIfCancelled()` when cancellation has been requested.
-
-## Usage
-
-```typescript
-import { Async } from '@/lib/orcas-angular/async/async';
-import { CancellationTokenSource } from '@/lib/orcas-angular/async/cancellation-token';
-
-// Delay example
-await Async.delay(500);
-
-// Poll until condition
-await Async.until(() => someFlag === true);
-
-// Cancellation example
-const cts = new CancellationTokenSource();
-const token = cts.newUnique(5000); // auto-cancels after 5 s
-
-async function doWork() {
-    token.throwIfCancelled();
-    await Async.delay(100);
-    token.throwIfCancelled();
-    // ...
-}
-
-cts.cancel(); // cancel from outside
-```

package/async/async.ts

@@ -1,16 +0,0 @@
-export class Async {
-    static async delay(ms: number): Promise<void> {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-
-    static async until(check: () => boolean, timeoutMs: number = 10000, frequencyMs: number = 100): Promise<void> {
-        let timePassed = 0;
-        while (!check() && timePassed < timeoutMs) {
-            await Async.delay(frequencyMs);
-            timePassed += frequencyMs;
-
-            if (timePassed >= timeoutMs)
-                throw new Error('Timeout while waiting for condition');
-        }
-    }
-}

package/async/cancellation-token.ts

@@ -1,90 +0,0 @@
-export interface CancellationToken {
-    isCancelled(): boolean;
-
-    throwIfCancelled(): void;
-}
-
-class CancellationTokenInternal implements CancellationToken {
-    private _isCancelled: boolean = false;
-
-    constructor(isCancelled: boolean = false) {
-        this._isCancelled = isCancelled;
-    }
-
-    /**
-     * Gets whether cancellation has been requested
-     */
-    public isCancelled(): boolean {
-        return this._isCancelled;
-    }
-
-    /**
-     * Throws an error if cancellation has been requested
-     */
-    public throwIfCancelled(): void {
-        if (this._isCancelled) {
-            throw new CancellationError('Operation was cancelled');
-        }
-    }
-
-    /**
-     * Internal method to cancel the token
-     */
-    cancel(): void {
-        this._isCancelled = true;
-    }
-
-    /**
-     * A token that is never cancelled
-     */
-    public static readonly None: CancellationToken = new CancellationTokenInternal(false);
-
-    /**
-     * A token that is already cancelled
-     */
-    public static readonly Cancelled: CancellationToken = new CancellationTokenInternal(true);
-}
-
-/**
- * Error thrown when an operation is cancelled
- */
-export class CancellationError extends Error {
-    constructor(message: string = 'Operation was cancelled') {
-        super(message);
-        this.name = 'CancellationError';
-    }
-}
-
-/**
- * Source for creating and managing cancellation tokens
- */
-export class CancellationTokenSource {
-    private _token: CancellationTokenInternal = new CancellationTokenInternal();
-
-    /**
-     * Gets the token currently associated with this source
-     */
-    public get token(): CancellationToken {
-        return this._token;
-    }
-
-    /**
-     * Cancels the current token and creates a new one
-     */
-    public newUnique(timeoutMs: number = -1): CancellationToken {
-        this._token.cancel();
-        this._token = new CancellationTokenInternal();
-
-        if (timeoutMs != -1)
-            setTimeout(() => this._token.cancel(), timeoutMs);
-
-        return this._token;
-    }
-
-    /**
-     * Cancels the current token
-     */
-    public cancel(): void {
-        this._token.cancel();
-    }
-}

package/dev/README.md

@@ -1,41 +0,0 @@
-# dev
-
-Development and debugging utilities. These helpers are meant for use during development only and should not be shipped as core application services.
-
-## Files
-
-### `console-hook.ts`
-
-`ConsoleHook` exposes a lightweight command registry that can be invoked from the browser console. It registers a global `window.r(command, ...args)` function so that developers can call application methods without needing to open Angular DevTools.
-
-**Methods:**
-- **`ConsoleHook.initialize()`** — Sets up `window.r` if it has not been set up yet.
-- **`ConsoleHook.register(commandName, method)`** — Registers a named command. Automatically calls `initialize()`.
-- **`ConsoleHook.run(input, ...additionalParams)`** — Parses the input string (command name + space-separated arguments) and executes the matching registered command.
-
-**Browser console usage:**
-```javascript
-// Call a registered command named "example" with no extra args
-r("example")
-
-// Call "myCommand" with arguments
-r("myCommand arg1 arg2")
-```
-
-### `debug.service.ts.example`
-
-A template showing how to integrate `ConsoleHook` into an Angular service. Copy this file, rename it to `debug.service.ts`, and adapt it to register the commands relevant to your application.
-
-The example registers two commands:
-- `"example"` — returns the injected `ExampleService` instance.
-- `"nop"` — logs `"nop"` to the console and returns `"1"`.
-
-## Usage
-
-```typescript
-import { ConsoleHook } from '@/lib/orcas-angular/dev/console-hook';
-
-// In any service or component constructor:
-ConsoleHook.register('reload', () => location.reload());
-ConsoleHook.register('clearStorage', () => localStorage.clear());
-```

package/dev/console-hook.ts

@@ -1,25 +0,0 @@
-export class ConsoleHook {
-    private static commands: { [key: string]: Function } = {};
-
-    static initialize() {
-        if (!(window as any).r)
-            (window as any).r = ConsoleHook.run.bind(ConsoleHook);
-    }
-
-    static register(commandName: string, method: Function) {
-        ConsoleHook.initialize();
-        ConsoleHook.commands[commandName] = method;
-    }
-
-    static run(input: string, ...additionalParams: any[]) {
-        const [commandName, ...params] = input.split(' ');
-        const command = ConsoleHook.commands[commandName];
-
-        if (command) {
-            return command(...params, ...additionalParams);
-        }
-        else {
-            console.error(`Custom command "${commandName}" not found.`);
-        }
-    }
-}