@finsemble/finsemble-electron-adapter 1.0.0-beta-1

package/types/permissions/defaultWindowOptions.d.ts

@@ -0,0 +1,377 @@
+declare const _default: {
+    width: number;
+    windowName: string;
+    height: number;
+    x: undefined;
+    y: undefined;
+    useContentSize: boolean;
+    center: undefined;
+    minWidth: number;
+    minHeight: number;
+    maxWidth: undefined;
+    maxHeight: undefined;
+    resizable: boolean;
+    alwaysOnTop: boolean;
+    alwaysOnTopLevel: null;
+    fullscreen: boolean;
+    skipTaskbar: boolean;
+    kiosk: boolean;
+    title: string;
+    icon: undefined;
+    show: boolean;
+    frame: boolean;
+    acceptFirstMouse: boolean;
+    disableAutoHideCursor: boolean;
+    autoHideMenuBar: boolean;
+    enableLargerThanScreen: boolean;
+    backgroundColor: string;
+    darkTheme: boolean;
+    transparent: boolean;
+    type: undefined;
+    titleBarStyle: undefined;
+    webPreferences: {
+        nodeIntegration: boolean;
+        preload: undefined;
+        partition: undefined;
+        zoomFactor: number;
+        disableZoom: boolean;
+        javascript: boolean;
+        webSecurity: boolean;
+        allowDisplayingInsecureContent: boolean;
+        allowRunningInsecureContent: boolean;
+        images: boolean;
+        java: boolean;
+        textAreasAreResizable: boolean;
+        webgl: boolean;
+        webaudio: boolean;
+        plugins: boolean;
+        experimentalFeatures: boolean;
+        experimentalCanvasFeatures: boolean;
+        overlayScrollbars: boolean;
+        overlayFullscreenVideo: boolean;
+        sharedWorker: boolean;
+        directWrite: boolean;
+        pageVisibility: boolean;
+    };
+    permissions: {
+        Application: {
+            close: boolean;
+            getManifest: boolean;
+            getOptions: boolean;
+            remoteApplicationEvents: boolean;
+            removeTrayIcon: boolean;
+            restartApplication: boolean;
+            setTrayIcon: boolean;
+            spawn: boolean;
+            addListener: {
+                closed: boolean;
+                connected: boolean;
+                crashed: boolean;
+                initialized: boolean;
+                "manifest-changed": boolean;
+                "not-responding": boolean;
+                "out-of-memory": boolean;
+                responding: boolean;
+                "run-requested": boolean;
+                started: boolean;
+                "tray-icon-clicked": boolean;
+                "window-alert-requested": boolean;
+                "window-auth-requested": boolean;
+                "window-blurred": boolean;
+                "window-bounds-changed": boolean;
+                "window-bounds-changing": boolean;
+                "window-closed": boolean;
+                "window-closing": boolean;
+                "window-crashed": boolean;
+                "window-created": boolean;
+                "window-disabled-frame-bounds-changed": boolean;
+                "window-disabled-frame-bounds-changing": boolean;
+                "window-embedded": boolean;
+                "window-end-load": boolean;
+                "window-external-process-exited": boolean;
+                "window-external-process-started": boolean;
+                "window-file-download-completed": boolean;
+                "window-file-download-progress": boolean;
+                "window-file-download-started": boolean;
+                "window-focused": boolean;
+                "window-frame-disabled": boolean;
+                "window-frame-enabled": boolean;
+                "window-group-changed": boolean;
+                "window-hidden": boolean;
+                "window-initialized": boolean;
+                "window-maximized": boolean;
+                "window-minimized": boolean;
+                "window-navigation-rejected": boolean;
+                "window-not-responding": boolean;
+                "window-out-of-memory": boolean;
+                "window-preload-scripts-state-changed": boolean;
+                "window-preload-scripts-state-changing": boolean;
+                "window-reloaded": boolean;
+                "window-responding": boolean;
+                "window-restored": boolean;
+                "window-show-requested": boolean;
+                "window-shown": boolean;
+                "window-start-load": boolean;
+            };
+        };
+        InterApplicationBus: {
+            publish: boolean;
+            subscribe: boolean;
+        };
+        Notification: {
+            notification: boolean;
+        };
+        System: {
+            clearCache: boolean;
+            deleteAssets: boolean;
+            exit: boolean;
+            flushStorage: boolean;
+            getEnvironmentVariable: boolean;
+            getSDServerInfo: boolean;
+            getHostSpecs: boolean;
+            getMonitorInfo: boolean;
+            getMousePosition: boolean;
+            getProcessList: boolean;
+            getVersion: boolean;
+            getFEAInfo: boolean;
+            getUpdateAvailable: boolean;
+            launchExternalProcess: boolean;
+            logToDisk: boolean;
+            openUrlWithBrowser: boolean;
+            showDeveloperTools: boolean;
+            getProtocolString: boolean;
+            availableFormatsFromClipboard: boolean;
+            writeText: boolean;
+            writeHTML: boolean;
+            writeRTF: boolean;
+            write: boolean;
+            readText: boolean;
+            readHTML: boolean;
+            readRTF: boolean;
+            setTrayIcon: boolean;
+            getCommandLineArguments: boolean;
+            register: boolean;
+            isRegistered: boolean;
+            unregister: boolean;
+            addSelectClientCertificateListener: boolean;
+            addCertificateErrorListener: boolean;
+            getScreenShareSources: boolean;
+            getScreenShot: boolean;
+            addListener: {
+                "application-closed": boolean;
+                "application-connected": boolean;
+                "application-crashed": boolean;
+                "application-created": boolean;
+                "application-initialized": boolean;
+                "application-manifest-changed": boolean;
+                "application-not-responding": boolean;
+                "application-responding": boolean;
+                "application-run-requested": boolean;
+                "application-started": boolean;
+                "application-tray-icon-clicked": boolean;
+                "desktop-icon-clicked": boolean;
+                "idle-state-changed": boolean;
+                "new-window-created": boolean;
+                "monitor-info-changed": boolean;
+                "session-changed": boolean;
+                "window-blurred": boolean;
+                "window-bounds-changed": boolean;
+                "window-bounds-changing": boolean;
+                "window-closed": boolean;
+                "window-closing": boolean;
+                "window-crashed": boolean;
+                "window-created": boolean;
+                "window-disabled-frame-bounds-changed": boolean;
+                "window-disabled-frame-bounds-changing": boolean;
+                "window-embedded": boolean;
+                "window-end-load": boolean;
+                "window-external-process-exited": boolean;
+                "window-external-process-started": boolean;
+                "window-file-download-completed": boolean;
+                "window-file-download-progress": boolean;
+                "window-file-download-started": boolean;
+                "window-focused": boolean;
+                "window-frame-disabled": boolean;
+                "window-frame-enabled": boolean;
+                "window-group-changed": boolean;
+                "window-hidden": boolean;
+                "window-initialized": boolean;
+                "window-maximized": boolean;
+                "window-minimized": boolean;
+                "window-navigation-rejected": boolean;
+                "window-not-responding": boolean;
+                "window-preload-scripts-state-changed": boolean;
+                "window-preload-scripts-state-changing": boolean;
+                "window-reloaded": boolean;
+                "window-responding": boolean;
+                "window-restored": boolean;
+                "window-shown": boolean;
+                "window-start-load": boolean;
+            };
+        };
+        Window: {
+            addBrowserView: boolean;
+            animate: boolean;
+            authenticate: boolean;
+            blur: boolean;
+            bringToFront: boolean;
+            close: boolean;
+            closeRequestedAdd: boolean;
+            closeRequestedRemove: boolean;
+            disableFrame: boolean;
+            enableFrame: boolean;
+            flash: boolean;
+            focus: boolean;
+            getAllFrames: boolean;
+            getBounds: boolean;
+            getBoundsFromSystem: boolean;
+            getDetails: boolean;
+            getGroup: boolean;
+            getInfo: boolean;
+            getOptions: boolean;
+            getSnapshot: boolean;
+            getState: boolean;
+            getZoomLevel: boolean;
+            hide: boolean;
+            isShowing: boolean;
+            joinGroup: boolean;
+            leaveGroup: boolean;
+            maximize: boolean;
+            minimize: boolean;
+            moveBy: boolean;
+            moveTo: boolean;
+            windowMouseDown: boolean;
+            windowMoving: boolean;
+            windowMoved: boolean;
+            navigate: boolean;
+            navigateBack: boolean;
+            navigateForward: boolean;
+            reload: boolean;
+            removeBrowserView: boolean;
+            bringViewToFront: boolean;
+            removeListener: boolean;
+            resetBrowserView: boolean;
+            resizeBy: boolean;
+            resizeTo: boolean;
+            restore: boolean;
+            setAsForegroundColor: boolean;
+            setBounds: boolean;
+            setIgnoreMouseEvents: boolean;
+            setMinimumSize: boolean;
+            setMaximumSize: boolean;
+            setResizable: boolean;
+            setShape: boolean;
+            setTaskbarIcon: boolean;
+            setTaskbarIconOverlay: boolean;
+            showNativeOpenDialog: boolean;
+            setViewBounds: boolean;
+            setZoomLevel: boolean;
+            syncWindowInfo: boolean;
+            show: boolean;
+            showAt: boolean;
+            showDeveloperTools: boolean;
+            stopFlashing: boolean;
+            stopNavigation: boolean;
+            updateOptions: boolean;
+            addListener: {
+                "auth-requested": boolean;
+                "begin-user-bounds-changing": boolean;
+                blurred: boolean;
+                "bounds-changed": boolean;
+                "bounds-change-end": boolean;
+                "close-requested": boolean;
+                closed: boolean;
+                closing: boolean;
+                crashed: boolean;
+                "disabled-frame-bounds-changed": boolean;
+                "disabled-frame-bounds-changing": boolean;
+                embedded: boolean;
+                "end-user-bounds-changing": boolean;
+                "external-process-exited": boolean;
+                "external-process-started": boolean;
+                "file-download-completed": boolean;
+                "file-download-progress": boolean;
+                "file-download-started": boolean;
+                focused: boolean;
+                "frame-disabled": boolean;
+                "frame-enabled": boolean;
+                "group-changed": boolean;
+                hidden: boolean;
+                initialized: boolean;
+                maximized: boolean;
+                minimized: boolean;
+                "navigation-rejected": boolean;
+                "preload-scripts-state-changed": boolean;
+                "preload-scripts-state-changing": boolean;
+                reloaded: boolean;
+                "resource-load-failed": boolean;
+                "resource-response-received": boolean;
+                restored: boolean;
+                "show-requested": boolean;
+                shown: boolean;
+            };
+            chromePermissions: {
+                alarms: boolean;
+                audio: boolean;
+                audioCapture: boolean;
+                background: boolean;
+                browser: boolean;
+                certificateProvider: boolean;
+                clipboard: boolean;
+                clipboardRead: boolean;
+                clipboardWrite: boolean;
+                contextMenu: boolean;
+                desktopCapture: boolean;
+                diagnostics: boolean;
+                displaySource: boolean;
+                dns: boolean;
+                documentScan: boolean;
+                "enterprise.deviceAttributes": boolean;
+                "enterprise.platformKeys": boolean;
+                experimental: boolean;
+                fileBrowserHandler: boolean;
+                fileSystem: boolean;
+                fileSystemProvider: boolean;
+                gcm: boolean;
+                geolocation: boolean;
+                hid: boolean;
+                identity: boolean;
+                idle: boolean;
+                mdns: boolean;
+                mediaGalleries: boolean;
+                nativeMessaging: boolean;
+                "networking.config": boolean;
+                "networking.onc": boolean;
+                notifications: boolean;
+                platformKeys: boolean;
+                pointerLock: boolean;
+                power: boolean;
+                printerProvider: boolean;
+                proxy: boolean;
+                serial: boolean;
+                signedInDevices: boolean;
+                socket: boolean;
+                storage: boolean;
+                syncFileSystem: boolean;
+                "system.cpu": boolean;
+                "system.display": boolean;
+                "system.memory": boolean;
+                "system.network": boolean;
+                "system.powerSource": boolean;
+                "system.storage": boolean;
+                tts: boolean;
+                unlimitedStorage: boolean;
+                usb: boolean;
+                videoCapture: boolean;
+                virtualKeyboard: boolean;
+                vpnProvider: boolean;
+                wallpaper: boolean;
+                webview: boolean;
+            };
+            webPreferences: {
+                preload: boolean;
+            };
+        };
+    };
+};
+export default _default;

package/types/render/InterApplicationBus.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { IpcRendererEvent } from "electron";
+import { EventEmitter } from "events";
+import { IABSubscribeResponse } from "../types/types";
+export declare class InterApplicationBus extends EventEmitter {
+    subscribers: {
+        [listenerID: string]: (data: any) => void;
+    };
+    constructor();
+    bindAllFunctions(): void;
+    setUpListeners(): void;
+    onSubscribeResponse(event: IpcRendererEvent, response: IABSubscribeResponse): void;
+    publish(destination: string, message: any, callback?: Function, errorCallback?: Function): void;
+    subscribe(ignored: string, source: string, listener: (data: any) => void, callback?: Function, errorCallbackArg?: Function): string | null;
+    unsubscribe(listenerID: string): void;
+}

package/types/render/Notification.d.ts

@@ -0,0 +1,3 @@
+export declare const Notification: {
+    send: (params: any) => void;
+};

package/types/render/RequestHelper.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { IpcRendererEvent } from "electron";
+import { EventEmitter } from "events";
+declare type RequestParams = {
+    topic: string;
+    data?: any;
+    persistChannel?: any;
+};
+declare class RequestHelper extends EventEmitter {
+    request: any;
+    constructor();
+    handleResponse(event: IpcRendererEvent, data: any): void;
+    promisifiedSendRequest<T>(e2oRequest: RequestParams): Promise<T>;
+    sendRequest(params: RequestParams, functionCB?: Function): void;
+    systemResponse(event: IpcRendererEvent, response: {
+        topic: string;
+        data: any;
+    }): void;
+    addListener(eventName: string, listener: (...args: any[]) => void): this;
+    removeListener(eventName: string, listener: (...args: any[]) => void): this;
+}
+declare const _default: RequestHelper;
+export default _default;

package/types/render/System.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { StandardPromise, FEALogLevel } from "../types/types";
+import { Certificate } from "electron";
+declare class Clipboard {
+    constructor();
+    availableFormats(successCallback?: Function, errorCallback?: Function): void;
+    writeText(text: string, successCallback?: Function, errorCallback?: Function): void;
+    writeHTML(text: string, successCallback?: Function, errorCallback?: Function): void;
+    writeRTF(text: string, successCallback?: Function, errorCallback?: Function): void;
+    write(data: any, successCallback?: Function, errorCallback?: Function): void;
+    readText(successCallback?: Function, errorCallback?: Function): void;
+    readHTML(successCallback?: Function, errorCallback?: Function): void;
+    readRTF(successCallback?: Function, errorCallback?: Function): void;
+}
+declare class GlobalShortcut {
+    listeners: any;
+    constructor();
+    register(accelerator: string, callback: (...args: any[]) => void, successCallback?: Function, errorCallback?: Function): void;
+    isRegistered(accelerator: string, successCallback?: Function, errorCallback?: Function): void;
+    unregister(accelerator: string, successCallback?: Function, errorCallback?: Function): void;
+}
+export declare class System extends EventEmitter {
+    addEventListener: (eventName: string, listener: (...args: any[]) => void) => System;
+    removeEventListener: (eventName: string, listener: (...args: any[]) => void) => void;
+    Clipboard: Clipboard;
+    GlobalShortcut: GlobalShortcut;
+    constructor();
+    bindAllFunctions(): void;
+    addListener(eventName: string, listener: (...args: any[]) => void): this;
+    addSelectClientCertificateListener(callback: (url: string, list: Certificate[], pickedCertificate: (certificate: Certificate) => void) => void): void;
+    addCertificateErrorListener(callback: (url: string, error: string, certificate: Certificate, allowOrDisallowCertificate: (allowOrDisallow: boolean) => void) => void): void;
+    clearCache(data: any): void;
+    exit(): void;
+    flushStorage(): void;
+    getManifest(cb?: Function): Promise<unknown>;
+    hideSplashScreen(): void;
+    getEnvironmentVariable(variableName: string | string[], successCallback?: Function, errorCallback?: Function): void;
+    deleteAssets(alias?: string | null): StandardPromise<void>;
+    getSDServerInfo(cb: Function): void;
+    getHostSpecs(cb: Function): void;
+    getMonitorInfo(cb: Function): void;
+    getMousePosition(cb: Function): void;
+    getProcessList(cb: Function): Promise<unknown>;
+    getVersion(cb: Function): void;
+    getUpdateAvailable(cb: Function): void;
+    getFEAInfo(cb: Function): void;
+    startupApplicationHandshake(): void;
+    launchExternalProcess(params: any, cb1: Function, cb2: Function): void;
+    openUrlWithBrowser(url: string, cb?: (...args: any[]) => void): void;
+    removeListener(eventName: string, listener: (...args: any[]) => void): this;
+    showDeveloperTools(name: string, viewId?: boolean, cb?: Function): void;
+    restart(): void;
+    terminate(): void;
+    getProtocolString(cb?: (data: string) => void): Promise<string>;
+    getCommandLineArguments(cb?: Function): void;
+    getScreenShareSources(options?: {}): Promise<Electron.DesktopCapturerSource[]>;
+    getScreenShot(sourceId?: string | null): Promise<string>;
+    setTrayIcon(url: string, cb?: Function): void;
+    logToDisk(level: FEALogLevel, ...messages: any[]): void;
+}
+export {};

package/types/render/Window.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { WebContentsId } from "../types/types";
+import { Manifest, StandardErrorCallback, StandardPromise } from "../types/types";
+import { EventEmitter } from "events";
+export declare class Window extends EventEmitter {
+    uuid: string;
+    name: string;
+    webContentsName: string;
+    webContentsId: WebContentsId;
+    closeRequestedListeners: any[];
+    useDOMMovement: boolean;
+    mouseX?: number;
+    mouseY?: number;
+    isMoving: boolean;
+    animationId: number;
+    manifest: Manifest;
+    constructor(params: {
+        manifest: Manifest;
+        windowName: string;
+        webContentsName: string;
+        webContentsId: WebContentsId;
+    });
+    attachToMainWindow(): void;
+    wrap(windowName: string, deprecated: string): Window;
+    private static spawnPhysicalWindow;
+    createNew(params: any, cb?: StandardErrorCallback<Window>): StandardPromise<Window>;
+    bindAllFunctions(): void;
+    addEventListener(eventName: string, listener: (...args: any[]) => void): void;
+    addBrowserView(data: any, cb: Function): void;
+    setViewBounds(viewId: any, bounds: any, cb: Function): void;
+    bringViewToFront(viewId: any, cb: Function): void;
+    addListener(eventName: string, listener: (...args: any[]) => void): this;
+    blur(cb?: Function): void;
+    bringToFront(cb?: Function): void;
+    close(force?: boolean, cb?: Function): void;
+    closeRequestedAdd(listener: Function): void;
+    closeRequestedRemove(listener: Function): void;
+    disableFrame(cb?: Function): void;
+    enableFrame(cb?: Function): void;
+    focus(cb?: Function): void;
+    getBounds(cb?: Function): void;
+    getBoundsFromSystem(cb?: Function): void;
+    getCurrent(): Window;
+    getOptions(cb?: Function): void;
+    getSnapshot(area: any, cb?: Function): Promise<unknown>;
+    hide(cb?: Function): void;
+    isShowing(cb?: Function): void;
+    minimize(cb?: Function): void;
+    resetBrowserView(cb?: Function): void;
+    removeBrowserView(viewId: number, cb?: Function): void;
+    removeEventListener(eventName: string, listener: (...args: any[]) => void): void;
+    removeListener(eventName: string, listener: (...args: any[]) => void): this;
+    removeTrayIcon(cb?: Function): void;
+    setTrayIcon(iconpath: string, listeners: any, cb?: Function): void;
+    maximize(cb?: Function): void;
+    reload(cb?: Function): void;
+    restore(cb?: Function): void;
+    setBounds(left: number, top: number, width: number, height: number, cb: Function): void;
+    setIgnoreMouseEvents(data: any): void;
+    setResizable(data: any): void;
+    setShape(data: any): void;
+    setTaskbarIcon(data: any): void;
+    setTaskbarIconOverlay(data: any): void;
+    showNativeOpenDialog(data: any, cb: Function): void;
+    show(cb?: Function): void;
+    showAt(left: number, top: number, force: boolean, cb?: Function): void;
+    setMinimumSize(width: number, height: number, cb?: Function): void;
+    setMaximumSize(width?: number | null, height?: number | null, cb?: Function): void;
+    updateOptions(options: any, cb?: Function): void;
+    remoteFSBLEvents(event: any, data: any): void;
+    animate(params: any, cb?: Function): void;
+    setAsForeground(cb: Function): void;
+    startMovingWindow(e: any): void;
+    stopMovingWindow(): void;
+}

package/types/render/renderHelpers.d.ts

@@ -0,0 +1 @@
+export declare const checkAndLogAccessDenied: (response: any) => boolean;

package/types/server/AppD.d.ts

@@ -0,0 +1,18 @@
+import express from "express";
+import { ConsoleLogger } from "../logger/types";
+export declare type AppDefinition = any;
+export declare type AppDPlugin = {
+    getApp: (appId: string) => Promise<AppDefinition | undefined>;
+    getAll: () => Promise<Array<AppDefinition>>;
+    search: (text: string) => Promise<Array<AppDefinition>>;
+    addApp: (definition: AppDefinition) => Promise<void>;
+    updateApp: (appId: string, definition: AppDefinition) => Promise<void>;
+    deleteApp: (appId: string) => Promise<void>;
+};
+declare type UseEndpointsParams = {
+    app: express.Application;
+    plugin: AppDPlugin;
+    logger?: ConsoleLogger;
+};
+declare const useEndpoints: ({ app, plugin, logger }: UseEndpointsParams) => void;
+export { useEndpoints };

package/types/server/AppDStaticConfigPlugin.d.ts

@@ -0,0 +1,8 @@
+import { AppDPlugin } from "./AppD";
+import { ConsoleLogger } from "../logger/types";
+export declare type AppDStaticConfigPluginParams = {
+    projectRoot: string;
+    logger?: ConsoleLogger;
+};
+declare const initialize: ({ projectRoot, logger }: AppDStaticConfigPluginParams) => Promise<AppDPlugin>;
+export { initialize };

package/types/server/CosaicCloud.d.ts

@@ -0,0 +1,21 @@
+import { ConsoleLogger } from "../logger/types";
+import { DeployInfo } from "./SmartDesktop";
+import * as Progress from "./Progress";
+export declare const CosaicCloudConfig: {
+    initiateURI: string;
+    generateInstallerURL: string;
+    progressURI: string;
+    xAPIKey: null;
+};
+declare type PublishParams = {
+    projectPath: string;
+    uuid?: string;
+    logger: ConsoleLogger;
+    appDataPath: string;
+};
+export declare const publish: (params: PublishParams) => Promise<DeployInfo>;
+declare type GetProgressParams = {
+    logger: ConsoleLogger;
+};
+export declare const getProgress: ({ logger }: GetProgressParams) => Promise<Progress.Progress>;
+export {};

package/types/server/Progress.d.ts

@@ -0,0 +1,26 @@
+export declare enum ProgressState {
+    NotStarted = "NotStarted",
+    Started = "Started",
+    Error = "Error",
+    Finished = "Finished"
+}
+export declare type ProgressItem = {
+    step: string;
+    state: ProgressState;
+    percentComplete: number;
+    error: string;
+};
+export declare type Progress = {
+    steps: {
+        [key: string]: ProgressItem;
+    };
+    currentStep: string;
+};
+export declare class ProgressTracker {
+    progress: Progress;
+    constructor(steps: Array<string>);
+    start(step: string): void;
+    setPercentComplete(percentComplete: number): void;
+    error(errorMessage: string): void;
+    currentStep(): string;
+}

package/types/server/Server.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import express from "express";
+import serveStatic from "serve-static";
+import http from "http";
+export declare type ServerTuple = {
+    app: express.Application;
+    server: http.Server;
+};
+export declare type ServerParameters = {
+    root: string;
+    port: number;
+    host?: string;
+    options?: serveStatic.ServeStaticOptions;
+    tmpDir: string | undefined;
+};
+declare const start: ({ root, port, host, options, tmpDir }: ServerParameters) => Promise<ServerTuple>;
+export { start };