test-filesystem 1.0.0

package/dist/mjs/functions/circularObject.mjs

@@ -0,0 +1,33 @@
+/**
+ * Multilayered node tree-like structure with parent references
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object|Array>}
+ */
+export const circularObject = {
+  name: 'root',
+  parent: null,
+  body: null,
+  head: null,
+  children: []
+}
+circularObject.children = [
+  { name: 'body', parent: null, children: [] },
+  { name: 'head', parent: null, children: [] }
+]
+circularObject.body = circularObject.children[0]
+circularObject.head = circularObject.children[1]
+circularObject.body.parent = circularObject
+circularObject.head.parent = circularObject
+circularObject.body.children = [
+  { name: 'body child one', parent: null, children: [] },
+  { name: 'body child two', parent: null, children: [] }
+]
+circularObject.body.children[0].parent = circularObject.body
+circularObject.body.children[1].parent = circularObject.body
+circularObject.head.children = [
+  { name: 'head child one', parent: null, children: [] },
+  { name: 'head child two', parent: null, children: [] }
+]
+circularObject.head.children[0].parent = circularObject.head
+circularObject.head.children[1].parent = circularObject.head
+export default circularObject

package/dist/mjs/functions/countMatches.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Simple way to count string occurrences for testing.
+ * @function
+ * @memberOf module:test-fs
+ * @param {string} content
+ * @param {string} search
+ * @returns {number}
+ */
+export declare const countMatches: (content: string, search: string) => number;
+export default countMatches;

package/dist/mjs/functions/countMatches.min.mjs

@@ -0,0 +1 @@
+export const countMatches=(t,e)=>t.split(e).length-1;export default countMatches;

package/dist/mjs/functions/countMatches.mjs

@@ -0,0 +1,10 @@
+/**
+ * Simple way to count string occurrences for testing.
+ * @function
+ * @memberOf module:test-fs
+ * @param {string} content
+ * @param {string} search
+ * @returns {number}
+ */
+export const countMatches = (content, search) => content.split(search).length - 1
+export default countMatches

package/dist/mjs/functions/deepReferenceObject.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sample object with deep references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Object>}
+ */
+export declare const deepReferenceObject: {
+    object1: {
+        name: string;
+        object2: {
+            age: number;
+            array1: Array<string>;
+        };
+        array2: Array<number>;
+    };
+    title: string;
+    item: number;
+};
+export default deepReferenceObject;

package/dist/mjs/functions/deepReferenceObject.min.mjs

@@ -0,0 +1 @@
+export const deepReferenceObject={object1:{name:"someName",object2:{age:12,array1:["someString","anotherString"]},array2:[89,32]},title:"Some Title",item:45};export default deepReferenceObject;

package/dist/mjs/functions/deepReferenceObject.mjs

@@ -0,0 +1,24 @@
+/**
+ * Sample object with deep references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Object>}
+ */
+export const deepReferenceObject = {
+  object1: {
+    name: 'someName',
+    object2: {
+      age: 12,
+      array1: [
+        'someString',
+        'anotherString'
+      ]
+    },
+    array2: [
+      89,
+      32
+    ]
+  },
+  title: 'Some Title',
+  item: 45
+}
+export default deepReferenceObject

package/dist/mjs/functions/domItem.d.ts

@@ -0,0 +1,24 @@
+export type jsonDomItem = {
+    name?: string;
+    attributes?: {
+        className?: string;
+        style?: {};
+    };
+    axis?: 'x' | 'y' | 'z';
+    parent?: jsonDomItem | null;
+    children?: Array<jsonDomItem> | [];
+    element?: Node | {} | null;
+    eventListeners?: {};
+    hasShip?: boolean;
+    isHit?: boolean;
+    parentItem?: {} | null;
+    point?: {};
+    tagName?: string;
+};
+/**
+ * Sample of domItem child with nested child and optional details
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+export declare const domItem: Array<jsonDomItem>;
+export default domItem;

package/dist/mjs/functions/domItem.min.mjs

@@ -0,0 +1 @@
+export const domItem=[{attributes:{className:"row",style:{}},axis:"y",children:[{attributes:{style:{}},axis:"x",children:[],element:{},eventListeners:{},hasShip:!1,isHit:!1,parentItem:{},point:{},tagName:"div"}],element:null,eventListeners:{},parentItem:{},tagName:"div"}];export default domItem;

package/dist/mjs/functions/domItem.mjs

@@ -0,0 +1,30 @@
+/**
+ * Sample of domItem child with nested child and optional details
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+export const domItem = [
+  {
+    attributes: { className: 'row', style: {} },
+    axis: 'y',
+    children: [
+      {
+        attributes: { style: {} },
+        axis: 'x',
+        children: [],
+        element: {},
+        eventListeners: {},
+        hasShip: false,
+        isHit: false,
+        parentItem: {},
+        point: {},
+        tagName: 'div'
+      }
+    ],
+    element: null,
+    eventListeners: {},
+    parentItem: {},
+    tagName: 'div'
+  }
+]
+export default domItem

package/dist/mjs/functions/jsonDom.d.ts

@@ -0,0 +1,8 @@
+import { jsonDomItem } from './domItem';
+/**
+ * Sample of jsonDom object containing an empty nested array and objects
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+export declare const jsonDom: jsonDomItem;
+export default jsonDom;

package/dist/mjs/functions/jsonDom.min.mjs

@@ -0,0 +1 @@
+export const jsonDom={tagName:"div",attributes:{style:{},className:"column"},element:null,eventListeners:{},parentItem:{},children:[],axis:"x"};export default jsonDom;

package/dist/mjs/functions/jsonDom.mjs

@@ -0,0 +1,15 @@
+/**
+ * Sample of jsonDom object containing an empty nested array and objects
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Array|Object>}
+ */
+export const jsonDom = {
+  tagName: 'div',
+  attributes: { style: {}, className: 'column' },
+  element: null,
+  eventListeners: {},
+  parentItem: {},
+  children: [],
+  axis: 'x'
+}
+export default jsonDom

package/dist/mjs/functions/linkedList.d.ts

@@ -0,0 +1,12 @@
+export type linker = {
+    name: string;
+    prev: linker | null;
+    next: linker | null;
+};
+/**
+ * Sample LinkedList for testing circular references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object>}
+ */
+export declare const linkedList: linker;
+export default linkedList;

package/dist/mjs/functions/linkedList.min.mjs

@@ -0,0 +1 @@
+export const linkedList={name:"one",prev:null,next:null};linkedList.next={name:"two",prev:linkedList,next:null},linkedList.next.next={name:"three",prev:linkedList.next,next:null};export default linkedList;

package/dist/mjs/functions/linkedList.mjs

@@ -0,0 +1,9 @@
+/**
+ * Sample LinkedList for testing circular references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object>}
+ */
+export const linkedList = { name: 'one', prev: null, next: null }
+linkedList.next = { name: 'two', prev: linkedList, next: null }
+linkedList.next.next = { name: 'three', prev: linkedList.next, next: null }
+export default linkedList

package/dist/mjs/functions/logObject.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Log out an object in a nicely formatted way.
+ * @function
+ * @memberOf module:test-fs
+ * @param {Object} object
+ * @param {string} [label=logging]
+ * @param {string} [outputType=log]
+ * @returns {string|undefined}
+ */
+export declare const logObject: (object: any, label?: string, outputType?: 'debug' | 'error' | 'log' | 'string' | 'warn') => string | void;
+export default logObject;

package/dist/mjs/functions/logObject.min.mjs

@@ -0,0 +1 @@
+export const logObject=(e,t="logging",n="log")=>{const o="string"===n?(e,t)=>`'${e}' | `+JSON.stringify(t):console[n];return"undefined"==typeof require||"string"===n?o(t,e):o(t,require("util").inspect(e,!1,null,!0))};export default logObject;

package/dist/mjs/functions/logObject.mjs

@@ -0,0 +1,17 @@
+/**
+ * Log out an object in a nicely formatted way.
+ * @function
+ * @memberOf module:test-fs
+ * @param {Object} object
+ * @param {string} [label=logging]
+ * @param {string} [outputType=log]
+ * @returns {string|undefined}
+ */
+export const logObject = (object, label = 'logging', outputType = 'log') => {
+  const logger = outputType === 'string' ? (label, object) => `'${label}' | ` + JSON.stringify(object) : console[outputType]
+  if (typeof require === 'undefined' || outputType === 'string') {
+    return logger(label, object)
+  }
+  return logger(label, require('util').inspect(object, false, null, true))
+}
+export default logObject

package/dist/mjs/functions/multiReferenceObject.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sample of an object containing multiple references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Object>}
+ */
+export declare const multiReferenceObject: {
+    object1: {
+        name: string;
+    };
+    object2: {
+        age: number;
+    };
+    array1: Array<string>;
+    array2: Array<number>;
+    title: string;
+    item: number;
+};
+export default multiReferenceObject;

package/dist/mjs/functions/multiReferenceObject.min.mjs

@@ -0,0 +1 @@
+export const multiReferenceObject={object1:{name:"someName"},object2:{age:12},array1:["someString","anotherString"],array2:[89,32],title:"Some Title",item:45};export default multiReferenceObject;

package/dist/mjs/functions/multiReferenceObject.mjs

@@ -0,0 +1,24 @@
+/**
+ * Sample of an object containing multiple references.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|number|Object>}
+ */
+export const multiReferenceObject = {
+  object1: {
+    name: 'someName'
+  },
+  object2: {
+    age: 12
+  },
+  array1: [
+    'someString',
+    'anotherString'
+  ],
+  array2: [
+    89,
+    32
+  ],
+  title: 'Some Title',
+  item: 45
+}
+export default multiReferenceObject

package/dist/mjs/functions/nodeTree.d.ts

@@ -0,0 +1,12 @@
+export type treeLinker = {
+    name: string;
+    parent: treeLinker | null;
+    children: Array<treeLinker> | [];
+};
+/**
+ * Sample NodeTree for testing circular references and arrays.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object|Array>}
+ */
+export declare const nodeTree: treeLinker;
+export default nodeTree;

package/dist/mjs/functions/nodeTree.min.mjs

@@ -0,0 +1 @@
+export const nodeTree={name:"one",parent:null,children:[]};nodeTree.children[0]={name:"child one",parent:nodeTree,children:[]},nodeTree.children[1]={name:"child two",parent:nodeTree,children:[]},nodeTree.children[0].children[0]={name:"grandchild one",parent:nodeTree.children[0],children:[]};export default nodeTree;

package/dist/mjs/functions/nodeTree.mjs

@@ -0,0 +1,10 @@
+/**
+ * Sample NodeTree for testing circular references and arrays.
+ * @memberOf module:test-fs
+ * @type {Object.<string, string|Object|Array>}
+ */
+export const nodeTree = { name: 'one', parent: null, children: [] }
+nodeTree.children[0] = { name: 'child one', parent: nodeTree, children: [] }
+nodeTree.children[1] = { name: 'child two', parent: nodeTree, children: [] }
+nodeTree.children[0].children[0] = { name: 'grandchild one', parent: nodeTree.children[0], children: [] }
+export default nodeTree

package/dist/mjs/functions/removeDirectory.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Return a promise to be completed once the specified directory is deleted.
+ * @function
+ * @memberOf module:test-fs
+ * @param {string} dirPath
+ * @returns {Promise<*>}
+ */
+export declare const removeDirectory: (dirPath: string) => Promise<any>;
+export default removeDirectory;

package/dist/mjs/functions/removeDirectory.min.mjs

@@ -0,0 +1 @@
+import{access,constants,rm}from"fs";export const removeDirectory=e=>new Promise(((r,o)=>access(e,constants.F_OK,(s=>s?r(e):rm(e,{recursive:!0},(s=>s?o(s):r(e)))))));export default removeDirectory;

package/dist/mjs/functions/removeDirectory.mjs

@@ -0,0 +1,12 @@
+import { access, constants, rm } from 'fs'
+/**
+ * Return a promise to be completed once the specified directory is deleted.
+ * @function
+ * @memberOf module:test-fs
+ * @param {string} dirPath
+ * @returns {Promise<*>}
+ */
+export const removeDirectory = (dirPath) => new Promise((resolve, reject) => access(dirPath, constants.F_OK, (removed) => removed
+  ? resolve(dirPath)
+  : rm(dirPath, { recursive: true }, (error) => error ? reject(error) : resolve(dirPath))))
+export default removeDirectory

package/dist/mjs/functions/setUp.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In the Jest.afterEach function call this one to clean up and remove the temp directory.
+ * @function
+ * @memberOf module:test-fs
+ * @returns {Promise<*>}
+ */
+export declare const afterEach: () => Promise<any>;
+/**
+ * Ensure that the del has completed, recursively attempt to delete and recreate
+ * @function
+ * @memberOf module:test-fs
+ * @param {boolean} [exists=true]
+ * @returns {Promise<*|void>}
+ */
+export declare const createTempDir: (exists?: boolean) => Promise<any | void>;
+/**
+ * In the Jest.beforeEach function call this one to set up the temp directory.
+ * @function
+ * @memberOf module:test-fs
+ * @returns {Promise<*|void>}
+ */
+export declare const beforeEach: () => Promise<any | void>;
+export declare const setDefaults: (dirPath?: string) => void;
+export declare const setUp: {
+    afterEach: () => Promise<any>;
+    beforeEach: () => Promise<any | void>;
+    createTempDir: (exists?: boolean) => Promise<any | void>;
+    setDefaults: (dirPath?: string) => void;
+};
+export default setUp;

package/dist/mjs/functions/setUp.min.mjs

@@ -0,0 +1 @@
+var __awaiter=this&&this.__awaiter||function(e,t,r,c){return new(r||(r=Promise))((function(o,i){function a(e){try{s(c.next(e))}catch(e){i(e)}}function n(e){try{s(c.throw(e))}catch(e){i(e)}}function s(e){var t;e.done?o(e.value):(t=e.value,t instanceof r?t:new r((function(e){e(t)}))).then(a,n)}s((c=c.apply(e,t||[])).next())}))};import{existsSync,mkdirSync}from"fs";import removeDirectory from"./removeDirectory";let tempDir="test-temp/",srcPath=`${tempDir}src`;export const afterEach=()=>removeDirectory(tempDir);export const createTempDir=(e=!0)=>__awaiter(void 0,void 0,void 0,(function*(){return e?removeDirectory(tempDir).then((e=>createTempDir(existsSync(e)))).catch((e=>console.error("Error: ",e))):mkdirSync(srcPath,{recursive:!0})}));export const beforeEach=()=>createTempDir();export const setDefaults=(e=null)=>{e&&(tempDir=e,srcPath=`${tempDir}src`)};export const setUp={afterEach:afterEach,beforeEach:beforeEach,createTempDir:createTempDir,setDefaults:setDefaults};export default setUp;

package/dist/mjs/functions/setUp.mjs

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync } from 'fs'
+// Import the configurations and override some of them to direct to the temp directory.
+import removeDirectory from './removeDirectory'
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+  function adopt (value) { return value instanceof P ? value : new P(function (resolve) { resolve(value) }) }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled (value) { try { step(generator.next(value)) } catch (e) { reject(e) } }
+    function rejected (value) { try { step(generator.throw(value)) } catch (e) { reject(e) } }
+    function step (result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected) }
+    step((generator = generator.apply(thisArg, _arguments || [])).next())
+  })
+}
+let tempDir = 'test-temp/'
+let srcPath = `${tempDir}src`
+/**
+ * In the Jest.afterEach function call this one to clean up and remove the temp directory.
+ * @function
+ * @memberOf module:test-fs
+ * @returns {Promise<*>}
+ */
+export const afterEach = () => removeDirectory(tempDir)
+/**
+ * Ensure that the del has completed, recursively attempt to delete and recreate
+ * @function
+ * @memberOf module:test-fs
+ * @param {boolean} [exists=true]
+ * @returns {Promise<*|void>}
+ */
+export const createTempDir = (exists = true) => __awaiter(void 0, void 0, void 0, function * () {
+  if (exists) {
+    return removeDirectory(tempDir)
+      .then(removedDir => createTempDir(existsSync(removedDir)))
+      .catch(error => console.error('Error: ', error))
+  }
+  return mkdirSync(srcPath, { recursive: true })
+})
+/**
+ * In the Jest.beforeEach function call this one to set up the temp directory.
+ * @function
+ * @memberOf module:test-fs
+ * @returns {Promise<*|void>}
+ */
+export const beforeEach = () => createTempDir()
+export const setDefaults = (dirPath = null) => {
+  if (dirPath) {
+    tempDir = dirPath
+    srcPath = `${tempDir}src`
+  }
+}
+export const setUp = {
+  afterEach,
+  beforeEach,
+  createTempDir,
+  setDefaults
+}
+export default setUp

package/dist/mjs/main.d.ts

@@ -0,0 +1,93 @@
+/**
+ * An assortment of objects that can be used in tests and some functions to help debug and write tests.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module test-fs
+ */
+export declare let testFs: {
+    circularObject: {
+        name: string;
+        parent: null;
+        body: import("./functions/domItem").jsonDomItem;
+        head: import("./functions/domItem").jsonDomItem;
+        children: [] | import("./functions/domItem").jsonDomItem[];
+    };
+    countMatches: (content: string, search: string) => number;
+    deepReferenceObject: {
+        object1: {
+            name: string;
+            object2: {
+                age: number;
+                array1: string[];
+            };
+            array2: number[];
+        };
+        title: string;
+        item: number;
+    };
+    domItem: import("./functions/domItem").jsonDomItem[];
+    jsonDom: import("./functions/domItem").jsonDomItem;
+    linkedList: import("./functions/linkedList").linker;
+    logObject: (object: any, label?: string, outputType?: "string" | "error" | "debug" | "log" | "warn") => string | void;
+    multiReferenceObject: {
+        object1: {
+            name: string;
+        };
+        object2: {
+            age: number;
+        };
+        array1: string[];
+        array2: number[];
+        title: string;
+        item: number;
+    };
+    nodeTree: import("./functions/nodeTree").treeLinker;
+    removeDirectory: (dirPath: string) => Promise<any>;
+    setUp: {
+        afterEach: () => Promise<any>;
+        beforeEach: () => Promise<any>;
+        createTempDir: (exists?: boolean) => Promise<any>;
+        setDefaults: (dirPath?: string) => void;
+    };
+};
+export default testFs;
+export declare let testFsBrowser: {
+    circularObject: {
+        name: string;
+        parent: null;
+        body: import("./functions/domItem").jsonDomItem;
+        head: import("./functions/domItem").jsonDomItem;
+        children: [] | import("./functions/domItem").jsonDomItem[];
+    };
+    countMatches: (content: string, search: string) => number;
+    deepReferenceObject: {
+        object1: {
+            name: string;
+            object2: {
+                age: number;
+                array1: string[];
+            };
+            array2: number[];
+        };
+        title: string;
+        item: number;
+    };
+    domItem: import("./functions/domItem").jsonDomItem[];
+    jsonDom: import("./functions/domItem").jsonDomItem;
+    linkedList: import("./functions/linkedList").linker;
+    logObject: (object: any, label?: string, outputType?: "string" | "error" | "debug" | "log" | "warn") => string | void;
+    multiReferenceObject: {
+        object1: {
+            name: string;
+        };
+        object2: {
+            age: number;
+        };
+        array1: string[];
+        array2: number[];
+        title: string;
+        item: number;
+    };
+    nodeTree: import("./functions/nodeTree").treeLinker;
+};

package/dist/mjs/main.min.mjs

@@ -0,0 +1 @@
+import circularObject from"./functions/circularObject";import countMatches from"./functions/countMatches";import deepReferenceObject from"./functions/deepReferenceObject";import domItem from"./functions/domItem";import jsonDom from"./functions/jsonDom";import linkedList from"./functions/linkedList";import logObject from"./functions/logObject";import multiReferenceObject from"./functions/multiReferenceObject";import nodeTree from"./functions/nodeTree";import removeDirectory from"./functions/removeDirectory";import setUp from"./functions/setUp";export let testFs={circularObject:circularObject,countMatches:countMatches,deepReferenceObject:deepReferenceObject,domItem:domItem,jsonDom:jsonDom,linkedList:linkedList,logObject:logObject,multiReferenceObject:multiReferenceObject,nodeTree:nodeTree,removeDirectory:removeDirectory,setUp:setUp};export default testFs;export let testFsBrowser={circularObject:circularObject,countMatches:countMatches,deepReferenceObject:deepReferenceObject,domItem:domItem,jsonDom:jsonDom,linkedList:linkedList,logObject:logObject,multiReferenceObject:multiReferenceObject,nodeTree:nodeTree};this?this.testFs=testFsBrowser:"undefined"!=typeof window&&(window.testFs=testFsBrowser);

package/dist/mjs/main.mjs

@@ -0,0 +1,50 @@
+/**
+ * An assortment of objects that can be used in tests and some functions to help debug and write tests.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module test-fs
+ */
+import circularObject from './functions/circularObject'
+import countMatches from './functions/countMatches'
+import deepReferenceObject from './functions/deepReferenceObject'
+import domItem from './functions/domItem'
+import jsonDom from './functions/jsonDom'
+import linkedList from './functions/linkedList'
+import logObject from './functions/logObject'
+import multiReferenceObject from './functions/multiReferenceObject'
+import nodeTree from './functions/nodeTree'
+import removeDirectory from './functions/removeDirectory'
+import setUp from './functions/setUp'
+export const testFs = {
+  circularObject,
+  countMatches,
+  deepReferenceObject,
+  domItem,
+  jsonDom,
+  linkedList,
+  logObject,
+  multiReferenceObject,
+  nodeTree,
+  removeDirectory,
+  setUp
+}
+export default testFs
+export const testFsBrowser = {
+  circularObject,
+  countMatches,
+  deepReferenceObject,
+  domItem,
+  jsonDom,
+  linkedList,
+  logObject,
+  multiReferenceObject,
+  nodeTree
+}
+if (this) {
+  // @ts-ignore
+  this.testFs = testFsBrowser
+} else if (typeof window !== 'undefined') {
+  // @ts-ignore
+  window.testFs = testFsBrowser
+}