deepline 0.1.123 → 0.1.124

package/dist/plays/bundle-play-file.mjs

@@ -211,6 +211,93 @@ function stripCommentsToSpaces(source) {
     (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
   );
 }
+function previousSignificantToken(source, index) {
+  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, slashIndex) {
+  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) {
+  const chars = source.split("");
+  const maskRange = (start, end) => {
+    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, index) {
   const prefix = source.slice(0, index);
   const lines = prefix.split("\n");
@@ -280,9 +367,13 @@ function findSourceImportReferences(sourceCode) {
 function unquoteStringLiteral(literal) {
   const trimmed = literal.trim();
   const quote = trimmed[0];
-  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+  if (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 === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
@@ -292,25 +383,10 @@ function unquoteStringLiteral(literal) {
   }
 }
 function findMatchingBrace(source, openIndex) {
+  const structuralSource = maskSourceForStructure(source);
   let depth = 0;
-  let quote = 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;
@@ -319,35 +395,198 @@ function findMatchingBrace(source, openIndex) {
   }
   return -1;
 }
+function findMatchingParen(source, openIndex) {
+  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) {
+  const args = [];
+  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, propertyName) {
+  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;
+}
 function extractDefinedPlayName(sourceCode) {
-  const source = stripCommentsToSpaces(sourceCode);
+  for (const call of findDefinePlayCalls(sourceCode)) {
+    const name = nameFromDefinePlayArguments(sourceCode, call.arguments);
+    if (name) return name;
+  }
+  return null;
+}
+function extractDefinedPlayNameForExport(sourceCode, exportName) {
+  return findDefinedPlayMetadata(
+    sourceCode,
+    exportName,
+    nameFromDefinePlayArguments
+  );
+}
+function extractDefinedPlayDescription(sourceCode) {
+  return findDefinedPlayMetadata(
+    sourceCode,
+    null,
+    descriptionFromDefinePlayArguments
+  );
+}
+function extractDefinedPlayDescriptionForExport(sourceCode, exportName) {
+  return findDefinedPlayMetadata(
+    sourceCode,
+    exportName,
+    descriptionFromDefinePlayArguments
+  );
+}
+function findDefinedPlayMetadata(sourceCode, exportName, getMetadata) {
+  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;
+}
+function findDefinePlayCalls(sourceCode) {
+  const source = maskSourceForStructure(sourceCode);
   const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
+  const calls = [];
   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) {
+  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, args) {
+  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, args) {
+  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, arg) {
+  const trimmed = arg?.trim();
+  if (!trimmed) return null;
+  const objectSource = objectLiteralBodyFromArgument(sourceCode, trimmed);
+  if (!objectSource) return null;
+  return extractStringProperty(objectSource, "description");
+}
+function objectLiteralBodyFromArgument(sourceCode, arg) {
+  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) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findTopLevelObjectLiteralBody(sourceCode, identifier) {
+  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, callStart) {
+  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) {
   const source = stripCommentsToSpaces(sourceCode);
   const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
@@ -748,7 +987,7 @@ function resolvePackageImport(specifier, fromFile, adapter) {
     version: readPackageVersionFromPackageJson(packageJsonPath, packageName)
   };
 }
-async function analyzeSourceGraph(entryFile, adapter) {
+async function analyzeSourceGraph(entryFile, adapter, exportName) {
   const absoluteEntryFile = await normalizeLocalPath(entryFile);
   const workspace = createPlayWorkspace(absoluteEntryFile);
   const localFiles = /* @__PURE__ */ new Map();
@@ -849,7 +1088,8 @@ async function analyzeSourceGraph(entryFile, adapter) {
       })).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,
     sourceFiles: Object.fromEntries(
@@ -865,6 +1105,7 @@ async function analyzeSourceGraph(entryFile, adapter) {
       packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name))
     },
     playName,
+    playDescription,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath)
     )
@@ -1144,7 +1385,11 @@ async function bundlePlayFile(filePath, options) {
   const absolutePath = await normalizeLocalPath(filePath);
   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({
       analysis,
       entryFile: absolutePath,
@@ -1216,6 +1461,7 @@ workers-harness:${harnessFingerprint}`
         sourceFiles: analysis.sourceFiles,
         filePath: absolutePath,
         playName: analysis.playName,
+        playDescription: analysis.playDescription,
         packagedFiles: discoveredFiles.files,
         unresolvedFileReferences: discoveredFiles.unresolved,
         importedPlayDependencies: analysis.importedPlayDependencies
@@ -1282,6 +1528,7 @@ workers-harness:${harnessFingerprint}`
       sourceFiles: analysis.sourceFiles,
       filePath: absolutePath,
       playName: analysis.playName,
+      playDescription: analysis.playDescription,
       packagedFiles: discoveredFiles.files,
       unresolvedFileReferences: discoveredFiles.unresolved,
       importedPlayDependencies: analysis.importedPlayDependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.123",
+  "version": "0.1.124",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {