bm-core-ui 2.10.5 → 2.11.1

package/build/@types/index.d.ts

@@ -1524,6 +1524,24 @@ export class BMAnimationContext {
 	 */
 	registerAnimationForTarget(target: $ | DOMNode, {properties, options}: {properties: Dictionary< any>, options?: Dictionary< any> | null | undefined}): void;
 
+
+	/**
+	 * A map having DOM nodes as keys which contains delayed animations that have yet to start.
+	 * 
+	 */
+	private static _pendingAnimations (): void;
+
+
+	/**
+	 * Stops all current animations for the specified node on the properties that
+	 * are specified in an animation that is about to start.
+	 * @param node 							The DOM node on which the animation is about to start.
+	 * @param withProperties 		The properties that are about to be animated.
+	 * @param options 			The options of the animation that is about to start.
+	 * 
+	 */
+	private static _prepareAnimationForNode (node: DOMNode, {withProperties, options}: {withProperties: Dictionary<unknown>, options: Dictionary<unknown>}): void;
+
 }
 
 
@@ -8943,6 +8961,37 @@ export class BMJQueryShim {
 }
 
 
+export class BMCollectionViewCellReuseState {
+	/**
+	 * Indicates that this cell is currently bound to a data source object and retained
+	 * or managed by the collection view.
+	 *  
+	 */
+	static InUse: BMCollectionViewCellReuseState;
+
+	/**
+	 * Indicates that this cell is not currently in use, but may be reused in the future.
+	 *  
+	 */
+	static InQueue: BMCollectionViewCellReuseState;
+
+	/**
+	 * Indicates that this cell is in the process of being deleted and is bound to a data
+	 * source object that no longer has a valid index path.
+	 *  
+	 */
+	static Deleting: BMCollectionViewCellReuseState;
+
+	/**
+	 * Indicates that this cell is not currently in use and cannot be reused in the future.
+	 * References to cells in this state should be cleared as they are no longer valid.
+	 *     
+	 */
+	static Discarded: BMCollectionViewCellReuseState;
+
+	private constructor(); 
+}
+
 /**
  * A controller object that manages a cell view instance and its associated retain count.
  * The cell is used as a controller for both regular cells, supplementary views and decoration views.
@@ -8990,12 +9039,6 @@ export class BMCollectionViewCell extends BMView {
 	 */
 	readonly element: BMJQueryShim;
 
-	/**
-	 * The DOM node managed by this cell.
-	 *     
-	 */
-	//node: DOMNode;
-
 	/**
 	 * The type of item this cell represents.
 	 * Subclasses should not override this property.
@@ -9004,7 +9047,8 @@ export class BMCollectionViewCell extends BMView {
 	itemType: BMCollectionViewLayoutAttributesType;
 
 	/**
-	 * The cell's reuse identifier which corresponds to the template's reuse identifier.
+	 * The cell's reuse identifier which controls when this cell is reused when data source objects
+	 * request cell instances from the associated collection view.
 	 *     
 	 */
 	reuseIdentifier: string;
@@ -9119,6 +9163,12 @@ export class BMCollectionViewCell extends BMView {
 	releaseRecycledCell(): void;
 
 
+	/**
+	 * The cell's current reuse state.
+	 *     
+	 */
+	readonly reuseState: BMCollectionViewCellReuseState;
+
 	/**
 	 * Should be set to YES to hide the cell, or NO to reveal it.
 	 *     
@@ -9145,7 +9195,7 @@ export class BMCollectionViewCell extends BMView {
 	 * Temporarily set to `YES` while this cell is being measured.
 	 *     
 	 */
-	private readonly _isMeasuring: any;
+	protected readonly _isMeasuring: any;
 
 	/**
 	 * Invoked prior to this cell being updated as part of an animated data update.
@@ -9161,7 +9211,7 @@ export class BMCollectionViewCell extends BMView {
 	/**
 	 * Invoked prior to this cell being collected for reuse by the collection view.
 	 * Subclasses can override this method to perform any changes necessary for reusing this cell.
-	 * Subclasses should invoke the superclass method at some point in their implementation.
+	 * Subclasses must invoke the superclass method at some point in their implementation.
 	 *     
 	 */
 	prepareForReuse(): void;
@@ -9169,8 +9219,8 @@ export class BMCollectionViewCell extends BMView {
 
 	/**
 	 * Invoked prior to this cell being shown on the screen either after being initialized or after having been previously collected.
-	 * Subclasses can override this method to perform any changes necesarry for displaying this cell.
-	 * Subclasses should invoke the superclass method at some point in their implementaiton.
+	 * Subclasses can override this method to perform any changes necessary for displaying this cell.
+	 * Subclasses must invoke the superclass method at some point in their implementation.
 	 *     
 	 */
 	prepareForDisplay(): void;
@@ -10051,6 +10101,7 @@ export class BMCollectionViewTableLayoutSupplementaryView {
 
 /**
  * @deprecated Use `BMCollectionViewFlowLayout` with the `maximumCellsPerRow` property set to `1`.
+ * 
  * --------------------------------------
  * A basic layout implementation, the BMCollectionViewTableLayout will lay out its elements as a list where each row can have
  * either a fixed height or a variable height.
@@ -11354,11 +11405,26 @@ export class BMCollectionView<T = any> extends BMView {
 	delegate?: BMCollectionViewDelegate | null | undefined;
 
 	/**
-	 * A required data set object that specifies how many objects are in this collection view and configures their contents.
+	 * Set to `YES` if a legacy data set is being used. When a legacy 
+	 *  
+	 */
+	private readonly _usesLegacyDataSet: any;
+
+	/**
+	 * @deprecated Use the `dataSource` property instead.
+	 * 
+	 * ---
+	 * A data set object that specifies how many objects are in this collection view and configures their contents.
 	 *  
 	 */
 	dataSet: BMCollectionViewDataSet;
 
+	/**
+	 * A required data source object that specifies how many objects are in this collection view and configures their contents.
+	 *  
+	 */
+	dataSource: BMCollectionViewDataSource;
+
 	/**
 	 * The collection view's container element.
 	 *  
@@ -12357,6 +12423,13 @@ export class BMCollectionView<T = any> extends BMView {
 	 */
 	private _dataUpdatePromise?: Promise<void> | null | undefined;
 
+	/**
+	 * A promise initialized during data updates or similar operations such as animated layout updates. 
+	 * This promise resolves resolves when the operation and its associated animations complete.
+	 *  
+	 */
+	readonly dataUpdated?: Promise<void> | null | undefined;
+
 	/**
 	 * Should be invoked when the entire data set is updated in bulk.
 	 * This method should be invoked when the data set object has access to the new data;
@@ -12575,6 +12648,9 @@ export function BMCollectionViewMakeWithContainer(container: BMJQueryShim, {cust
 
 
 /**
+ * @deprecated Use `BMCollectionViewDataSource` instead.
+ * 
+ * ------
  * The specification for a BMCollectionViewDataSet object, which is used to provide information to the collection view regarding the number
  * of sections and objects that it should display, as well as their contents and the contents of any supplementary views defined by the current layout.
  * 
@@ -12791,6 +12867,185 @@ export interface BMCollectionViewDataSet<T = any> {
 }
 
 
+/**
+ * Describes a `BMCollectionViewDataSource` object, which is used to provide information to the collection view regarding the number
+ * of sections and objects that it should display, as well as their contents and the contents of any supplementary views defined by the current layout.
+ * 
+ * There is no built-in concrete implementation for this interface; all objects implementing this interface must define their own methods.
+ * 
+ */
+export interface BMCollectionViewDataSource<T = any> {
+
+	/**
+	 * Returns the number of sections in the data set.
+	 * @param collectionView          The collection view for which the number of sections should be returned.
+	 * @return 			                        The number of sections.
+	 *  
+	 */
+	collectionViewNumberOfSections(collectionView: BMCollectionView): Int;
+
+
+	/**
+	 * Returns the number of cells in the given section.
+	 * @param collectionView          The collection view for which the number of objects should be returned.
+	 * @param index 		                        The section's index.
+	 * @return 			                        The number of cells.
+	 *  
+	 */
+	collectionViewNumberOfObjectsInSectionAtIndex(collectionView: BMCollectionView, index: Int): Int;
+
+
+	/**
+	 * Returns the index path for the object with the specified section and row indexes.
+	 * @param collectionView          The collection view for which the number of objects should be returned.
+	 * @param row 						            The object's index within the section.
+	 * @param inSectionAtIndex 		            The section's index.
+	 * @return 	            The index path if these indexes are part of the data set,
+	 * 										            `undefined` otherwise. `undefined` may only be returned during
+	 * 										            animated data updates while `isUsingOldData` returns `YES`.
+	 *  
+	 */
+	collectionViewIndexPathForObjectAtRow(collectionView: BMCollectionView, row: Int, {inSectionAtIndex}: {inSectionAtIndex: Int}): BMIndexPath<T> | null | undefined;
+
+
+	/**
+	 * Returns the index path for the specified object.
+	 * @param collectionView          The collection view for which the index path should be returned.
+	 * @param object 				            The object.
+	 * @return 	            The index path, if the object is part of the data set,
+	 * 										            `undefined` otherwise. `undefined` may only be returned during
+	 * 										            animated data updates while `isUsingOldData` returns `YES`.
+	 *  
+	 */
+	collectionViewIndexPathForObject(collectionView: BMCollectionView, object: any): BMIndexPath<T> | null | undefined;
+
+
+	/**
+	 * Returns the cell for the object at the specified index path.
+	 * To retrieve a cell, use the collection view's `dequeueCellForReuseIdentifier` method,
+	 * passing in the appropriate identifier for your cell depending on the item at the specified index path.
+	 * The data source object defines the reuse identifiers that the cells have.
+	 * @param collectionView          The collection view for which the cell should be returned.
+	 * @param indexPath 		        The index path.
+	 * @return 			        The cell.
+	 *  
+	 */
+	collectionViewCellForItemAtIndexPath(collectionView: BMCollectionView, indexPath: BMIndexPath<T>): BMCollectionViewCell;
+
+
+	/**
+	 * Returns the cell for the supplementary view of the specified type at the specified index path.
+	 * To retrieve a cell, use the collection view's `dequeueCellForSupplementaryViewWithIdentifier`,
+	 * passing in the supplementary view's type as the parameter.
+	 * Both the supplementary's view kind and its index path are defined entirely by the layout object
+	 * and the data source must not return a supplementary view of a different kind from this method.
+	 * @param collectionView          The collection view for which the cell should be returned.
+	 * @param identifier 				        The supplementary view's type identifier.
+	 * @param atIndexPath 		        The supplementary view's index path.
+	 * @return 			        The cell.
+	 *  
+	 */
+	collectionViewCellForSupplementaryViewWithIdentifier(collectionView: BMCollectionView, identifier: string, {atIndexPath}: {atIndexPath: BMIndexPath<T>}): BMCollectionViewCell;
+
+
+	/**
+	 * If this data set performs full data updates, this function is required. For data sets that never update, or those that
+	 * can perform delta updates, this method is optional.
+	 * This function may be invoked by the collection view during a full data update to access the old data set.
+	 * When this function is invoked with the parameter set to `YES`, the data set object should return values from the old data set
+	 * for all data and index path queries.
+	 * When this function is invoked with the parameter set to `NO`, the data set object should return values from the new data set.
+	 * Before the update is finished, the collection view will always invoke this method with the parameter set to `NO`.
+	 * @param collectionView          The collection view that is switching the data set.
+	 * @param use 			                    `YES` if the data set should switch to the old data, `NO` if it should switch to the new data.
+	 *  
+	 */
+	collectionViewUseOldData?(collectionView: BMCollectionView, use: boolean): void;
+
+
+	/**
+	 * If this data set performs full data updates, this function is required. For data sets that never update, or those that
+	 * can perform delta updates, this method is optional.
+	 * This function may be invoked by the collection view during a full data update to determine if this data set is currently serving the previous data.
+	 * The data set must return YES if it is serving up the old data, NO otherwise.
+	 * @param collectionView          The collection view whose old data set should be retrieved.
+	 * @return 			                    YES if this data source is currently serving the old data, NO otherwise.
+	 *  
+	 */
+	collectionViewIsUsingOldData(collectionView: BMCollectionView): boolean;
+
+
+	/**
+	 * This method must be implemented by data set objects that support moving items for interactive drag gestures.
+	 * Data set objects implementing this method are expected to update their internal data structures to match
+	 * the item's new position, then trigger a data update to run on the collection view.
+	 * Optionally, data sets may reject the change and not perform any action.
+	 * 
+	 * ---
+	 * For collection views that support moving items, this method must be implemented by the data sets these collection views
+	 * use. In this case, data sets that don't support moving items may simply return `NO` from this method.
+	 * @param collectionView          The collection view that is moving the item.
+	 * @param indexPath 			    The item's current index path.
+	 * @param toIndexPath 		        The index path to which the item should move.
+	 * @return 						        `YES` if the data set has performed the requested change, `NO` otherwise.
+	 *  
+	 */
+	collectionViewMoveItemFromIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath<T>, {toIndexPath}: {toIndexPath: BMIndexPath<T>}): boolean;
+
+
+	/**
+	 * This method may be implemented by data set objects that support moving items for interactive drag gestures.
+	 * Data set objects implementing this method are expected to update their internal data structures to match
+	 * the items' new positions, then trigger a data update to run on the collection view.
+	 * Optionally, data sets may reject the change and not perform any action or only partially accept the update
+	 * and move just some of the items.
+	 * The order of the items in the array is guaranteed to be such that the target index paths are in ascending order.
+	 * Implementing this method is optional and if it is not implemented, collection view will repeatedly invoke
+	 * `moveItemFromIndexPath(_, {toIndexPath})` passing in each of the items that need to be moved.
+	 * @param collectionView      The collection view that is moving the items.
+	 * @param indexPaths 		    An array of index paths identifying which items have to be moved.
+	 * @param toIndexPath 		    The starting index path to which the items should move. This represents the index path of the current layout
+	 * 											    before any items may have moved. It is the data source's responsibility to adjust this index path as the items shift
+	 * 											    within its data structure.
+	 * @return 					An array of index paths specifying the positions of the items after they have been moved.
+	 * 											    The index paths in this array are not required to match either of the lists supplied by
+	 * 											collection view.
+	 *  
+	 */
+	collectionViewMoveItemsFromIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath<T>[], {toIndexPath}: {toIndexPath: BMIndexPath<T>}): BMIndexPath<T>[];
+
+
+	/**
+	 * This method may be implemented by data source objects that support removing items for interactive drag gestures.
+	 * Data source objects implementing this method are expected to update their internal data structures to remove
+	 * the items, then trigger a data update to run on the collection view.
+	 * Optionally, data sources may reject the change and not perform any action or only partially accept the update
+	 * and remove just some of the items, by changing their internal data structures appropriately.
+	 * The order of the items in the array is guaranteed to be such that the target index paths are in ascending order.
+	 * @param collectionView      The collection view that is removing the items.
+	 * @param indexPaths 		    An array of index paths identifying which items have to be removed.
+	 *     
+	 */
+	collectionViewRemoveItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath<T>[]): void;
+
+
+	/**
+	 * This method may be implemented by data source objects that support transferring items from another collection view.
+	 * Data source objects implementing this method are expected to update their internal data structures to add
+	 * the items, then trigger a data update to run on the collection view. This data update must be triggered before
+	 * this method returns for the appropriate animation to play on the items being transferred.
+	 * Optionally, data sources may reject the change and not perform any action or only partially accept the update
+	 * and add just some of the items, by changing their internal data structures appropriately.
+	 * @param collectionView      The collection view into which items are being inserted.
+	 * @param items 					An array of objects to add to the collection view.
+	 * @param toIndexPath 		    The starting index path to which the items should be inserted.
+	 *     
+	 */
+	collectionViewInsertItems?(collectionView: BMCollectionView, items: any[], {toIndexPath}: {toIndexPath: BMIndexPath<T>}): void;
+
+}
+
+
 /**
  * The specification for a `BMCollectionViewDelegate` object.
  * 
@@ -13665,6 +13920,51 @@ export class BMWindow extends BMView {
 	initWithFrame(frame: BMRect, {toolbar, modal}?: {toolbar?: boolean | null | undefined, modal?: boolean | null | undefined}): BMWindow;
 
 
+	/**
+	 * Starts a drag event from the specified `mousedown` or `touchstart` event that moves this window.
+	 * When this method is invoked, further mouse and touch events will be blocked until the drag finishes.
+	 * 
+	 * If there is already a drag operation in progress or if this window is full screen or a modal window,
+	 * this method has no effect.
+	 * @param event 		The `mousedown` or `touchstart` event from which to begin
+	 * 												the window movement.
+	 *  
+	 */
+	performDragWithEvent(event: MouseEvent | TouchEvent): void;
+
+
+	/**
+	 * Starts a drag event from the specified `mousedown` event that will move this window.
+	 * When this method is invoked, further mouse events will be blocked until the drag finishes.
+	 * 
+	 * If there is already a drag operation in progress or if this window is full screen or a modal window,
+	 * this method has no effect.
+	 * @param event 		The `mousedown` event from which to begin the window movement.
+	 *  
+	 */
+	performDragWithMouseEvent(event: MouseEvent | TouchEvent): void;
+
+
+	/**
+	 * The identifier of the touch point that is tracked during a drag operation. `undefined`
+	 * when not tracking a drag.
+	 *  
+	 */
+	private _touchDragPoint: string;
+
+	/**
+	 * Starts a drag event from the specified `touchstart` event that will move this window.
+	 * When this method is invoked, further touch events will be blocked until the drag finishes.
+	 * 
+	 * 
+	 * If there is already a drag operation in progress or if this window is full screen or a modal window,
+	 * this method has no effect.
+	 * @param event 		The `touchstart` event from which to begin the window movement.
+	 *  
+	 */
+	performDragWithTouchEvent(event: MouseEvent | TouchEvent): void;
+
+
 	/**
 	 * Invoked on non-modal windows when the viewport resizes.
 	 * @param event 			The event that triggered this action.

package/build/BMCodeEditor/BMCodeEditor.js

@@ -474,7 +474,7 @@ BMExtend(BMMonacoCodeEditor.prototype, BMCodeEditor.prototype, {
 			experimentalDecorators: YES,
 			strict: YES,
 			inlineSourceMap: YES,
-			module: monaco.languages.typescript.ModuleKind.CommonJS,
+			module: monaco.languages.typescript.ModuleKind.ES2015,
 			noImplicitUseStrict: YES
 		});
 		
@@ -487,7 +487,7 @@ BMExtend(BMMonacoCodeEditor.prototype, BMCodeEditor.prototype, {
 			inlineSources: YES,
 			noImplicitUseStrict: YES,
 			alwaysStrict: NO,
-			module: monaco.languages.typescript.ModuleKind.None,
+			module: monaco.languages.typescript.ModuleKind.ES2015,
 			useDefineForClassFields: NO,
 		});