json-to-fs-structure 1.2.13 → 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/{test → dist/test}/__snapshots__/index.test.js.snap

@@ -1,7 +1,7 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
 exports[`json-to-fs-structure jsonToFsWithFunction should not do anything with ignored words like meta 1`] = `
-Array [
+[
   "./testArrayField5",
   "./testArrayField5/somedir",
   "./testArrayField5/anotherdir",
@@ -12,7 +12,7 @@ Array [
 `;
 
 exports[`json-to-fs-structure jsonToFsWithFunction should not go below the stop word andanotherdir provided 1`] = `
-Array [
+[
   "./testArrayField5",
   "./testArrayField5/somedir",
   "./testArrayField5/anotherdir",
@@ -20,7 +20,7 @@ Array [
 `;
 
 exports[`json-to-fs-structure jsonToFsWithFunction should produce a nested deep complex directory structure and execute the procedure on everything 1`] = `
-Array [
+[
   "./testArrayField5",
   "./testArrayField5/somedir",
   "./testArrayField5/anotherdir",
@@ -34,7 +34,7 @@ Array [
 `;
 
 exports[`json-to-fs-structure jsonToFsWithLeafFunction should produce a nested deep complex directory structure and execute the procedure on leaves 1`] = `
-Array [
+[
   "./testArrayField5/somedir",
   "./testArrayField5/anotherdir",
   "./testArrayField5/andanotherdir/interiorone/interiortwo/interiorthree/interiorfour",
@@ -43,7 +43,7 @@ Array [
 `;
 
 exports[`json-to-fs-structure jsonToFsWithLeafFunction should produce a nested directory not past a stop word with a leaf function 1`] = `
-Array [
+[
   "./testArrayField5/somedir",
   "./testArrayField5/anotherdir",
   "./testArrayField5/andanotherdir/",
@@ -51,7 +51,7 @@ Array [
 `;
 
 exports[`json-to-fs-structure jsonToFsWithNonLeafFunction should produce a nested deep complex directory structure and execute the procedure on non leaves 1`] = `
-Array [
+[
   "./testArrayField5",
   "./testArrayField5/andanotherdir",
   "./testArrayField5/andanotherdir/interiorone",

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

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