globlin 1.0.0-beta.1

package/js/index.d.ts

@@ -0,0 +1,475 @@
+/**
+ * globlin - A high-performance glob pattern matcher
+ *
+ * This module provides a 100% compatible drop-in replacement for glob v13,
+ * implemented in Rust for 20-30x faster performance.
+ */
+/**
+ * Pattern warning info returned by analyzePattern/analyzePatterns
+ */
+export interface PatternWarningInfo {
+    /** The type of warning (e.g., "escaped_wildcard_at_start", "performance", "empty_pattern") */
+    warningType: string;
+    /** Human-readable warning message */
+    message: string;
+    /** The original problematic pattern (if applicable) */
+    pattern?: string;
+    /** Suggested fix (if applicable) */
+    suggestion?: string;
+}
+/**
+ * Path data returned from native glob with withFileTypes
+ */
+interface NativePathData {
+    path: string;
+    isDirectory: boolean;
+    isFile: boolean;
+    isSymlink: boolean;
+}
+import { PathScurry, Path } from 'path-scurry';
+export { PathScurry, Path };
+export { Minimatch, minimatch } from 'minimatch';
+import { Minipass } from 'minipass';
+export { Minipass };
+export interface GlobOptions {
+    cwd?: string;
+    root?: string;
+    dot?: boolean;
+    nobrace?: boolean;
+    noglobstar?: boolean;
+    noext?: boolean;
+    nocase?: boolean;
+    magicalBraces?: boolean;
+    follow?: boolean;
+    maxDepth?: number;
+    matchBase?: boolean;
+    absolute?: boolean;
+    dotRelative?: boolean;
+    mark?: boolean;
+    nodir?: boolean;
+    posix?: boolean;
+    withFileTypes?: boolean;
+    stat?: boolean;
+    realpath?: boolean;
+    ignore?: string | string[] | IgnorePattern;
+    includeChildMatches?: boolean;
+    platform?: 'linux' | 'darwin' | 'win32';
+    windowsPathsNoEscape?: boolean;
+    signal?: AbortSignal;
+    /**
+     * Enable parallel directory walking using multiple threads.
+     *
+     * When `true`, uses parallel traversal which can be faster on:
+     * - Spinning hard drives (HDDs)
+     * - Network filesystems (NFS, CIFS)
+     * - Very large directory trees (100k+ files)
+     *
+     * When `false` (default), uses serial traversal which is:
+     * - Faster on SSDs for small to medium directories
+     * - Deterministic result ordering
+     * - Lower memory overhead
+     *
+     * **Note:** This is a globlin-specific option not present in the original glob package.
+     * Results may be returned in a different order when `parallel: true`.
+     *
+     * @default false
+     */
+    parallel?: boolean;
+    /**
+     * Enable directory caching for repeated glob operations.
+     *
+     * When `true`, caches directory listings in memory with a TTL-based invalidation
+     * strategy. This provides significant speedup when:
+     * - Running multiple glob operations on the same directories
+     * - Using the Glob class with cache reuse (passing Glob as options)
+     * - Patterns with overlapping directory prefixes
+     *
+     * When `false` (default), directories are read fresh each time, which is:
+     * - More accurate if the filesystem is changing
+     * - Lower memory usage (no cached directory listings)
+     * - Slightly slower for repeated operations
+     *
+     * The cache has a 5-second TTL to balance freshness with performance.
+     * Use `cache: false` when you expect filesystem changes during the operation.
+     *
+     * **Note:** This is a globlin-specific option not present in the original glob package.
+     *
+     * @default false
+     */
+    cache?: boolean;
+    /**
+     * Use optimized native I/O operations on Linux and macOS.
+     *
+     * When `true`, uses platform-specific optimizations:
+     * - Linux: `getdents64` syscall for faster directory reading (bypasses libc overhead)
+     * - macOS: Low-level BSD directory APIs with d_type for early file type detection
+     *
+     * Performance characteristics:
+     * - Linux: Expected 1.3-1.5x speedup on directory-heavy workloads
+     * - macOS: May provide speedup on some filesystems; benchmark for your use case
+     *
+     * When `false` (default), uses the standard `walkdir` library which is:
+     * - Cross-platform compatible
+     * - Well-tested and stable
+     * - Sufficient for most use cases
+     *
+     * On Windows, this option is ignored and the standard walker is used.
+     *
+     * **Note:** This is a globlin-specific option not present in the original glob package.
+     *
+     * @default false
+     */
+    useNativeIO?: boolean;
+    /**
+     * Use Grand Central Dispatch (GCD) for parallel walking on macOS.
+     *
+     * When `true` on macOS, uses Apple's Grand Central Dispatch framework for
+     * parallel directory traversal. This provides:
+     * - Native macOS scheduler integration
+     * - Automatic handling of efficiency vs performance cores on Apple Silicon
+     * - Better power management than generic thread pools
+     * - Lower overhead than rayon for I/O-bound workloads
+     *
+     * When `false` (default), uses the standard walker which is often faster
+     * on modern SSDs due to reduced coordination overhead.
+     *
+     * **When to use:**
+     * - Large directory trees (100k+ files) on Macs with many cores
+     * - Network filesystems where I/O latency dominates
+     * - When power efficiency matters (GCD respects system power state)
+     *
+     * **When NOT to use:**
+     * - Small to medium directories on SSD
+     * - When deterministic ordering is required
+     * - On non-macOS platforms (option is ignored)
+     *
+     * **Note:** This is a globlin-specific option not present in the original glob package.
+     *
+     * @default false
+     */
+    useGcd?: boolean;
+}
+/**
+ * Custom ignore pattern object. Compatible with glob v13's IgnoreLike interface.
+ *
+ * Both methods receive Path objects from path-scurry, allowing for rich
+ * filtering based on file properties (name, isDirectory, isFile, etc.)
+ */
+export interface IgnorePattern {
+    /**
+     * Called for each path to determine if it should be excluded from results.
+     * @param path - The Path object representing the file/directory
+     * @returns true if the path should be ignored (excluded from results)
+     */
+    ignored?: (path: Path) => boolean;
+    /**
+     * Called for each directory to determine if its children should be ignored.
+     * When this returns true, the directory's contents are not traversed.
+     * @param path - The Path object representing the directory
+     * @returns true if the directory's children should be skipped
+     */
+    childrenIgnored?: (path: Path) => boolean;
+}
+/**
+ * Options for glob with withFileTypes: true
+ */
+export interface GlobOptionsWithFileTypesTrue extends GlobOptions {
+    withFileTypes: true;
+}
+/**
+ * Options for glob with withFileTypes: false or undefined
+ */
+export interface GlobOptionsWithFileTypesFalse extends GlobOptions {
+    withFileTypes?: false | undefined;
+}
+/**
+ * Result type for glob with withFileTypes: true.
+ * Returns GloblinPath objects which are 85% faster to create than PathScurry Path objects.
+ * Use .toPath() on any result if you need the full PathScurry Path.
+ */
+export type GlobPathResult = GloblinPath;
+/**
+ * GloblinPath - A lazy Path-like wrapper that provides fast access to common properties
+ * while deferring expensive PathScurry resolution until needed.
+ *
+ * This class implements the most commonly used Path interface methods using cached
+ * values from Rust, avoiding the expensive `scurry.cwd.resolve()` call for each result.
+ * When advanced features are needed, call `toPath()` to get the full PathScurry Path.
+ *
+ * **Performance Characteristics:**
+ * - Creation: ~0.5µs (vs ~16µs for PathScurry Path)
+ * - isFile()/isDirectory()/isSymbolicLink(): ~0.06µs (uses cached values)
+ * - fullpath()/relative(): ~0.1µs (string operations)
+ * - toPath(): ~16µs (creates full PathScurry Path on demand)
+ *
+ * This optimization provides ~85% speedup for withFileTypes compared to eagerly
+ * creating PathScurry Path objects for every result.
+ */
+export declare class GloblinPath {
+    /** The relative path string */
+    readonly path: string;
+    /** The absolute working directory */
+    private readonly _cwd;
+    /** Cached file type information from Rust */
+    private readonly _isDir;
+    private readonly _isFileVal;
+    private readonly _isSymlinkVal;
+    /** Whether stat option was enabled (if false, isFile/isDirectory return false like PathScurry) */
+    private readonly _stat;
+    /** Lazily resolved PathScurry Path (only created if toPath() is called) */
+    private _pathScurryPath?;
+    private _pathScurry?;
+    /** Cached fullpath string */
+    private _fullpath?;
+    /** The name (basename) of this path entry */
+    readonly name: string;
+    constructor(relativePath: string, cwd: string, isDirectory: boolean, isFile: boolean, isSymlink: boolean, stat?: boolean);
+    /**
+     * Returns true if this is a regular file.
+     * Without stat: true, returns false (unknown type) to match PathScurry behavior.
+     * With stat: true, uses cached value from Rust - no filesystem access needed.
+     */
+    isFile(): boolean;
+    /**
+     * Returns true if this is a directory.
+     * Without stat: true, returns false (unknown type) to match PathScurry behavior.
+     * With stat: true, uses cached value from Rust - no filesystem access needed.
+     */
+    isDirectory(): boolean;
+    /**
+     * Returns true if this is a symbolic link.
+     * Uses cached value from Rust - no filesystem access needed.
+     */
+    isSymbolicLink(): boolean;
+    /**
+     * Returns the full absolute path.
+     * This is a fast string operation (no filesystem access).
+     */
+    fullpath(): string;
+    /**
+     * Returns the path relative to the cwd.
+     * This is a fast string operation (no filesystem access).
+     */
+    relative(): string;
+    /**
+     * Returns the full absolute path as a string.
+     * Alias for fullpath() for compatibility.
+     */
+    fullpathPosix(): string;
+    /**
+     * Returns the relative path as a string.
+     * Alias for relative() for compatibility.
+     */
+    relativePosix(): string;
+    /**
+     * Convert to a full PathScurry Path object.
+     * This is an expensive operation (~16µs) that should only be called
+     * when you need advanced Path features not provided by GloblinPath.
+     *
+     * The PathScurry Path is cached, so subsequent calls are fast.
+     *
+     * @returns A full PathScurry Path object
+     */
+    toPath(): Path;
+    /**
+     * Get the parent directory as a GloblinPath.
+     * Note: This creates a new GloblinPath for the parent.
+     * For advanced parent traversal, use toPath().parent.
+     */
+    get parent(): GloblinPath | undefined;
+    /**
+     * String representation (returns the relative path).
+     */
+    toString(): string;
+}
+/**
+ * Type representing either a PathScurry Path or a GloblinPath wrapper.
+ * GloblinPath provides the same common interface with better performance.
+ */
+export type GlobPath = Path | GloblinPath;
+/**
+ * LEGACY: Convert native PathData to full PathScurry Path objects.
+ * This is the slow path (~16µs per result) that was used before optimization.
+ * Kept for compatibility and when full PathScurry features are needed.
+ *
+ * @deprecated Use convertToPathObjects() instead for better performance.
+ */
+declare function convertToFullPathObjects(data: NativePathData[], cwd: string, performLstat?: boolean): Path[];
+export { convertToFullPathObjects };
+/**
+ * Synchronous glob pattern matching
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @returns Array of matching file paths (or GloblinPath objects if withFileTypes: true)
+ *
+ * @remarks
+ * When `withFileTypes: true`, returns GloblinPath objects which are 85% faster to create
+ * than PathScurry Path objects. GloblinPath provides the same common interface (isFile,
+ * isDirectory, isSymbolicLink, fullpath, relative) using cached values from Rust.
+ * Call `.toPath()` on any result if you need the full PathScurry Path.
+ */
+export declare function globSync(pattern: string | string[], options: GlobOptionsWithFileTypesTrue): GloblinPath[];
+export declare function globSync(pattern: string | string[], options?: GlobOptionsWithFileTypesFalse): string[];
+export declare function globSync(pattern: string | string[], options?: GlobOptions): string[] | GloblinPath[];
+/**
+ * Asynchronous glob pattern matching
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @returns Promise resolving to array of matching file paths (or GloblinPath objects if withFileTypes: true)
+ *
+ * @remarks
+ * When `withFileTypes: true`, returns GloblinPath objects which are 85% faster to create
+ * than PathScurry Path objects. GloblinPath provides the same common interface (isFile,
+ * isDirectory, isSymbolicLink, fullpath, relative) using cached values from Rust.
+ * Call `.toPath()` on any result if you need the full PathScurry Path.
+ */
+export declare function glob(pattern: string | string[], options: GlobOptionsWithFileTypesTrue): Promise<GloblinPath[]>;
+export declare function glob(pattern: string | string[], options?: GlobOptionsWithFileTypesFalse): Promise<string[]>;
+export declare function glob(pattern: string | string[], options?: GlobOptions): Promise<string[] | GloblinPath[]>;
+/**
+ * Streaming glob pattern matching
+ *
+ * Uses native streaming to reduce peak memory usage for large result sets.
+ * Results are streamed directly from Rust as they are found, rather than
+ * collecting all results before sending to JavaScript.
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @returns Minipass stream of matching file paths
+ */
+export declare function globStream(pattern: string | string[], options?: GlobOptions): Minipass<string, string>;
+/**
+ * Synchronous streaming glob pattern matching
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @returns Minipass stream of matching file paths
+ */
+export declare function globStreamSync(pattern: string | string[], options?: GlobOptions): Minipass<string, string>;
+/**
+ * Async iterator for glob results
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @yields Matching file paths
+ */
+export declare function globIterate(pattern: string | string[], options?: GlobOptions): AsyncGenerator<string, void, void>;
+/**
+ * Sync iterator for glob results
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @yields Matching file paths
+ */
+export declare function globIterateSync(pattern: string | string[], options?: GlobOptions): Generator<string, void, void>;
+/**
+ * Check if a pattern contains any magic glob characters.
+ * Takes into account escaped characters - escaped magic chars don't count.
+ *
+ * @param pattern - Glob pattern or array of patterns
+ * @param options - Glob options
+ * @returns True if the pattern has magic (unescaped) glob characters
+ */
+export declare function hasMagic(pattern: string | string[], options?: GlobOptions): boolean;
+/**
+ * Escape magic glob characters in a pattern.
+ * After escaping, the pattern will match the literal string.
+ *
+ * @param pattern - Pattern to escape
+ * @param options - Glob options (windowsPathsNoEscape affects escape style)
+ * @returns Escaped pattern
+ */
+export declare function escape(pattern: string, options?: GlobOptions): string;
+/**
+ * Unescape magic glob characters in a pattern.
+ * This reverses the effect of `escape()`.
+ *
+ * @param pattern - Pattern to unescape
+ * @param options - Glob options (windowsPathsNoEscape affects unescape style)
+ * @returns Unescaped pattern
+ */
+export declare function unescape(pattern: string, options?: GlobOptions): string;
+/**
+ * Analyze a pattern for potential issues and return warnings.
+ * This is useful for providing helpful feedback about common mistakes.
+ *
+ * @param pattern - The glob pattern to analyze
+ * @param options - Options affecting analysis (windowsPathsNoEscape, platform)
+ * @returns Array of warnings (empty if no issues detected)
+ *
+ * @example
+ * ```ts
+ * import { analyzePattern } from 'globlin'
+ *
+ * // Check for trailing spaces
+ * const warnings = analyzePattern('*.txt   ')
+ * // [{ warningType: 'trailing_spaces', suggestion: '*.txt', ... }]
+ * ```
+ *
+ * @remarks
+ * This function detects common mistakes such as:
+ * - Escaped wildcards at the start of patterns
+ * - Double-escaped characters
+ * - Backslash path separators on Windows without windowsPathsNoEscape
+ * - Performance issues (multiple globstars, redundant patterns)
+ * - Trailing spaces in patterns
+ * - Empty patterns
+ * - Null bytes in patterns
+ */
+export declare function analyzePattern(pattern: string, options?: GlobOptions): PatternWarningInfo[];
+/**
+ * Analyze multiple patterns for potential issues and return all warnings.
+ *
+ * @param patterns - Array of glob patterns to analyze
+ * @param options - Options affecting analysis (windowsPathsNoEscape, platform)
+ * @returns Array of warnings for all patterns (empty if no issues detected)
+ *
+ * @example
+ * ```ts
+ * import { analyzePatterns } from 'globlin'
+ *
+ * const warnings = analyzePatterns(['*.js', '*.txt   '])
+ * // Returns warnings for escaped wildcard and performance issue
+ * ```
+ */
+export declare function analyzePatterns(patterns: string[], options?: GlobOptions): PatternWarningInfo[];
+/**
+ * Glob class for reusable glob operations
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const g = new Glob('*.js', { cwd: '/path' })
+ * const files = g.walkSync()
+ *
+ * // Cache reuse - pass a Glob instance as options to reuse settings
+ * const g2 = new Glob('*.ts', g)  // Reuses cwd, dot, nocase, etc. from g
+ * ```
+ */
+export declare class Glob {
+    readonly pattern: string[];
+    readonly options: GlobOptions;
+    /**
+     * Create a new Glob instance.
+     *
+     * @param pattern - Glob pattern or array of patterns
+     * @param options - Glob options or a previous Glob instance to reuse settings
+     *
+     * When a Glob instance is passed as options, its settings (cwd, dot, nocase, etc.)
+     * are copied to the new instance. This allows for efficient reuse of settings
+     * when running multiple glob operations with similar configurations.
+     */
+    constructor(pattern: string | string[], options?: GlobOptions | Glob);
+    walk(): Promise<string[]>;
+    walkSync(): string[];
+    stream(): Minipass<string, string>;
+    streamSync(): Minipass<string, string>;
+    iterate(): AsyncGenerator<string, void, void>;
+    iterateSync(): Generator<string, void, void>;
+    [Symbol.asyncIterator](): AsyncGenerator<string, void, void>;
+    [Symbol.iterator](): Generator<string, void, void>;
+}
+export default glob;
+//# sourceMappingURL=index.d.ts.map

package/js/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"}