bpmn-js 18.13.2 → 18.14.0

package/dist/bpmn-modeler.development.js

@@ -1,5 +1,5 @@
 /*!
- * bpmn-js - bpmn-modeler v18.13.2
+ * bpmn-js - bpmn-modeler v18.14.0
  *
  * Copyright (c) 2014-present, camunda Services GmbH
  *
@@ -8,7 +8,7 @@
  *
  * Source Code: https://github.com/bpmn-io/bpmn-js
  *
- * Date: 2026-03-23
+ * Date: 2026-03-27
  */
 (function (global, factory) {
 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -123,7 +123,7 @@
 	 *
 	 * @param {Object} [element] element to bind the id to
 	 *
-	 * @return {String} id
+	 * @return {string} id
 	 */
 	Ids$1.prototype.next = function(element) {
 	  return this._seed(element || true);
@@ -134,7 +134,7 @@
 	 *
 	 * @param {Object} [element] element to bind the id to
 	 *
-	 * @return {String} id
+	 * @return {string} id
 	 */
 	Ids$1.prototype.nextPrefixed = function(prefix, element) {
 	  var id;
@@ -153,8 +153,8 @@
 	/**
 	 * Manually claim an existing id.
 	 *
-	 * @param {String} id
-	 * @param {String} [element] element the id is claimed by
+	 * @param {string} id
+	 * @param {any} [element] element the id is claimed by
 	 */
 	Ids$1.prototype.claim = function(id, element) {
 	  this._seed.set(id, element || true);
@@ -163,8 +163,8 @@
 	/**
 	 * Returns true if the given id has already been assigned.
 	 *
-	 * @param  {String} id
-	 * @return {Boolean}
+	 * @param  {string} id
+	 * @return {boolean}
 	 */
 	Ids$1.prototype.assigned = function(id) {
 	  return this._seed.get(id) || false;
@@ -173,7 +173,7 @@
 	/**
 	 * Unclaim an id.
 	 *
-	 * @param  {String} id the id to unclaim
+	 * @param  {string} id the id to unclaim
 	 */
 	Ids$1.prototype.unclaim = function(id) {
 	  delete this._seed.hats[id];
@@ -28757,11 +28757,16 @@
 	/**
 	 * @typedef { {
 	 *   index: number;
-	 *   match: boolean;
-	 *   value: string;
-	 * } } Token
+	 *   value: string,
+	 *   match?: boolean;
+	 *   start?: boolean;
+	 *   end?: boolean;
+	 *   wordStart?: boolean;
+	 *   wordEnd?: boolean;
+	 *   all?: boolean;
+	 * } } BaseToken
 	 *
-	 * @typedef {Token[]} Tokens
+	 * @typedef { BaseToken | BaseToken[] } Token
 	 */
 
 	/**
@@ -28769,7 +28774,7 @@
 	 *
 	 * @typedef { {
 	 *   item: R,
-	 *   tokens: Record<string, Tokens>
+	 *   tokens: Record<string, Token[]>
 	 * } } SearchResult
 	 */
 
@@ -28780,15 +28785,15 @@
 	/**
 	 * Search items by query.
 	 *
-	 * @template {SearchItem} T
+	 * @template { SearchItem } T
 	 *
-	 * @param {T[]} items elements to search in
-	 * @param {string} pattern pattern to search for
+	 * @param { T[] } items elements to search in
+	 * @param { string } pattern pattern to search for
 	 * @param { {
 	 *   keys: string[];
 	 * } } options
 	 *
-	 * @returns {SearchResult<T>[]}
+	 * @returns { SearchResult<T>[] }
 	 */
 	function search(items, pattern, options) {
 
@@ -28804,7 +28809,7 @@
 
 	  const words = pattern.trim().toLowerCase().split(/\s+/);
 
-	  return items.flatMap((item) => {
+	  return items.flatMap((/** @type {T} */ item) => {
 	    const tokens = matchItem(item, words, keys);
 
 	    if (!tokens) {
@@ -28821,11 +28826,11 @@
 	/**
 	 * Match an item and return tokens in case of a match.
 	 *
-	 * @param {SearchItem} item element to be matched
-	 * @param {string[]} words words from search pattern to find
-	 * @param {string[]} keys keys to search in the item
+	 * @param { SearchItem } item element to be matched
+	 * @param { string[] } words words from search pattern to find
+	 * @param { string[] } keys keys to search in the item
 	 *
-	 * @returns {Record<string, Tokens>}
+	 * @returns { Record<string, Token[]> | null }
 	 */
 	function matchItem(item, words, keys) {
 
@@ -28852,8 +28857,8 @@
 	          };
 	        },
 	        {
-	          matchedWords: {},
-	          tokens: []
+	          matchedWords: /** @type { Record<string, boolean> } */ ({}),
+	          tokens: /** @type { Token[] } */ ([])
 	        }
 	      )
 	    ) : (
@@ -28886,15 +28891,17 @@
 	/**
 	 * Creates a compare function that can be used in Array.sort() based on a custom scoring function
 	 *
-	 * @param {string[]} keys
+	 * @template {SearchItem} T
 	 *
-	 * @returns { (resultA: SearchResult, resultB: SearchResult) => number}
+	 * @param { string[] } keys
+	 *
+	 * @returns { (resultA: SearchResult<T>, resultB: SearchResult<T>) => number }
 	 */
 	function createResultSorter(keys) {
 
 	  /**
-	   * @param {SearchResult} resultA
-	   * @param {SearchResult} resultB
+	   * @param { SearchResult<T> } resultA
+	   * @param { SearchResult<T> } resultB
 	   */
 	  return (resultA, resultB) => {
 	    let comparison = 0;
@@ -28911,7 +28918,7 @@
 
 	      if (tokenComparison !== 0) {
 	        comparison += tokenComparison * modifier;
-	        modifier *= 0.9;
+	        modifier *= DECAY_MODIFIER;
 	        continue;
 	      }
 
@@ -28922,7 +28929,7 @@
 
 	      if (stringComparison !== 0) {
 	        comparison += stringComparison * modifier;
-	        modifier *= 0.9;
+	        modifier *= DECAY_MODIFIER;
 	        continue;
 	      }
 	    }
@@ -28935,21 +28942,43 @@
 	/**
 	 * Compares two token arrays.
 	 *
-	 * @param {Token[]} [tokensA]
-	 * @param {Token[]} [tokensB]
+	 * @param { Token[] } tokensA
+	 * @param { Token[] } tokensB
 	 *
-	 * @returns {number}
+	 * @returns { number }
 	 */
 	function compareTokens(tokensA, tokensB) {
 	  return scoreTokens(tokensB) - scoreTokens(tokensA);
 	}
 
+	const DECAY_MODIFIER = 0.5;
+
+	const TOKEN_MATCH_SCORES = {
+	  FULL: 131.9,
+	  START_FULL_WORD: 8.0,
+	  START_WORD_PART: 7.87,
+	  WORD_START: 2.19,
+	  WORD_PART: 1,
+	  NO_MATCH: -0.07
+	};
+
 	/**
 	 * @param { Token[] } tokens
 	 * @returns { number }
 	 */
 	function scoreTokens(tokens) {
-	  return tokens.reduce((sum, token) => sum + scoreToken(token), 0);
+	  const baseScore = tokens.reduce((sum, token) => sum + scoreToken(token), 0);
+
+	  const flatTokens = tokens.flat();
+
+	  const totalLength = flatTokens.reduce((sum, token) => sum + token.value.length, 0);
+	  const matchedLength = flatTokens.reduce((sum, token) => sum + (token.match ? token.value.length : 0), 0);
+
+	  const density = totalLength ? matchedLength / totalLength : 0;
+
+	  const score = baseScore * (1 + density);
+
+	  return score;
 	}
 
 	/**
@@ -28968,28 +28997,30 @@
 	  const modifier = Math.log(token.value.length);
 
 	  if (!token.match) {
-	    return -0.07 * modifier;
+	    return TOKEN_MATCH_SCORES.NO_MATCH * modifier;
 	  }
 
 	  return (
 	    token.start
 	      ? (
 	        token.end
-	          ? 131.9
-	          : 7.87
+	          ? TOKEN_MATCH_SCORES.FULL
+	          : token.wordEnd
+	            ? TOKEN_MATCH_SCORES.START_FULL_WORD
+	            : TOKEN_MATCH_SCORES.START_WORD_PART
 	      )
 	      : (
 	        token.wordStart
-	          ? 2.19
-	          : 1
+	          ? TOKEN_MATCH_SCORES.WORD_START
+	          : TOKEN_MATCH_SCORES.WORD_PART
 	      )
 	  ) * modifier;
 	}
 
 	/**
-	 * @param {string|string[]} [str='']
+	 * @param { string|string[] } [str='']
 	 *
-	 * @return {string}
+	 * @return { string }
 	 */
 	function stringJoin(str = '') {
 	  return isArray$2(str) ? str.join(', ') : str;
@@ -28998,10 +29029,10 @@
 	/**
 	 * Compares two strings. also supports string arrays, which will be joined
 	 *
-	 * @param {string|string[]} [a]
-	 * @param {string|string[]} [b]
+	 * @param { string|string[] } [a]
+	 * @param { string|string[] } [b]
 	 *
-	 * @returns {number}
+	 * @returns { number }
 	 */
 	function compareStrings(a, b) {
 	  return stringJoin(a).localeCompare(stringJoin(b));
@@ -29011,11 +29042,11 @@
 	 * Match a given string against a set of words,
 	 * and return the result.
 	 *
-	 * @param {string} string
-	 * @param {string[]} words
+	 * @param { string } string
+	 * @param { string[] } words
 	 *
 	 * @return { {
-	 *   tokens: Token[],
+	 *   tokens: BaseToken[],
 	 *   matchedWords: Record<string, boolean>
 	 * } }
 	 */
@@ -29028,7 +29059,14 @@
 	    };
 	  }
 
+	  /**
+	   * @type { BaseToken[] }
+	   */
 	  const tokens = [];
+
+	  /**
+	   * @type { Record<string, boolean> }
+	   */
 	  const matchedWords = {};
 
 	  const wordsEscaped = words.map(escapeRegexp);
@@ -29053,7 +29091,7 @@
 	    const start = startIndex === 0;
 	    const end = endIndex === string.length;
 
-	    const all = !!match.groups.all;
+	    const all = !!match.groups?.all;
 
 	    const wordStart = start || /\s/.test(string.charAt(startIndex - 1));
 	    const wordEnd = end || /\s/.test(string.charAt(endIndex));
@@ -29102,6 +29140,13 @@
 	  };
 	}
 
+	/**
+	 * Escape string to not contain illegal regexp chars.
+	 *
+	 * @param { string } string
+	 *
+	 * @return { string }
+	 */
 	function escapeRegexp(string) {
 	  return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
 	}