@finsemble/finsemble-electron-adapter 0.0.0

package/dist/main/autoUpdaterWrapper.d.ts

@@ -0,0 +1,37 @@
+import { StandardResponse } from "../types/types";
+import { AutoUpdater, Event, FeedURLOptions } from "electron";
+declare type Listener = (event: Event, releaseNotes: string, releaseName: string, releaseDate: Date, updateURL: string) => void;
+declare type EventName = "update-not-available" | "checking-for-update" | "error" | "before-quit-for-update" | "update-available" | "update-downloaded";
+declare class AutoUpdaterWrapper {
+    autoUpdater: AutoUpdater;
+    useProxy: boolean;
+    feedURL?: FeedURLOptions;
+    localCache: FeedURLOptions;
+    releaseFileChecksum?: string;
+    latestReleaseFileName?: string;
+    constructor();
+    bindCorrectContext(): void;
+    on(event: EventName, listener: Listener): AutoUpdaterWrapper;
+    quitAndInstall(): void;
+    setFeedURL(options: FeedURLOptions): void;
+    _setFeedUrl(): void;
+    downloadViaElectron(downloadViaElectron: boolean): void;
+    downloadFile(params: any): Promise<{
+        err?: import("../types/types").StandardError;
+        data?: string | undefined;
+    }>;
+    checkForUpdates(): void;
+    _checkForUpdates(): void;
+    removeOlderVersions(): void;
+    onReleaseFileDownloaded(releasesObj: StandardResponse): Promise<void>;
+    getReleaseEntriesToDownload(fileContents: any): Promise<any[]>;
+    validateLocalFiles(entries: any): Promise<any[]>;
+    hashIsValid(fileName: string, sha1: string): Promise<boolean>;
+    parseReleaseEntry(entry: any): {
+        sha1: any;
+        fileName: any;
+        filesize: number;
+    } | null;
+}
+export declare const autoUpdaterWrapper: AutoUpdaterWrapper;
+export {};

package/dist/main/contentSecurity.d.ts

@@ -0,0 +1,17 @@
+import { Manifest } from "../types/types";
+import { OnHeadersReceivedListenerDetails, HeadersReceivedResponse } from "electron";
+export declare class CSPParser {
+    directives: any;
+    constructor(csp?: string | string[]);
+    convertToObject(cspString: string): void;
+    has(key: string): any;
+    delete(key: string): this;
+    set(key: string, value: string): this;
+    toString(): string;
+    getObject(): any;
+}
+export declare const removeFetchDirectives: (originalHeaders: Record<string, string[]>, url: string) => Record<string, string[]>;
+export declare const substituteOurCSP: (originalHeaders: Record<string, string[]>, csp: string | string[]) => {
+    [x: string]: any;
+};
+export declare const maybeModifyResponseHeaders: (manifest: Manifest, details: OnHeadersReceivedListenerDetails, callback: (headersReceivedResponse: HeadersReceivedResponse) => void) => void;

package/dist/main/contextMenu.d.ts

@@ -0,0 +1,2 @@
+import { WebContents, BrowserWindow } from "electron";
+export declare const enableContextMenu: (webContents: WebContents, bw: BrowserWindow) => void;

package/dist/main/download.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConsoleLogger } from "../logger/types";
+import { StandardPromise } from "../types/types";
+import { Transform as Stream } from "stream";
+interface Headers {
+    [key: string]: string;
+}
+export declare type DownloadOptions = {
+    headers?: Headers;
+    returnStream?: boolean;
+    timeout?: number;
+    retries?: number;
+    logger?: ConsoleLogger;
+};
+export declare type DownloadResult = {
+    data: Buffer;
+    response: Electron.IncomingMessage;
+};
+export declare type StreamResult = {
+    data: Stream;
+    response: Electron.IncomingMessage;
+};
+export declare const download: (url: string, options?: DownloadOptions) => Promise<DownloadResult>;
+export declare const downloadGoLang: (url: string, options?: DownloadOptions) => StandardPromise<DownloadResult>;
+export declare const stream: (url: string, options?: DownloadOptions) => StandardPromise<StreamResult>;
+export declare const downloadFile: (params?: any) => StandardPromise<string>;
+export {};

package/dist/main/getWindowIdentity.d.ts

@@ -0,0 +1,3 @@
+import { IpcMainEvent } from "electron";
+export declare const getWindowIdentity: (event: IpcMainEvent) => void;
+export declare const getWindowIdentityForWindowName: (event: IpcMainEvent, windowName: string) => void;

package/dist/main/listeners.d.ts

@@ -0,0 +1,7 @@
+import { MainSystem } from "./MainSystem";
+import { ProtocolHandler } from "./protocolHandler";
+import { DownloadManager } from "./DownloadManager";
+import { SplashScreen } from "./SplashScreen";
+import { Manifest } from "../types/types";
+import { App } from "electron";
+export declare const setupListeners: (app: App, system: MainSystem, manifest: Manifest, protocolHandler: ProtocolHandler, downloadManager: DownloadManager, splashScreen: SplashScreen) => void;

package/dist/main/mainStore.d.ts

@@ -0,0 +1,3 @@
+import { MainStore, WindowsIndex } from "../types/types";
+export declare let mainStore: MainStore;
+export declare let windowsIndex: WindowsIndex;

package/dist/main/preloads.d.ts

@@ -0,0 +1,8 @@
+import { Manifest } from "../types/types";
+import { StandardResponse, WebContentsId, Preload } from "../types/types";
+export declare const makePreloadDirectories: () => void;
+export declare const calculateWindowTitleBarUrl: (url: string, extension: "js" | "html") => string;
+export declare const getPreloads: (webContentsId: WebContentsId) => StandardResponse<Preload[]>;
+export declare const validateTrustedPreloadArray: (manifest: Manifest) => void;
+export declare const clearPreloadCache: () => Promise<void>;
+export declare const initializePreloads: (manifest: Manifest) => Promise<void>;

package/dist/main/protocolHandler.d.ts

@@ -0,0 +1,11 @@
+import { App } from "electron";
+export declare class ProtocolHandler {
+    protocolURL?: URL;
+    app: App;
+    constructor(app: App);
+    saveIfProtocolString(s: string): void;
+    isCustom(): boolean;
+    handleFirstInstance(): void;
+    handleSecondInstance(commandLineParameter: string): void;
+    private registerProtocolHandler;
+}

package/dist/main/updateManager.d.ts

@@ -0,0 +1,20 @@
+declare class UpdateManager {
+    feedURL: any;
+    updateTimeout: number;
+    updateAvailable: boolean;
+    signalUpdateAvailable: Function | null;
+    setUpdateAvailable: Function | null;
+    updateChecker: ReturnType<typeof setTimeout> | undefined;
+    constructor();
+    setFeedUrl(feedUrl: any): void;
+    usePreloadUpdater(usePreloader: any): void;
+    setUpdateFrequency(timeInMs: number): void;
+    setOnRestartAndUpdateRequested(signalUpdateAvailable: Function): void;
+    setOnUpdateAvailable(setUpdateAvailable: Function): void;
+    requestRestart(): void;
+    _startUpdater(): void;
+    listenForNewUpdates(): void;
+}
+export declare const updateManager: UpdateManager;
+export declare function handleSquirrelEvents(app: any): boolean;
+export {};

package/dist/makeInstaller.d.ts

@@ -0,0 +1,9 @@
+declare type InstallerConfig = {
+    manifestUrl?: string;
+    updateUrl?: string;
+    chromiumFlags?: Record<string, string>;
+    sddMode?: boolean;
+    [key: string]: any;
+};
+export declare const makeInstaller: (installerConfig: InstallerConfig) => Promise<void>;
+export {};