json-to-fs-structure 1.3.0 → 2.0.0

package/README.md

@@ -1,11 +1,11 @@
 # json-to-fs-structure
-Clean and simple JavaScript project for turning JSON objects into directory structures.
+Clean and simple TypeScript project for turning JSON objects into directory structures.
 
 # Development
 For development, clone into this repository and to install run:
-`npm install`
+`yarn install`
 To test run:
-`npm test`
+`yarn test`
 
 # Usage
 To use this node module, install it like so:

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+export type LeafProcedure<T = unknown> = (filePath: string, accumulator: T, value: unknown, property: string) => void;
+export type NonLeafProcedure<T = unknown> = (filePath: string, accumulator: T, value: unknown, property: string) => T | void;
+export type Procedure<T = unknown> = (filePath: string, accumulator: T, value: unknown, property: string) => T | void;
+export interface ExecutorObject<T> {
+    leafProcedure?: LeafProcedure<T>;
+    nonLeafProcedure?: NonLeafProcedure<T>;
+    procedure?: Procedure<T>;
+    accumulator?: T;
+}
+export interface JsonToFsStructureOptions {
+    jsonObject: unknown;
+    filePath?: string;
+    callback?: () => void;
+    stopWord?: string | string[];
+    spaceReplace?: string;
+    ignoredWords?: string[];
+}
+export interface JsonToFsWithLeafFunctionOptions<T = unknown> {
+    jsonObject: unknown;
+    leafProcedure?: LeafProcedure<T>;
+    context?: T;
+    filePath?: string;
+    callback?: () => void;
+    stopWord?: string | string[];
+    spaceReplace?: string;
+    ignoredWords?: string[];
+}
+export interface JsonToFsWithNonLeafFunctionOptions<T = unknown> {
+    jsonObject: unknown;
+    nonLeafProcedure?: NonLeafProcedure<T>;
+    context?: T;
+    filePath?: string;
+    callback?: () => void;
+    stopWord?: string | string[];
+    spaceReplace?: string;
+    ignoredWords?: string[];
+}
+export interface JsonToFsWithFunctionOptions<T = unknown> {
+    jsonObject: unknown;
+    procedure?: Procedure<T>;
+    context?: T;
+    filePath?: string;
+    callback?: () => void;
+    stopWord?: string | string[];
+    spaceReplace?: string;
+    ignoredWords?: string[];
+}
+export declare function jsonToFsStructure({ jsonObject, filePath, callback, stopWord, spaceReplace, ignoredWords, }: JsonToFsStructureOptions): Promise<void>;
+export declare function jsonToFsWithLeafFunction<T = unknown>({ jsonObject, leafProcedure, context, filePath, callback, stopWord, spaceReplace, ignoredWords, }: JsonToFsWithLeafFunctionOptions<T>): Promise<void>;
+export declare function jsonToFsWithNonLeafFunction<T = unknown>({ jsonObject, nonLeafProcedure, context, filePath, callback, stopWord, spaceReplace, ignoredWords, }: JsonToFsWithNonLeafFunctionOptions<T>): Promise<void>;
+export declare function jsonToFsWithFunction<T = unknown>({ jsonObject, procedure, context, filePath, callback, stopWord, spaceReplace, ignoredWords, }: JsonToFsWithFunctionOptions<T>): Promise<void>;

package/dist/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonToFsStructure = jsonToFsStructure;
+exports.jsonToFsWithLeafFunction = jsonToFsWithLeafFunction;
+exports.jsonToFsWithNonLeafFunction = jsonToFsWithNonLeafFunction;
+exports.jsonToFsWithFunction = jsonToFsWithFunction;
+const fs = __importStar(require("fs"));
+const path_1 = require("path");
+const isLeaf = (testNode) => testNode !== null &&
+    testNode !== undefined &&
+    typeof testNode === "object" &&
+    testNode.constructor === Object &&
+    Object.keys(testNode).length === 0;
+const isEqualOrIsInArray = (property, stopWord) => !!stopWord &&
+    (property === stopWord ||
+        (Array.isArray(stopWord) && stopWord.indexOf(property) > -1));
+const cloneAccumulator = (acc) => {
+    return Object.assign({}, acc);
+};
+const levelPropertiesToDirectories = (obj, filePath, stopWord, ignoredWords, spaceReplace, executorObject = {}) => {
+    if (obj && (typeof obj === "string" || obj instanceof String)) {
+        return [];
+    }
+    const { leafProcedure, nonLeafProcedure, procedure } = executorObject;
+    let { accumulator } = executorObject;
+    let promiseArray = [];
+    let fields = [];
+    if (obj && Array.isArray(obj)) {
+        obj.forEach((arrayObject) => {
+            promiseArray = promiseArray.concat(levelPropertiesToDirectories(arrayObject, filePath, stopWord, ignoredWords, spaceReplace, {
+                leafProcedure,
+                nonLeafProcedure,
+                procedure,
+                accumulator,
+            }));
+        });
+    }
+    else if (obj && typeof obj === "object") {
+        fields = Object.keys(obj);
+    }
+    fields.forEach((property) => {
+        if (!isEqualOrIsInArray(property, stopWord) &&
+            ignoredWords.indexOf(property) === -1) {
+            const newPath = spaceReplace
+                ? `${filePath}${path_1.sep}${property.replace(/ /g, spaceReplace)}`
+                : `${filePath}${path_1.sep}${property}`;
+            let accumulatorCopy = cloneAccumulator(accumulator);
+            try {
+                fs.mkdirSync(newPath);
+            }
+            catch (e) { }
+            const objRecord = obj;
+            const value = objRecord[property];
+            if (value && typeof value === "object" && Object.keys(value).length > 0) {
+                if (nonLeafProcedure) {
+                    accumulatorCopy = nonLeafProcedure(newPath, cloneAccumulator(accumulator), value, property);
+                }
+                if (procedure) {
+                    accumulatorCopy = procedure(newPath, cloneAccumulator(accumulator), value, property);
+                }
+                promiseArray = promiseArray.concat(levelPropertiesToDirectories(value, newPath, stopWord, ignoredWords, spaceReplace, {
+                    leafProcedure,
+                    nonLeafProcedure,
+                    procedure,
+                    accumulator: accumulatorCopy,
+                }));
+            }
+            else {
+                if (leafProcedure && isLeaf(value)) {
+                    leafProcedure(newPath, cloneAccumulator(accumulator), value, property);
+                }
+                if (procedure && isLeaf(value)) {
+                    accumulatorCopy = procedure(newPath, cloneAccumulator(accumulator), value, property);
+                }
+            }
+        }
+        else if (ignoredWords.indexOf(property) === -1) {
+            if (leafProcedure) {
+                const objRecord = obj;
+                const value = objRecord[property];
+                leafProcedure(`${filePath}${path_1.sep}`, cloneAccumulator(accumulator), value, property);
+            }
+        }
+    });
+    return promiseArray;
+};
+function jsonToFsStructure({ jsonObject, filePath = ".", callback = () => { }, stopWord, spaceReplace, ignoredWords = [], }) {
+    return Promise.all(levelPropertiesToDirectories(jsonObject, filePath, stopWord, ignoredWords, spaceReplace)).then(callback);
+}
+function jsonToFsWithLeafFunction({ jsonObject, leafProcedure = () => { }, context = {}, filePath = ".", callback = () => { }, stopWord, spaceReplace, ignoredWords = [], }) {
+    return Promise.all(levelPropertiesToDirectories(jsonObject, filePath, stopWord, ignoredWords, spaceReplace, {
+        leafProcedure,
+        accumulator: context,
+    })).then(callback);
+}
+function jsonToFsWithNonLeafFunction({ jsonObject, nonLeafProcedure = () => { }, context = {}, filePath = ".", callback = () => { }, stopWord, spaceReplace, ignoredWords = [], }) {
+    return Promise.all(levelPropertiesToDirectories(jsonObject, filePath, stopWord, ignoredWords, spaceReplace, {
+        nonLeafProcedure,
+        accumulator: context,
+    })).then(callback);
+}
+function jsonToFsWithFunction({ jsonObject, procedure = () => { }, context = {}, filePath = ".", callback = () => { }, stopWord, spaceReplace, ignoredWords = [], }) {
+    return Promise.all(levelPropertiesToDirectories(jsonObject, filePath, stopWord, ignoredWords, spaceReplace, {
+        procedure,
+        accumulator: context,
+    })).then(callback);
+}

package/dist/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/index.test.js

@@ -0,0 +1,424 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const index_1 = require("../index");
+describe("json-to-fs-structure", () => {
+    describe("jsonToFsStructure", () => {
+        it("should produce a simple directory with a first layer object", (done) => {
+            const options = {
+                jsonObject: {
+                    testDirectoryField: {},
+                },
+                filePath: ".",
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testDirectoryField").size, 4096);
+                    fs.rmdirSync("testDirectoryField");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsStructure)(options);
+        });
+        it("should produce a simple directory with a first layer object with siblings", (done) => {
+            const options = {
+                jsonObject: {
+                    testDirectoryField0: {},
+                    testDirectoryField1: {},
+                    testDirectoryField2: {},
+                },
+                filePath: ".",
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testDirectoryField0").size, 4096);
+                    assert.strictEqual(fs.statSync("testDirectoryField1").size, 4096);
+                    assert.strictEqual(fs.statSync("testDirectoryField2").size, 4096);
+                    fs.rmdirSync("testDirectoryField0");
+                    fs.rmdirSync("testDirectoryField1");
+                    fs.rmdirSync("testDirectoryField2");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsStructure)(options);
+        });
+        it("should produce a nested directory structure", (done) => {
+            const options = {
+                jsonObject: {
+                    testDirectoryField3: { innerTestField: {} },
+                },
+                filePath: ".",
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testDirectoryField3/innerTestField").size, 4096);
+                    fs.rmdirSync("testDirectoryField3/innerTestField");
+                    fs.rmdirSync("testDirectoryField3");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsStructure)(options);
+        });
+        it("should produce a nested directory structure when there is an array of strings", (done) => {
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        { andanotherdir: {} },
+                    ],
+                },
+                filePath: ".",
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsStructure)(options);
+        });
+        it("should produce a nested deep complex directory structure", (done) => {
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        {
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                filePath: ".",
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo")
+                        .size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsStructure)(options);
+        });
+    });
+    describe("jsonToFsWithLeafFunction", () => {
+        it("should produce a nested deep complex directory structure and execute the procedure on leaves", (done) => {
+            const endpoints = [];
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        {
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                filePath: ".",
+                leafProcedure: (filePath) => {
+                    endpoints.push(filePath);
+                },
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo")
+                        .size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsWithLeafFunction)(options);
+            expect(endpoints).toMatchSnapshot();
+        });
+        it("should produce a nested directory not past a stop word with a leaf function", (done) => {
+            const endpoints = [];
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        {
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                leafProcedure: (filePath) => {
+                    endpoints.push(filePath);
+                },
+                filePath: ".",
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+                stopWord: "interiorone",
+            };
+            (0, index_1.jsonToFsWithLeafFunction)(options);
+            expect(endpoints).toMatchSnapshot();
+        });
+    });
+    describe("jsonToFsWithNonLeafFunction", () => {
+        it("should produce a nested deep complex directory structure and execute the procedure on non leaves", (done) => {
+            const endpoints = [];
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        {
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                nonLeafProcedure: (filePath) => {
+                    endpoints.push(filePath);
+                },
+                filePath: ".",
+                context: {},
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo")
+                        .size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsWithNonLeafFunction)(options);
+            expect(endpoints).toMatchSnapshot();
+        });
+    });
+    describe("jsonToFsWithFunction", () => {
+        it("should produce a nested deep complex directory structure and execute the procedure on everything", (done) => {
+            const endpoints = [];
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        {
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                procedure: (filePath) => {
+                    endpoints.push(filePath);
+                },
+                filePath: ".",
+                context: {},
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo")
+                        .size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfive");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+            };
+            (0, index_1.jsonToFsWithFunction)(options);
+            expect(endpoints).toMatchSnapshot();
+        });
+        it("should not go below the stop word andanotherdir provided", (done) => {
+            const endpoints = [];
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: {} },
+                        { anotherdir: {} },
+                        {
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                procedure: (filePath) => {
+                    endpoints.push(filePath);
+                },
+                filePath: ".",
+                context: {},
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+                stopWord: "andanotherdir",
+            };
+            (0, index_1.jsonToFsWithFunction)(options);
+            expect(endpoints).toMatchSnapshot();
+        });
+        it("should not do anything with ignored words like meta", (done) => {
+            const endpoints = [];
+            const options = {
+                jsonObject: {
+                    testArrayField5: [
+                        { somedir: { meta: {}, apple: {} } },
+                        { anotherdir: {} },
+                        {
+                            meta: { somethingweird: {} },
+                            andanotherdir: {
+                                interiorone: {
+                                    interiortwo: {
+                                        apple: { dontdonothing: {} },
+                                        interiorthree: [{ interiorfour: {} }, { interiorfive: {} }],
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                procedure: (filePath) => {
+                    endpoints.push(filePath);
+                },
+                filePath: ".",
+                context: {},
+                callback: () => {
+                    assert.strictEqual(fs.statSync("testArrayField5/somedir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/anotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone").size, 4096);
+                    assert.strictEqual(fs.statSync("testArrayField5/andanotherdir/interiorone/interiortwo")
+                        .size, 4096);
+                    fs.rmdirSync("testArrayField5/somedir");
+                    fs.rmdirSync("testArrayField5/anotherdir");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone/interiortwo");
+                    fs.rmdirSync("testArrayField5/andanotherdir/interiorone");
+                    fs.rmdirSync("testArrayField5/andanotherdir");
+                    fs.rmdirSync("testArrayField5");
+                    done();
+                },
+                ignoredWords: ["meta", "apple"],
+                stopWord: "interiorthree",
+            };
+            (0, index_1.jsonToFsWithFunction)(options);
+            expect(endpoints).toMatchSnapshot();
+        });
+    });
+});