@trudb/tru-common-lib 0.2.542 → 0.2.544

package/fesm2022/trudb-tru-common-lib.mjs

@@ -2757,13 +2757,24 @@ class TruSearchViewBase {
     }
     onPkeyCellDoubleClicked = (gridConfig) => {
         if (this.hasDetailView) {
+            let clickedEntity = gridConfig.data?.$entity;
+            if (!clickedEntity) {
+                return;
+            }
             let entities = [];
-            gridConfig.api.forEachNodeAfterFilterAndSort((rowNode) => {
-                entities.push(rowNode.data.$entity);
-            });
+            for (let i = 0; i < gridConfig.api.getDisplayedRowCount(); i++) {
+                let rowNode = gridConfig.api.getDisplayedRowAtIndex(i);
+                if (rowNode?.data?.$entity) {
+                    entities.push(rowNode.data.$entity);
+                }
+            }
+            let entityIndex = entities.indexOf(clickedEntity);
+            if (entityIndex < 0) {
+                return;
+            }
             let windowAddViewEventArgs = new TruDesktopViewConfig();
             windowAddViewEventArgs.entities = entities;
-            windowAddViewEventArgs.entityIndex = gridConfig.rowIndex;
+            windowAddViewEventArgs.entityIndex = entityIndex;
             windowAddViewEventArgs.componentName = this.tableName + 'DetailView';
             this.windowEventHandler.addView(windowAddViewEventArgs);
             this.view.active = false;
@@ -5141,13 +5152,24 @@ class TruSearchResultViewBase {
     }
     onPkeyCellDoubleClicked = (gridConfig) => {
         if (this.hasDetailView) {
+            let clickedEntity = gridConfig.data?.$entity;
+            if (!clickedEntity) {
+                return;
+            }
             let entities = [];
-            gridConfig.api.forEachNodeAfterFilterAndSort((rowNode) => {
-                entities.push(rowNode.data.$entity);
-            });
+            for (let i = 0; i < gridConfig.api.getDisplayedRowCount(); i++) {
+                let rowNode = gridConfig.api.getDisplayedRowAtIndex(i);
+                if (rowNode?.data?.$entity) {
+                    entities.push(rowNode.data.$entity);
+                }
+            }
+            let entityIndex = entities.indexOf(clickedEntity);
+            if (entityIndex < 0) {
+                return;
+            }
             let windowAddViewEventArgs = new TruDesktopViewConfig();
             windowAddViewEventArgs.entities = entities;
-            windowAddViewEventArgs.entityIndex = gridConfig.rowIndex;
+            windowAddViewEventArgs.entityIndex = entityIndex;
             windowAddViewEventArgs.componentName = this.tableName + 'DetailView';
             this.truWindowEventHandler.addView(windowAddViewEventArgs);
         }
@@ -6855,9 +6877,7 @@ class TruDataGridCellRenderer {
     };
     init(params) {
         params.eGridCell.innerHTML = '';
-        let value = params.value;
-        if (params.value === null)
-            value = '';
+        const value = params.value ?? '';
         if (params.colDef.cellEditor && params.colDef.cellEditor.name === "StdRichTextList") {
             var p = document.createElement('div');
             p.innerHTML = value;
@@ -7253,7 +7273,9 @@ class TruDataGridClipboard {
     copiedCellValue = null;
     copiedCellEntity = null;
     copiedCellParams = null;
+    copiedCellText = null;
     copiedRows = [];
+    copiedRowsText = null;
     gridElement = null;
     constructor(util, formatter, uiNotification, modelPropertyLookup) {
         this.util = util;
@@ -7269,6 +7291,46 @@ class TruDataGridClipboard {
         else
             return this.formatter.excelFormula(propertyConfig.formatter(controlConfig));
     };
+    normalizeClipboardText = (value) => String(value ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n$/, '');
+    readClipboardText = async () => {
+        if (!navigator.clipboard?.readText)
+            throw new Error('The browser does not support reading from the clipboard.');
+        return navigator.clipboard.readText();
+    };
+    parseExternalCellValue = (clipboardText, controlConfig) => {
+        const value = this.normalizeClipboardText(clipboardText);
+        const currentValue = controlConfig.$;
+        const property = controlConfig.property;
+        const typeName = property?.typeName;
+        if (!value && property?.isNullable)
+            return null;
+        const isDate = currentValue instanceof Date || typeName === 'date' || typeName === 'date-time';
+        if (isDate) {
+            const isoDate = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(value);
+            const parsedValue = isoDate
+                ? new Date(Number(isoDate[1]), Number(isoDate[2]) - 1, Number(isoDate[3]))
+                : new Date(value);
+            if (isNaN(parsedValue.getTime()))
+                throw new Error('Clipboard data is not a valid date.');
+            return parsedValue;
+        }
+        const numericTypes = ['primary-key', 'integer', 'big-integer', 'decimal', 'usa-dollars', 'percentage', 'scientific', 'foreign-key', 'user-foreign-key'];
+        if (typeof currentValue === 'number' || numericTypes.includes(typeName)) {
+            const numericText = value.replace(/[$,%\s]/g, '');
+            const parsedValue = Number(numericText);
+            if (!numericText || !Number.isFinite(parsedValue))
+                throw new Error('Clipboard data is not a valid number.');
+            return typeName === 'percentage' && value.includes('%') ? parsedValue / 100 : parsedValue;
+        }
+        if (typeof currentValue === 'boolean') {
+            if (/^(true|yes|1)$/i.test(value))
+                return true;
+            if (/^(false|no|0)$/i.test(value))
+                return false;
+            throw new Error('Clipboard data is not a valid yes/no value.');
+        }
+        return value;
+    };
     removeBorderAnimation = () => {
         var elementsWithAnimatedBorders = this.gridElement?.querySelectorAll('.animated-border');
         if (elementsWithAnimatedBorders && elementsWithAnimatedBorders.length)
@@ -7308,6 +7370,7 @@ class TruDataGridClipboard {
         this.copiedCellData = copiedCellData;
         this.copiedCellValue = copiedCellData[columnName].$;
         this.copiedCellEntity = copiedCellEntity;
+        this.copiedCellText = this.normalizeClipboardText(params.value);
         this.removeBorderAnimation();
         this.addCellBorderAnimation();
         try {
@@ -7317,28 +7380,49 @@ class TruDataGridClipboard {
             console.error('Failed to copy text: ', err);
         }
     };
-    pasteCell = (params, pastedCellData, pastedCell) => {
+    pasteCell = async (params, pastedCellData, pastedCell) => {
         let colDef = params.colDef;
         let columnName = colDef.field;
-        let copiedCellDataTypeName = this.copiedCellData[this.copiedCellParams?.colDef?.field].property.typeName;
-        let pastedCellDataTypeName = pastedCellData[params.colDef?.field].property.typeName;
         if (!colDef.editable) {
             this.uiNotification.error('Cannot paste into a non-editable column: ' + colDef.field);
             return;
         }
-        if (copiedCellDataTypeName !== pastedCellDataTypeName) {
-            this.uiNotification.error('Clipboard data type does not match the current cell data type: ' + copiedCellDataTypeName + ' vs ' + pastedCellDataTypeName);
+        let clipboardText;
+        try {
+            clipboardText = this.normalizeClipboardText(await this.readClipboardText());
+        }
+        catch (err) {
+            this.uiNotification.error('Unable to read data from the system clipboard.');
             return;
         }
+        const pastedCellConfig = pastedCellData[columnName];
+        const isInternalCopy = this.copiedCellText !== null && clipboardText === this.copiedCellText;
+        if (isInternalCopy && this.copiedCellData && this.copiedCellParams) {
+            const copiedColumnName = this.copiedCellParams.colDef?.field;
+            const copiedCellDataTypeName = this.copiedCellData[copiedColumnName].property.typeName;
+            const pastedCellDataTypeName = pastedCellConfig.property.typeName;
+            if (copiedCellDataTypeName !== pastedCellDataTypeName) {
+                this.uiNotification.error('Clipboard data type does not match the current cell data type: ' + copiedCellDataTypeName + ' vs ' + pastedCellDataTypeName);
+                return;
+            }
+            pastedCellConfig.$ = this.copiedCellValue;
+        }
         else {
-            pastedCellData[params.colDef?.field].$ = this.copiedCellValue;
-            this.removeBorderAnimation();
-            params.api.refreshCells({ force: true });
+            try {
+                pastedCellConfig.$ = this.parseExternalCellValue(clipboardText, pastedCellConfig);
+            }
+            catch (err) {
+                this.uiNotification.error(err.message);
+                return;
+            }
         }
+        this.removeBorderAnimation();
+        params.api.refreshCells({ force: true });
     };
     copyRow = async (tableName, columnDefs, copiedRows, includeHeaders = false) => {
         this.tableName = tableName;
         this.copiedRows = copiedRows;
+        this.copiedRowsText = null;
         this.removeBorderAnimation();
         this.addRowBorderAnimation();
         if (copiedRows.length) {
@@ -7364,6 +7448,7 @@ class TruDataGridClipboard {
                 });
                 multiRowString += rowPropertyValues.join('\t') + '\n';
             });
+            this.copiedRowsText = this.normalizeClipboardText(multiRowString);
             try {
                 await navigator.clipboard.writeText(multiRowString);
             }
@@ -7372,7 +7457,19 @@ class TruDataGridClipboard {
             }
         }
     };
-    pasteRow = (gridApi, config, selectedRows) => {
+    pasteRow = async (gridApi, config, selectedRows) => {
+        let clipboardText;
+        try {
+            clipboardText = this.normalizeClipboardText(await this.readClipboardText());
+        }
+        catch (err) {
+            this.uiNotification.error('Unable to read data from the system clipboard.');
+            return;
+        }
+        if (this.copiedRowsText === null || clipboardText !== this.copiedRowsText) {
+            this.uiNotification.error('External row data cannot be pasted as an internal grid row copy. Paste into an individual cell instead.');
+            return;
+        }
         if (this.tableName !== config.tableName) {
             this.uiNotification.error('Clipboard data does not match the current table name: ' + this.tableName + ' vs ' + config.tableName);
             return;
@@ -9127,27 +9224,36 @@ class TruDataGrid {
                 this.dataGridClipboard.copyRow(this.config.tableName, columnDefs, selectedRows);
         }
         else if (params.column.isPinned() && event.ctrlKey && event.code === 'KeyV') {
-            this.dataGridClipboard.pasteRow(this.api, this.config, this.api.getSelectedRows());
+            event.preventDefault();
+            void this.dataGridClipboard.pasteRow(this.api, this.config, this.api.getSelectedRows());
         }
         else if (!params.column.isPinned() && event.ctrlKey && event.code === 'KeyC') {
             this.dataGridClipboard.copyCell(params, this.config.tableName, params.colDef?.field, params.data, params.data.$entity);
         }
         else if (!params.column.isPinned() && event.ctrlKey && event.code === 'KeyV') {
-            this.dataGridClipboard.pasteCell(params, params.data, params.data.$entity);
+            event.preventDefault();
+            void this.dataGridClipboard.pasteCell(params, params.data, params.data.$entity);
         }
     };
     onCellMouseOver(e) {
-        let targetElement = e.event.target;
-        let fieldName = e.colDef.field;
-        let propertyConfig = e.data[fieldName];
+        let targetElement = e?.event?.target;
+        const fieldName = e?.colDef?.field;
+        const rowData = e?.data;
+        const propertyConfig = fieldName ? rowData?.[fieldName] : undefined;
         let propertyPathParts = [];
-        if (propertyConfig?.propertyPath.includes('.')) {
+        if (typeof propertyConfig?.propertyPath === 'string' && propertyConfig.propertyPath.includes('.')) {
             propertyPathParts = this.getPropertyPathParts(propertyConfig.propertyPath);
         }
-        let entityToValidate = propertyPathParts.length ? propertyPathParts.reduce((p, c) => p && p[c] || null, e.data.$entity) : e.data.$entity;
-        if (targetElement &&
+        let entityToValidate = rowData?.$entity ?? null;
+        for (const propertyPathPart of propertyPathParts) {
+            entityToValidate = entityToValidate?.[propertyPathPart] ?? null;
+            if (entityToValidate === null)
+                break;
+        }
+        if (targetElement?.classList &&
+            propertyConfig?.propertyName &&
             !targetElement.classList.contains('ag-cell-popup-editing') &&
-            entityToValidate.entityAspect.hasValidationErrors) {
+            entityToValidate?.entityAspect?.hasValidationErrors === true) {
             if (!targetElement.classList.contains('ag-cell'))
                 targetElement = targetElement.closest('.ag-cell');
             if (targetElement && targetElement.classList.contains('invalid')) {