@sendbird/uikit-react 3.14.3 → 3.14.5

package/chunks/bundle-DwvN2wPi.js

@@ -0,0 +1,120 @@
+import { a as __awaiter, b as __generator } from './bundle-CDy_GVNR.js';
+import { p as pxToNumber } from './bundle-BQPvwBK8.js';
+
+var compressImage = function (_a) {
+    var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight, outputFormat = _a.outputFormat;
+    var image = document.createElement('img');
+    return new Promise(function (resolve, reject) {
+        image.src = URL.createObjectURL(imageFile);
+        image.onerror = reject;
+        image.onload = function () {
+            URL.revokeObjectURL(image.src);
+            var canvas = document.createElement('canvas');
+            var originWidth = image.width;
+            var originHeight = image.height;
+            var targetResizingWidth = (!resizingWidth || resizingWidth > originWidth) ? originWidth : resizingWidth;
+            var targetResizingHeight = (!resizingHeight || resizingHeight > originHeight) ? originHeight : resizingHeight;
+            var widthRatio = originWidth / targetResizingWidth;
+            var heightRatio = originHeight / targetResizingHeight;
+            /**
+             * Set the target resizing values again with the calculated ratios
+             * to use the impactful value, so the original images' ratio won't be broken.
+             */
+            if (widthRatio > heightRatio) {
+                targetResizingHeight = originHeight / (resizingWidth ? widthRatio : 1);
+            }
+            else if (heightRatio > widthRatio) {
+                targetResizingWidth = originWidth / (resizingHeight ? heightRatio : 1);
+            }
+            canvas.width = targetResizingWidth;
+            canvas.height = targetResizingHeight;
+            var ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new Error('Failed to get canvas 2d context'));
+                return;
+            }
+            ctx.drawImage(image, 0, 0, targetResizingWidth, targetResizingHeight);
+            // Change the file.name & file.type for converting file type
+            var targetFileType = outputFormat === 'preserve' ? imageFile.type : "image/".concat(outputFormat);
+            var targetSubtype = targetFileType.split('/').pop();
+            var dotIndex = imageFile.name.lastIndexOf('.');
+            // targetName = `fileName.targetSubtype`
+            var targetName = "".concat(dotIndex === -1 ? imageFile.name : imageFile.name.substring(0, dotIndex), ".").concat(targetSubtype);
+            ctx.canvas.toBlob(function (blob) {
+                if (blob) {
+                    var file = new File([blob], targetName, { type: targetFileType });
+                    resolve(file);
+                }
+                else {
+                    reject(new Error('Failed to compress image'));
+                }
+            }, targetFileType, compressionRate);
+        };
+    });
+};
+var compressImages = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var compressionRate, _c, outputFormat, resizingWidth, resizingHeight, result;
+    var files = _b.files, logger = _b.logger, imageCompression = _b.imageCompression;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                compressionRate = imageCompression.compressionRate, _c = imageCompression.outputFormat, outputFormat = _c === void 0 ? 'preserve' : _c;
+                resizingWidth = pxToNumber(imageCompression.resizingWidth);
+                resizingHeight = pxToNumber(imageCompression.resizingHeight);
+                result = {
+                    failedIndexes: [],
+                    compressedFiles: [],
+                };
+                if (!(Array.isArray(files) && files.length > 0)) {
+                    logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: There are no files.', files);
+                    return [2 /*return*/, result];
+                }
+                if (compressionRate < 0 || 1 < compressionRate) {
+                    logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: The compressionRate is not acceptable.', compressionRate);
+                    return [2 /*return*/, result];
+                }
+                return [4 /*yield*/, Promise.all(files
+                        .map(function (file, index) { return __awaiter(void 0, void 0, void 0, function () {
+                        var compressedImage, err_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (!(file.type === 'image/jpg' || file.type === 'image/png' || file.type === 'image/jpeg')) {
+                                        logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: The fileType is not compressible.', { file: file, index: index });
+                                        result.failedIndexes.push(index);
+                                        result.compressedFiles.push(file);
+                                        return [2 /*return*/];
+                                    }
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 3, , 4]);
+                                    return [4 /*yield*/, compressImage({
+                                            imageFile: file,
+                                            compressionRate: compressionRate,
+                                            resizingWidth: resizingWidth,
+                                            resizingHeight: resizingHeight,
+                                            outputFormat: outputFormat,
+                                        })];
+                                case 2:
+                                    compressedImage = _a.sent();
+                                    result.compressedFiles.push(compressedImage);
+                                    return [3 /*break*/, 4];
+                                case 3:
+                                    err_1 = _a.sent();
+                                    result.failedIndexes.push(index);
+                                    logger === null || logger === void 0 ? void 0 : logger.warning('utils - compressImages: Failed to compress image file', { file: file, err: err_1 });
+                                    return [3 /*break*/, 4];
+                                case 4: return [2 /*return*/];
+                            }
+                        });
+                    }); }))];
+            case 1:
+                _d.sent();
+                logger === null || logger === void 0 ? void 0 : logger.info('utils - compressImages: Finished compressing images', result);
+                return [2 /*return*/, result];
+        }
+    });
+}); };
+
+export { compressImages as c };
+//# sourceMappingURL=bundle-DwvN2wPi.js.map

package/chunks/bundle-DwvN2wPi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-DwvN2wPi.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-CUPPssXo.js → bundle-E4462uBn.js}

@@ -1,30 +1,30 @@
-// we use pubsub to sync events between multiple components(example - ChannelList, Channel)
-// for example, if customer sends a message from their custom component
-// without pubsub,we would not be able to listen to it
-// in our ChannelList or Conversation
-var pubSubFactory = function () {
-    var topics = {};
-    return {
-        __getTopics: function () { return topics; },
-        subscribe: function (topic, listener) {
-            var _a;
-            (_a = topics[topic]) !== null && _a !== void 0 ? _a : (topics[topic] = new Set());
-            topics[topic].add(listener);
-            return {
-                remove: function () {
-                    topics[topic].delete(listener);
-                },
-            };
-        },
-        publish: function (topic, info) {
-            if (topics[topic]) {
-                topics[topic].forEach(function (fn) {
-                    setTimeout(function () { return fn(info !== undefined ? info : {}); }, 0);
-                });
-            }
-        },
-    };
+// we use pubsub to sync events between multiple components(example - ChannelList, Channel)
+// for example, if customer sends a message from their custom component
+// without pubsub,we would not be able to listen to it
+// in our ChannelList or Conversation
+var pubSubFactory = function () {
+    var topics = {};
+    return {
+        __getTopics: function () { return topics; },
+        subscribe: function (topic, listener) {
+            var _a;
+            (_a = topics[topic]) !== null && _a !== void 0 ? _a : (topics[topic] = new Set());
+            topics[topic].add(listener);
+            return {
+                remove: function () {
+                    topics[topic].delete(listener);
+                },
+            };
+        },
+        publish: function (topic, info) {
+            if (topics[topic]) {
+                topics[topic].forEach(function (fn) {
+                    setTimeout(function () { return fn(info !== undefined ? info : {}); }, 0);
+                });
+            }
+        },
+    };
 };
 
 export { pubSubFactory as p };
-//# sourceMappingURL=bundle-CUPPssXo.js.map
+//# sourceMappingURL=bundle-E4462uBn.js.map

package/chunks/bundle-E4462uBn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-E4462uBn.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-BLMDgHS-.js → bundle-HFOQJZAX.js}

@@ -1,88 +1,88 @@
 import { useRef, useEffect } from 'react';
 import { usePreservedCallback } from '@sendbird/uikit-tools';
 
-/**
- * Note: `leading` has higher priority rather than `trailing`
- * */
-function useThrottleCallback(callback, delay, options) {
-    if (options === void 0) { options = {
-        leading: true,
-        trailing: false,
-    }; }
-    var timer = useRef(null);
-    var trailingArgs = useRef(null);
-    useEffect(function () {
-        return function () {
-            if (timer.current)
-                clearTimeout(timer.current);
-        };
-    }, []);
-    return usePreservedCallback(function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        if (timer.current) {
-            trailingArgs.current = args;
-            return;
-        }
-        if (options.leading) {
-            callback.apply(void 0, args);
-        }
-        else {
-            trailingArgs.current = args;
-        }
-        var invoke = function () {
-            if (options.trailing && trailingArgs.current) {
-                callback.apply(void 0, trailingArgs.current);
-                trailingArgs.current = null;
-                timer.current = setTimeout(invoke, delay);
-            }
-            else {
-                timer.current = null;
-            }
-        };
-        timer.current = setTimeout(invoke, delay);
-    });
-}
-/**
- * Note: `leading` has higher priority rather than `trailing`
- * */
-function throttle(callback, delay, options) {
-    if (options === void 0) { options = {
-        leading: true,
-        trailing: false,
-    }; }
-    var timer = null;
-    var trailingArgs = null;
-    return (function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        if (timer) {
-            trailingArgs = args;
-            return;
-        }
-        if (options.leading) {
-            callback.apply(void 0, args);
-        }
-        else {
-            trailingArgs = args;
-        }
-        var invoke = function () {
-            if (options.trailing && trailingArgs) {
-                callback.apply(void 0, trailingArgs);
-                trailingArgs = null;
-                timer = setTimeout(invoke, delay);
-            }
-            else {
-                timer = null;
-            }
-        };
-        timer = setTimeout(invoke, delay);
-    });
+/**
+ * Note: `leading` has higher priority rather than `trailing`
+ * */
+function useThrottleCallback(callback, delay, options) {
+    if (options === void 0) { options = {
+        leading: true,
+        trailing: false,
+    }; }
+    var timer = useRef(null);
+    var trailingArgs = useRef(null);
+    useEffect(function () {
+        return function () {
+            if (timer.current)
+                clearTimeout(timer.current);
+        };
+    }, []);
+    return usePreservedCallback(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (timer.current) {
+            trailingArgs.current = args;
+            return;
+        }
+        if (options.leading) {
+            callback.apply(void 0, args);
+        }
+        else {
+            trailingArgs.current = args;
+        }
+        var invoke = function () {
+            if (options.trailing && trailingArgs.current) {
+                callback.apply(void 0, trailingArgs.current);
+                trailingArgs.current = null;
+                timer.current = setTimeout(invoke, delay);
+            }
+            else {
+                timer.current = null;
+            }
+        };
+        timer.current = setTimeout(invoke, delay);
+    });
+}
+/**
+ * Note: `leading` has higher priority rather than `trailing`
+ * */
+function throttle(callback, delay, options) {
+    if (options === void 0) { options = {
+        leading: true,
+        trailing: false,
+    }; }
+    var timer = null;
+    var trailingArgs = null;
+    return (function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (timer) {
+            trailingArgs = args;
+            return;
+        }
+        if (options.leading) {
+            callback.apply(void 0, args);
+        }
+        else {
+            trailingArgs = args;
+        }
+        var invoke = function () {
+            if (options.trailing && trailingArgs) {
+                callback.apply(void 0, trailingArgs);
+                trailingArgs = null;
+                timer = setTimeout(invoke, delay);
+            }
+            else {
+                timer = null;
+            }
+        };
+        timer = setTimeout(invoke, delay);
+    });
 }
 
 export { throttle as t, useThrottleCallback as u };
-//# sourceMappingURL=bundle-BLMDgHS-.js.map
+//# sourceMappingURL=bundle-HFOQJZAX.js.map

package/chunks/bundle-HFOQJZAX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-HFOQJZAX.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-DBBVxbFA.js → bundle-HhDUyQa4.js}

@@ -1,146 +1,146 @@
-import { c as __spreadArray } from './bundle-DZcgZWKq.js';
+import { c as __spreadArray } from './bundle-CDy_GVNR.js';
 
 var USER_MENTION_PREFIX = '@';
 
-var TOKEN_TYPES = {
-    string: 'string',
-    mention: 'mention',
-    url: 'url',
-    undetermined: 'undetermined',
+var TOKEN_TYPES = {
+    string: 'string',
+    mention: 'mention',
+    url: 'url',
+    undetermined: 'undetermined',
 };
 
-function getUserMentionRegex(mentionedUsers, templatePrefix_) {
-    var templatePrefix = templatePrefix_ || USER_MENTION_PREFIX;
-    return RegExp("(".concat(mentionedUsers.map(function (u) {
-        var userId = u.userId.replace(
-        // If user.id includes these patterns, need to convert it into an escaped one
-        /([.*+?^${}()|[\]\\])/g, '\\$1');
-        /**
-         * //{ And //} are also for escaping
-         * because curly braces `{}` are metacharacters in regular expressions used to specify repetition
-         */
-        return "".concat(templatePrefix, "\\{").concat(userId, "\\}");
-    }).join('|'), ")"), 'g');
-}
-function identifyMentions(_a) {
-    var tokens = _a.tokens, _b = _a.mentionedUsers, mentionedUsers = _b === void 0 ? [] : _b, _c = _a.templatePrefix, templatePrefix = _c === void 0 ? USER_MENTION_PREFIX : _c;
-    if (!(mentionedUsers === null || mentionedUsers === void 0 ? void 0 : mentionedUsers.length)) {
-        return tokens;
-    }
-    var userMentionRegex = getUserMentionRegex(mentionedUsers, templatePrefix);
-    var results = tokens.map(function (token) {
-        // if the token is not undetermined, return it as is
-        // is kinda unnecessary with TS, but just in case
-        if (token.type !== TOKEN_TYPES.undetermined) {
-            return token;
-        }
-        var value = token.value;
-        var parts = value.split(userMentionRegex);
-        var tokens = parts.map(function (part) {
-            if (part.match(userMentionRegex)) {
-                var matchedUser = mentionedUsers.find(function (user) { return "@{".concat(user === null || user === void 0 ? void 0 : user.userId, "}") === part; });
-                var nickname = (matchedUser === null || matchedUser === void 0 ? void 0 : matchedUser.nickname) || '(No name)';
-                return { value: nickname, type: TOKEN_TYPES.mention, userId: matchedUser === null || matchedUser === void 0 ? void 0 : matchedUser.userId };
-            }
-            else {
-                return { value: part, type: TOKEN_TYPES.undetermined };
-            }
-        });
-        return tokens;
-    }).flat();
-    return results;
-}
-function identifyUrlsAndStrings(token) {
-    var URL_REG = /(?:https?:\/\/|www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.(xn--)?[a-z]{2,20}\b([-a-zA-Z0-9@:%_+[\],.~#?&/=]*[-a-zA-Z0-9@:%_+~#?&/=])*/g;
-    var results = token.map(function (token) {
-        if (token.type !== TOKEN_TYPES.undetermined) {
-            return token;
-        }
-        var _a = token.value, value = _a === void 0 ? '' : _a;
-        var matches = Array.from(value.matchAll(URL_REG));
-        var founds = matches.map(function (value) {
-            var _a;
-            var text = value[0];
-            var start = (_a = value.index) !== null && _a !== void 0 ? _a : 0;
-            var end = start + text.length;
-            return { text: text, start: start, end: end };
-        });
-        var items = [{ value: value, type: TOKEN_TYPES.string }];
-        var cursor = 0;
-        founds.forEach(function (_a) {
-            var text = _a.text, start = _a.start, end = _a.end;
-            var restText = items.pop().value;
-            var head = restText.slice(0, start - cursor);
-            var mid = text;
-            var tail = restText.slice(end - cursor);
-            if (head.length > 0)
-                items.push({ value: head, type: TOKEN_TYPES.string });
-            items.push({ value: mid, type: TOKEN_TYPES.url });
-            if (tail.length > 0)
-                items.push({ value: tail, type: TOKEN_TYPES.string });
-            cursor = end;
-        });
-        return items;
-    }).flat();
-    return results;
-}
-function combineNearbyStrings(tokens) {
-    var results = tokens.reduce(function (acc, token) {
-        var lastToken = acc[acc.length - 1];
-        if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.type) === TOKEN_TYPES.string && token.type === TOKEN_TYPES.string) {
-            lastToken.value = "".concat(lastToken.value).concat(token.value);
-            return acc;
-        }
-        return __spreadArray(__spreadArray([], acc, true), [token], false);
-    }, []);
-    return results;
-}
-/**
- * Converts text into set of rich tokens
- */
-function tokenizeMessage(_a) {
-    var messageText = _a.messageText, _b = _a.mentionedUsers, mentionedUsers = _b === void 0 ? [] : _b, _c = _a.templatePrefix, templatePrefix = _c === void 0 ? USER_MENTION_PREFIX : _c;
-    // mention can be squeezed-in(no-space-between) with other mentions and urls
-    // if no users are mentioned, return the messageText as a single token
-    var partialResult = [{
-            type: TOKEN_TYPES.undetermined,
-            value: messageText,
-        }];
-    // order is important because we want to identify mentions first
-    // identifyMentions will return a token with type mention or undetermined
-    var partialWithMentions = identifyMentions({
-        tokens: partialResult,
-        mentionedUsers: mentionedUsers,
-        templatePrefix: templatePrefix,
-    });
-    var partialsWithUrlsAndMentions = identifyUrlsAndStrings(partialWithMentions);
-    var result = combineNearbyStrings(partialsWithUrlsAndMentions);
-    return result;
-}
-/**
- * Don't need to use this util in DOM element since the white spaces will be kept as is,
- * but will need if the text is wrapped \w React.Fragement or </>
- * @link https://sendbird.slack.com/archives/GPGHESTL3/p1681180484341369
- * Or!!! -> convert any space or tab in leading/trailing to nbsp
- * to preserve the leading & trailing white spaces
- */
-function getWhiteSpacePreservedText(text) {
-    var NON_BREAKING_SPACE = '\u00A0';
-    // Split the input string into lines
-    var lines = text.split('\n');
-    // Process each line and convert leading and trailing white spaces to "\u00A0"
-    var processedLines = lines.map(function (line) {
-        var _a, _b;
-        var leadingWhitespace = ((_a = line.match(/^\s*/)) === null || _a === void 0 ? void 0 : _a[0]) || '';
-        var trailingWhitespace = ((_b = line.match(/\s*$/)) === null || _b === void 0 ? void 0 : _b[0]) || '';
-        var convertedLeadingWhitespace = leadingWhitespace.replace(/ /g, NON_BREAKING_SPACE);
-        var convertedTrailingWhitespace = trailingWhitespace.replace(/ /g, NON_BREAKING_SPACE);
-        return convertedLeadingWhitespace + line.trim() + convertedTrailingWhitespace;
-    });
-    // Combine the processed lines into a new string with "\n"
-    var result = processedLines.join('\n');
-    return result;
+function getUserMentionRegex(mentionedUsers, templatePrefix_) {
+    var templatePrefix = templatePrefix_ || USER_MENTION_PREFIX;
+    return RegExp("(".concat(mentionedUsers.map(function (u) {
+        var userId = u.userId.replace(
+        // If user.id includes these patterns, need to convert it into an escaped one
+        /([.*+?^${}()|[\]\\])/g, '\\$1');
+        /**
+         * //{ And //} are also for escaping
+         * because curly braces `{}` are metacharacters in regular expressions used to specify repetition
+         */
+        return "".concat(templatePrefix, "\\{").concat(userId, "\\}");
+    }).join('|'), ")"), 'g');
+}
+function identifyMentions(_a) {
+    var tokens = _a.tokens, _b = _a.mentionedUsers, mentionedUsers = _b === void 0 ? [] : _b, _c = _a.templatePrefix, templatePrefix = _c === void 0 ? USER_MENTION_PREFIX : _c;
+    if (!(mentionedUsers === null || mentionedUsers === void 0 ? void 0 : mentionedUsers.length)) {
+        return tokens;
+    }
+    var userMentionRegex = getUserMentionRegex(mentionedUsers, templatePrefix);
+    var results = tokens.map(function (token) {
+        // if the token is not undetermined, return it as is
+        // is kinda unnecessary with TS, but just in case
+        if (token.type !== TOKEN_TYPES.undetermined) {
+            return token;
+        }
+        var value = token.value;
+        var parts = value.split(userMentionRegex);
+        var tokens = parts.map(function (part) {
+            if (part.match(userMentionRegex)) {
+                var matchedUser = mentionedUsers.find(function (user) { return "@{".concat(user === null || user === void 0 ? void 0 : user.userId, "}") === part; });
+                var nickname = (matchedUser === null || matchedUser === void 0 ? void 0 : matchedUser.nickname) || '(No name)';
+                return { value: nickname, type: TOKEN_TYPES.mention, userId: matchedUser === null || matchedUser === void 0 ? void 0 : matchedUser.userId };
+            }
+            else {
+                return { value: part, type: TOKEN_TYPES.undetermined };
+            }
+        });
+        return tokens;
+    }).flat();
+    return results;
+}
+function identifyUrlsAndStrings(token) {
+    var URL_REG = /(?:https?:\/\/|www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.(xn--)?[a-z]{2,20}\b([-a-zA-Z0-9@:%_+[\],.~#?&/=]*[-a-zA-Z0-9@:%_+~#?&/=])*/g;
+    var results = token.map(function (token) {
+        if (token.type !== TOKEN_TYPES.undetermined) {
+            return token;
+        }
+        var _a = token.value, value = _a === void 0 ? '' : _a;
+        var matches = Array.from(value.matchAll(URL_REG));
+        var founds = matches.map(function (value) {
+            var _a;
+            var text = value[0];
+            var start = (_a = value.index) !== null && _a !== void 0 ? _a : 0;
+            var end = start + text.length;
+            return { text: text, start: start, end: end };
+        });
+        var items = [{ value: value, type: TOKEN_TYPES.string }];
+        var cursor = 0;
+        founds.forEach(function (_a) {
+            var text = _a.text, start = _a.start, end = _a.end;
+            var restText = items.pop().value;
+            var head = restText.slice(0, start - cursor);
+            var mid = text;
+            var tail = restText.slice(end - cursor);
+            if (head.length > 0)
+                items.push({ value: head, type: TOKEN_TYPES.string });
+            items.push({ value: mid, type: TOKEN_TYPES.url });
+            if (tail.length > 0)
+                items.push({ value: tail, type: TOKEN_TYPES.string });
+            cursor = end;
+        });
+        return items;
+    }).flat();
+    return results;
+}
+function combineNearbyStrings(tokens) {
+    var results = tokens.reduce(function (acc, token) {
+        var lastToken = acc[acc.length - 1];
+        if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.type) === TOKEN_TYPES.string && token.type === TOKEN_TYPES.string) {
+            lastToken.value = "".concat(lastToken.value).concat(token.value);
+            return acc;
+        }
+        return __spreadArray(__spreadArray([], acc, true), [token], false);
+    }, []);
+    return results;
+}
+/**
+ * Converts text into set of rich tokens
+ */
+function tokenizeMessage(_a) {
+    var messageText = _a.messageText, _b = _a.mentionedUsers, mentionedUsers = _b === void 0 ? [] : _b, _c = _a.templatePrefix, templatePrefix = _c === void 0 ? USER_MENTION_PREFIX : _c;
+    // mention can be squeezed-in(no-space-between) with other mentions and urls
+    // if no users are mentioned, return the messageText as a single token
+    var partialResult = [{
+            type: TOKEN_TYPES.undetermined,
+            value: messageText,
+        }];
+    // order is important because we want to identify mentions first
+    // identifyMentions will return a token with type mention or undetermined
+    var partialWithMentions = identifyMentions({
+        tokens: partialResult,
+        mentionedUsers: mentionedUsers,
+        templatePrefix: templatePrefix,
+    });
+    var partialsWithUrlsAndMentions = identifyUrlsAndStrings(partialWithMentions);
+    var result = combineNearbyStrings(partialsWithUrlsAndMentions);
+    return result;
+}
+/**
+ * Don't need to use this util in DOM element since the white spaces will be kept as is,
+ * but will need if the text is wrapped \w React.Fragement or </>
+ * @link https://sendbird.slack.com/archives/GPGHESTL3/p1681180484341369
+ * Or!!! -> convert any space or tab in leading/trailing to nbsp
+ * to preserve the leading & trailing white spaces
+ */
+function getWhiteSpacePreservedText(text) {
+    var NON_BREAKING_SPACE = '\u00A0';
+    // Split the input string into lines
+    var lines = text.split('\n');
+    // Process each line and convert leading and trailing white spaces to "\u00A0"
+    var processedLines = lines.map(function (line) {
+        var _a, _b;
+        var leadingWhitespace = ((_a = line.match(/^\s*/)) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        var trailingWhitespace = ((_b = line.match(/\s*$/)) === null || _b === void 0 ? void 0 : _b[0]) || '';
+        var convertedLeadingWhitespace = leadingWhitespace.replace(/ /g, NON_BREAKING_SPACE);
+        var convertedTrailingWhitespace = trailingWhitespace.replace(/ /g, NON_BREAKING_SPACE);
+        return convertedLeadingWhitespace + line.trim() + convertedTrailingWhitespace;
+    });
+    // Combine the processed lines into a new string with "\n"
+    var result = processedLines.join('\n');
+    return result;
 }
 
 export { TOKEN_TYPES as T, USER_MENTION_PREFIX as U, getWhiteSpacePreservedText as g, tokenizeMessage as t };
-//# sourceMappingURL=bundle-DBBVxbFA.js.map
+//# sourceMappingURL=bundle-HhDUyQa4.js.map

package/chunks/bundle-HhDUyQa4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-HhDUyQa4.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}