bm-core-ui 2.7.0 → 2.8.3

package/lib/@types/BMCoreUI.min.d.ts

@@ -241,6 +241,12 @@ declare function BMUUIDMake(): string;
  * 
  */
 declare class BMHTMLEntity {
+	/**
+	 * The HTML entity representing the control key.
+	 *  
+	 */
+	static Control: BMHTMLEntity;
+
 	/**
 	 * The HTML entity representing the bowen knot Command symbol.
 	 *  
@@ -277,6 +283,12 @@ declare class BMHTMLEntity {
 	 */
 	static Return: BMHTMLEntity;
 
+	/**
+	 * The HTML entity representing the Escape symbol.
+	 *  
+	 */
+	static Escape: BMHTMLEntity;
+
 	private constructor(); 
 }
 
@@ -3501,7 +3513,6 @@ declare class BMViewLayoutQueue {
  * 
  * Views are usually not constructed using any constructor function. Instead, their lifecycle is managed by CoreUI.
  * You obtain views by invoking the static `viewForNode(_)` method on the `BMView` type.
- * It is also not necessary to invoke any destruction method when the DOM nodes managed by views are removed.
  * 
  * To extend from BMView and create a view subtype, extend from the BMView prototype, then, when requesting views use
  * `BMView.viewForNode.call(MyCustomViewType, node)`. Note that if the node already had
@@ -3671,6 +3682,24 @@ declare class BMView {
 	private _layoutVariableValuesForViewport(): Dictionary<number>;
 
 
+	/**
+	 * Registers a keyboard shortcut that can be activated when the given node has keyboard focus.
+	 * @param shortcut      The shortcut to register.
+	 * @param forNode                 The DOM node for which the shortcut should be registered.
+	 *     
+	 */
+	static registerKeyboardShortcut (shortcut: BMKeyboardShortcut, {forNode: forNode}: {forNode: DOMNode}): void;
+
+
+	/**
+	 * Unregisters a keyboard shortcut. If this keyboard shortcut had not been previously registered, this method does nothing.
+	 * @param shortcut 			The keyboard shortcut to unregister.
+	 * @param forNode                     The DOM node for which the shortcut should be unregistered.
+	 *  
+	 */
+	static unregisterKeyboardShortcut (shortcut: BMKeyboardShortcut, {forNode: forNode}: {forNode: DOMNode}): void;
+
+
 	/**
 	 * Used when releasing an entire view hierarchy.
 	 * Releases this view without affecting constraints or the DOM.
@@ -3802,8 +3831,6 @@ declare class BMView {
 
 	/**
 	 * The layout queue on which this view processes its layout passes.
-	 * If this property is modified while this view had already registered a layout pass with a different queue,
-	 * that layout pass will still run on that queue the next time it is drained.
 	 *     
 	 */
 	layoutQueue: BMViewLayoutQueue;
@@ -4404,6 +4431,60 @@ declare class BMView {
 	valueForLayoutVariable(variable: string): number | null | undefined;
 
 
+	/**
+	 * The keyboard shortcuts that have been registered to this view.
+	 *  
+	 */
+	private _keyboardShortcuts: Dictionary<string, [BMKeyboardShortcut]>;
+
+	/**
+	 * Registers a keyboard shortcut that can be activated when this view has keyboard focus.
+	 * @param shortcut 			The keyboard shortcut to register.
+	 *  
+	 */
+	registerKeyboardShortcut(shortcut: BMKeyboardShortcut): void;
+
+
+	/**
+	 * Unregisters a keyboard shortcut. If this keyboard shortcut had not been previously registered, this method does nothing.
+	 * @param shortcut 			The keyboard shortcut to unregister.
+	 *  
+	 */
+	unregisterKeyboardShortcut(shortcut: BMKeyboardShortcut): void;
+
+
+	/**
+	 * If keyboard shortcuts have been registered on this view, this method will be invoked to identify
+	 * and handle key presses. Subclasses that override this method should invoke the base implementation to allow
+	 * keyboard shortcuts to be handled correctly.
+	 * @param event 			The event that triggered this action.
+	 *  
+	 */
+	keyPressedWithEvent(event: KeyboardEvent): void;
+
+
+	/**
+	 * Set to `YES` if keyboard shortcuts are enabled.
+	 *  
+	 */
+	private _keyboardShortcutsEnabled: boolean;
+
+	/**
+	 * Enables keyboard shortcut handling. This makes the view's `node` focusable and attaches
+	 * the relevant event handlers to it.
+	 *  
+	 */
+	private _enableKeyboardShortcuts(): void;
+
+
+	/**
+	 * Disables keyboard shortcut handling. This detaches the relevant event handlers from this view's `node`.
+	 * The node's `tabIndex` property will not be cleared by this method.
+	 *  
+	 */
+	private _disableKeyboardShortcuts(): void;
+
+
 	/**
 	 * An internal list of layout constraints that affect this view. This array will contain both constraints having
 	 * this view as the source view and constraints having this view as the target view. It also contains constraints
@@ -5202,6 +5283,12 @@ declare class BMTextField extends BMView {
 	 */
 	usesSuggestions: boolean;
 
+	/**
+	 * The maximum number of suggestions that will be visible when the autocomplete menu is open.
+	 *     
+	 */
+	maxSuggestions: number;
+
 	/**
 	 * An optional delegate that can be used to respond to various callbacks from the text field.
 	 *     
@@ -5342,6 +5429,15 @@ declare class BMLayoutEditor extends BMWindow {
 	initWithView(view: BMView, {layoutVariableProvider: layoutVariableProvider}?: {layoutVariableProvider?: BMLayoutVariableProvider | null | undefined}): BMLayoutEditor;
 
 
+	/**
+	 * Prepares the given view for being edited by setting up the appropriate event handlers and
+	 * adding the required controls to the view's node.
+	 * @param view      The view to prepare.
+	 *     
+	 */
+	private _prepareView(view: BMView): void;
+
+
 	/**
 	 * Is set to `YES` while this layout editor is full screen.
 	 *     
@@ -7967,6 +8063,18 @@ declare class BMMenu {
 	 */
 	private _sourceNodeDisplacement?: number | null | undefined;
 
+	/**
+	 * The index of the currently highlighted menu item.
+	 *     
+	 */
+	private _highlightedIndex: number;
+
+	/**
+	 * The DOM node that was focused when this alert was opened.
+	 *     
+	 */
+	private readonly _previouslyActiveNode: any;
+
 	/**
 	 * Initializes this menu with the specified items.
 	 * The menu will be hidden by default; the method showAtPoint(_) should be used to make the menu visible.
@@ -8036,6 +8144,38 @@ declare class BMMenu {
 	closeAnimated(animated?: boolean | null | undefined): void;
 
 
+	/**
+	 * Invoked when the up arrow is pressed.
+	 * @param event      The event that triggered this action.
+	 *     
+	 */
+	arrowUpPressedWithEvent(event: KeyboardEvent): void;
+
+
+	/**
+	 * Invoked when the down arrow is pressed.
+	 * @param event      The event that triggered this action.
+	 *     
+	 */
+	arrowDownPressedWithEvent(event: KeyboardEvent): void;
+
+
+	/**
+	 * Invoked when the tab key is pressed.
+	 * @param event      The event that triggered this action.
+	 *     
+	 */
+	tabPressedWithEvent(event: KeyboardEvent): void;
+
+
+	/**
+	 * Invoked when the escape key is pressed.
+	 * @param event      The event that triggered this action.
+	 *     
+	 */
+	escapePressedWithEvent(event: KeyboardEvent): void;
+
+
 	/**
 	 * Constructs and returns a menu with the specified items.
 	 * The menu will be hidden by default; the method `openAtPoint(_)` should be used to make the menu visible.
@@ -8811,22 +8951,24 @@ declare var BMCellMakeForCollectionView: any;
  *
  * 
  * Creating a subtype of the `BMCollectionViewLayout` type can be achieved in several ways:
- * <ol>
+ * 
+ *
  *  *  Create a type whose prototype inherits the `BMCollectionViewLayout` prototype, e.g.:
- * <pre>
+ * ```
  * 	MyCollectionViewLayout.prototype = Object.create(BMCollectionViewLayout.prototype, {
  * 		// MyCollectionViewLayout prototype methods and properties here
  * 	});
- * </pre>
+ * ```
  * 
  *  *  Create a type whose prototype copies the properties of `BMCollectionViewLayout`'s prototype, e.g.:
- * <pre>
+ * ```
  * 	BMExtend(MyCollectionViewLayout.prototype, BMCollectionViewLayout.prototype, {
  * 		// MyCollectionViewLayout prototype methods and properties here
  * 	});
- * </pre>
+ * ```
  * 
- * </ol>
+ * 
+ *
  * 
  * All layout objects should inherit from the `BMCollectionViewLayout` prototype.
  * 
@@ -8931,6 +9073,87 @@ declare class BMCollectionViewLayout {
 	applyUpdates(): void;
 
 
+	/**
+	 * Invoked by the collection view to obtain the first index path in the layout.
+	 * The default implementation returns the first index path in the data set.
+	 * @return 		The first index path, or `undefined` if no index path exists.
+	 *  
+	 */
+	firstIndexPath(): BMIndexPath | null | undefined;
+
+
+	/**
+	 * Invoked by the collection to obtain the index path that is visually to the left of the given index path.
+	 * 
+	 * Subclasses may override this method to return an appropriate index path.
+	 * If the given index path is at the left edge of the content area, the same index path should be returned.
+	 * 
+	 * The default implementation returns the previous index path in the data set.
+	 * @param indexPath 		The starting index path.
+	 * @return 				The index path to the left of the starting index path.
+	 *  
+	 */
+	indexPathToTheLeftOfIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Invoked by the collection to obtain the index path that is visually on top of the given index path.
+	 * 
+	 * Subclasses may override this method to return an appropriate index path.
+	 * If the given index path is at the top edge of the content area, the same index path should be returned.
+	 * 
+	 * The default implementation returns the result of calling `indexPathToTheLeftOfIndexPath`.
+	 * @param indexPath 		The starting index path.
+	 * @return 				The index path above the starting index path.
+	 *  
+	 */
+	indexPathAboveIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Invoked by the collection to obtain the index path that is visually to the right of the given index path.
+	 * 
+	 * Subclasses may override this method to return an appropriate index path.
+	 * If the given index path is at the right edge of the content area, the same index path should be returned.
+	 * 
+	 * The default implementation returns the next index path in the data set.
+	 * @param indexPath 		The starting index path.
+	 * @return 				The index path to the right of the starting index path.
+	 *  
+	 */
+	indexPathToTheRightOfIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Invoked by the collection view to obtain the index path that is visually below the given index path.
+	 * 
+	 * Subclasses may override this method to return an appropriate index path.
+	 * If the given index path is at the bottom edge of the content area, the same index path should be returned.
+	 * 
+	 * The default implementation returns the result of calling `indexPathToTheRightOfIndexPath`.
+	 * @param indexPath 		The starting index path.
+	 * @return 				The index path below the starting index path.
+	 *  
+	 */
+	indexPathBelowIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Invoked by the collection view to obtain a list of index paths that are visually between
+	 * the two given index paths.
+	 * 
+	 * The default implementation returns a list containing the index paths from the data set that
+	 * start at the given index path, stopping at the target index path.
+	 * 
+	 * The starting and ending index paths should be included in the result.
+	 * @param indexPath 		The starting index path.
+	 * @param toIndexPath 	The ending index path.
+	 * @return 				An array of index paths.
+	 *  
+	 */
+	indexPathsFromIndexPath(indexPath: BMIndexPath, {toIndexPath: toIndexPath}: {toIndexPath: BMIndexPath}): BMIndexPath[];
+
+
 	/**
 	 * Will be invoked by the collection before it updates to a new data set.
 	 * Until collectionViewDidStartUpdates() is invoked, it is recommended that the layout object should be able to produce both the
@@ -9686,106 +9909,118 @@ declare class BMCollectionViewTreeLayout extends BMCollectionViewLayout {
 }
 
 
+/**
+ * Controls how cells are distributed within their row.
+ * 
+ */
 declare class BMCollectionViewFlowLayoutGravity {
-
 	/**
 	 * The cells will flow to the center of the row with no spacing between them.
 	 *  
 	 */
-	readonly Center: any;
+	static Center: BMCollectionViewFlowLayoutGravity;
 
 	/**
 	 * The cells will be aligned to the start of the row.
 	 *  
 	 */
-	readonly Start: any;
+	static Start: BMCollectionViewFlowLayoutGravity;
 
 	/**
 	 * The cells will be aligned to the end of the row.
 	 *  
 	 */
-	readonly End: any;
+	static End: BMCollectionViewFlowLayoutGravity;
 
 	/**
 	 * The cells will flow to the edges of the row with equal spacing between them.
 	 *  
 	 */
-	readonly Edge: any;
+	static Edge: BMCollectionViewFlowLayoutGravity;
 
 	/**
 	 * The cells will flow such that they have equal spacing between them and the row edges.
 	 *  
 	 */
-	readonly Spaced: any;
+	static Spaced: BMCollectionViewFlowLayoutGravity;
 
 	/**
 	 * The cells will flow such that they will have no spacing between them.
 	 * If the cells in a row do not occupy the entire horizontal alrea of that row, they will be expanded proportionally until they do.
 	 *  
 	 */
-	readonly Expand: any;
-}
+	static Expand: BMCollectionViewFlowLayoutGravity;
 
+	private constructor(); 
+}
 
+/**
+ * Controls how cells will be aligned within their row.
+ *  
+ */
 declare class BMCollectionViewFlowLayoutAlignment {
-
 	/**
 	 * @deprecated Use `Start`
 	 * The cells will be aligned to the starting edge of the row.
 	 * 	 
 	 */
-	readonly Top: any;
+	static Top: BMCollectionViewFlowLayoutAlignment;
 
 	/**
 	 * The cells will be aligned to the start of the row.
 	 * 	 
 	 */
-	readonly Start: any;
+	static Start: BMCollectionViewFlowLayoutAlignment;
 
 	/**
 	 * The cells will be aligned to the center of the row.
 	 * 	 
 	 */
-	readonly Center: any;
+	static Center: BMCollectionViewFlowLayoutAlignment;
 
 	/**
 	 * @deprecated Use `End`
 	 * The cells will be aligned to the end of the row.
 	 * 	 
 	 */
-	readonly Bottom: any;
+	static Bottom: BMCollectionViewFlowLayoutAlignment;
 
 	/**
 	 * The cells will be aligned to the end of the row.
 	 * 	 
 	 */
-	readonly End: any;
+	static End: BMCollectionViewFlowLayoutAlignment;
 
 	/**
 	 * The cells will expand to fit the entire height of the row.
 	 * 	 
 	 */
-	readonly Expand: any;
-}
+	static Expand: BMCollectionViewFlowLayoutAlignment;
 
+	private constructor(); 
+}
 
+/**
+ * An enum containing the possible orientations that the flow layout can use.
+ * 
+ */
 declare class BMCollectionViewFlowLayoutOrientation {
-
 	/**
 	 * Indicates that the flow layout will arrange cells primarily along the horizontal axis.
 	 * When the orientation is set to this value the flow layout will scroll horizontally.
 	 *  
 	 */
-	readonly Horizontal: any;
+	static Horizontal: BMCollectionViewFlowLayoutOrientation;
 
 	/**
 	 * Indicates that the flow layout will arrange cells primarily along the vertical axis.
 	 * When the orientation is set to this value the tile flow will scroll vertically.
 	 *  
 	 */
-	readonly Vertical: any;
-}
+	static Vertical: BMCollectionViewFlowLayoutOrientation;
 
+	private constructor(); 
+}
 
 /**
  * The flow layout arranges cells in a horiztonally (TO DO) or vertically scrolling container.
@@ -9936,10 +10171,14 @@ declare class BMCollectionViewFlowLayout extends BMCollectionViewLayout {
 	 * When using automatic cell sizes, the generator will yield execution and only calculate portions of the layout on demand.
 	 * With the exeption of the first invocation, it is required to pass an index path to the iterator's `next` method. The layout process
 	 * will continue until it fully lays out the cell for that index path, at which point it will yield again.
-	 * @param useOffset 			When set to `YES` the layout will take the scrollbar size into account.
+	 * @param useOffset 							When set to `YES` the layout will take the scrollbar size into account.
+	 * @param targetRect 				When computing a layout using automatic cell sizes, this is an optional rect up to which
+	 * 														to measure cells. This is reserved for when this is invoked as a delegate.
+	 * @param targetIndexPath 		When computing a layout using automatic cell sizes, this is an optional index path up to which
+	 * 														to measure cells. This is reserved for when this is invoked as a delegate.
 	 *  
 	 */
-	*_prepareLayoutWithScrollbarOffsetGenerator(useOffset: boolean): void;
+	*_prepareLayoutWithScrollbarOffsetGenerator(useOffset: boolean, {targetRect: targetRect, targetIndexPath: targetIndexPath}?: {targetRect?: BMRect | null | undefined, targetIndexPath?: BMIndexPath | null | undefined}): void;
 
 
 	/**
@@ -10037,6 +10276,46 @@ declare class BMCollectionViewFlowLayout extends BMCollectionViewLayout {
 	computedAttributesForElementsInRect(rect: BMRect, {usingCache: usingCache}?: {usingCache?: any | null | undefined}): BMCollectionViewLayoutAttributes[];
 
 
+	/**
+	 * Returns the index path that is above the given index path in a cached layout.
+	 * In a horizontal layout this returns the index path that is to the left of the given index path.
+	 * @param indexPath 		The index path to start from.
+	 * @return 				The index path above the given one.
+	 *  
+	 */
+	private _cachedIndexPathAboveIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Returns the index path that is above the given index path in a computed layout.
+	 * In a horizontal layout this returns the index path that is to the left of the given index path.
+	 * @param indexPath 		The index path to start from.
+	 * @return 				The index path above the given one.
+	 *  
+	 */
+	private _computedIndexPathAboveIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Returns the index path that is below the given index path in a cached layout.
+	 * In a horizontal layout this returns the index path that is to the right of the given index path.
+	 * @param indexPath 		The index path to start from.
+	 * @return 				The index path below the given one.
+	 *  
+	 */
+	private _cachedIndexPathBelowIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
+	/**
+	 * Returns the index path that is below the given index path in a computed layout.
+	 * In a horizontal layout this returns the index path that is to the left of the given index path.
+	 * @param indexPath 		The index path to start from.
+	 * @return 				The index path below the given one.
+	 *  
+	 */
+	private _computedIndexPathBelowIndexPath(indexPath: BMIndexPath): BMIndexPath;
+
+
 	/**
 	 * Constructs and returns a new flow layout.
 	 * @return 		A flow layout.	 
@@ -10131,11 +10410,23 @@ declare class BMCollectionViewMasonryLayout extends BMCollectionViewLayout {
 
 	/**
 	 * Retrieves the cached attributes for the cell at the given index path.
+	 * @param indexPath 							The cell's index path.
+	 * @param usingCache 					Defaults to this layout's current cache. The cache object to use.
+	 * @return 		The layout attributes if the index path exists in the data set, `undefined` otherwise.
+	 *  
+	 */
+	cachedAttributesForCellAtIndexPath(indexPath: BMIndexPath, {usingCache: usingCache}?: {usingCache?: any | null | undefined}): BMCollectionViewLayoutAttributes | null | undefined;
+
+
+	/**
+	 * Retrieves the cached attributes for the cell at the given index path and information about
+	 * the column it is on.
 	 * @param indexPath 			The cell's index path.
 	 * @param usingCache 	Defaults to this layout's current cache. The cache object to use.
+	 * @return 				An object that describes the requested attributes and its position in the layout.
 	 *  
 	 */
-	cachedAttributesForCellAtIndexPath(indexPath: BMIndexPath, {usingCache: usingCache}?: {usingCache?: any | null | undefined}): void;
+	private _extendedCachedAttributesForCellAtIndexPath(indexPath: BMIndexPath, {usingCache: usingCache}?: {usingCache?: any | null | undefined}): any | null | undefined;
 
 
 	/**
@@ -10822,6 +11113,12 @@ declare class BMCollectionView<T = any> extends BMView {
 	 */
 	readonly bounds: BMRect;
 
+	/**
+	 * A rect that represents the part of the bounds that are visible on screen.
+	 *  
+	 */
+	readonly visibleBounds: BMRect;
+
 	/**
 	 * The number of pixels by which to extend the bounds to preload layout attributes and render off-screen elements.
 	 * Higher values will create more cells and reduce the flickering at high scroll speeds, but will use more memory and processing time.
@@ -10953,6 +11250,12 @@ declare class BMCollectionView<T = any> extends BMView {
 	 */
 	assignsReuseIdentifierAsClass: boolean;
 
+	/**
+	 * Defaults to `YES`. When set to `NO`, keyboard navigation is disabled.
+	 *  
+	 */
+	supportsKeyboardNavigation: boolean;
+
 	/**
 	 * Registers a class to be used when creating cells with the given reuse identifier.
 	 * This does not affect already existing cells, but newly created cells with the given identifier will be created
@@ -11494,6 +11797,77 @@ declare class BMCollectionView<T = any> extends BMView {
 	cellWasRightClicked(cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: Event}): boolean | null | undefined;
 
 
+	/**
+	 * An array that contains the registered keyboard navigation shortcuts.
+	 *  
+	 */
+	private _keyboardNavigationShortcuts: BMKeyboardShortcut[];
+
+	/**
+	 * @protected
+	 * Configures the keyboard shortcuts used by the collection view for highlighting.
+	 * Subclasses overriding this may invoke the superclass implementation to retain the default keyboard
+	 * shortcuts.
+	 *     
+	 */
+	configureKeyboardShortcuts(): void;
+
+
+	/**
+	 * @protected
+	 * Removes the keyboard shortcuts used by the collection view for highlighting.
+	 * Subclasses overriding this should invoke the superclass implementation to remove the default keyboard
+	 * shortcuts.
+	 *     
+	 */
+	disableKeyboardShortcuts(): void;
+
+
+	/**
+	 * Invoked when an arrow key is pressed on the keyboard while this collection view has keyboard focus.
+	 * @param event          The keyboard event that triggered this action.
+	 *     
+	 */
+	private _keyboardArrowPressedWithEvent(event: KeyboardEvent): void;
+
+
+	/**
+	 * The index path, if any, of the cell that is currently receiving keyboard focus. 
+	 * 
+	 * Setting this property to a valid index path will cause the relevant cell to become highlighted.
+	 * Additionally, setting this property to `undefined` will clear the highlighted cell.
+	 *  
+	 */
+	highlightedIndexPath?: BMIndexPath<T> | null | undefined;
+
+	/**
+	 * Highlights the given index path.
+	 * @param indexPath            The index path to highlight.
+	 * @param withEvent     The event that triggered this action, if any. 
+	 *     
+	 */
+	private _highlightIndexPath(indexPath: BMIndexPath, {withEvent: withEvent}?: {withEvent?: UIEvent | null | undefined}): void;
+
+
+	/**
+	 * Checks if the cell at the specified index path is highlighted.
+	 * @param indexPath 	The index path. This will be loosely compared to the highlighted index path.
+	 * @return 					YES if the cell is highlighted, NO otherwise.
+	 *  
+	 */
+	isCellAtIndexPathHighlighted(indexPath: BMIndexPath<T>): boolean;
+
+
+	/**
+	 * Invoked when an arrow is pressed while this collection view has keyboard focus.
+	 * Highlights the index path to the specified direction of the currently highlighted index path.
+	 * @param arrow 				The key code of the keyboard arrow that was pressed.
+	 * @param withEvent 	The event that triggerred this action.
+	 *  
+	 */
+	keyboardArrowPressed(arrow: string, {withEvent: withEvent}: {withEvent: KeyboardEvent}): void;
+
+
 	/**
 	 * The list of selected index paths.
 	 * The index paths in the selection are all strictly compared to the index paths in the data set.
@@ -11503,7 +11877,7 @@ declare class BMCollectionView<T = any> extends BMView {
 	selectedIndexPaths: BMIndexPath<T>[];
 
 	/**
-	 * Invoked by the collection view during an update to refresh the index paths of the selected cells.
+	 * Invoked by the collection view during an update to refresh the index paths of the selected and highlighted cells.
 	 * Index paths that are no longer in the data set will be removed and all other index paths will be updated
 	 * to the correct section and row indexes.
 	 *  
@@ -11638,10 +12012,10 @@ declare class BMCollectionView<T = any> extends BMView {
 	 * Should be invoked to cause the collection view to scroll to the cell at the specified index path.
 	 * Optionally, this scrolling may be animated.
 	 * @param indexPath 												The index path of the cell to scroll to.
-	 * @param withVerticalGravity 	Defaults to `BMCollectionViewScrollingGravityVertical.Top`. The scroll gravity to use, 
+	 * @param withVerticalGravity 	Defaults to a value depending on where the cell is positioned. The scroll gravity to use, 
 	 * 																				which controls where on the screen the cell should appear after the scrolling operation
 	 * 																				completes.
-	 * @param horizontalGravity 	Defaults to `BMCollectionViewScrollingGravityHorizontal.Left`. The scroll gravity to use, 
+	 * @param horizontalGravity 	Defaults to a value depending on where the cell is positioned. The scroll gravity to use, 
 	 * 																				which controls where on the screen the cell should appear after the scrolling operation
 	 * 																				completes.
 	 * @param animated 												Defaults to `NO`. If set to `YES`, the scroll will be animated, otherwise it will be 
@@ -11657,10 +12031,10 @@ declare class BMCollectionView<T = any> extends BMView {
 	 * Optionally, this scrolling may be animated.
 	 * @param identifier 														The supplementary view's type identifier.
 	 * @param atIndexPath 												The index path of the supplementary view to scroll to.
-	 * @param verticalGravity 		Defaults to BMCollectionViewScrollingGravityVertical.Top. The scroll gravity to use, 
+	 * @param verticalGravity 		Defaults to a value depending on where the cell is positioned. The scroll gravity to use, 
 	 * 																				which controls where on the screen the cell should appear after the scrolling operation
 	 * 																				completes.
-	 * @param horizontalGravity 	Defaults to BMCollectionViewScrollingGravityHorizontal.Left. The scroll gravity to use, 
+	 * @param horizontalGravity 	Defaults to a value depending on where the cell is positioned. The scroll gravity to use, 
 	 * 																				which controls where on the screen the cell should appear after the scrolling operation
 	 * 																				completes.
 	 * @param animated 												Defaults to NO. If set to YES, the scroll will be animated, otherwise it will be 
@@ -12171,6 +12545,68 @@ declare interface BMCollectionViewDelegate {
 	collectionViewDidDeselectCellAtIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath): void;
 
 
+	/**
+	 * Invoked by the collection view whenever any arrow key is pressed to determine if it should process that event and highlight
+	 * an appropriate cell.
+	 * 
+	 * Delegates can implement this method to control when keyboard events should be handled, for example to disallow handling the
+	 * left and right arrow keys when the event originates from an input element.
+	 * @param collectionView 		The calling collection view.
+	 * @param key 							The code of the key that was pressed.
+	 * @param withEvent 			The keyboard event that triggered this action.
+	 *  
+	 */
+	collectionViewShouldHighlightCellForArrowKey?(collectionView: BMCollectionView, key: string, {withEvent: withEvent}: {withEvent: KeyboardEvent}): void;
+
+
+	/**
+	 * Invoked by the collection view to verify if a cell can be highlighted.
+	 * 
+	 * If this method is not implemented by the delegate object, the collection view will assume that any cell may be highlighted.
+	 * @param collectionView 		The calling collection view.
+	 * @param indexPath 		The cell's index path or `undefined` if the highlighted index path should be cleared.
+	 * @param withEvent 			If the cell should be highlighted because of an event, this represents the event
+	 * 												for which the cell should be highlighted.
+	 * @return 							`YES` if the cell can be highlighted, `NO` otherwise.
+	 *  
+	 */
+	collectionViewCanHighlightCellAtIndexPath?(collectionView: BMCollectionView, indexPath?: BMIndexPath | null | undefined, {withEvent: withEvent}?: {withEvent?: Event | null | undefined}): boolean;
+
+
+	/**
+	 * Invoked by the collection view whenever any cell was highlighted.
+	 * @param collectionView 		The calling collection view.
+	 * @param indexPath 				The cell's index path or `undefined` if the highlighted index path was cleared.
+	 * @param withEvent 			If the cell was highlighted because of an event, this represents the event
+	 * 												for which the cell was highlighted.
+	 *  
+	 */
+	collectionViewDidHighlightCellAtIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath, {withEvent: withEvent}?: {withEvent?: Event | null | undefined}): void;
+
+
+	/**
+	 * Invoked by the collection view whenever any cell is no longer highlighted.
+	 * @param collectionView 		The calling collection view.
+	 * @param indexPath 				The cell's index path.
+	 * @param withEvent 			If the cell was dehighlighted because of an event, this represents the event
+	 * 												for which the cell was dehighlighted.
+	 *  
+	 */
+	collectionViewDidDehighlightCellAtIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath, {withEvent: withEvent}?: {withEvent?: Event | null | undefined}): void;
+
+
+	/**
+	 * Invoked by a collection view after highlighting a cell that it is not visible on screen to determine
+	 * if it should scroll to reveal that cell.
+	 * 
+	 * When this method is not implemented, the default behaviour is to scroll to off-screen cells that are highlighted.
+	 * @param collectionView  		The calling collection view.
+	 * @param indexPath 			        The index path that was just highlighted.
+	 *  
+	 */
+	collectionViewShouldScrollToHighlightedCellAtIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath): void;
+
+
 	/**
 	 * Invoked by the collection view before running the initial presentation animation. Delegate objects can implement this method
 	 * to customize the animation's parameters.
@@ -12211,11 +12647,11 @@ declare interface BMCollectionViewDelegate {
 	 * until the collection view is certain that a second click will not follow fast enough to trigger a double click.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
-	 * @param withEvent 					The jQuery event that triggered this action.
+	 * @param withEvent 					The event that triggered this action.
 	 * @return 					Defaults to NO. If set to YES the collection view will track double clicks for this event.
 	 *  
 	 */
-	collectionViewCanDoubleClickCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: $event}): boolean | null | undefined;
+	collectionViewCanDoubleClickCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: UIEvent}): boolean | null | undefined;
 
 
 	/**
@@ -12226,11 +12662,11 @@ declare interface BMCollectionViewDelegate {
 	 * By default, when returning NO or nothing from this method, the collection view will togle the selection state of the clicked cell.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
-	 * @param withEvent 					The jQuery event that triggered this action.
+	 * @param withEvent 					The event that triggered this action.
 	 * @return 					Defaults to NO. If set to YES the default actions will be suppressed for this event.
 	 *  
 	 */
-	collectionViewCellWasClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: $event}): boolean | null | undefined;
+	collectionViewCellWasClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: UIEvent}): boolean | null | undefined;
 
 
 	/**
@@ -12240,11 +12676,11 @@ declare interface BMCollectionViewDelegate {
 	 * and prevent the default actions from occuring.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
-	 * @param withEvent 					The jQuery event that triggered this action.
+	 * @param withEvent 					The event that triggered this action.
 	 * @return 					Defaults to NO. If set to YES the default actions will be suppressed for this event.
 	 *  
 	 */
-	collectionViewCellWasDoubleClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: $event}): boolean | null | undefined;
+	collectionViewCellWasDoubleClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: UIEvent}): boolean | null | undefined;
 
 
 	/**
@@ -12254,11 +12690,11 @@ declare interface BMCollectionViewDelegate {
 	 * and prevent the default actions from occuring.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
-	 * @param withEvent 					The jQuery event that triggered this action.
+	 * @param withEvent 					The event that triggered this action.
 	 * @return 					Defaults to NO. If set to YES the default actions will be suppressed for this event.
 	 *  
 	 */
-	collectionViewCellWasLongClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: $event}): boolean | null | undefined;
+	collectionViewCellWasLongClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: UIEvent}): boolean | null | undefined;
 
 
 	/**
@@ -12269,11 +12705,11 @@ declare interface BMCollectionViewDelegate {
 	 * By default, when returning NO or nothing from this method, the browser's default context menu will appear.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
-	 * @param withEvent 					The jQuery event that triggered this action.
+	 * @param withEvent 					The event that triggered this action.
 	 * @return 					Defaults to NO. If set to YES the default actions will be suppressed for this event.
 	 *  
 	 */
-	collectionViewCellWasRightClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: $event}): boolean | null | undefined;
+	collectionViewCellWasRightClicked?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {withEvent: withEvent}: {withEvent: UIEvent}): boolean | null | undefined;
 
 
 	/**
@@ -12842,12 +13278,6 @@ declare class BMWindow extends BMView {
 	 */
 	private _toolWindows: BMToolWindow[];
 
-	/**
-	 * The keyboard shortcuts that have been registered to this window.
-	 *  
-	 */
-	private _keyboardShortcuts: BMKeyboardShortcut[];
-
 	/**
 	 * Initializes this window with the given screen area.
 	 * @param frame 					The frame.
@@ -12868,38 +13298,6 @@ declare class BMWindow extends BMView {
 	private _viewportDidResize(event: Event): void;
 
 
-	/**
-	 * Registers a keyboard shortcut that can be activated when this window is the key window.
-	 * @param shortcut 			The keyboard shortcut to register.
-	 *  
-	 */
-	registerKeyboardShortcut(shortcut: BMKeyboardShortcut): void;
-
-
-	/**
-	 * Unregisters a keyboard shortcut. If this keyboard shortcut had not been previously registered, this method does nothing.
-	 * @param shortcut 			The keyboard shortcut to unregister.
-	 *  
-	 */
-	unregisterKeyboardShortcut(shortcut: BMKeyboardShortcut): void;
-
-
-	/**
-	 * If keyboard shortcuts have been registered on this window, this method will be invoked to identify
-	 * and handle key presses. Subclasses that override this method should invoke the base implementation to allow
-	 * keyboard shortcuts to be handled correctly.
-	 * @param event 			The event that triggered this action.
-	 *  
-	 */
-	keyPressedWithEvent(event: KeyboardEvent): void;
-
-
-	/**
-	 * Set to `YES` if keyboard shortcuts are enabled.
-	 *  
-	 */
-	private _keyboardShortcutsEnabled: boolean;
-
 	/**
 	 * Enables keyboard shortcut handling. This makes the window's `node` focusable and attaches
 	 * the relevant event handlers to it. If this window is the key window and the keyboard focus
@@ -12909,13 +13307,6 @@ declare class BMWindow extends BMView {
 	private _enableKeyboardShortcuts(): void;
 
 
-	/**
-	 * Disables keyboard shortcut handling. This detaches the relevant event handlers from this window's `node`.
-	 *  
-	 */
-	private _disableKeyboardShortcuts(): void;
-
-
 	/**
 	 * If this window is visible, this method dismisses it. Otherwise the window is made visible.
 	 * @param animated 				Defaults to `YES`. If set to `YES`, this change will be animated, otherwise it will be instant.
@@ -13622,6 +14013,12 @@ declare class BMAlertPopup extends BMWindow {
 	 */
 	positiveActionText: string;
 
+	/**
+	 * The DOM node that was focused when this alert was opened.
+	 *     
+	 */
+	private readonly _previouslyActiveNode: any;
+
 	/**
 	 * Designated initializer. Initializes this alert popup with the given labels.
 	 * @param title                     The popup's title.
@@ -13737,6 +14134,189 @@ declare class BMConfirmationPopup extends BMAlertPopup {
 }
 
 
+declare class BMKeyboardShortcutModifier {
+	/**
+	 * Represents the command key on macOS and iOS, windows key on Windows and meta key on Linux.
+	 *  
+	 */
+	static Command: BMKeyboardShortcutModifier;
+
+	/**
+	 * Represents the option key on macOS and alt on other systems.
+	 *  
+	 */
+	static Option: BMKeyboardShortcutModifier;
+
+	/**
+	 * Represents the shit key.
+	 *  
+	 */
+	static Shift: BMKeyboardShortcutModifier;
+
+	/**
+	 * Represents the control key.
+	 *  
+	 */
+	static Control: BMKeyboardShortcutModifier;
+
+	/**
+	 * Represents the command key on macOS and iOS and control key on other systems.
+	 *  
+	 */
+	static System: BMKeyboardShortcutModifier;
+
+	private constructor(); 
+}
+
+/**
+ * A keyboard shortcut object describes the keys that must be pressed for a keyboard shortcut to trigger as
+ * well as what should happen when that shortcut is triggered.
+ * 
+ */
+declare class BMKeyboardShortcut {
+
+	/**
+	 * The key that should be pressed for this keyboard shortcut.
+	 *     
+	 */
+	readonly keyCode: string;
+
+	/**
+	 * An optional array of keyboard modifiers that must be pressed
+	 * together with the key in order to trigger the shortcut.
+	 *     
+	 */
+	readonly modifiers: BMKeyboardShortcutModifier[];
+
+	/**
+	 * A bitmap describing the modifiers that should be active.
+	 *     
+	 */
+	private _modifierBitmap: number;
+
+	/**
+	 * The object which will handle this keyboard shortcut.
+	 *     
+	 */
+	target: any;
+
+	/**
+	 * The name of the method that will be invoked on the target object when this keyboard
+	 * shortcut is triggered. This method will receive the keyboard event that triggered
+	 * this action as its single parameter.
+	 *     
+	 */
+	action: string;
+
+	/**
+	 * When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 *     
+	 */
+	preventsDefault: boolean;
+
+	/**
+	 * Designated initializer. Initializes this keyboard shortcut with the given key and optional modifiers, as well as
+	 * the target and action that will handle it.
+	 * 
+	 * In order to be triggered, this keyboard shortcut must be registered with an event handler such as a window
+	 * that can receive keyboard focus and keypress events.
+	 * @param key                                               The key that should be pressed for this keyboard shortcut. This maps to the `code` property of keyboard events.
+	 * @param modifiers 		Defaults to an empty array. An optional array of keyboard modifiers that must be active.
+	 * 																	for the keyboard shortcut to fire.
+	 * @param target 										The object that will handle this keyboard shortcut action.
+	 * @param action 											The name of a method on the target object that will be invoked when this 
+	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
+	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * @return                                      This keyboard shortcut.
+	 *     
+	 */
+	initWithKeyCode(key: string, {modifiers: modifiers, target: target, action: action, preventsDefault: preventsDefault}: {modifiers?: BMKeyboardShortcutModifier[] | null | undefined, target: any, action: string, preventsDefault?: boolean | null | undefined}): BMKeyboardShortcut;
+
+
+	/**
+	 * Initializes this keyboard shortcut with the given keyboard event. If the event includes the control or command keys, these may be converted
+	 * into a system key modifier based on the current platform.
+	 * @param event                                      The keyboard event from which this keyboard shortcut should be initialized.
+	 * @param target 										The object that will handle this keyboard shortcut action.
+	 * @param action 											The name of a method on the target object that will be invoked when this 
+	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
+	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * 
+	 *     
+	 */
+	initWithKeyboardEvent(event: KeyboardEvent, {target: target, action: action, preventsDefault: preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): void;
+
+
+	/**
+	 * Initializes this keyboard shortcut with the given serialized object representation. A callback is used to
+	 * convert from the target object ID to an actual target object.
+	 * @param shortcut                  A serialized keyboard shortcut.
+	 * @param targetID       A callback that is invoked with the target ID and should return
+	 *                                          the target object which will handle the keyboard shortcut.
+	 * @return                         This keyboard shortcut.
+	 *     
+	 */
+	initWithSerializedKeyboardShortcut(shortcut: any, {targetID: targetID}: {targetID: (($0: string) => any)}): any;
+
+
+	/**
+	 * Returns an object representation of this keyboard shortcut that can be used with `JSON.stringify` to 
+	 * serialize this keyboard shortcut.
+	 * @param ID            A string that identifies the target object and can be used when recreating
+	 *                              the keyboard shortcut instance.
+	 * @return             An object that can be used with `JSON.stringify`.
+	 *     
+	 */
+	serializedKeyboardShortcutWithTargetID(ID: string): any;
+
+
+	/**
+	 * Constructs and returns a keyboard shortcut with the given key and optional modifiers, as well as
+	 * the target and action that will handle it.
+	 * 
+	 * In order to be triggered, this keyboard shortcut must be registered with an event handler such as a window
+	 * that can receive keyboard focus and keypress events.
+	 * @param key                                               The key that should be pressed for this keyboard shortcut. This maps to the `code` property of keyboard events.
+	 * @param modifiers 		Defaults to an empty array. An optional array of keyboard modifiers that must be active.
+	 * 																	for the keyboard shortcut to fire.
+	 * @param target 										The object that will handle this keyboard shortcut action.
+	 * @param action 											The name of a method on the target object that will be invoked when this 
+	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
+	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * @return                                      A keyboard shortcut.
+	 * 
+	 */
+	static keyboardShortcutWithKeyCode (key: string, {modifiers: modifiers, target: target, action: action, preventsDefault: preventsDefault}: {modifiers?: BMKeyboardShortcutModifier[] | null | undefined, target: any, action: string, preventsDefault?: boolean | null | undefined}): BMKeyboardShortcut;
+
+
+	/**
+	 * Constructs and returns a keyboard shortcut with the given keyboard event. If the event includes the control or command keys, these may be converted
+	 * into a system key modifier based on the current platform.
+	 * @param event                                      The keyboard event from which this keyboard shortcut should be initialized.
+	 * @param target 										The object that will handle this keyboard shortcut action.
+	 * @param action 											The name of a method on the target object that will be invoked when this 
+	 * 																	keyboard shortcut is triggered. That method will receive the keyboard event as its single parameter.
+	 * @param preventsDefault                       Defaults to `NO`. When set to `YES`, the default action of the event that triggers this keyboard shortcut will be prevented.
+	 * 
+	 * 
+	 */
+	static keyboardShortcutWithKeyboardEvent (event: KeyboardEvent, {target: target, action: action, preventsDefault: preventsDefault}: {target: any, action: string, preventsDefault?: boolean | null | undefined}): void;
+
+
+	/**
+	 * Constructs and returns keyboard shortcut with the given serialized object representation. A callback is used to
+	 * convert from the target object ID to an actual target object.
+	 * @param shortcut                  A serialized keyboard shortcut.
+	 * @param targetID       A callback that is invoked with the target ID and should return
+	 *                                          the target object which will handle the keyboard shortcut.
+	 * @return                         A keyboard shortcut.
+	 * 
+	 */
+	static keyboardShortcutWithSerializedKeyboardShortcut (shortcut: any, {targetID: targetID}: {targetID: (($0: string) => any)}): any;
+
+}
+
+
 /**
  * @deprecated - This enum will be removed in a future version
  * ---