core-3nweb-client-lib 0.21.0 → 0.22.0

package/build/lib-client/3nstorage/xsp-fs/folder-node.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -13,7 +13,8 @@
  See the GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>. */
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FolderNode = void 0;
 /**
@@ -31,7 +32,8 @@ const json_utils_1 = require("../../../lib-common/json-utils");
 const xsp_files_1 = require("xsp-files");
 const random = require("../../../lib-common/random-node");
 const folder_node_serialization_1 = require("./folder-node-serialization");
-const file_attrs_1 = require("../../files/file-attrs");
+const attrs_1 = require("./attrs");
+const node_persistence_1 = require("./node-persistence");
 function jsonToInfoAndAttrs(json) {
     const folderInfo = {
         nodes: json_utils_1.copy(json.nodes)
@@ -40,50 +42,30 @@ function jsonToInfoAndAttrs(json) {
         node.key = buffer_utils_1.base64.open(node.key);
     }
     checkFolderInfo(folderInfo);
-    if (json.attrs) {
-        const attrs = file_attrs_1.AttrsHolder.fromJSONReadonly(json.attrs);
-        return { attrs, folderInfo };
-    }
-    else {
-        return { folderInfo };
-    }
+    const attrs = new attrs_1.CommonAttrs(json.ctime, json.ctime);
+    return { attrs, folderInfo };
 }
-class FolderCrypto extends node_in_fs_1.NodeCrypto {
+class FolderPersistance extends node_persistence_1.NodePersistance {
     constructor(zNonce, key, cryptor) {
         super(zNonce, key, cryptor);
         Object.seal(this);
     }
-    async pack(folderInfo, version, attrs) {
-        return this.saveBytes(folder_node_serialization_1.serializeFolderInfo(folderInfo), version, attrs);
+    async write(folderInfo, version, attrs, xattrs) {
+        const bytes = folder_node_serialization_1.serializeFolderInfo(folderInfo);
+        return this.writeWhole(bytes, version, attrs, xattrs);
     }
-    async open(src) {
-        try {
-            const { attrs, content } = await this.readBytes(src);
-            const folderInfo = folder_node_serialization_1.deserializeFolderInfo(content);
-            if (attrs) {
-                return {
-                    folderInfo,
-                    attrs: file_attrs_1.AttrsHolder.fromBytesReadonly(attrs)
-                };
-            }
-            else {
-                return { folderInfo };
-            }
-        }
-        catch (err) {
-            throw error_1.errWithCause(err, `Cannot open folder object`);
-        }
+    async read(src) {
+        const { content, xattrs, attrs } = await this.readAll(src);
+        const folderInfo = folder_node_serialization_1.parseFolderInfo(content);
+        return { folderInfo, xattrs, attrs: attrs_1.CommonAttrs.fromAttrs(attrs) };
     }
 }
-Object.freeze(FolderCrypto.prototype);
-Object.freeze(FolderCrypto);
+Object.freeze(FolderPersistance.prototype);
+Object.freeze(FolderPersistance);
 class FolderNode extends node_in_fs_1.NodeInFS {
     constructor(storage, name, objId, zNonce, version, parentId, key, setNewAttrs) {
         super(storage, 'folder', name, objId, version, parentId);
         this.currentState = { nodes: {} };
-        this.transitionState = undefined;
-        this.transitionVersion = undefined;
-        this.transitionSaved = false;
         if (!name && (objId || parentId)) {
             throw new Error("Root folder must " +
                 "have both objId and parent as nulls.");
@@ -97,9 +79,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             }
             zNonce = xsp_files_1.idToHeaderNonce(objId);
         }
-        this.crypto = new FolderCrypto(zNonce, key, storage.cryptor);
+        this.crypto = new FolderPersistance(zNonce, key, storage.cryptor);
         if (setNewAttrs) {
-            this.attrs = file_attrs_1.AttrsHolder.makeReadonlyForFolder(Date.now());
+            this.attrs = attrs_1.CommonAttrs.makeForTimeNow();
         }
         Object.seal(this);
     }
@@ -107,7 +89,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         const zNonce = await random.bytes(xsp_files_1.NONCE_LENGTH);
         const rf = new FolderNode(storage, undefined, null, zNonce, 0, undefined, key, true);
         rf.storage.nodes.set(rf);
-        await rf.saveFirstVersion();
+        await rf.saveFirstVersion(undefined);
         return rf;
     }
     static async rootFromObjBytes(storage, name, objId, src, key) {
@@ -122,9 +104,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     static async readNodeFromObjBytes(storage, name, objId, zNonce, src, key) {
         const rf = new FolderNode(storage, name, objId, zNonce, src.version, undefined, key, false);
-        const { folderInfo, attrs } = await rf.crypto.open(src);
+        const { folderInfo, attrs, xattrs } = await rf.crypto.read(src);
         rf.currentState = folderInfo;
-        rf.attrs = (attrs ? attrs : file_attrs_1.AttrsHolder.makeReadonlyForFolder(0));
+        rf.setUpdatedParams(src.version, attrs, xattrs);
         return rf;
     }
     static async rootFromLinkParams(storage, params) {
@@ -145,9 +127,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     static rootFromJSON(storage, name, folderJson) {
         const rf = new FolderNode(storage, name, 'readonly-root', EMPTY_ARR, 0, undefined, undefined, false);
-        const { folderInfo, attrs } = jsonToInfoAndAttrs(folderJson);
+        const { folderInfo, attrs, xattrs } = jsonToInfoAndAttrs(folderJson);
         rf.currentState = folderInfo;
-        rf.attrs = (attrs ? attrs : file_attrs_1.AttrsHolder.makeReadonlyForFolder(0));
+        rf.setUpdatedParams(0, attrs, xattrs);
         return rf;
     }
     list() {
@@ -267,15 +249,15 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return this.getNode('link', name, undefOnMissing);
     }
     async fixMissingChildAndThrow(exc, childInfo) {
-        await this.doTransition(true, async () => {
-            delete this.transitionState.nodes[childInfo.name];
+        await this.doTransition(async (state, version) => {
+            delete state.nodes[childInfo.name];
             const event = {
                 type: 'entry-removal',
                 path: this.name,
                 name: childInfo.name,
-                newVersion: this.transitionVersion
+                newVersion: version
             };
-            this.broadcastEvent(event);
+            return event;
         }).catch(noop);
         const fileExc = file_1.makeFileException(file_1.Code.notFound, childInfo.name, exc);
         fileExc.inconsistentStateOfFS = true;
@@ -283,117 +265,59 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     /**
      * This method prepares a transition state, runs given action, and completes
-     * transition to a new version. Returned promise resolves to whatever given
-     * action returns (promise is unwrapped).
+     * transition to a new version.
      * Note that if there is already an ongoing change, this transition will
      * wait. Such behaviour is generally needed for folder as different processes
      * may be sharing same elements in a file tree. In contrast, file
      * operations should more often follow a throw instead wait approach.
-     * @param autoSave true value turns on saving in of transition by this call,
-     * while false value indicates that saving will be done within a given action
-     * @param action is a function that is run when transition is started
+     * @param change is a function that is run when transition is started
      */
-    doTransition(autoSave, action) {
-        return this.doChange(true, this.wrapInTransition(autoSave, action));
-    }
-    wrapInTransition(autoSave, action) {
-        return async () => {
-            // start transition and prepare transition state
-            // Note on copy: byte arrays are not cloned
-            this.transitionState = json_utils_1.copy(this.currentState);
-            this.transitionVersion = this.version + 1;
-            try {
-                // do action within transition state
-                const result = await action();
-                // return fast, if transaction was canceled
-                if (!this.transitionState) {
-                    return result;
-                }
-                // save transition state, if saving hasn't been done inside of action
-                if (autoSave) {
-                    await this.saveTransitionState();
-                }
-                // complete transition
-                if (!this.transitionSaved) {
-                    throw new Error(`Transition state has not been saved`);
-                }
-                this.currentState = this.transitionState;
-                this.setCurrentVersion(this.transitionVersion);
-                return result;
-            }
-            finally {
-                // cleanup after both completion and fail
-                this.clearTransitionState();
-            }
-        };
-    }
-    clearTransitionState() {
-        this.transitionState = undefined;
-        this.transitionVersion = undefined;
-        this.transitionSaved = false;
-    }
-    async saveTransitionState() {
-        if (!this.transitionState || !this.transitionVersion) {
-            throw new Error(`Transition is not set correctly`);
-        }
-        if (this.transitionSaved) {
-            throw new Error(`Transition has already been saved.`);
-        }
-        const attrs = this.attrs.modifiableCopy();
-        const encSub = await this.crypto.pack(this.transitionState, this.transitionVersion, attrs);
-        await this.storage.saveObj(this.objId, this.transitionVersion, encSub);
-        this.transitionSaved = true;
-        attrs.setReadonly();
+    async doTransition(change) {
+        await this.doChange(true, () => this.performTransition(change));
+    }
+    async performTransition(change) {
+        // start transition and prepare transition state
+        // Note on copy: byte arrays are not cloned
+        const state = json_utils_1.copy(this.currentState);
+        const version = this.version + 1;
+        const attrs = this.attrs.copy();
+        // do action within transition state
+        const event = await change(state, version);
+        // save transition state
+        const encSub = await this.crypto.write(state, version, attrs, this.xattrs);
+        await this.storage.saveObj(this.objId, version, encSub);
+        // complete transition
+        this.currentState = state;
+        this.setCurrentVersion(version);
         this.attrs = attrs;
-    }
-    addToTransitionState(f, key) {
-        const nodeInfo = {
-            name: f.name,
-            objId: f.objId,
-            key
-        };
-        if (f.type === 'folder') {
-            nodeInfo.isFolder = true;
-        }
-        else if (f.type === 'file') {
-            nodeInfo.isFile = true;
-        }
-        else if (f.type === 'link') {
-            nodeInfo.isLink = true;
-        }
-        else {
-            throw new Error(`Unknown type of file system entity: ${f.type}`);
-        }
-        this.transitionState.nodes[nodeInfo.name] = nodeInfo;
+        this.broadcastEvent(event);
     }
     /**
      * This function only creates folder node, but it doesn't insert it anywhere.
      * @param name
      */
-    async makeAndSaveNewChildFolderNode(name) {
+    async makeAndSaveNewChildFolderNode(name, changes) {
         const key = await random.bytes(xsp_files_1.KEY_LENGTH);
         const childObjId = await this.storage.generateNewObjId();
         const node = new FolderNode(this.storage, name, childObjId, undefined, 0, this.objId, key, true);
-        await node.saveFirstVersion().catch((exc) => {
+        await node.saveFirstVersion(changes).catch((exc) => {
             if (!exc.objExists) {
                 throw exc;
             }
             // call this method recursively, if obj id is already used in storage
-            return this.makeAndSaveNewChildFolderNode(name);
+            return this.makeAndSaveNewChildFolderNode(name, changes);
         });
         return { node, key };
     }
-    async saveFirstVersion() {
+    async saveFirstVersion(changes) {
         await this.doChange(false, async () => {
             if (this.version > 0) {
                 throw new Error(`Can call this function only for zeroth version, not ${this.version}`);
             }
-            this.setCurrentVersion(1);
-            const attrs = this.attrs.modifiableCopy();
-            const encSub = await this.crypto.pack(this.currentState, this.version, attrs);
-            await this.storage.saveObj(this.objId, this.version, encSub);
-            attrs.setReadonly();
-            this.attrs = attrs;
+            const { attrs, xattrs, newVersion } = super.getParamsForUpdate(changes);
+            const encSub = await this.crypto.write(this.currentState, newVersion, attrs, xattrs);
+            await this.storage.saveObj(this.objId, newVersion, encSub);
+            super.setUpdatedParams(newVersion, attrs, xattrs);
         });
     }
     /**
@@ -420,7 +344,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     async makeAndSaveNewChildLinkNode(name, params) {
         const key = await random.bytes(xsp_files_1.KEY_LENGTH);
         const node = await link_node_1.LinkNode.makeForNew(this.storage, this.objId, name, key);
-        await node.setLinkParams(params).catch((exc) => {
+        await node.save(params).catch((exc) => {
             if (!exc.objExists) {
                 throw exc;
             }
@@ -429,19 +353,17 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         });
         return { node, key };
     }
-    create(type, name, exclusive, linkParams) {
-        return this.doTransition(false, async () => {
+    create(type, name, exclusive, changes, linkParams) {
+        return this.doChange(true, async () => {
             // do check for concurrent creation of a node
             if (this.getNodeInfo(name, true)) {
                 if (exclusive) {
                     throw file_1.makeFileException(file_1.Code.alreadyExists, name);
                 }
                 else if (type === 'folder') {
-                    this.clearTransitionState();
                     return (await this.getNode('folder', name));
                 }
                 else if (type === 'file') {
-                    this.clearTransitionState();
                     return (await this.getNode('file', name));
                 }
                 else if (type === 'link') {
@@ -451,62 +373,63 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                     throw new Error(`Unknown type of node: ${type}`);
                 }
             }
-            // create new node
-            let node;
-            let key;
-            if (type === 'file') {
-                ({ node, key } = await this.makeAndSaveNewChildFileNode(name));
-            }
-            else if (type === 'folder') {
-                ({ node, key } = await this.makeAndSaveNewChildFolderNode(name));
-            }
-            else if (type === 'link') {
-                ({ node, key } = await this.makeAndSaveNewChildLinkNode(name, linkParams));
-            }
-            else {
-                throw new Error(`Unknown type of node: ${type}`);
-            }
-            this.addToTransitionState(node, key);
-            await this.saveTransitionState(); // manual save
-            this.storage.nodes.set(node);
-            const event = {
-                type: 'entry-addition',
-                path: this.name,
-                newVersion: this.transitionVersion,
-                entry: {
-                    name: node.name,
-                    isFile: (node.type === 'file'),
-                    isFolder: (node.type === 'folder'),
-                    isLink: (node.type === 'link')
+            let node = undefined;
+            await this.performTransition(async (state, version) => {
+                // create new node
+                let key;
+                if (type === 'file') {
+                    ({ node, key } = await this.makeAndSaveNewChildFileNode(name));
                 }
-            };
-            this.broadcastEvent(event);
+                else if (type === 'folder') {
+                    ({ node, key } = await this.makeAndSaveNewChildFolderNode(name, changes));
+                }
+                else if (type === 'link') {
+                    ({ node, key } = await this.makeAndSaveNewChildLinkNode(name, linkParams));
+                }
+                else {
+                    throw new Error(`Unknown type of node: ${type}`);
+                }
+                addToTransitionState(state, node, key);
+                this.storage.nodes.set(node);
+                const event = {
+                    type: 'entry-addition',
+                    path: this.name,
+                    newVersion: version,
+                    entry: {
+                        name: node.name,
+                        isFile: (node.type === 'file'),
+                        isFolder: (node.type === 'folder'),
+                        isLink: (node.type === 'link')
+                    }
+                };
+                return event;
+            });
             return node;
         });
     }
-    createFolder(name, exclusive) {
-        return this.create('folder', name, exclusive);
+    createFolder(name, exclusive, changes) {
+        return this.create('folder', name, exclusive, changes);
     }
     createFile(name, exclusive) {
         return this.create('file', name, exclusive);
     }
     async createLink(name, params) {
-        await this.create('link', name, true, params);
+        await this.create('link', name, true, undefined, params);
     }
     async removeChild(f) {
-        await this.doTransition(true, async () => {
-            const childJSON = this.transitionState.nodes[f.name];
+        await this.doTransition(async (state, version) => {
+            const childJSON = state.nodes[f.name];
             if (!childJSON || (childJSON.objId !== f.objId)) {
                 throw new Error(`Not a child given: name==${f.name}, objId==${f.objId}, parentId==${f.parentId}, this folder objId==${this.objId}`);
             }
-            delete this.transitionState.nodes[f.name];
+            delete state.nodes[f.name];
             const event = {
                 type: 'entry-removal',
                 path: this.name,
                 name: f.name,
-                newVersion: this.transitionVersion
+                newVersion: version
             };
-            this.broadcastEvent(event);
+            return event;
         });
         // explicitly do not wait on a result of child's delete, cause if it fails
         // we just get traceable garbage, yet, the rest of a live/non-deleted tree
@@ -514,10 +437,10 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         f.localDelete();
     }
     changeChildName(initName, newName) {
-        return this.doTransition(true, async () => {
-            const child = this.transitionState.nodes[initName];
-            delete this.transitionState.nodes[child.name];
-            this.transitionState.nodes[newName] = child;
+        return this.doTransition(async (state, version) => {
+            const child = state.nodes[initName];
+            delete state.nodes[child.name];
+            state.nodes[newName] = child;
             child.name = newName;
             const childNode = this.storage.nodes.get(child.objId);
             if (childNode) {
@@ -528,9 +451,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 path: this.name,
                 newName,
                 oldName: initName,
-                newVersion: this.transitionVersion
+                newVersion: version
             };
-            this.broadcastEvent(event);
+            return event;
         });
     }
     async moveChildTo(childName, dst, nameInDst) {
@@ -549,22 +472,22 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         ]);
     }
     async moveChildOut(name) {
-        await this.doTransition(true, async () => {
-            delete this.transitionState.nodes[name];
+        await this.doTransition(async (state, version) => {
+            delete state.nodes[name];
             const event = {
                 type: 'entry-removal',
                 path: this.name,
                 name,
-                newVersion: this.transitionVersion
+                newVersion: version
             };
-            this.broadcastEvent(event);
+            return event;
         });
     }
     async moveChildIn(newName, child) {
         child = json_utils_1.copy(child);
-        await this.doTransition(true, async () => {
+        await this.doTransition(async (state, version) => {
             child.name = newName;
-            this.transitionState.nodes[child.name] = child;
+            state.nodes[child.name] = child;
             const event = {
                 type: 'entry-addition',
                 path: this.name,
@@ -574,9 +497,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                     isFolder: child.isFolder,
                     isLink: child.isLink
                 },
-                newVersion: this.transitionVersion
+                newVersion: version
             };
-            this.broadcastEvent(event);
+            return event;
         });
     }
     async getFolderInThisSubTree(path, createIfMissing = false, exclusiveCreate = false) {
@@ -604,7 +527,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 throw err;
             }
             try {
-                f = await this.createFolder(path[0], exclusiveCreate);
+                f = await this.createFolder(path[0], exclusiveCreate, undefined);
             }
             catch (exc) {
                 if (exc.alreadyExists && !exclusiveCreate) {
@@ -704,7 +627,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         if (newVersion <= this.version) {
             return;
         }
-        const { folderInfo, attrs } = await this.crypto.open(src);
+        const { folderInfo, attrs } = await this.crypto.read(src);
         const initState = this.currentState;
         this.currentState = checkFolderInfo(folderInfo);
         this.setCurrentVersion(newVersion);
@@ -765,4 +688,24 @@ function checkFolderInfo(folderJson) {
     // TODO throw if folderJson is not ok
     return folderJson;
 }
+function addToTransitionState(state, f, key) {
+    const nodeInfo = {
+        name: f.name,
+        objId: f.objId,
+        key
+    };
+    if (f.type === 'folder') {
+        nodeInfo.isFolder = true;
+    }
+    else if (f.type === 'file') {
+        nodeInfo.isFile = true;
+    }
+    else if (f.type === 'link') {
+        nodeInfo.isLink = true;
+    }
+    else {
+        throw new Error(`Unknown type of file system entity: ${f.type}`);
+    }
+    state.nodes[nodeInfo.name] = nodeInfo;
+}
 Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/fs.d.ts

@@ -1,9 +1,8 @@
-import { FolderNode, FolderLinkParams, FolderInfoWithAttrs } from './folder-node';
+import { FolderNode, FolderLinkParams, FolderInJSON } from './folder-node';
 import { FileNode } from './file-node';
 import { Storage } from './common';
 import { LinkParameters } from '../../files';
 import { NodeInFS } from './node-in-fs';
-import { EntityAttrs } from '../../files/file-attrs';
 declare type Stats = web3n.files.Stats;
 declare type FS = web3n.files.FS;
 declare type WritableFS = web3n.files.WritableFS;
@@ -46,7 +45,7 @@ export declare class XspFS implements WritableFS {
      * @param key is a file key of a root object
      */
     static fromExistingRoot(storage: Storage, key: Uint8Array): Promise<WritableFS>;
-    static fromASMailMsgRootFromJSON(storage: Storage, folderJson: FolderInfoWithAttrs, rootName?: string): ReadonlyFS;
+    static fromASMailMsgRootFromJSON(storage: Storage, folderJson: FolderInJSON, rootName?: string): ReadonlyFS;
     /**
      * Note that this method doesn't close storage.
      */
@@ -97,7 +96,7 @@ declare class V implements WritableFSVersionedAPI {
     root: FolderNode;
     constructor();
     getOrCreateFile(path: string, flags: FileFlags): Promise<FileNode>;
-    get(path: string): Promise<NodeInFS<any, EntityAttrs>>;
+    get(path: string): Promise<NodeInFS<any>>;
     updateXAttrs(path: string, changes: XAttrsChanges): Promise<number>;
     getXAttr(path: string, xaName: string): Promise<{
         attr: any;

package/build/lib-client/3nstorage/xsp-fs/fs.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -36,7 +36,8 @@ function splitPathIntoParts(path) {
 }
 function setExcPath(path) {
     return (exc) => {
-        if (exc.notFound || exc.notDirectory || exc.alreadyExists || exc.notFile) {
+        if (exc.notFound || exc.notDirectory || exc.alreadyExists
+            || exc.notFile) {
             exc.path = path;
         }
         throw exc;
@@ -189,27 +190,25 @@ class XspFS {
     }
     async stat(path) {
         const node = await this.v.get(path);
+        const attrs = node.getAttrs();
+        const stats = {
+            ctime: new Date(attrs.ctime),
+            mtime: new Date(attrs.mtime),
+            version: node.version,
+            writable: this.writable,
+        };
         if (node.type === 'file') {
-            const { src, version } = await node.readSrc();
-            return {
-                isFile: true,
-                writable: this.writable,
-                size: await src.getSize(),
-                version
-            };
+            stats.size = node.size;
+            stats.isFile = true;
+            return stats;
         }
         else if (node.type === 'folder') {
-            return {
-                isFolder: true,
-                writable: this.writable,
-                version: node.version
-            };
+            stats.isFolder = true;
+            return stats;
         }
         else if (node.type === 'link') {
-            return {
-                writable: false,
-                isLink: true
-            };
+            stats.isLink = true;
+            return stats;
         }
         else {
             throw new Error(`Unknown type of fs node`);
@@ -515,9 +514,7 @@ class V {
     }
     async readBytes(path, start, end) {
         const file = await this.getOrCreateFile(path, {});
-        const { src, version } = await file.readSrc();
-        const bytes = await file_2.readBytesFrom(src, start, end);
-        return { bytes, version };
+        return await file.readBytes(start, end);
     }
     writeTxtFile(path, txt, flags = WRITE_NONEXCL_FLAGS) {
         const bytes = buffer_utils_1.utf8.pack(txt);