@lvce-editor/static-server 0.81.8 → 0.81.10

package/static/{b29e269 → ec38d11}/packages/test-worker/dist/testWorkerMain.js

@@ -533,7 +533,7 @@ const execute$2 = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks$1 = Object.create(null);
-const get$2 = id => {
+const get$3 = id => {
   return callbacks$1[id];
 };
 const remove$2 = id => {
@@ -682,7 +682,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve$1 = (id, response) => {
-  const fn = get$2(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -1091,10 +1091,10 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs[id];
 };
 const remove$1 = id => {
@@ -1105,18 +1105,18 @@ const remove$1 = id => {
 const create = rpcId => {
   return {
     async dispose() {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1124,7 +1124,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$4(rpcId, mockRpc);
+      set$5(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1133,7 +1133,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$4(rpcId, rpc);
+      set$5(rpcId, rpc);
     }
   };
 };
@@ -1152,18 +1152,18 @@ const TestWorker = 9001;
 
 const {
   invoke: invoke$2,
-  set: set$3
+  set: set$4
 } = create(EditorWorker);
 
 const {
   invoke: invoke$1,
-  set: set$2
+  set: set$3
 } = create(OpenerWorker);
 
 const {
   invoke,
   invokeAndTransfer,
-  set: set$1
+  set: set$2
 } = create(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1188,7 +1188,7 @@ const initializeEditorWorker = async () => {
     commandMap: {},
     send: send$1
   });
-  set$3(rpc);
+  set$4(rpc);
 };
 
 const send = async port => {
@@ -1199,7 +1199,18 @@ const initializeOpenerWorker = async () => {
     commandMap: {},
     send
   });
-  set$2(rpc);
+  set$3(rpc);
+};
+
+let autoFixError;
+const get$1 = () => {
+  return autoFixError;
+};
+const set$1 = value => {
+  autoFixError = value;
+};
+const clear$3 = () => {
+  autoFixError = undefined;
 };
 
 class AssertionError extends Error {
@@ -2060,6 +2071,9 @@ const setShowChatListTime = async showTime => {
 const handleAgentModeChange = async newAgentMode => {
   return invoke('Chat.handleAgentModeChange', newAgentMode);
 };
+const mockOpenApiSetResponse = async items => {
+  return invoke('Chat.mockOpenApiSetResponse', items);
+};
 
 const Chat = {
   chatListFocusFirst,
@@ -2101,6 +2115,7 @@ const Chat = {
   mockOpenAiResponse,
   mockOpenApiRequestGetAll,
   mockOpenApiRequestReset,
+  mockOpenApiSetResponse,
   mockOpenApiStreamFinish,
   mockOpenApiStreamPushChunk,
   mockOpenApiStreamReset,
@@ -2132,6 +2147,71 @@ const Chat = {
   useMockApi
 };
 
+const isObject$3 = value => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const formatValue = value => {
+  return JSON.stringify(value);
+};
+const assertArrayMatches = (actual, expected, path) => {
+  if (!Array.isArray(actual)) {
+    throw new TypeError(`Expected ${path} to be an array but got ${formatValue(actual)}`);
+  }
+  if (actual.length < expected.length) {
+    throw new Error(`Expected ${path} to have at least ${expected.length} items but got ${actual.length}`);
+  }
+  for (let index = 0; index < expected.length; index++) {
+    assertPayloadMatches(actual[index], expected[index], `${path}[${index}]`);
+  }
+};
+const assertObjectMatches = (actual, expected, path) => {
+  if (!isObject$3(actual)) {
+    throw new TypeError(`Expected ${path} to be an object but got ${formatValue(actual)}`);
+  }
+  for (const key of Object.keys(expected)) {
+    if (!Object.hasOwn(actual, key)) {
+      throw new Error(`Expected ${path}.${key} to exist`);
+    }
+    assertPayloadMatches(actual[key], expected[key], `${path}.${key}`);
+  }
+};
+const assertPrimitiveMatches = (actual, expected, path) => {
+  if (!Object.is(actual, expected)) {
+    throw new Error(`Expected ${path} to equal ${formatValue(expected)} but got ${formatValue(actual)}`);
+  }
+};
+const assertPayloadMatches = (actual, expected, path) => {
+  if (Array.isArray(expected)) {
+    assertArrayMatches(actual, expected, path);
+    return;
+  }
+  if (isObject$3(expected)) {
+    assertObjectMatches(actual, expected, path);
+    return;
+  }
+  assertPrimitiveMatches(actual, expected, path);
+};
+
+const defaultMessage = 'ChatDebug.shouldHavePayload assertion failed';
+const getMessage = cause => {
+  if (!cause || typeof cause !== 'object') {
+    return defaultMessage;
+  }
+  if ('message' in cause && typeof cause.message === 'string' && cause.message) {
+    return cause.message;
+  }
+  return defaultMessage;
+};
+class ChatDebugShouldHavePayloadError extends Error {
+  constructor(expectedPayload, actualPayload, cause) {
+    super(getMessage(cause));
+    this.name = 'ChatDebugShouldHavePayloadError';
+    this.code = 'chat-debug.should-have-payload';
+    this.expectedPayload = expectedPayload;
+    this.actualPayload = actualPayload;
+  }
+}
+
 const open$a = async sessionId => {
   await invoke('Main.openUri', `chat-debug://${sessionId}`);
 };
@@ -2169,6 +2249,34 @@ const resetIndexedDbSupportForTest = async () => {
 const selectEventRow = async index => {
   await invoke('ChatDebug.handleEventRowClick', String(index));
 };
+const getActualPayload = error => {
+  if (!error || typeof error !== 'object') {
+    return undefined;
+  }
+  if ('actualPayload' in error) {
+    return error.actualPayload;
+  }
+  if ('actual' in error) {
+    return error.actual;
+  }
+  return undefined;
+};
+const shouldHavePayload = async expectedPayload => {
+  try {
+    await invoke('ChatDebug.shouldHavePayload', expectedPayload);
+  } catch (error) {
+    const actualPayload = getActualPayload(error);
+    throw new ChatDebugShouldHavePayloadError(expectedPayload, actualPayload, error);
+  }
+};
+const shouldHavePayload2 = async expectedPayload => {
+  const actualPayload = await invoke('ChatDebug.getPayload');
+  try {
+    assertPayloadMatches(actualPayload, expectedPayload, 'payload');
+  } catch (error) {
+    throw new ChatDebugShouldHavePayloadError(expectedPayload, actualPayload, error);
+  }
+};
 const handleInput$7 = async (name, value, checked) => {
   await invoke('ChatDebug.handleInput', name, value, checked);
 };
@@ -2282,6 +2390,8 @@ const ChatDebug = {
   setShowInputEvents,
   setShowResponsePartEvents,
   setTimelineRangePreset,
+  shouldHavePayload,
+  shouldHavePayload2,
   toggleHeadersSection,
   useDevtoolsLayout
 };
@@ -2417,7 +2527,7 @@ const directionMap = {
   horizontal: 1,
   vertical: 2
 };
-const isObject$1 = value => {
+const isObject$2 = value => {
   return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof RegExp);
 };
 const matchesExpectedArray = (actual, expected) => {
@@ -2432,7 +2542,7 @@ const matchesExpectedArray = (actual, expected) => {
   return true;
 };
 const matchesExpectedObject = (actual, expected) => {
-  if (!isObject$1(actual)) {
+  if (!isObject$2(actual)) {
     return false;
   }
   for (const [childKey, childExpectedValue] of Object.entries(expected)) {
@@ -2455,7 +2565,7 @@ const matchesExpected = (actual, expected, key = '') => {
   if (Array.isArray(expected)) {
     return matchesExpectedArray(actual, expected);
   }
-  if (isObject$1(expected)) {
+  if (isObject$2(expected)) {
     return matchesExpectedObject(actual, expected);
   }
   return Object.is(actual, expected);
@@ -3482,7 +3592,7 @@ const ExtensionSearch = {
 
 const Memfs = 'memfs';
 
-const toFileUrl = url => {
+const toFileUrl$1 = url => {
   const urlObject = new URL(url);
   const pathName = urlObject.pathname;
   if (!pathName.startsWith('/remote')) {
@@ -3506,7 +3616,7 @@ const getDirents = async fileUrl => {
   return allDirents;
 };
 const getFileMapNode = async url => {
-  const fileUrl = toFileUrl(url);
+  const fileUrl = toFileUrl$1(url);
   const allFiles = await getDirents(fileUrl);
   const fileMap = Object.create(null);
   const contents = await Promise.all(allFiles.map(filePath => {
@@ -3520,11 +3630,11 @@ const getFileMapNode = async url => {
   return fileMap;
 };
 
-const isObject = value => {
+const isObject$1 = value => {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 };
 const isValidFileMap = value => {
-  if (!isObject(value)) {
+  if (!isObject$1(value)) {
     return false;
   }
   for (const key in value) {
@@ -4834,6 +4944,22 @@ const formatDuration = duration => {
 const Fail = 'fail';
 const Pass = 'pass';
 
+const getAutoFixProperties = error => {
+  const isChatDebugPayloadError = error instanceof ChatDebugShouldHavePayloadError && error.actualPayload !== undefined;
+  const autoFixProperties = isChatDebugPayloadError ? {
+    autoFixError: {
+      actualPayload: error.actualPayload,
+      code: error.code,
+      expectedPayload: error.expectedPayload
+    },
+    overlayActions: [{
+      command: 'Test.tryAutoFix',
+      id: 'chat-debug-should-have-payload-autofix',
+      label: 'Autofix'
+    }]
+  } : {};
+  return autoFixProperties;
+};
 const executeTest2 = async (name, fn, globals, timestampGenerator) => {
   const getTimestamp = timestampGenerator;
   const start = getTimestamp();
@@ -4842,6 +4968,7 @@ const executeTest2 = async (name, fn, globals, timestampGenerator) => {
   const duration = end - start;
   const formattedDuration = formatDuration(duration);
   if (error) {
+    const autoFixProperties = getAutoFixProperties(error);
     return {
       background: 'red',
       duration,
@@ -4849,6 +4976,7 @@ const executeTest2 = async (name, fn, globals, timestampGenerator) => {
       error,
       formattedDuration,
       name,
+      ...autoFixProperties,
       start,
       text: `test failed: ${error}`,
       type: Fail
@@ -4886,18 +5014,25 @@ const now = () => {
 
 const executeTest = async (name, fn, globals = {}) => {
   const {
+    autoFixError,
     background,
     error,
     formattedDuration,
+    overlayActions,
     text,
     type
   } = await executeTest2(name, fn, globals, now);
+  set$1(autoFixError);
   if (error) {
     await printTestError(error);
   } else {
     // eslint-disable-next-line no-console
     console.info(`PASS ${name} in ${formattedDuration}`);
   }
+  if (overlayActions && overlayActions.length > 0) {
+    await invoke('TestFrameWork.showOverlay', type, background, text, overlayActions);
+    return;
+  }
   await invoke('TestFrameWork.showOverlay', type, background, text);
 };
 
@@ -4989,6 +5124,7 @@ const execute = async (href, platform, assetDir) => {
     }
     // TODO maybe setup file watcher earlier, to not miss events?
   } catch (error) {
+    clear$3();
     await printTestError(error);
     await invoke('TestFrameWork.showOverlay', Fail, 'red', `test failed: ${error}`);
     return;
@@ -5073,17 +5209,365 @@ 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 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') {
+      return {
+        consumed: 1,
+        inBlockComment,
+        inLineComment: false
+      };
+    }
+    return {
+      consumed: 1,
+      inBlockComment,
+      inLineComment
+    };
+  }
+  if (inBlockComment) {
+    if (character === '*' && nextCharacter === '/') {
+      return {
+        consumed: 2,
+        inBlockComment: false,
+        inLineComment
+      };
+    }
+    return {
+      consumed: 1,
+      inBlockComment,
+      inLineComment
+    };
+  }
+  if (character === '/' && nextCharacter === '/') {
+    return {
+      consumed: 2,
+      inBlockComment,
+      inLineComment: true
+    };
+  }
+  if (character === '/' && nextCharacter === '*') {
+    return {
+      consumed: 2,
+      inBlockComment: true,
+      inLineComment
+    };
+  }
+  return {
+    consumed: 0,
+    inBlockComment,
+    inLineComment
+  };
+};
+const consumeString = (stringDelimiter, character) => {
+  if (!stringDelimiter) {
+    if (isStringDelimiter(character)) {
+      return {
+        consumed: 1,
+        stringDelimiter: character
+      };
+    }
+    return {
+      consumed: 0,
+      stringDelimiter
+    };
+  }
+  if (character === '\\') {
+    return {
+      consumed: 2,
+      stringDelimiter
+    };
+  }
+  if (character === stringDelimiter) {
+    return {
+      consumed: 1,
+      stringDelimiter: ''
+    };
+  }
+  return {
+    consumed: 1,
+    stringDelimiter
+  };
+};
+const findClosingParenthesis = (fileContent, startIndex) => {
+  let depth = 1;
+  let inBlockComment = false;
+  let inLineComment = false;
+  let stringDelimiter = '';
+  for (let index = startIndex; index < fileContent.length;) {
+    const character = fileContent[index];
+    const nextCharacter = fileContent[index + 1];
+    const stringState = consumeString(stringDelimiter, character);
+    const {
+      consumed: consumedString,
+      stringDelimiter: nextStringDelimiter
+    } = stringState;
+    stringDelimiter = nextStringDelimiter;
+    if (consumedString > 0) {
+      index += consumedString;
+      continue;
+    }
+    const commentState = consumeComment(inBlockComment, inLineComment, character, nextCharacter);
+    const {
+      consumed: consumedComment,
+      inBlockComment: nextInBlockComment,
+      inLineComment: nextInLineComment
+    } = commentState;
+    inBlockComment = nextInBlockComment;
+    inLineComment = nextInLineComment;
+    if (consumedComment > 0) {
+      index += consumedComment;
+      continue;
+    }
+    if (character === '(') {
+      depth++;
+      index++;
+      continue;
+    }
+    if (character === ')') {
+      depth--;
+      if (depth === 0) {
+        return index;
+      }
+    }
+    index++;
+  }
+  return -1;
+};
+const findShouldHavePayloadMatches = fileContent => {
+  const matches = [];
+  let searchIndex = 0;
+  while (searchIndex < fileContent.length) {
+    const matchIndex = fileContent.indexOf(shouldHavePayloadSearch, searchIndex);
+    if (matchIndex === -1) {
+      break;
+    }
+    const argumentStart = matchIndex + shouldHavePayloadSearch.length;
+    const closingParenthesisIndex = findClosingParenthesis(fileContent, argumentStart);
+    if (closingParenthesisIndex === -1) {
+      break;
+    }
+    matches.push({
+      argument: fileContent.slice(argumentStart, closingParenthesisIndex),
+      index: matchIndex,
+      length: closingParenthesisIndex - matchIndex + 1
+    });
+    searchIndex = closingParenthesisIndex + 1;
+  }
+  return matches;
+};
+const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) => {
+  const minimalPayload = projectActualOntoExpected(actualPayload, expectedPayload);
+  const serializedMinimalPayload = trySerialize(minimalPayload);
+  if (!serializedMinimalPayload) {
+    return undefined;
+  }
+  const matches = findShouldHavePayloadMatches(fileContent);
+  if (matches.length === 0) {
+    return undefined;
+  }
+  if (matches.length === 1) {
+    const [match] = matches;
+    return replaceMatch(fileContent, match.index, match.length, `shouldHavePayload(${serializedMinimalPayload})`);
+  }
+  const serializedExpected = trySerialize(expectedPayload);
+  if (!serializedExpected) {
+    return undefined;
+  }
+  const normalizedExpected = normalizeWhitespace(serializedExpected);
+  const matchingCandidates = [];
+  for (const match of matches) {
+    if (normalizeWhitespace(match.argument) === normalizedExpected) {
+      matchingCandidates.push(match);
+    }
+  }
+  if (matchingCandidates.length !== 1) {
+    return undefined;
+  }
+  const [candidate] = matchingCandidates;
+  return replaceMatch(fileContent, candidate.index, candidate.length, `shouldHavePayload(${serializedMinimalPayload})`);
+};
+const getFileUrlFromRemotePath = rawPathName => {
+  if (!rawPathName.startsWith('/remote')) {
+    return undefined;
+  }
+  const rest = rawPathName.slice('/remote'.length);
+  return `file://${rest}`;
+};
+const toFileUrl = (url, locationHref) => {
+  const parsedUrl = new URL(url, locationHref);
+  if (parsedUrl.protocol === 'file:') {
+    parsedUrl.hash = '';
+    parsedUrl.search = '';
+    return parsedUrl.toString();
+  }
+  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();
+  if (!latestTestInfo) {
+    return;
+  }
+  if (latestTestInfo.inProgress) {
+    return;
+  }
+  const autoFixError = dependencies.getAutoFixError();
+  if (!isAutoFixError(autoFixError)) {
+    return;
+  }
+  if (autoFixError.actualPayload === undefined) {
+    return;
+  }
+  const locationHref = dependencies.getLocationHref();
+  const fileUrl = toFileUrl(latestTestInfo.url, locationHref);
+  if (!fileUrl) {
+    return;
+  }
+  const fileContent = await dependencies.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);
+};
+const tryAutoFix = async () => {
+  await tryAutoFixWith(defaultDependencies);
+};
+
 const commandMap = {
   'FileWatcher.handleEvent': handleFileWatcherEvent,
   'Test.execute': execute,
-  'Test.executeMock': executeMock
+  'Test.executeMock': executeMock,
+  'Test.tryAutoFix': tryAutoFix
 };
 
 const initializeRendererWorker = async () => {
   const rpc = await create$1({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const listen = async () => {