Support flat copy (#111)

Author: sibiraj-s

.github/workflows/tests.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        node-version: [12.x, 14.x, 16.x]
+        node-version: [12.x, 14.x, 16.x, 17.x]
 
     name: Test - ${{ matrix.os }} - Node v${{ matrix.node-version }}
 

README.md

@@ -118,7 +118,18 @@ Copy individual files or entire directories from a source folder to a destinatio
 ```js
 [
   { source: '/path/from', destination: '/path/to' },
-  { source: '/path/**/*.js', destination: '/path' },
+  {
+    source: '/path/**/*.js',
+    destination: '/path',
+    options: {
+      flat: false,
+      preserveTimestamps: true,
+      overwite: true,
+    },
+    globOptions: {
+      dot: true,
+    },
+  },
   { source: '/path/fromfile.txt', destination: '/path/tofile.txt' },
   { source: '/path/**/*.{html,js}', destination: '/path/to' },
   { source: '/path/{file1,file2}.js', destination: '/path/to' },
@@ -129,6 +140,8 @@ Copy individual files or entire directories from a source folder to a destinatio
 
 - source[`string`] - a file or a directory or a glob
 - destination[`string`] - a file or a directory.
+- options ['object`] - copy options
+- globOptions [`object`] - options to forward to glob options
 
 **Caveats**
 

src/actions/copy.js

@@ -11,16 +11,26 @@ const fsExtraDefaultOptions = {
 };
 
 const copy = async (task, { logger }) => {
-  const { source, absoluteSource, destination, absoluteDestination, context, toType } = task;
+  const {
+    source,
+    absoluteSource,
+    destination,
+    absoluteDestination,
+    context,
+    toType,
+    options = {},
+    globOptions = {},
+  } = task;
 
   logger.log(`copying from ${source} to ${destination}`);
 
   if (isGlob(source)) {
     const cpOptions = {
+      ...options,
       cwd: context,
     };
 
-    await globCopy(source, absoluteDestination, cpOptions);
+    await globCopy(source, absoluteDestination, cpOptions, globOptions);
   } else {
     const isSourceFile = fs.lstatSync(absoluteSource).isFile();
 

src/options-schema.js

@@ -23,6 +23,33 @@ export default {
               type: 'string',
               minLength: 1,
             },
+            options: {
+              additionalProperties: false,
+              type: 'object',
+              description: 'Options to forward to archiver',
+              properties: {
+                flat: {
+                  description: 'Flatten the directory structure. All copied files will be put in the same directory',
+                  type: 'boolean',
+                  default: false,
+                },
+                overwrite: {
+                  description: 'overwrite existing file or directory',
+                  type: 'boolean',
+                  default: true,
+                },
+                preserveTimestamps: {
+                  description: 'Set last modification and access times to the ones of the original source files',
+                  type: 'boolean',
+                  default: false,
+                },
+              },
+            },
+            globOptions: {
+              additionalProperties: true,
+              type: 'object',
+              description: 'Options to forward to fast-glob',
+            },
           },
         },
       ],
@@ -187,7 +214,7 @@ export default {
     runOnceInWatchMode: {
       type: 'boolean',
       default: false,
-      description: 'Run tasks only at first compilation in watch mode'
-    }
+      description: 'Run tasks only at first compilation in watch mode',
+    },
   },
 };

src/utils/glob-copy.js

@@ -3,31 +3,35 @@ import fse from 'fs-extra';
 import fg from 'fast-glob';
 
 const defaultOptions = {
+  flat: false,
   cwd: process.cwd(),
 };
 
-const destPath = (pattern, file, cwd) => {
+const destPath = (pattern, file, options = defaultOptions) => {
+  if (options.flat) {
+    return path.posix.basename(file);
+  }
+
   const pathArr = pattern.split('/');
   const globIndex = pathArr.findIndex((item) => (item ? fg.isDynamicPattern(item) : false));
   const normalized = pathArr.slice(0, globIndex).join('/');
 
-  const absolutePath = path.isAbsolute(normalized) ? normalized : path.posix.join(cwd, normalized);
+  const absolutePath = path.isAbsolute(normalized) ? normalized : path.posix.join(options.cwd, normalized);
 
   return path.relative(absolutePath, file);
 };
 
-const globCopy = async (pattern, destination, options = defaultOptions) => {
+const globCopy = async (pattern, destination, options = defaultOptions, globOptions = {}) => {
   await fse.ensureDir(destination);
 
-  const matches = await fg(pattern, { dot: true, absolute: true, cwd: options.cwd });
+  const matches = await fg(pattern, { dot: true, ...globOptions, absolute: true, cwd: options.cwd });
 
   const entries = matches.map((file) => {
     const destDir = path.isAbsolute(destination) ? destination : path.posix.join(options.cwd, destination);
-    const destFileName = destPath(pattern, file, options.cwd);
+    const destFileName = destPath(pattern, file, options);
 
     return {
       from: file,
-
       destDir,
       destFileName,
       to: path.posix.join(destDir, destFileName),

tests/copy.test.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { basename, join, sep } from 'node:path';
 
 import test from 'ava';
 import del from 'del';
@@ -94,7 +94,43 @@ test('should deep copy files to directory given a glob source', async (t) => {
 
   t.true(existsSync(join(tmpdir, dirName)));
   t.true(existsSync(join(tmpdir, dirName, basename(file1))));
-  t.true(existsSync(join(nestedDir, basename(file2))));
+  t.true(existsSync(join(tmpdir, dirName, nestedDir.split(sep).pop(), basename(file2))));
+});
+
+test('should flat copy the files to directory given a glob source', async (t) => {
+  const { tmpdir } = t.context;
+
+  const file1 = await tempy.file(tmpdir);
+  const nestedDir = await tempy.dir({ root: tmpdir });
+  const file2 = await tempy.file(nestedDir);
+
+  const dirName = tempy.getDirName();
+
+  const config = {
+    context: tmpdir,
+    events: {
+      onEnd: {
+        copy: [
+          {
+            source: '**/*',
+            destination: dirName,
+            options: {
+              flat: true,
+            },
+            globOptions: {},
+          },
+        ],
+      },
+    },
+  };
+
+  const compiler = getCompiler();
+  new FileManagerPlugin(config).apply(compiler);
+  await compile(compiler);
+
+  t.true(existsSync(join(tmpdir, dirName)));
+  t.true(existsSync(join(tmpdir, dirName, basename(file1))));
+  t.true(existsSync(join(tmpdir, dirName, basename(file2))));
 });
 
 test(`should create destination directory if it doesn't exist and copy files`, async (t) => {

types.d.ts

@@ -1,18 +1,35 @@
 import type { ArchiverOptions } from 'archiver';
 import type { Options as DelOptions } from 'del';
 import type { Compiler, WebpackPluginInstance } from 'webpack';
+import type { CopyOptions } from 'fs-extra';
+import type { Options as FgOptions } from 'fast-glob';
+
+type FsCopyOptions = Pick<CopyOptions, 'overwrite' | 'preserveTimestamps'>;
+
+interface CopyActionOptions extends FsCopyOptions {
+  /**
+   * Flatten directory structure. All copied files will be put in the same directory.
+   * disabled by default
+   */
+  flat: boolean;
+}
 
 /** Copy individual files or entire directories from a source folder to a destination folder */
 type Copy = {
   /** Copy source. A file or directory or a glob */
   source: string;
   /** Copy destination */
   destination: string;
+  /** Copy Options */
+  options: CopyActionOptions;
+  /** Glob options */
+  globOptions: Omit<FgOptions, 'absolute' | 'cwd'>;
 }[];
 
 /** Delete individual files or entire directories */
 type Delete = (
   | {
+      /** A folder or file or a glob to delete */
       source: string;
       /** Options to forward to del */
       options: DelOptions;