@oa-sdk/spec-bundler 0.1.0

package/dist/resolver.d.ts

@@ -0,0 +1,27 @@
+import type { BundleManifest, DeduplicationStrategy, ResolvedFileEntry } from "./types.js";
+/**
+ * Expands braces in glob patterns, e.g. "docs/{a,b}.md" -> ["docs/a.md", "docs/b.md"]
+ */
+export declare function expandBraces(pattern: string): string[];
+/**
+ * Converts a glob pattern to a regular expression.
+ */
+export declare function globToRegex(glob: string): RegExp;
+/**
+ * Matches a relative path against an array of glob exclusion patterns.
+ */
+export declare function matchesAnyPattern(relativePath: string, patterns: string[]): boolean;
+/**
+ * Resolves all target mappings against project root, enforcing deduplication and exclusion filters.
+ */
+export declare function resolveBundleTargets(manifest: BundleManifest, baseDir: string): {
+    entries: Map<string, ResolvedFileEntry>;
+    contentDuplicates: Map<string, string[]>;
+    warnings: string[];
+};
+/**
+ * Recursively crawls relative TypeSpec imports (`import "./file.tsp"`)
+ * for resolved .tsp files, discovering local spec dependencies automatically.
+ */
+export declare function crawlTypeSpecImports(entries: Map<string, ResolvedFileEntry>, baseDir: string, contentDuplicates: Map<string, string[]>, warnings: string[], collisionStrategy: DeduplicationStrategy, excludes?: string[]): void;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.js

@@ -0,0 +1,276 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+/**
+ * Expands braces in glob patterns, e.g. "docs/{a,b}.md" -> ["docs/a.md", "docs/b.md"]
+ */
+export function expandBraces(pattern) {
+    const match = pattern.match(/\{([^{}]+)\}/);
+    if (!match)
+        return [pattern];
+    const before = pattern.slice(0, match.index);
+    const after = pattern.slice((match.index ?? 0) + match[0].length);
+    const parts = match[1].split(",");
+    const results = [];
+    for (const part of parts) {
+        for (const expanded of expandBraces(`${before}${part}${after}`)) {
+            results.push(expanded);
+        }
+    }
+    return results;
+}
+/**
+ * Converts a glob pattern to a regular expression.
+ */
+export function globToRegex(glob) {
+    const normalized = glob.replace(/\\/g, "/");
+    let regexStr = "";
+    let i = 0;
+    while (i < normalized.length) {
+        const c = normalized[i];
+        if (c === "*" && normalized[i + 1] === "*") {
+            if (normalized[i + 2] === "/") {
+                regexStr += "(?:.*/)?";
+                i += 3;
+            }
+            else {
+                regexStr += ".*";
+                i += 2;
+            }
+        }
+        else if (c === "*") {
+            regexStr += "[^/]*";
+            i += 1;
+        }
+        else if (c === "?") {
+            regexStr += "[^/]";
+            i += 1;
+        }
+        else if (["[", "]", "(", ")", "+", ".", "^", "$", "|"].includes(c)) {
+            regexStr += "\\" + c;
+            i += 1;
+        }
+        else {
+            regexStr += c;
+            i += 1;
+        }
+    }
+    return new RegExp(`^${regexStr}$`);
+}
+/**
+ * Matches a relative path against an array of glob exclusion patterns.
+ */
+export function matchesAnyPattern(relativePath, patterns) {
+    const posixPath = relativePath.replace(/\\/g, "/");
+    for (const pattern of patterns) {
+        for (const expanded of expandBraces(pattern)) {
+            const regex = globToRegex(expanded);
+            if (regex.test(posixPath))
+                return true;
+            // If pattern didn't start with **/ or /, also test if it matches the basename
+            if (!expanded.includes("/") && regex.test(path.posix.basename(posixPath))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Recursively scans directory returning POSIX-relative file paths.
+ */
+function scanDirectory(baseDir, currentSubDir = "") {
+    const fullDir = currentSubDir ? path.join(baseDir, currentSubDir) : baseDir;
+    if (!fs.existsSync(fullDir))
+        return [];
+    const files = [];
+    const entries = fs.readdirSync(fullDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const subRel = currentSubDir ? `${currentSubDir}/${entry.name}` : entry.name;
+        const posixRel = subRel.replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+            if (entry.name === ".git" || entry.name === "node_modules")
+                continue;
+            files.push(...scanDirectory(baseDir, posixRel));
+        }
+        else if (entry.isFile()) {
+            files.push(posixRel);
+        }
+    }
+    return files;
+}
+/**
+ * Determines the static base directory of a glob pattern before any wildcards.
+ */
+function getStaticBaseDirectory(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    const firstWildcard = normalized.search(/[*?{[]/);
+    if (firstWildcard === -1) {
+        return path.posix.dirname(normalized);
+    }
+    const prefix = normalized.slice(0, firstWildcard);
+    const lastSlash = prefix.lastIndexOf("/");
+    return lastSlash === -1 ? "." : prefix.slice(0, lastSlash);
+}
+/**
+ * Resolves all target mappings against project root, enforcing deduplication and exclusion filters.
+ */
+export function resolveBundleTargets(manifest, baseDir) {
+    const entries = new Map();
+    const contentDuplicates = new Map(); // sha256 -> destPaths
+    const warnings = [];
+    const collisionStrategy = manifest.deduplicate?.byPath ?? "warn-overwrite";
+    const globalExcludes = manifest.exclude ?? [];
+    for (const target of manifest.targets) {
+        const targetExcludes = [...globalExcludes, ...(target.exclude ?? [])];
+        const expandedSources = expandBraces(target.source);
+        for (const sourcePattern of expandedSources) {
+            const posixSource = sourcePattern.replace(/\\/g, "/");
+            const isDirectFile = !/[*?{[]/.test(posixSource);
+            if (isDirectFile) {
+                const absPath = path.resolve(baseDir, posixSource);
+                if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) {
+                    warnings.push(`Target source file not found: ${posixSource}`);
+                    continue;
+                }
+                const relPath = path.relative(baseDir, absPath).replace(/\\/g, "/");
+                if (matchesAnyPattern(relPath, targetExcludes))
+                    continue;
+                let bundleDest;
+                if (target.dest.endsWith("/")) {
+                    bundleDest = path.posix.join(target.dest, path.posix.basename(relPath));
+                }
+                else {
+                    bundleDest = target.dest.replace(/\\/g, "/");
+                }
+                bundleDest = path.posix.normalize(bundleDest).replace(/^\/+/, "");
+                addFileEntry(absPath, relPath, bundleDest, entries, contentDuplicates, warnings, collisionStrategy);
+            }
+            else {
+                // Glob pattern
+                const staticBase = getStaticBaseDirectory(posixSource);
+                const absScanDir = path.resolve(baseDir, staticBase);
+                const allFiles = scanDirectory(absScanDir);
+                const patternRegex = globToRegex(posixSource);
+                for (const fileRelToStatic of allFiles) {
+                    const fileRelToProject = staticBase === "."
+                        ? fileRelToStatic
+                        : path.posix.join(staticBase, fileRelToStatic);
+                    if (!patternRegex.test(fileRelToProject))
+                        continue;
+                    if (matchesAnyPattern(fileRelToProject, targetExcludes))
+                        continue;
+                    const absPath = path.resolve(baseDir, fileRelToProject);
+                    let bundleDest;
+                    if (target.dest.endsWith("/")) {
+                        // Keep relative path structure starting from staticBase
+                        bundleDest = path.posix.join(target.dest, fileRelToStatic);
+                    }
+                    else {
+                        bundleDest = path.posix.join(target.dest, fileRelToStatic);
+                    }
+                    bundleDest = path.posix.normalize(bundleDest).replace(/^\/+/, "");
+                    addFileEntry(absPath, fileRelToProject, bundleDest, entries, contentDuplicates, warnings, collisionStrategy);
+                }
+            }
+        }
+    }
+    crawlTypeSpecImports(entries, baseDir, contentDuplicates, warnings, collisionStrategy, globalExcludes);
+    return { entries, contentDuplicates, warnings };
+}
+/**
+ * Recursively crawls relative TypeSpec imports (`import "./file.tsp"`)
+ * for resolved .tsp files, discovering local spec dependencies automatically.
+ */
+export function crawlTypeSpecImports(entries, baseDir, contentDuplicates, warnings, collisionStrategy, excludes = []) {
+    const queue = [];
+    for (const entry of entries.values()) {
+        if (entry.bundleDestPath.endsWith(".tsp") ||
+            entry.sourceAbsolutePath.endsWith(".tsp")) {
+            queue.push(entry);
+        }
+    }
+    const visited = new Set();
+    for (const item of queue) {
+        visited.add(path.resolve(item.sourceAbsolutePath));
+    }
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!fs.existsSync(current.sourceAbsolutePath))
+            continue;
+        let content;
+        try {
+            content = fs.readFileSync(current.sourceAbsolutePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const importRegex = /import\s+["'](\.[^"']+)["']/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const rawSpecifier = match[1];
+            const sourceDir = path.dirname(current.sourceAbsolutePath);
+            const candidatePaths = [
+                path.resolve(sourceDir, rawSpecifier),
+                path.resolve(sourceDir, `${rawSpecifier}.tsp`),
+                path.resolve(sourceDir, rawSpecifier, "main.tsp"),
+                path.resolve(sourceDir, rawSpecifier, "index.tsp"),
+            ];
+            let targetAbsPath = null;
+            for (const cand of candidatePaths) {
+                if (fs.existsSync(cand) && fs.statSync(cand).isFile()) {
+                    targetAbsPath = cand;
+                    break;
+                }
+            }
+            if (!targetAbsPath)
+                continue;
+            if (visited.has(targetAbsPath))
+                continue;
+            visited.add(targetAbsPath);
+            const relToProject = path.relative(baseDir, targetAbsPath).replace(/\\/g, "/");
+            if (matchesAnyPattern(relToProject, excludes))
+                continue;
+            const relBetween = path
+                .relative(path.dirname(current.sourceAbsolutePath), targetAbsPath)
+                .replace(/\\/g, "/");
+            let bundleDest = path.posix.normalize(path.posix.join(path.posix.dirname(current.bundleDestPath), relBetween));
+            bundleDest = bundleDest.replace(/^\/+/, "");
+            if (bundleDest.startsWith("../") || bundleDest === "..") {
+                bundleDest = relToProject;
+            }
+            addFileEntry(targetAbsPath, relToProject, bundleDest, entries, contentDuplicates, warnings, collisionStrategy);
+            const newEntry = entries.get(bundleDest);
+            if (newEntry) {
+                queue.push(newEntry);
+            }
+        }
+    }
+}
+function addFileEntry(absPath, relPath, bundleDest, entries, contentDuplicates, warnings, collisionStrategy) {
+    const stat = fs.statSync(absPath);
+    const buffer = fs.readFileSync(absPath);
+    const sha256 = crypto.createHash("sha256").update(buffer).digest("hex");
+    if (entries.has(bundleDest)) {
+        const existing = entries.get(bundleDest);
+        if (collisionStrategy === "error") {
+            throw new Error(`Destination path collision for '${bundleDest}': '${relPath}' conflicts with '${existing.sourceRelativePath}'`);
+        }
+        else if (collisionStrategy === "warn-overwrite") {
+            warnings.push(`Destination collision for '${bundleDest}': overwriting '${existing.sourceRelativePath}' with '${relPath}'`);
+        }
+        // "overwrite" or "warn-overwrite" replaces existing
+    }
+    const entry = {
+        sourceAbsolutePath: absPath,
+        sourceRelativePath: relPath,
+        bundleDestPath: bundleDest,
+        sha256,
+        size: stat.size,
+        mtime: stat.mtimeMs,
+    };
+    entries.set(bundleDest, entry);
+    const existingDups = contentDuplicates.get(sha256) ?? [];
+    existingDups.push(bundleDest);
+    contentDuplicates.set(sha256, existingDups);
+}
+//# sourceMappingURL=resolver.js.map