@openfin/core 31.74.7 → 31.74.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "31.74.7",
+    "version": "31.74.8",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/OpenFin.d.ts

@@ -1,21 +1,23 @@
-import type { Application } from './api/application';
+import type { Application } from './api/application/index';
 import { AppVersionEvent } from './api/events/system';
 import { TypedEventEmitter } from './api/events/typedEventEmitter';
-import type { ExternalApplication } from './api/external-application';
+import type { ExternalApplication } from './api/external-application/index';
 import { FinApi } from './api/fin';
-import type { _Frame } from './api/frame';
+import type { _Frame } from './api/frame/index';
 import type ChannelClient from './api/interappbus/channel/client';
-import { MessagingProtocols } from './api/interappbus/channel/protocols';
+import { MessagingProtocols } from './api/interappbus/channel/protocols/index';
 import type { ChannelProvider } from './api/interappbus/channel/provider';
-import type { InteropBroker, InteropClient } from './api/interop';
-import type { Platform } from './api/platform';
-import type { Layout } from './api/platform/layout';
+import type { InteropBroker, InteropClient } from './api/interop/index';
+import type { Platform } from './api/platform/index';
+import type { Layout } from './api/platform/layout/index';
 import { PlatformProvider } from './api/platform/provider';
-import { SnapshotSource } from './api/snapshot-source';
-import type { View } from './api/view';
-import { _Window } from './api/window';
+import { SnapshotSource } from './api/snapshot-source/index';
+import type { View } from './api/view/index';
+import { _Window } from './api/window/index';
+import { ColumnOrRow, TabStack } from './api/platform/layout/entities/layout-entities';
 export type Fin<MeType extends EntityType = 'window' | 'view'> = FinApi<MeType>;
-export type { Application, ExternalApplication, _Frame as Frame, ChannelClient, ChannelProvider, Platform, Layout, View, _Window as Window, InteropClient, InteropBroker, SnapshotSource };
+export type { Application, ExternalApplication, _Frame as Frame, ChannelClient, ChannelProvider, Platform, Layout, View, ColumnOrRow, TabStack, _Window as Window, InteropClient, InteropBroker, SnapshotSource };
+export type { LayoutEntityDefinition, LayoutEntityTypes, LayoutPosition } from './api/platform/layout/entities/shapes';
 export type WebContent = View | _Window;
 export type { PlatformProvider };
 export type ApplicationIdentity = {
@@ -1330,6 +1332,22 @@ export type ApplySnapshotPayload = {
      */
     options?: ApplySnapshotOptions;
 };
+export type AddViewToStackOptions = {
+    /**
+     * Optional index within the stack to insert the view. Defaults to 0
+     */
+    index?: number;
+};
+export type CreateViewTarget = Identity & {
+    /**
+     * If specified, view creation will not attach to a window and caller must
+     * insert the view into the layout explicitly
+     */
+    location?: {
+        id: string;
+        index?: number;
+    };
+};
 export type CreateViewPayload = {
     /**
      * Options for the view to be added.
@@ -1338,7 +1356,7 @@ export type CreateViewPayload = {
     /**
      * Window the view will be added to. If no target is provided, a new window will be created.
      */
-    target: Identity;
+    target?: CreateViewTarget;
     targetView?: Identity;
 };
 export type ReplaceViewPayload = {
@@ -1460,10 +1478,7 @@ export type PlatformWindowOptions = WindowCreationOptions & {
      */
     stylesheetUrl: string;
 };
-export type PlatformViewCreationOptions = Partial<ViewOptions> & {
-    url: string;
-    target: Identity;
-};
+export type PlatformViewCreationOptions = Partial<ViewOptions>;
 /**
  * Strategy to assign views to process affinity by domain.
  *
@@ -2199,6 +2214,22 @@ export type FindInPageOptions = {
      */
     medialCapitalAsWordStart?: boolean;
 };
+export type FindInPageResult = {
+    requestId: number;
+    /**
+     * Position of the active match.
+     */
+    activeMatchOrdinal: number;
+    /**
+     * Number of Matches.
+     */
+    matches: number;
+    /**
+     * Coordinates of first match region.
+     */
+    selectionArea: Rectangle;
+    finalUpdate: boolean;
+};
 export type FrameInfo = {
     name: string;
     uuid: string;
@@ -2940,3 +2971,24 @@ export interface InteropActionLoggingOption {
 export type InteropLoggingActions = 'beforeAction' | 'afterAction';
 export type InteropLoggingOptions = Record<InteropLoggingActions, InteropActionLoggingOption>;
 export type { Me } from './api/me';
+/**
+ * Configuration for page capture.
+ */
+export interface CapturePageOptions {
+    /**
+     * The area of the window to be captured.
+     */
+    area?: 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;
+}

package/src/api/api-exposer/api-consumer.d.ts

@@ -0,0 +1,28 @@
+import { ExposedProp } from "./decorators";
+export type ConsumeStrategy<TMetaConsumeOptions, TPropConsumeDefinition> = {
+    getExposedFunctions: (options: TMetaConsumeOptions) => Promise<ExposedProp<TPropConsumeDefinition>[]>;
+    createFunction: (options: ExposedProp<TPropConsumeDefinition>, meta: TMetaConsumeOptions) => Function;
+};
+type PickOfType<T extends Record<any, any>, TTarget> = {
+    [key in keyof T as T[key] extends TTarget | undefined ? key : never]: T[key];
+};
+export type ApiClient<T extends Record<any, any>> = {
+    [key in keyof PickOfType<T, Function>]: (...args: Parameters<T[key]>) => ReturnType<T[key]> extends Promise<any> ? ReturnType<T[key]> : Promise<ReturnType<T[key]>>;
+};
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+export declare class ApiConsumer<TMetaConsumeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    constructor(strategy: ConsumeStrategy<TMetaConsumeOptions, TPropConsumptionOptions>);
+    /**
+     * Consumes an api exposed using a given transport strategy, and generates a client
+     * for easy, type safe consumption of that client.
+     * @param options Strategy specific consumption options.
+     * @returns An api client matching the given type.
+     */
+    consume: <T extends Record<any, any>>(options: TMetaConsumeOptions) => Promise<ApiClient<T>>;
+}
+export {};

package/src/api/api-exposer/api-consumer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
+    }
+}
+exports.ApiConsumer = ApiConsumer;

package/src/api/api-exposer/api-exposer.d.ts

@@ -0,0 +1,35 @@
+import { ExposedProp } from './decorators';
+export type ConsumptionConfig<T> = {
+    key: string;
+    options: T;
+};
+export type ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumeOptions> = {
+    /**
+     * Exposes the given function on the strategy.
+     */
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: TPropExposeOptions;
+        meta: TInstanceExposeOptions;
+    }) => Promise<TPropConsumeOptions>;
+    /**
+     * Exposes metadata to enable creation of client objects.
+     */
+    exposeMeta: (instanceOptions: TInstanceExposeOptions, props: ExposedProp<TPropConsumeOptions>[]) => Promise<void>;
+};
+/**
+ * Exposes api services on the transport of choice.
+ */
+export declare class ApiExposer<TInstanceExposeOptions = any, TPropExposeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    constructor(strategy: ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumptionOptions>);
+    /**
+     * Exposes an instance of a given api on
+     * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+     * @param instanceOptions Transport strategy specific options to use when exposing.
+     */
+    exposeInstance: (instance: Record<any, any>, instanceOptions: TInstanceExposeOptions) => Promise<void>;
+}

package/src/api/api-exposer/api-exposer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExposer = void 0;
+const decorators_1 = require("./decorators");
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
+    }
+    ;
+}
+exports.ApiExposer = ApiExposer;

package/src/api/api-exposer/decorators.d.ts

@@ -0,0 +1,10 @@
+export type ExposedProp<T> = {
+    key: string;
+    options: T;
+};
+export declare const getExposedProperties: <T>(target: Record<any, any>) => ExposedProp<T>[];
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+export declare const expose: <T = undefined>(options?: T) => any;

package/src/api/api-exposer/decorators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+exports.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+exports.expose = expose;

package/src/api/api-exposer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-consumer';
+export * from './api-exposer';
+export * from './strategies';
+export * from './decorators';

package/src/api/api-exposer/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-consumer"), exports);
+__exportStar(require("./api-exposer"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./decorators"), exports);

package/src/api/api-exposer/strategies/index.d.ts

@@ -0,0 +1 @@
+export * from './openfin-channels';

package/src/api/api-exposer/strategies/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openfin-channels"), exports);

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.d.ts

@@ -0,0 +1,14 @@
+import { ConsumeStrategy } from "../../api-consumer";
+import { ExposedProp } from "../../decorators";
+export type ChannelConsumeOptions = {
+    id: string;
+};
+export type ChannelsPropConfig = {
+    action: string;
+};
+export declare class ChannelsConsumer implements ConsumeStrategy<ChannelConsumeOptions, ChannelsPropConfig> {
+    private channel;
+    constructor(channel: any);
+    getExposedFunctions: (options: ChannelConsumeOptions) => Promise<ExposedProp<ChannelsPropConfig>[]>;
+    createFunction: (prop: ExposedProp<ChannelsPropConfig>) => Function;
+}

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
+    }
+    ;
+}
+exports.ChannelsConsumer = ChannelsConsumer;

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.d.ts

@@ -0,0 +1,20 @@
+import { ExposeStrategy } from '../../api-exposer';
+import { ExposedProp } from '../../decorators';
+import { ChannelsPropConfig } from './channels-consumer';
+type ChannelInstanceExposeOptions = {
+    id: string;
+};
+export type ChannelsPropOptions = {
+    action?: string;
+} | undefined;
+export declare class ChannelsExposer implements ExposeStrategy<ChannelInstanceExposeOptions, ChannelsPropOptions, ChannelsPropConfig> {
+    private channelProviderOrClient;
+    constructor(channelProviderOrClient: any);
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: ChannelsPropOptions;
+        meta: ChannelInstanceExposeOptions;
+    }) => Promise<ChannelsPropConfig>;
+    exposeMeta: ({ id }: ChannelInstanceExposeOptions, props: ExposedProp<ChannelsPropOptions>[]) => Promise<void>;
+}
+export {};

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${(options === null || options === void 0 ? void 0 : options.action) || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
+    }
+}
+exports.ChannelsExposer = ChannelsExposer;

package/src/api/api-exposer/strategies/openfin-channels/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channels-consumer';
+export * from './channels-exposer';

package/src/api/api-exposer/strategies/openfin-channels/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./channels-consumer"), exports);
+__exportStar(require("./channels-exposer"), exports);

package/src/api/application/Factory.js

@@ -203,8 +203,7 @@ class ApplicationModule extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         const app = await this._createFromManifest(manifestUrl);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore using private method without warning.
+        // @ts-expect-error using private method without warning.
         await app._run(opts); // eslint-disable-line no-underscore-dangle
         return app;
     }

package/src/api/application/Instance.js

@@ -141,11 +141,29 @@ class Application extends base_1.EmitterBase {
      * @tutorial Application.quit
      */
     async quit(force = false) {
-        await this._close(force);
-        await this.wire.sendAction('destroy-application', { force, ...this.identity });
-    }
-    _close(force = false) {
-        return this.wire.sendAction('close-application', { force, ...this.identity }).then(() => undefined);
+        try {
+            await this._close(force);
+            await this.wire.sendAction('destroy-application', { force, ...this.identity });
+        }
+        catch (error) {
+            const acceptableErrors = [
+                'Remote connection has closed',
+                'Could not locate the requested application'
+            ];
+            if (!acceptableErrors.some(msg => error.message.includes(msg))) {
+                throw error;
+            }
+        }
+    }
+    async _close(force = false) {
+        try {
+            await this.wire.sendAction('close-application', { force, ...this.identity });
+        }
+        catch (error) {
+            if (!error.message.includes('Remote connection has closed')) {
+                throw error;
+            }
+        }
     }
     close(force = false) {
         console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');

package/src/api/base.d.ts

@@ -2,14 +2,13 @@
 import { EventEmitter } from 'events';
 import { Transport } from '../transport/transport';
 import type * as OpenFin from '../OpenFin';
-import Fin from './fin';
 import { BaseEvent, EventHandler } from './events/base';
 type ApplicationIdentity = OpenFin.ApplicationIdentity;
 type Identity = OpenFin.Identity;
 export declare class Base {
     wire: Transport;
     constructor(wire: Transport);
-    protected get fin(): Fin;
+    protected get fin(): OpenFin.Fin<OpenFin.EntityType>;
     get me(): Identity;
     protected isNodeEnvironment: () => boolean;
     protected isOpenFinEnvironment: () => boolean;

package/src/api/events/base.d.ts

@@ -1,4 +1,3 @@
-import type * as OpenFin from '../../OpenFin';
 /**
  * Modifies an event key to reflect propagation by prefixing with the topic.
  */
@@ -13,8 +12,6 @@ export type PropagatedEvent<Topic extends string, Event extends {
     type: string;
 } ? Omit<E, 'type'> & {
     type: PropagatedEventType<Topic, E['type']>;
-} & {
-    [topic in `${Topic}Identity`]: OpenFin.Identity;
 } : never;
 /**
  * Handler for an event on an EventEmitter; selects the correct type for the event

package/src/api/events/system.d.ts

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../OpenFin';
 import { PropagatedApplicationEvent } from './application';
-import { BaseEvent } from './base';
+import { BaseEvent, IdentityEvent } from './base';
 import { PropagatedViewEvent } from './view';
 import { PropagatedWindowEvent } from './window';
 import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
@@ -38,7 +38,7 @@ export type EventWithId<Event extends AppVersionEvent> = Event extends infer E e
     appVersionId: string;
 } : never;
 export type AppVersionEventWithId = EventWithId<AppVersionEvent>;
-export type ApplicationCreatedEvent = BaseEvent & {
+export type ApplicationCreatedEvent = IdentityEvent & {
     type: 'application-created';
 };
 export type DesktopIconClickedEvent = BaseEvent & {

package/src/api/events/view.d.ts

@@ -1,15 +1,18 @@
 import type * as OpenFin from '../../OpenFin';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
 import { NamedEvent, PropagatedEvent } from './base';
+export type BaseViewEvent = {
+    target: OpenFin.Identity;
+    viewIdentity: OpenFin.Identity;
+};
 export type TargetChangedEvent = NamedEvent & {
     type: 'target-changed';
     previousTarget: OpenFin.Identity;
-    target: OpenFin.Identity;
 };
 /**
  * A View event that does not propagate to (republish on) parent topics.
  */
-export type NonPropagatedViewEvent = NonPropagatedWebContentsEvent;
+export type NonPropagatedViewEvent = BaseViewEvent & NonPropagatedWebContentsEvent;
 export type AttachedEvent = NamedEvent & {
     type: 'attached';
 };
@@ -31,7 +34,7 @@ export type ShownEvent = NamedEvent & {
 /**
  * A View event that does propagate to (republish on) parent topics.
  */
-export type WillPropagateViewEvent = WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent;
+export type WillPropagateViewEvent = BaseViewEvent & (WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent);
 export type ViewEvent = {
     topic: 'view';
 } & (NonPropagatedViewEvent | WillPropagateViewEvent);

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

@@ -64,6 +64,8 @@ export type DidFailLoadEvent = BaseLoadFailedEvent & {
 };
 export type FoundInPageEvent = NamedEvent & {
     type: 'found-in-page';
+} & {
+    result: OpenFin.FindInPageResult;
 };
 /**
  * A WebContents event that does not propagate to (republish on) parent topics.