@cmusei/console-forge 0.20.6 → 0.21.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmusei/console-forge",
-  "version": "0.20.6",
+  "version": "0.21.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/cmu-sei/console-forge.git"
@@ -9,8 +9,8 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@angular/common": "^19.2.0",
-    "@angular/core": "^19.2.0",
+    "@angular/common": "^21.2.5",
+    "@angular/core": "^21.2.5",
     "@novnc/novnc": "^1.4.0"
   },
   "dependencies": {
@@ -19,13 +19,13 @@
   },
   "sideEffects": false,
   "module": "fesm2022/cmusei-console-forge.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/cmusei-console-forge.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/cmusei-console-forge.d.ts",
       "default": "./fesm2022/cmusei-console-forge.mjs"
     }
   }

package/types/cmusei-console-forge.d.ts

@@ -0,0 +1,343 @@
+import * as _angular_core from '@angular/core';
+import { Signal, InputSignal, OnDestroy, Type, ElementRef, EnvironmentProviders } from '@angular/core';
+import * as _cmusei_console_forge from '@cmusei/console-forge';
+
+type ConsoleToolbarPosition = "left" | "right" | "top" | "bottom";
+
+type ConsoleToolbarTheme = "light" | "dark" | undefined;
+
+interface ConsoleUserSettings {
+    console: {
+        allowCopyToLocalClipboard: boolean;
+        attemptRemoteSessionResize: boolean;
+        scaleToCanvasHostSize: boolean;
+    };
+    toolbar: {
+        dockTo: ConsoleToolbarPosition;
+        preferTheme: ConsoleToolbarTheme;
+    };
+}
+
+interface ConsoleCredentials {
+    accessTicket?: string;
+    password?: string;
+}
+
+type ConsoleClientType = "vmware" | "vnc";
+
+interface ConsoleComponentConfig {
+    /**
+     * If true, the client will attempt to set control focus on the console session after connection. Defaults to false.
+     */
+    autoFocusOnConnect?: boolean;
+    /**
+     * Specifies the client that will be used to connect to the console (e.g. VNC, VMWare WMKS, etc.) Note that
+     * you can configure a default for all ConsoleForge consoles in your app or module by using the `provideConsoleForgeConfig`
+     * provider.
+     */
+    consoleClientType?: ConsoleClientType;
+    /**
+     * An optional identifier for this console. ConsoleForge doesn't use this value internally at all, but some of its events
+     * (e.g. reconnect requests) will return this configuration to you. You may want to set this identifier to something that allows
+     * you to uniquely identify the console so you can handle its events as desired.
+     */
+    consoleId?: string;
+    /**
+     * An optional username, password, or sessionId to use to authenticate to the console. Configuration here is specific
+     * to the protocol being used and the configuration of the target virtual console. See ConsoleForge's documentation
+     * for details.
+     */
+    credentials?: ConsoleCredentials;
+    /**
+     * The URL of the console's accessible web socket interface.
+     */
+    url: string;
+}
+
+interface ConsoleConnectionOptions {
+    autoFocusOnConnect?: boolean;
+    backgroundStyle?: string;
+    credentials?: ConsoleCredentials;
+    hostElement: HTMLElement;
+}
+
+type ConsoleConnectionStatus = "connected" | "connecting" | "disconnected";
+
+type ConsolePowerRequest = "reboot" | "rebootHard" | "shutdown";
+
+interface ConsoleSupportedFeatures {
+    /**
+     * This is basically a stupid kludge that is only here because VMWare's client has a very weird implementation of "copy".
+     *
+     * The VMWare "WMKS" client only emits clipboard events after the remote console's clipboard receives new data (i.e. you copy some content on the remote desktop)
+     * AND after the console canvas loses focus. That is, no matter how much copying you do, the client doesn't know about until the canvas housing the console
+     * is blurred.
+     *
+     * The downstream effect of this that, unlike with other protocols, we can't gracefully emit events when copies happen or automatically copy to your local
+     * clipboard in a reasonable way, because we can't know when the remote copy happened and if you really want it copied to your local CB or not. So when this
+     * flag is set to false (VMWare is the only service which does this), we show a panel in the default toolbar that you can manually copy content from and
+     * automatically receives the last "copy" event from the console.
+     *
+     * Yuck.
+     */
+    clipboardAutomaticLocalCopy: boolean;
+    /**
+     * Indicates whether the remote console protocol allows us to write content directly to the clipboard of the remote machine.
+     */
+    clipboardRemoteWrite: boolean;
+    /**
+     * Indicates whether there remote console offers an on-screen keyboard. (Hint: probably not. As far as we know, VMWare's WMKS is the only one that will do this.)
+     */
+    onScreenKeyboard: boolean;
+    /**
+     * Indicates whether the remote console protocol allows us to issue power requests (like restart, reboot, and hard reboot). This is typically a configuration detail
+     * of the machine, so we usually have to rely on the protocol-specific service to tell us whether the feature is enabled (see our VNC client, wrapping noVnc, for an example)
+     */
+    powerManagement: boolean;
+    /**
+     * NoVNC seems to have a quirk that causes it to lose proper mouse tracking after leaving fullscreen. We're working around this by requesting a reconnection of the console
+     * upon exiting. VMWare doesn't seem to need this.
+     */
+    requireReconnectOnExitingFullscreen?: boolean;
+    /**
+     * Whether the remote console protocol/library supports a "view/read"-only canvas. If it doesn't, we have to do some CSS/JS hacking in the console component, so
+     * we prefer the client lib/protocol's implementation if we can get it.
+     */
+    viewOnlyMode: boolean;
+}
+
+interface ConsoleClientService {
+    readonly clientType: ConsoleClientType;
+    readonly connectionStatus: Signal<ConsoleConnectionStatus>;
+    readonly consoleClipboardUpdated: Signal<string>;
+    readonly supportedFeatures: Signal<ConsoleSupportedFeatures>;
+    connect(url: string, options: ConsoleConnectionOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    sendClipboardText(text: string): Promise<void>;
+    sendCtrlAltDelete(): Promise<void>;
+    sendKeyboardInput(text: string): Promise<void>;
+    sendPowerRequest(request: ConsolePowerRequest): Promise<void>;
+    setIsViewOnly(isViewOnly: boolean): Promise<void>;
+    /**
+     * Automatically called by the console component on destroy. Disconnect any clients/websocket usage here
+     * (or just do it in your disconnect logic and call that internally in your implementation).
+     */
+    dispose(): Promise<void>;
+}
+
+interface CanvasRecordingSettings {
+    id: string;
+    stream: MediaStream;
+    window: Window;
+    mimeType: string;
+    chunkLength: number;
+    maxDuration: number;
+    onStopCallback: () => void;
+}
+
+declare class CanvasRecording {
+    private readonly chunks;
+    private readonly mimeType;
+    private readonly recorder;
+    private readonly window;
+    private stopPromise?;
+    private stopResolveFn?;
+    readonly settings: CanvasRecordingSettings;
+    constructor(settings: CanvasRecordingSettings);
+    stop(): Promise<Blob>;
+}
+
+interface ConsoleComponentNetworkConfig {
+    networks: string[];
+    nics: string[];
+    currentConnections: Record<string, string>;
+}
+
+interface ConsoleNetworkConnectionRequest {
+    network: string;
+    nic: string;
+}
+
+interface ConsoleNetworkDisconnectionRequest {
+    /**
+     * The which should be disconnected. If this value is falsey, interpret as
+     * a request to disconnect all NICs.
+     */
+    nic?: string;
+}
+
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+declare class UserSettingsService {
+    private readonly _settings;
+    readonly settings: _angular_core.Signal<ConsoleUserSettings>;
+    private readonly logger;
+    private readonly settingsKey;
+    private readonly window;
+    constructor();
+    patch(patch: DeepPartial<ConsoleUserSettings>): void;
+    update(update: Partial<ConsoleUserSettings>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserSettingsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UserSettingsService>;
+}
+
+interface ConsoleToolbarContext {
+    clipboard: {
+        consoleClipboardText: Signal<string>;
+        sendTextToConsoleClipboard(text: string): Promise<void>;
+    };
+    console: {
+        copyScreenshot(): Promise<void>;
+        recordScreenStart(): void;
+        recordScreenStop(): Promise<Blob>;
+        sendCtrlAltDel(): Promise<void>;
+        sendKeyboardInput(text: string): Promise<void>;
+        sendPowerRequest(request: ConsolePowerRequest): Promise<void>;
+        sendReconnectRequest(): Promise<void>;
+        supportedFeatures: Signal<ConsoleSupportedFeatures>;
+        toggleFullscreen(): Promise<void>;
+    };
+    networks: {
+        config: Signal<ConsoleComponentNetworkConfig | undefined>;
+        connectionRequested(request: ConsoleNetworkConnectionRequest): void;
+        disconnectRequested(request: ConsoleNetworkDisconnectionRequest): void;
+    };
+    state: {
+        activeConsoleRecording: Signal<CanvasRecording | undefined>;
+        isConnected: Signal<boolean>;
+        isFullscreenAvailable: Signal<boolean>;
+        isManualReconnectAvailable: Signal<boolean>;
+        isRecordingAvailable: Signal<boolean>;
+        isViewOnly: Signal<boolean>;
+    };
+    userSettings: UserSettingsService;
+}
+
+interface ConsoleToolbarComponentBase {
+    consoleContext: InputSignal<ConsoleToolbarContext>;
+}
+
+declare class ConsoleComponent implements OnDestroy {
+    autoConnect: _angular_core.InputSignal<boolean>;
+    config: _angular_core.InputSignal<ConsoleComponentConfig>;
+    isViewOnly: _angular_core.InputSignal<boolean>;
+    networkConfig: _angular_core.InputSignal<ConsoleComponentNetworkConfig | undefined>;
+    toolbarComponent: _angular_core.InputSignal<Type<ConsoleToolbarComponentBase> | undefined>;
+    toolbarDisabled: _angular_core.InputSignal<boolean>;
+    connectionStatusChanged: _angular_core.OutputEmitterRef<ConsoleConnectionStatus | undefined>;
+    consoleClipboardUpdated: _angular_core.OutputEmitterRef<string>;
+    consoleRecorded: _angular_core.OutputEmitterRef<Blob>;
+    ctrlAltDelSent: _angular_core.OutputEmitterRef<void>;
+    localClipboardUpdated: _angular_core.OutputEmitterRef<ClipboardItem>;
+    networkConnectionRequested: _angular_core.OutputEmitterRef<ConsoleNetworkConnectionRequest>;
+    networkDisconnectRequested: _angular_core.OutputEmitterRef<ConsoleNetworkDisconnectionRequest | undefined>;
+    powerRequestSent: _angular_core.OutputEmitterRef<ConsolePowerRequest>;
+    reconnectRequest: _angular_core.OutputEmitterRef<ConsoleComponentConfig>;
+    screenshotCopied: _angular_core.OutputEmitterRef<Blob>;
+    private readonly browserNotifications;
+    private readonly canvasService;
+    private readonly clipboardService;
+    private readonly consoleClientFactory;
+    private readonly consoleForgeConfig;
+    private readonly document;
+    private readonly fullscreen;
+    private readonly logger;
+    private readonly userSettingsService;
+    private readonly uuids;
+    protected readonly componentContainer: _angular_core.Signal<ElementRef<HTMLElement>>;
+    protected readonly consoleHostElement: _angular_core.Signal<ElementRef<HTMLElement>>;
+    protected readonly consoleClient: _angular_core.WritableSignal<ConsoleClientService | undefined>;
+    protected readonly consoleClientConnectionStatus: _angular_core.Signal<ConsoleConnectionStatus | undefined>;
+    protected readonly consoleHostBackgroundStyle: string | undefined;
+    protected readonly consoleHostElementId: string;
+    protected readonly isRecording: _angular_core.Signal<boolean>;
+    protected readonly toolbarEnabled: _angular_core.Signal<false | Type<ConsoleToolbarComponentBase>>;
+    protected readonly userSettings: _angular_core.Signal<ConsoleUserSettings>;
+    constructor();
+    ngOnDestroy(): Promise<void>;
+    protected handleConsoleRecordingStarted(): Promise<void>;
+    protected handleCtrlAltDelSent(): Promise<void>;
+    protected handleFullscreen(): Promise<void>;
+    protected handleReconnectRequest(): void;
+    protected handleScreenshotCopied(screenshotData: Blob): Promise<Blob>;
+    connect(config: ConsoleComponentConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    private resolveConsoleCanvas;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConsoleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConsoleComponent, "cf-console", never, { "autoConnect": { "alias": "autoConnect"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "isViewOnly": { "alias": "isViewOnly"; "required": false; "isSignal": true; }; "networkConfig": { "alias": "networkConfig"; "required": false; "isSignal": true; }; "toolbarComponent": { "alias": "toolbarComponent"; "required": false; "isSignal": true; }; "toolbarDisabled": { "alias": "toolbarDisabled"; "required": false; "isSignal": true; }; }, { "connectionStatusChanged": "connectionStatusChanged"; "consoleClipboardUpdated": "consoleClipboardUpdated"; "consoleRecorded": "consoleRecorded"; "ctrlAltDelSent": "ctrlAltDelSent"; "localClipboardUpdated": "localClipboardUpdated"; "networkConnectionRequested": "networkConnectionRequested"; "networkDisconnectRequested": "networkDisconnectRequested"; "powerRequestSent": "powerRequestSent"; "reconnectRequest": "reconnectRequest"; "screenshotCopied": "screenshotCopied"; }, never, never, true, never>;
+}
+
+declare class ConsoleTileComponent {
+    config: _angular_core.InputSignal<ConsoleComponentConfig | undefined>;
+    clicked: _angular_core.OutputEmitterRef<ConsoleComponentConfig | undefined>;
+    connectionStatus: _angular_core.OutputEmitterRef<ConsoleConnectionStatus>;
+    reconnectRequest: _angular_core.OutputEmitterRef<ConsoleComponentConfig | undefined>;
+    private readonly cfConfig;
+    private readonly consoleClientFactory;
+    private readonly consoleHostElement;
+    private readonly logger;
+    private readonly uuids;
+    protected consoleClient?: ConsoleClientService;
+    protected readonly consoleClientType: _angular_core.Signal<_cmusei_console_forge.ConsoleClientType | undefined>;
+    protected consoleHostElementId: string;
+    constructor();
+    private connect;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConsoleTileComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConsoleTileComponent, "cf-console-tile", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; "connectionStatus": "connectionStatus"; "reconnectRequest": "reconnectRequest"; }, never, never, true, never>;
+}
+
+declare class ClassOnHoverDirective {
+    applyClasses: _angular_core.InputSignal<string>;
+    directiveHost: ElementRef<any>;
+    protected handleMouseEnter(): void;
+    protected handleMouseLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClassOnHoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClassOnHoverDirective, "[cfClassOnHover]", never, { "applyClasses": { "alias": "applyClasses"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3
+}
+
+declare abstract class ConsoleForgeConfig {
+    abstract canvasRecording: {
+        autoDownloadCompletedRecordings?: boolean;
+        chunkLength?: number;
+        frameRate?: number;
+        maxDuration?: number;
+        mimeType?: string;
+    };
+    abstract consoleBackgroundStyle?: string;
+    abstract defaultConsoleClientType?: ConsoleClientType;
+    abstract disabledFeatures: {
+        clipboard?: boolean;
+        consoleScreenRecord?: boolean;
+        manualConsoleReconnect?: boolean;
+        networkDisconnection?: boolean;
+    };
+    abstract logThreshold: LogLevel;
+    abstract showBrowserNotificationsOnConsoleEvents: boolean;
+    abstract toolbar: {
+        component: Type<ConsoleToolbarComponentBase>;
+        disabled: boolean;
+    };
+}
+
+declare function provideConsoleForge(config?: DeepPartial<ConsoleForgeConfig>): EnvironmentProviders;
+
+/**
+ * Extracts plain text from a ClipboardItem, if available.
+ *
+ * @param clipboardItem - The ClipboardItem to extract text from.
+ * @returns A promise that resolves to the extracted text, or null if no text is present.
+ */
+declare function getTextFromClipboardItem(clipboardItem?: ClipboardItem): Promise<string | null>;
+declare function getClipboardItemFromText(text: string): ClipboardItem;
+
+export { ClassOnHoverDirective, ConsoleComponent, ConsoleTileComponent, LogLevel, UserSettingsService, getClipboardItemFromText, getTextFromClipboardItem, provideConsoleForge };
+export type { ConsoleClientType, ConsoleComponentConfig, ConsoleComponentNetworkConfig, ConsoleConnectionOptions, ConsoleConnectionStatus, ConsoleCredentials, ConsoleNetworkConnectionRequest, ConsoleNetworkDisconnectionRequest, ConsolePowerRequest, ConsoleSupportedFeatures, ConsoleToolbarComponentBase, ConsoleToolbarContext, ConsoleToolbarPosition };

package/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@cmusei/console-forge" />
-export * from './public-api';

package/lib/components/console/console.component.d.ts

@@ -1,59 +0,0 @@
-import { ElementRef, OnDestroy, Type } from '@angular/core';
-import { ConsoleComponentConfig } from '../../models/console-component-config';
-import { ConsoleClientService } from '../../services/console-clients/console-client.service';
-import { ConsoleToolbarComponentBase } from '../../models/console-toolbar-component-base';
-import { ConsolePowerRequest } from '../../models/console-power-request';
-import { ConsoleComponentNetworkConfig } from '../../models/console-component-network-config';
-import { ConsoleConnectionStatus } from '../../models/console-connection-status';
-import { ConsoleNetworkConnectionRequest } from '../../models/console-network-connection-request';
-import { ConsoleNetworkDisconnectionRequest } from '../../models/console-network-disconnection-request';
-import * as i0 from "@angular/core";
-export declare class ConsoleComponent implements OnDestroy {
-    autoConnect: import("@angular/core").InputSignal<boolean>;
-    config: import("@angular/core").InputSignal<ConsoleComponentConfig>;
-    isViewOnly: import("@angular/core").InputSignal<boolean>;
-    networkConfig: import("@angular/core").InputSignal<ConsoleComponentNetworkConfig | undefined>;
-    toolbarComponent: import("@angular/core").InputSignal<Type<ConsoleToolbarComponentBase> | undefined>;
-    toolbarDisabled: import("@angular/core").InputSignal<boolean>;
-    connectionStatusChanged: import("@angular/core").OutputEmitterRef<ConsoleConnectionStatus | undefined>;
-    consoleClipboardUpdated: import("@angular/core").OutputEmitterRef<string>;
-    consoleRecorded: import("@angular/core").OutputEmitterRef<Blob>;
-    ctrlAltDelSent: import("@angular/core").OutputEmitterRef<void>;
-    localClipboardUpdated: import("@angular/core").OutputEmitterRef<ClipboardItem>;
-    networkConnectionRequested: import("@angular/core").OutputEmitterRef<ConsoleNetworkConnectionRequest>;
-    networkDisconnectRequested: import("@angular/core").OutputEmitterRef<ConsoleNetworkDisconnectionRequest | undefined>;
-    powerRequestSent: import("@angular/core").OutputEmitterRef<ConsolePowerRequest>;
-    reconnectRequest: import("@angular/core").OutputEmitterRef<ConsoleComponentConfig>;
-    screenshotCopied: import("@angular/core").OutputEmitterRef<Blob>;
-    private readonly browserNotifications;
-    private readonly canvasService;
-    private readonly clipboardService;
-    private readonly consoleClientFactory;
-    private readonly consoleForgeConfig;
-    private readonly document;
-    private readonly fullscreen;
-    private readonly logger;
-    private readonly userSettingsService;
-    private readonly uuids;
-    protected readonly componentContainer: import("@angular/core").Signal<ElementRef<HTMLElement>>;
-    protected readonly consoleHostElement: import("@angular/core").Signal<ElementRef<HTMLElement>>;
-    protected readonly consoleClient: import("@angular/core").WritableSignal<ConsoleClientService | undefined>;
-    protected readonly consoleClientConnectionStatus: import("@angular/core").Signal<ConsoleConnectionStatus | undefined>;
-    protected readonly consoleHostBackgroundStyle: string | undefined;
-    protected readonly consoleHostElementId: string;
-    protected readonly isRecording: import("@angular/core").Signal<boolean>;
-    protected readonly toolbarEnabled: import("@angular/core").Signal<false | Type<ConsoleToolbarComponentBase>>;
-    protected readonly userSettings: import("@angular/core").Signal<import("../../models/console-user-settings").ConsoleUserSettings>;
-    constructor();
-    ngOnDestroy(): Promise<void>;
-    protected handleConsoleRecordingStarted(): Promise<void>;
-    protected handleCtrlAltDelSent(): Promise<void>;
-    protected handleFullscreen(): Promise<void>;
-    protected handleReconnectRequest(): void;
-    protected handleScreenshotCopied(screenshotData: Blob): Promise<Blob>;
-    connect(config: ConsoleComponentConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    private resolveConsoleCanvas;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConsoleComponent, "cf-console", never, { "autoConnect": { "alias": "autoConnect"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "isViewOnly": { "alias": "isViewOnly"; "required": false; "isSignal": true; }; "networkConfig": { "alias": "networkConfig"; "required": false; "isSignal": true; }; "toolbarComponent": { "alias": "toolbarComponent"; "required": false; "isSignal": true; }; "toolbarDisabled": { "alias": "toolbarDisabled"; "required": false; "isSignal": true; }; }, { "connectionStatusChanged": "connectionStatusChanged"; "consoleClipboardUpdated": "consoleClipboardUpdated"; "consoleRecorded": "consoleRecorded"; "ctrlAltDelSent": "ctrlAltDelSent"; "localClipboardUpdated": "localClipboardUpdated"; "networkConnectionRequested": "networkConnectionRequested"; "networkDisconnectRequested": "networkDisconnectRequested"; "powerRequestSent": "powerRequestSent"; "reconnectRequest": "reconnectRequest"; "screenshotCopied": "screenshotCopied"; }, never, never, true, never>;
-}

package/lib/components/console-status/console-status.component.d.ts

@@ -1,12 +0,0 @@
-import { AfterViewInit } from '@angular/core';
-import { ConsoleConnectionStatus } from '../../models/console-connection-status';
-import * as i0 from "@angular/core";
-export declare class ConsoleStatusComponent implements AfterViewInit {
-    status: import("@angular/core").InputSignal<ConsoleConnectionStatus | undefined>;
-    reconnectRequest: import("@angular/core").OutputEmitterRef<void>;
-    private readonly picoCssService;
-    private readonly hostElement;
-    ngAfterViewInit(): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleStatusComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConsoleStatusComponent, "cf-console-status", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, { "reconnectRequest": "reconnectRequest"; }, never, never, true, never>;
-}

package/lib/components/console-tile/console-tile.component.d.ts

@@ -1,20 +0,0 @@
-import { ConsoleComponentConfig } from '../../models/console-component-config';
-import { ConsoleClientService } from '../../services/console-clients/console-client.service';
-import * as i0 from "@angular/core";
-export declare class ConsoleTileComponent {
-    config: import("@angular/core").InputSignal<ConsoleComponentConfig | undefined>;
-    clicked: import("@angular/core").OutputEmitterRef<ConsoleComponentConfig | undefined>;
-    reconnectRequest: import("@angular/core").OutputEmitterRef<ConsoleComponentConfig | undefined>;
-    private readonly cfConfig;
-    private readonly consoleClientFactory;
-    private readonly consoleHostElement;
-    private readonly logger;
-    private readonly uuids;
-    protected consoleClient?: ConsoleClientService;
-    protected readonly consoleClientType: import("@angular/core").Signal<import("@cmusei/console-forge").ConsoleClientType | undefined>;
-    protected consoleHostElementId: string;
-    constructor();
-    private connect;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleTileComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConsoleTileComponent, "cf-console-tile", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; "reconnectRequest": "reconnectRequest"; }, never, never, true, never>;
-}

package/lib/components/console-toolbar/console-toolbar.component.d.ts

@@ -1,53 +0,0 @@
-import { Type } from '@angular/core';
-import { ConsoleClientService } from '../../services/console-clients/console-client.service';
-import { ConsoleComponentNetworkConfig } from '../../models/console-component-network-config';
-import { ConsoleToolbarContext } from '../../models/console-toolbar-context';
-import { ConsoleToolbarComponentBase } from '../../models/console-toolbar-component-base';
-import { ConsoleNetworkConnectionRequest } from '../../models/console-network-connection-request';
-import { ConsoleNetworkDisconnectionRequest } from '../../models/console-network-disconnection-request';
-import { ConsolePowerRequest } from '../../models/console-power-request';
-import * as i0 from "@angular/core";
-export declare class ConsoleToolbarComponent {
-    consoleClient: import("@angular/core").InputSignal<ConsoleClientService>;
-    consoleNetworkConfig: import("@angular/core").InputSignal<ConsoleComponentNetworkConfig | undefined>;
-    customToolbarComponent: import("@angular/core").InputSignal<Type<ConsoleToolbarComponentBase> | undefined>;
-    isViewOnly: import("@angular/core").InputSignal<boolean>;
-    canvasRecordingStarted: import("@angular/core").OutputEmitterRef<void>;
-    canvasRecordingFinished: import("@angular/core").OutputEmitterRef<Blob>;
-    ctrlAltDelSent: import("@angular/core").OutputEmitterRef<void>;
-    keyboardInputSent: import("@angular/core").OutputEmitterRef<string>;
-    networkConnectionRequested: import("@angular/core").OutputEmitterRef<ConsoleNetworkConnectionRequest>;
-    networkDisconnectRequested: import("@angular/core").OutputEmitterRef<ConsoleNetworkDisconnectionRequest | undefined>;
-    powerRequestSent: import("@angular/core").OutputEmitterRef<ConsolePowerRequest>;
-    reconnectRequestSent: import("@angular/core").OutputEmitterRef<void>;
-    screenshotCopied: import("@angular/core").OutputEmitterRef<Blob>;
-    toggleFullscreen: import("@angular/core").OutputEmitterRef<void>;
-    private readonly blobDownloader;
-    private readonly canvas;
-    private readonly canvasRecorder;
-    private readonly clipboardService;
-    private readonly config;
-    private readonly fullscreen;
-    private readonly logger;
-    private readonly userSettings;
-    private readonly window;
-    private readonly activeConsoleRecording;
-    private readonly isConnected;
-    private readonly isManualConsoleReconnectAvailable;
-    protected readonly toolbarComponentContext: ConsoleToolbarContext;
-    protected readonly toolbarComponent: import("@angular/core").Signal<Type<ConsoleToolbarComponentBase>>;
-    constructor();
-    protected handleCopyScreenshot(): Promise<void>;
-    protected handleFullscreen(): Promise<void>;
-    protected handleKeyboardInputSend(text: string): Promise<void>;
-    protected handleNetworkConnectionRequest(request: ConsoleNetworkConnectionRequest): void;
-    protected handleNetworkDisconnectionRequest(request?: ConsoleNetworkDisconnectionRequest): void;
-    protected handleReconnectRequestSent(): Promise<void>;
-    protected handleRecordScreenStart(): void;
-    protected handleRecordScreenStop(): Promise<Blob>;
-    protected handleSendCtrlAltDelete(): Promise<void>;
-    private handleSendPowerRequest;
-    protected handleSendTextToClipboard(text: string): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleToolbarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConsoleToolbarComponent, "cf-console-toolbar", never, { "consoleClient": { "alias": "consoleClient"; "required": true; "isSignal": true; }; "consoleNetworkConfig": { "alias": "consoleNetworkConfig"; "required": false; "isSignal": true; }; "customToolbarComponent": { "alias": "customToolbarComponent"; "required": false; "isSignal": true; }; "isViewOnly": { "alias": "isViewOnly"; "required": true; "isSignal": true; }; }, { "canvasRecordingStarted": "canvasRecordingStarted"; "canvasRecordingFinished": "canvasRecordingFinished"; "ctrlAltDelSent": "ctrlAltDelSent"; "keyboardInputSent": "keyboardInputSent"; "networkConnectionRequested": "networkConnectionRequested"; "networkDisconnectRequested": "networkDisconnectRequested"; "powerRequestSent": "powerRequestSent"; "reconnectRequestSent": "reconnectRequestSent"; "screenshotCopied": "screenshotCopied"; "toggleFullscreen": "toggleFullscreen"; }, never, never, true, never>;
-}

package/lib/components/console-toolbar-default/console-toolbar-default-button/console-toolbar-default-button.component.d.ts

@@ -1,13 +0,0 @@
-import { AfterViewInit } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class ConsoleToolbarDefaultButtonComponent implements AfterViewInit {
-    clicked: import("@angular/core").OutputEmitterRef<void>;
-    disabled: import("@angular/core").InputSignal<boolean>;
-    label: import("@angular/core").InputSignal<string | undefined>;
-    isOngoing: import("@angular/core").InputSignal<boolean>;
-    private readonly picoCssService;
-    private readonly hostElement;
-    ngAfterViewInit(): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleToolbarDefaultButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConsoleToolbarDefaultButtonComponent, "cf-console-toolbar-default-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "isOngoing": { "alias": "isOngoing"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
-}

package/lib/components/console-toolbar-default/console-toolbar-default.component.d.ts

@@ -1,43 +0,0 @@
-import { AfterViewInit, ElementRef } from '@angular/core';
-import { ConsoleToolbarContext } from '../../models/console-toolbar-context';
-import { ConsoleToolbarComponentBase } from '../../models/console-toolbar-component-base';
-import { ConsoleForgeConfig } from '../../config/console-forge-config';
-import { ConsolePowerRequest } from '../../models/console-power-request';
-import { ConsoleToolbarPosition } from '../../models/console-toolbar-position';
-import { ConsoleToolbarTheme } from '../../models/console-toolbar-theme';
-import { ConsoleNetworkConnectionRequest } from '../../models/console-network-connection-request';
-import * as i0 from "@angular/core";
-export declare class ConsoleToolbarDefaultComponent implements AfterViewInit, ConsoleToolbarComponentBase {
-    consoleContext: import("@angular/core").InputSignal<ConsoleToolbarContext>;
-    protected isClipboardDialogOpen: boolean;
-    protected isKeyboardDialogOpen: boolean;
-    protected isNetworkDialogOpen: boolean;
-    protected isPowerDialogOpen: boolean;
-    protected isSettingsDialogOpen: boolean;
-    protected readonly keyboardInputText: import("@angular/core").ModelSignal<string>;
-    protected readonly cfConfig: ConsoleForgeConfig;
-    private readonly clipboardService;
-    protected readonly clipboardTextInput: import("@angular/core").Signal<ElementRef<any> | undefined>;
-    private readonly picoCssService;
-    private readonly hostElement;
-    constructor();
-    ngAfterViewInit(): Promise<void>;
-    protected handleChangeToolbarPosition(position: ConsoleToolbarPosition): void;
-    protected handleClipboardDialogOpenClose(isOpen: boolean): void;
-    protected handleClipboardCopyLastText(text: string): void;
-    protected handleNetworkChangeRequested(request: ConsoleNetworkConnectionRequest): void;
-    protected handleNetworkDisconnectAllRequested(): void;
-    protected handleNetworkDialogOpenClose(isOpen: boolean): void;
-    protected handleRecordToggle(): void;
-    protected handleSendClipboardText(event: Event, text: string): Promise<void>;
-    protected handlSendKeyboardCtrlAltDel(): Promise<void>;
-    protected handleSendKeyboardInput(event: Event, text: string): Promise<void>;
-    protected handleSendPowerRequest(request: ConsolePowerRequest): Promise<void>;
-    protected handleSettingsDialogOpenClose(isOpen: boolean): void;
-    protected handleSettingsAllowLocalClipboardWrite(allow: boolean): void;
-    protected handleSettingsAttemptRemoteSessionResize(attempt: boolean): void;
-    protected handleSettingsScaleToContainerHostSize(scaleToCanvasHostSize: boolean): void;
-    protected handleToolbarThemeChange(theme?: ConsoleToolbarTheme): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleToolbarDefaultComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConsoleToolbarDefaultComponent, "cf-console-toolbar-default", never, { "consoleContext": { "alias": "consoleContext"; "required": true; "isSignal": true; }; "keyboardInputText": { "alias": "keyboardInputText"; "required": false; "isSignal": true; }; }, { "keyboardInputText": "keyboardInputTextChange"; }, never, never, true, never>;
-}

package/lib/config/console-forge-config.d.ts

@@ -1,28 +0,0 @@
-import { Type } from "@angular/core";
-import { LogLevel } from "../models/log-level";
-import { ConsoleClientType } from "../models/console-client-type";
-import { ConsoleToolbarComponentBase } from "../models/console-toolbar-component-base";
-export declare abstract class ConsoleForgeConfig {
-    abstract canvasRecording: {
-        autoDownloadCompletedRecordings?: boolean;
-        chunkLength?: number;
-        frameRate?: number;
-        maxDuration?: number;
-        mimeType?: string;
-    };
-    abstract consoleBackgroundStyle?: string;
-    abstract defaultConsoleClientType?: ConsoleClientType;
-    abstract disabledFeatures: {
-        clipboard?: boolean;
-        consoleScreenRecord?: boolean;
-        manualConsoleReconnect?: boolean;
-        networkDisconnection?: boolean;
-    };
-    abstract logThreshold: LogLevel;
-    abstract showBrowserNotificationsOnConsoleEvents: boolean;
-    abstract toolbar: {
-        component: Type<ConsoleToolbarComponentBase>;
-        disabled: boolean;
-    };
-}
-export declare const defaultCfConfig: ConsoleForgeConfig;

package/lib/config/provide-console-forge.d.ts

@@ -1,4 +0,0 @@
-import { EnvironmentProviders } from "@angular/core";
-import { ConsoleForgeConfig } from "./console-forge-config";
-import { DeepPartial } from "../services/object.helpers";
-export declare function provideConsoleForge(config?: DeepPartial<ConsoleForgeConfig>): EnvironmentProviders;

package/lib/directives/apply-toolbar-theme.directive.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class ApplyToolbarThemeDirective {
-    private readonly hostElement;
-    private readonly userSettings;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyToolbarThemeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ApplyToolbarThemeDirective, "[cfApplyToolbarTheme]", never, {}, {}, never, never, true, never>;
-}