mem-fs-editor 12.0.2 → 12.0.3

package/README.md

@@ -79,16 +79,30 @@ Delete a file or a directory.
 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.fileTransform` function (`fileTransform(destinationPath, sourcePath, contents)`) that transforms both the destination path and file contents. The function takes two arguments:
+Optionally, pass an `options.fileTransform` function that transforms both the destination path and file contents. The function receives a single object parameter with the following properties:
 
-- `destinationPath`: The resolved destination file path
-- `sourcePath`: The resolved source file path
+- `destinationPath`: The resolved destination file path (string)
+- `sourcePath`: The source file path (string)
 - `contents`: The file contents as a `Buffer`
+- `data`: Optional data passed via `options.transformData`
+- `options`: Optional options passed via `options.transformOptions`
 
-It should return a tuple `[newFilepath, newContents]` where:
+The function should return an object `{ path, contents }` where:
 
-- `newFilepath`: The transformed destination path (string)
-- `newContents`: The transformed file contents (Buffer)
+- `path`: The transformed destination path (string)
+- `contents`: The transformed file contents (string | Buffer)
+
+Example:
+
+```js
+fs.copy('source.txt', 'dest.txt', {
+  fileTransform({ destinationPath, sourcePath, contents, data, options }) {
+    const newPath = destinationPath.replace('.txt', '.md');
+    const newContents = contents.toString().toUpperCase();
+    return { path: newPath, contents: newContents };
+  },
+});
+```
 
 `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).
@@ -104,7 +118,7 @@ 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`
+Same parameters of `copy`. The `fileTransform` function can also return a `Promise<{ path: string; contents: string | Buffer }>` for async transformations.
 
 See [copy() documentation for more details](#copyfrom-to-options).
 

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

@@ -23,7 +23,6 @@ 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);

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

@@ -1,20 +1,37 @@
 import { GlobOptions } from 'tinyglobby';
 import type { MemFsEditor } from '../index.js';
 import type { Options as MultimatchOptions } from 'multimatch';
-type CopySingleAsyncOptions = Parameters<MemFsEditor['append']>[2] & {
+type CopySingleAsyncOptions<TransformData = any, TransformOptions = any> = Parameters<MemFsEditor['append']>[2] & {
     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]
+     * @param options The transform options
+     * @param options.destinationPath The destination file path
+     * @param options.sourcePath The source file path
+     * @param options.contents The file content as Buffer
+     * @param options.options The options passed to fileTransform
+     * @param options.data The data passed to fileTransform
+     * @returns An object containing the new file path and contents.
      */
-    fileTransform?: (destinationPath: string, sourcePath: string, contents: Buffer) => [string, string | Buffer] | Promise<[string, string | Buffer]>;
+    fileTransform?: (options: {
+        destinationPath: string;
+        sourcePath: string;
+        contents: Buffer;
+        data?: TransformData;
+        options?: TransformOptions;
+    }) => {
+        path: string;
+        contents: string | Buffer;
+    } | Promise<{
+        path: string;
+        contents: string | Buffer;
+    }>;
+    transformData?: TransformData;
+    transformOptions?: TransformOptions;
 };
-type CopyAsyncOptions = CopySingleAsyncOptions & {
+type CopyAsyncOptions<TransformData = any, TransformOptions = any> = CopySingleAsyncOptions<TransformData, TransformOptions> & {
     noGlob?: boolean;
     /**
      * Options for disk globbing.
@@ -28,5 +45,5 @@ type CopyAsyncOptions = CopySingleAsyncOptions & {
     ignoreNoMatch?: boolean;
     fromBasePath?: string;
 };
-export declare function copyAsync(this: MemFsEditor, from: string | string[], to: string, options?: CopyAsyncOptions): Promise<void>;
+export declare function copyAsync<const TransformData = any, const TransformOptions = any>(this: MemFsEditor, from: string | string[], to: string, options?: CopyAsyncOptions<TransformData, TransformOptions>): Promise<void>;
 export {};

package/dist/actions/copy-async.js

@@ -82,19 +82,25 @@ export async function copyAsync(from, to, options = {}) {
         ...storeFiles.map((file) => copySingleAsync(this, file, generateDestination(file), options)),
     ]);
 }
-const defaultFileTransform = (destPath, _sourcePath, contents) => [
-    destPath,
+const defaultFileTransform = ({ destinationPath, contents }) => ({
+    path: destinationPath,
     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);
+    const { fileTransform = defaultFileTransform, transformOptions, transformData } = options;
+    const transformPromise = fileTransform({
+        destinationPath: path.resolve(to),
+        sourcePath: from,
+        contents: file.contents,
+        options: transformOptions,
+        data: transformData,
+    });
     let contents;
-    [to, contents] = await transformPromise;
+    ({ path: to, contents } = await transformPromise);
     if (options.append && editor.store.existsInMemory(to)) {
         editor.append(to, contents, { create: true, ...options });
     }

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

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

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

@@ -1,12 +1,20 @@
 import { isBinary } from '../util.js';
 import ejs from 'ejs';
-export default async function (from, to, data = {}, options) {
+export default async function (from, to, data = {}, options, compatOptions) {
+    /* v8 ignore next -- @preserve */
+    if (compatOptions) {
+        // Backward compatibility.
+        options = {
+            ...compatOptions,
+            transformOptions: options,
+        };
+    }
     await this.copyAsync(from, to, {
         ...options,
-        async fileTransform(destinationPath, sourcePath, contents) {
-            const { transformOptions } = options ?? {};
-            const processedPath = await ejs.render(destinationPath, data, {
-                ...transformOptions,
+        transformData: data,
+        async fileTransform({ destinationPath, sourcePath, contents, data, options }) {
+            let processedPath = await ejs.render(destinationPath, data, {
+                ...options,
                 cache: false, // Cache uses filename as key, which is not provided in this case.
             });
             const processedContent = isBinary(sourcePath, contents)
@@ -16,9 +24,13 @@ export default async function (from, to, data = {}, options) {
                     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,
+                    ...options,
                 });
-            return [processedPath.replace(/.ejs$/, ''), processedContent];
+            if (!to.endsWith('.ejs')) {
+                // If the initial destination path ends with .ejs, the output is expected to be .ejs file, so we keep the extension. Remove .ejs extension for other cases.
+                processedPath = processedPath.replace(/.ejs$/, '');
+            }
+            return { path: processedPath, contents: processedContent };
         },
     });
 }

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

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

package/dist/actions/copy-tpl.js

@@ -1,15 +1,23 @@
 import ejs from 'ejs';
 import { isBinary } from '../util.js';
-export function copyTpl(from, to, data = {}, options) {
+export function copyTpl(from, to, data = {}, options, compatOptions) {
+    /* v8 ignore next -- @preserve */
+    if (compatOptions) {
+        // Backward compatibility.
+        options = {
+            ...compatOptions,
+            transformOptions: options,
+        };
+    }
     this.copy(from, to, {
         ...options,
-        fileTransform(destinationPath, sourcePath, contents) {
-            const { transformOptions } = options ?? {};
-            if (transformOptions?.async) {
+        transformData: data,
+        fileTransform({ destinationPath, sourcePath, contents, data, options }) {
+            if (options?.async) {
                 throw new Error('Async EJS rendering is not supported');
             }
-            const processedPath = ejs.render(destinationPath, data, {
-                ...transformOptions,
+            let processedPath = ejs.render(destinationPath, data, {
+                ...options,
                 cache: false, // Cache uses filename as key, which is not provided in this case.
                 async: false,
             });
@@ -18,10 +26,14 @@ export function copyTpl(from, to, data = {}, options) {
                 : ejs.render(contents.toString(), data, {
                     // Setting filename by default allow including partials.
                     filename: sourcePath,
-                    ...transformOptions,
+                    ...options,
                     async: false,
                 });
-            return [processedPath.replace(/.ejs$/, ''), processedContent];
+            if (!to.endsWith('.ejs')) {
+                // If the initial destination path ends with .ejs, the output is expected to be .ejs file, so we keep the extension. Remove .ejs extension for other cases.
+                processedPath = processedPath.replace(/.ejs$/, '');
+            }
+            return { path: processedPath, contents: processedContent };
         },
     });
 }

package/dist/actions/copy.d.ts

@@ -1,20 +1,34 @@
 import { type GlobOptions } from 'tinyglobby';
 import type { Options as MultimatchOptions } from 'multimatch';
 import type { MemFsEditor } from '../index.js';
-type CopySingleOptions = {
+type CopySingleOptions<TransformData = any, TransformOptions = any> = {
     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]
+     * @param options The transform options
+     * @param options.destinationPath The destination file path
+     * @param options.sourcePath The source file path
+     * @param options.contents The file content as Buffer
+     * @param options.options The options passed to fileTransform
+     * @param options.data The data passed to fileTransform
+     * @returns An object containing the new file path and contents.
      */
-    fileTransform?: (destinationPath: string, sourcePath: string, contents: Buffer) => [string, string | Buffer];
+    fileTransform?: (options: {
+        destinationPath: string;
+        sourcePath: string;
+        contents: Buffer;
+        data?: TransformData;
+        options?: TransformOptions;
+    }) => {
+        path: string;
+        contents: string | Buffer;
+    };
+    transformData?: TransformData;
+    transformOptions?: TransformOptions;
 };
-type CopyOptions = CopySingleOptions & {
+type CopyOptions<TransformData = any, TransformOptions = any> = CopySingleOptions<TransformData, TransformOptions> & {
     noGlob?: boolean;
     /**
      * Options for disk globbing.
@@ -28,6 +42,6 @@ type CopyOptions = CopySingleOptions & {
     ignoreNoMatch?: boolean;
     fromBasePath?: string;
 };
-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 declare function copy<const TransformData = any, const TransformOptions = any>(this: MemFsEditor, from: string | string[], to: string, options?: CopyOptions<TransformData, TransformOptions>): void;
+export declare function copySingle<const TransformData = any, const TransformOptions = any>(editor: MemFsEditor, from: string, to: string, options?: CopySingleOptions<TransformData, TransformOptions>): void;
 export {};

package/dist/actions/copy.js

@@ -74,20 +74,27 @@ export function copy(from, to, options = {}) {
         copySingle(this, file.resolvedFrom, toFile, options);
     });
 }
-const defaultFileTransform = (destPath, _srcPath, contents) => [
-    destPath,
+const defaultFileTransform = ({ destinationPath, contents }) => ({
+    path: destinationPath,
     contents,
-];
+});
 export function copySingle(editor, from, to, options = {}) {
     assert(editor.exists(from), 'Trying to copy from a source that does not exist: ' + from);
     debug('Copying %s to %s with %o', from, to, options);
     const file = editor.store.get(from);
     let contents;
+    /* v8 ignore next -- @preserve should not happen */
     if (!file.contents) {
         throw new Error(`Cannot copy empty file ${from}`);
     }
-    const { fileTransform = defaultFileTransform } = options;
-    [to, contents] = fileTransform(path.resolve(to), from, file.contents);
+    const { fileTransform = defaultFileTransform, transformOptions, transformData } = options;
+    ({ path: to, contents } = fileTransform({
+        destinationPath: path.resolve(to),
+        sourcePath: from,
+        contents: file.contents,
+        options: transformOptions,
+        data: transformData,
+    }));
     if (options.append && editor.store.existsInMemory(to)) {
         editor.append(to, contents, { create: true, ...options });
     }

package/dist/actions/write.js

@@ -3,7 +3,6 @@ import { resolve } from 'path';
 import { isFileStateModified, setModifiedFileState } from '../state.js';
 import File from 'vinyl';
 export const isMemFsEditorFileEqual = (a, b) => {
-    /* c8 ignore next */
     if (a.stat?.mode !== b.stat?.mode) {
         return false;
     }

package/dist/util.js

@@ -33,7 +33,7 @@ export function globify(inputFilePath) {
     }
     if (!fs.existsSync(filePath)) {
         // The target of a pattern who's not a glob and doesn't match an existing
-        // entity on the disk is ambiguous. As such, match both files and directories.
+        // Entity on the disk is ambiguous. As such, match both files and directories.
         return [filePath, normalize(path.join(filePath, '**'))];
     }
     const fsStats = fs.statSync(filePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mem-fs-editor",
-  "version": "12.0.2",
+  "version": "12.0.3",
   "description": "File edition helpers working on top of mem-fs",
   "repository": "SBoudrias/mem-fs-editor",
   "license": "MIT",