neo.mjs 8.43.1 → 9.0.0

package/src/selection/Model.mjs

@@ -94,17 +94,19 @@ class Model extends Base {
      * @param {String} [selectedCls]
      */
     deselect(item, silent, itemCollection=this.items, selectedCls) {
+        let me     = this,
+            {view} = me,
+            node;
+
         // We hold vdom ids for now, so all incoming selections must be converted.
         item = item.isRecord ? view.getItemId(item) : Neo.isObject(item) ? item.id : item;
 
         if (itemCollection.includes(item)) {
-            let me     = this,
-                {view} = me,
-                node   = view.getVdomChild(item);
+            node = view.getVdomChild(item);
 
             if (node) {
                 node.cls = NeoArray.remove(node.cls || [], selectedCls || me.selectedCls);
-                node['aria-selected'] = false
+                delete node['aria-selected']
             }
 
             NeoArray.remove(itemCollection, item);
@@ -119,9 +121,8 @@ class Model extends Base {
                     selection: itemCollection
                 })
             }
-        }
-        else if (!silent) {
-            this.fire('noChange')
+        } else if (!silent) {
+            me.fire('noChange')
         }
     }
 
@@ -146,8 +147,7 @@ class Model extends Base {
             me.fire('selectionChange', {
                 selection: this.items
             })
-        }
-        else if (!silent) {
+        } else if (!silent) {
             me.fire('noChange')
         }
     }
@@ -225,12 +225,15 @@ class Model extends Base {
      * @param {String} [selectedCls]
      */
     select(items, itemCollection=this.items, selectedCls) {
+        if (!Array.isArray(items)) {
+            items = [items]
+        }
+
         let me     = this,
             {view} = me;
 
         // We hold vdom ids for now, so all incoming selections must be converted.
-        items = (items = Array.isArray(items) ?
-            items: [items]).map(item => item.isRecord ? view.getItemId(item) : Neo.isObject(item) ? item.id : item);
+        items = items.map(item => item.isRecord ? view.getItemId(item) : Neo.isObject(item) ? item.id : item);
 
         if (!Neo.isEqual(itemCollection, items)) {
             if (me.singleSelect && itemCollection === me.items) {

package/src/selection/grid/BaseModel.mjs

@@ -1,4 +1,5 @@
-import Model from '../Model.mjs';
+import Model    from '../Model.mjs';
+import NeoArray from '../../util/Array.mjs';
 
 /**
  * Abstract base class for all grid related selection models
@@ -12,7 +13,18 @@ class BaseModel extends Model {
          * @member {String} className='Neo.selection.grid.BaseModel'
          * @protected
          */
-        className: 'Neo.selection.grid.BaseModel'
+        className: 'Neo.selection.grid.BaseModel',
+        /**
+         * Storing the column dataFields
+         * @member {String[]} selectedColumns=[]
+         */
+        selectedColumns: [],
+        /**
+         * Storing the record ids
+         * @member {Number[]|String[]} selectedRows=[]
+         * @protected
+         */
+        selectedRows: []
     }
 
     /**
@@ -23,6 +35,83 @@ class BaseModel extends Model {
         return this.view.parent.columns.items.map(column => column.dataField)
     }
 
+    /**
+     * @param {Boolean} [silent=false] true to prevent a vdom update
+     */
+    deselectAllRows(silent=false) {
+        let me     = this,
+            items  = [...me.selectedRows],
+            {view} = me;
+
+        if (items.length) {
+            items.forEach(item => {
+                me.deselectRow(item, true)
+            });
+
+            if (!silent && items.length > 0) {
+                view.update()
+            }
+
+            me.fire('selectionChange', {
+                selection: me.selectedRows
+            })
+        } else if (!silent) {
+            me.fire('noChange')
+        }
+    }
+
+    /**
+     * @param {Number|String} recordId
+     * @param {Boolean}       [silent=false]
+     */
+    deselectRow(recordId, silent=false) {
+        let me      = this,
+            {view}  = me,
+            {store} = view,
+            record  = store.get(recordId),
+            rowId   = view.getRowId(store.indexOf(record)),
+            node    = view.getVdomChild(rowId);
+
+        if (node) {
+            node.cls = NeoArray.remove(node.cls || [], me.selectedCls);
+            delete node['aria-selected']
+        }
+
+        me.selectedRows = [recordId];
+
+        !silent && view.update()
+    }
+
+    /**
+     * Get the record for a given event path
+     * @param {Object[]} path
+     * @returns {Number|String|null}
+     */
+    getRecord(path) {
+        let node, rowIndex;
+
+        for (node of path) {
+            if (node.aria.rowindex) {
+                rowIndex = parseInt(node.aria.rowindex);
+
+                // aria-rowindex is 1 based & also includes the header
+                rowIndex -= 2;
+
+                return this.view.store.getAt(rowIndex)
+            }
+        }
+
+        return null
+    }
+
+    /**
+     * @param {Record} record
+     * @returns {Boolean}
+     */
+    hasAnnotations(record) {
+        return !!Object.getOwnPropertyDescriptor(record.__proto__, this.view.selectedRecordField)
+    }
+
     /**
      * Checks if an event path contains a grid cell editor
      * @param {Object}   data
@@ -38,6 +127,70 @@ class BaseModel extends Model {
 
         return false
     }
+
+    /**
+     * @param {String} dataField
+     * @returns {Boolean} true in case the column is selected
+     */
+    isSelectedColumn(dataField) {
+        return this.selectedColumns.includes(dataField)
+    }
+
+    /**
+     * @param {Number|String} recordId
+     * @returns {Boolean} true in case the row is selected
+     */
+    isSelectedRow(recordId) {
+        return this.selectedRows.includes(recordId)
+    }
+
+    /**
+     * @param {Number|String} recordId
+     * @param {Boolean}       [silent=false]
+     */
+    selectRow(recordId, silent=false) {
+        let me      = this,
+            {view}  = me,
+            {store} = view,
+            record  = store.get(recordId),
+            rowId   = view.getRowId(store.indexOf(record)),
+            node    = view.getVdomChild(rowId);
+
+        if (me.singleSelect) {
+            me.deselectAllRows(true)
+        }
+
+        if (node) {
+            node.cls = NeoArray.add(node.cls || [], me.selectedCls);
+            node['aria-selected'] = true
+        }
+
+        me.selectedRows = [recordId];
+
+        !silent && view.update()
+    }
+
+    /**
+     * @param {Number|String} recordId
+     * @param {Boolean}       [silent=false]
+     */
+    toggleRowSelection(recordId, silent=false) {
+        this[this.isSelectedRow(recordId) ? 'deselectRow' : 'selectRow'](recordId, silent)
+    }
+
+    /**
+     *
+     */
+    unregister() {
+        let me        = this,
+            countRows = me.selectedRows.length;
+
+        me.selectedRows = [];
+
+        countRows > 0 && me.view.createViewData();
+
+        super.unregister()
+    }
 }
 
 export default Neo.setupClass(BaseModel);

package/src/selection/grid/CellColumnModel.mjs

@@ -25,24 +25,20 @@ class CellColumnModel extends CellModel {
          * @member {String} selectedColumnCellCls='selected-column-cell'
          * @protected
          */
-        selectedColumnCellCls: 'selected-column-cell',
-        /**
-         * Storing the column dataFields
-         * @member {String[]} selectedColumns=[]
-         */
-        selectedColumns: []
+        selectedColumnCellCls: 'selected-column-cell'
     }
 
     /**
      * @param {Object} data
      */
     onCellClick(data) {
-        let me     = this,
-            {view} = me,
-            cellId = data.data.currentTarget;
+        let me        = this,
+            {view}    = me,
+            cellId    = data.data.currentTarget,
+            dataField = cellId && view.getDataField(cellId);
 
-        if (cellId) {
-            me.selectedColumns = [view.getDataField(cellId)];
+        if (dataField) {
+            me.selectedColumns = me.isSelected(cellId) ? [] : [dataField];
             view.createViewData(true)
         }
 

package/src/selection/grid/CellColumnRowModel.mjs

@@ -25,24 +25,20 @@ class CellColumnRowModel extends CellRowModel {
          * @member {String} selectedColumnCellCls='selected-column-cell'
          * @protected
          */
-        selectedColumnCellCls: 'selected-column-cell',
-        /**
-         * Storing the column dataFields
-         * @member {String[]} selectedColumns=[]
-         */
-        selectedColumns: []
+        selectedColumnCellCls: 'selected-column-cell'
     }
 
     /**
      * @param {Object} data
      */
     onCellClick(data) {
-        let me     = this,
-            {view} = me,
-            cellId = data.data.currentTarget;
+        let me        = this,
+            {view}    = me,
+            cellId    = data.data.currentTarget,
+            dataField = cellId && view.getDataField(cellId);
 
-        if (cellId) {
-            me.selectedColumns = [view.getDataField(cellId)];
+        if (dataField) {
+            me.selectedColumns = me.isSelected(cellId) ? [] : [dataField];
             view.createViewData(true)
         }
 

package/src/selection/grid/CellModel.mjs

@@ -102,7 +102,7 @@ class CellModel extends BaseModel {
             newIndex += dataFields.length
         }
 
-        me.select(view.getCellId(record, dataFields[newIndex]));
+        me.select(view.getCellId(store.indexOf(record), dataFields[newIndex]));
 
         view.parent.scrollByColumns(currentIndex, step)
     }
@@ -114,6 +114,7 @@ class CellModel extends BaseModel {
         let me           = this,
             {view}       = me,
             {store}      = view,
+            countRecords = store.getCount(),
             currentIndex = 0,
             dataField, newIndex;
 
@@ -124,13 +125,13 @@ class CellModel extends BaseModel {
             dataField = me.dataFields[0]
         }
 
-        newIndex = (currentIndex + step) % store.getCount();
+        newIndex = (currentIndex + step) % countRecords;
 
         while (newIndex < 0) {
-            newIndex += store.getCount()
+            newIndex += countRecords
         }
 
-        me.select(view.getCellId(store.getAt(newIndex), dataField));
+        me.select(view.getCellId(newIndex, dataField));
         view.scrollByRows(currentIndex, step)
     }
 

package/src/selection/grid/CellRowModel.mjs

@@ -20,13 +20,7 @@ class CellRowModel extends CellModel {
          * @member {String} cls='neo-selection-cellrowmodel'
          * @protected
          */
-        cls: 'neo-selection-cellrowmodel',
-        /**
-         * Storing the node ids
-         * @member {String[]} selectedRows=[]
-         * @protected
-         */
-        selectedRows: []
+        cls: 'neo-selection-cellrowmodel'
     }
 
     /**
@@ -35,12 +29,15 @@ class CellRowModel extends CellModel {
     onCellClick(data) {
         let me     = this,
             {view} = me,
-            record = view.getRecord(data.data.currentTarget),
-            rowId  = view.getRowId(record);
+            cellId = data.data.currentTarget,
+            record = me.getRecord(data.data.path);
 
-        if (rowId) {
-            me.selectedRows = [rowId];
-            view.createViewData(true)
+        if (record) {
+            if (me.hasAnnotations(record)) {
+                me.updateAnnotations(record)
+            } else {
+                me[me.isSelected(cellId) ? 'deselectRow' : 'selectRow'](record[view.store.getKeyProperty()], true)
+            }
         }
 
         super.onCellClick(data)
@@ -54,35 +51,30 @@ class CellRowModel extends CellModel {
             {view}       = me,
             {store}      = view,
             countRecords = store.getCount(),
-            rowId        = me.selectedRows[0] || view.getRowId(store.getAt(0)),
-            record       = view.getRecord(rowId),
+            keyProperty  = store.getKeyProperty(),
+            recordId     = me.selectedRows[0] || store.getAt(0)[keyProperty],
+            record       = store.get(recordId),
             index        = store.indexOf(record),
-            newIndex     = (index + step) % countRecords,
-            id;
+            newIndex     = (index + step) % countRecords;
 
         while (newIndex < 0) {
             newIndex += countRecords
         }
 
-        id = view.getRowId(store.getAt(newIndex));
+        record = store.getAt(newIndex);
 
-        if (id) {
-            me.selectedRows = [id];
-            view.createViewData(true)
+        if (me.hasAnnotations(record)) {
+            me.updateAnnotations(record)
+        } else {
+            recordId = record[keyProperty];
+
+            if (recordId) {
+                me.selectRow(recordId, true) // silent
+            }
         }
 
         super.onNavKeyRow(step)
     }
-
-    /**
-     *
-     */
-    unregister() {
-        this.selectedRows = [];
-        this.view.createViewData();
-
-        super.unregister()
-    }
 }
 
 export default Neo.setupClass(CellRowModel);

package/src/selection/grid/ColumnModel.mjs

@@ -20,12 +20,7 @@ class ColumnModel extends BaseModel {
          * @member {String} cls='neo-selection-columnmodel'
          * @protected
          */
-        cls: 'neo-selection-columnmodel',
-        /**
-         * Storing the column dataFields
-         * @member {String[]} selectedColumns=[]
-         */
-        selectedColumns: []
+        cls: 'neo-selection-columnmodel'
     }
 
     /**
@@ -59,12 +54,13 @@ class ColumnModel extends BaseModel {
      * @param {Object} data
      */
     onCellClick(data) {
-        let me     = this,
-            {view} = me,
-            cellId = data.data.currentTarget;
+        let me        = this,
+            {view}    = me,
+            cellId    = data.data.currentTarget,
+            dataField = cellId && view.getDataField(cellId);
 
-        if (cellId) {
-            me.selectedColumns = [view.getDataField(cellId)];
+        if (dataField) {
+            me.selectedColumns = me.isSelectedColumn(dataField) ? [] : [dataField];
             view.createViewData()
         }
     }

package/src/selection/grid/RowModel.mjs

@@ -43,14 +43,6 @@ class RowModel extends BaseModel {
         super.destroy(...args)
     }
 
-    /**
-     * @param {Record} record
-     * @returns {Boolean}
-     */
-    hasAnnotations(record) {
-        return !!Object.getOwnPropertyDescriptor(record.__proto__, this.view.selectedRecordField)
-    }
-
     /**
      * @param {Object} data
      */
@@ -73,14 +65,11 @@ class RowModel extends BaseModel {
             {view}       = me,
             {store}      = view,
             countRecords = store.getCount(),
-            currentIndex = 0,
-            newIndex, record, rowId;
-
-        if (me.hasSelection()) {
-            currentIndex = store.indexOf(view.getRecordByRowId(me.items[0]))
-        }
-
-        newIndex = (currentIndex + step) % countRecords;
+            keyProperty  = store.getKeyProperty(),
+            recordId     = me.selectedRows[0] || store.getAt(0)[keyProperty],
+            record       = store.get(recordId),
+            index        = store.indexOf(record),
+            newIndex     = (index + step) % countRecords;
 
         while (newIndex < 0) {
             newIndex += countRecords
@@ -91,12 +80,12 @@ class RowModel extends BaseModel {
         if (me.hasAnnotations(record)) {
             me.updateAnnotations(record)
         } else {
-            rowId = view.getRowId(record);
+            recordId = record[keyProperty];
 
-            if (rowId) {
-                me.select(rowId);
+            if (recordId) {
+                me.selectRow(recordId);
 
-                view.scrollByRows(currentIndex, step);
+                view.scrollByRows(index, step);
                 view.fire('select', {record})
             }
         }
@@ -105,25 +94,21 @@ class RowModel extends BaseModel {
     /**
      * @param {Object} data
      */
-    onRowClick(data) {
+    onRowClick({data}) {
         let me     = this,
-            id     = data.data.currentTarget,
             {view} = me,
-            isSelected, record;
-
-        if (id) {
-            record = view.getRecord(id);
+            record = me.getRecord(data.path),
+            recordId;
 
+        if (record) {
             if (me.hasAnnotations(record)) {
                 me.updateAnnotations(record)
             } else {
-                me.toggleSelection(id);
-
-                isSelected = me.isSelected(id);
+                recordId = record[view.store.getKeyProperty()];
 
-                !isSelected && view.onDeselect?.(record);
+                me.toggleRowSelection(recordId);
 
-                view.fire(isSelected ? 'select' : 'deselect', {record})
+                view.fire(me.isSelectedRow(recordId) ? 'select' : 'deselect', {record})
             }
         }
     }
@@ -162,17 +147,18 @@ class RowModel extends BaseModel {
     updateAnnotations(record) {
         let me               = this,
             {view}           = me,
-            rowId            = view.getRowId(record),
-            isSelected       = me.isSelected(rowId),
+            {store}          = view,
+            recordId         = record[store.getKeyProperty()],
+            isSelected       = me.isSelectedRow(recordId),
             annotationsField = view.selectedRecordField;
 
         if (me.singleSelect) {
             if (isSelected) {
                 record[annotationsField] = false
             } else {
-                me.items.forEach(rowId => {
+                me.selectedRows.forEach(recordId => {
                     // We can use setSilent(), since the last change will trigger a view update
-                    view.getRecordByRowId(rowId).setSilent({[annotationsField]: false})
+                    store.get(recordId).setSilent({[annotationsField]: false})
                 });
 
                 record[annotationsField] = true

package/src/state/Provider.mjs

@@ -155,17 +155,12 @@ class Provider extends Base {
      */
     beforeSetStores(value, oldValue) {
         if (value) {
-            let me         = this,
-                controller = me.getController();
+            let me = this;
 
             Object.entries(value).forEach(([key, storeValue]) => {
-                controller?.parseConfig(storeValue);
-
                 // support mapping string based listeners into the stateProvider instance
-                Object.entries(storeValue.listeners || {}).forEach(([listenerKey,listener]) => {
-                    if (Neo.isString(listener) && Neo.isFunction(me[listener])) {
-                        storeValue.listeners[listenerKey] = me[listener].bind(me)
-                    }
+                Object.entries(storeValue.listeners || {}).forEach(([listenerKey, listener]) => {
+                    me.bindCallback(listener, listenerKey, me, storeValue.listeners)
                 })
 
                 value[key] = ClassSystemUtil.beforeSetInstance(storeValue)

package/src/tab/Container.mjs

@@ -281,7 +281,23 @@ class Container extends BaseContainer {
             items                : tabComponents,
             layout               : {ntype: 'card', activeIndex: me.activeIndex, removeInactiveCards: me.removeInactiveCards},
             useActiveTabIndicator: me.useActiveTabIndicator,
-            ...me.contentContainer
+            ...me.contentContainer,
+
+            insert(index, item, silent) {
+                if (item?.isTab) {
+                    me.insert(index, item, silent)
+                } else {
+                    super.insert(index, item, silent)
+                }
+            },
+
+            remove(component, destroyItem, silent) {
+                if (component?.isTab) {
+                    me.remove(component, destroyItem, silent)
+                } else {
+                    super.remove(component, destroyItem, silent)
+                }
+            }
         }];
 
         me.itemDefaults = null;