@synerise/ds-utils 1.5.1 → 1.5.2

package/CHANGELOG.md

@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.5.2](https://github.com/synerise/synerise-design/compare/@synerise/ds-utils@1.5.1...@synerise/ds-utils@1.5.2) (2026-01-07)
+
+**Note:** Version bump only for package @synerise/ds-utils
+
 ## [1.5.1](https://github.com/synerise/synerise-design/compare/@synerise/ds-utils@1.5.0...@synerise/ds-utils@1.5.1) (2025-12-15)
 
 **Note:** Version bump only for package @synerise/ds-utils

package/dist/index.d.ts

@@ -23,5 +23,6 @@ export * from './omitKeys/omitKeys';
 export * from './useTraceUpdate';
 export * from './getPopupContainer';
 export * from './useLatestRef';
+export * from './useDelimiterEscape/useDelimiterEscape';
 export declare const NOOP: () => void;
 export type { DataAttributes, ExactlyOne, LiteralStringUnion, WithHTMLAttributes, DeepPartial, RequiredProps, ObjectStringKeys, } from './types/types';

package/dist/index.js

@@ -23,4 +23,5 @@ export * from './omitKeys/omitKeys';
 export * from './useTraceUpdate';
 export * from './getPopupContainer';
 export * from './useLatestRef';
+export * from './useDelimiterEscape/useDelimiterEscape';
 export var NOOP = function NOOP() {};

package/dist/useDelimiterEscape/__specs__/testCases.d.ts

@@ -0,0 +1,6 @@
+export declare const validTestCases: string[];
+export declare const invalidTestCases: string[];
+export declare const splitWithCommaEscapeTestCases: {
+    input: string;
+    expected: string[];
+}[];

package/dist/useDelimiterEscape/__specs__/useDelimiterEscape.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/useDelimiterEscape/useDelimiterEscape.d.ts

@@ -0,0 +1,11 @@
+export interface DelimiterEscapeConfig {
+    delimiter?: string;
+    openTag?: string;
+    closeTag?: string;
+}
+export interface DelimiterEscapeUtils {
+    joinWithEscape: (items: string[]) => string;
+    splitWithEscape: (input: string) => string[];
+    isValidEscapedString: (input: string) => boolean;
+}
+export declare const useDelimiterEscape: (config?: DelimiterEscapeConfig) => DelimiterEscapeUtils;

package/dist/useDelimiterEscape/useDelimiterEscape.js

@@ -0,0 +1,136 @@
+import { useMemo } from 'react';
+export var useDelimiterEscape = function useDelimiterEscape(config) {
+  if (config === void 0) {
+    config = {};
+  }
+  var _config = config,
+    _config$delimiter = _config.delimiter,
+    delimiter = _config$delimiter === void 0 ? ',' : _config$delimiter,
+    _config$openTag = _config.openTag,
+    openTag = _config$openTag === void 0 ? '```' : _config$openTag,
+    _config$closeTag = _config.closeTag,
+    closeTag = _config$closeTag === void 0 ? '```' : _config$closeTag;
+  return useMemo(function () {
+    var joinWithEscape = function joinWithEscape(items) {
+      return items.map(function (item) {
+        return item.includes(delimiter) ? "" + openTag + item + closeTag : item;
+      }).join(delimiter);
+    };
+    var splitWithEscape = function splitWithEscape(input) {
+      var result = [];
+      var i = 0;
+      var openTagLen = openTag.length;
+      var closeTagLen = closeTag.length;
+      while (i < input.length) {
+        var current = '';
+
+        // Check if we're at the start of a potential opening sequence
+        if (input.substring(i, i + openTagLen) === openTag) {
+          var validOpening = i === 0 || input[i - 1] === delimiter;
+          if (validOpening) {
+            // This is a valid opening - consume the opening tag
+            i += openTagLen;
+            current = '';
+
+            // Find the closing tag (must be followed by delimiter or at end)
+            while (i < input.length) {
+              if (input.substring(i, i + closeTagLen) === closeTag) {
+                // Check if this is a valid closing
+                var validClosing = i + closeTagLen === input.length || input[i + closeTagLen] === delimiter;
+                if (validClosing) {
+                  // Found closing tag
+                  i += closeTagLen;
+                  break;
+                } else {
+                  // Not a valid closing - treat as content
+                  current += input[i];
+                  i++;
+                }
+              } else {
+                current += input[i];
+                i++;
+              }
+            }
+            // Push the item without the wrapper tags
+            result.push(current);
+          } else {
+            // Not a valid opening - treat as regular item
+            while (i < input.length && input[i] !== delimiter) {
+              current += input[i];
+              i++;
+            }
+            if (current) {
+              result.push(current);
+            }
+          }
+        } else {
+          // Regular item - consume until delimiter
+          while (i < input.length && input[i] !== delimiter) {
+            current += input[i];
+            i++;
+          }
+          if (current) {
+            result.push(current);
+          }
+        }
+
+        // Skip the delimiter
+        if (i < input.length && input[i] === delimiter) {
+          i++;
+        }
+      }
+      return result;
+    };
+    var isValidEscapedString = function isValidEscapedString(input) {
+      var inEscapeBlock = false;
+      var i = 0;
+      var openTagLen = openTag.length;
+      var closeTagLen = closeTag.length;
+      var delimiterLen = delimiter.length;
+      while (i < input.length) {
+        if (!inEscapeBlock) {
+          // Not in escape block - look for opening tag
+          if (input.substring(i, i + openTagLen) === openTag) {
+            // Check if this is a valid opening position
+            var validOpening = i === 0 || input.substring(i - delimiterLen, i) === delimiter;
+            if (validOpening) {
+              // Valid opening position - enter escape block
+              inEscapeBlock = true;
+              i += openTagLen;
+            } else {
+              // Not a valid opening position - treat as regular content
+              i++;
+            }
+          } else {
+            i++;
+          }
+        } else {
+          // In escape block - look for closing tag
+          if (input.substring(i, i + closeTagLen) === closeTag) {
+            // Check if this is a valid closing
+            // Valid closing: at end of string or followed by delimiter
+            var validClosing = i + closeTagLen === input.length || input.substring(i + closeTagLen, i + closeTagLen + delimiterLen) === delimiter;
+            if (validClosing) {
+              // This is a closing tag
+              inEscapeBlock = false;
+              i += closeTagLen;
+            } else {
+              // Not a valid closing - treat as regular content
+              i++;
+            }
+          } else {
+            i++;
+          }
+        }
+      }
+
+      // Invalid if we're still inside an escape block (unclosed opening tag)
+      return !inEscapeBlock;
+    };
+    return {
+      joinWithEscape: joinWithEscape,
+      splitWithEscape: splitWithEscape,
+      isValidEscapedString: isValidEscapedString
+    };
+  }, [delimiter, openTag, closeTag]);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synerise/ds-utils",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Utils UI Component for the Synerise Design System",
   "license": "ISC",
   "repository": "synerise/synerise-design",
@@ -41,5 +41,5 @@
     "react": ">=16.9.0 <= 18.3.1",
     "styled-components": "^5.3.3"
   },
-  "gitHead": "b1279d5354132a2bf0b6f0cfa343db4c6c928f72"
+  "gitHead": "f38e4b2dca1d43c39af0b189c93808de62c11e9b"
 }