@lvce-editor/test-worker 14.17.0 → 14.19.0

package/dist/api.d.ts

@@ -329,7 +329,9 @@ interface ChatDebug {
   readonly setShowInputEvents: (enabled: boolean) => Promise<void>;
   readonly setShowResponsePartEvents: (enabled: boolean) => Promise<void>;
   readonly setTimelineRangePreset: (value: string) => Promise<void>;
-  readonly shouldHavePayload: (expectedPayload: any) => Promise<void>;
+  readonly shouldHavePayload: (expectedPayload: unknown) => Promise<void>;
+  readonly shouldHavePayload2: (expectedPayload: unknown) => Promise<void>;
+  readonly shouldHaveResponse: (expectedPayload: unknown) => Promise<void>;
   readonly toggleHeadersSection: (sectionId: string) => Promise<void>;
   readonly useDevtoolsLayout: () => Promise<void>;
 }

package/dist/testWorkerMain.js

@@ -2147,6 +2147,51 @@ 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') {
@@ -2224,6 +2269,23 @@ const shouldHavePayload = async expectedPayload => {
     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 shouldHaveResponse = async expectedPayload => {
+  const actualPayload = await invoke('ChatDebug.getResponse');
+  try {
+    assertPayloadMatches(actualPayload, expectedPayload, 'response');
+  } catch (error) {
+    // TODO maybe rename class
+    throw new ChatDebugShouldHavePayloadError(expectedPayload, actualPayload, error);
+  }
+};
 const handleInput$7 = async (name, value, checked) => {
   await invoke('ChatDebug.handleInput', name, value, checked);
 };
@@ -2338,6 +2400,8 @@ const ChatDebug = {
   setShowResponsePartEvents,
   setTimelineRangePreset,
   shouldHavePayload,
+  shouldHavePayload2,
+  shouldHaveResponse,
   toggleHeadersSection,
   useDevtoolsLayout
 };
@@ -2473,7 +2537,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) => {
@@ -2488,7 +2552,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)) {
@@ -2511,7 +2575,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);
@@ -3576,11 +3640,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) {
@@ -5156,13 +5220,83 @@ const handleFileWatcherEvent = async event => {
 };
 
 const whitespaceRegex = /\s+/g;
-const shouldHavePayloadRegex = /shouldHavePayload\(([^)]*)\)/gs;
+const shouldHavePayloadSearch = 'shouldHavePayload(';
+const validIdentifierRegex = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const normalizeWhitespace = value => {
   return value.replaceAll(whitespaceRegex, '');
 };
-const trySerialize = value => {
+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 {
-    return JSON.stringify(value, null, 2);
+    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;
   }
@@ -5172,21 +5306,168 @@ const replaceMatch = (fileContent, index, length, replacement) => {
   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 serializedActual = trySerialize(actualPayload);
-  if (!serializedActual) {
+  const minimalPayload = projectActualOntoExpected(actualPayload, expectedPayload);
+  const serializedMinimalPayload = trySerialize(minimalPayload);
+  if (!serializedMinimalPayload) {
     return undefined;
   }
-  const matches = [...fileContent.matchAll(shouldHavePayloadRegex)];
+  const matches = findShouldHavePayloadMatches(fileContent);
   if (matches.length === 0) {
     return undefined;
   }
   if (matches.length === 1) {
     const [match] = matches;
-    if (typeof match.index !== 'number') {
-      return undefined;
-    }
-    return replaceMatch(fileContent, match.index, match[0].length, `shouldHavePayload(${serializedActual})`);
+    return replaceMatch(fileContent, match.index, match.length, `shouldHavePayload(${serializedMinimalPayload})`);
   }
   const serializedExpected = trySerialize(expectedPayload);
   if (!serializedExpected) {
@@ -5195,8 +5476,7 @@ const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) =
   const normalizedExpected = normalizeWhitespace(serializedExpected);
   const matchingCandidates = [];
   for (const match of matches) {
-    const currentArgument = match[1];
-    if (normalizeWhitespace(currentArgument) === normalizedExpected) {
+    if (normalizeWhitespace(match.argument) === normalizedExpected) {
       matchingCandidates.push(match);
     }
   }
@@ -5204,10 +5484,7 @@ const replaceShouldHavePayload = (fileContent, expectedPayload, actualPayload) =
     return undefined;
   }
   const [candidate] = matchingCandidates;
-  if (typeof candidate.index !== 'number') {
-    return undefined;
-  }
-  return replaceMatch(fileContent, candidate.index, candidate[0].length, `shouldHavePayload(${serializedActual})`);
+  return replaceMatch(fileContent, candidate.index, candidate.length, `shouldHavePayload(${serializedMinimalPayload})`);
 };
 const getFileUrlFromRemotePath = rawPathName => {
   if (!rawPathName.startsWith('/remote')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "14.17.0",
+  "version": "14.19.0",
   "description": "Test Worker",
   "repository": {
     "type": "git",