@excalidraw/element 0.18.0-816c81c → 0.18.0-81ab857

package/dist/dev/index.js

@@ -4316,91 +4316,168 @@ var parseTokens = (line2) => {
   return line2.normalize("NFC").split(breakLineRegex).filter(Boolean);
 };
 var wrapText = (text, font, maxWidth) => {
+  return getWrappedTextLines(text, font, maxWidth).map((line2) => line2.text).join("\n");
+};
+var getHardLineBreaks = (text) => {
+  let offset = 0;
+  return text.split("\n").map((line2) => {
+    const start = offset;
+    const end = start + line2.length;
+    offset = end + 1;
+    return {
+      text: line2,
+      start,
+      end
+    };
+  });
+};
+var getWrappedTextLines = (text, font, maxWidth) => {
   if (!Number.isFinite(maxWidth) || maxWidth < 0) {
-    return text;
+    return getHardLineBreaks(text);
   }
   const lines = [];
-  const originalLines = text.split("\n");
-  for (const originalLine of originalLines) {
-    const currentLineWidth = getLineWidth(originalLine, font);
-    if (currentLineWidth <= maxWidth) {
-      lines.push(originalLine);
-      continue;
+  let offset = 0;
+  for (const originalLine of text.split("\n")) {
+    const originalLineWidth = getLineWidth(originalLine, font);
+    if (originalLineWidth <= maxWidth) {
+      lines.push({
+        text: originalLine,
+        start: offset,
+        end: offset + originalLine.length
+      });
+    } else {
+      lines.push(...wrapLine(originalLine, font, maxWidth, offset));
     }
-    const wrappedLine = wrapLine(originalLine, font, maxWidth);
-    lines.push(...wrappedLine);
+    offset += originalLine.length + 1;
   }
-  return lines.join("\n");
+  return lines;
 };
-var wrapLine = (line2, font, maxWidth) => {
+var wrapLine = (line2, font, maxWidth, lineStart) => {
   const lines = [];
   const tokens = parseTokens(line2);
-  const tokenIterator = tokens[Symbol.iterator]();
   let currentLine = "";
+  let currentLineStart = lineStart;
+  let currentLineEnd = lineStart;
   let currentLineWidth = 0;
-  let iterator = tokenIterator.next();
-  while (!iterator.done) {
-    const token = iterator.value;
+  let tokenOffset = lineStart;
+  let tokenIndex = 0;
+  while (tokenIndex < tokens.length) {
+    const token = tokens[tokenIndex];
+    const tokenStart = tokenOffset;
+    const tokenEnd = tokenStart + token.length;
     const testLine = currentLine + token;
     const testLineWidth = isSingleCharacter(token) ? currentLineWidth + charWidth.calculate(token, font) : getLineWidth(testLine, font);
     if (/\s/.test(token) || testLineWidth <= maxWidth) {
+      if (!currentLine) {
+        currentLineStart = tokenStart;
+      }
       currentLine = testLine;
+      currentLineEnd = tokenEnd;
       currentLineWidth = testLineWidth;
-      iterator = tokenIterator.next();
+      tokenOffset = tokenEnd;
+      tokenIndex++;
       continue;
     }
     if (!currentLine) {
-      const wrappedWord = wrapWord(token, font, maxWidth);
-      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? "";
+      const wrappedWord = wrapWord(token, font, maxWidth, tokenStart);
+      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? {
+        text: "",
+        start: tokenStart,
+        end: tokenStart
+      };
       const precedingLines = wrappedWord.slice(0, -1);
       lines.push(...precedingLines);
-      currentLine = trailingLine;
-      currentLineWidth = getLineWidth(trailingLine, font);
-      iterator = tokenIterator.next();
+      currentLine = trailingLine.text;
+      currentLineStart = trailingLine.start;
+      currentLineEnd = trailingLine.end;
+      currentLineWidth = getLineWidth(trailingLine.text, font);
+      tokenOffset = tokenEnd;
+      tokenIndex++;
     } else {
-      lines.push(currentLine.trimEnd());
+      lines.push(
+        trimLineEndAtSoftBreak(currentLine, currentLineStart, currentLineEnd)
+      );
       currentLine = "";
+      currentLineStart = tokenStart;
+      currentLineEnd = tokenStart;
       currentLineWidth = 0;
     }
   }
   if (currentLine) {
-    const trailingLine = trimLine(currentLine, font, maxWidth);
+    const trailingLine = trimLine(
+      currentLine,
+      currentLineStart,
+      currentLineEnd,
+      font,
+      maxWidth
+    );
     lines.push(trailingLine);
   }
   return lines;
 };
-var wrapWord = (word, font, maxWidth) => {
+var wrapWord = (word, font, maxWidth, wordStart) => {
   if (getEmojiRegex().test(word)) {
-    return [word];
+    return [
+      {
+        text: word,
+        start: wordStart,
+        end: wordStart + word.length
+      }
+    ];
   }
   satisfiesWordInvariant(word);
   const lines = [];
   const chars = Array.from(word);
   let currentLine = "";
+  let currentLineStart = wordStart;
+  let currentLineEnd = wordStart;
   let currentLineWidth = 0;
+  let offset = wordStart;
   for (const char of chars) {
+    const charStart = offset;
+    const charEnd = charStart + char.length;
     const _charWidth = charWidth.calculate(char, font);
     const testLineWidth = currentLineWidth + _charWidth;
     if (testLineWidth <= maxWidth) {
+      if (!currentLine) {
+        currentLineStart = charStart;
+      }
       currentLine = currentLine + char;
+      currentLineEnd = charEnd;
       currentLineWidth = testLineWidth;
+      offset = charEnd;
       continue;
     }
     if (currentLine) {
-      lines.push(currentLine);
+      lines.push({
+        text: currentLine,
+        start: currentLineStart,
+        end: currentLineEnd
+      });
     }
     currentLine = char;
+    currentLineStart = charStart;
+    currentLineEnd = charEnd;
     currentLineWidth = _charWidth;
+    offset = charEnd;
   }
   if (currentLine) {
-    lines.push(currentLine);
+    lines.push({
+      text: currentLine,
+      start: currentLineStart,
+      end: currentLineEnd
+    });
   }
   return lines;
 };
-var trimLine = (line2, font, maxWidth) => {
+var trimLine = (line2, start, end, font, maxWidth) => {
   const shouldTrimWhitespaces = getLineWidth(line2, font) > maxWidth;
   if (!shouldTrimWhitespaces) {
-    return line2;
+    return {
+      text: line2,
+      start,
+      end
+    };
   }
   let [, trimmedLine, whitespaces] = line2.match(/^(.+?)(\s+)$/) ?? [
     line2,
@@ -4417,7 +4494,19 @@ var trimLine = (line2, font, maxWidth) => {
     trimmedLine = trimmedLine + whitespace;
     trimmedLineWidth = testLineWidth;
   }
-  return trimmedLine;
+  return {
+    text: trimmedLine,
+    start,
+    end: end - (line2.length - trimmedLine.length)
+  };
+};
+var trimLineEndAtSoftBreak = (line2, start, end) => {
+  const trimmedLine = line2.trimEnd();
+  return {
+    text: trimmedLine,
+    start,
+    end: end - (line2.length - trimmedLine.length)
+  };
 };
 var isSingleCharacter = (maybeSingleCharacter) => {
   return maybeSingleCharacter.codePointAt(0) !== void 0 && maybeSingleCharacter.codePointAt(1) === void 0;
@@ -11230,6 +11319,10 @@ var getSelectionStateForElements = (targetElements, allElements, appState) => {
     )
   };
 };
+var getActiveTextElement = (selectedElements, appState) => {
+  const activeTextElement = appState.editingTextElement || selectedElements.length === 1 && isTextElement(selectedElements[0]) && selectedElements[0];
+  return activeTextElement || null;
+};
 
 // src/frame.ts
 var bindElementsToFramesAfterDuplication = (nextElements, origElements, origIdToDuplicateId) => {
@@ -21881,6 +21974,7 @@ export {
   frameAndChildrenSelectedTogether,
   generateLinearCollisionShape,
   generateRoughOptions,
+  getActiveTextElement,
   getAllHoveredElementAtPoint,
   getApproxMinLineHeight,
   getApproxMinLineWidth,
@@ -21989,6 +22083,7 @@ export {
   getVisibleAndNonSelectedElements,
   getVisibleElements,
   getVisibleSceneBounds,
+  getWrappedTextLines,
   groupByFrameLikes,
   groupsAreAtLeastIntersectingTheFrame,
   groupsAreCompletelyOutOfFrame,