mem-fs-editor 9.7.0 → 10.0.1

package/README.md

@@ -9,10 +9,10 @@ File edition helpers working on top of [mem-fs](https://github.com/SBoudrias/mem
 ## Usage
 
 ```js
-import memFs from 'mem-fs';
+import { create as createMemFs } from 'mem-fs';
 import editor from 'mem-fs-editor';
 
-const store = memFs.create();
+const store = createMemFs();
 const fs = editor.create(store);
 
 fs.write('somefile.js', 'var a = 1;');

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

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Data, Options } 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;

package/dist/actions/append-tpl.js

@@ -0,0 +1,4 @@
+import { render } from '../util.js';
+export default function appendTpl(to, contents, context, tplSettings, options) {
+    this.append(to, render(contents.toString(), context, tplSettings), options);
+}

package/dist/actions/append.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { MemFsEditor } from '../index.js';
+export type AppendOptions = {
+    create?: boolean;
+    trimEnd?: boolean;
+    separator?: string;
+};
+export default function append(this: MemFsEditor, to: string, contents: string | Buffer, options?: AppendOptions): void;

package/dist/actions/append.js

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

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

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

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

@@ -0,0 +1,50 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { clearFileState, isFileStateModified, isFileStateDeleted, setCommittedFile } from '../state.js';
+async function write(file) {
+    if (!file.contents) {
+        throw new Error(`${file.path} cannot write an empty file`);
+    }
+    const dir = path.dirname(file.path);
+    try {
+        if (!(await fs.stat(dir)).isDirectory()) {
+            throw new Error(`${file.path} is not a directory`);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        else {
+            throw error;
+        }
+    }
+    const newMode = file.stat?.mode;
+    await fs.writeFile(file.path, file.contents, { mode: newMode });
+    if (newMode !== undefined) {
+        const { mode: existingMode } = await fs.stat(file.path);
+        // 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) {
+    const existingFile = this.store.get(file.path);
+    if (!existingFile || existingFile !== file) {
+        this.store.add(file);
+    }
+    if (isFileStateModified(file)) {
+        setCommittedFile(file);
+        await write(file);
+    }
+    else if (isFileStateDeleted(file)) {
+        setCommittedFile(file);
+        await remove(file);
+    }
+    clearFileState(file);
+}

package/dist/actions/commit.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PipelineSource } from 'stream';
+import type { MemFsEditor, MemFsEditorFile } from '../index.js';
+declare function commit<EditorFile extends MemFsEditorFile>(this: MemFsEditor<EditorFile>, stream?: PipelineSource<any>): any;
+declare function commit<EditorFile extends MemFsEditorFile>(this: MemFsEditor<EditorFile>, filters?: any[], stream?: PipelineSource<any>): any;
+export default commit;

package/dist/actions/commit.js

@@ -0,0 +1,15 @@
+import { promisify } from 'util';
+import { pipeline as _pipeline } from 'stream';
+const pipeline = promisify(_pipeline);
+import { createPendingFilesPassthrough, createCommitTransform } from '../transform.js';
+import { isFilePending } from '../state.js';
+function commit(filters, stream) {
+    if (!Array.isArray(filters)) {
+        stream = filters;
+        filters = [];
+    }
+    stream = stream ?? this.store.stream({ filter: (file) => isFilePending(file) });
+    filters = filters ?? [];
+    return pipeline(stream, createPendingFilesPassthrough(), ...filters, createCommitTransform(this));
+}
+export default commit;

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

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type Options as GlobbyOptions } from 'globby';
+import type { MemFsEditor } from '../index.js';
+import { AppendOptions } from './append.js';
+import { Data, Options } from 'ejs';
+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 & {
+    append?: boolean;
+    processFile?: (this: MemFsEditor, filepath: string) => string | Promise<string | Buffer>;
+};
+export declare function _copySingleAsync(this: MemFsEditor, from: string, to: string, options?: CopySingleAsyncOptions): Promise<void>;

package/dist/actions/copy-async.js

@@ -0,0 +1,88 @@
+import assert from 'assert';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import { globbySync, isDynamicPattern } from 'globby';
+import multimatch from 'multimatch';
+import { render, globify, getCommonPath } from '../util.js';
+import normalize from 'normalize-path';
+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);
+    try {
+        if ((await fsPromises.stat(resolved)).isFile()) {
+            return resolved;
+        }
+    }
+    catch (_) { }
+    return undefined;
+}
+export async function copyAsync(from, to, options, context, tplSettings) {
+    to = path.resolve(to);
+    options = options || {};
+    const oneFile = await getOneFile(from);
+    if (oneFile) {
+        return this._copySingleAsync(oneFile, renderFilepath(to, context, tplSettings), options);
+    }
+    const fromGlob = globify(from);
+    const globOptions = { ...options.globOptions, nodir: true };
+    const diskFiles = globbySync(fromGlob, globOptions).map((filepath) => path.resolve(filepath));
+    const storeFiles = [];
+    this.store.each((file) => {
+        // The store may have a glob path and when we try to copy it will fail because not real file
+        if (!isDynamicPattern(normalize(file.path)) &&
+            multimatch([file.path], fromGlob).length !== 0 &&
+            !diskFiles.includes(file.path)) {
+            storeFiles.push(file.path);
+        }
+    });
+    let generateDestination = () => to;
+    if (Array.isArray(from) || !this.exists(from) || isDynamicPattern(normalize(from))) {
+        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));
+        };
+    }
+    // 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))),
+    ]);
+}
+export async function _copySingleAsync(from, to, options = {}) {
+    if (!options.processFile) {
+        return this._copySingle(from, to, options);
+    }
+    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;
+        }
+    }
+    const stat = await fsPromises.stat(from);
+    this.write(to, contents, stat);
+}

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

@@ -0,0 +1,4 @@
+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>;

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

@@ -0,0 +1,23 @@
+import fs from 'fs/promises';
+import { isBinary, renderFile } from '../util.js';
+export default async function (from, to, context, tplSettings, options) {
+    context = context || {};
+    tplSettings = tplSettings || {};
+    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);
+        },
+        process: (contents, filename, destination) => this._processTpl({
+            contents,
+            filename,
+            destination,
+            context,
+            tplSettings,
+        }),
+    }, context, tplSettings);
+}

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

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Data, Options } 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;

package/dist/actions/copy-tpl.js

@@ -0,0 +1,21 @@
+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 || {};
+    this.copy(from, to, {
+        processDestinationPath: (path) => path.replace(/.ejs$/, ''),
+        ...options,
+        process: (contents, filename) => this._processTpl({ contents, filename, context, tplSettings }),
+    }, context, tplSettings);
+}

package/dist/actions/copy.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type Options as GlobbyOptions } from 'globby';
+import { Data, Options } from 'ejs';
+import type { MemFsEditor } from '../index.js';
+export type CopyOptions = CopySingleOptions & {
+    noGlob?: boolean;
+    globOptions?: GlobbyOptions;
+    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;

package/dist/actions/copy.js

@@ -0,0 +1,75 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { globbySync, isDynamicPattern } from 'globby';
+import multimatch from 'multimatch';
+import normalize from 'normalize-path';
+import { getCommonPath, globify, render } from '../util.js';
+function applyProcessingFunc(process, contents, filename, destination) {
+    const output = process(contents, filename, destination);
+    return Buffer.isBuffer(output) ? output : Buffer.from(output);
+}
+export function copy(from, to, options, context, tplSettings) {
+    to = path.resolve(to);
+    options = options || {};
+    let files = [];
+    if (options.noGlob) {
+        const fromFiles = Array.isArray(from) ? from : [from];
+        files = fromFiles.filter((filepath) => this.store.existsInMemory(filepath) || fs.existsSync(filepath));
+    }
+    else {
+        const fromGlob = globify(from);
+        const globOptions = { ...options.globOptions, nodir: true };
+        const diskFiles = globbySync(fromGlob, globOptions).map((file) => path.resolve(file));
+        const storeFiles = [];
+        this.store.each((file) => {
+            // The store may have a glob path and when we try to copy it will fail because not real file
+            if (!diskFiles.includes(file.path) &&
+                !isDynamicPattern(normalize(file.path)) &&
+                multimatch([file.path], fromGlob).length !== 0) {
+                storeFiles.push(file.path);
+            }
+        });
+        files = diskFiles.concat(storeFiles);
+    }
+    let generateDestination = () => to;
+    if (Array.isArray(from) || !this.exists(from) || (isDynamicPattern(normalize(from)) && !options.noGlob)) {
+        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 = options.fromBasePath || getCommonPath(from);
+        generateDestination = (filepath) => {
+            const toFile = path.relative(root, filepath);
+            return processDestinationPath(path.join(to, toFile));
+        };
+    }
+    // Sanity checks: Makes sure we copy at least one file.
+    assert(options.ignoreNoMatch || files.length > 0, 'Trying to copy from a source that does not exist: ' + from);
+    files.forEach((file) => {
+        let toFile = generateDestination(file);
+        if (context) {
+            toFile = render(toFile, context, { ...tplSettings, cache: false });
+        }
+        this._copySingle(file, toFile, options);
+    });
+}
+export function _copySingle(from, to, options = {}) {
+    assert(this.exists(from), 'Trying to copy from a source that does not exist: ' + from);
+    const file = this.store.get(from);
+    let { contents } = file;
+    if (!contents) {
+        throw new Error(`Cannot copy empty file ${from}`);
+    }
+    if (options.process) {
+        contents = applyProcessingFunc(options.process, contents, file.path, to);
+    }
+    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;
+        }
+    }
+    this.write(to, contents, file.stat);
+}

package/dist/actions/delete.d.ts

@@ -0,0 +1,5 @@
+import { type Options as GlobbyOptions } from 'globby';
+import type { MemFsEditor } from '../index.js';
+export default function deleteAction(this: MemFsEditor, paths: string | string[], options?: {
+    globOptions?: GlobbyOptions;
+}): void;

package/dist/actions/delete.js

@@ -0,0 +1,29 @@
+import path from 'path';
+import { globbySync } from 'globby';
+import multimatch from 'multimatch';
+import { setDeletedFileState } from '../state.js';
+import { globify } from '../util.js';
+function deleteFile(path, store) {
+    const file = store.get(path);
+    setDeletedFileState(file);
+    file.contents = null;
+    store.add(file);
+}
+export default function deleteAction(paths, options) {
+    if (!Array.isArray(paths)) {
+        paths = [paths];
+    }
+    paths = paths.map((filePath) => path.resolve(filePath));
+    paths = globify(paths);
+    options = options || {};
+    const globOptions = options.globOptions || {};
+    const files = globbySync(paths, globOptions);
+    files.forEach((file) => {
+        deleteFile(file, this.store);
+    });
+    this.store.each((file) => {
+        if (multimatch([file.path], paths).length !== 0) {
+            deleteFile(file.path, this.store);
+        }
+    });
+}

package/dist/actions/dump.d.ts

@@ -0,0 +1,7 @@
+import type { MemFsEditor, MemFsEditorFile } from '../index.js';
+export type MemFsEditorFileDump = {
+    contents: string | null;
+    state?: string;
+    stateCleared?: string;
+};
+export default function <EditorFile extends MemFsEditorFile>(this: MemFsEditor<EditorFile>, cwd?: string, filter?: string | ((file: EditorFile, cwd: string) => boolean)): any;

package/dist/actions/dump.js

@@ -0,0 +1,26 @@
+import path from 'path';
+import normalize from 'normalize-path';
+import { minimatch } from 'minimatch';
+import { hasClearedState, hasState } from '../state.js';
+const defaultDumpFilter = (file) => hasClearedState(file) || hasState(file);
+export default function (cwd = process.cwd(), filter) {
+    const filterFile = typeof filter === 'string'
+        ? (file) => defaultDumpFilter(file) && minimatch(file.path, filter)
+        : defaultDumpFilter;
+    return Object.fromEntries(this.store
+        .all()
+        .filter((file) => filterFile(file, cwd))
+        .map((file) => {
+        const filePath = normalize(cwd ? path.relative(cwd, file.path) : file.path);
+        const fileDump = {
+            contents: file.contents?.toString() ?? null,
+        };
+        if (file.state) {
+            fileDump.state = file.state;
+        }
+        if (file.stateCleared) {
+            fileDump.stateCleared = file.stateCleared;
+        }
+        return [filePath, fileDump];
+    }));
+}

package/dist/actions/exists.d.ts

@@ -0,0 +1,2 @@
+import type { MemFsEditor } from '../index.js';
+export default function exist(this: MemFsEditor, filepath: string): boolean;

package/dist/actions/exists.js

@@ -0,0 +1,4 @@
+export default function exist(filepath) {
+    const file = this.store.get(filepath);
+    return file.contents !== null;
+}

package/dist/actions/extend-json.d.ts

@@ -0,0 +1,2 @@
+import type { MemFsEditor } from '../index.js';
+export default function extendJSON(this: MemFsEditor, filepath: string, contents?: Record<string, unknown>, replacer?: ((this: any, key: string, value: any) => any) | (number | string)[] | null, space?: string | number): void;

package/dist/actions/extend-json.js

@@ -0,0 +1,6 @@
+import extend from 'deep-extend';
+export default function extendJSON(filepath, contents, replacer, space) {
+    const originalContent = this.readJSON(filepath, {});
+    const newContent = extend({}, originalContent, contents);
+    this.writeJSON(filepath, newContent, replacer, space);
+}

package/dist/actions/move.d.ts

@@ -0,0 +1,3 @@
+import type { MemFsEditor } from '../index.js';
+import { CopyOptions } from './copy.js';
+export default function (this: MemFsEditor, from: string, to: string, options?: CopyOptions): void;

package/dist/actions/move.js

@@ -0,0 +1,4 @@
+export default function (from, to, options) {
+    this.copy(from, to, options);
+    this.delete(from, options);
+}

package/dist/actions/read-json.d.ts

@@ -0,0 +1,2 @@
+import type { MemFsEditor } from '../index.js';
+export default function readJSON(this: MemFsEditor, filepath: string, defaults?: any): any;

package/dist/actions/read-json.js

@@ -0,0 +1,17 @@
+export default function readJSON(filepath, defaults) {
+    if (this.exists(filepath)) {
+        try {
+            const content = this.read(filepath);
+            if (!content) {
+                throw new Error(`${filepath} has no content`);
+            }
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error('Could not parse JSON in file: ' + filepath + '. Detail: ' + error.message);
+        }
+    }
+    else {
+        return defaults;
+    }
+}

package/dist/actions/read.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { MemFsEditor } from '../index.js';
+declare function read(this: MemFsEditor, filepath: string, options?: {
+    raw?: boolean;
+    defaults?: string | null;
+}): string | null;
+declare function read(this: MemFsEditor, filepath: string, options: {
+    raw?: true;
+    defaults?: Buffer | null;
+}): Buffer | string | null;
+export default read;

package/dist/actions/read.js

@@ -0,0 +1,12 @@
+function read(filepath, options) {
+    options = options || { raw: false };
+    const file = this.store.get(filepath);
+    if (file.contents === null) {
+        if ('defaults' in options) {
+            return options.defaults ?? null;
+        }
+        throw new Error(filepath + " doesn't exist");
+    }
+    return options.raw ? file.contents : file.contents?.toString() || null;
+}
+export default read;

package/dist/actions/write-json.d.ts

@@ -0,0 +1,2 @@
+import type { MemFsEditor } from '../index.js';
+export default function writeJSON(this: MemFsEditor, filepath: string, contents: any, replacer?: ((this: any, key: string, value: any) => any) | (number | string)[] | null, space?: string | number): string;

package/dist/actions/write-json.js

@@ -0,0 +1,11 @@
+const DEFAULT_INDENTATION = 2;
+export default function writeJSON(filepath, contents, replacer, space) {
+    let jsonStr;
+    if (typeof replacer === 'function') {
+        jsonStr = JSON.stringify(contents, replacer, space || DEFAULT_INDENTATION) + '\n';
+    }
+    else {
+        jsonStr = JSON.stringify(contents, replacer, space || DEFAULT_INDENTATION) + '\n';
+    }
+    return this.write(filepath, jsonStr);
+}

package/dist/actions/write.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { MemFsEditor } from '../index.js';
+export default function write(this: MemFsEditor, filepath: string, contents: string | Buffer, stat?: {
+    mode?: number;
+} | null): string;

package/dist/actions/write.js

@@ -0,0 +1,17 @@
+import assert from 'assert';
+import { isFileStateModified, setModifiedFileState } from '../state.js';
+export default function write(filepath, contents, stat) {
+    assert(typeof contents === 'string' || Buffer.isBuffer(contents), 'Expected `contents` to be a String or a Buffer');
+    const file = this.store.get(filepath);
+    const newContents = Buffer.isBuffer(contents) ? contents : Buffer.from(contents);
+    if (!isFileStateModified(file) ||
+        !Buffer.isBuffer(file.contents) ||
+        !newContents.equals(file.contents) ||
+        (stat && file.stat !== stat)) {
+        setModifiedFileState(file);
+        file.contents = newContents;
+        file.stat = stat ?? null;
+        this.store.add(file);
+    }
+    return file.contents.toString();
+}