@openfin/core 31.74.21 → 31.74.23

package/src/api/view/Instance.js

@@ -1,12 +1,19 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _View_providerChannelClient;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.View = void 0;
-/* eslint-disable import/prefer-default-export */
-/* eslint-disable consistent-return */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const transport_errors_1 = require("../../transport/transport-errors");
+const lazy_1 = require("../../util/lazy");
+const layout_entities_1 = require("../platform/layout/entities/layout-entities");
+const layout_constants_1 = require("../platform/layout/layout.constants");
+const bounds_observer_1 = require("../platform/layout/utils/bounds-observer");
 const main_1 = require("../webcontents/main");
 const window_1 = require("../window");
-const bounds_observer_1 = require("../platform/layout/utils/bounds-observer");
 /**
  * @PORTED
  * @typedef {object} View~options
@@ -148,6 +155,9 @@ const bounds_observer_1 = require("../platform/layout/utils/bounds-observer");
  * @property {string} [processAffinity=<application uuid>]
  * A string to attempt to group renderers together. Will only be used if pages are on the same origin.
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the view.
+ *
  * @property {Identity} [target]
  * The identity of the window this view should be attached to.
  *
@@ -178,6 +188,10 @@ class View extends main_1.WebContents {
     constructor(wire, identity) {
         super(wire, identity, 'view');
         this.identity = identity;
+        _View_providerChannelClient.set(this, new lazy_1.Lazy(() => {
+            const platform = this.fin.Platform.wrapSync(this.identity);
+            return platform.getClient();
+        }));
         /**
          * Returns the zoom level of the view.
          * @function getZoomLevel
@@ -446,6 +460,26 @@ class View extends main_1.WebContents {
             const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });
             return new window_1._Window(this.wire, data);
         };
+        /**
+         * Retrieves the current {@link TabStack} of the view if it belongs to one.
+         * @return {Promise<TabStack>} The {@link TabStack} this view belongs to.
+         * @throws if this view does not belong to a TabStack or if the window has been destroyed.
+         */
+        this.getCurrentStack = async () => {
+            this.wire.sendAction('view-get-current-stack').catch(() => {
+                // don't expose
+            });
+            try {
+                const layoutWindow = await this.getCurrentWindow();
+                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
+                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);
+                const stackDefinition = (await client.getStackByView(this.identity));
+                return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);
+            }
+            catch (error) {
+                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });
+            }
+        };
         /**
          * Triggers the before-unload handler for the View, if one is set. Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.
          * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will always return false.
@@ -515,3 +549,4 @@ class View extends main_1.WebContents {
     }
 }
 exports.View = View;
+_View_providerChannelClient = new WeakMap();

package/src/api/webcontents/main.d.ts

@@ -2,31 +2,11 @@ import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import { Transport } from '../../transport/transport';
 import { BaseEvent } from '../events/base';
-/**
- * Configuration for page capture.
- */
-export interface CapturePageOptions {
-    /**
-     * The area of the window to be captured.
-     */
-    area?: OpenFin.Rectangle;
-    /**
-     * @defaultValue 'png'
-     *
-     * The format of the captured image.  Can be 'png', 'jpg', or 'bmp'.
-     */
-    format?: 'bmp' | 'jpg' | 'png';
-    /**
-     * @defaultValue 100
-     *
-     * Quality of JPEG image. Between 0 - 100.
-     */
-    quality?: number;
-}
 export declare class WebContents<T extends BaseEvent> extends EmitterBase<T> {
+    identity: OpenFin.Identity;
     entityType: string;
     constructor(wire: Transport, identity: OpenFin.Identity, entityType: string);
-    capturePage(options?: CapturePageOptions): Promise<string>;
+    capturePage(options?: OpenFin.CapturePageOptions): Promise<string>;
     executeJavaScript(code: string): Promise<void>;
     getZoomLevel(): Promise<number>;
     setZoomLevel(level: number): Promise<void>;

package/src/api/webcontents/main.js

@@ -5,6 +5,7 @@ const base_1 = require("../base");
 class WebContents extends base_1.EmitterBase {
     constructor(wire, identity, entityType) {
         super(wire, entityType, identity.uuid, identity.name);
+        this.identity = identity;
         this.entityType = entityType;
     }
     capturePage(options) {
@@ -41,7 +42,7 @@ class WebContents extends base_1.EmitterBase {
         })
             .then(() => undefined);
     }
-    print(options) {
+    print(options = {}) {
         return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
     }
     findInPage(searchTerm, options) {

package/src/api/window/Instance.d.ts

@@ -334,6 +334,9 @@ import { WebContents } from '../webcontents/main';
  * _Note: Caveats of small windows are no Aero Snap and drag to/from maximize._
  * _Windows 10: Requires `maximizable` to be false. Resizing with the mouse is only possible down to 38x39 px._
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the window.
+ *
  * @property {string} [state="normal"]
  * The visible state of the window on creation.
  * One of:
@@ -1071,4 +1074,11 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      * @tutorial Window.dispatchPopupResult
      */
     dispatchPopupResult(data: any): Promise<void>;
+    /**
+     * Prints the contents of the window.
+     *
+     * @param options Configuration for the print task.
+     * @tutorial Window.print
+     */
+    print(options?: OpenFin.WindowPrintOptions): Promise<void>;
 }

package/src/api/window/Instance.js

@@ -341,6 +341,9 @@ const view_1 = require("../view");
  * _Note: Caveats of small windows are no Aero Snap and drag to/from maximize._
  * _Windows 10: Requires `maximizable` to be false. Resizing with the mouse is only possible down to 38x39 px._
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the window.
+ *
  * @property {string} [state="normal"]
  * The visible state of the window on creation.
  * One of:
@@ -1317,5 +1320,24 @@ class _Window extends main_1.WebContents {
         });
         await this.wire.sendAction('dispatch-popup-result', { data, ...this.identity });
     }
+    /**
+     * Prints the contents of the window.
+     *
+     * @param options Configuration for the print task.
+     * @tutorial Window.print
+     */
+    async print(options = { content: 'self' }) {
+        switch (options.content) {
+            case undefined:
+            case 'self':
+                return super.print(options);
+            case 'screenshot':
+                return this.wire.sendAction('print-screenshot', this.identity).then(() => undefined);
+            case 'views':
+                return this.wire.sendAction('print-views', { ...this.identity, options }).then(() => undefined);
+            default:
+                return undefined;
+        }
+    }
 }
 exports._Window = _Window;

package/src/environment/mockEnvironment.d.ts

@@ -0,0 +1,27 @@
+import { Environment } from './environment';
+import type * as OpenFin from '../OpenFin';
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../OpenFin';
+export declare class MockEnvironment implements Environment {
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    getManagerConstructor(): Promise<any>;
+    getProviderInitializer(): Promise<any>;
+    observeBounds(): never;
+    writeToken(path: string, token: string): Promise<string>;
+    retrievePort(config: NewConnectConfig): Promise<number>;
+    getNextMessageId(): string;
+    getRandomId(): string;
+    createChildContent(options: any): Promise<any>;
+    getWebWindow(identity: OpenFin.Identity): globalThis.Window;
+    getCurrentEntityIdentity(): OpenFin.EntityInfo;
+    getCurrentEntityType(): EntityType;
+    raiseEvent(eventName: string, eventArgs: any): void;
+    getUrl(): string;
+    whenReady(): Promise<void>;
+    childViews: boolean;
+    getWsConstructor(): any;
+}

package/src/environment/mockEnvironment.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEnvironment = void 0;
+const me_1 = require("../api/me");
+class MockEnvironment {
+    constructor() {
+        this.childViews = true;
+    }
+    getDefaultChannelOptions() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRtcPeer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    async getManagerConstructor() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    async getProviderInitializer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    observeBounds() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    writeToken(path, token) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    retrievePort(config) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getNextMessageId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRandomId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    createChildContent(options) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWebWindow(identity) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityIdentity() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityType() {
+        return 'unknown';
+    }
+    raiseEvent(eventName, eventArgs) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getUrl() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    whenReady() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWsConstructor() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.MockEnvironment = MockEnvironment;

package/src/mock.js

@@ -1,94 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fin = void 0;
-/* eslint-disable import/prefer-default-export */
-/* eslint-disable spaced-comment */
-/* eslint-disable @typescript-eslint/triple-slash-reference */
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-/* eslint-disable class-methods-use-this */
-const events_1 = require("events");
 const OpenFin = require("./OpenFin");
 const fin_1 = require("./api/fin");
 const transport_1 = require("./transport/transport");
-const me_1 = require("./api/me");
-class MockWire extends events_1.EventEmitter {
-    connect(address) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    connectSync() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    send(data) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    shutdown() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    getPort() {
-        throw new Error('This transport has no port');
-    }
-    // eslint-disable-next-line no-useless-constructor
-    constructor() {
-        super();
-    }
-}
-class MockEnvironment {
-    constructor() {
-        this.childViews = true;
-    }
-    getDefaultChannelOptions() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRtcPeer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getManagerConstructor() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getProviderInitializer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    writeToken(path, token) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    retrievePort(config) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getNextMessageId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRandomId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    createChildContent(options) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWebWindow(identity) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityIdentity() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityType() {
-        return 'unknown';
-    }
-    raiseEvent(eventName, eventArgs) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getUrl() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    whenReady() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWsConstructor() {
-        throw new Error('Method not implemented.');
-    }
-}
+const mockEnvironment_1 = require("./environment/mockEnvironment");
+const mockWire_1 = require("./transport/mockWire");
 exports.fin = ((typeof window !== 'undefined' && (window === null || window === void 0 ? void 0 : window.fin)) ||
     (() => {
-        const environment = new MockEnvironment();
-        const transport = new transport_1.Transport(MockWire, environment, {
+        const environment = new mockEnvironment_1.MockEnvironment();
+        const transport = new transport_1.Transport(mockWire_1.MockWire, environment, {
             uuid: '',
             name: ''
         });

package/src/shapes/protocol.d.ts

@@ -37,6 +37,22 @@ export interface ProtocolMap extends ProtocolMapBase {
     }>;
     'trigger-before-unload': IdentityCall<{}, boolean>;
     'window-get-views': IdentityCall<{}, OpenFin.Identity[]>;
+    'print': {
+        request: OpenFin.Identity & {
+            options: OpenFin.PrintOptions;
+        };
+        response: void;
+    };
+    'print-screenshot': {
+        request: OpenFin.Identity;
+        response: void;
+    };
+    'print-views': {
+        request: OpenFin.Identity & {
+            options: OpenFin.WindowViewsPrintOptions;
+        };
+        response: void;
+    };
     'launch-manifest': {
         request: {
             manifestUrl: string;
@@ -148,6 +164,7 @@ export interface ProtocolMap extends ProtocolMapBase {
         request: void;
         response: OpenFin.PrinterInfo[];
     };
+    'system-register-shutdown-handler': VoidCall;
 }
 type ApiCall<Request, Response> = {
     request: Request;

package/src/transport/mockWire.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Wire } from './wire';
+export declare class MockWire extends EventEmitter implements Wire {
+    connect(address: string): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+    getPort(): string;
+    constructor();
+}

package/src/transport/mockWire.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWire = void 0;
+const events_1 = require("events");
+class MockWire extends events_1.EventEmitter {
+    connect(address) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    connectSync() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    send(data) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    shutdown() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    getPort() {
+        throw new Error('This transport has no port');
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() {
+        super();
+    }
+}
+exports.MockWire = MockWire;

package/src/transport/transport-errors.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { ErrorPlainObject } from '../util/errors';
 export type ReadyState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
 export declare class DisconnectedError extends Error {
@@ -18,6 +19,13 @@ export type RuntimeErrorPayload = {
     reason: string;
     error?: ErrorPlainObject;
 };
+declare class InternalError<T extends ErrorPlainObject = ErrorPlainObject> extends Error {
+    constructor(err: T);
+}
 export declare class RuntimeError extends Error {
-    constructor(payload: RuntimeErrorPayload);
+    cause?: InternalError;
+    static getCallSite(callsToRemove?: number): NodeJS.CallSite[];
+    static prepareStackTrace(err: Error, callSites: NodeJS.CallSite[]): string;
+    constructor(payload: RuntimeErrorPayload, callSites?: NodeJS.CallSite[]);
 }
+export {};

package/src/transport/transport-errors.js

@@ -23,13 +23,56 @@ exports.NotImplementedError = NotImplementedError;
 class NotSupportedError extends Error {
 }
 exports.NotSupportedError = NotSupportedError;
+class InternalError extends Error {
+    constructor(err) {
+        const { message, name, stack, ...rest } = err;
+        super(message);
+        this.name = name || 'Error';
+        this.stack = stack !== null && stack !== void 0 ? stack : this.toString();
+        Object.keys(rest).forEach(key => {
+            this[key] = rest[key];
+        });
+    }
+}
+// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api
 class RuntimeError extends Error {
-    constructor(payload) {
+    static getCallSite(callsToRemove = 0) {
+        var _a, _b;
+        const length = Error.stackTraceLimit;
+        const realCallsToRemove = callsToRemove + 1; // remove this call;
+        Error.stackTraceLimit = length + realCallsToRemove;
+        // eslint-disable-next-line no-underscore-dangle
+        const _prepareStackTrace = Error.prepareStackTrace;
+        // This will be called when we access the `stack` property
+        Error.prepareStackTrace = (_, stack) => stack;
+        // stack is optional in non chromium contexts
+        const stack = (_b = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.slice(realCallsToRemove)) !== null && _b !== void 0 ? _b : [];
+        Error.prepareStackTrace = _prepareStackTrace;
+        Error.stackTraceLimit = length;
+        return stack;
+    }
+    static prepareStackTrace(err, callSites) {
+        if (typeof Error.prepareStackTrace === 'function') {
+            return Error.prepareStackTrace(err, callSites);
+        }
+        let string = "";
+        string += err.name || "Error";
+        string += `: ${err.message || ""}`;
+        for (const callSite of callSites) {
+            string += `\n    at ${callSite.toString()}`;
+        }
+        return string;
+    }
+    ;
+    constructor(payload, callSites) {
         const { reason, error } = payload;
         super(reason);
         this.name = 'RuntimeError';
         if (error === null || error === void 0 ? void 0 : error.stack) {
-            this.stack = error.stack;
+            this.cause = new InternalError(error);
+        }
+        if (callSites) {
+            this.stack = RuntimeError.prepareStackTrace(this, callSites);
         }
     }
 }

package/src/transport/transport.d.ts

@@ -1,20 +1,29 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import type * as OpenFin from '../OpenFin';
 import { ExistingConnectConfig, InternalConnectConfig, RemoteConfig, Wire, WireConstructor } from './wire';
 import { Environment } from '../environment/environment';
+import { RuntimeErrorPayload } from './transport-errors';
 import EventAggregator from '../api/events/eventAggregator';
 import { EntityTypeHelpers } from '../api/me';
 import { ProtocolMap } from '../shapes/protocol';
 import { NamedEvent } from '../api/events/base';
 import { ErrorPlainObject } from '../util/errors';
 type EntityType = OpenFin.EntityType;
+type SendActionResponse<T extends keyof ProtocolMap> = Message<{
+    data: ProtocolMap[T]['response'];
+} & ProtocolMap[T]['specialResponse']>;
 export type MessageHandler = (data: any) => boolean;
+export type CancellablePromise<T> = Promise<T> & {
+    cancel: (reason?: any) => void;
+};
+type NackHandler = (payloadOrMessage: RuntimeErrorPayload | string) => void;
 export declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
     #private;
     protected wireListeners: Map<number, {
         resolve: Function;
-        reject: Function;
+        handleNack: (payload: RuntimeErrorPayload) => void;
     }>;
     protected uncorrelatedListener: Function;
     me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
@@ -24,6 +33,8 @@ export declare class Transport<MeType extends EntityType = EntityType> extends E
     eventAggregator: EventAggregator;
     protected messageHandlers: MessageHandler[];
     constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
+    getFin(): OpenFin.Fin<MeType>;
+    registerFin(_fin: OpenFin.Fin<MeType>): void;
     connectSync: () => void;
     getPort: () => string;
     shutdown(): Promise<void>;
@@ -31,12 +42,11 @@ export declare class Transport<MeType extends EntityType = EntityType> extends E
     private connectRemote;
     connectByPort(config: ExistingConnectConfig): Promise<void>;
     private authorize;
-    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): Promise<Message<{
-        data: ProtocolMap[T]['response'];
-    } & ProtocolMap[T]['specialResponse']>>;
+    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): CancellablePromise<SendActionResponse<T>>;
+    protected nackHandler(payloadOrMessage: RuntimeErrorPayload | string, reject: Function, callSites?: NodeJS.CallSite[]): void;
     ferryAction(origData: any): Promise<Message<any>>;
     registerMessageHandler(handler: MessageHandler): void;
-    protected addWireListener(id: number, resolve: Function, reject: Function, uncorrelated: boolean): void;
+    protected addWireListener(id: number, resolve: Function, handleNack: NackHandler, uncorrelated: boolean): void;
     protected onmessage(data: Message<Payload>): void;
     protected handleMessage(data: Message<Payload>): boolean;
 }