@workos/oagen 0.21.0 → 0.22.0

package/dist/{diff-CBFCoTCw.mjs → diff-Dobf9PHC.mjs}

@@ -1697,10 +1697,10 @@ async function extractClassEndLines(source, language) {
 	const tree = safeParse(await getParser(language), source);
 	const map = /* @__PURE__ */ new Map();
 	function processClassNode(node) {
-		const nameNode = node.childForFieldName("name");
+		const nameNode = node.childForFieldName("name") ?? node.children.find((c) => c.type === "type_identifier" || c.type === "identifier");
 		if (!nameNode) return;
 		const name = nameNode.text;
-		const body = node.childForFieldName("body");
+		const body = node.childForFieldName("body") ?? node.children.find((c) => c.type === "class_body" || c.type === "body");
 		const endRow = body ? body.endPosition.row : node.endPosition.row;
 		if (source[body ? body.endIndex - 1 : node.endIndex - 1] === "}") map.set(name, { bodyEndLine: endRow });
 		else map.set(name, { bodyEndLine: endRow + 1 });
@@ -2249,9 +2249,16 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		if (!existingLines[i].includes("@oagen-ignore-start")) continue;
 		const startIdx = i;
 		while (i < existingLines.length && !existingLines[i].includes("@oagen-ignore-end")) i++;
+		let anchor = "";
+		for (let a = i + 1; a < existingLines.length; a++) if (existingLines[a].trim()) {
+			anchor = existingLines[a].trimStart();
+			break;
+		}
 		blocks.push({
 			containingClass: findContainingClass(existingLines, startIdx),
-			lines: existingLines.slice(startIdx, i + 1)
+			containingScope: findContainingDescribeScope(existingLines, startIdx),
+			lines: existingLines.slice(startIdx, i + 1),
+			anchor
 		});
 	}
 	if (blocks.length === 0) return generatedContent;
@@ -2261,15 +2268,19 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	const blocksByClass = /* @__PURE__ */ new Map();
 	for (const b of blocks) {
 		if (!blocksByClass.has(b.containingClass)) blocksByClass.set(b.containingClass, []);
-		blocksByClass.get(b.containingClass).push(b.lines);
+		blocksByClass.get(b.containingClass).push({
+			containingScope: b.containingScope,
+			lines: b.lines,
+			anchor: b.anchor
+		});
 	}
 	const replacedClasses = /* @__PURE__ */ new Set();
 	const handledBlockKeys = /* @__PURE__ */ new Set();
 	const replacements = [];
 	for (const [className, classBlocks] of blocksByClass) {
 		let targetClass = className;
-		if (!targetClass) for (const blockLines of classBlocks) {
-			for (const l of blockLines) {
+		if (!targetClass) for (const entry of classBlocks) {
+			for (const l of entry.lines) {
 				const m = l.match(/^(?:export\s+)?class\s+(\w+)/);
 				if (m && classEndLines.has(m[1])) {
 					targetClass = m[1];
@@ -2279,7 +2290,7 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 			if (targetClass) break;
 		}
 		if (!targetClass) continue;
-		if (!classBlocks.some((blockLines) => blockLines.some((l) => {
+		if (!classBlocks.some((entry) => entry.lines.some((l) => {
 			return l.match(/^(?:export\s+)?class\s+(\w+)/)?.[1] === targetClass;
 		}))) continue;
 		const info = classEndLines.get(targetClass);
@@ -2287,9 +2298,9 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		const startLine = findClassDeclarationStart(result, targetClass, info.bodyEndLine);
 		if (startLine < 0) continue;
 		const content = [];
-		for (const block of classBlocks) {
+		for (const entry of classBlocks) {
 			content.push("");
-			content.push(...block);
+			content.push(...entry.lines);
 		}
 		replacements.push({
 			startLine,
@@ -2304,22 +2315,46 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	let effectiveClassEndLines = classEndLines;
 	if (replacedClasses.size > 0) effectiveClassEndLines = await extractClassEndLines(result.join("\n"), language);
 	const insertions = [];
+	let insertionOrder = 0;
 	for (const [className, classBlocks] of blocksByClass) {
 		if (handledBlockKeys.has(className) || replacedClasses.has(className)) continue;
 		const info = className ? effectiveClassEndLines.get(className) : void 0;
-		const insertLine = info ? info.bodyEndLine : result.length;
-		const content = [];
-		for (const block of classBlocks) {
-			content.push("");
-			content.push(...block);
+		for (const entry of classBlocks) {
+			let insertLine;
+			if (entry.anchor && !entry.anchor.includes("@oagen-ignore") && /[a-zA-Z]|^\/\*|^\/\//.test(entry.anchor)) {
+				for (let li = 0; li < result.length; li++) if (result[li].trimStart() === entry.anchor) {
+					insertLine = li;
+					break;
+				}
+			}
+			if (insertLine === void 0) if (info) insertLine = info.bodyEndLine;
+			else {
+				const scopeEndLine = entry.containingScope ? findDescribeScopeEndLine(result, entry.containingScope) : void 0;
+				const blockHasImportsFallback = entry.lines.some((l) => /^\s*(import|from)\s/.test(l));
+				if (scopeEndLine !== void 0) insertLine = scopeEndLine;
+				else if (blockHasImportsFallback || hasTopLevelDeclaration(entry.lines)) {
+					let lastImportLine = 0;
+					for (let li = 0; li < result.length; li++) {
+						const trimmed = result[li].trimStart();
+						if (/^(import|from)\s/.test(trimmed)) lastImportLine = li + 1;
+					}
+					insertLine = lastImportLine;
+				} else insertLine = result.length;
+			}
+			if (entry.lines.some((l) => /^\s*import\s/.test(l))) while (insertLine >= 2 && result[insertLine - 1]?.trim() === "" && /^\s*(import|using|from)\s/.test(result[insertLine - 2] ?? "")) insertLine--;
+			const prevLine = insertLine > 0 ? result[insertLine - 1]?.trimStart() ?? "" : "";
+			const blockContent = /^import\s/.test(prevLine) || /^using\s/.test(prevLine) || /^from\s/.test(prevLine) || insertLine > 0 && prevLine === "" ? [...entry.lines] : ["", ...entry.lines];
+			if ((result[insertLine]?.trimStart() ?? "").startsWith("///")) blockContent.push("");
+			insertions.push({
+				line: insertLine,
+				order: insertionOrder++,
+				content: blockContent
+			});
 		}
-		insertions.push({
-			line: insertLine,
-			content
-		});
 	}
-	insertions.sort((a, b) => b.line - a.line);
+	insertions.sort((a, b) => b.line - a.line || b.order - a.order);
 	for (const ins of insertions) result.splice(ins.line, 0, ...ins.content);
+	removeDuplicateImportsCoveredByIgnoreBlocks(result);
 	return result.join("\n");
 }
 /**
@@ -2347,12 +2382,47 @@ function stripIgnoreRegions(lines) {
 }
 /** Scan backwards from `lineIdx` to find the nearest class declaration name. */
 function findContainingClass(lines, lineIdx) {
+	if (/^\S/.test(lines[lineIdx] ?? "")) return "";
 	for (let j = lineIdx - 1; j >= 0; j--) {
-		const m = lines[j].match(/^\s*(?:export\s+)?class\s+(\w+)/);
+		const m = lines[j].match(/^\s*(?:(?:export|public|private|protected|internal|abstract|sealed|static|partial)\s+)*class\s+(\w+)/);
 		if (m) return m[1];
 	}
 	return "";
 }
+function findContainingDescribeScope(lines, lineIdx) {
+	const markerLine = lines[lineIdx] ?? "";
+	if (/^\S/.test(markerLine)) return "";
+	const markerIndent = leadingSpaces(markerLine);
+	for (let j = lineIdx - 1; j >= 0; j--) {
+		const line = lines[j];
+		if (leadingSpaces(line) >= markerIndent) continue;
+		const match = line.match(/^\s*describe\((['"`])(.+?)\1\s*,/);
+		if (match) return match[2];
+		if (/^\s*(?:export\s+)?class\s+\w+/.test(line)) return "";
+	}
+	return "";
+}
+function findDescribeScopeEndLine(lines, scopeName) {
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].match(/^\s*describe\((['"`])(.+?)\1\s*,/);
+		if (!match || match[2] !== scopeName) continue;
+		let depth = 0;
+		for (let j = i; j < lines.length; j++) {
+			depth += countChar(lines[j], "{");
+			depth -= countChar(lines[j], "}");
+			if (j > i && depth <= 0) return j;
+		}
+	}
+}
+function leadingSpaces(line) {
+	return line.match(/^\s*/)?.[0].length ?? 0;
+}
+function countChar(line, char) {
+	return [...line].filter((c) => c === char).length;
+}
+function hasTopLevelDeclaration(lines) {
+	return lines.some((line) => /^(?:export\s+)?(?:interface|type|class|function|const|let|var|enum)\s+\w+/.test(line.trim()));
+}
 /**
 * Find the start line of a class declaration (including decorators above it)
 * by scanning backwards from `beforeLine`.
@@ -2430,9 +2500,13 @@ function collectTsImports(lines) {
 			const mod = m[4];
 			if (defaultName) out.defaults.set(mod, defaultName);
 			const names = namesRaw.split(",").map((s) => s.trim().replace(/\s+as\s+\w+$/, "")).filter(Boolean);
-			const target = isTypeOnly ? out.typeOnly : out.named;
-			if (!target.has(mod)) target.set(mod, /* @__PURE__ */ new Set());
-			for (const n of names) target.get(mod).add(n);
+			for (const rawName of names) {
+				const isInlineTypeOnly = rawName.startsWith("type ");
+				const name = rawName.replace(/^type\s+/, "");
+				const target = isTypeOnly || isInlineTypeOnly ? out.typeOnly : out.named;
+				if (!target.has(mod)) target.set(mod, /* @__PURE__ */ new Set());
+				target.get(mod).add(name);
+			}
 			continue;
 		}
 		m = normalized.match(/^import\s+(?:type\s+)?(\w+)\s+from\s+['"]([^'"]+)['"]$/);
@@ -2455,12 +2529,99 @@ function collectTsImports(lines) {
 *
 * Mutates `resultLines` in place.
 */
+function filterOutIgnoreRegions(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			continue;
+		}
+		if (skipping) {
+			if (line.includes("@oagen-ignore-end")) skipping = false;
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
+function collectIgnoreRegionUsageText(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			continue;
+		}
+		if (!skipping) continue;
+		if (/^\s*(import|from)\s/.test(line)) continue;
+		out.push(line);
+		if (line.includes("@oagen-ignore-end")) skipping = false;
+	}
+	return out.join("\n");
+}
+function removeDuplicateImportsCoveredByIgnoreBlocks(lines) {
+	const ignoredImports = /* @__PURE__ */ new Set();
+	const importStatements = collectImportStatements(lines);
+	for (const stmt of importStatements) if (stmt.inIgnore) ignoredImports.add(normalizeImportStatement(stmt.lines));
+	if (ignoredImports.size === 0) return;
+	for (const stmt of [...importStatements].reverse()) {
+		if (stmt.inIgnore) continue;
+		if (ignoredImports.has(normalizeImportStatement(stmt.lines))) lines.splice(stmt.start, stmt.end - stmt.start + 1);
+	}
+}
+function collectImportStatements(lines) {
+	const statements = [];
+	let inIgnore = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!inIgnore && line.includes("@oagen-ignore-start")) {
+			inIgnore = true;
+			continue;
+		}
+		if (inIgnore && line.includes("@oagen-ignore-end")) {
+			inIgnore = false;
+			continue;
+		}
+		if (!isImportLine(line)) continue;
+		const start = i;
+		let end = i;
+		const statementLines = [line];
+		if ((line.match(/[({]/g) ?? []).length > (line.match(/[)}]/g) ?? []).length) {
+			while (end + 1 < lines.length) {
+				end++;
+				statementLines.push(lines[end]);
+				if ((lines[end].match(/[)}]/g) ?? []).length > 0 && /\bfrom\b/.test(lines[end])) break;
+			}
+			i = end;
+		}
+		statements.push({
+			start,
+			end,
+			lines: statementLines,
+			inIgnore
+		});
+	}
+	return statements;
+}
+function normalizeImportStatement(lines) {
+	return lines.join("\n").replace(/,\s*}/g, " }").replace(/\s+/g, " ").trim();
+}
+function isImportLine(line) {
+	const trimmed = line.trim();
+	return /^import(\s|$)/.test(trimmed) || /^from\s+/.test(trimmed) || /^use\s+[\w\\]/.test(trimmed) || /^require(_relative)?\s+['"]/.test(trimmed);
+}
+function identifierUsed(source, identifier) {
+	return new RegExp(`\\b${identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(source);
+}
 function spliceExtraImports(existingLines, resultLines) {
+	const existingOutsideIgnore = filterOutIgnoreRegions(existingLines);
+	const ignoreRegionText = collectIgnoreRegionUsageText(existingLines);
 	const isPythonSimpleImport = (l) => /^import\s+\w/.test(l) && !/\sfrom\s/.test(l) && !/[{}]/.test(l);
-	const existingSimple = new Set(existingLines.filter(isPythonSimpleImport).map((l) => l.trim()));
+	const existingSimple = new Set(existingOutsideIgnore.filter(isPythonSimpleImport).map((l) => l.trim()));
 	const generatedSimple = new Set(resultLines.filter(isPythonSimpleImport).map((l) => l.trim()));
 	const extraSimple = [...existingSimple].filter((l) => !generatedSimple.has(l));
-	const existingFrom = collectFromImports(existingLines);
+	const existingFrom = collectFromImports(existingOutsideIgnore);
 	const generatedFrom = collectFromImports(resultLines);
 	const allGeneratedIds = /* @__PURE__ */ new Set();
 	for (const ids of generatedFrom.values()) for (const id of ids) allGeneratedIds.add(id);
@@ -2475,29 +2636,33 @@ function spliceExtraImports(existingLines, resultLines) {
 			if (extra.length > 0) extraFromLines.push(`from ${mod} import ${extra.join(", ")}`);
 		}
 	}
-	const existingTs = collectTsImports(existingLines);
+	const existingTs = collectTsImports(existingOutsideIgnore);
 	const generatedTs = collectTsImports(resultLines);
 	const extraTsLines = [];
 	for (const mod of existingTs.sideEffects) if (!generatedTs.sideEffects.has(mod)) extraTsLines.push(`import '${mod}';`);
 	for (const [mod, name] of existingTs.defaults) {
 		if (generatedTs.defaults.has(mod)) continue;
+		if (!identifierUsed(ignoreRegionText, name)) continue;
 		extraTsLines.push(`import ${name} from '${mod}';`);
 	}
-	for (const [mod, name] of existingTs.namespaces) if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+	for (const [mod, name] of existingTs.namespaces) {
+		if (!identifierUsed(ignoreRegionText, name)) continue;
+		if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+	}
 	for (const [mod, existIds] of existingTs.named) {
 		const genIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
 		const genTypeIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id));
+		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import { ${extra.join(", ")} } from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.typeOnly) {
 		const genIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
 		const genNamedIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id));
+		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import type { ${extra.join(", ")} } from '${mod}';`);
 	}
 	const isPhpUseImport = (l) => /^use\s+[\w\\]+\\[\w\\]*(\s+as\s+\w+)?\s*;?$/.test(l);
-	const existingPhpUse = new Set(existingLines.filter(isPhpUseImport).map((l) => l.trim()));
+	const existingPhpUse = new Set(existingOutsideIgnore.filter(isPhpUseImport).map((l) => l.trim()));
 	const generatedPhpUse = new Set(resultLines.filter(isPhpUseImport).map((l) => l.trim()));
 	const extraPhpUse = [...existingPhpUse].filter((l) => !generatedPhpUse.has(l));
 	const rubyRequireRe = /^(require(?:_relative)?)\s+['"]([^'"]+)['"]\s*$/;
@@ -2512,7 +2677,7 @@ function spliceExtraImports(existingLines, resultLines) {
 	}
 	const seenExistingKeys = /* @__PURE__ */ new Set();
 	const extraRubyRequire = [];
-	for (const l of existingLines) {
+	for (const l of existingOutsideIgnore) {
 		const key = rubyRequireKey(l);
 		if (!key) continue;
 		if (generatedRubyRequireKeys.has(key)) continue;
@@ -2904,6 +3069,7 @@ async function readManifest(dir) {
 }
 /** Write `.oagen-manifest.json` to a directory with sorted paths. */
 async function writeManifest(dir, opts) {
+	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
 	const manifest = {
 		version: MANIFEST_VERSION,
 		language: opts.language,
@@ -2918,10 +3084,16 @@ async function writeManifest(dir, opts) {
 		files: [...new Set(opts.files)].sort(),
 		...opts.operations !== void 0 ? { operations: opts.operations } : {}
 	};
-	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
+	const previous = await readManifest(dir);
+	if (previous && sameManifestExceptGeneratedAt(previous, manifest)) manifest.generatedAt = previous.generatedAt;
 	await fs.mkdir(dir, { recursive: true });
 	await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
+function sameManifestExceptGeneratedAt(a, b) {
+	const { generatedAt: _aGeneratedAt, ...aComparable } = a;
+	const { generatedAt: _bGeneratedAt, ...bComparable } = b;
+	return JSON.stringify(aComparable) === JSON.stringify(bComparable);
+}
 /** Return the set of previous paths no longer present in the current emission. */
 function computeStalePaths(prev, currentPaths) {
 	const current = new Set(currentPaths);
@@ -3540,4 +3712,4 @@ function summarize(changes) {
 //#endregion
 export { MANIFEST_FILENAME as a, treeShakeFiles as c, collectReferencedNames as d, generateAllFiles as f, resolveOperations as h, generate as i, applyFileHeaders as l, deriveMethodName as m, getEmitter as n, integrateGeneratedFiles as o, generateFiles as p, registerEmitter as r, mapFilesForTargetIntegration as s, diffSpecs as t, buildEmitterContext as u };
 
-//# sourceMappingURL=diff-CBFCoTCw.mjs.map
+//# sourceMappingURL=diff-Dobf9PHC.mjs.map