@lvce-editor/editor-worker 19.30.12 → 19.31.0

package/dist/editorWorkerMain.js

@@ -1393,6 +1393,7 @@ const KeyC = 31;
 const KeyD = 32;
 const KeyF = 34;
 const KeyH = 36;
+const KeyI = 37;
 const KeyJ = 38;
 const KeyK = 39;
 const KeyL = 40;
@@ -3259,7 +3260,7 @@ const getEnabled = () => {
 };
 
 // TODO this should be in a separate scrolling module
-const setDeltaY$2 = async (state, value) => {
+const setDeltaY$1 = async (state, value) => {
   object(state);
   number(value);
   const {
@@ -4001,11 +4002,11 @@ const applyEdit$1 = (editor, changes) => {
 };
 
 // TODO
-const setDeltaYFixedValue$1 = (editor, value) => {
-  return setDeltaY$2(editor, value);
+const setDeltaYFixedValue = (editor, value) => {
+  return setDeltaY$1(editor, value);
 };
-const setDeltaY$1 = (editor, value) => {
-  return setDeltaYFixedValue$1(editor, editor.deltaY + value);
+const setDeltaY = (editor, value) => {
+  return setDeltaYFixedValue(editor, editor.deltaY + value);
 };
 const isAutoClosingChange = change => {
   return change.origin === EditorTypeWithAutoClosing;
@@ -4864,9 +4865,9 @@ const createEditor = async ({
   if (lineToReveal && columnToReveal) {
     const delta = lineToReveal * rowHeight;
     // TODO scroll to this line
-    newEditor3 = await setDeltaY$2(newEditor2, delta);
+    newEditor3 = await setDeltaY$1(newEditor2, delta);
   } else {
-    newEditor3 = await setDeltaY$2(newEditor2, 0);
+    newEditor3 = await setDeltaY$1(newEditor2, 0);
   }
 
   // Detect links and initialize decorations
@@ -5160,7 +5161,7 @@ const disposeEditor = async editorUid => {
 };
 
 // @ts-ignore
-const getNewSelections$c = selections => {
+const getNewSelections$d = selections => {
   const newSelections = [];
   for (let i = 0; i < selections.length; i += 4) {
     const startRowIndex = selections[i];
@@ -5180,7 +5181,7 @@ const addCursorAbove = editor => {
   const {
     selections
   } = editor;
-  const newSelections = getNewSelections$c(selections);
+  const newSelections = getNewSelections$d(selections);
   return {
     ...editor,
     selections: newSelections
@@ -5188,7 +5189,7 @@ const addCursorAbove = editor => {
 };
 
 // @ts-ignore
-const getNewSelections$b = (selections, linesLength) => {
+const getNewSelections$c = (selections, linesLength) => {
   const newSelections = [];
   for (let i = 0; i < selections.length; i += 4) {
     const startRowIndex = selections[i];
@@ -5209,7 +5210,7 @@ const addCursorBelow = editor => {
     lines,
     selections
   } = editor;
-  const newSelections = getNewSelections$b(selections, lines.length);
+  const newSelections = getNewSelections$c(selections, lines.length);
   return {
     ...editor,
     selections: newSelections
@@ -5897,6 +5898,251 @@ const cancelSelection = editor => {
   return scheduleSelections(editor, newSelections);
 };
 
+const colorPattern$1 = /#[\dA-Fa-f]+/g;
+const numberPattern = /(?<![\w.#])[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE][+-]?\d+)?(?![\d.])/g;
+const validColorLengths = new Set([4, 5, 7, 9]);
+const isColor = value => {
+  return validColorLengths.has(value.length) && /^#[\dA-Fa-f]+$/.test(value);
+};
+const isNumber = value => {
+  return /^[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE][+-]?\d+)?$/.test(value);
+};
+const adjustNumber = (value, delta) => {
+  const match = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))([eE][+-]?\d+)?$/.exec(value);
+  if (!match) {
+    return value;
+  }
+  const [, originalSign, integerPart = '', fractionAfterInteger, fractionWithoutInteger, exponent = ''] = match;
+  const fraction = fractionAfterInteger ?? fractionWithoutInteger ?? '';
+  const mantissaEnd = exponent ? value.length - exponent.length : value.length;
+  const hadDecimalPoint = value.slice(0, mantissaEnd).includes('.');
+  const scale = fraction.length;
+  const unsignedUnits = BigInt(`${integerPart || '0'}${fraction}`);
+  const signedUnits = originalSign === '-' ? -unsignedUnits : unsignedUnits;
+  const nextUnits = signedUnits + BigInt(delta);
+  const isNegative = nextUnits < 0;
+  const absoluteUnits = isNegative ? -nextUnits : nextUnits;
+  const minimumIntegerLength = Math.max(integerPart.length, 1);
+  const digits = absoluteUnits.toString().padStart(scale + minimumIntegerLength, '0');
+  const resultInteger = scale === 0 ? digits : digits.slice(0, -scale);
+  const resultFraction = scale === 0 ? '' : digits.slice(-scale);
+  const omitLeadingZero = integerPart === '' && resultInteger === '0';
+  const mantissa = `${omitLeadingZero ? '' : resultInteger}${hadDecimalPoint ? '.' : ''}${resultFraction}`;
+  const sign = isNegative ? '-' : originalSign === '+' ? '+' : '';
+  return `${sign}${mantissa}${exponent}`;
+};
+const adjustColorComponent = (digits, componentIndex, componentWidth, delta, uppercase) => {
+  const start = componentIndex * componentWidth;
+  const value = Number.parseInt(digits.slice(start, start + componentWidth), 16);
+  const maximum = componentWidth === 1 ? 0xf : 0xff;
+  const nextValue = Math.max(0, Math.min(maximum, value + delta));
+  const replacement = nextValue.toString(16).padStart(componentWidth, '0');
+  return `${digits.slice(0, start)}${uppercase ? replacement.toUpperCase() : replacement}${digits.slice(start + componentWidth)}`;
+};
+const adjustColor = (value, delta, activeOffset) => {
+  const digits = value.slice(1);
+  const componentWidth = digits.length <= 4 ? 1 : 2;
+  const componentCount = digits.length / componentWidth;
+  const uppercase = /[A-F]/.test(digits) && !/[a-f]/.test(digits);
+  if (activeOffset !== undefined && activeOffset > 0) {
+    const digitOffset = Math.min(activeOffset - 1, digits.length - 1);
+    const componentIndex = Math.floor(digitOffset / componentWidth);
+    return `#${adjustColorComponent(digits, componentIndex, componentWidth, delta, uppercase)}`;
+  }
+  let adjusted = digits;
+  for (let componentIndex = 0; componentIndex < Math.min(componentCount, 3); componentIndex++) {
+    adjusted = adjustColorComponent(adjusted, componentIndex, componentWidth, delta, uppercase);
+  }
+  return `#${adjusted}`;
+};
+const changeValue = (value, delta, activeOffset = undefined) => {
+  if (isColor(value)) {
+    return adjustColor(value, delta, activeOffset);
+  }
+  if (isNumber(value)) {
+    return adjustNumber(value, delta);
+  }
+  return value;
+};
+const findMatchAt = (line, columnIndex, pattern, predicate) => {
+  pattern.lastIndex = 0;
+  for (const match of line.matchAll(pattern)) {
+    const value = match[0];
+    const start = match.index;
+    const end = start + value.length;
+    if (predicate(value) && columnIndex >= start && columnIndex <= end) {
+      return {
+        end,
+        start,
+        value
+      };
+    }
+  }
+  return undefined;
+};
+const findValueAt = (line, columnIndex) => {
+  return findMatchAt(line, columnIndex, colorPattern$1, isColor) ?? findMatchAt(line, columnIndex, numberPattern, isNumber);
+};
+const getSelectionTarget = (editor, index) => {
+  const selectionStartRow = editor.selections[index];
+  const selectionStartColumn = editor.selections[index + 1];
+  const selectionEndRow = editor.selections[index + 2];
+  if (selectionStartRow !== selectionEndRow) {
+    return undefined;
+  }
+  const selectionEndColumn = editor.selections[index + 3];
+  const rowIndex = selectionStartRow;
+  const line = editor.lines[rowIndex];
+  const start = Math.min(selectionStartColumn, selectionEndColumn);
+  const end = Math.max(selectionStartColumn, selectionEndColumn);
+  if (start !== end) {
+    const value = line.slice(start, end);
+    if (!isColor(value) && !isNumber(value)) {
+      return undefined;
+    }
+    return {
+      activeOffset: undefined,
+      end,
+      index,
+      rowIndex,
+      selectionEnd: selectionEndColumn,
+      selectionStart: selectionStartColumn,
+      start,
+      value
+    };
+  }
+  const range = findValueAt(line, selectionEndColumn);
+  if (!range) {
+    return undefined;
+  }
+  return {
+    ...range,
+    activeOffset: selectionEndColumn - range.start,
+    index,
+    rowIndex,
+    selectionEnd: selectionEndColumn,
+    selectionStart: selectionStartColumn
+  };
+};
+const getTargets = editor => {
+  const targets = [];
+  for (let index = 0; index < editor.selections.length; index += 4) {
+    const target = getSelectionTarget(editor, index);
+    if (target) {
+      targets.push(target);
+    }
+  }
+  return targets;
+};
+const getUniqueTargets = targets => {
+  const seen = new Set();
+  return targets.filter(target => {
+    const key = `${target.rowIndex}:${target.start}:${target.end}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  }).toSorted((a, b) => a.rowIndex - b.rowIndex || a.start - b.start);
+};
+const getColumnDeltaBefore = (targets, replacements, rowIndex, column) => {
+  let delta = 0;
+  for (const target of targets) {
+    if (target.rowIndex !== rowIndex || target.end > column) {
+      continue;
+    }
+    delta += replacements.get(target).length - target.value.length;
+  }
+  return delta;
+};
+const mapColumn = (targets, replacements, rowIndex, column) => {
+  for (const target of targets) {
+    if (target.rowIndex === rowIndex && column > target.start && column < target.end) {
+      const replacement = replacements.get(target);
+      return target.start + getColumnDeltaBefore(targets, replacements, rowIndex, target.start) + Math.min(column - target.start, replacement.length);
+    }
+  }
+  return column + getColumnDeltaBefore(targets, replacements, rowIndex, column);
+};
+const getNewSelections$b = (editor, targets, uniqueTargets, replacements) => {
+  const newSelections = new Uint32Array(editor.selections);
+  const targetByIndex = new Map(targets.map(target => [target.index, target]));
+  for (let index = 0; index < editor.selections.length; index += 4) {
+    const startRow = editor.selections[index];
+    const startColumn = editor.selections[index + 1];
+    const endRow = editor.selections[index + 2];
+    const endColumn = editor.selections[index + 3];
+    const target = targetByIndex.get(index);
+    if (!target) {
+      newSelections[index + 1] = mapColumn(uniqueTargets, replacements, startRow, startColumn);
+      newSelections[index + 3] = mapColumn(uniqueTargets, replacements, endRow, endColumn);
+      continue;
+    }
+    const matchingTarget = uniqueTargets.find(candidate => candidate.rowIndex === target.rowIndex && candidate.start === target.start && candidate.end === target.end);
+    const replacement = replacements.get(matchingTarget);
+    const newStart = target.start + getColumnDeltaBefore(uniqueTargets, replacements, target.rowIndex, target.start);
+    const newEnd = newStart + replacement.length;
+    if (target.selectionStart === target.selectionEnd) {
+      const originalOffset = target.selectionEnd - target.start;
+      const newOffset = originalOffset === target.value.length ? replacement.length : Math.min(originalOffset, replacement.length);
+      newSelections[index + 1] = newStart + newOffset;
+      newSelections[index + 3] = newStart + newOffset;
+    } else if (target.selectionStart < target.selectionEnd) {
+      newSelections[index + 1] = newStart;
+      newSelections[index + 3] = newEnd;
+    } else {
+      newSelections[index + 1] = newEnd;
+      newSelections[index + 3] = newStart;
+    }
+  }
+  return newSelections;
+};
+const changeSelectedValue = async (editor, delta) => {
+  const targets = getTargets(editor);
+  const uniqueTargets = getUniqueTargets(targets);
+  if (uniqueTargets.length === 0) {
+    return editor;
+  }
+  const replacements = new Map(uniqueTargets.map(target => [target, changeValue(target.value, delta, targets.find(candidate => candidate === target)?.activeOffset)]));
+  const changedTargets = uniqueTargets.filter(target => replacements.get(target) !== target.value);
+  if (changedTargets.length === 0) {
+    return editor;
+  }
+  const changedTargetKeys = new Set(changedTargets.map(target => `${target.rowIndex}:${target.start}:${target.end}`));
+  const selectionTargetsWithChanges = targets.filter(target => changedTargetKeys.has(`${target.rowIndex}:${target.start}:${target.end}`));
+  const changes = [];
+  const rowDeltas = new Map();
+  for (const target of changedTargets) {
+    const columnDelta = rowDeltas.get(target.rowIndex) ?? 0;
+    const startColumn = target.start + columnDelta;
+    const endColumn = target.end + columnDelta;
+    const replacement = replacements.get(target);
+    changes.push({
+      deleted: [target.value],
+      end: {
+        columnIndex: endColumn,
+        rowIndex: target.rowIndex
+      },
+      inserted: [replacement],
+      origin: 'changeSelectedValue',
+      start: {
+        columnIndex: startColumn,
+        rowIndex: target.rowIndex
+      }
+    });
+    rowDeltas.set(target.rowIndex, columnDelta + replacement.length - target.value.length);
+  }
+  const newSelections = getNewSelections$b(editor, selectionTargetsWithChanges, changedTargets, replacements);
+  return scheduleDocumentAndCursorsSelections(editor, changes, newSelections);
+};
+
+const decrementSelection = editor => {
+  return changeSelectedValue(editor, -1);
+};
+const incrementSelection = editor => {
+  return changeSelectedValue(editor, 1);
+};
+
 const isMatchingWidget$2 = widget => {
   return widget.id === CodeGenerator;
 };
@@ -6696,7 +6942,7 @@ const cursorPageDown = editor => {
     moveRangeToPosition$1(result, index, Math.min(endRow + pageSize, lastRowIndex), endColumn);
   });
   const newEditor = scheduleSelections(editor, newSelections);
-  return setDeltaYFixedValue$1(newEditor, deltaY + pageSize * itemHeight);
+  return setDeltaYFixedValue(newEditor, deltaY + pageSize * itemHeight);
 };
 
 const cursorSet = (editor, rowIndex, columnIndex) => {
@@ -7209,10 +7455,12 @@ const DeleteLine = 'Delete Line';
 const EditorCloseColorPicker = 'Editor: Close Color Picker';
 const EditorCopyLineDown = 'Editor: Copy Line Down';
 const EditorCopyLineUp = 'Editor: Copy Line Up';
+const EditorDecrementSelection = 'Editor: Decrement Selection';
 const EditorFormatDocumentForced = 'Editor: Format Document (forced)';
 const EditorGoToDefinition = 'Editor: Go To Definition';
 const EditorGoToTypeDefinition = 'Editor: Go To Type Definition';
 const EditorIndent = 'Editor: Indent';
+const EditorIncrementSelection = 'Editor: Increment Selection';
 const EditorOpenColorPicker = 'Editor: Open Color Picker';
 const EditorSelectAllOccurrences = 'Editor: Select All Occurrences';
 const EditorSelectDown = 'Editor: Select Down';
@@ -7348,6 +7596,9 @@ const editorSelectInsideString = () => {
 const editorIndent = () => {
   return i18nString(EditorIndent);
 };
+const editorIncrementSelection = () => {
+  return i18nString(EditorIncrementSelection);
+};
 const editorUnindent$1 = () => {
   return i18nString(EditorUnindent);
 };
@@ -7357,6 +7608,9 @@ const editorSortLinesAscending = () => {
 const editorToggleComment = () => {
   return i18nString(EditorToggleComment);
 };
+const editorDecrementSelection = () => {
+  return i18nString(EditorDecrementSelection);
+};
 const editorSelectUp = () => {
   return i18nString(EditorSelectUp);
 };
@@ -8628,7 +8882,7 @@ const handleScrollBarMove = async (state, eventY) => {
   const relativeY = eventY - y - handleOffset;
   const newPercent = getNewPercent(state, relativeY);
   const newDeltaY = newPercent * finalDeltaY;
-  const newState = await setDeltaYFixedValue$1(state, newDeltaY);
+  const newState = await setDeltaYFixedValue(state, newDeltaY);
   return newState;
 };
 const handleScrollBarVerticalPointerMove = handleScrollBarMove;
@@ -8661,7 +8915,7 @@ const handleScrollBarPointerDown = async (state, eventY) => {
     percent
   } = getNewDeltaPercent(height, scrollBarHeight, relativeY);
   const newDeltaY = percent * finalDeltaY;
-  const newState = await setDeltaYFixedValue$1(state, newDeltaY);
+  const newState = await setDeltaYFixedValue(state, newDeltaY);
   return {
     ...newState,
     handleOffset
@@ -8709,13 +8963,9 @@ const handleTouchStart = (editor, touchEvent) => {
 };
 
 // @ts-ignore
-const setDeltaY = (editor, deltaY) => {
-  return setDeltaY$1(editor, deltaY);
-};
-
-// @ts-ignore
-const setDeltaYFixedValue = (editor, deltaY) => {
-  return setDeltaYFixedValue$1(editor, deltaY);
+const scrollByLines = (editor, lineCount) => {
+  number(lineCount);
+  return setDeltaY(editor, lineCount * editor.itemHeight);
 };
 
 // @ts-ignore
@@ -11739,6 +11989,13 @@ const getLines2 = editorUid => {
   } = editor;
   return lines;
 };
+const getVisibleLineRange = editorUid => {
+  const {
+    maxLineY,
+    minLineY
+  } = getEditor$1(editorUid);
+  return [minLineY, maxLineY];
+};
 const getSelections2 = editorUid => {
   const editor = getEditor$1(editorUid);
   const {
@@ -11921,6 +12178,14 @@ const getKeyBindings = () => {
     command: 'Editor.cursorDocumentStart',
     key: CtrlCmd | Home,
     when: FocusEditorText
+  }, {
+    command: 'Editor.incrementSelection',
+    key: CtrlCmd | Alt$1 | KeyI,
+    when: FocusEditorText
+  }, {
+    command: 'Editor.decrementSelection',
+    key: CtrlCmd | Alt$1 | KeyD,
+    when: FocusEditorText
   }, {
     command: 'Editor.deleteWordPartLeft',
     key: Alt$1 | Backspace,
@@ -12303,6 +12568,12 @@ const getQuickPickMenuEntries = () => {
   }, {
     id: 'Editor.deleteLine',
     label: deleteLine()
+  }, {
+    id: 'Editor.incrementSelection',
+    label: editorIncrementSelection()
+  }, {
+    id: 'Editor.decrementSelection',
+    label: editorDecrementSelection()
   }, {
     id: 'Editor.format',
     label: formatDocument()
@@ -12522,16 +12793,24 @@ const applyTabCompletion = (editor, result) => {
   return editorSnippet(editor, result);
 };
 
+const insertTab = editor => {
+  // TODO have setting what should be inserted on tab
+  return type(editor, '  ');
+};
 const handleTab = async editor => {
   if (!isEverySelectionEmpty(editor.selections)) {
     return indentMore(editor);
   }
-  const result = await getTabCompletion(editor);
-  if (!result) {
-    // TODO enter tab or two spaces
-    return editor;
+  try {
+    const result = await getTabCompletion(editor);
+    if (!result) {
+      return insertTab(editor);
+    }
+    return applyTabCompletion(editor, result);
+  } catch (error) {
+    await handleError$1(error, 'Failed to execute tab completion provider: ');
+    return insertTab(editor);
   }
-  return applyTabCompletion(editor, result);
 };
 
 const relaunchWorkers = async () => {
@@ -14265,6 +14544,7 @@ const commandMap = {
   'Editor.cursorWordPartRight': wrapCommand(cursorWordPartRight),
   'Editor.cursorWordRight': wrapCommand(cursorWordRight),
   'Editor.cut': wrapCommand(cut$1),
+  'Editor.decrementSelection': wrapCommand(decrementSelection),
   'Editor.deleteAll': wrapCommand(deleteAll),
   'Editor.deleteAllLeft': wrapCommand(deleteAllLeft),
   'Editor.deleteAllRight': wrapCommand(deleteAllRight),
@@ -14302,6 +14582,7 @@ const commandMap = {
   'Editor.getSourceActions': getSourceActions,
   'Editor.getText': getText,
   'Editor.getUri': getUri,
+  'Editor.getVisibleLineRange': getVisibleLineRange,
   'Editor.getWordAt': getWordAt$1,
   'Editor.getWordAt2': getWordAt,
   'Editor.getWordAtOffset2': getWordAtOffset2,
@@ -14344,6 +14625,7 @@ const commandMap = {
   'Editor.handleUriChange': wrapCommand(handleUriChange),
   'Editor.handleWheel': wrapCommand(handleWheel$2),
   'Editor.hotReload': hotReload,
+  'Editor.incrementSelection': wrapCommand(incrementSelection),
   'Editor.indendLess': wrapCommand(indentLess),
   'Editor.indentMore': wrapCommand(indentMore),
   'Editor.insertLineBreak': wrapCommand(insertLineBreak),
@@ -14373,6 +14655,7 @@ const commandMap = {
   'Editor.resize': wrapCommand(resize),
   'Editor.save': wrapCommand(save),
   'Editor.saveState': wrapGetter(saveState),
+  'Editor.scrollByLines': wrapCommand(scrollByLines),
   'Editor.selectAll': wrapCommand(selectAll),
   'Editor.selectAllLeft': wrapCommand(editorSelectAllLeft),
   'Editor.selectAllOccurrences': wrapCommand(selectAllOccurrences),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "19.30.12",
+  "version": "19.31.0",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"