Gulp Load Plugins

const gulpLoadPlugins = require('gulp-load-plugins');
const plugins = gulpLoadPlugins();

const plugins = require('gulp-load-plugins')();

{
  "dependencies": {
    "gulp-jshint": "*",
    "gulp-concat": "*",
    "gulp-uglify": "*"
  }
}

const gulp = require('gulp');
const plugins = require('gulp-load-plugins')();

// Now you can use plugins without requiring them individually
gulp.task('scripts', () => {
  return gulp.src('src/**/*.js')
    .pipe(plugins.jshint())
    .pipe(plugins.concat('app.js'))
    .pipe(plugins.uglify())
    .pipe(gulp.dest('dist'));
});

const jshint = require('gulp-jshint');
const concat = require('gulp-concat');
const uglify = require('gulp-uglify');

/**
 * Loads gulp plugins from package dependencies and attaches them to an object
 * @param {LoadPluginsOptions} options - Configuration options
 * @returns {object} Object with plugin properties that load on first access
 */
function gulpLoadPlugins(options);

interface LoadPluginsOptions {
  /** Enable debug logging to console (default: false) */
  DEBUG?: boolean;
  
  /** Glob patterns to search for plugins (default: ['gulp-*', 'gulp.*', '@*/gulp{-,.}*']) */
  pattern?: string | string[];
  
  /** When true, overrides built-in patterns; when false, extends them (default: true) */
  overridePattern?: boolean;
  
  /** Path to package.json or config object (default: auto-discovered from current working directory) */
  config?: string | object;
  
  /** Which dependency sections to scan (default: ['dependencies', 'devDependencies', 'peerDependencies']) */
  scope?: string | string[];
  
  /** Pattern to remove from plugin names (default: /^gulp(-|\.)/) */
  replaceString?: RegExp;
  
  /** Transform hyphenated names to camelCase (default: true) */
  camelize?: boolean;
  
  /** Whether plugins should be lazy loaded on demand (default: true) */
  lazy?: boolean;
  
  /** Manual mapping for renaming specific plugins (default: {}) */
  rename?: { [pluginName: string]: string };
  
  /** Custom function for plugin name transformation */
  renameFn?: (name: string) => string;
  
  /** Transform functions applied after plugin loading (default: {}) */
  postRequireTransforms?: { [pluginName: string]: (plugin: any) => any };
  
  /** Keep scoped packages in nested objects vs flattened (default: true) */
  maintainScope?: boolean;
  
  /** Custom require function for loading plugins */
  requireFn?: (name: string) => any;
}

const plugins = require('gulp-load-plugins')({
  DEBUG: false,              // Enable for troubleshooting
  lazy: true,               // Lazy load plugins (recommended)
  camelize: true,           // Convert hyphenated names to camelCase
  maintainScope: true       // Keep scoped packages nested
});

// Override default patterns completely
const plugins = require('gulp-load-plugins')({
  pattern: ['gulp-*', 'my-gulp-*'],
  overridePattern: true
});

// Extend default patterns
const plugins = require('gulp-load-plugins')({
  pattern: ['my-gulp-*'],
  overridePattern: false  // Adds to built-in patterns
});

const plugins = require('gulp-load-plugins')({
  rename: {
    'gulp-ruby-sass': 'sass',
    'gulp-typescript': 'ts'
  }
});

// Access as plugins.sass and plugins.ts

const plugins = require('gulp-load-plugins')({
  renameFn: function(name) {
    // Custom logic to transform plugin names
    return name.replace(/^gulp-/, '').replace(/-(\w)/g, (m, p1) => p1.toUpperCase());
  }
});

const plugins = require('gulp-load-plugins')({
  postRequireTransforms: {
    sass: function(sass) {
      return sass.logError; // Return a specific method
    },
    foo: function(foo) {
      return foo.configure({ /* options */ });
    }
  }
});

const merge = require('lodash.merge');

const packages = merge(
  require('some-shared-config/package.json'),
  require('./package.json')
);

const plugins = require('gulp-load-plugins')({
  config: packages
});

// With maintainScope: true (default)
const plugins = require('gulp-load-plugins')();
// @mycompany/gulp-eslint becomes plugins.mycompany.eslint

// With maintainScope: false
const plugins = require('gulp-load-plugins')({
  maintainScope: false
});
// @mycompany/gulp-eslint becomes plugins.eslint

try {
  const plugins = require('gulp-load-plugins')({
    config: null
  });
} catch (error) {
  console.error(error.message); 
  // Throws: "Could not find dependencies. Do you have a package.json file in your project?"
}

const plugins = require('gulp-load-plugins')({
  DEBUG: true
});

// Console output will show:
// gulp-load-plugins: Debug enabled with options: {...}
// gulp-load-plugins: 15 plugin(s) found: gulp-concat gulp-uglify ...
// gulp-load-plugins: renaming gulp-concat to concat
// gulp-load-plugins: lazyload: adding property concat

// Optimize for performance
const plugins = require('gulp-load-plugins')({
  lazy: true,                    // Only load plugins when used
  scope: ['devDependencies'],    // Only scan dev dependencies
  pattern: ['gulp-*']           // Only match standard gulp plugins
});

interface LoadPluginsOptions {
  DEBUG?: boolean;
  pattern?: string | string[];
  overridePattern?: boolean;
  config?: string | object;
  scope?: string | string[];
  replaceString?: RegExp;
  camelize?: boolean;
  lazy?: boolean;
  rename?: { [pluginName: string]: string };
  renameFn?: (name: string) => string;
  postRequireTransforms?: { [pluginName: string]: (plugin: any) => any };
  maintainScope?: boolean;
  requireFn?: (name: string) => any;
}

/**
 * Return type is a dynamic object where property names depend on the plugins found
 * and the configuration options applied. Each property contains the loaded plugin.
 */
interface PluginsObject {
  [pluginName: string]: any;
}