@lvce-editor/static-server 0.40.9 → 0.41.1

package/static/{8c086b8 → 89cea5f}/packages/explorer-worker/dist/explorerViewWorkerMain.js

@@ -320,14 +320,14 @@ const readyMessage = 'ready';
 const getData$2 = event => {
   return event.data;
 };
-const listen$6 = () => {
+const listen$7 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$6 = global => {
+const signal$7 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -353,7 +353,7 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$d = global => {
+const wrap$e = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const withResolvers = () => {
@@ -378,10 +378,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$5 = async () => {
-  const parentIpcRaw = listen$6();
-  signal$6(parentIpcRaw);
-  const parentIpc = wrap$d(parentIpcRaw);
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$7(parentIpcRaw);
+  const parentIpc = wrap$e(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -426,13 +426,13 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$c = port => {
+const wrap$d = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$5,
-  wrap: wrap$c
+  listen: listen$6,
+  wrap: wrap$d
 };
 
 const Two = '2.0';
@@ -2167,23 +2167,24 @@ const getMenuEntries = state => {
   }
 };
 
-const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue) => {
+const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, icons) => {
   const visible = [];
+  let iconIndex = 0;
   for (let i = minLineY; i < Math.min(maxLineY, items.length); i++) {
     const item = items[i];
+    const icon = icons[iconIndex++];
     if (i === editingIndex) {
       visible.push({
         ...item,
         isFocused: i === focusedIndex,
         isEditing: true,
-        icon: getFileIcon$1({
-          name: editingValue
-        })
+        icon
       });
     } else {
       visible.push({
         ...item,
-        isFocused: i === focusedIndex
+        isFocused: i === focusedIndex,
+        icon
       });
     }
   }
@@ -2325,7 +2326,7 @@ const handleClickDirectoryExpanding = (state, dirent, index, keepFocus) => {
 };
 
 const handleClickFile$1 = async (state, dirent, index, keepFocus = false) => {
-  // await Command.execute(/* Main.openAbsolutePath */ 'Main.openUri', /* absolutePath */ dirent.path, /* focus */ !keepFocus)
+  await invoke(/* Main.openAbsolutePath */'Main.openUri', /* absolutePath */dirent.path, /* focus */!keepFocus);
   return {
     ...state,
     focusedIndex: index,
@@ -2677,6 +2678,65 @@ const handleCopy = async state => {
   return state;
 };
 
+const canBeDroppedInto = dirent => {
+  if (!dirent) {
+    return false;
+  }
+  switch (dirent.type) {
+    case Directory:
+    case DirectoryExpanded:
+    case DirectoryExpanding:
+      return true;
+    default:
+      return false;
+  }
+};
+
+const getNewDropTargets = (state, x, y) => {
+  const {
+    items
+  } = state;
+  const index = getIndexFromPosition(state, x, y);
+  if (index === -1) {
+    return [-1];
+  }
+  const item = items[index];
+  if (!canBeDroppedInto(item)) {
+    return [];
+  }
+  const newDropTargets = [index];
+  return newDropTargets;
+};
+
+const isEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  const length = a.length;
+  for (let i = 0; i < length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const handleDragOver = (state, x, y) => {
+  number(x);
+  number(y);
+  const {
+    dropTargets
+  } = state;
+  const newDropTargets = getNewDropTargets(state, x, y);
+  if (isEqual(dropTargets, newDropTargets)) {
+    return state;
+  }
+  return {
+    ...state,
+    dropTargets: newDropTargets
+  };
+};
+
 const getFilePathElectron = async file => {
   return invoke('GetFilePathElectron.getFilePathElectron', file);
 };
@@ -3280,9 +3340,15 @@ const removeDirent = async state => {
   } else {
     indexToFocus = Math.max(state.focusedIndex - 1, 0);
   }
+  const visible = newDirents.slice(state.minLineY, state.maxLineY);
+  const icons = await getFileIcons(visible);
+  console.log({
+    icons
+  });
   return {
     ...state,
     items: newDirents,
+    icons,
     focusedIndex: indexToFocus
   };
 };
@@ -3302,6 +3368,57 @@ const renameDirent = state => {
   };
 };
 
+const renderItems = {
+  isEqual(oldState, newState) {
+    return JSON.stringify(oldState.items) === JSON.stringify(newState.items) && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex && oldState.editingIndex === newState.editingIndex && oldState.editingType === newState.editingType && oldState.editingValue === newState.editingValue && oldState.width === newState.width;
+  },
+  apply(oldState, newState) {
+    const visibleDirents = getVisibleExplorerItems(newState.items, newState.minLineY, newState.maxLineY, newState.focusedIndex, newState.editingIndex, newState.editingType, newState.editingValue, newState.icons);
+    const isWide = newState.width > 450;
+    const dom = getExplorerVirtualDom(visibleDirents, newState.focusedIndex, newState.root, isWide);
+    return ['Viewlet.setDom2', dom];
+  }
+};
+
+// const renderFocusedIndex = {
+//   isEqual(oldState:any, newState:any) {
+//     return oldState.focusedIndex === newState.focusedIndex && oldState.focused === newState.focused && oldState.minLineY === newState.minLineY
+//   },
+//   apply(oldState:any, newState:any) {
+//     const oldFocusedIndex = oldState.focusedIndex - oldState.minLineY
+//     const newFocusedIndex = newState.focusedIndex - newState.minLineY
+//     return [/* method */ 'setFocusedIndex', /* oldindex */ oldFocusedIndex, /* newIndex */ newFocusedIndex, /* focused */ newState.focused]
+//   },
+// }
+
+// const renderDropTargets = {
+//   isEqual(oldState:any, newState:any) {
+//     return oldState.dropTargets === newState.dropTargets
+//   },
+//   apply(oldState:any, newState:any) {
+//     return [/* method */ 'setDropTargets', /* oldDropTargets */ oldState.dropTargets, /* newDropTargets */ newState.dropTargets]
+//   },
+// }
+
+const renderEditingIndex = {
+  isEqual(oldState, newState) {
+    return oldState.editingIndex === newState.editingIndex && oldState.editingType === newState.editingType;
+  },
+  apply(oldState, newState) {
+    return ['focusInput', 'ExplorerInput'];
+  }
+};
+const render = [renderItems, renderEditingIndex];
+const doRender = (oldState, newState) => {
+  const commands = [];
+  for (const fn of render) {
+    if (!fn.isEqual(oldState, newState)) {
+      commands.push(fn.apply(oldState, newState));
+    }
+  }
+  return commands;
+};
+
 const getIconVirtualDom = (icon, type = Div) => {
   return {
     type,
@@ -3688,6 +3805,7 @@ const commandMap = {
   'Explorer.handleClickOpenFolder': handleClickOpenFolder,
   'Explorer.handleContextMenu': handleContextMenu,
   'Explorer.handleCopy': handleCopy,
+  'Explorer.handleDragOver': handleDragOver,
   'Explorer.handleDrop': handleDrop,
   'Explorer.handleIconThemeChange': handleIconThemeChange,
   'Explorer.handlePaste': handlePaste,
@@ -3701,6 +3819,7 @@ const commandMap = {
   'Explorer.openContainingFolder': openContainingFolder,
   'Explorer.removeDirent': removeDirent,
   'Explorer.renameDirent': renameDirent,
+  'Explorer.render': doRender,
   'Explorer.renderActions': renderActions,
   'Explorer.restoreState': restoreState,
   'Explorer.revealItem': revealItem,

package/static/{8c086b8 → 89cea5f}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -4,13 +4,13 @@ const Function = 3;
 const Variable = 4;
 const Keyword = 5;
 const Folder = 6;
-const File$2 = 7;
+const File$3 = 7;
 const Field = 8;
 
 const EditorCompletionType = {
   __proto__: null,
   Field,
-  File: File$2,
+  File: File$3,
   Folder,
   Function,
   Keyword,
@@ -26,7 +26,7 @@ class DepecratedError extends Error {
   }
 }
 
-const getJson = async url => {
+const getJson$1 = async url => {
   throw new DepecratedError(`vscode.getJson is deprecated, use createNodeRpc instead`);
 };
 
@@ -307,7 +307,7 @@ const get$6 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
-const getText = textDocument => {
+const getText$1 = textDocument => {
   return textDocument.text;
 };
 const setLanguageId = (textDocumentId, languageId) => {
@@ -887,14 +887,14 @@ const joinLines$1 = lines => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines$1 = lines => {
+const splitLines$2 = lines => {
   return lines.split(NewLine$2);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(1));
+  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -1650,7 +1650,7 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/8c086b8/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/89cea5f/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -2200,18 +2200,18 @@ class FormattingError extends Error {
   }
 }
 
-const File$1 = 1;
+const File$2 = 1;
 const Match = 2;
 
 const TextSearchResultType = {
   __proto__: null,
-  File: File$1,
+  File: File$2,
   Match
 };
 
 const api = {
   // Ajax
-  getJson: getJson,
+  getJson: getJson$1,
   // Brace Completion
   registerBraceCompletionProvider: registerBraceCompletionProvider,
   executeBraceCompletionProvider: executeBraceCompletionProvider,
@@ -2286,7 +2286,7 @@ const api = {
   registerTabCompletionProvider: registerTabCompletionProvider,
   executeTabCompletionProvider: executeTabCompletionProvider,
   // Text Document
-  getTextFromTextDocument: getText,
+  getTextFromTextDocument: getText$1,
   // Text Search
   registerTextSearchProvider: registerTextSearchProvider,
   executeTextSearchProvider: executeTextSearchProvider,
@@ -2484,9 +2484,9 @@ class BabelParseError extends SyntaxError {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/8c086b8' !== 'undefined') {
+  if (typeof '/89cea5f' !== 'undefined') {
     // @ts-ignore
-    return '/8c086b8';
+    return '/89cea5f';
   }
   if (platform === Electron) {
     return '../../../../..';
@@ -2542,7 +2542,7 @@ const CallExpression = 'CallExpression';
 const ExportAllDeclaration = 'ExportAllDeclaration';
 const ExportNamedDeclaration = 'ExportNamedDeclaration';
 const ExpressionStatement = 'ExpressionStatement';
-const File = 'File';
+const File$1 = 'File';
 const Import = 'Import';
 const ImportDeclaration = 'ImportDeclaration';
 const Program = 'Program';
@@ -2562,7 +2562,7 @@ const walk = (node, visitor) => {
   }
   visitor(node);
   switch (node.type) {
-    case File:
+    case File$1:
       walk(node.program, visitor);
       break;
     case Program:
@@ -3054,14 +3054,14 @@ const NewLine$1 = '\n';
 const joinLines = lines => {
   return lines.join(NewLine$1);
 };
-const splitLines = lines => {
+const splitLines$1 = lines => {
   return lines.split(NewLine$1);
 };
 const isModuleNotFoundMessage = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
 const getModuleNotFoundError = stderr => {
-  const lines = splitLines(stderr);
+  const lines = splitLines$1(stderr);
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
@@ -3085,7 +3085,7 @@ const isMessageCodeBlockEndIndex = line => {
   return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
 const getMessageCodeBlock = stderr => {
-  const lines = splitLines(stderr);
+  const lines = splitLines$1(stderr);
   const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
   const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
   const relevantLines = lines.slice(startIndex, endIndex);
@@ -3149,7 +3149,7 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
   if (isModuleNotFoundError(stderr)) {
     return getModuleNotFoundError(stderr);
   }
-  const lines = splitLines(stderr);
+  const lines = splitLines$1(stderr);
   const {
     actualMessage,
     rest
@@ -3681,7 +3681,7 @@ const addHandle = async (uri, handle) => {
   const handleDb = await getHandleDb();
   await handleDb.put('file-handles-store', handle, uri);
 };
-const getHandle = async uri => {
+const getHandle$1 = async uri => {
   const handleDb = await getHandleDb();
   const handle = await handleDb.get('file-handles-store', uri);
   return handle;
@@ -3758,16 +3758,300 @@ const saveState = async () => {
   return serialized;
 };
 
+const fileMapUrl = `${assetDir}/config/fileMap.json`;
+
+const getJson = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const json = await response.json();
+    return json;
+  } catch (error) {
+    throw new VError$1(error, `Failed to get json`);
+  }
+};
+
+const removeLeadingSlash = path => {
+  if (path.startsWith('/')) {
+    return path.slice(1);
+  }
+  return path;
+};
+
+// TODO simplify code
+// 1. don't have playground prefix in fileMap json
+// 2. remove code here that removes the prefix
+const searchFile$1 = async path => {
+  const fileList = await getJson(fileMapUrl);
+  const result = fileList.map(removeLeadingSlash);
+  const prefixLength = path.length - 'file:///'.length;
+  const final = [];
+  for (const item of result) {
+    final.push(item.slice(prefixLength));
+  }
+  return final;
+};
+
+const Directory = 'directory';
+const File = 'file';
+
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+
+const insertInto = (array, start, newItems) => {
+  const originalLength = array.length;
+  const newItemsLength = newItems.length;
+  array.length = originalLength + newItemsLength;
+  // Move the items after the start index, start from the end so that we don't overwrite any value.
+  for (let i = originalLength - 1; i >= start; i--) {
+    array[i + newItemsLength] = array[i];
+  }
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
+  }
+};
+const push = (array, newItems) => {
+  insertInto(array, array.length, newItems);
+};
+const fromAsync = async asyncIterable => {
+  const children = [];
+  for await (const value of asyncIterable) {
+    children.push(value);
+  }
+  return children;
+};
+
+const getChildHandles$1 = async handle => {
+  object(handle);
+  // @ts-ignore
+  const childHandles = handle.values();
+  const handles = await fromAsync(childHandles);
+  return handles;
+};
+
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return path;
+  }
+  return path.slice(0, index);
+};
+
+const getHandle = async uri => {
+  try {
+    // TODO retrieve handle from state or from indexeddb
+    // TODO if not found, throw error
+    const handle = await getHandle$1(uri);
+    return handle;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to get handle');
+  }
+};
+
+const getDirectoryHandle$1 = async uri => {
+  const handle = await getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname('/', uri);
+  if (uri === dirname$1) {
+    return undefined;
+  }
+  return getDirectoryHandle$1(dirname$1);
+};
+const toIgnore = ['.git', 'node_modules', 'dist', 'dist2'];
+const searchFilesRecursively = async (all, parent, handle) => {
+  const childHandles = await getChildHandles$1(handle);
+  const promises = [];
+  for (const childHandle of childHandles) {
+    if (toIgnore.includes(childHandle.name)) {
+      continue;
+    }
+    const absolutePath = parent + '/' + childHandle.name;
+    switch (childHandle.kind) {
+      case Directory:
+        promises.push(searchFilesRecursively(all, absolutePath, childHandle));
+        break;
+      case File:
+        all.push(absolutePath);
+        break;
+    }
+  }
+  await Promise.all(promises);
+};
+const searchFile = async uri => {
+  const path = uri.slice('html://'.length);
+  const handle = await getDirectoryHandle$1(path);
+  if (!handle) {
+    // @ts-ignore
+    throw new VError$1(`Folder not found ${uri}`);
+  }
+  const all = [];
+  await searchFilesRecursively(all, '', handle);
+  return all;
+};
+
+const getText = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const text = await response.text();
+    return text;
+  } catch (error) {
+    throw new VError$1(error, `Failed to get text`);
+  }
+};
+
+const splitLines = lines => {
+  return lines.split('\n');
+};
+
+const textSearchInText = (file, content, query) => {
+  const results = [];
+  const lines = splitLines(content);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const index = line.indexOf(query);
+    if (index !== -1) {
+      results.push({
+        type: Match,
+        text: line,
+        start: index,
+        end: index + query.length,
+        lineNumber: i
+      });
+    }
+  }
+  if (results.length > 0) {
+    results.unshift({
+      type: File$2,
+      text: file,
+      start: 0,
+      end: 0,
+      lineNumber: 0
+    });
+  }
+  return results;
+};
+
+const textSearch$1 = async (scheme, root, query, options, assetDir) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const fetchUri = `${assetDir}/config/fileMap.json`;
+  const fileList = await getJson(fetchUri);
+  const allResults = [];
+  const relativeRoot = root.slice('fetch://'.length);
+  for (const uri of fileList) {
+    const fetchUri = `${assetDir}${uri}`;
+    const content = await getText(fetchUri);
+    const relativeUri = uri.slice(relativeRoot.length + 1);
+    const results = textSearchInText(relativeUri, content, query);
+    allResults.push(...results);
+  }
+  return allResults;
+};
+
+class FileNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'FileNotFoundError';
+  }
+}
+
+const getChildHandles = async handle => {
+  try {
+    return await getChildHandles$1(handle);
+  } catch (error) {
+    throw new VError$1(error, 'failed to get child handles');
+  }
+};
+
+const getDirectoryHandle = async uri => {
+  const handle = await getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname('/', uri);
+  if (uri === dirname$1) {
+    return undefined;
+  }
+  return getDirectoryHandle(dirname$1);
+};
+
+const NotReadableError = 'NotReadableError';
+
+const isNotReadableError = error => {
+  return error && error.name === NotReadableError;
+};
+
+const getFile = handle => {
+  return handle.getFile();
+};
+
+const textSearchInFile = async (all, handle, absolutePath, query) => {
+  try {
+    const file = await getFile(handle);
+    const content = await file.text();
+    const results = textSearchInText(absolutePath, content, query);
+    push(all, results);
+  } catch (error) {
+    if (isNotReadableError(error)) {
+      // ignore
+      return;
+    }
+    throw error;
+  }
+};
+
+const textSearchRecursively = async (all, parent, handle, query) => {
+  const childHandles = await getChildHandles(handle);
+  const promises = [];
+  for (const childHandle of childHandles) {
+    const absolutePath = parent + '/' + childHandle.name;
+    switch (childHandle.kind) {
+      case Directory:
+        promises.push(textSearchRecursively(all, absolutePath, childHandle, query));
+        break;
+      case File:
+        // @ts-ignore
+        promises.push(textSearchInFile(all, childHandle, absolutePath, query));
+        break;
+    }
+  }
+  await Promise.all(promises);
+};
+const textSearch = async (scheme, root, query) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const relativeRoot = root.slice('html://'.length);
+  const handle = await getDirectoryHandle(relativeRoot);
+  if (!handle) {
+    throw new FileNotFoundError(`Folder not found: ${relativeRoot}`);
+  }
+  const all = [];
+  await textSearchRecursively(all, '', handle, query);
+  return all;
+};
+
 const commandMap = {
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
   'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
   'IndexedDb.addHandle': addHandle,
   'IndexedDb.get': get,
-  'IndexedDb.getHandle': getHandle,
+  'IndexedDb.getHandle': getHandle$1,
   'IndexedDb.getValues': getValues,
   'IndexedDb.getValuesByIndexName': getValuesByIndexName,
   'IndexedDb.saveValue': saveValue,
   'IndexedDb.set': set,
+  'SearchFileWithFetch.searchFileWithFetch': searchFile$1,
+  'SearchFileWithHtml.searchFileWithHtml': searchFile,
+  'TextSearchFetch.textSearch': textSearch$1,
+  'TextSearchHtml.textSearch': textSearch,
   ['ExtensionHostDebug.evaluate']: evaluate,
   ['ExtensionHostDebug.getProperties']: getProperties,
   ['ExtensionHostDebug.listProcesses']: listProcesses,