copy-webpack-plugin

type AdditionalOptions = {
    /**
     * maximum number of concurrent operations, default is 100
     */
    concurrency?: number | undefined;
};

type Asset = import('webpack').Asset;

type AssetInfo = import('webpack').AssetInfo;

type CacheFacade = ReturnType<Compilation['getCache']>;

type Compilation = import('webpack').Compilation;

type Compiler = import('webpack').Compiler;

type Context = string;

type CopiedResult = {
    /**
     * relative path to the file from the context
     */
    sourceFilename: string;
    /**
     * absolute path to the file
     */
    absoluteFilename: string;
    /**
     * relative path to the file from the output path
     */
    filename: string;
    /**
     * source of the file
     */
    source: Asset['source'];
    /**
     * whether to force update the asset if it already exists
     */
    force: Force | undefined;
    /**
     * additional information about the asset
     */
    info: Record<string, unknown>;
};

type Etag = ReturnType<ReturnType<Compilation['getCache']>['getLazyHashedEtag']>;

type Filter = (filepath: string) => boolean | Promise<boolean>;

type Force = boolean;

type From = string;

type GlobbyOptions = import('tinyglobby').GlobOptions;

type Info =
    | Record<string, unknown>
    | ((item: {
          absoluteFilename: string;
          sourceFilename: string;
          filename: string;
          toType: ToType;
      }) => Record<string, unknown>);

type InputFileSystem = import('webpack').InputFileSystem;

type NoErrorOnMissing = boolean;

type ObjectPattern = {
    /**
     * source path or glob pattern to copy files from
     */
    from: From;
    /**
     * options for globbing
     */
    globOptions?: GlobbyOptions | undefined;
    /**
     * context for the source path or glob pattern
     */
    context?: Context | undefined;
    /**
     * destination path or function to determine the destination path
     */
    to?: To | undefined;
    /**
     * type of the destination path, can be "dir", "file" or "template"
     */
    toType?: ToType | undefined;
    /**
     * additional information about the asset
     */
    info?: Info | undefined;
    /**
     * function to filter files, if it returns false, the file will be skipped
     */
    filter?: Filter | undefined;
    /**
     * function to transform the file content, can be a function or an object with a transformer function and cache options
     */
    transform?: Transform | undefined;
    /**
     * function to transform all files, it receives an array of objects with data, sourceFilename and absoluteFilename properties
     */
    transformAll?: TransformAllFunction | undefined;
    /**
     * whether to force update the asset if it already exists
     */
    force?: Force | undefined;
    /**
     * priority of the pattern, patterns with higher priority will be processed first
     */
    priority?: number | undefined;
    /**
     * whether to skip errors when no files are found for the pattern
     */
    noErrorOnMissing?: NoErrorOnMissing | undefined;
};

type Pattern = StringPattern | ObjectPattern;

type PluginOptions = {
    /**
     * array of patterns to copy files from
     */
    patterns: Pattern[];
    /**
     * additional options for the plugin
     */
    options?: AdditionalOptions | undefined;
};

type Schema = import('schema-utils/declarations/validate').Schema;

type Snapshot = ReturnType<Compilation['fileSystemInfo']['mergeSnapshots']>;

type StringPattern = string;

type To = string | ToFunction;

type ToFunction = (pathData: {
    context: string;
    absoluteFilename?: string;
}) => string | Promise<string>;

type ToType = 'dir' | 'file' | 'template';

type Transform = TransformerFunction | TransformerObject;

type TransformAllFunction = (
    data: {
        data: Buffer;
        sourceFilename: string;
        absoluteFilename: string;
    }[]
) => string | Buffer | Promise<string> | Promise<Buffer>;

type TransformerCacheObject =
    | {
          keys: {
              [key: string]: unknown;
          };
      }
    | {
          keys: (
              defaultCacheKeys: {
                  [key: string]: unknown;
              },
              absoluteFilename: string
          ) => Promise<{
              [key: string]: unknown;
          }>;
      };

type TransformerFunction = (
    input: Buffer,
    absoluteFilename: string
) => string | Buffer | Promise<string> | Promise<Buffer>;

type TransformerObject = {
    /**
     * function to transform the file content
     */
    transformer: TransformerFunction;
    /**
     * whether to cache the transformed content or an object with keys for caching
     */
    cache?: (boolean | TransformerCacheObject) | undefined;
};

type WebpackLogger = ReturnType<Compilation['getLogger']>;