@openfin/workspace-platform 4.2.0 → 4.6.0

package/common/src/api/protocol.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="openfin-adapter/fin" />
+/** The name of the channel for the centralized workspace protocol. */
+export declare const channelName = "__of_workspace_protocol__";
+/**
+ * All of the remote procedures that can be called in the
+ * Workspace Provider's address space.
+ *
+ * When adding a new channel action make sure to register a
+ * handler for the remote procedure in the Workspace Provider.
+ * All of the registered channel action handlers can be found here:
+ * @see link: [Provider Protocol Handlers](https://github.com/openfin/workspace/provider/src/api/protocol.ts)
+ */
+export declare enum ChannelAction {
+    RegisterStorefrontProvider = "register-storefront-provider",
+    DeregisterStorefrontProvider = "deregister-storefront-provider",
+    GetStorefrontProviders = "get-storefront-providers",
+    HideStorefront = "hide-storefront",
+    GetStorefrontProviderApps = "get-storefront-provider-apps",
+    GetStorefrontProviderLandingPage = "get-storefront-provider-landing-page",
+    GetStorefrontProviderFooter = "get-storefront-provider-footer",
+    GetStorefrontProviderNavigation = "get-storefront-provider-navigation",
+    LaunchStorefrontProviderApp = "launch-storefront-provider-app",
+    ShowStorefront = "show-storefront",
+    CreateStorefrontWindow = "create-storefront-window",
+    ShowHome = "show-home",
+    HideHome = "hide-home",
+    AssignHomeSearchContext = "assign-home-search-context",
+    GetLegacyPages = "get-legacy-pages",
+    GetLegacyWorkspaces = "get-legacy-workspaces"
+}
+export interface ChannelClient extends OpenFin.ChannelClient {
+    dispatch: (action: ChannelAction, payload: any) => Promise<any>;
+}
+/**
+ * Get a channel client for the centralized Workspace protocol.
+ *
+ * The channel client is automatically connected to the Workspace Provider,
+ * in which acts as a centralized location for executing Workspace API logic.
+ *
+ * The channel client can execute remote procedures on the provider via its `dispatch` function.
+ * A call to the `dispatch` function will block until the channel action has concluded execution
+ * in the Workspace Provider's address space.
+ * For a list of supported procedures, see the `ChannelAction` enum.
+ *
+ * @returns the channel client for the centralized workspace protocol.
+ */
+export declare const getChannelClient: () => Promise<ChannelClient>;
+/**
+ * Returns true if the current application was launched via a library (such as the Client APIs).
+ * Otherwise, returns false.
+ */
+export declare const isLaunchedViaLib: () => Promise<boolean>;
+/**
+ * Launches the Workspace Provider.
+ * If the Workspace Provider is already running, does nothing.
+ */
+export declare const launchProvider: () => Promise<void>;
+/**
+ * Launches the Workspace provider if it is not running.
+ * Then gets a Channel Client that is connected to the Workspace Provider.
+ * @returns the Channel Client that is connected to the Workspace Provider.
+ */
+export declare const getChannelClientAndLaunchProvider: () => Promise<ChannelClient>;

package/common/src/api/theming.d.ts

@@ -0,0 +1,60 @@
+import type { ThemePaletteSet } from '@openfin/ui-library';
+export interface ComputedThemes extends Array<ComputedTheme> {
+}
+export interface ComputedTheme {
+    label: string;
+    logoUrl?: string;
+    theme: ThemePaletteSet;
+}
+export interface CustomThemes extends Array<CustomThemeOptions> {
+}
+export interface CustomThemeOptions {
+    label: string;
+    logoUrl?: string;
+    palette: CustomPaletteSet;
+}
+export interface DefaultPaletteSet {
+    brandPrimary: string;
+    brandSecondary: string;
+    backgroundPrimary: string;
+}
+export interface CustomPaletteSet extends DefaultPaletteSet {
+    functional1?: string;
+    functional2?: string;
+    functional3?: string;
+    functional4?: string;
+    functional5?: string;
+    functional6?: string;
+    functional7?: string;
+    functional8?: string;
+    functional9?: string;
+    functional10?: string;
+    statusSuccess?: string;
+    statusWarning?: string;
+    statusCritical?: string;
+    statusActive?: string;
+    inputBg?: string;
+    inputColor?: string;
+    inputPlaceholder?: string;
+    inputDisabled?: string;
+    inputFocused?: string;
+    textDefault?: string;
+    textHelp?: string;
+    textInactive?: string;
+    background1?: string;
+    background2?: string;
+    background3?: string;
+    background4?: string;
+    background5?: string;
+    background6?: string;
+}
+/**
+ * computeThemes()
+ * Accepts the array of registered CustomThemes objects
+ * Creates a light and dark palette from a tempalte overriding with custom options
+ * Uses createTheme to build theme object
+ * Creates a ThemePaletteSet
+ * @param customPalettes
+ * @returns theme object ready to be applied to the UI
+ */
+export declare const computeThemes: (customPalettes: CustomThemes) => ComputedThemes;

package/common/src/api/workspaces/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="openfin-adapter/fin" />
+export interface Workspace {
+    workspaceId: string;
+    title: string;
+    snapshot: OpenFin.Snapshot;
+}
+export declare const getLegacyWorkspaces: () => Promise<Workspace[]>;

package/common/src/utils/application.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="openfin-adapter/fin" />
+export declare enum ApplicationUUID {
+    /**
+     * The UUID of workspace.
+     * Home is a part of this application.
+     */
+    Workspace = "openfin-browser"
+}
+export interface ApplicationEvent {
+    viewIdentity?: OpenFin.Identity;
+    name?: string;
+    uuid?: string;
+}
+export declare type ApplicationListener = (ev: ApplicationEvent) => void;
+export declare enum ApplicationEventType {
+    RunRequested = "run-requested",
+    WindowOptionsChanged = "window-options-changed",
+    WindowClosed = "window-closed",
+    WindowCreated = "window-created"
+}
+export declare enum LaunchModeType {
+    FinProtocol = "fin-protocol"
+}
+export declare type ApplicationInfoExtended = OpenFin.ApplicationInfo & {
+    initialOptions: OpenFin.ApplicationInfo['initialOptions'] & {
+        userAppConfigArgs: any;
+    };
+};
+export declare const currentOFAppIdentity: {
+    uuid: string;
+    name: string;
+};
+export declare const workspaceOFAppIdentity: {
+    name: ApplicationUUID;
+    uuid: ApplicationUUID;
+};
+export declare const getCurrentOFApplication: () => import("openfin-adapter").Application;
+export declare const getWorkspaceOFApplication: () => import("openfin-adapter").Application;

package/common/src/utils/channels.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Make a function that connects to a channel.
+ * If already connected to the channel, will return the channel connection.
+ * If disconnected from the channel, will automatically reconnect.
+ * @param channelName the name of the channel to connect to.
+ * @returns the function to connect to the channel.
+ */
+export default function makeGetChannelClient(channelName: string): () => Promise<import("openfin-adapter").ChannelClient>;

package/common/src/utils/debounce.d.ts

@@ -0,0 +1,16 @@
+declare const makeDebouncedFunc: <T extends (...args: any[]) => Promise<any>>(func: T, debounceTimeout?: number) => T;
+/**
+ * Debounce a specified function.
+ *
+ * When the debounced function is called, the underlying wrapped function
+ * will be called.
+ *
+ * If the function is called again while the promise returned by the wrapped
+ * function is still resolving, the call will be blocked until the promise has
+ * resolved.
+ *
+ * Once the promise has been resolved, the wrapped function will be called again
+ * after a specified debounce timeout.
+ *
+ */
+export default makeDebouncedFunc;

package/common/src/utils/env.d.ts

@@ -0,0 +1,30 @@
+export declare enum Env {
+    Local = "local",
+    Dev = "dev",
+    Staging = "staging",
+    Prod = "prod"
+}
+export declare const isFin: boolean;
+export declare const isJest: boolean;
+export declare const isWindowDefined: boolean;
+export declare const isDocumentDefined: boolean;
+export declare const isWindowDefinedWithIndexDB: boolean;
+export declare const finUUID: string;
+export declare const finName: string;
+export declare const finEntityType: "" | import("openfin-adapter/src/shapes/EntityType").EntityType;
+export declare const env: Env;
+export declare const isEnvLocal: boolean;
+export declare const isEnvDev: boolean;
+export declare const isEnvStaging: boolean;
+export declare const isEnvProd: boolean;
+export declare const isLibrary: boolean;
+export declare const workspaceProviderFinsLink: string;
+export declare const workspaceProviderFallbackUrl: string;
+export declare const workspaceAppsUrl: string;
+export declare const workspaceStorefrontFooterUrl: string;
+export declare const workspaceStorefrontLandingPageUrl: string;
+export declare const workspaceStorefrontNavigationUrl: string;
+export declare const workspaceShareUrl: string;
+export declare const workspaceCdnUrl: string;
+export declare const workspaceCdnEnvUrl: string;
+export declare const workspaceRuntimeVersion: string;

package/common/src/utils/layout.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="openfin-adapter/fin" />
+export declare type LayoutComponentStateExtended = OpenFin.LayoutComponent['componentState'] & {
+    name: string;
+    uuid: string;
+};
+export declare type LayoutComponentExtended = Omit<OpenFin.LayoutComponent, 'componentState'> & {
+    componentState: LayoutComponentStateExtended;
+};
+export declare type LayoutStack = {
+    type: 'stack';
+    content: OpenFin.LayoutContent;
+};
+export declare type LayoutContentItemExtended = OpenFin.LayoutRow | OpenFin.LayoutColumn | LayoutComponentExtended | LayoutStack;
+export declare type LayoutContentExtended = LayoutContentItemExtended[];
+export declare type LayoutSettingsExtended = OpenFin.LayoutOptions['settings'] & {
+    reorderEnabled?: boolean;
+};
+export declare type LayoutExtended = {
+    settings?: LayoutSettingsExtended;
+    content: LayoutContentExtended;
+};
+export declare enum LayoutDOMEventType {
+    TabCreated = "tab-created",
+    ContainerCreated = "container-created",
+    ContainerResized = "container-resized"
+}
+export interface LayoutDOMEvent {
+    type: LayoutDOMEventType;
+    detail: {
+        containerSelector: string;
+        tabSelector: string;
+    };
+    isInitialized: boolean;
+}
+export declare type LayoutDOMEventListener = (ev: LayoutDOMEvent) => void;
+/**
+ * Deep clones a layout and removes view names.
+ * @param layout The Layout to be cloned
+ * @returns A copy of the layout with names removed
+ */
+export declare const cloneLayoutAndRemoveNames: (layout: any) => any;
+export declare const mapContentComponentState: (content: OpenFin.LayoutContent | LayoutContentExtended) => LayoutComponentStateExtended[];
+export declare const getLayoutWithSingleView: (title: string, url: string) => Promise<any>;
+export declare const isLayoutTabActive: (tabSelector: string) => boolean;
+export declare const containerId = "layout_container";
+export declare const getViewComponents: () => LayoutContentExtended;
+export declare const removeLayoutView: (name: string) => Promise<void>;
+export declare const addLayoutEventListener: (event: LayoutDOMEventType, listener: LayoutDOMEventListener) => void;
+/**
+ * Initialize the layout for the current OF window.
+ */
+export declare const initLayout: () => Promise<void>;

package/common/src/utils/local-storage-key.d.ts

@@ -0,0 +1,8 @@
+declare enum LocalStorageKey {
+    LastLaunchedWorkspaceId = "activeWorkspaceId",
+    LastFocusedBrowserWindow = "lastFocusedBrowserWindow",
+    MachineName = "machineName",
+    NewTabPageLayout = "NewTabPageLayout",
+    NewTabPageSort = "NewTabPageSort"
+}
+export default LocalStorageKey;

package/common/src/utils/logger/index.d.ts

@@ -0,0 +1,26 @@
+import { LogLocal } from './shapes';
+/**
+ * Responsible of capturing log information locally and centrally alongside the logs of other windows/views.
+ *
+ * **Warning: if you don't specify a name then it will still log out your messages but it becomes harder to distinguish where the log entry came from**
+ *
+ * Basic usage example:
+ *
+ * ```ts
+ * import logger from '../utils/logger';
+ *   const log = logger("My Component");
+ *
+ *   log.info("Initialised.");
+ * ```
+ * More information can be found [here](https://github.com/openfin/browser/blob/main/docs/Logging.md)
+ * @param name  Specify a name for this logger that will be the prefix of all log messages.
+ * @param logLocal  Specify an object to say what loglevel should be logged to the local window console e.g. { info: true }.
+ */
+export default function logger(name?: string, logLocal?: LogLocal): {
+    trace: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, error?: any, ...args: any[]) => void;
+    fatal: (message: string, error?: any, ...args: any[]) => void;
+};

package/common/src/utils/logger/manager.d.ts

@@ -0,0 +1,35 @@
+import { LogEntry, LogOptions } from './shapes';
+declare class LogInterface {
+    private worker;
+    private name;
+    private requestResponseHandler;
+    private errorListeners;
+    constructor();
+    getLogs(fromId?: number): Promise<LogEntry[]>;
+    trace(message: string, sourceName?: string, args?: any[]): void;
+    debug(message: string, sourceName?: string, args?: any[]): void;
+    info(message: string, sourceName?: string, args?: any[]): void;
+    warn(message: string, sourceName?: string, args?: any[]): void;
+    error(message: string, error?: any, sourceName?: string, args?: any[]): void;
+    fatal(message: string, error?: any, sourceName?: string, args?: any[]): void;
+    configure(options: LogOptions): void;
+    onLogError(listener: (error: Error) => void): void;
+    removeListener(listener: (...args: unknown[]) => void): void;
+    private log;
+    private listener;
+}
+/**
+ * Responsible for managing the way logging behaves and retrieving logs. Additionally exposes logging functions but logger should be used for logging.
+ *
+ * Basic usage example:
+ *
+ * ```ts
+ * import logManager from '../utils/log-manager';
+ *
+ * const logs = await logManager.getLogs();
+ *
+ * ```
+ * More information can be found [here](https://github.com/openfin/browser/blob/main/docs/Logging.md)
+ */
+declare let instance: LogInterface | undefined;
+export default instance;

package/common/src/utils/logger/shapes.d.ts

@@ -0,0 +1,27 @@
+export declare type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export interface LogOptions {
+    instanceId?: string;
+    auditLimit?: number;
+    auditLevel?: LogLevel;
+    logLevel?: LogLevel;
+}
+export declare type LogLocal = {
+    [key in LogLevel]?: boolean;
+};
+export interface LogEntry {
+    id?: number;
+    level: LogLevel;
+    name: string;
+    source?: string;
+    message: string;
+    error?: string;
+    ts?: number;
+    data?: any[];
+}
+export interface GetLogOptions {
+    from?: number;
+    responseId: number;
+}
+export declare const LogColors: {
+    [key in LogLevel]: string;
+};

package/common/src/utils/route.d.ts

@@ -0,0 +1,55 @@
+/**
+ * All routes that serve HTML pages for the app.
+ * Routes should include the zone the the HTML page is a part of.
+ * Make sure to include trailing slash, as it is essential for deployed version to route correctly.
+ */
+export declare enum PageRoute {
+    HomeIndex = "/home/",
+    HomeSearch = "/home/search/",
+    HomePagesRename = "/home/pages/rename/",
+    Dock = "/home/dock/",
+    BrowserPagesLanding = "/browser/pages/landing/",
+    HomeIndicator = "/home/indicator/",
+    Browser = "/browser/",
+    BrowserPopupMenu = "/browser/popup-menu/",
+    Provider = "/provider/",
+    BrowserPopupMenuSharePage = "/browser/popup-menu/share-page/",
+    BrowserPopupMenuSavePage = "/browser/popup-menu/save-page/",
+    BrowserPopupMenuLayouts = "/browser/popup-menu/layouts/layouts/",
+    BrowserPopupMenuColorLinking = "/browser/popup-menu/color-linking/color-linking/",
+    BrowserIndicator = "/browser/indicator/",
+    ResponseModal = "/browser/popup-menu/response-modal/",
+    Docs = "/provider/docs/",
+    Storefront = "/storefront/",
+    DeprecatedAlert = "/provider/deprecated-alert/"
+}
+/**
+ * All routes that serve assets. (icons, json, etc.)
+ */
+export declare enum AssetRoute {
+    IconOpenFinLogo = "/icons/openfinlogo.svg",
+    IconFilter = "/icons/filter.svg"
+}
+declare const _default: {
+    HomeIndex: PageRoute.HomeIndex;
+    HomeSearch: PageRoute.HomeSearch;
+    HomePagesRename: PageRoute.HomePagesRename;
+    Dock: PageRoute.Dock;
+    BrowserPagesLanding: PageRoute.BrowserPagesLanding;
+    HomeIndicator: PageRoute.HomeIndicator;
+    Browser: PageRoute.Browser;
+    BrowserPopupMenu: PageRoute.BrowserPopupMenu;
+    Provider: PageRoute.Provider;
+    BrowserPopupMenuSharePage: PageRoute.BrowserPopupMenuSharePage;
+    BrowserPopupMenuSavePage: PageRoute.BrowserPopupMenuSavePage;
+    BrowserPopupMenuLayouts: PageRoute.BrowserPopupMenuLayouts;
+    BrowserPopupMenuColorLinking: PageRoute.BrowserPopupMenuColorLinking;
+    BrowserIndicator: PageRoute.BrowserIndicator;
+    ResponseModal: PageRoute.ResponseModal;
+    Docs: PageRoute.Docs;
+    Storefront: PageRoute.Storefront;
+    DeprecatedAlert: PageRoute.DeprecatedAlert;
+    IconOpenFinLogo: AssetRoute.IconOpenFinLogo;
+    IconFilter: AssetRoute.IconFilter;
+};
+export default _default;

package/common/src/utils/shared-emitter.d.ts

@@ -0,0 +1,10 @@
+export declare type Listener = (...args: any[]) => void;
+/**
+ * Creates an event emitter that is shared between all windows within the same domain.
+ */
+export default function makeSharedEmitter<E extends string | number, L extends Listener>(id: string): {
+    emit: (event: E, ...payload: any[]) => Promise<void>;
+    addListener: (event: E, listener: L) => void;
+    removeListener: (event: E, listener: L) => void;
+    once: (event: E, listener: L) => void;
+};

package/common/src/utils/snapshot.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="openfin-adapter/fin" />
+export declare type SnapshotDetailsExtended = OpenFin.Snapshot['snapshotDetails'] & {
+    machineId: string;
+    machineName?: string;
+};
+export declare type SnapshotExtended = {
+    snapshotDetails: SnapshotDetailsExtended;
+    windows: OpenFin.WindowOptions[];
+};
+export declare type ApplySnapshotOptionsExtended = OpenFin.ApplySnapshotOptions & {
+    attachToExistingWindow: boolean;
+};
+/**
+ * Set a friendly name of the current machine.
+ * @param name the friendly name.
+ */
+export declare function setMachineName(name: string): void;
+/**
+ * Get the machine's friendly name.
+ * @returns the machine's friendly name.
+ */
+export declare function getMachineName(): string;
+/**
+ * Get the current machine ID.
+ * @returns the machine ID.
+ */
+export declare function getMachineId(): Promise<string>;
+/**
+ * Get a snapshot with extra snapshot details.
+ * @param snapshot the snapshot to extend.
+ * @returns the snapshot with more snapshot details.
+ */
+export declare function getSnapshotExtended(snapshot?: OpenFin.Snapshot): Promise<SnapshotExtended>;

package/common/src/utils/strings.d.ts

@@ -0,0 +1,5 @@
+export declare const capitalize: (s: string) => string;
+export declare const titleize: (s: string) => string;
+export declare const pascalize: (s: string) => string;
+export declare const slugify: (s: string) => string;
+export declare const isStringMatchesQuery: (title: string, query?: string) => boolean;

package/common/src/utils/theming.d.ts

@@ -0,0 +1,57 @@
+import { CustomPaletteSet } from '@common/api/theming';
+/**
+ * Get hue from a CSS color
+ *
+ * The getHue function is used manage extracting hue from 3 types of css
+ * string input types. An object including hue, hsl, hsla, lightness and
+ * saturation are returned.
+ *
+ * Each function was copied css tricks and modified to fit this platform.
+ * Links above each function for technical details.
+ *
+ * Allowed formats:
+ *      RGB with or with out the alpha rgb(x,x,x) or rgba(x,x,x,x)
+ *      HEX 3 or 6 characters, plus hashtag #333 or #333333
+ *      HSL with or with out the alhpa hsl(x,x%,x%) or hsla(x,x%,x%,x)
+ *
+ * The hue value is used later to build an array of background colors in the
+ * theme that are various shades of the hue returned from this function.
+ *
+ * An invalid format should error telling the integrator how to fix the error.
+ * - Error for missing required options
+ * - Error for invalid css strings that are unable to be processed
+ *
+ * @param colorInput string - Supported formats rgb/RGB/rgba/RGBA, #000/#000000, hsl/HSL/hsla/HSLA
+ * @returns hue as string
+ */
+export declare const getHue: (colorInput: string) => string;
+export declare const makeBackgroundLayers: (hue: string) => {
+    light: {
+        background1: string;
+        background2: string;
+        background3: string;
+        background4: string;
+        background5: string;
+        background6: string;
+    };
+    dark: {
+        background1: string;
+        background2: string;
+        background3: string;
+        background4: string;
+        background5: string;
+        background6: string;
+    };
+};
+/**
+ * makePalette() - generic - doesn't care about scheme
+ *
+ * Accepts a default palette object, and a custom palette object.
+ * The default object gets overrides from customPalette and returns a new palette object.
+ * @param defaultPalette
+ * @param customPalette
+ * @returns { light: newPalette, dark: newPalette }
+ *
+ * TODO: DefaultPaletteSet isn't working, need to redo.
+ */
+export declare const makePalette: (defaultPalette: any, customPalette: CustomPaletteSet) => CustomPaletteSet;

package/common/src/utils/umd.d.ts

@@ -0,0 +1,2 @@
+declare const injectAPI: (namespace: string, api: any) => void;
+export default injectAPI;