@vercel/build-utils 4.2.1 → 5.0.1

package/dist/detect-file-system-api.d.ts

@@ -1,34 +0,0 @@
-import type { Builder, BuilderFunctions, PackageJson, ProjectSettings } from './types';
-interface Metadata {
-    plugins: string[];
-    hasDotOutput: boolean;
-    hasMiddleware: boolean;
-}
-/**
- * If the Deployment can be built with the new File System API,
- * return the new Builder. Otherwise an "Exclusion Condition"
- * was hit so return `null` builder with a `reason` for exclusion.
- */
-export declare function detectFileSystemAPI({ files, projectSettings, builders, vercelConfig, pkg, tag, enableFlag, }: {
-    files: {
-        [relPath: string]: any;
-    };
-    projectSettings: ProjectSettings;
-    builders: Builder[];
-    vercelConfig: {
-        builds?: Builder[];
-        functions?: BuilderFunctions;
-    } | null | undefined;
-    pkg: PackageJson | null | undefined;
-    tag: string | undefined;
-    enableFlag: boolean | undefined;
-}): Promise<{
-    metadata: Metadata;
-    fsApiBuilder: Builder;
-    reason: null;
-} | {
-    metadata: Metadata;
-    fsApiBuilder: null;
-    reason: string;
-}>;
-export {};

package/dist/detect-file-system-api.js

@@ -1,173 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFileSystemAPI = void 0;
-const semver_1 = __importDefault(require("semver"));
-const _1 = require("./");
-const enableFileSystemApiFrameworks = new Set(['solidstart']);
-/**
- * If the Deployment can be built with the new File System API,
- * return the new Builder. Otherwise an "Exclusion Condition"
- * was hit so return `null` builder with a `reason` for exclusion.
- */
-async function detectFileSystemAPI({ files, projectSettings, builders, vercelConfig, pkg, tag, enableFlag = false, }) {
-    const framework = projectSettings.framework || '';
-    const deps = Object.assign({}, pkg?.dependencies, pkg?.devDependencies);
-    const plugins = Object.keys(deps).filter(dep => dep.startsWith('vercel-plugin-'));
-    const hasDotOutput = Object.keys(files).some(file => file.startsWith('.output/'));
-    const hasMiddleware = Boolean(files['_middleware.js'] || files['_middleware.ts']);
-    const metadata = {
-        plugins,
-        hasDotOutput,
-        hasMiddleware,
-    };
-    const isEnabled = enableFlag ||
-        hasMiddleware ||
-        hasDotOutput ||
-        enableFileSystemApiFrameworks.has(framework);
-    if (!isEnabled) {
-        return { metadata, fsApiBuilder: null, reason: 'Flag not enabled.' };
-    }
-    if (vercelConfig?.builds && vercelConfig.builds.length > 0) {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: 'Detected `builds` in vercel.json. Please remove it in favor of CLI plugins.',
-        };
-    }
-    if (Object.values(vercelConfig?.functions || {}).some(fn => !!fn.runtime)) {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: 'Detected `functions.runtime` in vercel.json. Please remove it in favor of CLI plugins.',
-        };
-    }
-    if (process.env.HUGO_VERSION) {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: 'Detected `HUGO_VERSION` environment variable. Please remove it.',
-        };
-    }
-    if (process.env.ZOLA_VERSION) {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: 'Detected `ZOLA_VERSION` environment variable. Please remove it.',
-        };
-    }
-    if (process.env.GUTENBERG_VERSION) {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: 'Detected `GUTENBERG_VERSION` environment variable. Please remove it.',
-        };
-    }
-    const invalidBuilder = builders.find(({ use }) => {
-        const valid = _1.isOfficialRuntime('go', use) ||
-            _1.isOfficialRuntime('python', use) ||
-            _1.isOfficialRuntime('ruby', use) ||
-            _1.isOfficialRuntime('node', use) ||
-            _1.isOfficialRuntime('next', use) ||
-            _1.isOfficialRuntime('static', use) ||
-            _1.isOfficialRuntime('static-build', use);
-        return !valid;
-    });
-    if (invalidBuilder) {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: `Detected \`${invalidBuilder.use}\` in vercel.json. Please remove it in favor of CLI plugins.`,
-        };
-    }
-    for (const lang of ['go', 'python', 'ruby']) {
-        for (const { use } of builders) {
-            const plugin = 'vercel-plugin-' + lang;
-            if (_1.isOfficialRuntime(lang, use) && !deps[plugin]) {
-                return {
-                    metadata,
-                    fsApiBuilder: null,
-                    reason: `Detected \`${lang}\` Serverless Function usage without plugin \`${plugin}\`. Please run \`npm i ${plugin}\`.`,
-                };
-            }
-        }
-    }
-    if (framework === 'nuxtjs' ||
-        framework === 'sveltekit' ||
-        framework === 'redwoodjs') {
-        return {
-            metadata,
-            fsApiBuilder: null,
-            reason: `Detected framework \`${framework}\` that only supports legacy File System API. Please contact the framework author.`,
-        };
-    }
-    if (framework === 'nextjs' && !hasDotOutput) {
-        // Use the old pipeline if a custom output directory was specified for Next.js
-        // because `vercel build` cannot ensure that the directory will be in the same
-        // location as `.output`, which can break imports (not just nft.json files).
-        if (projectSettings?.outputDirectory) {
-            return {
-                metadata,
-                fsApiBuilder: null,
-                reason: `Detected Next.js with Output Directory \`${projectSettings.outputDirectory}\` override. Please change it back to the default.`,
-            };
-        }
-        const nextVersion = deps['next'];
-        if (!nextVersion) {
-            return {
-                metadata,
-                fsApiBuilder: null,
-                reason: `Detected Next.js in Project Settings but missing \`next\` package.json dependencies. Please run \`npm i next\`.`,
-            };
-        }
-        // TODO: Read version from lockfile instead of package.json
-        if (nextVersion !== 'latest' && nextVersion !== 'canary') {
-            const fixedVersion = semver_1.default.valid(semver_1.default.coerce(nextVersion) || '');
-            if (!fixedVersion || !semver_1.default.gte(fixedVersion, '12.0.0')) {
-                return {
-                    metadata,
-                    fsApiBuilder: null,
-                    reason: `Detected legacy Next.js version "${nextVersion}" in package.json. Please run \`npm i next@latest\` to upgrade.`,
-                };
-            }
-        }
-    }
-    if (!hasDotOutput) {
-        // TODO: Read version from lockfile instead of package.json
-        const vercelCliVersion = deps['vercel'];
-        if (vercelCliVersion &&
-            vercelCliVersion !== 'latest' &&
-            vercelCliVersion !== 'canary') {
-            const fixedVersion = semver_1.default.valid(semver_1.default.coerce(vercelCliVersion) || '');
-            // TODO: we might want to use '24.0.0' once its released
-            if (!fixedVersion || !semver_1.default.gte(fixedVersion, '23.1.3-canary.68')) {
-                return {
-                    metadata,
-                    fsApiBuilder: null,
-                    reason: `Detected legacy Vercel CLI version "${vercelCliVersion}" in package.json. Please run \`npm i vercel@latest\` to upgrade.`,
-                };
-            }
-        }
-    }
-    const frontendBuilder = builders.find(({ use }) => _1.isOfficialRuntime('next', use) ||
-        _1.isOfficialRuntime('static', use) ||
-        _1.isOfficialRuntime('static-build', use));
-    const config = frontendBuilder?.config || {};
-    const withTag = tag ? `@${tag}` : '';
-    const fsApiBuilder = {
-        use: `@vercelruntimes/file-system-api${withTag}`,
-        src: '**',
-        config: {
-            ...config,
-            fileSystemAPI: true,
-            framework: config.framework || framework || null,
-            projectSettings,
-            hasMiddleware,
-            hasDotOutput,
-        },
-    };
-    return { metadata, fsApiBuilder, reason: null };
-}
-exports.detectFileSystemAPI = detectFileSystemAPI;

package/dist/detect-framework.d.ts

@@ -1,12 +0,0 @@
-import { Framework } from '@vercel/frameworks';
-import { DetectorFilesystem } from './detectors/filesystem';
-interface BaseFramework {
-    slug: Framework['slug'];
-    detectors?: Framework['detectors'];
-}
-export interface DetectFrameworkOptions {
-    fs: DetectorFilesystem;
-    frameworkList: readonly BaseFramework[];
-}
-export declare function detectFramework({ fs, frameworkList, }: DetectFrameworkOptions): Promise<string | null>;
-export {};

package/dist/detect-framework.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFramework = void 0;
-async function matches(fs, framework) {
-    const { detectors } = framework;
-    if (!detectors) {
-        return false;
-    }
-    const { every, some } = detectors;
-    if (every !== undefined && !Array.isArray(every)) {
-        return false;
-    }
-    if (some !== undefined && !Array.isArray(some)) {
-        return false;
-    }
-    const check = async ({ path, matchContent }) => {
-        if (!path) {
-            return false;
-        }
-        if ((await fs.hasPath(path)) === false) {
-            return false;
-        }
-        if (matchContent) {
-            if ((await fs.isFile(path)) === false) {
-                return false;
-            }
-            const regex = new RegExp(matchContent, 'gm');
-            const content = await fs.readFile(path);
-            if (!regex.test(content.toString())) {
-                return false;
-            }
-        }
-        return true;
-    };
-    const result = [];
-    if (every) {
-        const everyResult = await Promise.all(every.map(item => check(item)));
-        result.push(...everyResult);
-    }
-    if (some) {
-        let someResult = false;
-        for (const item of some) {
-            if (await check(item)) {
-                someResult = true;
-                break;
-            }
-        }
-        result.push(someResult);
-    }
-    return result.every(res => res === true);
-}
-async function detectFramework({ fs, frameworkList, }) {
-    for (const framework of frameworkList) {
-        if (await matches(fs, framework)) {
-            return framework.slug;
-        }
-    }
-    return null;
-}
-exports.detectFramework = detectFramework;

package/dist/detectors/filesystem.d.ts

@@ -1,54 +0,0 @@
-/// <reference types="node" />
-export interface Stat {
-    name: string;
-    path: string;
-    type: 'file' | 'dir';
-}
-/**
- * `DetectorFilesystem` is an abstract class that represents a virtual filesystem
- * to perform read-only operations on in order to detect which framework is being
- * used.
- *
- * Its abstract methods must be implemented by a subclass that perform the actual
- * FS operations. Example subclasses could be implemented as:
- *
- *  - Local filesystem, which proxies the FS operations to the equivalent `fs`
- *    module functions.
- *  - HTTP filesystem, which implements the FS operations over an HTTP server
- *    and does not require a local copy of the files.
- *  - `Files` filesystem, which operates on a virtual `Files` object (i.e. from
- *    the `glob()` function) which could include `FileFsRef`, `FileBlob`, etc.
- *
- * This base class implements various helper functions for common tasks (i.e.
- * read and parse a JSON file). It also includes caching for all FS operations
- * so that multiple detector functions de-dup read operations on the same file
- * to reduce network/filesystem overhead.
- *
- * **NOTE:** It's important that all instance methods in this base class are
- * bound to `this` so that the `fs` object may be destructured in the detector
- * functions. The easiest way to do this is to use the `=` syntax when defining
- * methods in this class definition.
- */
-export declare abstract class DetectorFilesystem {
-    protected abstract _hasPath(name: string): Promise<boolean>;
-    protected abstract _readFile(name: string): Promise<Buffer>;
-    protected abstract _isFile(name: string): Promise<boolean>;
-    protected abstract _readdir(name: string): Promise<Stat[]>;
-    protected abstract _chdir(name: string): DetectorFilesystem;
-    private pathCache;
-    private fileCache;
-    private readFileCache;
-    private readdirCache;
-    constructor();
-    hasPath: (path: string) => Promise<boolean>;
-    isFile: (name: string) => Promise<boolean>;
-    readFile: (name: string) => Promise<Buffer>;
-    /**
-     * Returns a list of Stat objects from the current working directory.
-     */
-    readdir: (name: string) => Promise<Stat[]>;
-    /**
-     * Changes the current directory to the specified path and returns a new instance of DetectorFilesystem.
-     */
-    chdir: (name: string) => DetectorFilesystem;
-}

package/dist/detectors/filesystem.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DetectorFilesystem = void 0;
-/**
- * `DetectorFilesystem` is an abstract class that represents a virtual filesystem
- * to perform read-only operations on in order to detect which framework is being
- * used.
- *
- * Its abstract methods must be implemented by a subclass that perform the actual
- * FS operations. Example subclasses could be implemented as:
- *
- *  - Local filesystem, which proxies the FS operations to the equivalent `fs`
- *    module functions.
- *  - HTTP filesystem, which implements the FS operations over an HTTP server
- *    and does not require a local copy of the files.
- *  - `Files` filesystem, which operates on a virtual `Files` object (i.e. from
- *    the `glob()` function) which could include `FileFsRef`, `FileBlob`, etc.
- *
- * This base class implements various helper functions for common tasks (i.e.
- * read and parse a JSON file). It also includes caching for all FS operations
- * so that multiple detector functions de-dup read operations on the same file
- * to reduce network/filesystem overhead.
- *
- * **NOTE:** It's important that all instance methods in this base class are
- * bound to `this` so that the `fs` object may be destructured in the detector
- * functions. The easiest way to do this is to use the `=` syntax when defining
- * methods in this class definition.
- */
-class DetectorFilesystem {
-    constructor() {
-        this.hasPath = async (path) => {
-            let p = this.pathCache.get(path);
-            if (!p) {
-                p = this._hasPath(path);
-                this.pathCache.set(path, p);
-            }
-            return p;
-        };
-        this.isFile = async (name) => {
-            let p = this.fileCache.get(name);
-            if (!p) {
-                p = this._isFile(name);
-                this.fileCache.set(name, p);
-            }
-            return p;
-        };
-        this.readFile = async (name) => {
-            let p = this.readFileCache.get(name);
-            if (!p) {
-                p = this._readFile(name);
-                this.readFileCache.set(name, p);
-            }
-            return p;
-        };
-        /**
-         * Returns a list of Stat objects from the current working directory.
-         */
-        this.readdir = async (name) => {
-            let p = this.readdirCache.get(name);
-            if (!p) {
-                p = this._readdir(name);
-                this.readdirCache.set(name, p);
-            }
-            return p;
-        };
-        /**
-         * Changes the current directory to the specified path and returns a new instance of DetectorFilesystem.
-         */
-        this.chdir = (name) => {
-            return this._chdir(name);
-        };
-        this.pathCache = new Map();
-        this.fileCache = new Map();
-        this.readFileCache = new Map();
-        this.readdirCache = new Map();
-    }
-}
-exports.DetectorFilesystem = DetectorFilesystem;

package/dist/fs/get-glob-fs.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import fs from 'fs';
-import { DetectorFilesystem } from '../detectors/filesystem';
-declare type GlobFs = typeof fs;
-export declare function getGlobFs(_fs: DetectorFilesystem): GlobFs;
-export {};

package/dist/fs/get-glob-fs.js

@@ -1,71 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobFs = void 0;
-const fs_1 = __importDefault(require("fs"));
-function normalizePath(path) {
-    // on windows, this will return a path like
-    // D:/c/package.json
-    // since we abstract the filesystem, we need to remove windows specific info from the path
-    // and let the FS decide how to process the path
-    // D:/c/package.json => /c/package.json
-    return path.replace(/^[a-zA-Z]:/, '');
-}
-function getGlobFs(_fs) {
-    const readdir = (path, callback) => {
-        _fs
-            .readdir(normalizePath(String(path)))
-            .then(stats => callback(null, stats.map(stat => stat.name)))
-            .catch(err => callback(err, []));
-    };
-    const stat = (path, callback) => {
-        _fs
-            .isFile(normalizePath(String(path)))
-            .then(isPathAFile => {
-            callback(null, {
-                ino: 0,
-                mode: 0,
-                nlink: 0,
-                uid: 0,
-                gid: 0,
-                rdev: 0,
-                size: 0,
-                blksize: 0,
-                blocks: 0,
-                atimeMs: 0,
-                mtimeMs: 0,
-                ctimeMs: 0,
-                birthtimeMs: 0,
-                atime: new Date(),
-                mtime: new Date(),
-                ctime: new Date(),
-                birthtime: new Date(),
-                dev: 0,
-                isBlockDevice: () => false,
-                isCharacterDevice: () => false,
-                isDirectory: () => !isPathAFile,
-                isFIFO: () => false,
-                isFile: () => isPathAFile,
-                isSocket: () => false,
-                isSymbolicLink: () => false,
-            });
-        })
-            .catch(err => callback(err, null));
-    };
-    return new Proxy(fs_1.default, {
-        get(_target, prop) {
-            switch (prop) {
-                case 'readdir':
-                    return readdir;
-                case 'lstat':
-                case 'stat':
-                    return stat;
-                default:
-                    throw new Error('Not Implemented');
-            }
-        },
-    });
-}
-exports.getGlobFs = getGlobFs;

package/dist/get-project-paths.d.ts

@@ -1,9 +0,0 @@
-import { DetectorFilesystem } from './detectors/filesystem';
-export interface GetProjectPathsOptions {
-    fs: DetectorFilesystem;
-    path?: string;
-    skipPaths?: string[];
-    depth?: number;
-}
-export declare type ProjectPath = string;
-export declare const getProjectPaths: ({ fs, path, skipPaths, depth, }: GetProjectPathsOptions) => Promise<ProjectPath[]>;

package/dist/get-project-paths.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProjectPaths = void 0;
-const detect_framework_1 = require("./detect-framework");
-const frameworks_1 = __importDefault(require("@vercel/frameworks"));
-const MAX_DEPTH_TRAVERSE = 3;
-const getProjectPaths = async ({ fs, path, skipPaths, depth = MAX_DEPTH_TRAVERSE, }) => {
-    if (depth === 0)
-        return [];
-    const allPaths = [];
-    const topPath = path ?? './';
-    if (path && skipPaths?.includes(path)) {
-        return allPaths;
-    }
-    const framework = await detect_framework_1.detectFramework({
-        fs: fs.chdir(topPath),
-        frameworkList: frameworks_1.default,
-    });
-    if (framework !== null)
-        allPaths.push(topPath);
-    if (depth > 1) {
-        const directoryContents = await fs.readdir(topPath);
-        const childDirectories = directoryContents.filter(stat => stat.type === 'dir' && !skipPaths?.includes(stat.path));
-        const paths = (await Promise.all(childDirectories.map(({ path }) => {
-            return exports.getProjectPaths({
-                fs,
-                path,
-                depth: depth - 1,
-                skipPaths,
-            });
-        }))).flat();
-        return [...paths, ...allPaths];
-    }
-    return allPaths;
-};
-exports.getProjectPaths = getProjectPaths;

package/dist/monorepos/monorepo-managers.d.ts

@@ -1,16 +0,0 @@
-import type { Framework } from '@vercel/frameworks';
-/**
- * The supported list of monorepo managers.
- *
- * This list is designed to work with the @see {@link detectFramework} function.
- *
- * @example
- *   import { monorepoManagers as frameworkList } from '@vercel/build-utils'
- *   import { detectFramework } from '@vercel/build-utils'
- *
- *   const fs = new GitDetectorFilesystem(...)
- *   detectFramwork({ fs, frameworkList }) // returns the 'slug' field if detected, otherwise null
- *
- */
-export declare const monorepoManagers: Array<Omit<Framework, 'description' | 'logo' | 'settings' | 'getOutputDirName'>>;
-export default monorepoManagers;

package/dist/monorepos/monorepo-managers.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.monorepoManagers = void 0;
-/**
- * The supported list of monorepo managers.
- *
- * This list is designed to work with the @see {@link detectFramework} function.
- *
- * @example
- *   import { monorepoManagers as frameworkList } from '@vercel/build-utils'
- *   import { detectFramework } from '@vercel/build-utils'
- *
- *   const fs = new GitDetectorFilesystem(...)
- *   detectFramwork({ fs, frameworkList }) // returns the 'slug' field if detected, otherwise null
- *
- */
-exports.monorepoManagers = [
-    {
-        name: 'Turborepo',
-        slug: 'turbo',
-        detectors: {
-            some: [
-                {
-                    path: 'turbo.json',
-                },
-                {
-                    path: 'package.json',
-                    matchContent: '"turbo":\\s*{[^}]*.+[^}]*}',
-                },
-            ],
-        },
-    },
-];
-exports.default = exports.monorepoManagers;

package/dist/workspaces/get-workspace-package-paths.d.ts

@@ -1,11 +0,0 @@
-import { DetectorFilesystem } from '../detectors/filesystem';
-import { Workspace } from './get-workspaces';
-interface GetPackagePathOptions {
-    fs: DetectorFilesystem;
-}
-export interface GetWorkspacePackagePathsOptions extends GetPackagePathOptions {
-    fs: DetectorFilesystem;
-    workspace: Workspace;
-}
-export declare function getWorkspacePackagePaths({ fs, workspace, }: GetWorkspacePackagePathsOptions): Promise<string[]>;
-export {};

package/dist/workspaces/get-workspace-package-paths.js

@@ -1,62 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorkspacePackagePaths = void 0;
-const path_1 = __importDefault(require("path"));
-const js_yaml_1 = __importDefault(require("js-yaml"));
-const glob_1 = __importDefault(require("glob"));
-const get_glob_fs_1 = require("../fs/get-glob-fs");
-const normalize_path_1 = require("../fs/normalize-path");
-const posixPath = path_1.default.posix;
-async function getWorkspacePackagePaths({ fs, workspace, }) {
-    const { type, rootPath } = workspace;
-    const workspaceFs = fs.chdir(rootPath);
-    let results = [];
-    switch (type) {
-        case 'yarn':
-        case 'npm':
-            results = await getPackageJsonWorkspacePackagePaths({ fs: workspaceFs });
-            break;
-        case 'pnpm':
-            results = await getPnpmWorkspacePackagePaths({ fs: workspaceFs });
-            break;
-        default:
-            throw new Error(`Unknown workspace implementation: ${type}`);
-    }
-    return results.map(packagePath => {
-        return posixPath.join(rootPath, posixPath.dirname(packagePath));
-    });
-}
-exports.getWorkspacePackagePaths = getWorkspacePackagePaths;
-async function getPackagePaths(packages, fs) {
-    return (await Promise.all(packages.map(packageGlob => new Promise((resolve, reject) => {
-        glob_1.default(normalize_path_1.normalizePath(posixPath.join(packageGlob, 'package.json')), {
-            cwd: '/',
-            fs: get_glob_fs_1.getGlobFs(fs),
-        }, (err, matches) => {
-            if (err)
-                reject(err);
-            else
-                resolve(matches);
-        });
-    })))).flat();
-}
-async function getPackageJsonWorkspacePackagePaths({ fs, }) {
-    const packageJsonAsBuffer = await fs.readFile('package.json');
-    const { workspaces } = JSON.parse(packageJsonAsBuffer.toString());
-    let packages = [];
-    if (Array.isArray(workspaces)) {
-        packages = workspaces;
-    }
-    else {
-        packages = workspaces?.packages ?? [];
-    }
-    return getPackagePaths(packages, fs);
-}
-async function getPnpmWorkspacePackagePaths({ fs, }) {
-    const pnpmWorkspaceAsBuffer = await fs.readFile('pnpm-workspace.yaml');
-    const { packages = [] } = js_yaml_1.default.load(pnpmWorkspaceAsBuffer.toString());
-    return getPackagePaths(packages, fs);
-}