blixify-ui-web 0.4.217 → 0.4.218

package/lib/components/data/dataTemplate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/data/dataTemplate/index.tsx"],"names":[],"mappings":"AAkCA,OAAO,KAQN,MAAM,OAAO,CAAC;AAuEf,OAAO,EACL,iBAAiB,EAKlB,MAAM,kBAAkB,CAAC;AAoB1B,eAAO,MAAM,YAAY,mFAw4QvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/data/dataTemplate/index.tsx"],"names":[],"mappings":"AAkCA,OAAO,KAQN,MAAM,OAAO,CAAC;AAuEf,OAAO,EACL,iBAAiB,EAKlB,MAAM,kBAAkB,CAAC;AAoB1B,eAAO,MAAM,YAAY,mFAu+QvB,CAAC"}

package/lib/components/data/dataTemplate/index.js

@@ -1644,10 +1644,30 @@ exports.DataTemplate = (0, react_1.forwardRef)(function (props, ref) {
                                     if (!(selectedField instanceof File ||
                                         eachImage.type === "signature")) return [3 /*break*/, 8];
                                     imageValue = selectedField;
-                                    if (eachImage.type === "signature" &&
-                                        selectedField &&
-                                        typeof selectedField === "string") {
-                                        imageValue = (0, blobModule_1.handleDataURLtoBlob)(selectedField);
+                                    // For signatures, handle the case where it might be undefined, null, or empty
+                                    if (eachImage.type === "signature") {
+                                        // If it's undefined or null, return empty string (no signature)
+                                        if (!selectedField || selectedField === null) {
+                                            return [2 /*return*/, ""];
+                                        }
+                                        // If it's a string, check if it's a data URL or token
+                                        if (typeof selectedField === "string") {
+                                            // Check if it's a data URL (new signature) or a token (existing signature from database)
+                                            // Data URLs start with "data:image", tokens don't
+                                            if (selectedField.startsWith("data:image")) {
+                                                // New signature - convert data URL to blob for upload
+                                                imageValue = (0, blobModule_1.handleDataURLtoBlob)(selectedField);
+                                            }
+                                            else if (selectedField && selectedField !== "") {
+                                                // Existing signature token from database - return as-is, don't re-upload
+                                                // Only return if it's a non-empty string (valid token)
+                                                return [2 /*return*/, selectedField];
+                                            }
+                                            else {
+                                                // Empty string - no signature, return empty
+                                                return [2 /*return*/, ""];
+                                            }
+                                        }
                                     }
                                     imageCollectionName = (_a = eachImage.imageCollectionName) !== null && _a !== void 0 ? _a : "";
                                     if (objectId) {
@@ -3227,10 +3247,75 @@ exports.DataTemplate = (0, react_1.forwardRef)(function (props, ref) {
         }
     };
     var handleSignatureComplete = function (dataURL, id) {
-        var _a = handleOnChangeData(), data = _a.data, model = _a.model;
-        var clonedData = (0, updateModule_1.handleClonedDataAttribute)(data, model, props.devSettings.server, false, remainId);
-        clonedData[id] = dataURL;
-        handleUpdateChangeData(clonedData);
+        var model = handleOnChangeData().model;
+        // Helper function to determine if we should preserve the existing token
+        var shouldPreserveToken = function (currentValue, newDataURL) {
+            // If newDataURL is empty but there's an existing token, preserve it
+            // This happens when:
+            // 1. Signature validation passes but user didn't draw a new signature
+            // 2. User cleared the signature but didn't draw anything new
+            return ((!newDataURL || newDataURL === "") &&
+                currentValue &&
+                currentValue !== "" &&
+                // Only preserve if it's a token (not a data URL)
+                typeof currentValue === "string" &&
+                !currentValue.startsWith("data:image"));
+        };
+        // Handle modal and batch update cases through handleUpdateChangeData
+        if (modalVisible && selectedObjectStructureId) {
+            // For modal case, update selectedObjectData
+            setSelectedObjectData(function (prevObjectData) {
+                var clonedData = (0, updateModule_1.handleClonedDataAttribute)(prevObjectData, model, props.devSettings.server, false, remainId);
+                // Preserve token if dataURL is empty and there's an existing token
+                if (shouldPreserveToken(clonedData[id], dataURL)) {
+                    // Don't overwrite - keep the existing token
+                }
+                else {
+                    clonedData[id] = dataURL;
+                }
+                return clonedData;
+            });
+        }
+        else if (batchUpdateModal && batchUpdateData.columnId) {
+            // For batch update case, update batchUpdateData
+            var selectedModel = structure.find(function (eachModel) { return eachModel.id === batchUpdateData.columnId; });
+            if (selectedModel && selectedModel.id === id) {
+                setBatchUpdateData(function (prevBatchData) {
+                    var _a;
+                    var currentValue = (_a = prevBatchData.columnData) === null || _a === void 0 ? void 0 : _a[id];
+                    var newColumnData = __assign({}, prevBatchData.columnData);
+                    // Preserve token if dataURL is empty and there's an existing token
+                    if (shouldPreserveToken(currentValue, dataURL)) {
+                        // Don't overwrite - keep the existing token
+                        newColumnData[id] = currentValue;
+                    }
+                    else {
+                        newColumnData[id] = dataURL;
+                    }
+                    return __assign(__assign({}, prevBatchData), { columnData: newColumnData });
+                });
+            }
+        }
+        else {
+            // Normal case: Use functional update to ensure we're working with the latest state
+            // This prevents the issue where handleClonedDataAttribute copies stale state
+            setSelectedData(function (prevSelectedData) {
+                var clonedData = (0, updateModule_1.handleClonedDataAttribute)(prevSelectedData, model, props.devSettings.server, false, remainId);
+                // If dataURL is empty but there's an existing token, preserve it
+                // This happens when signature validation passes but user didn't draw a new signature
+                // or when user cleared but didn't draw anything new
+                if (shouldPreserveToken(clonedData[id], dataURL)) {
+                    // Don't overwrite - keep the existing token (clonedData[id] remains unchanged)
+                }
+                else {
+                    // New signature or explicitly clearing - update the value
+                    clonedData[id] = dataURL;
+                }
+                return clonedData;
+            });
+        }
+        // Note: Can't check state immediately after setState - it's async
+        // But we can verify it worked by checking in the next render or at submission
     };
     var handleOnChangeAddress = function (id, address) {
         var _a = handleOnChangeData(), data = _a.data, model = _a.model;