@lvce-editor/static-server 0.91.19 → 0.91.21

package/static/{963d54f → 53bd123}/packages/renderer-process/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "30.9.0",
+  "version": "30.10.1",
   "keywords": [
     "lvce-editor",
     "renderer-process"

package/static/{963d54f → 53bd123}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -526,7 +526,7 @@ class VError extends Error {
   }
 }
 
-const state$C = {
+const state$E = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -549,20 +549,20 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$C.load(moduleId);
+    const module = await state$E.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$C.pendingModules[moduleId]) {
-    state$C.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$E.pendingModules[moduleId]) {
+    state$E.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$C.pendingModules[moduleId];
+  return state$E.pendingModules[moduleId];
 };
 const loadCommand = async command => {
-  if (command in state$C.commands) {
+  if (command in state$E.commands) {
     return;
   }
   await getOrLoadModule(getModuleId$2(command));
@@ -571,12 +571,12 @@ const register$2 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$C.commands[commandId] = listener;
+  state$E.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$C.commands) {
-    const fn = state$C.commands[command];
+  if (command in state$E.commands) {
+    const fn = state$E.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -585,7 +585,7 @@ const execute$4 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$C.commands)) {
+    if (!(command in state$E.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -596,20 +596,20 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$C.load = load;
+  state$E.load = load;
 };
 
-const state$B = {
+const state$D = {
   pending: Object.create(null)
 };
 const get$i = id => {
-  return state$B.pending[id];
+  return state$D.pending[id];
 };
 const has$2 = id => {
-  return id in state$B.pending;
+  return id in state$D.pending;
 };
 const set$h = (id, value) => {
-  state$B.pending[id] = value;
+  state$D.pending[id] = value;
 };
 
 const Web$1 = 1;
@@ -635,7 +635,7 @@ const getAssetDir$2 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/963d54f';
+    return '/53bd123';
   }
 };
 const assetDir = getAssetDir$2();
@@ -1256,6 +1256,223 @@ const WebWorkerRpcClient2 = {
 
 const commandMapRef = {};
 
+const kDispose$1 = 'Viewlet.dispose';
+const kPatchCss = 'Viewlet.patchCss';
+const kSetCss$1 = 'Viewlet.setCss';
+const kSetPatches$1 = 'Viewlet.setPatches';
+const state$C = {
+  /** @type {Map<string | number, string>} */
+  cssTexts: new Map()
+};
+const getJsonByteLength = value => {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+};
+const getCommonPrefixLength = (oldText, newText) => {
+  const limit = Math.min(oldText.length, newText.length);
+  let index = 0;
+  while (index < limit && oldText[index] === newText[index]) {
+    index++;
+  }
+  return index;
+};
+const getCommonSuffixLength = (oldText, newText, prefixLength) => {
+  const limit = Math.min(oldText.length, newText.length) - prefixLength;
+  let length = 0;
+  while (length < limit && oldText[oldText.length - length - 1] === newText[newText.length - length - 1]) {
+    length++;
+  }
+  return length;
+};
+const normalizeSetCss = command => {
+  const id = command[1];
+  const newText = command[2];
+  if (typeof id !== 'string' && typeof id !== 'number' || typeof newText !== 'string') {
+    return command;
+  }
+  const oldText = state$C.cssTexts.get(id);
+  if (oldText === newText) {
+    return undefined;
+  }
+  state$C.cssTexts.set(id, newText);
+  if (oldText === undefined) {
+    return command;
+  }
+  const start = getCommonPrefixLength(oldText, newText);
+  const suffixLength = getCommonSuffixLength(oldText, newText, start);
+  const deleteCount = oldText.length - start - suffixLength;
+  const replacement = newText.slice(start, newText.length - suffixLength);
+  const patchCommand = [kPatchCss, id, start, deleteCount, replacement];
+  if (getJsonByteLength(patchCommand) < getJsonByteLength(command)) {
+    return patchCommand;
+  }
+  return command;
+};
+const normalizeCommand = command => {
+  if (!Array.isArray(command)) {
+    return command;
+  }
+  if (command[0] === kSetPatches$1 && Array.isArray(command[2]) && command[2].length === 0) {
+    return undefined;
+  }
+  if (command[0] === kSetCss$1) {
+    return normalizeSetCss(command);
+  }
+  if (command[0] === kDispose$1) {
+    state$C.cssTexts.delete(command[1]);
+  }
+  return command;
+};
+const normalizeCommands = commands => {
+  const normalized = [];
+  for (const command of commands) {
+    const normalizedCommand = normalizeCommand(command);
+    if (normalizedCommand) {
+      normalized.push(normalizedCommand);
+    }
+  }
+  return normalized;
+};
+const getCssText = id => {
+  return state$C.cssTexts.get(id);
+};
+const setCssText = (id, text) => {
+  state$C.cssTexts.set(id, text);
+};
+const reset$3 = () => {
+  state$C.cssTexts.clear();
+};
+
+const requestAnimationFrame = fn => {
+  globalThis.requestAnimationFrame(fn);
+};
+
+const now = () => {
+  return performance.now();
+};
+
+const kAddCssStyleSheet = 'Css.addCssStyleSheet';
+const kDispose = 'Viewlet.dispose';
+const kSendMultiple$1 = 'Viewlet.sendMultiple';
+const kSetCss = 'Viewlet.setCss';
+const kSetPatches = 'Viewlet.setPatches';
+const minimumFrameDuration = 16;
+const state$B = {
+  frameCount: 0,
+  lastFrameTime: Number.NEGATIVE_INFINITY,
+  /** @type {{commands: any[], promise: Promise<any>} | undefined} */
+  pendingFrame: undefined,
+  /** @type {any} */
+  rpc: undefined,
+  tail: Promise.resolve()
+};
+const enqueue = operation => {
+  const promise = state$B.tail.then(operation);
+  state$B.tail = promise.catch(() => {});
+  return promise;
+};
+const waitForEligibleFrame = () => {
+  return new Promise(resolve => {
+    const handleFrame = timestamp => {
+      if (timestamp - state$B.lastFrameTime < minimumFrameDuration) {
+        requestAnimationFrame(handleFrame);
+        return;
+      }
+      resolve(timestamp);
+    };
+    requestAnimationFrame(handleFrame);
+  });
+};
+const invokeWithCacheRecovery = async (method, ...params) => {
+  try {
+    return await state$B.rpc.invoke(method, ...params);
+  } catch (error) {
+    reset$3();
+    throw error;
+  }
+};
+const runFrame = async frame => {
+  const timestamp = await waitForEligibleFrame();
+  if (state$B.pendingFrame === frame) {
+    state$B.pendingFrame = undefined;
+  }
+  const commands = normalizeCommands(frame.commands);
+  if (commands.length === 0) {
+    return;
+  }
+  state$B.frameCount++;
+  try {
+    return await invokeWithCacheRecovery(kSendMultiple$1, commands);
+  } finally {
+    state$B.lastFrameTime = Math.max(timestamp, now());
+  }
+};
+const sealPendingFrame = () => {
+  state$B.pendingFrame = undefined;
+};
+const invokeDirectRendererCommand = async (method, params) => {
+  const commands = normalizeCommands([[method, ...params]]);
+  if (commands.length === 0) {
+    return;
+  }
+  const [command] = commands;
+  return invokeWithCacheRecovery(command[0], ...command.slice(1));
+};
+const invokeCssStyleSheet = async (id, text) => {
+  if (getCssText(id) === text) {
+    return;
+  }
+  setCssText(id, text);
+  return invokeWithCacheRecovery(kAddCssStyleSheet, id, text);
+};
+const reset$2 = rpc => {
+  reset$3();
+  state$B.frameCount = 0;
+  state$B.lastFrameTime = Number.NEGATIVE_INFINITY;
+  state$B.pendingFrame = undefined;
+  state$B.rpc = rpc;
+  state$B.tail = Promise.resolve();
+};
+const sendMultiple = commands => {
+  if (state$B.pendingFrame) {
+    state$B.pendingFrame.commands.push(...commands);
+    return state$B.pendingFrame.promise;
+  }
+  /** @type {{commands: any[], promise: Promise<any>}} */
+  const frame = {
+    commands: [...commands],
+    promise: Promise.resolve()
+  };
+  state$B.pendingFrame = frame;
+  frame.promise = enqueue(() => runFrame(frame));
+  return frame.promise;
+};
+const invoke$J = (method, ...params) => {
+  if (method === kSendMultiple$1) {
+    return sendMultiple(params[0]);
+  }
+  sealPendingFrame();
+  return enqueue(async () => {
+    if (method === kAddCssStyleSheet) {
+      return invokeCssStyleSheet(params[0], params[1]);
+    }
+    if (method === kDispose || method === kSetCss || method === kSetPatches) {
+      return invokeDirectRendererCommand(method, params);
+    }
+    return invokeWithCacheRecovery(method, ...params);
+  });
+};
+const invokeAndTransfer$v = (method, ...params) => {
+  sealPendingFrame();
+  return enqueue(async () => {
+    try {
+      return await state$B.rpc.invokeAndTransfer(method, ...params);
+    } catch (error) {
+      reset$3();
+      throw error;
+    }
+  });
+};
+
 // @ts-ignore
 const state$A = {
   pendingMessages: [],
@@ -1276,12 +1493,13 @@ const listen$1 = async () => {
   console.assert(state$A.pendingMessages.length === 0);
   const rpc = await getRpc$1();
   state$A.rpc = rpc;
+  reset$2(rpc);
 };
 const invoke$I = (method, ...params) => {
-  return state$A.rpc.invoke(method, ...params);
+  return invoke$J(method, ...params);
 };
 const invokeAndTransfer$u = (method, ...params) => {
-  return state$A.rpc.invokeAndTransfer(method, ...params);
+  return invokeAndTransfer$v(method, ...params);
 };
 
 const escapeCssComment = value => {
@@ -2508,7 +2726,10 @@ const getBuiltinExtensionsPath = () => {
 const getDisabledExtensionsJsonPath = () => {
   return invoke$F(/* Platform.getDisabledExtensionsJsonPath */'Platform.getDisabledExtensionsJsonPath');
 };
-const getConfigJsonPath = () => {
+const getConfigJsonPath = (platform = getPlatform$2(), assetDir$1 = assetDir) => {
+  if (platform === Web$1) {
+    return `${assetDir$1}/config.json`;
+  }
   return invoke$F(/* Platform.getConfigJsonPath */'Platform.getConfigJsonPath');
 };
 const getCachedExtensionsPath = () => {
@@ -3922,10 +4143,6 @@ const saveTimings = async (builtinSaveStart, builtinSaveEnd, extensionSaveEnd) =
   });
 };
 
-const now = () => {
-  return performance.now();
-};
-
 const Hidden = 'hidden';
 
 const handleVisibilityChange = async visibilityState => {
@@ -6539,8 +6756,8 @@ const exit$1 = code => {
   return invoke$F('Exit.exit', code);
 };
 
-const version = '0.91.19';
-const commit$1 = '963d54f';
+const version = '0.91.21';
+const commit$1 = '53bd123';
 const productNameLong$1 = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$F('Process.getPid');
@@ -17083,6 +17300,9 @@ const create$H = (uid, uri, x, y, width, height, args, parentUid) => {
 const loadContent$F = async (state, savedState) => {
   await invoke$h('DiffView.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.platform, state.assetDir);
   await invoke$h('DiffView.loadContent', state.uid, savedState);
+  if (state.uri.startsWith('inline-diff://')) {
+    await invoke$h('DiffView.setDiffMode', state.uid, 'inline');
+  }
   const diffResult = await invoke$h('DiffView.diff2', state.uid);
   const commands = await invoke$h('DiffView.render2', state.uid, diffResult);
   return {
@@ -20786,7 +21006,7 @@ const ViewletKeyBindings_ipc = {
 
 const Deb = 'Deb';
 
-const commit = '963d54f';
+const commit = '53bd123';
 
 const getAutoUpdateType = () => {
   return invoke$F('AutoUpdater.getAutoUpdateType');
@@ -21016,7 +21236,7 @@ const getModuleId$1 = async (uri, opener) => {
     return DiffEditor;
   }
   if (uri.startsWith('inline-diff://')) {
-    return InlineDiffEditor;
+    return DiffEditor;
   }
   if (uri.startsWith('browser-view-overview://')) {
     return BrowserViewOverview;
@@ -24553,7 +24773,18 @@ const measureTabWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing)
   return tabWidthInt;
 };
 
+const getDisplayUri = uri => {
+  if (!uri.startsWith('diff://') && !uri.startsWith('inline-diff://')) {
+    return uri;
+  }
+  const separatorIndex = uri.indexOf('<->');
+  return separatorIndex === -1 ? uri : uri.slice(separatorIndex + 3);
+};
 const getTitle = uri => {
+  if (!uri) {
+    return '';
+  }
+  uri = getDisplayUri(uri);
   const homeDir = getHomeDir();
   // TODO tree shake this out in web
   if (homeDir && uri.startsWith(homeDir)) {
@@ -24577,7 +24808,7 @@ const getLabel = uri => {
   if (uri.startsWith('running-extensions://')) {
     return 'Running Extensions';
   }
-  return pathBaseName(uri);
+  return pathBaseName(getDisplayUri(uri));
 };
 
 /**

package/static/{963d54f → 53bd123}/packages/status-bar-worker/dist/statusBarWorkerMain.js

@@ -1833,26 +1833,28 @@ const text = data => {
 const HandleContextMenu = 2;
 const HandleClick = 11;
 
-const getTextVirtualDom = element => {
+const getTextVirtualDom = (element, name) => {
   return [{
     childCount: 1,
     className: 'StatusBarItemLabel',
+    name,
     type: Span
   }, text(element.value)];
 };
-const getIconVirtualDom = element => {
+const getIconVirtualDom = (element, name) => {
   return [{
     childCount: 0,
     className: mergeClassNames(MaskIcon, element.value),
+    name,
     type: Div
   }];
 };
-const getStatusBarItemElementVirtualDom = element => {
+const getStatusBarItemElementVirtualDom = (element, name) => {
   if (element.type === 'text') {
-    return getTextVirtualDom(element);
+    return getTextVirtualDom(element, name);
   }
   if (element.type === 'icon') {
-    return getIconVirtualDom(element);
+    return getIconVirtualDom(element, name);
   }
   return [];
 };
@@ -1864,7 +1866,7 @@ const getStatusBarItemVirtualDom = statusBarItem => {
     name,
     tooltip
   } = statusBarItem;
-  const elementNodes = elements.flatMap(getStatusBarItemElementVirtualDom);
+  const elementNodes = elements.flatMap(element => getStatusBarItemElementVirtualDom(element, name));
   const buttonNode = {
     ariaLabel,
     childCount: elements.length,

package/static/{963d54f → 53bd123}/packages/syntax-highlighting-worker/dist/syntaxHighlightingWorkerMain.js

@@ -1221,10 +1221,9 @@ const getTokenizer = languageId => {
   return TokenizePlainText;
 };
 
+const embeddedResultCache = new WeakMap();
 const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed) => {
   const tokenizersToLoad = [];
-  const embeddedResults = [];
-  let topContext;
   for (const index of linesWithEmbed) {
     const result = lineCache[index + 1];
     const line = lines[index];
@@ -1235,45 +1234,64 @@ const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed)
         embeddedLanguageEnd
       } = result;
       const embeddedTokenizer = getTokenizer(embeddedLanguage);
+      const previousResult = lineCache[index];
+      const previousEmbeddedResult = previousResult && embeddedResultCache.get(previousResult);
+      const previousContext = previousEmbeddedResult?.languageId === embeddedLanguage ? previousEmbeddedResult.context : undefined;
       if (embeddedLanguageStart !== line.length && embeddedTokenizer && embeddedTokenizer !== TokenizePlainText) {
         const isFull = embeddedLanguageStart === 0 && embeddedLanguageEnd === line.length;
         const partialLine = line.slice(embeddedLanguageStart, embeddedLanguageEnd);
-        const embedResult = safeTokenizeLine(langageId, embeddedTokenizer.tokenizeLine, partialLine, topContext || getInitialLineState(embeddedTokenizer.initialLineState), embeddedTokenizer.hasArrayReturn);
-        topContext = embedResult;
-        result.embeddedResultIndex = embeddedResults.length;
-        embeddedResults.push({
-          result: embedResult,
-          TokenMap: embeddedTokenizer.TokenMap,
-          isFull
+        const embedResult = safeTokenizeLine(langageId, embeddedTokenizer.tokenizeLine, partialLine, previousContext || getInitialLineState(embeddedTokenizer.initialLineState), embeddedTokenizer.hasArrayReturn);
+        embeddedResultCache.set(result, {
+          context: embedResult,
+          languageId: embeddedLanguage,
+          response: {
+            result: embedResult,
+            TokenMap: embeddedTokenizer.TokenMap,
+            isFull
+          }
         });
       } else if (line.length === 0) {
         const embedResult = {
           tokens: []
         };
-        result.embeddedResultIndex = embeddedResults.length;
-        embeddedResults.push({
-          result: embedResult,
-          isFull: true,
-          TokenMap: []
+        embeddedResultCache.set(result, {
+          context: previousContext,
+          languageId: embeddedLanguage,
+          response: {
+            result: embedResult,
+            isFull: true,
+            TokenMap: []
+          }
         });
       } else {
         tokenizersToLoad.push(embeddedLanguage);
-        embeddedResults.push({
-          result: {},
-          isFull: false,
-          TokenMap: []
+        embeddedResultCache.set(result, {
+          context: undefined,
+          languageId: embeddedLanguage,
+          response: {
+            result: {},
+            isFull: false,
+            TokenMap: []
+          }
         });
-        topContext = undefined;
       }
-    } else {
-      topContext = undefined;
     }
   }
   return {
-    tokenizersToLoad,
-    embeddedResults
+    tokenizersToLoad
   };
 };
+const getVisibleEmbeddedResults = visibleLines => {
+  const embeddedResults = [];
+  for (const result of visibleLines) {
+    const cached = embeddedResultCache.get(result);
+    if (cached) {
+      result.embeddedResultIndex = embeddedResults.length;
+      embeddedResults.push(cached.response);
+    }
+  }
+  return embeddedResults;
+};
 const getTokenizeEndIndex = (invalidStartIndex, endLineIndex, tokenizeStartIndex) => {
   return invalidStartIndex < endLineIndex ? endLineIndex : tokenizeStartIndex;
 };
@@ -1298,8 +1316,6 @@ const getTokensViewport = (editor, startLineIndex, endLineIndex, hasLinesToSend,
   } = tokenizer;
   const tokenizeStartIndex = invalidStartIndex;
   const tokenizeEndIndex = getTokenizeEndIndex(invalidStartIndex, endLineIndex, tokenizeStartIndex);
-  const tokenizersToLoad = [];
-  const embeddedResults = [];
   const linesWithEmbed = [];
   for (let i = tokenizeStartIndex; i < tokenizeEndIndex; i++) {
     const lineState = i === 0 ? getInitialLineState(initialLineState) : lineCache[i];
@@ -1308,25 +1324,19 @@ const getTokensViewport = (editor, startLineIndex, endLineIndex, hasLinesToSend,
     // TODO if lineCacheEnd matches the one before, skip tokenizing lines after
     lineCache[i + 1] = result;
     if (result.embeddedLanguage) {
-      result.embeddedResultIndex = linesWithEmbed.length;
       linesWithEmbed.push(i);
     }
   }
   const visibleLines = lineCache.slice(startLineIndex + 1, endLineIndex + 1);
+  let tokenizersToLoad = [];
   if (linesWithEmbed.length > 0) {
-    const {
-      tokenizersToLoad,
-      embeddedResults
-    } = getTokensViewportEmbedded(languageId, lines, lineCache, linesWithEmbed);
-    // TODO support lineCache with embedded content
-    setInvalidStartIndex(id, 0);
-    return {
-      tokens: visibleLines,
-      tokenizersToLoad,
-      embeddedResults
-    };
+    ({
+      tokenizersToLoad
+    } = getTokensViewportEmbedded(languageId, lines, lineCache, linesWithEmbed));
   }
-  setInvalidStartIndex(id, Math.max(invalidStartIndex, tokenizeEndIndex));
+  const embeddedResults = getVisibleEmbeddedResults(visibleLines);
+  const nextInvalidStartIndex = tokenizersToLoad.length > 0 ? tokenizeStartIndex : Math.max(invalidStartIndex, tokenizeEndIndex);
+  setInvalidStartIndex(id, nextInvalidStartIndex);
   return {
     tokens: visibleLines,
     tokenizersToLoad,