@travisennis/acai 0.0.12 → 0.0.14

package/dist/utils/glob.js

@@ -1,376 +0,0 @@
-import * as fs from "node:fs";
-import { readFile } from "node:fs/promises";
-import path, * as nodePath from "node:path";
-import * as process from "node:process";
-import fg from "fast-glob";
-import { isDirectory, slash, toPath } from "./filesystem/operations.js";
-import { Ignore } from "./ignore.js";
-// Cache for ignore patterns to avoid repeated IO
-const ignoreCache = new Map();
-const CACHE_TTL = 60000; // 1 minute TTL
-const assertPatternsInput = (patterns) => {
-    if (patterns.some((pattern) => typeof pattern !== "string")) {
-        throw new TypeError("Patterns must be a string or an array of strings");
-    }
-};
-// Pre-compiled regexes for performance
-const GLOBSTAR_DIRECTORY_REGEX = /\*\*\/([^/]+)$/;
-const WILDCARD_CHARS_REGEX = /[*?[\]{}]/;
-const EXTENSION_PATTERN_REGEX = /\.[a-zA-Z0-9]{1,5}$/;
-const normalizePathForDirectoryGlob = (filePath, cwd) => {
-    const path = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
-    return nodePath.isAbsolute(path) ? path : nodePath.join(cwd, path);
-};
-const shouldExpandGlobstarDirectory = (pattern) => {
-    const match = pattern?.match(GLOBSTAR_DIRECTORY_REGEX);
-    if (!match) {
-        return false;
-    }
-    const dirname = match[1];
-    const hasWildcards = WILDCARD_CHARS_REGEX.test(dirname);
-    // Only consider it an extension if it looks like a file extension pattern
-    // (e.g., contains common extension chars and doesn't look like a directory name)
-    const hasExtension = EXTENSION_PATTERN_REGEX.test(dirname) && !dirname.startsWith(".");
-    return !hasWildcards && !hasExtension;
-};
-const getDirectoryGlob = ({ directoryPath, files, extensions, }) => {
-    const extensionGlob = extensions && extensions.length > 0
-        ? `.${extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0]}`
-        : "";
-    return files
-        ? files.map((file) => {
-            // Don't append extension glob if file already has wildcards, extension, or looks like a pattern
-            const hasGlobChars = /[*?[\]{}]/.test(file);
-            const hasExtension = nodePath.extname(file);
-            const shouldAppendExtension = extensionGlob && !hasGlobChars && !hasExtension;
-            return nodePath.posix.join(directoryPath, `**/${shouldAppendExtension ? `${file}${extensionGlob}` : file}`);
-        })
-        : [
-            nodePath.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ""}`),
-        ];
-};
-const directoryToGlob = async (directoryPaths, { cwd = process.cwd(), files, extensions, } = {}) => {
-    const globs = await Promise.all(directoryPaths.map(async (directoryPath) => {
-        // Check pattern without negative prefix
-        const checkPattern = isNegativePattern(directoryPath)
-            ? directoryPath.slice(1)
-            : directoryPath;
-        // Expand globstar directory patterns like **/dirname to **/dirname/**
-        if (shouldExpandGlobstarDirectory(checkPattern)) {
-            return getDirectoryGlob({ directoryPath, files, extensions });
-        }
-        // If pattern contains any glob wildcard, do not stat; leave as-is
-        if (/[*?[\]{}]/.test(checkPattern)) {
-            return directoryPath;
-        }
-        // Original logic for checking actual directories
-        const pathToCheck = normalizePathForDirectoryGlob(directoryPath, cwd);
-        return (await isDirectory(pathToCheck))
-            ? getDirectoryGlob({ directoryPath, files, extensions })
-            : directoryPath;
-    }));
-    return globs.flat();
-};
-const toPatternsArray = (patterns) => {
-    const flattenedPatterns = Array.from(new Set([patterns].flat()));
-    assertPatternsInput(flattenedPatterns);
-    return flattenedPatterns;
-};
-const checkCwdOption = (cwd) => {
-    if (!cwd) {
-        return;
-    }
-    let stat;
-    try {
-        stat = fs.statSync(cwd);
-    }
-    catch (_error) {
-        throw new Error(`The \`cwd\` option must point to an existing directory: ${cwd}`);
-    }
-    if (!stat.isDirectory()) {
-        throw new Error("The `cwd` option must be a path to a directory");
-    }
-};
-const normalizeOptions = (options = {}) => {
-    const resolvedCwd = options.cwd ? toPath(options.cwd) : undefined;
-    const normalizedOptions = {
-        ...options,
-        ignore: options.ignore ?? [],
-        expandDirectories: options.expandDirectories ?? true,
-        cwd: resolvedCwd,
-    };
-    if (resolvedCwd) {
-        checkCwdOption(resolvedCwd);
-    }
-    return normalizedOptions;
-};
-const normalizeArguments = (fn) => (patterns, options) => fn(toPatternsArray(patterns), normalizeOptions(options || {}));
-const getIgnoreFilesPatterns = (options) => {
-    const { ignoreFiles, gitignore } = options;
-    const patterns = ignoreFiles ? toPatternsArray(ignoreFiles) : [];
-    if (gitignore) {
-        patterns.push(GITIGNORE_FILES_PATTERN);
-    }
-    return patterns;
-};
-const getFilter = async (options) => {
-    const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
-    const isIgnoredFn = ignoreFilesPatterns.length > 0
-        ? await isIgnoredByIgnoreFiles(ignoreFilesPatterns, options)
-        : false;
-    return createFilterFunction(isIgnoredFn);
-};
-// No-op predicate for when no ignore filtering is needed
-const noOpPredicate = () => false;
-const createFilterFunction = (isIgnored) => {
-    const seen = new Set();
-    const ignorePredicate = isIgnored === false ? noOpPredicate : isIgnored;
-    return (fastGlobResult) => {
-        let pathKey;
-        if (typeof fastGlobResult === "string") {
-            pathKey = fastGlobResult;
-        }
-        else {
-            const entry = fastGlobResult;
-            if (!entry.path) {
-                // Entry without path is invalid - skip it
-                return false;
-            }
-            pathKey = entry.path;
-        }
-        // Normalize to POSIX for consistent cross-platform behavior
-        pathKey = slash(nodePath.normalize(pathKey));
-        if (seen.has(pathKey) || ignorePredicate(pathKey)) {
-            return false;
-        }
-        seen.add(pathKey);
-        return true;
-    };
-};
-const unionFastGlobResults = (results, filter) => results.flat().filter((fastGlobResult) => filter(fastGlobResult));
-const convertNegativePatterns = (patterns, options) => {
-    const tasks = [];
-    let localPatterns = patterns;
-    while (localPatterns.length > 0) {
-        const index = localPatterns.findIndex((pattern) => isNegativePattern(pattern));
-        if (index === -1) {
-            tasks.push({ patterns: localPatterns, options });
-            break;
-        }
-        const ignorePattern = localPatterns[index].slice(1);
-        // Create immutable copies for all existing tasks
-        for (let i = 0; i < tasks.length; i++) {
-            tasks[i] = {
-                ...tasks[i],
-                options: {
-                    ...tasks[i].options,
-                    ignore: [...(tasks[i].options.ignore ?? []), ignorePattern],
-                },
-            };
-        }
-        if (index !== 0) {
-            tasks.push({
-                patterns: localPatterns.slice(0, index),
-                options: {
-                    ...options,
-                    ignore: [...(options.ignore ?? []), ignorePattern],
-                },
-            });
-        }
-        localPatterns = localPatterns.slice(index + 1);
-    }
-    return tasks;
-};
-const normalizeExpandDirectoriesOption = (options, cwd) => {
-    const result = {};
-    if (cwd) {
-        result.cwd = cwd;
-    }
-    if (Array.isArray(options)) {
-        result.files = options;
-    }
-    else if (typeof options === "object" && options !== null) {
-        if ("files" in options)
-            result.files = options.files;
-        if ("extensions" in options)
-            result.extensions = options.extensions;
-    }
-    return result;
-};
-const generateTasks = async (patterns, options) => {
-    const globTasks = convertNegativePatterns(patterns, options);
-    const { cwd, expandDirectories } = options;
-    if (!expandDirectories) {
-        return globTasks;
-    }
-    const directoryToGlobOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd ? toPath(cwd) : cwd);
-    return Promise.all(globTasks.map(async (task) => {
-        let { patterns, options } = task;
-        [patterns, options.ignore] = await Promise.all([
-            directoryToGlob(patterns, directoryToGlobOptions),
-            directoryToGlob(options.ignore, {
-                cwd: cwd ? toPath(cwd) : cwd,
-            }),
-        ]);
-        return { patterns, options };
-    }));
-};
-/**
- * Find files and directories using glob patterns.
- *
- * Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
- *
- * @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
- * @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
- * @returns The matching paths.
- */
-export const glob = normalizeArguments(async (patterns, options) => {
-    const [tasks, filter] = await Promise.all([
-        generateTasks(patterns, options),
-        getFilter(options),
-    ]);
-    const results = await Promise.all(tasks.map((task) => fg(task.patterns, convertOptionsForFastGlob(task.options))));
-    return unionFastGlobResults(results, filter);
-});
-// Helper function to convert our Options to fast-glob compatible options
-const convertOptionsForFastGlob = (options) => {
-    const { cwd, ...rest } = options;
-    return {
-        ...rest,
-        cwd: cwd ? toPath(cwd) : undefined,
-    };
-};
-const defaultIgnoredDirectories = [
-    "**/node_modules",
-    "**/flow-typed",
-    "**/coverage",
-    "**/.git",
-];
-const ignoreFilesGlobOptions = {
-    absolute: true,
-    dot: true,
-};
-const GITIGNORE_FILES_PATTERN = "**/.gitignore";
-// Apply base path to gitignore patterns based on .gitignore spec 2.22.1
-// https://git-scm.com/docs/gitignore#_pattern_format
-// See also https://github.com/sindresorhus/globby/issues/146
-const applyBaseToPattern = (pattern, base) => {
-    if (!base) {
-        return pattern;
-    }
-    const isNegative = isNegativePattern(pattern);
-    const cleanPattern = isNegative ? pattern.slice(1) : pattern;
-    // Check if pattern has non-trailing slashes
-    const slashIndex = cleanPattern.indexOf("/");
-    const hasNonTrailingSlash = slashIndex !== -1 && slashIndex !== cleanPattern.length - 1;
-    let result;
-    if (!hasNonTrailingSlash) {
-        // "If there is no separator at the beginning or middle of the pattern,
-        // then the pattern may also match at any level below the .gitignore level."
-        // So patterns like '*.log' or 'temp' or 'build/' (trailing slash) match recursively.
-        result = path.posix.join(base, "**", cleanPattern);
-    }
-    else if (cleanPattern.startsWith("/")) {
-        // "If there is a separator at the beginning [...] of the pattern,
-        // then the pattern is relative to the directory level of the particular .gitignore file itself."
-        // Leading slash anchors the pattern to the .gitignore's directory.
-        result = path.posix.join(base, cleanPattern.slice(1));
-    }
-    else {
-        // "If there is a separator [...] middle [...] of the pattern,
-        // then the pattern is relative to the directory level of the particular .gitignore file itself."
-        // Patterns like 'src/foo' are relative to the .gitignore's directory.
-        result = path.posix.join(base, cleanPattern);
-    }
-    return isNegative ? `!${result}` : result;
-};
-const parseIgnoreFile = (file, cwd) => {
-    const base = slash(path.relative(cwd, path.dirname(file.filePath)));
-    const patterns = [];
-    for (const raw of file.content.split(/\r?\n/)) {
-        if (raw === "")
-            continue; // blank line
-        if (raw.startsWith("#"))
-            continue; // comment line (only when not escaped)
-        const line = raw; // preserve escapes like \# and \  for Ignore engine
-        patterns.push(applyBaseToPattern(line, base));
-    }
-    return patterns;
-};
-const toRelativePath = (fileOrDirectory, cwd) => {
-    const abs = path.isAbsolute(fileOrDirectory)
-        ? fileOrDirectory
-        : path.resolve(cwd, fileOrDirectory);
-    const rel = path.relative(cwd, abs);
-    if (rel.startsWith("..") || path.isAbsolute(rel))
-        return undefined;
-    return rel.startsWith("./") ? rel.slice(2) : rel;
-};
-const getIsIgnoredPredicate = (files, cwd) => {
-    // Sort files by path depth (ascending) so deeper .gitignore files override shallower ones
-    const sortedFiles = [...files].sort((a, b) => {
-        const depthA = a.filePath.split(nodePath.sep).length;
-        const depthB = b.filePath.split(nodePath.sep).length;
-        return depthA - depthB;
-    });
-    // Generate cache key using file paths + content hash
-    const hashString = (s) => {
-        // FNV-1a 32-bit
-        let h = 0x811c9dc5;
-        for (let i = 0; i < s.length; i++) {
-            h ^= s.charCodeAt(i);
-            h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
-        }
-        // force to uint32 and hex
-        return (h >>> 0).toString(16);
-    };
-    const cacheKey = `${cwd}|` +
-        sortedFiles.map((f) => `${f.filePath}:${hashString(f.content)}`).join("|");
-    const now = Date.now();
-    const cached = ignoreCache.get(cacheKey);
-    let patterns;
-    if (cached && now - cached.timestamp < CACHE_TTL) {
-        patterns = cached.patterns;
-    }
-    else {
-        patterns = sortedFiles.flatMap((file) => parseIgnoreFile(file, cwd));
-        ignoreCache.set(cacheKey, { patterns, timestamp: now });
-    }
-    const ignoreInstance = new Ignore().add(patterns);
-    return (fileOrDirectory) => {
-        let fileOrDirectoryAsPath = toPath(fileOrDirectory);
-        fileOrDirectoryAsPath = toRelativePath(fileOrDirectoryAsPath, cwd);
-        // If path is outside cwd (undefined), it can't be ignored by patterns in cwd
-        if (fileOrDirectoryAsPath === undefined) {
-            return false;
-        }
-        return fileOrDirectoryAsPath
-            ? ignoreInstance.ignores(slash(fileOrDirectoryAsPath))
-            : false;
-    };
-};
-const normalizeIgnoreOptions = (options = {}) => ({
-    cwd: options.cwd ? toPath(options.cwd) : process.cwd(),
-    suppressErrors: Boolean(options.suppressErrors),
-    deep: typeof options.deep === "number" ? options.deep : Number.POSITIVE_INFINITY,
-    ignore: [...(options.ignore ?? []), ...defaultIgnoredDirectories],
-});
-const isIgnoredByIgnoreFiles = async (patterns, options) => {
-    const { cwd, suppressErrors, deep, ignore } = normalizeIgnoreOptions(options);
-    const paths = await fg(patterns, {
-        cwd,
-        suppressErrors,
-        deep,
-        ignore: ignore,
-        ...ignoreFilesGlobOptions,
-    });
-    const files = await Promise.all(paths.map(async (filePath) => ({
-        filePath,
-        content: await readFile(filePath, "utf8"),
-    })));
-    return getIsIgnoredPredicate(files, cwd);
-};
-/**
- * Check if a pattern is negative (starts with '!')
- */
-const isNegativePattern = (pattern) => pattern[0] === "!";