deepline 0.1.123 → 0.1.125

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -125,6 +125,7 @@ export type BundledPlayFileSuccess = {
   sourceFiles: Record<string, string>;
   filePath: string;
   playName: string | null;
+  playDescription: string | null;
   compilerManifest?: PlayCompilerManifest;
   packagedFiles: PlayLocalFileReference[];
   unresolvedFileReferences: PlayLocalFileDiscoveryError[];
@@ -153,6 +154,7 @@ type SourceGraphAnalysis = {
   graphHash: string;
   importPolicy: PlayImportPolicy;
   playName: string | null;
+  playDescription: string | null;
   importedPlayDependencies: ImportedPlayDependency[];
 };
 
@@ -249,6 +251,107 @@ function stripCommentsToSpaces(source: string): string {
     );
 }
 
+function previousSignificantToken(source: string, index: number): string {
+  let cursor = index - 1;
+  while (cursor >= 0 && /\s/.test(source[cursor]!)) cursor -= 1;
+  if (cursor < 0) return '';
+  const char = source[cursor]!;
+  if (!/[A-Za-z0-9_$]/.test(char)) return char;
+  let start = cursor;
+  while (start > 0 && /[A-Za-z0-9_$]/.test(source[start - 1]!)) start -= 1;
+  return source.slice(start, cursor + 1);
+}
+
+function canStartRegexLiteral(source: string, slashIndex: number): boolean {
+  const token = previousSignificantToken(source, slashIndex);
+  return (
+    !token ||
+    token === 'return' ||
+    token === 'throw' ||
+    token === 'case' ||
+    token === 'delete' ||
+    token === 'typeof' ||
+    token === 'void' ||
+    token === 'instanceof' ||
+    /^(?:[({[=,:;!&|?+\-*~^<>%]|\.\.\.)$/.test(token)
+  );
+}
+
+function maskSourceForStructure(source: string): string {
+  const chars = source.split('');
+  const maskRange = (start: number, end: number) => {
+    for (let cursor = start; cursor < end; cursor += 1) {
+      if (chars[cursor] !== '\n') chars[cursor] = ' ';
+    }
+  };
+
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index]!;
+    const next = source[index + 1];
+    if (char === '/' && next === '/') {
+      let end = index + 2;
+      while (end < source.length && source[end] !== '\n') end += 1;
+      maskRange(index, end);
+      index = end;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      const close = source.indexOf('*/', index + 2);
+      const end = close >= 0 ? close + 2 : source.length;
+      maskRange(index, end);
+      index = end - 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      const quote = char;
+      let end = index + 1;
+      let escaped = false;
+      while (end < source.length) {
+        const current = source[end]!;
+        if (escaped) {
+          escaped = false;
+        } else if (current === '\\') {
+          escaped = true;
+        } else if (current === quote) {
+          end += 1;
+          break;
+        }
+        end += 1;
+      }
+      maskRange(index, end);
+      index = end - 1;
+      continue;
+    }
+    if (char === '/' && canStartRegexLiteral(source, index)) {
+      let end = index + 1;
+      let escaped = false;
+      let inCharacterClass = false;
+      while (end < source.length) {
+        const current = source[end]!;
+        if (escaped) {
+          escaped = false;
+        } else if (current === '\\') {
+          escaped = true;
+        } else if (current === '[') {
+          inCharacterClass = true;
+        } else if (current === ']') {
+          inCharacterClass = false;
+        } else if (current === '/' && !inCharacterClass) {
+          end += 1;
+          while (/[A-Za-z]/.test(source[end] ?? '')) end += 1;
+          break;
+        } else if (current === '\n') {
+          break;
+        }
+        end += 1;
+      }
+      maskRange(index, end);
+      index = end - 1;
+    }
+  }
+  return chars.join('');
+}
+
 function lineAndColumnAt(
   source: string,
   index: number,
@@ -339,11 +442,15 @@ function unquoteStringLiteral(literal: string): string | null {
   const trimmed = literal.trim();
   const quote = trimmed[0];
   if (
-    (quote !== '"' && quote !== "'") ||
+    (quote !== '"' && quote !== "'" && quote !== '`') ||
     trimmed[trimmed.length - 1] !== quote
   ) {
     return null;
   }
+  if (quote === '`') {
+    const value = trimmed.slice(1, -1);
+    return value.includes('${') ? null : value;
+  }
   try {
     return JSON.parse(
       quote === '"'
@@ -356,25 +463,10 @@ function unquoteStringLiteral(literal: string): string | null {
 }
 
 function findMatchingBrace(source: string, openIndex: number): number {
+  const structuralSource = maskSourceForStructure(source);
   let depth = 0;
-  let quote: string | null = null;
-  let escaped = false;
-  for (let index = openIndex; index < source.length; index += 1) {
-    const char = source[index]!;
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === '\\') {
-        escaped = true;
-      } else if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'" || char === '`') {
-      quote = char;
-      continue;
-    }
+  for (let index = openIndex; index < structuralSource.length; index += 1) {
+    const char = structuralSource[index]!;
     if (char === '{') depth += 1;
     if (char === '}') {
       depth -= 1;
@@ -384,39 +476,264 @@ function findMatchingBrace(source: string, openIndex: number): number {
   return -1;
 }
 
+function findMatchingParen(source: string, openIndex: number): number {
+  const structuralSource = maskSourceForStructure(source);
+  let depth = 0;
+  for (let index = openIndex; index < structuralSource.length; index += 1) {
+    const char = structuralSource[index]!;
+    if (char === '(') depth += 1;
+    if (char === ')') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function splitTopLevelArguments(source: string): string[] {
+  const args: string[] = [];
+  const structuralSource = maskSourceForStructure(source);
+  let start = 0;
+  let parenDepth = 0;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  for (let index = 0; index < structuralSource.length; index += 1) {
+    const char = structuralSource[index]!;
+    if (char === '(') parenDepth += 1;
+    if (char === ')') parenDepth -= 1;
+    if (char === '{') braceDepth += 1;
+    if (char === '}') braceDepth -= 1;
+    if (char === '[') bracketDepth += 1;
+    if (char === ']') bracketDepth -= 1;
+    if (
+      char === ',' &&
+      parenDepth === 0 &&
+      braceDepth === 0 &&
+      bracketDepth === 0
+    ) {
+      args.push(source.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  const finalArg = source.slice(start).trim();
+  if (finalArg) args.push(finalArg);
+  return args;
+}
+
+function extractStringProperty(
+  objectSource: string,
+  propertyName: string,
+): string | null {
+  for (const entry of splitTopLevelArguments(objectSource)) {
+    const structuralEntry = stripCommentsToSpaces(entry).trim();
+    const match = structuralEntry.match(
+      new RegExp(
+        `^(?:${propertyName}|['"]${propertyName}['"])\\s*:\\s*((['"\`])(?:\\\\.|(?!\\2)[\\s\\S])*\\2)\\s*$`,
+      ),
+    );
+    const value = match?.[1] ? unquoteStringLiteral(match[1]) : null;
+    if (value?.trim()) return value.trim();
+  }
+  return null;
+}
+
 export function extractDefinedPlayName(sourceCode: string): string | null {
-  const source = stripCommentsToSpaces(sourceCode);
+  for (const call of findDefinePlayCalls(sourceCode)) {
+    const name = nameFromDefinePlayArguments(sourceCode, call.arguments);
+    if (name) return name;
+  }
+  return null;
+}
+
+export function extractDefinedPlayNameForExport(
+  sourceCode: string,
+  exportName: string,
+): string | null {
+  return findDefinedPlayMetadata(
+    sourceCode,
+    exportName,
+    nameFromDefinePlayArguments,
+  );
+}
+
+export function extractDefinedPlayDescription(
+  sourceCode: string,
+): string | null {
+  return findDefinedPlayMetadata(
+    sourceCode,
+    null,
+    descriptionFromDefinePlayArguments,
+  );
+}
+
+export function extractDefinedPlayDescriptionForExport(
+  sourceCode: string,
+  exportName: string,
+): string | null {
+  return findDefinedPlayMetadata(
+    sourceCode,
+    exportName,
+    descriptionFromDefinePlayArguments,
+  );
+}
+
+function findDefinedPlayMetadata(
+  sourceCode: string,
+  exportName: string | null,
+  getMetadata: (sourceCode: string, args: string[]) => string | null,
+): string | null {
+  const resolvedExportName =
+    exportName === 'default'
+      ? (findDefaultExportIdentifier(sourceCode) ?? exportName)
+      : exportName;
+  for (const call of findDefinePlayCalls(sourceCode)) {
+    if (resolvedExportName && call.exportName !== resolvedExportName) {
+      continue;
+    }
+    const value = getMetadata(sourceCode, call.arguments);
+    if (value) return value;
+  }
+  return null;
+}
+
+type DefinePlayCallMetadata = {
+  arguments: string[];
+  exportName: string | null;
+};
+
+function findDefinePlayCalls(sourceCode: string): DefinePlayCallMetadata[] {
+  const source = maskSourceForStructure(sourceCode);
   const callPattern =
     /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
+  const calls: DefinePlayCallMetadata[] = [];
   for (const match of source.matchAll(callPattern)) {
-    const openParen = match.index! + match[0].length - 1;
-    const firstArgStart = openParen + 1;
-    const firstNonSpace = source.slice(firstArgStart).search(/\S/);
-    if (firstNonSpace < 0) continue;
-    const argIndex = firstArgStart + firstNonSpace;
-    const quote = source[argIndex];
-    if (quote === '"' || quote === "'") {
-      const literalMatch = source
-        .slice(argIndex)
-        .match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
-      const value = literalMatch ? unquoteStringLiteral(literalMatch[0]) : null;
-      if (value?.trim()) return value.trim();
-    }
-    if (quote === '{') {
-      const closeBrace = findMatchingBrace(source, argIndex);
-      if (closeBrace < 0) continue;
-      const objectSource = source.slice(argIndex + 1, closeBrace);
-      const idMatch = objectSource.match(
-        /(?:^|[,{\s])(?:id|['"]id['"])\s*:\s*(['"])([\s\S]*?)\1/,
-      );
-      if (idMatch?.[2]?.trim()) {
-        return idMatch[2].trim();
-      }
-    }
+    const callStart = match.index!;
+    const openParen = callStart + match[0].length - 1;
+    const closeParen = findMatchingParen(sourceCode, openParen);
+    if (closeParen < 0) continue;
+    calls.push({
+      arguments: splitTopLevelArguments(
+        sourceCode.slice(openParen + 1, closeParen),
+      ),
+      exportName: exportNameForDefinePlayCall(sourceCode, callStart),
+    });
+  }
+  return calls;
+}
+
+function findDefaultExportIdentifier(sourceCode: string): string | null {
+  const source = maskSourceForStructure(sourceCode);
+  const pattern = /\bexport\s+default\s+([A-Za-z_$][\w$]*)/g;
+  for (const match of source.matchAll(pattern)) {
+    const afterIdentifier = match.index! + match[0].length;
+    const nextNonSpace = source.slice(afterIdentifier).match(/\S/)?.[0] ?? '';
+    if (nextNonSpace !== '(') return match[1] ?? null;
   }
   return null;
 }
 
+function nameFromDefinePlayArguments(
+  sourceCode: string,
+  args: string[],
+): string | null {
+  const firstArg = args[0]?.trim();
+  if (!firstArg) return null;
+  if (/^(['"`])/.test(firstArg))
+    return unquoteStringLiteral(firstArg)?.trim() ?? null;
+  const objectSource = objectLiteralBodyFromArgument(sourceCode, firstArg);
+  if (objectSource) {
+    return extractStringProperty(objectSource, 'id');
+  }
+  return null;
+}
+
+function descriptionFromDefinePlayArguments(
+  sourceCode: string,
+  args: string[],
+): string | null {
+  const firstArgDescription = descriptionFromDefinePlayArgument(
+    sourceCode,
+    args[0],
+  );
+  if (firstArgDescription) return firstArgDescription;
+  for (let index = args.length - 1; index >= 2; index -= 1) {
+    const description = descriptionFromDefinePlayArgument(
+      sourceCode,
+      args[index],
+    );
+    if (description) return description;
+  }
+  return null;
+}
+
+function descriptionFromDefinePlayArgument(
+  sourceCode: string,
+  arg: string | undefined,
+): string | null {
+  const trimmed = arg?.trim();
+  if (!trimmed) return null;
+  const objectSource = objectLiteralBodyFromArgument(sourceCode, trimmed);
+  if (!objectSource) return null;
+  return extractStringProperty(objectSource, 'description');
+}
+
+function objectLiteralBodyFromArgument(
+  sourceCode: string,
+  arg: string,
+): string | null {
+  const trimmed = arg.trim();
+  if (trimmed.startsWith('{')) {
+    const closeBrace = findMatchingBrace(trimmed, 0);
+    return closeBrace >= 0 ? trimmed.slice(1, closeBrace) : trimmed.slice(1);
+  }
+  if (!/^[A-Za-z_$][\w$]*$/.test(trimmed)) return null;
+  return findTopLevelObjectLiteralBody(sourceCode, trimmed);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function findTopLevelObjectLiteralBody(
+  sourceCode: string,
+  identifier: string,
+): string | null {
+  const source = maskSourceForStructure(sourceCode);
+  const pattern = new RegExp(
+    `(?:^|[;\\n])\\s*(?:export\\s+)?(?:const|let|var)\\s+${escapeRegExp(
+      identifier,
+    )}(?:\\s*:[^=;]+)?\\s*=\\s*{`,
+    'g',
+  );
+  for (const match of source.matchAll(pattern)) {
+    const openBrace = source.indexOf('{', match.index);
+    if (openBrace < 0) continue;
+    const closeBrace = findMatchingBrace(sourceCode, openBrace);
+    if (closeBrace < 0) continue;
+    return sourceCode.slice(openBrace + 1, closeBrace);
+  }
+  return null;
+}
+
+function exportNameForDefinePlayCall(
+  sourceCode: string,
+  callStart: number,
+): string | null {
+  const source = maskSourceForStructure(sourceCode);
+  const structuralPrefix = source
+    .slice(Math.max(0, callStart - 500), callStart)
+    .trimEnd();
+  if (/\bexport\s+default\s*$/.test(structuralPrefix)) return 'default';
+  const variableMatch = structuralPrefix.match(
+    /\bexport\s+(?:declare\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:[^=;]+)?\s*=\s*$/,
+  );
+  if (variableMatch?.[1]) return variableMatch[1];
+  const localVariableMatch = structuralPrefix.match(
+    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:[^=;]+)?\s*=\s*$/,
+  );
+  return localVariableMatch?.[1] ?? null;
+}
+
 function canonicalizeRootPlayNameForWorkersRuntimeHash(
   sourceCode: string,
 ): string {
@@ -1016,6 +1333,7 @@ function resolvePackageImport(
 async function analyzeSourceGraph(
   entryFile: string,
   adapter: PlayBundlingAdapter,
+  exportName: string,
 ): Promise<SourceGraphAnalysis> {
   const absoluteEntryFile = await normalizeLocalPath(entryFile);
   const workspace = createPlayWorkspace(absoluteEntryFile);
@@ -1139,7 +1457,14 @@ async function analyzeSourceGraph(
         .sort((left, right) => left.filePath.localeCompare(right.filePath)),
     }),
   );
-  const playName = extractDefinedPlayName(sourceCode);
+  const playName =
+    extractDefinedPlayNameForExport(sourceCode, exportName) ??
+    (exportName === 'default' ? extractDefinedPlayName(sourceCode) : null);
+  const playDescription =
+    extractDefinedPlayDescriptionForExport(sourceCode, exportName) ??
+    (exportName === 'default'
+      ? extractDefinedPlayDescription(sourceCode)
+      : null);
 
   return {
     sourceCode,
@@ -1158,6 +1483,7 @@ async function analyzeSourceGraph(
         .sort((left, right) => left.name.localeCompare(right.name)),
     },
     playName,
+    playDescription,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath),
     ),
@@ -1588,7 +1914,11 @@ export async function bundlePlayFile(
   adapter.warnAboutNonDevelopmentBundling?.(absolutePath);
 
   try {
-    const analysis = await analyzeSourceGraph(absolutePath, adapter);
+    const analysis = await analyzeSourceGraph(
+      absolutePath,
+      adapter,
+      exportName,
+    );
     analysis.graphHash =
       target === PLAY_ARTIFACT_KINDS.esmWorkers
         ? buildWorkersRuntimeGraphHash({
@@ -1677,6 +2007,7 @@ export async function bundlePlayFile(
         sourceFiles: analysis.sourceFiles,
         filePath: absolutePath,
         playName: analysis.playName,
+        playDescription: analysis.playDescription,
         packagedFiles: discoveredFiles.files,
         unresolvedFileReferences: discoveredFiles.unresolved,
         importedPlayDependencies: analysis.importedPlayDependencies,
@@ -1749,6 +2080,7 @@ export async function bundlePlayFile(
       sourceFiles: analysis.sourceFiles,
       filePath: absolutePath,
       playName: analysis.playName,
+      playDescription: analysis.playDescription,
       packagedFiles: discoveredFiles.files,
       unresolvedFileReferences: discoveredFiles.unresolved,
       importedPlayDependencies: analysis.importedPlayDependencies,