mem-fs-editor 11.1.4 → 12.0.0

package/README.md

@@ -1,6 +1,5 @@
 # mem-fs-editor
 
-[![Node.js CI](https://github.com/SBoudrias/mem-fs-editor/workflows/Node.js%20CI/badge.svg)](https://github.com/SBoudrias/mem-fs-editor/actions?query=workflow%3A%22Node.js+CI%22)
 [![NPM version](https://badge.fury.io/js/mem-fs-editor.svg)](http://badge.fury.io/js/mem-fs-editor)
 [![Coverage Status](https://codecov.io/gh/SBoudrias/mem-fs-editor/branch/master/graph/badge.svg)](https://codecov.io/gh/SBoudrias/mem-fs-editor)
 
@@ -55,12 +54,13 @@ Append the new contents to the current file contents.
 - `options.separator` (default `os.EOL`). Separator to insert between current and new contents.
 - `options.create` (default `false`). Create the file if doesn't exists.
 
-### `#appendTpl(filepath, contents, context[, templateOptions[, [options]])`
+### `#appendTpl(filepath, contents, data[, options])`
 
-Append the new `contents` to the exsting `filepath` content and parse the new contents as an [ejs](http://ejs.co/) template where `context` is the template context (the variable names available inside the template).
+Append the new `contents` to the existing `filepath` content and parse the new contents as an [ejs](http://ejs.co/) template where `data` is the template context (the variable names available inside the template).
 
 - `options.trimEnd` (default `true`). Trim trailing whitespace of the current file contents.
 - `options.separator` (default `os.EOL`). Separator to insert between current and new contents.
+- `options.transformOptions`. Options passed to the EJS renderer when processing the template, similar to `copyTpl`.
 
 ### `#extendJSON(filepath, contents[, replacer [, space]])`
 
@@ -74,38 +74,45 @@ Delete a file or a directory.
 
 `filePath` can also be a `glob`. If `filePath` is glob, you can optionally pass in an `options.globOptions` object to change its pattern matching behavior. The full list of options are being described [here](https://github.com/mrmlnc/fast-glob#options-1). The `sync` flag is forced to be `true` in `globOptions`.
 
-### `#copy(from, to, [options], context[, templateOptions ])`
+### `#copy(from, to, [options])`
 
 Copy file(s) from the `from` path to the `to` path.
 When passing array, you should pass `options.fromBasePath` to be used to calculate the `to` relative path. The common directory will be detected and used as `fromBasePath` otherwise.
 
-Optionally, pass an `options.process` function (`process(contents)`) returning a string or a buffer who'll become the new file content. The process function will take a single contents argument who is the copied file contents as a `Buffer`.
+Optionally, pass an `options.fileTransform` function (`fileTransform(destinationPath, sourcePath, contents)`) that transforms both the destination path and file contents. The function takes two arguments:
+- `destinationPath`: The resolved destination file path
+- `sourcePath`: The resolved source file path
+- `contents`: The file contents as a `Buffer`
+
+It should return a tuple `[newFilepath, newContents]` where:
+- `newFilepath`: The transformed destination path (string)
+- `newContents`: The transformed file contents (Buffer)
 
 `options.ignoreNoMatch` can be used to silence the error thrown if no files match the `from` pattern.
 `options.append` can be used to append `from` contents to `to` instead of copying, when the file is already loaded in mem-fs (safe for regeneration).
 
 `from` can be a glob pattern that'll be match against the file system. If that's the case, then `to` must be an output directory. For a globified `from`, you can optionally pass in an `options.globOptions` object to change its pattern matching behavior. The full list of options are being described [here](https://github.com/mrmlnc/fast-glob#options-1). The `nodir` flag is forced to be `true` in `globOptions` to ensure a vinyl object representing each matching directory is marked as `deleted` in the `mem-fs` store.
 
-Optionally, when `from` is a glob pattern, pass an `options.processDestinationPath` function (`processDestinationPath(destinationFile)`) returning a string who'll become the new file name.
-
 `options.noGlob` can be used to by bypass glob matching entirely. In that case, `from` will directly match file paths against the file system.
 
-### `#copyAsync(from, to, [options], context[, templateOptions ])`
+### `#copyAsync(from, to, [options])`
 
 Async version of `copy`.
 
 `copy` loads `from` to memory and copy its contents to `to`.
 `copyAsync` copies directly from the disk to `to`, falling back to `copy` behavior if the file doesn't exists on disk.
 
-Same parameters of `copy` (see [copy() documentation for more details](#copyfrom-to-options-context-templateoptions-)).
+Same parameters of `copy`
+
+See [copy() documentation for more details](#copyfrom-to-options).
 
-### `#copyTpl(from, to, context[, templateOptions [, copyOptions]])`
+### `#copyTpl(from, to, data[, options])`
 
-Copy the `from` file and, if it is not a binary file, parse its content as an [ejs](http://ejs.co/) template where `context` is the template context (the variable names available inside the template).
+Copy the `from` file and, if it is not a binary file, parse its content as an [ejs](http://ejs.co/) template where `data` is the template context (the variable names available inside the template).
 
-You can optionally pass a `templateOptions` object. `mem-fs-editor` automatically setup the filename option so you can easily use partials.
+`options.transformOptions` replaced the old `tplOptions` parameter and is passed as ejs options. `mem-fs-editor` automatically setup the filename option so you can easily use partials.
 
-You can also optionally pass a `copyOptions` object (see [copy() documentation for more details](#copyfrom-to-options-context-templateoptions-)).
+You can also optionally pass a `options` object (see [copy() documentation for more details](#copyfrom-to-options)).
 
 Templates syntax looks like this:
 
@@ -122,13 +129,13 @@ Dir syntax looks like this:
 
 Refer to the [ejs documentation](http://ejs.co/) for more details.
 
-### `#copyTplAsync(from, to, [options], context[, templateOptions ])`
+### `#copyTplAsync(from, to, data[, options])`
 
 Async version of `copyTpl` that uses `copyAsync` instead of `copy`.
 
 Can be used for best performance. Reduces overheads.
 
-Same parameters of `copyTpl` (see [copyTpl() documentation for more details](#copyfrom-to-options-context-templateoptions-)).
+Same parameters of `copyTpl` (see [copyTpl() documentation for more details](#copytplfrom-to-data-options)).
 
 ### `#move(from, to, [options])`
 

package/dist/actions/append-tpl.d.ts

@@ -1,4 +1,5 @@
-import { Data, Options } from 'ejs';
+import ejs from 'ejs';
 import type { MemFsEditor } from '../index.js';
-import { AppendOptions } from './append.js';
-export default function appendTpl(this: MemFsEditor, to: string, contents: string | Buffer, context?: Data, tplSettings?: Options, options?: AppendOptions): void;
+export default function appendTpl(this: MemFsEditor, to: string, contents: string | Buffer, data?: ejs.Data, options?: NonNullable<Parameters<MemFsEditor['append']>[2]> & {
+    transformOptions?: ejs.Options;
+}): void;

package/dist/actions/append-tpl.js

@@ -1,4 +1,7 @@
-import { render } from '../util.js';
-export default function appendTpl(to, contents, context, tplSettings, options) {
-    this.append(to, render(contents.toString(), context, tplSettings), options);
+import ejs from 'ejs';
+export default function appendTpl(to, contents, data, options) {
+    if (options?.transformOptions?.async) {
+        throw new Error('Async EJS rendering is not supported');
+    }
+    this.append(to, ejs.render(contents.toString(), data, { ...options?.transformOptions, async: false }), options);
 }

package/dist/actions/append.d.ts

@@ -1,7 +1,6 @@
 import type { MemFsEditor } from '../index.js';
-export type AppendOptions = {
+export default function append(this: MemFsEditor, to: string, contents: string | Buffer, options?: {
     create?: boolean;
     trimEnd?: boolean;
     separator?: string;
-};
-export default function append(this: MemFsEditor, to: string, contents: string | Buffer, options?: AppendOptions): void;
+}): void;

package/dist/actions/append.js

@@ -1,20 +1,18 @@
 import { EOL } from 'os';
 export default function append(to, contents, options) {
-    options = {
+    const opts = {
+        create: false,
         trimEnd: true,
         separator: EOL,
         ...options,
     };
-    if (!this.exists(to) && options.create) {
-        this.write(to, contents);
-        return;
+    if (!this.exists(to) && !opts.create) {
+        throw new Error(`${to} doesn't exist`);
     }
-    let currentContents = this.read(to);
-    if (!currentContents) {
-        throw new Error(`Error appending to ${to}, file is empty.`);
+    let currentContent = this.read(to, { defaults: '' });
+    if (currentContent && opts.trimEnd) {
+        currentContent = currentContent.trimEnd();
     }
-    if (currentContents && options.trimEnd) {
-        currentContents = currentContents.replace(/\s+$/, '');
-    }
-    this.write(to, currentContents + options.separator + contents.toString());
+    const newContent = currentContent ? currentContent + opts.separator + contents.toString() : contents;
+    this.write(to, newContent);
 }

package/dist/actions/commit-file-async.d.ts

@@ -1,2 +1,2 @@
 import type { MemFsEditorFile } from '../index.js';
-export default function commitFileAsync<EditorFile extends MemFsEditorFile>(file: EditorFile): Promise<void>;
+export default function commitFileAsync(file: MemFsEditorFile): Promise<void>;

package/dist/actions/commit-file-async.js

@@ -23,16 +23,13 @@ async function write(file) {
     await fs.writeFile(file.path, file.contents, { mode: newMode });
     if (newMode !== undefined) {
         const { mode: existingMode } = await fs.stat(file.path);
+        /* c8 ignore next */
         // eslint-disable-next-line no-bitwise
         if ((existingMode & 0o777) !== (newMode & 0o777)) {
             await fs.chmod(file.path, newMode);
         }
     }
 }
-async function remove(file) {
-    const remove = fs.rm || fs.rmdir;
-    await remove(file.path, { recursive: true });
-}
 export default async function commitFileAsync(file) {
     if (isFileStateModified(file)) {
         setCommittedFile(file);
@@ -40,7 +37,7 @@ export default async function commitFileAsync(file) {
     }
     else if (isFileStateDeleted(file) && !isFileNew(file)) {
         setCommittedFile(file);
-        await remove(file);
+        await fs.rm(file.path, { recursive: true });
     }
     clearFileState(file);
 }

package/dist/actions/copy-async.d.ts

@@ -1,16 +1,32 @@
-import type { Data, Options } from 'ejs';
-import { type Options as GlobbyOptions } from 'globby';
+import { GlobOptions } from 'tinyglobby';
 import type { MemFsEditor } from '../index.js';
-import { AppendOptions } from './append.js';
-import { CopySingleOptions } from './copy.js';
-export type CopyAsyncOptions = CopySingleAsyncOptions & {
-    globOptions?: GlobbyOptions;
-    processDestinationPath?: (string: any) => string;
-    ignoreNoMatch?: boolean;
-};
-export declare function copyAsync(this: MemFsEditor, from: string | string[], to: string, options?: CopyAsyncOptions, context?: Data, tplSettings?: Options): Promise<void>;
-export type CopySingleAsyncOptions = AppendOptions & CopySingleOptions & {
+import type { Options as MultimatchOptions } from 'multimatch';
+type CopySingleAsyncOptions = Parameters<MemFsEditor['append']>[2] & {
     append?: boolean;
-    processFile?: (this: MemFsEditor, filepath: string) => string | Promise<string | Buffer>;
+    /**
+     * @experimental This API is experimental and may change without a major version bump.
+     *
+     * Transform both the file path and content during copy.
+     * @param destinationPath The destination file path
+     * @param sourcePath The source file path
+     * @param contents The file content as Buffer
+     * @returns Tuple of [new filepath, new content]
+     */
+    fileTransform?: (destinationPath: string, sourcePath: string, contents: Buffer) => [string, string | Buffer] | Promise<[string, string | Buffer]>;
+};
+type CopyAsyncOptions = CopySingleAsyncOptions & {
+    noGlob?: boolean;
+    /**
+     * Options for disk globbing.
+     * Glob options that should be compatible with minimatch results.
+     */
+    globOptions?: Pick<GlobOptions, 'caseSensitiveMatch' | 'cwd' | 'debug' | 'deep' | 'dot' | 'expandDirectories' | 'followSymbolicLinks'>;
+    /**
+     * Options for store files matching.
+     */
+    storeMatchOptions?: MultimatchOptions;
+    ignoreNoMatch?: boolean;
+    fromBasePath?: string;
 };
-export declare function _copySingleAsync(this: MemFsEditor, from: string, to: string, options?: CopySingleAsyncOptions): Promise<void>;
+export declare function copyAsync(this: MemFsEditor, from: string | string[], to: string, options?: CopyAsyncOptions): Promise<void>;
+export {};

package/dist/actions/copy-async.js

@@ -1,95 +1,115 @@
 import assert from 'assert';
 import fs from 'fs';
 import fsPromises from 'fs/promises';
-import path, { resolve } from 'path';
-import { globbySync, isDynamicPattern } from 'globby';
+import path from 'path';
+import createDebug from 'debug';
+import { glob, isDynamicPattern } from 'tinyglobby';
 import multimatch from 'multimatch';
-import { render, globify, getCommonPath } from '../util.js';
 import normalize from 'normalize-path';
 import File from 'vinyl';
-async function applyProcessingFileFunc(processFile, filename) {
-    const output = await Promise.resolve(processFile.call(this, filename));
-    return Buffer.isBuffer(output) ? output : Buffer.from(output);
-}
-function renderFilepath(filepath, context, tplSettings) {
-    if (!context) {
-        return filepath;
-    }
-    return render(filepath, context, tplSettings);
-}
-async function getOneFile(from) {
-    let oneFile;
-    if (typeof from === 'string') {
-        oneFile = from;
-    }
-    else {
-        return undefined;
-    }
-    const resolved = path.resolve(oneFile);
+import { resolveFromPaths, getCommonPath, globify, resolveGlobOptions } from '../util.js';
+import { writeInternal } from './write.js';
+const debug = createDebug('mem-fs-editor:copy-async');
+async function getOneFile(filepath) {
+    const resolved = path.resolve(filepath);
     try {
         if ((await fsPromises.stat(resolved)).isFile()) {
             return resolved;
         }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
-    catch (_) { }
+    catch (error) { }
     return undefined;
 }
-export async function copyAsync(from, to, options, context, tplSettings) {
+export async function copyAsync(from, to, options = {}) {
     to = path.resolve(to);
-    options = options || {};
-    const oneFile = await getOneFile(from);
-    if (oneFile) {
-        return this._copySingleAsync(oneFile, renderFilepath(to, context, tplSettings), options);
+    const { noGlob } = options;
+    const hasGlobOptions = Boolean(options.globOptions);
+    const hasMultimatchOptions = Boolean(options.storeMatchOptions);
+    assert(!noGlob || !hasGlobOptions, '`noGlob` and `globOptions` are mutually exclusive');
+    assert(!noGlob || !hasMultimatchOptions, '`noGlob` and `storeMatchOptions` are mutually exclusive');
+    if (typeof from === 'string') {
+        const oneFile = await getOneFile(from);
+        if (oneFile) {
+            return copySingleAsync(this, oneFile, to, options);
+        }
     }
-    const fromGlob = globify(from);
-    const globOptions = { ...options.globOptions, nodir: true };
-    const diskFiles = globbySync(fromGlob, globOptions).map((filepath) => path.resolve(filepath));
+    const { fromBasePath = getCommonPath(from) } = options;
+    const resolvedFromPaths = resolveFromPaths({ from, fromBasePath });
+    const hasDynamicPattern = resolvedFromPaths.some((f) => isDynamicPattern(normalize(f.from)));
+    const { preferFiles } = resolveGlobOptions({
+        noGlob,
+        hasDynamicPattern,
+        hasGlobOptions,
+    });
     const storeFiles = [];
-    this.store.each((file) => {
-        const normalizedFilepath = normalize(file.path);
-        // The store may have a glob path and when we try to copy it will fail because not real file
-        if (!isDynamicPattern(normalizedFilepath) &&
-            multimatch([normalizedFilepath], fromGlob).length !== 0 &&
-            !diskFiles.includes(file.path)) {
-            storeFiles.push(file.path);
+    const globResolved = [];
+    for (const resolvedFromPath of resolvedFromPaths) {
+        const { resolvedFrom } = resolvedFromPath;
+        if (this.store.existsInMemory(resolvedFrom)) {
+            storeFiles.push(resolvedFrom);
         }
-    });
+        else {
+            globResolved.push(resolvedFromPath);
+        }
+    }
+    let diskFiles = [];
+    if (globResolved.length > 0) {
+        const patterns = globResolved.map((file) => globify(file.from)).flat();
+        diskFiles = (await glob(patterns, { cwd: fromBasePath, ...options.globOptions, absolute: true, onlyFiles: true })).map((file) => path.resolve(file));
+        const normalizedStoreFilePaths = this.store
+            .all()
+            .map((file) => file.path)
+            .filter((filePath) => !diskFiles.includes(filePath))
+            .map((filePath) => normalize(filePath))
+            // The store may have a glob path and when we try to copy it will fail because not real file
+            .filter((filePath) => !isDynamicPattern(filePath));
+        multimatch(normalizedStoreFilePaths, patterns, options.storeMatchOptions).forEach((filePath) => {
+            storeFiles.push(path.resolve(filePath));
+        });
+    }
+    // Sanity checks: Makes sure we copy at least one file.
+    assert(options.ignoreNoMatch || diskFiles.length > 0 || storeFiles.length > 0, 'Trying to copy from a source that does not exist: ' + String(from));
+    // If `from` is an array, or if it contains any dynamic patterns, or if it doesn't exist, `to` must be a directory.
+    const treatToAsDir = Array.isArray(from) || !preferFiles || globResolved.length > 0;
     let generateDestination = () => to;
-    if (Array.isArray(from) || !this.exists(from) || isDynamicPattern(normalize(from))) {
+    if (treatToAsDir) {
         assert(!this.exists(to) || fs.statSync(to).isDirectory(), 'When copying multiple files, provide a directory as destination');
-        const processDestinationPath = options.processDestinationPath || ((path) => path);
-        const root = getCommonPath(from);
-        generateDestination = (filepath) => {
-            const toFile = path.relative(root, filepath);
-            return processDestinationPath(path.join(to, toFile));
-        };
+        generateDestination = (filepath) => path.join(to, path.relative(fromBasePath, filepath));
     }
-    // Sanity checks: Makes sure we copy at least one file.
-    assert(options.ignoreNoMatch || diskFiles.length > 0 || storeFiles.length > 0, 'Trying to copy from a source that does not exist: ' + from);
     await Promise.all([
-        ...diskFiles.map((file) => this._copySingleAsync(file, renderFilepath(generateDestination(file), context, tplSettings), options)),
-        ...storeFiles.map((file) => Promise.resolve(this._copySingle(file, renderFilepath(generateDestination(file), context, tplSettings), options))),
+        ...diskFiles.map((file) => copySingleAsync(this, file, generateDestination(file), options)),
+        ...storeFiles.map((file) => copySingleAsync(this, file, generateDestination(file), options)),
     ]);
 }
-export async function _copySingleAsync(from, to, options = {}) {
-    if (!options.processFile) {
-        return this._copySingle(from, to, options);
+const defaultFileTransform = (destPath, _sourcePath, contents) => [
+    destPath,
+    contents,
+];
+async function copySingleAsync(editor, from, to, options = {}) {
+    from = path.resolve(from);
+    debug('Copying %s to %s with %o', from, to, options);
+    const file = editor.store.get(from);
+    assert(file.contents, `Cannot copy empty file ${from}`);
+    const { fileTransform = defaultFileTransform } = options;
+    const transformPromise = fileTransform(path.resolve(to), from, file.contents);
+    let contents;
+    [to, contents] = await transformPromise;
+    if (options.append && editor.store.existsInMemory(to)) {
+        editor.append(to, contents, { create: true, ...options });
     }
-    from = resolve(from);
-    const contents = await applyProcessingFileFunc.call(this, options.processFile, from);
-    if (options.append) {
-        if (!this.store.existsInMemory) {
-            throw new Error('Current mem-fs is not compatible with append');
-        }
-        if (this.store.existsInMemory(to)) {
-            this.append(to, contents, { create: true, ...options });
-            return;
-        }
+    else if (File.isVinyl(file)) {
+        writeInternal(editor.store, Object.assign(file.clone({ contents: false, deep: false }), {
+            contents: Buffer.from(contents),
+            path: to,
+        }));
+    }
+    else {
+        writeInternal(editor.store, new File({
+            contents: Buffer.from(contents),
+            stat: file.stat,
+            path: to,
+            history: [file.path],
+        }));
     }
-    this._write(new File({
-        contents,
-        stat: await fsPromises.stat(from),
-        path: to,
-        history: [from],
-    }));
 }

package/dist/actions/copy-tpl-async.d.ts

@@ -1,4 +1,5 @@
 import type { MemFsEditor } from '../index.js';
-import { Data, Options } from 'ejs';
-import { CopyAsyncOptions } from './copy-async.js';
-export default function (this: MemFsEditor, from: string | string[], to: string, context?: Data, tplSettings?: Options, options?: CopyAsyncOptions): Promise<void>;
+import ejs from 'ejs';
+export default function (this: MemFsEditor, from: string | string[], to: string, data?: ejs.Data, options?: Omit<NonNullable<Parameters<MemFsEditor['copyAsync']>[2]>, 'fileTransform'> & {
+    transformOptions?: ejs.Options;
+}): Promise<void>;

package/dist/actions/copy-tpl-async.js

@@ -1,23 +1,24 @@
-import fs from 'fs/promises';
-import { isBinary, renderFile } from '../util.js';
-export default async function (from, to, context, tplSettings, options) {
-    context = context || {};
-    tplSettings = tplSettings || {};
+import { isBinary } from '../util.js';
+import ejs from 'ejs';
+export default async function (from, to, data = {}, options) {
     await this.copyAsync(from, to, {
-        processDestinationPath: (path) => path.replace(/.ejs$/, ''),
         ...options,
-        async processFile(filename) {
-            if (isBinary(filename, null)) {
-                return fs.readFile(filename);
-            }
-            return renderFile(filename, context, tplSettings);
+        async fileTransform(destinationPath, sourcePath, contents) {
+            const { transformOptions } = options ?? {};
+            const processedPath = await ejs.render(destinationPath, data, {
+                ...transformOptions,
+                cache: false, // Cache uses filename as key, which is not provided in this case.
+            });
+            const processedContent = isBinary(sourcePath, contents)
+                ? contents
+                : await ejs.render(contents.toString(), data, {
+                    // Setting filename by default allow including partials.
+                    filename: sourcePath,
+                    // Async option cannot be set to true because `include()` then also become async which change the behaviors of templates.
+                    // Users must pass async value in transformOptions if they want to use async features of ejs.
+                    ...transformOptions,
+                });
+            return [processedPath.replace(/.ejs$/, ''), processedContent];
         },
-        process: (contents, filename, destination) => this._processTpl({
-            contents,
-            filename,
-            destination,
-            context,
-            tplSettings,
-        }),
-    }, context, tplSettings);
+    });
 }

package/dist/actions/copy-tpl.d.ts

@@ -1,11 +1,5 @@
-import { Data, Options } from 'ejs';
+import ejs from 'ejs';
 import type { MemFsEditor } from '../index.js';
-import { CopySingleOptions } from './copy.js';
-export declare function _processTpl(this: MemFsEditor, { contents, filename, context, tplSettings, }: {
-    contents: string | Buffer;
-    filename: string;
-    destination?: string;
-    context?: Data;
-    tplSettings?: Options;
-}): string | Buffer;
-export declare function copyTpl(this: MemFsEditor, from: string | string[], to: string, context?: Data, tplSettings?: Options, options?: CopySingleOptions): void;
+export declare function copyTpl(this: MemFsEditor, from: string | string[], to: string, data?: ejs.Data, options?: Omit<NonNullable<Parameters<MemFsEditor['copy']>[2]>, 'fileTransform'> & {
+    transformOptions?: ejs.Options;
+}): void;

package/dist/actions/copy-tpl.js

@@ -1,21 +1,27 @@
-import { isBinary, render } from '../util.js';
-export function _processTpl({ contents, filename, context, tplSettings, }) {
-    if (isBinary(filename, contents)) {
-        return contents;
-    }
-    return render(contents.toString(), context, {
-        // Setting filename by default allow including partials.
-        filename,
-        cache: true,
-        ...tplSettings,
-    });
-}
-export function copyTpl(from, to, context, tplSettings, options) {
-    context = context || {};
-    tplSettings = tplSettings || {};
+import ejs from 'ejs';
+import { isBinary } from '../util.js';
+export function copyTpl(from, to, data = {}, options) {
     this.copy(from, to, {
-        processDestinationPath: (path) => path.replace(/.ejs$/, ''),
         ...options,
-        process: (contents, filename) => this._processTpl({ contents, filename, context, tplSettings }),
-    }, context, tplSettings);
+        fileTransform(destinationPath, sourcePath, contents) {
+            const { transformOptions } = options ?? {};
+            if (transformOptions?.async) {
+                throw new Error('Async EJS rendering is not supported');
+            }
+            const processedPath = ejs.render(destinationPath, data, {
+                ...transformOptions,
+                cache: false, // Cache uses filename as key, which is not provided in this case.
+                async: false,
+            });
+            const processedContent = isBinary(sourcePath, contents)
+                ? contents
+                : ejs.render(contents.toString(), data, {
+                    // Setting filename by default allow including partials.
+                    filename: sourcePath,
+                    ...transformOptions,
+                    async: false,
+                });
+            return [processedPath.replace(/.ejs$/, ''), processedContent];
+        },
+    });
 }

package/dist/actions/copy.d.ts

@@ -1,16 +1,33 @@
-import { type Options as GlobbyOptions } from 'globby';
-import { Data, Options } from 'ejs';
+import { type GlobOptions } from 'tinyglobby';
+import type { Options as MultimatchOptions } from 'multimatch';
 import type { MemFsEditor } from '../index.js';
-export type CopyOptions = CopySingleOptions & {
+type CopySingleOptions = {
+    append?: boolean;
+    /**
+     * @experimental This API is experimental and may change without a major version bump.
+     *
+     * Transform both the file path and content during copy.
+     * @param destinationPath The destination file path
+     * @param sourcePath The source file path
+     * @param contents The file content as Buffer
+     * @returns Tuple of [new filepath, new content]
+     */
+    fileTransform?: (destinationPath: string, sourcePath: string, contents: Buffer) => [string, string | Buffer];
+};
+type CopyOptions = CopySingleOptions & {
     noGlob?: boolean;
-    globOptions?: GlobbyOptions;
+    /**
+     * Options for disk globbing.
+     * Glob options that should be compatible with minimatch results.
+     */
+    globOptions?: Pick<GlobOptions, 'caseSensitiveMatch' | 'cwd' | 'debug' | 'deep' | 'dot' | 'expandDirectories' | 'followSymbolicLinks'>;
+    /**
+     * Options for store files matching.
+     */
+    storeMatchOptions?: MultimatchOptions;
     ignoreNoMatch?: boolean;
     fromBasePath?: string;
-    processDestinationPath?: (string: any) => string;
-};
-export declare function copy(this: MemFsEditor, from: string | string[], to: string, options?: CopyOptions, context?: Data, tplSettings?: Options): void;
-export type CopySingleOptions = {
-    append?: boolean;
-    process?: (contents: string | Buffer, filepath: string, destination: string) => string | Buffer;
 };
-export declare function _copySingle(this: MemFsEditor, from: string, to: string, options?: CopySingleOptions): void;
+export declare function copy(this: MemFsEditor, from: string | string[], to: string, options?: CopyOptions): void;
+export declare function copySingle(editor: MemFsEditor, from: string, to: string, options?: CopySingleOptions): void;
+export {};