@lvce-editor/static-server 0.81.15 → 0.82.1

package/static/{deea804 → 318496f}/packages/test-worker/dist/testWorkerMain.js

@@ -1139,6 +1139,7 @@ const create = rpcId => {
 };
 
 const Directory = 3;
+const File = 7;
 
 const Script$1 = 2;
 
@@ -3795,6 +3796,22 @@ const shouldHaveFolder = async uri => {
     throw new AssertionError(`expected filesystem entry "${uri}" to be a folder but it was type ${matchingDirent.type}`);
   }
 };
+const shouldHaveFile = async (uri, expectedContent) => {
+  const parentUri = getParentUri(uri);
+  const fileName = getBaseName(uri);
+  const dirents = await readDir(parentUri);
+  const matchingDirent = dirents.find(dirent => dirent.name === fileName);
+  if (!matchingDirent) {
+    throw new AssertionError(`expected filesystem to have file "${uri}" but it was not found`);
+  }
+  if (matchingDirent.type !== File) {
+    throw new AssertionError(`expected filesystem entry "${uri}" to be a file but it was type ${matchingDirent.type}`);
+  }
+  const actualContent = await readFile(uri);
+  if (actualContent !== expectedContent) {
+    throw new AssertionError(`expected file "${uri}" to have content "${expectedContent}" but got "${actualContent}"`);
+  }
+};
 const remove = async uri => {
   await invoke('FileSystem.remove', uri);
 };
@@ -3876,6 +3893,7 @@ const FileSystem = {
   readFile,
   remove,
   setFiles,
+  shouldHaveFile,
   shouldHaveFolder,
   writeFile,
   writeJson
@@ -3945,41 +3963,124 @@ const FindWidget = {
   toggleUseRegularExpression: toggleUseRegularExpression$1
 };
 
-const init = async () => {
-  await invoke('ExtensionHost.executeCommand', 'git.init');
+const executeExtensionCommand = async (commandId, ...args) => {
+  return invoke('ExtensionHost.executeCommand', commandId, ...args);
+};
+
+const init = async (options = {}) => {
+  await executeExtensionCommand('git.init', options);
 };
 const clone = async (repositoryUrl, cwd) => {
-  await invoke('ExtensionHost.executeCommand', 'git.clone', repositoryUrl, cwd);
+  await executeExtensionCommand('git.clone', repositoryUrl, cwd);
 };
 const add = async pathSpec => {
-  await invoke('ExtensionHost.executeCommand', 'git.add', pathSpec);
+  await executeExtensionCommand('git.add', pathSpec);
+};
+const addAll = async () => {
+  await add('.');
 };
 const commit = async message => {
-  await invoke('ExtensionHost.executeCommand', 'git.commit', message);
+  await executeExtensionCommand('git.commit', message);
 };
-const push$1 = async (remote, branch) => {
-  await invoke('ExtensionHost.executeCommand', 'git.push', remote, branch);
+const push$1 = async (remoteOrOptions, branch) => {
+  if (typeof remoteOrOptions === 'string') {
+    await executeExtensionCommand('git.push', {
+      setUpstream: [remoteOrOptions, branch || '']
+    });
+    return;
+  }
+  await executeExtensionCommand('git.push', remoteOrOptions || {});
 };
 const pull = async (remote, branch) => {
-  await invoke('ExtensionHost.executeCommand', 'git.pull', remote, branch);
+  await executeExtensionCommand('git.pull', remote, branch);
 };
 const fetch$1 = async remote => {
-  await invoke('ExtensionHost.executeCommand', 'git.fetch', remote);
+  await executeExtensionCommand('git.fetch', remote);
+};
+const fetchAll = async () => {
+  await executeExtensionCommand('git.fetchAll');
+};
+const fetchPrune = async () => {
+  await executeExtensionCommand('git.fetchPrune');
+};
+const stash = async message => {
+  if (message === undefined) {
+    await executeExtensionCommand('git.stash');
+    return;
+  }
+  await executeExtensionCommand('git.stash', message);
+};
+const unstash = async () => {
+  await executeExtensionCommand('git.unstash');
 };
 const checkout = async ref => {
-  await invoke('ExtensionHost.executeCommand', 'git.checkout', ref);
+  await executeExtensionCommand('git.checkout', ref);
 };
 const branch = async name => {
-  await invoke('ExtensionHost.executeCommand', 'git.branch', name);
+  await executeExtensionCommand('git.branch', name);
+};
+const deleteBranch = async name => {
+  await executeExtensionCommand('git.deleteBranch', name);
+};
+const renameBranch = async newName => {
+  await executeExtensionCommand('git.renameBranch', newName);
+};
+const cherryPick = async commitHash => {
+  await executeExtensionCommand('git.cherryPick', commitHash);
+};
+const merge = async ref => {
+  await executeExtensionCommand('git.merge', ref);
+};
+const rebase = async ref => {
+  await executeExtensionCommand('git.rebase', ref);
+};
+const createTag = async name => {
+  await executeExtensionCommand('git.createTag', name);
+};
+const deleteTag = async name => {
+  await executeExtensionCommand('git.deleteTag', name);
 };
 const status = async () => {
-  return invoke('ExtensionHost.executeCommand', 'git.status');
+  return executeExtensionCommand('git.status');
 };
 const addRemote = async (name, remoteUrl) => {
-  await invoke('ExtensionHost.executeCommand', 'git.addRemote', name, remoteUrl);
+  await executeExtensionCommand('git.addRemote', name, remoteUrl);
+};
+const setOrigin = async remoteUrl => {
+  await addRemote('origin', remoteUrl);
+};
+const setUpstream = async remoteUrl => {
+  await addRemote('upstream', remoteUrl);
+};
+const removeRemote = async name => {
+  await executeExtensionCommand('git.removeRemote', name);
+};
+const removeOrigin = async () => {
+  await removeRemote('origin');
+};
+const removeUpstream = async () => {
+  await removeRemote('upstream');
 };
 const setConfig = async (key, value) => {
-  await invoke('ExtensionHost.executeCommand', 'git.setConfig', key, value);
+  await executeExtensionCommand('git.setConfig', key, value);
+};
+const config = async values => {
+  await Promise.all(Object.entries(values).map(([key, value]) => setConfig(key, value)));
+};
+const shouldHaveCommit = async message => {
+  const commits = await executeExtensionCommand('git.getCommits');
+  if (!Array.isArray(commits)) {
+    throw new TypeError(`Expected commits to be an array, but got ${commits}`);
+  }
+  if (commits.length !== 1) {
+    throw new Error(`Expected 1 commit, but got ${commits.length}`);
+  }
+  if (!commits[0].hash) {
+    throw new Error('Expected commit hash to be defined');
+  }
+  if (commits[0].message !== message) {
+    throw new Error(`Expected commit message to be "${message}", but got "${commits[0].message}"`);
+  }
 };
 const shouldHaveInvocations = async invocations => {
   // TODO
@@ -3987,18 +4088,37 @@ const shouldHaveInvocations = async invocations => {
 
 const Git = {
   add,
+  addAll,
   addRemote,
   branch,
   checkout,
+  cherryPick,
   clone,
   commit,
+  config,
+  createTag,
+  deleteBranch,
+  deleteTag,
   fetch: fetch$1,
+  fetchAll,
+  fetchPrune,
   init,
+  merge,
   pull,
   push: push$1,
+  rebase,
+  removeOrigin,
+  removeRemote,
+  removeUpstream,
+  renameBranch,
   setConfig,
+  setOrigin,
+  setUpstream,
+  shouldHaveCommit,
   shouldHaveInvocations,
-  status
+  stash,
+  status,
+  unstash
 };
 
 const setIconTheme = async id => {
@@ -5356,96 +5476,13 @@ const handleFileWatcherEvent = async event => {
   await hotReloadTest(lastItem, locationHref, time);
 };
 
-const whitespaceRegex = /\s+/g;
-const shouldHavePayloadSearch = 'shouldHavePayload(';
-const validIdentifierRegex = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const normalizeWhitespace = value => {
-  return value.replaceAll(whitespaceRegex, '');
-};
-const isObject = value => {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-};
-const projectActualOntoExpected = (actualValue, expectedValue) => {
-  if (Array.isArray(expectedValue)) {
-    if (!Array.isArray(actualValue)) {
-      return actualValue;
-    }
-    const length = Math.min(expectedValue.length, actualValue.length);
-    return actualValue.slice(0, length).map((item, index) => projectActualOntoExpected(item, expectedValue[index]));
-  }
-  if (isObject(expectedValue)) {
-    if (!isObject(actualValue)) {
-      return actualValue;
-    }
-    const result = {};
-    for (const key of Object.keys(expectedValue)) {
-      if (!Object.hasOwn(actualValue, key)) {
-        continue;
-      }
-      result[key] = projectActualOntoExpected(actualValue[key], expectedValue[key]);
-    }
-    return result;
-  }
-  return actualValue;
-};
-const quoteString = value => {
-  return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'").replaceAll('\n', '\\n').replaceAll('\r', '\\r').replaceAll('\t', '\\t')}'`;
-};
-const formatObjectKey = key => {
-  if (validIdentifierRegex.test(key)) {
-    return key;
-  }
-  return quoteString(key);
-};
-const trySerialize = (value, indent = 0) => {
-  try {
-    if (value === null) {
-      return 'null';
-    }
-    if (typeof value === 'string') {
-      return quoteString(value);
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-      return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-      if (value.length === 0) {
-        return '[]';
-      }
-      const nextIndent = indent + 2;
-      const serializedItems = value.map(item => `${' '.repeat(nextIndent)}${trySerialize(item, nextIndent)}`);
-      return `[
-${serializedItems.join(',\n')}
-${' '.repeat(indent)}]`;
-    }
-    if (isObject(value)) {
-      const entries = Object.entries(value);
-      if (entries.length === 0) {
-        return '{}';
-      }
-      const nextIndent = indent + 2;
-      const serializedEntries = [];
-      for (const entry of entries) {
-        const [key, item] = entry;
-        serializedEntries.push(`${' '.repeat(nextIndent)}${formatObjectKey(key)}: ${trySerialize(item, nextIndent)}`);
-      }
-      return `{
-${serializedEntries.join(',\n')}
-${' '.repeat(indent)}}`;
-    }
-    return undefined;
-  } catch {
-    return undefined;
+const isAutoFixError = value => {
+  if (!value) {
+    return false;
   }
+  return value.code === 'chat-debug.should-have-payload';
 };
-const replaceMatch = (fileContent, index, length, replacement) => {
-  const before = fileContent.slice(0, index);
-  const after = fileContent.slice(index + length);
-  return `${before}${replacement}${after}`;
-};
-const isStringDelimiter = character => {
-  return character === "'" || character === '"' || character === '`';
-};
+
 const consumeComment = (inBlockComment, inLineComment, character, nextCharacter) => {
   if (inLineComment) {
     if (character === '\n') {
@@ -5495,6 +5532,11 @@ const consumeComment = (inBlockComment, inLineComment, character, nextCharacter)
     inLineComment
   };
 };
+
+const isStringDelimiter = character => {
+  return character === "'" || character === '"' || character === '`';
+};
+
 const consumeString = (stringDelimiter, character) => {
   if (!stringDelimiter) {
     if (isStringDelimiter(character)) {
@@ -5525,6 +5567,7 @@ const consumeString = (stringDelimiter, character) => {
     stringDelimiter
   };
 };
+
 const findClosingParenthesis = (fileContent, startIndex) => {
   let depth = 1;
   let inBlockComment = false;
@@ -5570,6 +5613,8 @@ const findClosingParenthesis = (fileContent, startIndex) => {
   }
   return -1;
 };
+
+const shouldHavePayloadSearch = 'shouldHavePayload(';
 const findShouldHavePayloadMatches = fileContent => {
   const matches = [];
   let searchIndex = 0;
@@ -5592,6 +5637,101 @@ const findShouldHavePayloadMatches = fileContent => {
   }
   return matches;
 };
+
+const whitespaceRegex = /\s+/g;
+const trailingCommaRegex = /,([}\]])/g;
+const normalizeWhitespace = value => {
+  return value.replaceAll(whitespaceRegex, '').replaceAll(trailingCommaRegex, '$1');
+};
+
+const isObject = value => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+const projectActualOntoExpected = (actualValue, expectedValue) => {
+  if (Array.isArray(expectedValue)) {
+    if (!Array.isArray(actualValue)) {
+      return actualValue;
+    }
+    const length = Math.min(expectedValue.length, actualValue.length);
+    return actualValue.slice(0, length).map((item, index) => projectActualOntoExpected(item, expectedValue[index]));
+  }
+  if (isObject(expectedValue)) {
+    if (!isObject(actualValue)) {
+      return actualValue;
+    }
+    const result = {};
+    for (const key of Object.keys(expectedValue)) {
+      if (!Object.hasOwn(actualValue, key)) {
+        continue;
+      }
+      result[key] = projectActualOntoExpected(actualValue[key], expectedValue[key]);
+    }
+    return result;
+  }
+  return actualValue;
+};
+
+const replaceMatch = (fileContent, index, length, replacement) => {
+  const before = fileContent.slice(0, index);
+  const after = fileContent.slice(index + length);
+  return `${before}${replacement}${after}`;
+};
+
+const quoteString = value => {
+  return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'").replaceAll('\n', '\\n').replaceAll('\r', '\\r').replaceAll('\t', '\\t')}'`;
+};
+
+const validIdentifierRegex = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const formatObjectKey = key => {
+  if (validIdentifierRegex.test(key)) {
+    return key;
+  }
+  return quoteString(key);
+};
+
+const trySerialize = (value, indent = 0) => {
+  try {
+    if (value === null) {
+      return 'null';
+    }
+    if (typeof value === 'string') {
+      return quoteString(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return '[]';
+      }
+      const nextIndent = indent + 2;
+      const serializedItems = value.map(item => `${' '.repeat(nextIndent)}${trySerialize(item, nextIndent)}`);
+      return `[
+${serializedItems.join(',\n')}
+${' '.repeat(indent)}]`;
+    }
+    if (isObject(value)) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) {
+        return '{}';
+      }
+      const nextIndent = indent + 2;
+      const serializedEntries = [];
+      for (const entry of entries) {
+        const [key, item] = entry;
+        serializedEntries.push(`${' '.repeat(nextIndent)}${formatObjectKey(key)}: ${trySerialize(item, nextIndent)}`);
+      }
+      return `{
+${serializedEntries.join(',\n')}
+${' '.repeat(indent)}}`;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+};
+
 const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) => {
   const minimalPayload = projectActualOntoExpected(actualPayload, expectedPayload);
   const serializedMinimalPayload = trySerialize(minimalPayload);
@@ -5623,6 +5763,7 @@ const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) =
   const [candidate] = matchingCandidates;
   return replaceMatch(fileContent, candidate.index, candidate.length, `shouldHavePayload(${serializedMinimalPayload})`);
 };
+
 const getFileUrlFromRemotePath = rawPathName => {
   if (!rawPathName.startsWith('/remote')) {
     return undefined;
@@ -5630,6 +5771,7 @@ const getFileUrlFromRemotePath = rawPathName => {
   const rest = rawPathName.slice('/remote'.length);
   return `file://${rest}`;
 };
+
 const toFileUrl = (url, locationHref) => {
   const parsedUrl = new URL(url, locationHref);
   if (parsedUrl.protocol === 'file:') {
@@ -5639,68 +5781,39 @@ const toFileUrl = (url, locationHref) => {
   }
   return getFileUrlFromRemotePath(parsedUrl.pathname);
 };
-const isAutoFixError = value => {
-  if (!value) {
-    return false;
-  }
-  return value.code === 'chat-debug.should-have-payload';
-};
-const defaultDependencies = {
-  getAutoFixError() {
-    return get$1();
-  },
-  getLatestTestInfo() {
-    return maybeLast();
-  },
-  getLocationHref() {
-    return location.href;
-  },
-  now: Date.now,
-  readFile(uri) {
-    return readFile(uri);
-  },
-  rerun(url, platform, assetDir) {
-    return execute(url, platform, assetDir);
-  },
-  setAutoFixError(value) {
-    set$1(value);
-  },
-  writeFile(uri, content) {
-    return writeFile(uri, content);
-  }
-};
-const tryAutoFixWith = async dependencies => {
-  const latestTestInfo = dependencies.getLatestTestInfo();
+
+const tryAutoFixWith = async () => {
+  const latestTestInfo = maybeLast();
   if (!latestTestInfo) {
     return;
   }
   if (latestTestInfo.inProgress) {
     return;
   }
-  const autoFixError = dependencies.getAutoFixError();
+  const autoFixError = get$1();
   if (!isAutoFixError(autoFixError)) {
     return;
   }
   if (autoFixError.actualPayload === undefined) {
     return;
   }
-  const locationHref = dependencies.getLocationHref();
-  const fileUrl = toFileUrl(latestTestInfo.url, locationHref);
+  const fileUrl = toFileUrl(latestTestInfo.url, location.href);
   if (!fileUrl) {
     return;
   }
-  const fileContent = await dependencies.readFile(fileUrl);
+  const fileContent = await readFile(fileUrl);
   const updatedFileContent = replaceShouldHavePayload(fileContent, autoFixError.expectedPayload, autoFixError.actualPayload);
   if (!updatedFileContent || updatedFileContent === fileContent) {
     return;
   }
-  await dependencies.writeFile(fileUrl, updatedFileContent);
-  dependencies.setAutoFixError(undefined);
-  const rerunUrl = createUrlWithQueryParameter(latestTestInfo.url, locationHref, dependencies.now());
-  await dependencies.rerun(rerunUrl, latestTestInfo.platform, latestTestInfo.assetDir);
+  await writeFile(fileUrl, updatedFileContent);
+  set$1(undefined);
+  const rerunUrl = createUrlWithQueryParameter(latestTestInfo.url, location.href, Date.now());
+  await execute(rerunUrl, latestTestInfo.platform, latestTestInfo.assetDir);
 };
+
 const tryAutoFix = async () => {
-  await tryAutoFixWith(defaultDependencies);
+  await tryAutoFixWith();
 };
 
 const commandMap = {

package/static/index.html

@@ -6,9 +6,9 @@
     <meta name="description" content="VS Code inspired text editor that mostly runs in a webworker." />
     <meta name="theme-color" content="#282e2f" />
     <title>Lvce Editor</title>
-    <link rel="stylesheet" href="/deea804/css/App.css" />
-    <link rel="manifest" href="/deea804/manifest.json" crossorigin="use-credentials" />
-    <link rel="apple-touch-icon" href="/deea804/icons/pwa-icon-192.png" />
-    <script type="module" src="/deea804/packages/renderer-process/dist/rendererProcessMain.js"></script>
+    <link rel="stylesheet" href="/318496f/css/App.css" />
+    <link rel="manifest" href="/318496f/manifest.json" crossorigin="use-credentials" />
+    <link rel="apple-touch-icon" href="/318496f/icons/pwa-icon-192.png" />
+    <script type="module" src="/318496f/packages/renderer-process/dist/rendererProcessMain.js"></script>
   </head>
 </html>