Utility Functions

/**
 * Check if patterns contain special glob characters
 * @param patterns - Glob patterns to analyze
 * @param options - Fast-glob options that affect pattern analysis
 * @returns Boolean indicating presence of dynamic patterns
 */
function isDynamicPattern(
  patterns: string | readonly string[],
  options?: {
    /** Current working directory */
    readonly cwd?: URL | string;
  }
): boolean;

import { isDynamicPattern } from "globby";

// Static patterns
console.log(isDynamicPattern('file.txt')); // false
console.log(isDynamicPattern('path/to/file.js')); // false

// Dynamic patterns
console.log(isDynamicPattern('*.js')); // true
console.log(isDynamicPattern('**/*.txt')); // true
console.log(isDynamicPattern('src/{js,ts}/**/*')); // true

// Multiple patterns
console.log(isDynamicPattern(['file.txt', '*.js'])); // true (at least one is dynamic)

// With options
console.log(isDynamicPattern('*', { 
  cwd: '/custom/path',
  caseSensitiveMatch: false 
})); // true

/**
 * Generate glob tasks for use with fast-glob (async)
 * @param patterns - Glob patterns to process
 * @param options - Globby options
 * @returns Promise resolving to array of task objects
 */
function generateGlobTasks(
  patterns: string | readonly string[],
  options?: Options
): Promise<GlobTask[]>;

/**
 * Generate glob tasks for use with fast-glob (sync)
 * @param patterns - Glob patterns to process
 * @param options - Globby options
 * @returns Array of task objects
 */
function generateGlobTasksSync(
  patterns: string | readonly string[],
  options?: Options
): GlobTask[];

import { generateGlobTasks, generateGlobTasksSync } from "globby";
import fastGlob from "fast-glob";

// Async task generation
const tasks = await generateGlobTasks(['src/**/*.js', '!**/*.test.js'], {
  cwd: '/path/to/project',
  gitignore: true
});

// Use tasks with fast-glob directly
const results = await Promise.all(
  tasks.map(task => fastGlob(task.patterns, task.options))
);
const allFiles = results.flat();

// Sync task generation
const syncTasks = generateGlobTasksSync(['**/*.ts', '!node_modules/**']);
const syncResults = syncTasks.map(task => 
  fastGlob.sync(task.patterns, task.options)
);

// Advanced usage with custom processing
const customTasks = await generateGlobTasks(['**/*.{js,ts}'], {
  expandDirectories: {
    files: ['index.js', 'main.ts'],
    extensions: ['jsx', 'tsx']
  }
});

customTasks.forEach((task, index) => {
  console.log(`Task ${index}:`, task.patterns);
  console.log(`Options:`, task.options);
});

/**
 * Convert a path to a pattern
 * @param source - File path to convert
 * @returns Converted glob pattern
 */
function convertPathToPattern(source: string): string;

import { convertPathToPattern } from "globby";

// Convert paths to patterns
const pattern1 = convertPathToPattern('/absolute/path/to/file.js');
console.log(pattern1); // Normalized pattern

const pattern2 = convertPathToPattern('relative/path/to/dir');
console.log(pattern2); // Normalized pattern

// Useful for dynamic pattern generation
const basePath = '/project/src';
const files = ['utils.js', 'config.js', 'types.ts'];

const patterns = files.map(file => 
  convertPathToPattern(`${basePath}/${file}`)
);

interface GlobTask {
  /** Processed glob patterns */
  readonly patterns: string[];
  /** Fast-glob compatible options */
  readonly options: Options;
}

import { generateGlobTasks } from "globby";
import customGlob from "some-other-glob-library";

// Generate tasks with globby's processing
const tasks = await generateGlobTasks([
  'src/**/*.js',
  '!**/*.test.js',
  'lib'  // This will be expanded to lib/**/*
], {
  gitignore: true,
  expandDirectories: true
});

// Use tasks with different glob implementation
const results = await Promise.all(
  tasks.map(task => customGlob(task.patterns, task.options))
);

import { generateGlobTasksSync, isDynamicPattern } from "globby";

function createBuildConfig(patterns, options = {}) {
  // Check if we need glob processing
  if (!isDynamicPattern(patterns)) {
    return { files: patterns }; // Static files, no globbing needed
  }

  // Generate optimized tasks
  const tasks = generateGlobTasksSync(patterns, options);
  
  return {
    tasks: tasks.map(task => ({
      include: task.patterns,
      exclude: task.options.ignore || [],
      cwd: task.options.cwd
    }))
  };
}

// Usage
const buildConfig = createBuildConfig([
  'src/**/*.{js,ts}',
  '!**/*.test.{js,ts}',
  'static'
], {
  gitignore: true,
  expandDirectories: { extensions: ['jsx', 'tsx'] }
});

import { generateGlobTasks, isDynamicPattern } from "globby";

async function optimizedGlob(patterns, options) {
  // Skip expensive processing for static patterns
  if (!isDynamicPattern(patterns)) {
    return Array.isArray(patterns) ? patterns : [patterns];
  }

  // Use task generation for complex patterns
  const tasks = await generateGlobTasks(patterns, options);
  
  // Process tasks in parallel with concurrency limit
  const concurrency = 4;
  const results = [];
  
  for (let i = 0; i < tasks.length; i += concurrency) {
    const batch = tasks.slice(i, i + concurrency);
    const batchResults = await Promise.all(
      batch.map(task => fastGlob(task.patterns, task.options))
    );
    results.push(...batchResults.flat());
  }
  
  return [...new Set(results)]; // Remove duplicates
}

import { isDynamicPattern, generateGlobTasks } from "globby";

// Safe pattern checking
function safeIsDynamic(patterns) {
  try {
    return isDynamicPattern(patterns);
  } catch (error) {
    console.warn('Invalid patterns:', error);
    return false;
  }
}

// Task generation with error handling
async function safeGenerateTasks(patterns, options) {
  try {
    return await generateGlobTasks(patterns, options);
  } catch (error) {
    console.error('Task generation failed:', error);
    return [{ patterns: [], options: {} }];
  }
}