jostraca 0.15.1 → 0.16.0

package/README.md

@@ -4,16 +4,5 @@
 A code and project generator that uses React-style components.
 
 
-## Options
-
-<!--START-OPTIONS-->
-
-* __folder__: `string`
-* __meta__: `any`
-* __exclude__: `boolean`
-* __fs__: `any`
-<!--END-OPTIONS-->
-
-
 
 

package/dist/build/BuildContext.d.ts

@@ -0,0 +1,37 @@
+import { Node, FST, Audit } from '../types';
+import { FileHandler } from './FileHandler';
+import { BuildMeta } from './BuildMeta';
+import type { Existing } from '../jostraca';
+declare class BuildContext {
+    fs: () => FST;
+    now: () => number;
+    bmeta: BuildMeta;
+    fh: FileHandler;
+    audit: Audit;
+    when: number;
+    vol: any;
+    folder: string;
+    current: {
+        project: {
+            node: Node;
+        };
+        folder: {
+            node: Node;
+            parent: string;
+            path: string[];
+        };
+        file: Node;
+        content: any;
+    };
+    log: {
+        exclude: string[];
+        last: number;
+    };
+    dfolder?: string;
+    constructor(folder: string, existing: Existing, processing: {
+        duplicate: boolean;
+    }, fs: () => FST, now: () => number);
+    addmeta(file: string, meta: any): void;
+    duplicateFolder(): string;
+}
+export { BuildContext };

package/dist/build/BuildContext.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildContext = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const FileHandler_1 = require("./FileHandler");
+const BuildMeta_1 = require("./BuildMeta");
+const CN = 'BuildContext:';
+// TODO: rename meta folder to build, move into build folder
+class BuildContext {
+    constructor(folder, existing, processing, fs, now) {
+        this.fs = fs;
+        this.now = now;
+        if (!this.fs().existsSync) {
+            throw new Error(CN + ' Invalid file system provider: ' + this.fs());
+        }
+        this.audit = [];
+        this.when = now();
+        this.folder = folder;
+        this.current = {
+            project: {
+                node: emptyNode(),
+            },
+            folder: {
+                node: emptyNode(),
+                parent: folder,
+                path: [],
+            },
+            // TODO: should be file.node
+            file: emptyNode(),
+            content: undefined,
+        };
+        this.log = { exclude: [], last: -1 };
+        this.fh = new FileHandler_1.FileHandler(this, existing, processing.duplicate);
+        this.bmeta = new BuildMeta_1.BuildMeta(this.fh);
+    }
+    addmeta(file, meta) {
+        this.bmeta.add(file, meta);
+    }
+    duplicateFolder() {
+        if (null == this.dfolder) {
+            this.dfolder =
+                node_path_1.default.normalize(node_path_1.default.join(this.folder, this.bmeta.next.foldername, 'generated'));
+        }
+        return this.dfolder;
+    }
+}
+exports.BuildContext = BuildContext;
+function emptyNode() {
+    return { kind: 'none', path: [], meta: {}, content: [] };
+}
+//# sourceMappingURL=BuildContext.js.map

package/dist/build/BuildContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuildContext.js","sourceRoot":"","sources":["../../src/build/BuildContext.ts"],"names":[],"mappings":";;;;;;AACA,0DAA4B;AAS5B,+CAEsB;AAEtB,2CAEoB;AAapB,MAAM,EAAE,GAAG,eAAe,CAAA;AAG1B,4DAA4D;AAC5D,MAAM,YAAY;IA6BhB,YACE,MAAc,EACd,QAAkB,EAClB,UAEC,EACD,EAAa,EACb,GAAiB;QAGjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;QACZ,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QAEd,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,EAAE,GAAG,iCAAiC,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC,CAAA;QACrE,CAAC;QAED,IAAI,CAAC,KAAK,GAAG,EAAE,CAAA;QACf,IAAI,CAAC,IAAI,GAAG,GAAG,EAAE,CAAA;QAEjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,OAAO,GAAG;YACb,OAAO,EAAE;gBACP,IAAI,EAAE,SAAS,EAAE;aAClB;YACD,MAAM,EAAE;gBACN,IAAI,EAAE,SAAS,EAAE;gBACjB,MAAM,EAAE,MAAM;gBACd,IAAI,EAAE,EAAE;aACT;YACD,4BAA4B;YAC5B,IAAI,EAAE,SAAS,EAAE;YACjB,OAAO,EAAE,SAAS;SACnB,CAAA;QACD,IAAI,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAA;QAEpC,IAAI,CAAC,EAAE,GAAG,IAAI,yBAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC,CAAA;QAC/D,IAAI,CAAC,KAAK,GAAG,IAAI,qBAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IACrC,CAAC;IAGD,OAAO,CAAC,IAAY,EAAE,IAAS;QAC7B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IAC5B,CAAC;IAGD,eAAe;QACb,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACzB,IAAI,CAAC,OAAO;gBACV,mBAAI,CAAC,SAAS,CACZ,mBAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAA;QACtE,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF;AAUC,oCAAY;AAPd,SAAS,SAAS;IAChB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAA;AAC1D,CAAC"}

package/dist/build/BuildMeta.d.ts

@@ -0,0 +1,24 @@
+import { FileHandler } from './FileHandler';
+type FileMetaData = {
+    path: string;
+    size: number;
+    last: number;
+    exclude: boolean;
+};
+type BuildMetaData = {
+    foldername: string;
+    filename: string;
+    last: number;
+    hlast: number;
+    files: Record<string, FileMetaData>;
+};
+declare class BuildMeta {
+    fh: FileHandler;
+    prev: BuildMetaData;
+    next: BuildMetaData;
+    constructor(fh: FileHandler);
+    last(): number;
+    add(file: string, meta: any): void;
+    done(): BuildMetaData;
+}
+export { BuildMeta };

package/dist/build/BuildMeta.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildMeta = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const basic_1 = require("../util/basic");
+// Handle loading, recording,and saving of build meta data
+class BuildMeta {
+    constructor(fh) {
+        this.fh = fh;
+        // TODO: file folder and name default can be overriden by jopts
+        this.prev = {
+            foldername: '.jostraca',
+            filename: 'jostraca.meta.log',
+            last: -1,
+            hlast: -1,
+            files: {}
+        };
+        this.prev = loadMetaData(this.fh, this.prev);
+        // TODO: load prev if exists
+        this.next = {
+            foldername: this.prev.foldername,
+            filename: this.prev.filename,
+            last: -1,
+            hlast: -1,
+            files: {}
+        };
+    }
+    last() {
+        return this.prev.last;
+    }
+    add(file, meta) {
+        this.next.files[file] = meta;
+    }
+    done() {
+        this.next.last = this.fh.now();
+        this.next.hlast = (0, basic_1.humanify)(this.next.last);
+        // save over previous
+        saveMetaData(this.fh, this.next);
+        return this.next;
+    }
+}
+exports.BuildMeta = BuildMeta;
+function loadMetaData(fh, bmeta) {
+    const metapath = node_path_1.default.join(bmeta.foldername, bmeta.filename);
+    if (fh.existsFile(metapath)) {
+        const json = fh.loadJSON(metapath);
+        bmeta.last = json.last;
+        bmeta.hlast = json.hlast;
+        bmeta.files = json.files;
+    }
+    return bmeta;
+}
+function saveMetaData(fh, bmeta) {
+    const metapath = node_path_1.default.join(bmeta.foldername, bmeta.filename);
+    fh.saveJSON(metapath, bmeta);
+}
+//# sourceMappingURL=BuildMeta.js.map

package/dist/build/BuildMeta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuildMeta.js","sourceRoot":"","sources":["../../src/build/BuildMeta.ts"],"names":[],"mappings":";;;;;;AACA,0DAA4B;AAI5B,yCAAwC;AAmBxC,0DAA0D;AAC1D,MAAM,SAAS;IAOb,YACE,EAAe;QAEf,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;QAEZ,+DAA+D;QAC/D,IAAI,CAAC,IAAI,GAAG;YACV,UAAU,EAAE,WAAW;YACvB,QAAQ,EAAE,mBAAmB;YAC7B,IAAI,EAAE,CAAC,CAAC;YACR,KAAK,EAAE,CAAC,CAAC;YACT,KAAK,EAAE,EAAE;SACV,CAAA;QAED,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;QAE5C,4BAA4B;QAE5B,IAAI,CAAC,IAAI,GAAG;YACV,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU;YAChC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ;YAC5B,IAAI,EAAE,CAAC,CAAC;YACR,KAAK,EAAE,CAAC,CAAC;YACT,KAAK,EAAE,EAAE;SACV,CAAA;IAEH,CAAC;IAGD,IAAI;QACF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAA;IACvB,CAAC;IAGD,GAAG,CAAC,IAAY,EAAE,IAAS;QACzB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAC9B,CAAC;IAGD,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAA;QAC9B,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,IAAA,gBAAQ,EAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAE1C,qBAAqB;QACrB,YAAY,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;QAEhC,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;CACF;AAsBC,8BAAS;AAnBX,SAAS,YAAY,CAAC,EAAe,EAAE,KAAoB;IACzD,MAAM,QAAQ,GAAG,mBAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC5D,IAAI,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;QAClC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;QACtB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;QACxB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;IAC1B,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAGD,SAAS,YAAY,CAAC,EAAe,EAAE,KAAoB;IACzD,MAAM,QAAQ,GAAG,mBAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC5D,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;AAC9B,CAAC"}

package/dist/build/FileHandler.d.ts

@@ -0,0 +1,47 @@
+import { BuildContext } from './BuildContext';
+import { FST, Audit } from '../types';
+declare class FileHandler {
+    when: number;
+    fs: () => FST;
+    now: () => number;
+    folder: string;
+    audit: Audit;
+    maxdepth: number;
+    existing: {
+        txt: any;
+        bin: any;
+    };
+    duplicate: boolean;
+    duplicateFolder: () => string;
+    last: () => number;
+    addmeta: (file: string, meta: any) => void;
+    metafile: () => string;
+    files: {
+        preserved: string[];
+        written: string[];
+        presented: string[];
+        diffed: string[];
+        merged: string[];
+        conflicted: string[];
+        unchanged: string[];
+    };
+    constructor(bctx: BuildContext, existing: {
+        txt: any;
+        bin: any;
+    }, duplicate: boolean);
+    save(path: string, content: string | Buffer, write?: boolean | string, whence?: string): void;
+    copy(frompath: string, topath: string, write?: boolean | string, whence?: string): void;
+    merge(newcontent: string, oldcontent: string, origcontent: string): {
+        content: string;
+        conflict: boolean;
+    };
+    diff(oldcontent: string, newcontent: string): string;
+    existsFile(path: string, whence?: string): boolean;
+    copyFile(frompath: string, topath: string, whence?: string): void;
+    loadJSON(path: string, opts?: any | string, whence?: string): any;
+    saveJSON(path: string, json: any, opts?: any | string, whence?: string): any;
+    loadFile(path: string, opts?: any | string, whence?: string): string | Buffer;
+    saveFile(path: string, content: string | Buffer, opts?: any | string, whence?: string, original?: string | Buffer): void;
+}
+declare function validPath(path: string, maxdepth: number, errmark: string): void;
+export { validPath, FileHandler };

package/dist/build/FileHandler.js

@@ -0,0 +1,424 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandler = void 0;
+exports.validPath = validPath;
+const Diff = require('diff');
+const Diff3 = require('node-diff3');
+const node_path_1 = __importDefault(require("node:path"));
+const basic_1 = require("../util/basic");
+const CN = 'FileHandler:';
+const JOSTRACA_PROTECT = 'JOSTRACA_PROTECT';
+// TODO: if EOL != '\n', normalize to '\n' in load,save 
+class FileHandler {
+    constructor(bctx, existing, duplicate) {
+        this.fs = bctx.fs;
+        this.now = bctx.now;
+        this.when = bctx.when;
+        this.folder = node_path_1.default.normalize(bctx.folder);
+        this.audit = bctx.audit;
+        this.existing = existing;
+        this.duplicate = duplicate;
+        this.maxdepth = 22; // TODO: get from JostracaOptions
+        this.files = {
+            preserved: [],
+            written: [],
+            presented: [],
+            diffed: [],
+            merged: [],
+            conflicted: [],
+            unchanged: [],
+        };
+        // Yikes!
+        this.duplicateFolder = bctx.duplicateFolder.bind(bctx);
+        this.last = () => bctx.bmeta.prev.last;
+        this.addmeta = bctx.addmeta.bind(bctx);
+        this.metafile = () => bctx.bmeta.next.filename;
+        if (!this.fs().existsSync) {
+            throw new Error(CN + ' Invalid file system provider: ' + this.fs());
+        }
+    }
+    save(path, content, write, whence) {
+        const wstr = null == whence ? '' : whence + ':';
+        const fs = this.fs();
+        const FN = 'save:';
+        if ('string' === typeof write) {
+            whence = write;
+            write = false;
+        }
+        else if (null == write) {
+            write = false;
+        }
+        whence = null == whence ? '' : whence;
+        const existing = 'string' === typeof content ? this.existing.txt : this.existing.bin;
+        path = node_path_1.default.normalize(path);
+        const folder = node_path_1.default.dirname(path);
+        const exists = fs.existsSync(path);
+        write = write || !exists;
+        const meta = {
+            action: 'init',
+            path,
+            exists,
+            actions: [],
+            protect: false,
+            conflict: false,
+        };
+        if (exists) {
+            // let oldcontent = fs.readFileSync(path, 'utf8').toString()
+            let oldcontent = this.loadFile(path);
+            const protect = 0 <= oldcontent.indexOf(JOSTRACA_PROTECT);
+            meta.protect = protect;
+            if (existing.preserve) {
+                if (protect) {
+                    write = false;
+                }
+                else if (oldcontent.length !== content.length || oldcontent !== content) {
+                    let oldpath = node_path_1.default.join(folder, node_path_1.default.basename(path).replace(/\.[^.]+$/, '') +
+                        '.old' + node_path_1.default.extname(path));
+                    this.copyFile(path, oldpath, whence + 'preserve:');
+                    this.files.preserved.push(path);
+                    meta.action = 'preserve';
+                    whenify(meta, this.now());
+                    meta.actions.push(meta.action);
+                    this.audit.push([CN + FN + wstr + meta.action,
+                        { ...meta, action: meta.action, path }]);
+                }
+            }
+            if (existing.write && !protect) {
+                write = true;
+            }
+            else if (existing.present) {
+                if (oldcontent.length !== content.length || oldcontent !== content) {
+                    let newpath = node_path_1.default.join(folder, node_path_1.default.basename(path).replace(/\.[^.]+$/, '') +
+                        '.new' + node_path_1.default.extname(path));
+                    this.saveFile(newpath, content, { flush: true }, whence + 'present:');
+                    this.files.presented.push(path);
+                    meta.action = 'present';
+                    whenify(meta, this.now());
+                    meta.actions.push(meta.action);
+                    this.audit.push([CN + FN + wstr + meta.action,
+                        { ...meta, action: meta.action, path }]);
+                }
+            }
+            if (!protect) {
+                if (existing.diff) {
+                    write = false;
+                    if (oldcontent.length !== content.length || oldcontent !== content) {
+                        meta.action = 'diff';
+                        const cstr = 'string' === typeof content ? content : content.toString('utf8');
+                        const diffcontent = this.diff(cstr, oldcontent.toString());
+                        this.saveFile(path, diffcontent, { encoding: 'utf8' }, whence + meta.action, content);
+                        this.files.diffed.push(path);
+                        const conflict = cstr !== diffcontent;
+                        if (conflict) {
+                            this.files.conflicted.push(path);
+                        }
+                        whenify(meta, this.now());
+                        meta.actions.push(meta.action);
+                        meta.conflict = conflict;
+                        this.audit.push([CN + FN + wstr + meta.action,
+                            { ...meta, action: meta.action, path }]);
+                    }
+                }
+                else if (existing.merge) {
+                    write = false;
+                    if (oldcontent.length !== content.length || oldcontent !== content) {
+                        const cstr = 'string' === typeof content ? content : content.toString('utf8');
+                        if (this.duplicate) {
+                            const dfolder = this.duplicateFolder();
+                            const dpath = node_path_1.default.join(dfolder, path);
+                            if (this.existsFile(dpath)) {
+                                meta.action = 'merge';
+                                const origcontent = this.loadFile(dpath, { encoding: 'utf8' });
+                                const mergeres = this.merge(cstr, oldcontent.toString(), origcontent);
+                                const diffcontent = mergeres.content;
+                                const conflict = mergeres.conflict;
+                                this.saveFile(path, diffcontent, { encoding: 'utf8' }, whence + meta.action, content);
+                                this.files.merged.push(path);
+                                if (conflict) {
+                                    this.files.conflicted.push(path);
+                                }
+                                whenify(meta, this.now());
+                                meta.actions.push(meta.action);
+                                meta.conflict = conflict;
+                                this.audit.push([CN + FN + wstr + meta.action,
+                                    { ...meta, action: meta.action, path }]);
+                            }
+                        }
+                    }
+                    else {
+                        this.files.unchanged.push(path);
+                    }
+                }
+            }
+        }
+        if (write) {
+            meta.action = 'write';
+            this.saveFile(path, content, whence + meta.action);
+            this.files.written.push(path);
+            meta.actions.push(meta.action);
+            whenify(meta, this.now());
+            this.audit.push([CN + FN + wstr + meta.action,
+                { ...meta, action: meta.action, path }]);
+        }
+        this.addmeta(path, meta);
+    }
+    copy(frompath, topath, write, whence) {
+        const wstr = null == whence ? '' : whence + ':';
+        const FN = 'copy:';
+        if ('string' === typeof write) {
+            whence = write;
+            write = false;
+        }
+        else if (null == write) {
+            write = false;
+        }
+        whence = wstr + FN;
+        const isBinary = (0, basic_1.isbinext)(frompath);
+        const content = this.loadFile(frompath, { encoding: isBinary ? null : 'utf8' }, whence);
+        this.save(topath, content, whence);
+    }
+    // TODO: need to record if diffed, merged
+    merge(newcontent, oldcontent, origcontent) {
+        const isowhen = new Date(this.when).toISOString();
+        const isolast = new Date(this.last()).toISOString();
+        // Consider the previously generated pure version, stored in
+        // .jostraca/generated to be the "original". That preserves
+        // manual edits in the main generated output.
+        const diffres = Diff3.merge(oldcontent, origcontent, newcontent, {
+            stringSeparator: '\n',
+            excludeFalseConflicts: true,
+            label: {
+                a: 'EXISTING: ' + isolast,
+                b: 'GENERATED: ' + isowhen,
+            }
+        });
+        // if (oldcontent.includes('foo js')) {
+        //   console.log(
+        //     'DIFF======',
+        //     '\no=', JSON.stringify(oldcontent),
+        //     '\ng=', JSON.stringify(origcontent),
+        //     '\nn=', JSON.stringify(newcontent),
+        //     diffres
+        //   )
+        // }
+        const conflict = diffres.conflict;
+        const content = diffres.result.join('\n');
+        return { content, conflict };
+    }
+    diff(oldcontent, newcontent) {
+        const isowhen = new Date(this.when).toISOString();
+        const isolast = new Date(this.last()).toISOString();
+        const difflines = Diff.diffLines(newcontent, oldcontent);
+        const out = [];
+        difflines.forEach((part) => {
+            if (part.added) {
+                out.push('<<<<<<< GENERATED: ' + isowhen + '\n');
+                out.push(part.value);
+                out.push('>>>>>>> GENERATED: ' + isowhen + '\n');
+            }
+            else if (part.removed) {
+                out.push('<<<<<<< EXISTING: ' + isolast + '\n');
+                out.push(part.value);
+                out.push('>>>>>>> EXISTING: ' + isolast + '\n');
+            }
+            else {
+                out.push(part.value);
+            }
+        });
+        const content = out.join('');
+        return content;
+    }
+    existsFile(path, whence) {
+        const when = this.now();
+        const wstr = null == whence ? '' : whence + ':';
+        const fs = this.fs();
+        const FN = 'existsFile:';
+        validPath(path, this.maxdepth, CN + FN + 'from:' + wstr);
+        const fullpath = node_path_1.default.isAbsolute(path) ? path : node_path_1.default.join(this.folder, path);
+        try {
+            const exists = fs.existsSync(fullpath);
+            this.audit.push([CN + FN + wstr,
+                { path, when, exists }]);
+            return exists;
+        }
+        catch (err) {
+            this.audit.push(['ERROR:' + CN + FN + wstr,
+                { path, when, err }]);
+            err.message = CN + FN + wstr + ' path=' + path +
+                ' err=' + err.message;
+            throw err;
+        }
+    }
+    copyFile(frompath, topath, whence) {
+        const when = this.now();
+        const wstr = null == whence ? '' : whence + ':';
+        const fs = this.fs();
+        const FN = 'copyFile:';
+        validPath(frompath, this.maxdepth, CN + FN + 'from:' + wstr);
+        validPath(topath, this.maxdepth, CN + FN + 'to:' + wstr);
+        const isBinary = (0, basic_1.isbinext)(frompath);
+        const fulltopath = node_path_1.default.isAbsolute(topath) ? topath : node_path_1.default.join(this.folder, topath);
+        const fullfrompath = node_path_1.default.isAbsolute(frompath) ? frompath : node_path_1.default.join(this.folder, frompath);
+        try {
+            const existed = fs.existsSync(fulltopath);
+            fs.mkdirSync(node_path_1.default.dirname(fulltopath), { recursive: true });
+            const content = fs.readFileSync(fullfrompath, isBinary ? undefined : 'utf8');
+            fs.writeFileSync(topath, content, { flush: true });
+            this.audit.push([CN + FN + wstr,
+                { topath, frompath, when, existed, size: content.length }]);
+        }
+        catch (err) {
+            this.audit.push(['ERROR:' + CN + FN + wstr,
+                { topath, frompath, when, err }]);
+            err.message = CN + FN + wstr + ' topath=' + topath + ' frompath=' + frompath +
+                ' err=' + err.message;
+            throw err;
+        }
+    }
+    loadJSON(path, opts, whence) {
+        const when = this.now();
+        const wstr = null == whence ? '' : whence + ':';
+        const FN = 'loadJSON:';
+        if ('string' === typeof opts) {
+            whence = opts;
+            opts = {};
+        }
+        else {
+            opts = opts || {};
+        }
+        opts.encoding = opts.encoding || 'utf8';
+        try {
+            const content = this.loadFile(path, opts, whence);
+            const cstr = 'string' === typeof content ? content : content.toString(opts.encoding);
+            const json = JSON.parse(cstr);
+            this.audit.push([CN + FN + wstr,
+                { path, when, size: content.length }]);
+            return json;
+        }
+        catch (err) {
+            this.audit.push(['ERROR:' + CN + FN + wstr,
+                { path, when, err }]);
+            err.message = CN + FN + wstr + ' path=' + path + ' err=' + err.message;
+            throw err;
+        }
+    }
+    saveJSON(path, json, opts, whence) {
+        const when = this.now();
+        const wstr = null == whence ? '' : whence + ':';
+        const FN = 'saveJSON:';
+        if ('string' === typeof opts) {
+            whence = opts;
+            opts = {};
+        }
+        else {
+            opts = opts || {};
+        }
+        opts.encoding = opts.encoding || 'utf8';
+        try {
+            const jstr = 'string' === typeof json ? json : JSON.stringify(json, null, 2);
+            this.saveFile(path, jstr, opts, whence);
+            this.audit.push([CN + FN + wstr,
+                { path, when, size: jstr.length }]);
+            return jstr;
+        }
+        catch (err) {
+            this.audit.push(['ERROR:' + CN + FN + wstr,
+                { path, when, err }]);
+            err.message = CN + FN + wstr + ' path=' + path + ' err=' + err.message;
+            throw err;
+        }
+    }
+    loadFile(path, opts, whence) {
+        const when = this.now();
+        const wstr = null == whence ? '' : whence + ':';
+        const fs = this.fs();
+        const FN = 'loadFile:';
+        if ('string' === typeof opts) {
+            whence = opts;
+            opts = {};
+        }
+        else {
+            opts = opts || {};
+        }
+        opts.encoding = undefined === opts.encoding ? 'utf8' : opts.encoding;
+        validPath(path, this.maxdepth, CN + FN + wstr);
+        try {
+            const fullpath = node_path_1.default.isAbsolute(path) ? path : node_path_1.default.join(this.folder, path);
+            const content = fs.readFileSync(fullpath, opts);
+            this.audit.push([CN + FN + wstr,
+                { path, when, size: content.length }]);
+            return content;
+        }
+        catch (err) {
+            this.audit.push(['ERROR:' + CN + FN + wstr,
+                { path, when, err }]);
+            err.message = CN + FN + wstr + ' path=' + path + ' err=' + err.message;
+            throw err;
+        }
+    }
+    saveFile(path, content, opts, whence, original) {
+        const when = this.now();
+        const wstr = null == whence ? '' : whence + ':';
+        const fs = this.fs();
+        const FN = 'saveFile:';
+        if ('string' === typeof opts) {
+            whence = opts;
+            opts = {};
+        }
+        else {
+            opts = opts || {};
+        }
+        opts.encoding = opts.encoding || ('string' === typeof content ? 'utf8' : undefined);
+        validPath(path, this.maxdepth, FN);
+        if ('string' !== typeof content && !(content instanceof Buffer)) {
+            throw new Error(CN + FN + wstr + ' invalid content, path=' + path +
+                ' content=' + content);
+        }
+        try {
+            path = node_path_1.default.normalize(path);
+            const isAbsolute = node_path_1.default.isAbsolute(path);
+            const fullpath = isAbsolute ? path : node_path_1.default.join(this.folder, path);
+            const parentfolder = node_path_1.default.dirname(fullpath);
+            const existed = fs.existsSync(fullpath);
+            fs.mkdirSync(parentfolder, { recursive: true });
+            fs.writeFileSync(fullpath, content, opts);
+            this.audit.push([CN + FN + wstr,
+                { path, when, existed, size: content.length }]);
+            const withinFolder = path.startsWith(this.folder);
+            if (this.duplicate &&
+                (!isAbsolute || withinFolder) &&
+                (node_path_1.default.basename(path) !== this.metafile())) {
+                const dfolder = this.duplicateFolder();
+                const dpath = node_path_1.default.join(dfolder, path);
+                fs.mkdirSync(node_path_1.default.dirname(dpath), { recursive: true });
+                const dopts = { ...opts, flush: true };
+                const dcontent = null == original ? content : original;
+                fs.writeFileSync(dpath, dcontent, dopts);
+            }
+        }
+        catch (err) {
+            this.audit.push(['ERROR:' + CN + FN + wstr,
+                { path, when, size: content.length, err }]);
+            err.message = CN + FN + wstr + ' path=' + path + ':' + err.message;
+            throw err;
+        }
+    }
+}
+exports.FileHandler = FileHandler;
+function whenify(meta, now) {
+    meta.when = now;
+    meta.hwhen = (0, basic_1.humanify)(now);
+}
+function validPath(path, maxdepth, errmark) {
+    if (null == path || '' == path || 'string' !== typeof path) {
+        throw new Error('ERROR:' + errmark + ' invalid path, path=' + path);
+    }
+    const depth = node_path_1.default.normalize(node_path_1.default.dirname(path)).split(node_path_1.default.sep).filter(Boolean).length;
+    if (maxdepth < depth) {
+        throw new Error(errmark + ' path too deep, path=' + path);
+    }
+}
+//# sourceMappingURL=FileHandler.js.map