@openfin/workspace-platform 20.0.2 → 20.0.5

package/browser/src/api/color-linking.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="lodash" />
+import type OpenFin from '@openfin/core';
+export declare enum ColorLinkingUiClass {
+    SHOW_INTEROP_GROUPS = "showInteropGroups",
+    HIGHLIGHT = "highlight"
+}
+export declare function getContextGroupColorForView(viewIdentity: OpenFin.Identity): Promise<OpenFin.DisplayMetadata | undefined>;
+export declare function isSameGroup(viewIdentity: OpenFin.Identity, groupId: string): Promise<boolean>;
+export declare function findActiveLayout(layoutContainerKey: string): HTMLElement;
+export declare function updateBorderColor(viewIdentity: OpenFin.Identity): Promise<void>;
+export declare const debouncedSetContextHighlighting: import("lodash").DebouncedFunc<(ids: OpenFin.Identity[], layoutContainerKey: string) => Promise<void>>;
+export declare function showBorder(viewIdentity: OpenFin.Identity): Promise<void>;
+export declare function highlightAllInteropViews(): Promise<void>;
+export declare function removeInteropOutlines(): void;
+/**
+ * Accepts a group of views and a channelId and updates group membership based on the following rules:
+ * - If all selected views are a member of group, remove them.
+ * - If one or more view is NOT a member of the group, add all to group.
+ * @param views Array of view identities
+ * @param channelId id of the channel for the group to be joined / removed from
+ * @returns Promise<void>
+ */
+export declare const updateContextGroup: (views: OpenFin.Identity[], channelId: string) => Promise<void>;

package/browser/src/api/controls.d.ts

@@ -0,0 +1,23 @@
+import type OpenFin from '@openfin/core';
+import { ShowBrowserIndicatorPayload } from '../../../common/src/utils/indicators/browser';
+import { AddToChannelRequest } from '../../../common/src/api/protocol/browser';
+import { OpenSaveMenuRequest } from '../../../client-api-platform/src/shapes';
+export declare const requestCloseBrowserWindow: () => Promise<void>;
+export declare const requestClosePage: (arg: import("@browser/slices/modal/close").ClosePageRequestPayload) => Promise<void>;
+/**
+ * Opens the save menu with the specified menu type provided and the ID to be saved
+ *
+ * @param menuType Provide one of the SaveModalType's to define the content to render
+ * @id id of the page or workspace to action against
+ */
+export declare const requestOpenSaveModal: ({ menuType, id }: OpenSaveMenuRequest) => Promise<OpenFin.Identity>;
+/**
+ * Creates a copy of a page in the same window.
+ * @param page The page to be duplicated
+ */
+export declare const requestDuplicatePage: (pageId: string) => Promise<void>;
+export declare const raiseJoinContextGroupAnalytics: (colorName: string, view: OpenFin.Identity) => void;
+export declare const requestAddToChannel: ({ newChannelId, selectedViews }: AddToChannelRequest) => void;
+export declare const raiseLeaveContextGroupAnalytics: (colorName: string, view: OpenFin.Identity) => void;
+export declare const requestRemoveFromChannel: (selectedViews: OpenFin.Identity[]) => void;
+export declare const requestShowBrowserIndicator: ({ type, message, parentBrowserName, secondaryMessage, icon, isEnterprise }: ShowBrowserIndicatorPayload) => Promise<void>;

package/browser/src/api/pages/attached.d.ts

@@ -0,0 +1,23 @@
+import type OpenFin from '@openfin/core';
+import { attachPagesToWindow as AttachPagesToWindowType, detachPagesFromWindow as DetachPagesFromWindowType, getPages as GetPagesType, renamePage as RenamePageType, reorderPagesForWindow as ReorderPagesForWindowType, setActivePageForWindow as SetActivePageForWindowType, updatePageForWindow as UpdatePageForWindowType } from '../../../../common/src/api/pages/attached';
+import type { AttachedPage } from '../../../../common/src/api/pages/shapes';
+/**
+ * Save the current attached page state in window options.
+ */
+export declare const updatePagesWindowOptions: () => Promise<void>;
+export declare const setActivePageForWindow: typeof SetActivePageForWindowType;
+export declare const getActivePageForWindow: () => Promise<AttachedPage>;
+export declare const renamePage: typeof RenamePageType;
+export declare const getPages: typeof GetPagesType;
+export declare const attachPagesToWindow: typeof AttachPagesToWindowType;
+export declare const detachPagesFromWindow: typeof DetachPagesFromWindowType;
+export declare const reorderPagesForWindow: typeof ReorderPagesForWindowType;
+export declare const updatePageForWindow: typeof UpdatePageForWindowType;
+export declare const isDetachingPages: () => boolean;
+export declare const isActivePageChanging: () => boolean;
+export declare const handleViewCrashed: ({ viewIdentity }: {
+    viewIdentity: OpenFin.Identity;
+}) => void;
+export declare const handleViewAttached: ({ viewIdentity }: {
+    viewIdentity: OpenFin.Identity;
+}) => Promise<void>;

package/browser/src/api/pages/state.d.ts

@@ -0,0 +1,10 @@
+import type { AnyAction } from 'redux';
+import type { ThunkDispatch } from 'redux-thunk';
+import { AttachedPagesRootState } from '../../../../browser/src/slices/pages/attached';
+declare let dispatchInstance: ThunkDispatch<unknown, unknown, AnyAction>;
+declare let getStateInstance: () => AttachedPagesRootState;
+export declare const getState: () => AttachedPagesRootState;
+export declare const dispatch: typeof dispatchInstance;
+export declare const setGetStateInstance: (instance: typeof getStateInstance) => void;
+export declare const setDispatchInstance: (instance: typeof dispatchInstance) => void;
+export {};

package/browser/src/api/panels.d.ts

@@ -0,0 +1,106 @@
+import type OpenFin from '@openfin/core';
+import { ExtendedPanelConfig, PanelPosition } from '../../../common/src/api/pages/shapes';
+export declare function attachPanelViews(panels?: ExtendedPanelConfig[]): Promise<void>;
+export declare function setUpPanelViews(panels?: ExtendedPanelConfig[], panelsToReplace?: ExtendedPanelConfig[]): Promise<void>;
+export declare function getPanelsWithViewSnapshots(panels?: ExtendedPanelConfig[]): Promise<({
+    viewOptions: {
+        uuid: string;
+        api?: OpenFin.ApiSettings;
+        name: string;
+        url: string;
+        target: OpenFin.Identity;
+        title?: string;
+        contentCreation?: OpenFin.ContentCreationOptions;
+        customRequestHeaders?: OpenFin.CustomRequestHeaders[];
+        bounds?: OpenFin.Bounds;
+        permissions?: Partial<OpenFin.Permissions>;
+        processAffinity?: string;
+        hotkeys?: OpenFin.Hotkey[];
+        preloadScripts?: OpenFin.PreloadScript[];
+        manifestUrl?: string;
+        zoomLevel?: number;
+        experimental?: any;
+        fdc3InteropApi?: string;
+        enableBeforeUnload?: boolean;
+        accelerator?: Partial<OpenFin.Accelerator>;
+        autoplayPolicy?: OpenFin.AutoplayPolicyOptions;
+        closeBehavior?: "hide" | "detach" | "destroy";
+        downloadShelf?: {
+            enabled: boolean;
+        };
+        excludeOptions?: OpenFin.ExcludeOptions;
+        autoResize?: OpenFin.AutoResizeOptions;
+        contextMenu?: boolean;
+        contextMenuSettings?: OpenFin.ContextMenuSettings;
+        contextMenuOptions?: OpenFin.ContextMenuOptions;
+        backgroundColor?: string;
+        customData?: any;
+        customContext?: any;
+        contentNavigation?: OpenFin.NavigationRules;
+        contentRedirect?: OpenFin.NavigationRules;
+        detachOnClose?: boolean;
+        isClosable?: boolean;
+        preventDragOut?: boolean;
+        interop?: OpenFin.InteropConfig;
+        _internalWorkspaceData?: any;
+        throttling?: OpenFin.ViewThrottling;
+        chromiumPolicies?: OpenFin.ChromiumPolicies;
+        componentName: "view";
+        initialUrl: string;
+        minWidth?: number;
+    };
+    position: PanelPosition.Top | PanelPosition.Bottom;
+    height: string;
+} | {
+    viewOptions: {
+        uuid: string;
+        api?: OpenFin.ApiSettings;
+        name: string;
+        url: string;
+        target: OpenFin.Identity;
+        title?: string;
+        contentCreation?: OpenFin.ContentCreationOptions;
+        customRequestHeaders?: OpenFin.CustomRequestHeaders[];
+        bounds?: OpenFin.Bounds;
+        permissions?: Partial<OpenFin.Permissions>;
+        processAffinity?: string;
+        hotkeys?: OpenFin.Hotkey[];
+        preloadScripts?: OpenFin.PreloadScript[];
+        manifestUrl?: string;
+        zoomLevel?: number;
+        experimental?: any;
+        fdc3InteropApi?: string;
+        enableBeforeUnload?: boolean;
+        accelerator?: Partial<OpenFin.Accelerator>;
+        autoplayPolicy?: OpenFin.AutoplayPolicyOptions;
+        closeBehavior?: "hide" | "detach" | "destroy";
+        downloadShelf?: {
+            enabled: boolean;
+        };
+        excludeOptions?: OpenFin.ExcludeOptions;
+        autoResize?: OpenFin.AutoResizeOptions;
+        contextMenu?: boolean;
+        contextMenuSettings?: OpenFin.ContextMenuSettings;
+        contextMenuOptions?: OpenFin.ContextMenuOptions;
+        backgroundColor?: string;
+        customData?: any;
+        customContext?: any;
+        contentNavigation?: OpenFin.NavigationRules;
+        contentRedirect?: OpenFin.NavigationRules;
+        detachOnClose?: boolean;
+        isClosable?: boolean;
+        preventDragOut?: boolean;
+        interop?: OpenFin.InteropConfig;
+        _internalWorkspaceData?: any;
+        throttling?: OpenFin.ViewThrottling;
+        chromiumPolicies?: OpenFin.ChromiumPolicies;
+        componentName: "view";
+        initialUrl: string;
+        minWidth?: number;
+    };
+    position: PanelPosition.Left | PanelPosition.Right;
+    width: string;
+    extendToTop?: boolean;
+    extendToBottom?: boolean;
+})[]>;
+export declare const handlePanelViewDetached: (e: OpenFin.WindowEvents.ViewDetachedEvent) => void;

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

@@ -0,0 +1,22 @@
+import type OpenFin from '@openfin/core';
+export declare function getOFView(identity: OpenFin.Identity): OpenFin.View;
+/**
+ * Creates a new View to the landing page at the end of the tab strip
+ * which includes the currently selected View
+ * @param view the currently selected View
+ */
+export declare const makeNewView: (view: OpenFin.View) => Promise<void>;
+/**
+ * Duplicates the current View at the end of the tab strip
+ * which includes the currently selected View
+ * @param view the currently selected View
+ */
+export declare const duplicateView: (view: OpenFin.View) => Promise<void>;
+/**
+ * Detaches the given OpenFin view.
+ * This allows for view pooling between windows.
+ *
+ * @param view the View to detach.
+ * @returns a promise that resolves when the View is detached.
+ */
+export declare const detachView: (view: OpenFin.View) => Promise<void>;

package/browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export declare const searchMenuIdentity: {
+    uuid: string;
+    name: string;
+};
+export type SearchViewExpansionState = {
+    method?: 'click' | 'keystroke';
+    shouldExpand: boolean;
+};
+export type SecureIconState = {
+    shouldShow: boolean;
+    isSecureSite: boolean;
+};
+declare const AddressBar: React.FC;
+export default AddressBar;

package/browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBarInput.d.ts

@@ -0,0 +1,18 @@
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { OpenFin } from '@openfin/core';
+import { BrowserSearchMenuKeyboardEvent } from '../../../../../../../common/src/utils/popup-window';
+import { SearchViewExpansionState, SecureIconState } from './AddressBar';
+type AddressBarInputProps = {
+    addressSearchResultsView: OpenFin.View;
+    addressBarInputRef: MutableRefObject<HTMLInputElement>;
+    inputContainerRef: MutableRefObject<HTMLDivElement>;
+    addressBarWidth: number;
+    isSecure: SecureIconState;
+    setShouldExpandMenu: Dispatch<SetStateAction<SearchViewExpansionState>>;
+    shouldExpandMenu: SearchViewExpansionState;
+    setSearchText: Dispatch<SetStateAction<string>>;
+    searchText: string;
+    sendKeyboardEventToSearchMenuView: (keyboardEvent: BrowserSearchMenuKeyboardEvent) => void;
+};
+export declare const AddressBarInput: React.FC<AddressBarInputProps>;
+export {};

package/browser/src/components/ControlBar/RightControlsContainer/ToolbarContainer/menus/menuConfig.d.ts

@@ -0,0 +1,17 @@
+import { MenuConfig, ResponseModalConfig, RightMenuConfig } from '../../../../../../../common/src/utils/menu-config';
+type PageCloseMenuOptions = {
+    textInputOptions: {
+        placeholder: string;
+        defaultValue: string;
+    };
+    titlePrefix?: string;
+};
+export declare const getPageCloseMenu: ({ textInputOptions, titlePrefix }: PageCloseMenuOptions) => Promise<ResponseModalConfig>;
+type WindowCloseMenuOptions = {
+    unsavedPagesCount: number;
+};
+export declare const getBrowserWindowCloseMenu: ({ unsavedPagesCount }: WindowCloseMenuOptions) => Promise<ResponseModalConfig>;
+export declare const getColorLinkingMenu: (title: string) => Promise<RightMenuConfig>;
+export declare const getLayoutsMenu: (title: string) => Promise<RightMenuConfig>;
+export declare const getSaveMenu: () => Promise<MenuConfig>;
+export {};

package/browser/src/components/ControlBar/SearchMenu/CommandBar.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { AttachedPage, Site } from '../../../../../client-api-platform/src/shapes';
+type CommandBarProps = {
+    selectedResult?: Site;
+    openPages: AttachedPage[];
+};
+export declare const COMMAND_BAR_HEIGHT = 40;
+export declare const CommandBar: ({ selectedResult, openPages }: CommandBarProps) => JSX.Element;
+export {};

package/browser/src/components/ControlBar/SearchMenu/Icons.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { IconOptionsType } from './ResultIcon';
+export declare const SiteIcon: React.FC<{
+    url: string;
+    iconOptions?: IconOptionsType;
+    isSelected?: boolean;
+}>;
+export declare const PageIcon: React.FC<{
+    isSelected?: boolean;
+}>;
+export declare const WorkspaceIcon: React.FC<{
+    isSelected?: boolean;
+}>;
+export declare const FavoriteIcon: React.FC<{
+    url: string;
+    isSelected: boolean;
+}>;
+export declare const VectorIcon: () => JSX.Element;
+export declare const ReturnIcon: () => JSX.Element;
+export declare const OptionIcon: () => JSX.Element;
+export declare const KeyIcon: ({ text }: {
+    text: string;
+}) => JSX.Element;

package/browser/src/components/ControlBar/SearchMenu/ResultIcon.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { AppSite } from '../../../../../client-api-platform/src/shapes';
+export type IconOptionsType = NonNullable<AppSite['options']>['icon'];
+type ResultIconProps = {
+    siteType: 'app' | 'website' | 'page' | 'workspace';
+    icon: string;
+    isSelected: boolean;
+    iconOptions?: IconOptionsType;
+};
+export declare const ResultIcon: ({ siteType, icon, isSelected, iconOptions }: ResultIconProps) => JSX.Element;
+export {};

package/browser/src/components/ControlBar/SearchMenu/SecureIcon.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { SecureIconState } from '../LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+export declare const SecureIcon: React.FC<{
+    isSecure: SecureIconState;
+}>;

package/browser/src/components/ControlBar/SearchMenu/UrlInput.d.ts

@@ -0,0 +1,3 @@
+export declare const UrlInput: import("styled-components").StyledComponent<"input", import("styled-components").DefaultTheme, {
+    expanded?: boolean;
+}, never>;

package/browser/src/components/ControlBar/SearchMenu/useIsPageOpen.d.ts

@@ -0,0 +1,3 @@
+import { Page, Site } from '../../../../../client-api-platform/src/shapes';
+declare const useIsPageOpen: (openPages: Page[], siteInfo: Site) => boolean;
+export default useIsPageOpen;

package/browser/src/components/ControlBar/Tablist/utils.d.ts

@@ -0,0 +1,8 @@
+import { AttachedPage } from '../../../../../common/src/api/pages/shapes';
+/**
+ * Gets the index of the page that should be active once current active page is removed.
+ * @param detachedActivePageIndex Index of the active page prior to being removed
+ * @param filteredPages Remaining pages
+ * @returns page that should be active once current active page is removed
+ */
+export declare const getNextActivePageOnRemoval: (detachedActivePageIndex: number, filteredPages: AttachedPage[]) => AttachedPage;

package/browser/src/components/ControlBar/utils.d.ts

@@ -0,0 +1 @@
+export declare const CONTROL_BAR_HEIGHT = 40;

package/browser/src/components/LandingPage/BrandIcon.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+type BrandLogoContainerProps = {
+    size: 'small' | 'large';
+};
+declare const BrandIcon: FC<BrandLogoContainerProps>;
+export default BrandIcon;

package/browser/src/components/LayoutContainer/utils.d.ts

@@ -0,0 +1,10 @@
+import type OpenFin from '@openfin/core';
+import { HTMLElementWithAria } from '../../../../common/src/utils/a11y';
+/**
+ * For clicks within a tab hat, returns the name of the attached view.
+ * Returns `null` if click is not within a tab hat.
+ */
+export declare const getViewNameFromClickEvent: (event: React.MouseEvent) => string;
+export declare function addViewTabGroupEventListener(tabGroup: HTMLElement, isPageLocked: boolean, shouldRemoveListener?: boolean): void;
+export declare const getViewUrl: (viewIdentity: OpenFin.Identity) => Promise<string>;
+export declare function getViewTabHat(viewName: string, containerRef?: HTMLElement): HTMLElementWithAria;

package/browser/src/components/PanelContainer/BookmarksPanel/BookmarkItem.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+import { Props as BaseButtonProps } from '../../../../../common/src/components/BaseButton/BaseButton';
+interface BookmarkItemProps {
+    bookmark: BookmarkNode;
+    isRenaming: boolean;
+    handleNavigateToFolder: (folderId: string) => void;
+    setRenamingNode: (id?: string) => void;
+}
+declare const _default: import("react").NamedExoticComponent<BookmarkItemProps>;
+export default _default;
+export declare const BookmarkItemButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<BaseButtonProps & import("react").HTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>>, import("styled-components").DefaultTheme, BaseButtonProps & {
+    isRenaming?: boolean;
+}, never>;
+export declare const BookmarkItemButtonContent: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const BookmarkFolderIcon: React.FC;
+export declare const BookmarkFavoritesIcon: React.FC;

package/browser/src/components/PanelContainer/BookmarksPanel/BookmarksFolderHeader.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+interface BookmarksPanelHeaderProps {
+    folder: BookmarkNode;
+    handleNavigateToFolder: (folderId: string) => void;
+}
+declare const BookmarksFolderHeader: React.FC<BookmarksPanelHeaderProps>;
+export default BookmarksFolderHeader;

package/browser/src/components/PanelContainer/BookmarksPanel/BookmarksPanel.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+declare const BookmarksPanel: () => JSX.Element;
+export default BookmarksPanel;
+export declare const TextHelp: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, import("react").HTMLAttributes<HTMLElement> & {
+    color?: "background6" | "textDefault";
+    children: import("react").ReactNode;
+    size?: "small" | "base" | "large" | "xsmall" | "xlarge" | "xxlarge" | "xxxlarge" | "xxxxlarge";
+    weight?: "normal" | "bold";
+}, never>;

package/browser/src/components/PanelContainer/BookmarksPanel/BookmarksPanelHeader.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const BookmarksPanelHeader: () => JSX.Element;
+export default BookmarksPanelHeader;

package/browser/src/components/PanelContainer/BookmarksPanel/BookmarksResults.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+import { CategorizedBookmarkSearchResults } from './utils';
+interface BookmarksResultsProps {
+    currentFolder: BookmarkNode;
+    bookmarksList: BookmarkNode[];
+    categorizedSearchResults: CategorizedBookmarkSearchResults;
+    isSearchQueryResults: boolean;
+    renamingNodeId: string | undefined;
+    handleNavigateToFolder: (folderId: string) => void;
+    setRenamingNode: (id?: string) => void;
+}
+declare const BookmarksResults: React.FC<BookmarksResultsProps>;
+export default BookmarksResults;
+export declare const TextHeader: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/browser/src/components/PanelContainer/BookmarksPanel/BookmarksSearchInput.d.ts

@@ -0,0 +1,7 @@
+import { ChangeEvent } from 'react';
+interface BookmarksSearchInputProps {
+    handleSearchInputChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    clearSearchInput: () => void;
+}
+declare const BookmarksSearchInput: React.FC<BookmarksSearchInputProps>;
+export default BookmarksSearchInput;

package/browser/src/components/PanelContainer/BookmarksPanel/useBookmarkNavigation.d.ts

@@ -0,0 +1,8 @@
+import { MouseEvent } from 'react';
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+/**
+ * Custom hook that returns function to handle navigation for a click on a bookmark item.
+ *
+ * @returns {Function} Function to handle bookmark navigation click.
+ */
+export declare const useBookmarkNavigation: () => (bookmark: BookmarkNode, event: MouseEvent<HTMLButtonElement>) => Promise<void>;

package/browser/src/components/PanelContainer/BookmarksPanel/useBookmarksSearch.d.ts

@@ -0,0 +1,16 @@
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+import { CategorizedBookmarkSearchResults } from './utils';
+/**
+ * Custom hook that manages and sorts bookmark search results and returns an object of categorized bookmarks
+ * and actions to update the search query.
+ *
+ * @returns {Object} An object containing the following:
+ * - `categorizedSearchResults` : An object containing two arrays, `bookmarksInFolder` and `bookmarksOutsideFolder`.
+ * - `handleSearchInputChange` : A function to update the search query phrase to retrieve new search results.
+ * - `clearSearchInput` : A function to clear the search query and reset the panel to its previous state.
+ */
+export declare const useBookmarksSearch: (currentFolder: BookmarkNode, setSearchQuery: (query: string) => void, updateBookmarksResults: (folderId?: string, navigateToFolder?: boolean) => void) => {
+    categorizedSearchResults: CategorizedBookmarkSearchResults;
+    handleSearchInputChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    clearSearchInput: () => void;
+};

package/browser/src/components/PanelContainer/BookmarksPanel/useUpdateBookmarkResultsActions.d.ts

@@ -0,0 +1,15 @@
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+/**
+ * Custom hook that retrieves the root node corresponding to All Bookmarks on initial render and
+ * provides actions to update bookmark results.
+ *
+ * @returns {Object} An object containing the following:
+ * - `bookmarksList` : `BookmarkNode[]` - A sorted list of the current folder's child bookmarks and folders.
+ * - `currentFolder` : `BookmarkNode` - The currently active folder.
+ * - `deleteBookmark` : A function to update currentFolder and bookmarksList given a specific folderId.
+ */
+export declare const useUpdateBookmarkResultsActions: () => {
+    bookmarksList: BookmarkNode[];
+    currentFolder: BookmarkNode;
+    updateBookmarksResults: (folderId?: string) => Promise<void>;
+};

package/browser/src/components/PanelContainer/BookmarksPanel/utils.d.ts

@@ -0,0 +1,7 @@
+import { BookmarkNode } from '../../../../../common/src/api/pages/shapes';
+export type CategorizedBookmarkSearchResults = {
+    bookmarksInFolder: BookmarkNode[];
+    bookmarksOutsideFolder: BookmarkNode[];
+};
+export declare const renderBookmarkNodeTitle: (title: string) => string;
+export declare const categorizeSearchResults: (bookmarks: BookmarkNode[], folderId: string) => CategorizedBookmarkSearchResults;

package/browser/src/components/PanelContainer/PanelContainer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { PanelPosition } from '../../../../common/src/api/pages/shapes';
+export declare const getSizeWithoutCSSUnits: (cssValue?: string) => number;
+interface Props {
+    position: PanelPosition;
+}
+declare const PanelContainer: React.FC<Props>;
+export default PanelContainer;

package/browser/src/hooks/EnterpriseSearchMenu/AdjustSearchMenuDimensions/getDimensions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @description Get the width of the search menu based on the parent window width and the expanded state of the menu
+ * @param parentWindowWidth - The width of the parent window
+ * @returns {number} The calculated width of the search menu
+ */
+export declare const getSearchMenuWidth: (parentWindowWidth: number) => number;
+/**
+ * @description Get the height of the search menu based on the parent window height, the expanded state of the menu, and the UI state of the menu
+ * @param parentWindowHeight - The height of the parent window
+ * @param shouldShowEmptySearchInputContainer - Whether the empty search input UI should be shown
+ * @param container - The container for the search menu
+ * @returns {number} The calculated height of the search menu
+ */
+export declare const getSearchMenuHeight: (parentWindowHeight: number, shouldShowEmptySearchInputContainer: boolean, container: HTMLElement) => number;

package/browser/src/hooks/EnterpriseSearchMenu/AdjustSearchMenuDimensions/useAdjustSearchMenuViewDimensions.d.ts

@@ -0,0 +1,29 @@
+import { SearchSitesResponse, Site } from '../../../../../client-api-platform/src/index';
+export declare const MENU_BOUNDS: {
+    expanded: {
+        minWidth: number;
+        maxWidth: number;
+    };
+    emptySearchInputContainer: {
+        minHeight: number;
+        maxHeight: number;
+    };
+    percentOfParentWidth: number;
+    resultsContainerMaxHeight: number;
+    parentWindowHeightOffset: number;
+};
+/**
+ * Custom hook to adjust the dimensions of the search menu view based on various conditions. The search menu will expand and collapse when opened or closed.
+ * When open, the search menu will expand to include all of the content (either results or curated content) until the height reaches the maximum.
+ * The search menu dimensions are sent to the browser window, where the view is resized accordingly.
+ *
+ * @param {React.RefObject<HTMLElement>} containerRef - Ref object pointing to the container element of the search menu.
+ * @param {boolean} shouldExpand - Boolean indicating if the search results view should expand.
+ * @param {React.RefObject<BroadcastChannel>} searchMenuChannel - Ref object for the broadcast channel used to communicate with the browser window.
+ * @param {SearchSitesResponse} searchResults - The current search results. (Displayed in the ResultsContainer)
+ * @param {string} searchText - String representing the current text in the address input.
+ * @param {Site[]} recentlyVisited - Array of recently visited sites. (Displayed in the EmptySearchInputContainer)
+ * @param {Site[]} curatedContent - Array of curated content sites. (Displayed in the EmptySearchInputContainer)
+ */
+declare const useAdjustSearchMenuViewDimensions: (containerRef: React.RefObject<HTMLElement>, shouldExpand: boolean, searchMenuChannel: React.RefObject<BroadcastChannel>, searchResults: SearchSitesResponse, recentlyVisited: Site[], curatedContent: Site[], shouldShowEmptySearchContainer: boolean) => void;
+export default useAdjustSearchMenuViewDimensions;

package/browser/src/hooks/EnterpriseSearchMenu/useInitChannelToSearchMenuView.d.ts

@@ -0,0 +1,18 @@
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { OpenFin } from '@openfin/core';
+import { SearchViewExpansionState } from '../../../../browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * Custom hook that initializes a channel between the browser window and the search view to receive communications from the search view.
+ * These messages include navigation requests, keyboard events to modify the search text while the search view is focused, and view resize requests,
+ *
+ * @param {OpenFin.Identity[]} selectedViews - Array of currently selected views in the browser window.
+ * @param {MutableRefObject<BroadcastChannel>} searchMenuChannel - Ref object for the broadcast channel used to communicate with the browser window.
+ * @param {MutableRefObject<HTMLDivElement>} inputContainerRef - Ref object associated with the address input DOM element.
+ * @param {number} offsetTop - Number indicating the offset in pixels from the top of the browser window at which the search results view should be drawn.
+ * @param {OpenFin.View} addressSearchResultsView - View object corresponding to the search results view.
+ * @param {SearchViewExpansionState} shouldExpandMenu - Object with boolean indicating if the search results view should expand and the method of expansion.
+ * @param {Dispatch<SetStateAction<number>>} setAddressBarWidth - Function that updates the width in pixels of the address input bar in its expanded state.
+ * @param {Dispatch<SetStateAction<SearchViewExpansionState>>} setShouldExpandMenu - Function that updates whether the menu should expand and the method of expansion.
+ * @param {Dispatch<SetStateAction<string>>} setSearchText - Function that updates the search text in the address input.
+ */
+export declare const useInitChannelToSearchMenuView: (selectedViews: OpenFin.Identity[], searchMenuChannel: MutableRefObject<BroadcastChannel>, inputContainerRef: MutableRefObject<HTMLDivElement>, offsetTop: number, addressSearchResultsView: OpenFin.View, shouldExpandMenu: SearchViewExpansionState, setAddressBarWidth: Dispatch<SetStateAction<number>>, setShouldExpandMenu: Dispatch<SetStateAction<SearchViewExpansionState>>, setSearchText: Dispatch<SetStateAction<string>>) => void;

package/browser/src/hooks/EnterpriseSearchMenu/usePostMessageToSearchMenuView.d.ts

@@ -0,0 +1,18 @@
+import OpenFin from '@openfin/core';
+import { BrowserSearchMenuKeyboardEvent } from '../../../../common/src/utils/popup-window';
+import type { AttachedPageInternal } from '../../../../common/src/api/pages/shapes';
+import { SearchViewExpansionState } from '../../components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * Custom hook that sends messages to the search view with updates about the browser window's views, search text changes, and whether
+ * the address search view should expand.
+ *
+ * @param {OpenFin.Identity[]} selectedViews - Array of currently selected views in the browser window.
+ * @param {BroadcastChannel} searchMenuChannel - The broadcast channel used to communicate with the search results view.
+ * @param {AttachedPageInternal} activePage - Object representing the currently active page in the browser window.
+ * @param {SearchViewExpansionState} shouldExpandMenu - Object with boolean indicating if the search results view should expand and the method of expansion.
+ * @param {string} searchText - String representing the current text in the address input.
+ * @returns {{ sendKeyboardEventToSearchMenuView: (keyboardEvent: BrowserSearchMenuKeyboardEvent) => void }} - Object containing a function to send keyboard events to the search menu view.
+ */
+export declare const usePostMessageToSearchMenuView: (selectedViews: OpenFin.Identity[], searchMenuChannel: BroadcastChannel, activePage: AttachedPageInternal, shouldExpandMenu: SearchViewExpansionState, searchText: string) => {
+    sendKeyboardEventToSearchMenuView: (keyboardEvent: BrowserSearchMenuKeyboardEvent) => Promise<void>;
+};

package/browser/src/hooks/EnterpriseSearchMenu/useProcessChildContentBlockEvent.d.ts

@@ -0,0 +1,3 @@
+import { OpenFin } from '@openfin/core';
+import { WindowIdentity } from '../../../../common/src/utils/window';
+export declare const useProcessChildContentBlockEvent: (browserWindow: OpenFin.Window, currentOFIdentity: WindowIdentity) => void;

package/browser/src/hooks/EnterpriseSearchMenu/useSearchMenuViewLifecycleManager.d.ts

@@ -0,0 +1,16 @@
+import type OpenFin from '@openfin/core';
+import { SecureIconState } from '../../../../browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * Custom hook that manages the contents of the address input as users interact with the browser and navigate views.
+ * This hook handles the auto-focusing the address input on the landing page, registers handlers for view URL changes,
+ * and manages the state of the secure icon displayed next to valid addresses.
+ *
+ * @param {string} searchText - String representing the current text in the address input.
+ * @param {OpenFin.Identity[]} selectedViews - Array of currently selected views in the browser window.
+ * @param {React.MutableRefObject<HTMLInputElement>} addressBarInputRef - Ref object associated with the address input DOM element.
+ * @param {SecureIconState} isSecure - Object describing whether the currently focused view's site is secure and whether to show an icon in the address bar.
+ * @param {Dispatch<SetStateAction<SearchViewExpansionState>>} setShouldExpandMenu - Function that updates whether the menu should expand and the method of expansion.
+ * @param {React.Dispatch<React.SetStateAction<SecureIconState>>} setIsSecure - Function that updates whether the currently focused view's site is secure and whether to show an icon in the address bar.
+ */
+declare const useSearchMenuViewLifecycleManager: (searchText: string, selectedViews: OpenFin.Identity[], addressBarInputRef: React.MutableRefObject<HTMLInputElement>, isSecure: SecureIconState, setSearchText: React.Dispatch<React.SetStateAction<string>>, setIsSecure: React.Dispatch<React.SetStateAction<SecureIconState>>) => void;
+export default useSearchMenuViewLifecycleManager;