my-common-zzp 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+# MyCommon
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.1.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project my-common` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project my-common`.
+> Note: Don't forget to add `--project my-common` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build my-common` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build my-common`, go to the dist folder `cd dist/my-common` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test my-common` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/esm2022/lib/ag-grid/AgGridSubPageBase.mjs

@@ -0,0 +1,138 @@
+//#region
+import { Directive, signal, ViewChild } from '@angular/core';
+import _ from 'lodash';
+import { ComponentBase, } from '../component';
+import { DEFAULT_COL_DEF } from './DEFAULT_COL_DEF';
+import { AgGridToolbarComponent } from './ag-gird-toolbar/component';
+import * as i0 from "@angular/core";
+import * as i1 from "../component";
+//#endregion
+/**
+ * 只读的 AG-GRID
+ */
+export class AgGridSubPageBase extends ComponentBase {
+    constructor(vss = null) {
+        super();
+        this.vss = vss;
+        // 列表所有数据
+        this.dataRows = [];
+        //页面ID
+        this.pageId = '';
+        // toolbar 变量
+        this.allowShowCheckbox = true;
+        this.columnDefs = [];
+        this.gridOptions = {
+            //columnDefs: colDefs,
+            defaultColDef: DEFAULT_COL_DEF,
+            rowSelection: 'multiple',
+            onRowClicked: this.onRowClicked.bind(this),
+            onSelectionChanged: this.onSelectionChanged.bind(this),
+        };
+        // 加总列数据计算
+        this.pinnedBottomRowData = [];
+        //#region 行选择、取消选择 相关功能
+        this.selectedRowsCount = signal(0); // 微变量
+        this._previousMasterId = 0;
+        this._previousRowData = [];
+    }
+    onGridReady(params) {
+        this.gridApi = params.api;
+        this.gridApi.addEventListener('cellKeyDown', this.onCellKeyDown.bind(this));
+    }
+    // 用于即时验证、保存单元格数据以及更新依赖单元格的其他组件。
+    onCellEditingStopped(event) { }
+    // 行修改事件，用于批量处理数据、同步整个数据集、刷新统计数据等,粗粒度，处理整行或整个数据集的变化
+    onRowDataUpdated(event) {
+        // 获取所有的数据
+        const rowData = this.getAllGridData();
+        //console.log('onRowDataUpdated');
+        // 计算总计行
+        const totalRow = rowData.reduce((acc, row) => {
+            return {
+                name: 'Total',
+                description: acc.description + 1,
+            };
+        }, { name: 'Total', description: 0 });
+        this.pinnedBottomRowData = [totalRow];
+        // 更新旧数据状态
+        this._previousRowData = _.cloneDeep(rowData);
+    }
+    /**
+     * 通过 UI HOT-KEY 处理新增删除拖拽编辑数据
+     * 注册各种热键操作
+     * @param event
+     */
+    onCellKeyDown(event) { }
+    onRowClicked(event) {
+        // 单选情况下，点击选择,并取消之前的选择
+        if (!this.allowShowCheckbox) {
+            //console.log(event.node);
+            event.node.setSelected(true, true);
+        }
+    }
+    cancelSelected() {
+        // 取消选择所有行
+        this.gridApi.deselectAll();
+        //this.gridApi.getSelectedNodes().map((node) => node.setSelected(false));
+    }
+    onSelectionChanged(event) {
+        this.selectedRowsCount.update(() => this.gridApi.getSelectedNodes().length);
+    }
+    //#endregion
+    //sortByConfigs = [];
+    menuItemClick(params = undefined) {
+        // 排序相关操作
+        if ('sort' in params) {
+            // todo: 'code,name:desc' 字符串转成数组的模式
+            const sortCols = [].concat(params['sort']);
+            this.gridApi.applyColumnState({
+                state: sortCols,
+                applyOrder: false,
+            });
+        }
+    }
+    /**
+     * 读取所有数据
+     * @returns
+     */
+    getAllGridData() {
+        const rowData = [];
+        this.gridApi?.forEachNode((node) => rowData.push(node.data));
+        return rowData;
+    }
+    //#region 数据更新
+    agGridSetData(list) {
+        // id 不相同，则更新，
+        if (this._previousMasterId !== this.vss.masterModel.id) {
+            this.dataRows = list;
+            //this.gridApi.refreshCells(); //.setRowData(this.rowData); // 更新表格数据
+            this._previousMasterId = this.vss.masterModel.id;
+            this._previousRowData = _.cloneDeep(list);
+        }
+        // 如果相同，且已提交，则刷新
+        else if (this.dataStore.isDirty === false) {
+            this.dataRows = list;
+            //this.gridApi.redrawRows();
+            this._previousRowData = _.cloneDeep(list);
+        }
+    }
+    //#endregion
+    onAgGridToolbarClick(event) {
+        if (event.actionCode === 'CANCEL_SELECT') {
+            this.cancelSelected();
+        }
+    }
+    // 在组件销毁时移除全局点击事件监听器
+    ngOnDestroy() {
+        console.log('SubPageBaseExt Destroy...');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: AgGridSubPageBase, deps: [{ token: i1.ViewStateServiceBaseEx }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.0", type: AgGridSubPageBase, viewQueries: [{ propertyName: "toolbar", first: true, predicate: ["agGridToolbar"], descendants: true, read: AgGridToolbarComponent }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: AgGridSubPageBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.ViewStateServiceBaseEx }], propDecorators: { toolbar: [{
+                type: ViewChild,
+                args: ['agGridToolbar', { read: AgGridToolbarComponent }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AgGridSubPageBase.js","sourceRoot":"","sources":["../../../../../projects/my-common/src/lib/ag-grid/AgGridSubPageBase.ts"],"names":[],"mappings":"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","sourcesContent":["//#region\r\nimport { Directive, signal, ViewChild } from '@angular/core';\r\nimport {\r\n    ColDef,\r\n    GridApi,\r\n    GridReadyEvent,\r\n    RowDataUpdatedEvent,\r\n    SelectionChangedEvent,\r\n} from 'ag-grid-community';\r\nimport _ from 'lodash';\r\n\r\nimport {\r\n    ComponentBase,\r\n    ViewStateServiceBaseEx,\r\n} from '../component';\r\nimport { DEFAULT_COL_DEF } from './DEFAULT_COL_DEF';\r\nimport { AgGridToolbarComponent } from './ag-gird-toolbar/component';\r\nimport { IStoreBase } from '../service';\r\n\r\n//#endregion\r\n\r\n/**\r\n * 只读的 AG-GRID\r\n */\r\n@Directive()\r\nexport abstract class AgGridSubPageBase extends ComponentBase {\r\n    // 当前行数据\r\n    currModel;\r\n    // 增删改服务\r\n    dataStore: IStoreBase;\r\n    // 列表所有数据\r\n    dataRows = [];\r\n\r\n    //页面ID\r\n    pageId = '';\r\n\r\n    // toolbar 变量\r\n    allowShowCheckbox = true;\r\n    //allowSortable = false;\r\n    //allowFilter = false;\r\n\r\n    @ViewChild('agGridToolbar', { read: AgGridToolbarComponent })\r\n    protected toolbar!: AgGridToolbarComponent;\r\n\r\n    protected gridApi!: GridApi<any>;\r\n    protected columnDefs: ColDef[] = [];\r\n    protected gridOptions = {\r\n        //columnDefs: colDefs,\r\n        defaultColDef: DEFAULT_COL_DEF,\r\n        rowSelection: 'multiple',\r\n        onRowClicked: this.onRowClicked.bind(this),\r\n        onSelectionChanged: this.onSelectionChanged.bind(this),\r\n    };\r\n\r\n    constructor(public vss: ViewStateServiceBaseEx = null) {\r\n        super();\r\n    }\r\n\r\n    protected onGridReady(params: GridReadyEvent) {\r\n        this.gridApi = params.api;\r\n        this.gridApi.addEventListener(\r\n            'cellKeyDown',\r\n            this.onCellKeyDown.bind(this)\r\n        );\r\n    }\r\n\r\n    // 用于即时验证、保存单元格数据以及更新依赖单元格的其他组件。\r\n    protected onCellEditingStopped(event) {}\r\n\r\n    // 加总列数据计算\r\n    pinnedBottomRowData = [];\r\n    // 行修改事件，用于批量处理数据、同步整个数据集、刷新统计数据等,粗粒度，处理整行或整个数据集的变化\r\n    protected onRowDataUpdated(event: RowDataUpdatedEvent) {\r\n        // 获取所有的数据\r\n        const rowData = this.getAllGridData();\r\n\r\n        //console.log('onRowDataUpdated');\r\n\r\n        // 计算总计行\r\n        const totalRow = rowData.reduce(\r\n            (acc, row) => {\r\n                return {\r\n                    name: 'Total',\r\n                    description: acc.description + 1,\r\n                };\r\n            },\r\n            { name: 'Total', description: 0 }\r\n        );\r\n        this.pinnedBottomRowData = [totalRow];\r\n\r\n        // 更新旧数据状态\r\n        this._previousRowData = _.cloneDeep(rowData);\r\n    }\r\n    /**\r\n     * 通过 UI HOT-KEY 处理新增删除拖拽编辑数据\r\n     * 注册各种热键操作\r\n     * @param event\r\n     */\r\n    protected onCellKeyDown(event: any) {}\r\n\r\n    //#region 行选择、取消选择 相关功能\r\n\r\n    selectedRowsCount = signal(0); // 微变量\r\n    protected onRowClicked(event) {\r\n        // 单选情况下，点击选择,并取消之前的选择\r\n        if (!this.allowShowCheckbox) {\r\n            //console.log(event.node);\r\n            event.node.setSelected(true, true);\r\n        }\r\n    }\r\n    protected cancelSelected() {\r\n        // 取消选择所有行\r\n        this.gridApi.deselectAll();\r\n        //this.gridApi.getSelectedNodes().map((node) => node.setSelected(false));\r\n    }\r\n\r\n    protected onSelectionChanged(event: SelectionChangedEvent) {\r\n        this.selectedRowsCount.update(\r\n            () => this.gridApi.getSelectedNodes().length\r\n        );\r\n    }\r\n\r\n    //#endregion\r\n\r\n    //sortByConfigs = [];\r\n\r\n    protected menuItemClick(params: any = undefined) {\r\n        // 排序相关操作\r\n        if ('sort' in params) {\r\n            // todo: 'code,name:desc' 字符串转成数组的模式\r\n            const sortCols = [].concat(params['sort']);\r\n            this.gridApi.applyColumnState({\r\n                state: sortCols,\r\n                applyOrder: false,\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 读取所有数据\r\n     * @returns\r\n     */\r\n    protected getAllGridData(): any[] {\r\n        const rowData: any[] = [];\r\n        this.gridApi?.forEachNode((node) => rowData.push(node.data));\r\n        return rowData;\r\n    }\r\n\r\n    //#region 数据更新\r\n    protected agGridSetData(list) {\r\n        // id 不相同，则更新，\r\n        if (this._previousMasterId !== this.vss.masterModel.id) {\r\n            this.dataRows = list;\r\n            //this.gridApi.refreshCells(); //.setRowData(this.rowData); // 更新表格数据\r\n            this._previousMasterId = this.vss.masterModel.id;\r\n            this._previousRowData = _.cloneDeep(list);\r\n        }\r\n        // 如果相同，且已提交，则刷新\r\n        else if (this.dataStore.isDirty === false) {\r\n            this.dataRows = list;\r\n            //this.gridApi.redrawRows();\r\n            this._previousRowData = _.cloneDeep(list);\r\n        }\r\n    }\r\n    protected _previousMasterId = 0;\r\n    protected _previousRowData = [];\r\n    //#endregion\r\n\r\n    protected onAgGridToolbarClick(event) {\r\n        if (event.actionCode === 'CANCEL_SELECT') {\r\n            this.cancelSelected();\r\n        }\r\n    }\r\n\r\n    // 在组件销毁时移除全局点击事件监听器\r\n    ngOnDestroy() {\r\n        console.log('SubPageBaseExt Destroy...');\r\n    }\r\n}\r\n"]}

package/esm2022/lib/ag-grid/AgGridSubPageBaseEx.mjs

@@ -0,0 +1,274 @@
+/***
+ * ag-grid 缺省功能: 增删改、拖拽
+ * 1、每个栏位都可以编辑，存档
+ * 2、tab 键到最后一行最后一列，自动新增一行
+ * 3、新增 + 按钮、在当前位置新增一行
+ * 4、快捷键 shift+insert, 当前行上方插入新行
+ * 5、快捷键 ctrl+d, 删除当前行
+ * 6、删除选择行
+ * 7、拖拽排序并存档(需要设定 lineCodeField) *
+ * 8、自定义编辑控件
+ * 9、自定义渲染控件
+ * 10、分组栏位第二行不显示
+ * 11、赠品、配件、主要标记
+ * 12、加总区域
+ *
+ * ag-grid toolbar
+ * 1、已选择行数、取消选择功能
+ * 2、取消编辑
+ * 3、多选开启或关闭
+ * 4、拖拽开启或关闭
+ * 5、新增
+ * 6、存档
+ */
+//#region
+import { Directive } from '@angular/core';
+import { AgGridSubPageBase } from './AgGridSubPageBase';
+import { calcFloatStepValue } from './index';
+import { AppInjector, Application } from '../service';
+import * as i0 from "@angular/core";
+import * as i1 from "../component";
+//#endregion
+export class AgGridSubPageBaseEx extends AgGridSubPageBase {
+    constructor(vss) {
+        super(vss);
+        this.vss = vss;
+        this.App = AppInjector.get(Application);
+        //lineCode
+        this.lineCodeField = '';
+    }
+    onGridReady(params) {
+        this.gridApi = params.api;
+        this.gridApi.addEventListener('cellKeyDown', this.onCellKeyDown.bind(this));
+    }
+    /**
+     * 通过 UI HOT-KEY 处理新增删除拖拽编辑数据
+     * 注册各种热键操作
+     * @param event
+     */
+    onCellKeyDown(event) {
+        if (event.event.code === 'Tab' && this.isLastCell(event)) {
+            // 新增至末尾
+            event.event.preventDefault();
+            this.addNewRow();
+        }
+        else if (event.event.ctrlKey && event.event.key === 'Insert') {
+            // 当前位置新增
+            event.event.preventDefault();
+            this.addNewRow(event.node.rowIndex);
+        }
+        else if (event.event.ctrlKey && event.event.key === 'd') {
+            // 删除当前笔
+            event.event.preventDefault();
+            this.deleteSelectedRow(event.node);
+        }
+    }
+    cellClicked(e) {
+        this.currRowIndex = e.rowIndex;
+        this.currModel = e.data;
+    }
+    onCellValueChanged(event) { }
+    // 用于即时验证、保存单元格数据以及更新依赖单元格的其他组件。
+    onCellEditingStopped(event) {
+        //console.log(event);
+        if (event.valueChanged) {
+            //console.log(event);
+            if (!this.validateField()) {
+                this.App.notify('提示', '请在提交或取消编辑后执行此操作');
+                this.gridApi.startEditingCell({
+                    rowIndex: event.rowIndex,
+                    colKey: event.column.colId,
+                });
+                return;
+            }
+            const field = event.colDef.field;
+            // 需要更新，否则订阅流的相关方法不会执行
+            this.dataStore.update(event.data.id, {
+                [field]: event.value,
+            });
+        }
+    }
+    /**
+     * 指定位置新增，并设定焦点
+     * @param indexToAdd
+     */
+    addNewRow(indexToAdd = -1) {
+        this.currModel = this.addNew();
+        const params = {
+            add: [this.currModel],
+        };
+        // 在特定位置新增
+        indexToAdd > -1 && (params.addIndex = indexToAdd);
+        const transactionResult = this.gridApi.applyTransaction(params);
+        if (transactionResult.add) {
+            // 根据插入位置，设定row 对象序号
+            this.calcNewSeqValue(transactionResult.add[0], this.getAllGridData());
+            console.log(transactionResult.add[0]);
+            // 获取新添加行的最大索引
+            const maxIndex = Math.max(...transactionResult.add.map((rowNode) => rowNode.rowIndex));
+            // 设定焦点
+            this.gridApi.ensureIndexVisible(maxIndex);
+            this.gridApi.setFocusedCell(maxIndex, 'code');
+        }
+        this.dataStore.add(this.currModel);
+    }
+    /**
+     * 删除当前行 或者 选择行，并重新设置焦点
+     * @param node
+     */
+    deleteSelectedRow(node) {
+        const selectedNodes = node ? [node] : this.gridApi.getSelectedNodes();
+        const selectedData = selectedNodes.map((node) => node.data);
+        const lastRemovedRowIndex = selectedNodes[selectedNodes.length - 1].rowIndex;
+        const transactionResult = this.gridApi.applyTransaction({
+            remove: selectedData,
+        });
+        selectedData.forEach((row) => this.dataStore.remove(row));
+        // this.gridApi.refreshCells({ force: true });
+        // 设置焦点
+        if (transactionResult.remove.length > 0) {
+            let focusIndex;
+            if (lastRemovedRowIndex < this.gridApi.getDisplayedRowCount() - 1) {
+                focusIndex = lastRemovedRowIndex; // Focus on the next row
+            }
+            else {
+                focusIndex = lastRemovedRowIndex - 1; // Focus on the previous row
+            }
+            if (focusIndex >= 0) {
+                this.gridApi.ensureIndexVisible(focusIndex);
+                this.gridApi.setFocusedCell(focusIndex, 'code');
+            }
+        }
+    }
+    /**
+     * 拖拽后 设定行序号
+     * @param event
+     */
+    onRowDragEnd(event) {
+        if (!this.lineCodeField)
+            return;
+        const rowData = [];
+        event.api.forEachNode((node) => rowData.push(node.data));
+        // 计算拖拽后行的 seq 值
+        this.calcNewSeqValue(event.node, rowData);
+        //console.log(rowData);
+        // 更新到后台
+        this.dataStore.update(event.node.data.id, {
+            [this.lineCodeField]: event.node.data[this.lineCodeField],
+        });
+    }
+    onAgGridToolbarClick(event) {
+        super.onAgGridToolbarClick(event);
+        // 一般增、删改、操作
+        if (event.actionCode === 'ADD_NEWROW') {
+            this.addNewRow();
+        }
+        else if (event.actionCode === 'DELETE_SELECT') {
+            this.deleteSelectedRow();
+        }
+        else if (event.actionCode === 'CANCEL_EDIT') {
+            this.dataStore.cancel();
+        }
+        else if (event.actionCode === 'MENUITEM_CLICK') {
+            this.menuItemClick(event.params);
+        }
+    }
+    //sortByConfigs = [];
+    menuItemClick(params = undefined) {
+        // 排序相关操作
+        if ('sort' in params) {
+            // todo: 'code,name:desc' 字符串转成数组的模式
+            const sortCols = [].concat(params['sort']);
+            this.gridApi.applyColumnState({
+                state: sortCols,
+                applyOrder: false,
+            });
+            //此处的排序，是需要存档的，下次载入就是按照这个顺序。
+            const rowNodes = this.gridApi.getRenderedNodes();
+            const sortedData = rowNodes.map((rowNode) => rowNode.data);
+            this.calcNewSeqValue2(sortedData);
+        }
+    }
+    // 校验所有
+    validate() {
+        return true;
+    }
+    validateField() {
+        return true;
+    }
+    validateObject() {
+        return true;
+    }
+    validateList() {
+        return true;
+    }
+    /**
+     * 判断 cell 是否为 最右下
+     * @param event
+     * @returns
+     */
+    isLastCell(event) {
+        const displayedRowCount = this.gridApi.getDisplayedRowCount();
+        const lastRowIndex = displayedRowCount - 1;
+        // Get all visible columns
+        const allColumns = this.gridApi.getAllDisplayedColumns();
+        const lastColumnIndex = allColumns.length - 1;
+        const columnIndex = allColumns.indexOf(event.column);
+        return (event.rowIndex === lastRowIndex && columnIndex === lastColumnIndex);
+    }
+    /**
+     * node.seq = 前后笔之差，取最大步进，100，10，1，0.1
+     * @param node
+     * @param rows
+     * @returns
+     */
+    calcNewSeqValue(draggedNode, rows) {
+        if (!this.lineCodeField)
+            return;
+        const draggedIndex = draggedNode.rowIndex;
+        // 仅一笔
+        let newSeq = 1;
+        // 多笔的情况下，重新赋值
+        if (rows.length >= 2) {
+            // 如果拖拽到第一行
+            if (draggedIndex === 0) {
+                newSeq = parseFloat(rows[1][this.lineCodeField]);
+                newSeq = calcFloatStepValue(newSeq);
+            }
+            // 如果拖拽到最后一行
+            else if (draggedIndex === rows.length - 1) {
+                newSeq =
+                    parseFloat(rows[rows.length - 2][this.lineCodeField]) + 1;
+            }
+            // 多行的中间
+            else if (rows.length >= 3) {
+                const prevSeq = parseFloat(rows[draggedIndex - 1][this.lineCodeField]);
+                const nextSeq = parseFloat(rows[draggedIndex + 1][this.lineCodeField]);
+                newSeq = prevSeq + calcFloatStepValue(nextSeq - prevSeq);
+            }
+        }
+        // 更新拖拽后行的 seq 值
+        draggedNode.data[this.lineCodeField] = newSeq;
+    }
+    /**
+     * node.seq = 重新排序，1，2，3...
+     * @param node
+     * @param rows
+     * @returns
+     */
+    calcNewSeqValue2(rows) {
+        if (this.lineCodeField)
+            rows.forEach((row, index) => {
+                row[this.lineCodeField] = index + 1; // 或者根据你的需求重新排序
+                this.dataStore.update(row.id, {
+                    [this.lineCodeField]: row[this.lineCodeField],
+                });
+            });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: AgGridSubPageBaseEx, deps: [{ token: i1.ViewStateServiceBaseEx }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.0", type: AgGridSubPageBaseEx, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: AgGridSubPageBaseEx, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.ViewStateServiceBaseEx }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AgGridSubPageBaseEx.js","sourceRoot":"","sources":["../../../../../projects/my-common/src/lib/ag-grid/AgGridSubPageBaseEx.ts"],"names":[],"mappings":"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","sourcesContent":["/***\r\n * ag-grid 缺省功能: 增删改、拖拽\r\n * 1、每个栏位都可以编辑，存档\r\n * 2、tab 键到最后一行最后一列，自动新增一行\r\n * 3、新增 + 按钮、在当前位置新增一行\r\n * 4、快捷键 shift+insert, 当前行上方插入新行\r\n * 5、快捷键 ctrl+d, 删除当前行\r\n * 6、删除选择行\r\n * 7、拖拽排序并存档(需要设定 lineCodeField) *\r\n * 8、自定义编辑控件\r\n * 9、自定义渲染控件\r\n * 10、分组栏位第二行不显示\r\n * 11、赠品、配件、主要标记\r\n * 12、加总区域\r\n *\r\n * ag-grid toolbar\r\n * 1、已选择行数、取消选择功能\r\n * 2、取消编辑\r\n * 3、多选开启或关闭\r\n * 4、拖拽开启或关闭\r\n * 5、新增\r\n * 6、存档\r\n */\r\n//#region\r\nimport { Directive } from '@angular/core';\r\nimport { GridReadyEvent } from 'ag-grid-community';\r\nimport { AgGridSubPageBase } from './AgGridSubPageBase';\r\nimport { calcFloatStepValue } from './index';\r\nimport { AppInjector, Application } from '../service';\r\nimport { ViewStateServiceBaseEx } from '../component';\r\n\r\n//#endregion\r\n\r\n@Directive()\r\nexport abstract class AgGridSubPageBaseEx extends AgGridSubPageBase {\r\n    public App = AppInjector.get(Application);\r\n    //lineCode\r\n    lineCodeField = '';\r\n\r\n    constructor(public vss: ViewStateServiceBaseEx) {\r\n        super(vss);\r\n    }\r\n\r\n    protected onGridReady(params: GridReadyEvent) {\r\n        this.gridApi = params.api;\r\n        this.gridApi.addEventListener(\r\n            'cellKeyDown',\r\n            this.onCellKeyDown.bind(this)\r\n        );\r\n    }\r\n    /**\r\n     * 通过 UI HOT-KEY 处理新增删除拖拽编辑数据\r\n     * 注册各种热键操作\r\n     * @param event\r\n     */\r\n    protected onCellKeyDown(event: any) {\r\n        if (event.event.code === 'Tab' && this.isLastCell(event)) {\r\n            // 新增至末尾\r\n            event.event.preventDefault();\r\n            this.addNewRow();\r\n        } else if (event.event.ctrlKey && event.event.key === 'Insert') {\r\n            // 当前位置新增\r\n            event.event.preventDefault();\r\n            this.addNewRow(event.node.rowIndex);\r\n        } else if (event.event.ctrlKey && event.event.key === 'd') {\r\n            // 删除当前笔\r\n            event.event.preventDefault();\r\n            this.deleteSelectedRow(event.node);\r\n        }\r\n    }\r\n    // (cellClicked)=\"cellClicked($event)\"\r\n    // (cellValueChanged)=\"onCellValueChanged($event)\"\r\n\r\n    currRowIndex;\r\n\r\n    protected cellClicked(e) {\r\n        this.currRowIndex = e.rowIndex;\r\n        this.currModel = e.data;\r\n    }\r\n    protected onCellValueChanged(event) {}\r\n    // 用于即时验证、保存单元格数据以及更新依赖单元格的其他组件。\r\n    protected onCellEditingStopped(event) {\r\n        //console.log(event);\r\n        if (event.valueChanged) {\r\n            //console.log(event);\r\n            if (!this.validateField()) {\r\n                this.App.notify('提示', '请在提交或取消编辑后执行此操作');\r\n                this.gridApi.startEditingCell({\r\n                    rowIndex: event.rowIndex,\r\n                    colKey: event.column.colId,\r\n                });\r\n                return;\r\n            }\r\n            const field = event.colDef.field;\r\n            // 需要更新，否则订阅流的相关方法不会执行\r\n            this.dataStore.update(event.data.id, {\r\n                [field]: event.value,\r\n            });\r\n        }\r\n    }\r\n    /**\r\n     * 继承类必须自定义新增default字段\r\n     */\r\n    abstract addNew(): object;\r\n    /**\r\n     * 指定位置新增，并设定焦点\r\n     * @param indexToAdd\r\n     */\r\n    addNewRow(indexToAdd = -1) {\r\n        this.currModel = this.addNew();\r\n\r\n        const params: any = {\r\n            add: [this.currModel],\r\n        };\r\n        // 在特定位置新增\r\n        indexToAdd > -1 && (params.addIndex = indexToAdd);\r\n        const transactionResult = this.gridApi.applyTransaction(params);\r\n\r\n        if (transactionResult.add) {\r\n            // 根据插入位置，设定row 对象序号\r\n            this.calcNewSeqValue(\r\n                transactionResult.add[0],\r\n                this.getAllGridData()\r\n            );\r\n            console.log(transactionResult.add[0]);\r\n            // 获取新添加行的最大索引\r\n            const maxIndex = Math.max(\r\n                ...transactionResult.add.map((rowNode) => rowNode.rowIndex)\r\n            );\r\n\r\n            // 设定焦点\r\n            this.gridApi.ensureIndexVisible(maxIndex);\r\n            this.gridApi.setFocusedCell(maxIndex, 'code');\r\n        }\r\n\r\n        this.dataStore.add(this.currModel);\r\n    }\r\n\r\n    /**\r\n     * 删除当前行 或者 选择行，并重新设置焦点\r\n     * @param node\r\n     */\r\n    deleteSelectedRow(node?: any) {\r\n        const selectedNodes = node ? [node] : this.gridApi.getSelectedNodes();\r\n        const selectedData = selectedNodes.map((node) => node.data);\r\n        const lastRemovedRowIndex =\r\n            selectedNodes[selectedNodes.length - 1].rowIndex;\r\n        const transactionResult = this.gridApi.applyTransaction({\r\n            remove: selectedData,\r\n        });\r\n        selectedData.forEach((row) => this.dataStore.remove(row));\r\n        // this.gridApi.refreshCells({ force: true });\r\n\r\n        // 设置焦点\r\n        if (transactionResult.remove.length > 0) {\r\n            let focusIndex;\r\n            if (lastRemovedRowIndex < this.gridApi.getDisplayedRowCount() - 1) {\r\n                focusIndex = lastRemovedRowIndex; // Focus on the next row\r\n            } else {\r\n                focusIndex = lastRemovedRowIndex - 1; // Focus on the previous row\r\n            }\r\n\r\n            if (focusIndex >= 0) {\r\n                this.gridApi.ensureIndexVisible(focusIndex);\r\n                this.gridApi.setFocusedCell(focusIndex, 'code');\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 拖拽后 设定行序号\r\n     * @param event\r\n     */\r\n    protected onRowDragEnd(event: any) {\r\n        if (!this.lineCodeField) return;\r\n        const rowData = [];\r\n        event.api.forEachNode((node: any) => rowData.push(node.data));\r\n\r\n        // 计算拖拽后行的 seq 值\r\n        this.calcNewSeqValue(event.node, rowData);\r\n        //console.log(rowData);\r\n\r\n        // 更新到后台\r\n        this.dataStore.update(event.node.data.id, {\r\n            [this.lineCodeField]: event.node.data[this.lineCodeField],\r\n        });\r\n    }\r\n\r\n    protected onAgGridToolbarClick(event) {\r\n        super.onAgGridToolbarClick(event);\r\n        // 一般增、删改、操作\r\n        if (event.actionCode === 'ADD_NEWROW') {\r\n            this.addNewRow();\r\n        } else if (event.actionCode === 'DELETE_SELECT') {\r\n            this.deleteSelectedRow();\r\n        } else if (event.actionCode === 'CANCEL_EDIT') {\r\n            this.dataStore.cancel();\r\n        } else if (event.actionCode === 'MENUITEM_CLICK') {\r\n            this.menuItemClick(event.params);\r\n        }\r\n    }\r\n    //sortByConfigs = [];\r\n\r\n    protected menuItemClick(params: any = undefined) {\r\n        // 排序相关操作\r\n        if ('sort' in params) {\r\n            // todo: 'code,name:desc' 字符串转成数组的模式\r\n            const sortCols = [].concat(params['sort']);\r\n            this.gridApi.applyColumnState({\r\n                state: sortCols,\r\n                applyOrder: false,\r\n            });\r\n\r\n            //此处的排序，是需要存档的，下次载入就是按照这个顺序。\r\n            const rowNodes = this.gridApi.getRenderedNodes();\r\n            const sortedData = rowNodes.map((rowNode) => rowNode.data);\r\n            this.calcNewSeqValue2(sortedData);\r\n        }\r\n    }\r\n\r\n    // 校验所有\r\n    validate(): boolean {\r\n        return true;\r\n    }\r\n    validateField(): boolean {\r\n        return true;\r\n    }\r\n    validateObject(): boolean {\r\n        return true;\r\n    }\r\n    validateList(): boolean {\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * 判断 cell 是否为 最右下\r\n     * @param event\r\n     * @returns\r\n     */\r\n    protected isLastCell(event: any): boolean {\r\n        const displayedRowCount = this.gridApi.getDisplayedRowCount();\r\n        const lastRowIndex = displayedRowCount - 1;\r\n\r\n        // Get all visible columns\r\n        const allColumns = this.gridApi.getAllDisplayedColumns();\r\n        const lastColumnIndex = allColumns.length - 1;\r\n\r\n        const columnIndex = allColumns.indexOf(event.column);\r\n        return (\r\n            event.rowIndex === lastRowIndex && columnIndex === lastColumnIndex\r\n        );\r\n    }\r\n\r\n    /**\r\n     * node.seq = 前后笔之差，取最大步进，100，10，1，0.1\r\n     * @param node\r\n     * @param rows\r\n     * @returns\r\n     */\r\n    protected calcNewSeqValue(draggedNode, rows) {\r\n        if (!this.lineCodeField) return;\r\n\r\n        const draggedIndex = draggedNode.rowIndex;\r\n\r\n        // 仅一笔\r\n        let newSeq = 1;\r\n\r\n        // 多笔的情况下，重新赋值\r\n        if (rows.length >= 2) {\r\n            // 如果拖拽到第一行\r\n            if (draggedIndex === 0) {\r\n                newSeq = parseFloat(rows[1][this.lineCodeField]);\r\n                newSeq = calcFloatStepValue(newSeq);\r\n            }\r\n            // 如果拖拽到最后一行\r\n            else if (draggedIndex === rows.length - 1) {\r\n                newSeq =\r\n                    parseFloat(rows[rows.length - 2][this.lineCodeField]) + 1;\r\n            }\r\n            // 多行的中间\r\n            else if (rows.length >= 3) {\r\n                const prevSeq = parseFloat(\r\n                    rows[draggedIndex - 1][this.lineCodeField]\r\n                );\r\n                const nextSeq = parseFloat(\r\n                    rows[draggedIndex + 1][this.lineCodeField]\r\n                );\r\n                newSeq = prevSeq + calcFloatStepValue(nextSeq - prevSeq);\r\n            }\r\n        }\r\n\r\n        // 更新拖拽后行的 seq 值\r\n        draggedNode.data[this.lineCodeField] = newSeq;\r\n    }\r\n\r\n    /**\r\n     * node.seq = 重新排序，1，2，3...\r\n     * @param node\r\n     * @param rows\r\n     * @returns\r\n     */\r\n    protected calcNewSeqValue2(rows) {\r\n        if (this.lineCodeField)\r\n            rows.forEach((row, index) => {\r\n                row[this.lineCodeField] = index + 1; // 或者根据你的需求重新排序\r\n                this.dataStore.update(row.id, {\r\n                    [this.lineCodeField]: row[this.lineCodeField],\r\n                });\r\n            });\r\n    }\r\n}\r\n"]}

package/esm2022/lib/ag-grid/DEFAULT_COL_DEF.mjs

@@ -0,0 +1,109 @@
+// 每一列的缺省属性
+export const DEFAULT_COL_DEF = {
+    resizable: true,
+    editable: true,
+    suppressHeaderMenuButton: true,
+    suppressHeaderFilterButton: true,
+    sortable: true,
+    filter: true,
+    // UTF-7 排序
+    comparator: (a, b) => {
+        if (!a && !b)
+            return 0;
+        if (!a && b)
+            return -1;
+        if (a && !b)
+            return 1;
+        // 中文打头 用中文排序规则 todo: 区分 简体繁体日文韩文
+        const chineseCharRegex = /^[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF]/;
+        const zhHansCNa = chineseCharRegex.test(a);
+        const zhHansCNb = chineseCharRegex.test(b);
+        if (!zhHansCNa && zhHansCNb) {
+            return -1; // 字母排在汉字前面
+        }
+        if (zhHansCNa && !zhHansCNb) {
+            return 1; // 汉字排在字母后面
+        }
+        // 如果都是字母或都是汉字，按拼音排序
+        if (zhHansCNa && zhHansCNb) {
+            return a.localeCompare(b, 'zh-Hans-CN', {
+                sensitivity: 'base',
+                numeric: true,
+                ignorePunctuation: true,
+                caseFirst: 'upper',
+            });
+        }
+        return a.localeCompare(b);
+        // 仅中文，
+        const chineseCharRegex2 = /[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF]/;
+        const isALetter = !chineseCharRegex2.test(a);
+        const isBLetter = !chineseCharRegex2.test(b);
+        if (isALetter && isBLetter)
+            return a.localeCompare(b);
+    },
+};
+function compareStrings(a, b) {
+    if (!a && !b)
+        return 0;
+    if (!a && b)
+        return -1;
+    if (a && !b)
+        return 1;
+    // 判断语言类型
+    const getLanguage = (str) => {
+        if (/^[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF]/.test(str)) {
+            // 判断是简体中文还是繁体中文
+            if (/^[\u4E00-\u9FFF]/.test(str))
+                return 'zh-Hans-CN'; // 简体中文
+            return 'zh-Hant-TW'; // 繁体中文
+        }
+        if (/^[\u3040-\u309F\u30A0-\u30FF]/.test(str))
+            return 'ja'; // 日文
+        if (/^[\u00C0-\u1EF9]/.test(str))
+            return 'vi'; // 越南文
+        return 'en'; // 英文或其他
+    };
+    const langA = getLanguage(a);
+    const langB = getLanguage(b);
+    if (langA !== langB) {
+        // 按语言分组排序
+        const languageOrder = ['vi', 'en', 'zh-Hans-CN', 'zh-Hant-TW', 'ja'];
+        return languageOrder.indexOf(langA) - languageOrder.indexOf(langB);
+    }
+    // 同语言按拼音或字母排序
+    return a.localeCompare(b, langA, {
+        sensitivity: 'base', // 忽略大小写和重音符号
+        numeric: true, // 支持数字的自然排序
+        ignorePunctuation: true, // 忽略标点符号
+        caseFirst: 'upper', // 大写字母优先
+    });
+}
+import { pinyin } from 'pinyin-pro';
+// 中文转拼音函数（支持简体和繁体）
+function convertToPinyin(str) {
+    const r = pinyin(str, {
+        type: 'array',
+        //style: 4, // 带声调
+        //heteronym: false, // 不显示多音字
+        //returnString: true,            // 返回字符串
+    });
+    return r.flat().join('');
+}
+function getSortKey(str) {
+    if (/^[\u4E00-\u9FFF]/.test(str)) {
+        return convertToPinyin(str); // 中文转换为拼音
+    }
+    if (/^[\u3040-\u309F\u30A0-\u30FF]/.test(str)) {
+        return str; // 日文直接使用原字符串
+    }
+    if (/^[\u00C0-\u1EF9]/.test(str)) {
+        return str.normalize('NFD').replace(/[\u0300-\u036f]/g, ''); // 越南文标准化
+    }
+    return str; // 英文或其他
+}
+function compareStringsBySortKey(a, b) {
+    const keyA = getSortKey(a);
+    const keyB = getSortKey(b);
+    return keyA.localeCompare(keyB, 'en'); // 使用英文语言环境比较
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DEFAULT_COL_DEF.js","sourceRoot":"","sources":["../../../../../projects/my-common/src/lib/ag-grid/DEFAULT_COL_DEF.ts"],"names":[],"mappings":"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","sourcesContent":["import { ColDef } from 'ag-grid-community';\r\n\r\n// 每一列的缺省属性\r\nexport const DEFAULT_COL_DEF: ColDef = {\r\n    resizable: true,\r\n    editable: true,\r\n    suppressHeaderMenuButton: true,\r\n    suppressHeaderFilterButton: true,\r\n    sortable: true,\r\n    filter: true,\r\n    // UTF-7 排序\r\n    comparator: (a: string, b: string) => {\r\n        if (!a && !b) return 0;\r\n        if (!a && b) return -1;\r\n        if (a && !b) return 1;\r\n\r\n        // 中文打头 用中文排序规则 todo: 区分 简体繁体日文韩文\r\n        const chineseCharRegex = /^[\\u4E00-\\u9FFF\\u3400-\\u4DBF\\uF900-\\uFAFF]/;\r\n        const zhHansCNa = chineseCharRegex.test(a);\r\n        const zhHansCNb = chineseCharRegex.test(b);\r\n\r\n        if (!zhHansCNa && zhHansCNb) {\r\n            return -1; // 字母排在汉字前面\r\n        }\r\n        if (zhHansCNa && !zhHansCNb) {\r\n            return 1; // 汉字排在字母后面\r\n        }\r\n        // 如果都是字母或都是汉字，按拼音排序\r\n        if (zhHansCNa && zhHansCNb) {\r\n            return a.localeCompare(b, 'zh-Hans-CN', {\r\n                sensitivity: 'base',\r\n                numeric: true,\r\n                ignorePunctuation: true,\r\n                caseFirst: 'upper',\r\n            });\r\n        }\r\n        return a.localeCompare(b);\r\n        // 仅中文，\r\n        const chineseCharRegex2 = /[\\u4E00-\\u9FFF\\u3400-\\u4DBF\\uF900-\\uFAFF]/;\r\n        const isALetter = !chineseCharRegex2.test(a);\r\n        const isBLetter = !chineseCharRegex2.test(b);\r\n        if (isALetter && isBLetter) return a.localeCompare(b);\r\n    },\r\n};\r\n\r\nfunction compareStrings(a: string, b: string): number {\r\n    if (!a && !b) return 0;\r\n    if (!a && b) return -1;\r\n    if (a && !b) return 1;\r\n\r\n    // 判断语言类型\r\n    const getLanguage = (str: string) => {\r\n        if (/^[\\u4E00-\\u9FFF\\u3400-\\u4DBF\\uF900-\\uFAFF]/.test(str)) {\r\n            // 判断是简体中文还是繁体中文\r\n            if (/^[\\u4E00-\\u9FFF]/.test(str)) return 'zh-Hans-CN'; // 简体中文\r\n            return 'zh-Hant-TW'; // 繁体中文\r\n        }\r\n        if (/^[\\u3040-\\u309F\\u30A0-\\u30FF]/.test(str)) return 'ja'; // 日文\r\n        if (/^[\\u00C0-\\u1EF9]/.test(str)) return 'vi'; // 越南文\r\n        return 'en'; // 英文或其他\r\n    };\r\n\r\n    const langA = getLanguage(a);\r\n    const langB = getLanguage(b);\r\n\r\n    if (langA !== langB) {\r\n        // 按语言分组排序\r\n        const languageOrder = ['vi', 'en', 'zh-Hans-CN', 'zh-Hant-TW', 'ja'];\r\n        return languageOrder.indexOf(langA) - languageOrder.indexOf(langB);\r\n    }\r\n\r\n    // 同语言按拼音或字母排序\r\n    return a.localeCompare(b, langA, {\r\n        sensitivity: 'base', // 忽略大小写和重音符号\r\n        numeric: true, // 支持数字的自然排序\r\n        ignorePunctuation: true, // 忽略标点符号\r\n        caseFirst: 'upper', // 大写字母优先\r\n    });\r\n}\r\n\r\nimport { pinyin } from 'pinyin-pro';\r\n// 中文转拼音函数（支持简体和繁体）\r\nfunction convertToPinyin(str: string): string {\r\n    const r = pinyin(str, {\r\n        type: 'array',\r\n        //style: 4, // 带声调\r\n        //heteronym: false, // 不显示多音字\r\n        //returnString: true,            // 返回字符串\r\n    });\r\n    return r.flat().join('');\r\n}\r\nfunction getSortKey(str: string): string {\r\n    if (/^[\\u4E00-\\u9FFF]/.test(str)) {\r\n        return convertToPinyin(str); // 中文转换为拼音\r\n    }\r\n    if (/^[\\u3040-\\u309F\\u30A0-\\u30FF]/.test(str)) {\r\n        return str; // 日文直接使用原字符串\r\n    }\r\n    if (/^[\\u00C0-\\u1EF9]/.test(str)) {\r\n        return str.normalize('NFD').replace(/[\\u0300-\\u036f]/g, ''); // 越南文标准化\r\n    }\r\n    return str; // 英文或其他\r\n}\r\n\r\nfunction compareStringsBySortKey(a: string, b: string): number {\r\n    const keyA = getSortKey(a);\r\n    const keyB = getSortKey(b);\r\n    return keyA.localeCompare(keyB, 'en'); // 使用英文语言环境比较\r\n}\r\n"]}