core-3nweb-client-lib 0.20.9 → 0.23.0

package/build/lib-client/files/file-attrs.js

@@ -1,549 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2020 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
- Foundation, either version 3 of the License, or (at your option) any later
- version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- 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/>. */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AttrsHolder = exports.makeLinkAttrs = exports.makeFolderAttrs = exports.makeFileAttrs = exports.attrType = void 0;
-const assert_1 = require("../../lib-common/assert");
-const buffer_utils_1 = require("../../lib-common/buffer-utils");
-const big_endian_1 = require("../../lib-common/big-endian");
-const json_utils_1 = require("../../lib-common/json-utils");
-// FS entity type values (xx_FSE)
-const FOLDER_JSON_V1_FSE = 0x01;
-// const FOLDER_BIN_V1_FSE = 0x02;
-const LINK_JSON_V1_FSE = 0x11;
-// const LINK_BIN_V1_FSE = 0x12;
-const FILE_V1_CONTINUOUS_FSE = 0x21;
-const FILE_V1_WITH_LAYOUT_FSE = 0x22;
-function attrType(value) {
-    if (typeof value === 'string') {
-        return 'named-utf8str';
-    }
-    else if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) {
-        return 'named-binary';
-    }
-    else {
-        return 'named-json';
-    }
-}
-exports.attrType = attrType;
-function makeFileAttrs(now) {
-    const attrs = makeAttrs('file-v1-continuous', now);
-    attrs.size = 0;
-    return attrs;
-}
-exports.makeFileAttrs = makeFileAttrs;
-function makeFolderAttrs(now) {
-    return makeAttrs('folder-json-v1', now);
-}
-exports.makeFolderAttrs = makeFolderAttrs;
-function makeLinkAttrs(now) {
-    return makeAttrs('link-json-v1', now);
-}
-exports.makeLinkAttrs = makeLinkAttrs;
-function makeAttrs(type, now) {
-    return { type, ctime: now, mtime: now, ext: {} };
-}
-function readAttrs(bytes) {
-    if (bytes.length < 1) {
-        throw parsingException(`byte array is empty`);
-    }
-    const fseByte = bytes[0];
-    bytes = bytes.slice(1);
-    if (fseByte === FOLDER_JSON_V1_FSE) {
-        return attrV1.readFolderAttrs(bytes, 'folder-json-v1');
-    }
-    else if (fseByte === LINK_JSON_V1_FSE) {
-        return attrV1.readLinkAttrs(bytes, 'link-json-v1');
-    }
-    else if (fseByte === FILE_V1_CONTINUOUS_FSE) {
-        return attrV1.readFileAttrs(bytes, 'file-v1-continuous');
-    }
-    else if (fseByte === FILE_V1_WITH_LAYOUT_FSE) {
-        return attrV1.readFileAttrs(bytes, 'file-v1-w-layout');
-    }
-    else {
-        throw parsingException(`Type byte ${fseByte} isn't recognized`);
-    }
-}
-var attrV1;
-(function (attrV1) {
-    function readFolderAttrs(bytes, type) {
-        const { ctime, mtime, commAttrBytes: ofs } = readCommonAttrs(bytes);
-        const ext = readNamedAttrs(bytes, ofs);
-        return { type, ctime, mtime, ext };
-    }
-    attrV1.readFolderAttrs = readFolderAttrs;
-    function readLinkAttrs(bytes, type) {
-        const { ctime, mtime, commAttrBytes: ofs } = readCommonAttrs(bytes);
-        const ext = readNamedAttrs(bytes, ofs);
-        return { type, ctime, mtime, ext };
-    }
-    attrV1.readLinkAttrs = readLinkAttrs;
-    function readFileAttrs(bytes, type) {
-        const { ctime, mtime, commAttrBytes } = readCommonAttrs(bytes);
-        let ofs = commAttrBytes;
-        const sizeOrLayoutOfs = big_endian_1.uintFrom8Bytes(bytes, ofs);
-        ofs += 8;
-        const ext = readNamedAttrs(bytes, ofs);
-        if (type === 'file-v1-continuous') {
-            return { type, ctime, mtime, ext, size: sizeOrLayoutOfs };
-        }
-        else if (type === 'file-v1-w-layout') {
-            return { type, ctime, mtime, ext, layoutOfs: sizeOrLayoutOfs };
-        }
-        else {
-            throw new Error(`Unknown type`);
-        }
-    }
-    attrV1.readFileAttrs = readFileAttrs;
-    function readCommonAttrs(bytes) {
-        if (bytes.length < (6 + 6)) {
-            throw parsingException(`byte array is empty`);
-        }
-        const ctime = big_endian_1.uintFrom6Bytes(bytes, 0);
-        const mtime = big_endian_1.uintFrom6Bytes(bytes, 6);
-        return { ctime, mtime, commAttrBytes: 12 };
-    }
-    function writeCommonAttrs(bytes, attrs) {
-        if (attrs.type === 'file-v1-continuous') {
-            bytes[0] = FILE_V1_CONTINUOUS_FSE;
-        }
-        else if (attrs.type === 'file-v1-w-layout') {
-            bytes[0] = FILE_V1_WITH_LAYOUT_FSE;
-        }
-        else if (attrs.type === 'folder-json-v1') {
-            bytes[0] = FOLDER_JSON_V1_FSE;
-        }
-        else if (attrs.type === 'link-json-v1') {
-            bytes[0] = LINK_JSON_V1_FSE;
-        }
-        else {
-            throw new Error(`Attribute type is not known`);
-        }
-        let ofs = 1;
-        big_endian_1.packUintTo6Bytes(attrs.ctime, bytes, ofs);
-        ofs += 6;
-        big_endian_1.packUintTo6Bytes(attrs.mtime, bytes, ofs);
-        ofs += 6;
-        if (attrs.type === 'file-v1-continuous') {
-            assert_1.assert(Number.isInteger(attrs.size) && (attrs.size >= 0));
-            big_endian_1.packUintTo8Bytes(attrs.size, bytes, ofs);
-            ofs += 8;
-        }
-        else if (attrs.type === 'file-v1-w-layout') {
-            assert_1.assert(Number.isInteger(attrs.layoutOfs) && (attrs.layoutOfs >= 0));
-            big_endian_1.packUintTo8Bytes(attrs.layoutOfs, bytes, ofs);
-            ofs += 8;
-        }
-        return ofs;
-    }
-    function readNamedAttrs(bytes, i) {
-        const xattrs = {};
-        while (i < bytes.length) {
-            const r = readNamedAttr(bytes, i);
-            if (!r) {
-                break;
-            }
-            i += r.bytesRead;
-            xattrs[r.attr.name] = r.attr;
-        }
-        return xattrs;
-    }
-    const NAMED_BINARY = 1;
-    const NAMED_UTF8_STR = 2;
-    const NAMED_JSON = 3;
-    function readNamedAttr(bytes, i) {
-        const t = parseTypeByte(bytes[i]);
-        if (!t) {
-            return;
-        }
-        let ofs = i + 1;
-        const nameLen = readLenNum(bytes, ofs, t.nameLen);
-        ofs += t.nameLen;
-        const contentLen = readLenNum(bytes, ofs, t.contentLen);
-        ofs += t.contentLen;
-        const name = bytes.slice(ofs, ofs + nameLen).toString('utf8');
-        ofs += nameLen;
-        const bytesRead = ofs - i + contentLen;
-        if ((contentLen === 0) || (bytes.length < (i + bytesRead))) {
-            throw parsingException(`Unexpected end of byte array`);
-        }
-        if (t.type === NAMED_UTF8_STR) {
-            let value;
-            try {
-                value = bytes.slice(ofs, ofs + contentLen).toString('utf8');
-            }
-            catch (err) {
-                throw parsingException(`Error in parsing `, err);
-            }
-            const attr = { type: 'named-utf8str', name, value };
-            return { attr, bytesRead };
-        }
-        else if (t.type === NAMED_JSON) {
-            let value;
-            try {
-                value = JSON.parse(buffer_utils_1.toBuffer(bytes).slice(ofs, ofs + contentLen).toString('utf8'));
-            }
-            catch (err) {
-                throw parsingException(``, err);
-            }
-            const attr = { type: 'named-json', name, value };
-            return { attr, bytesRead };
-        }
-        else if (t.type === NAMED_BINARY) {
-            const attr = {
-                type: 'named-binary', name,
-                value: bytes.slice(ofs, ofs + contentLen)
-            };
-            return { attr, bytesRead };
-        }
-        else {
-            throw new Error(`Unknown type ${t.type} of named attribute`);
-        }
-    }
-    function parseTypeByte(b) {
-        if (b === 0) {
-            return;
-        }
-        const type = ((b & 0b11100000) >> 5);
-        const nameLen = (b & 0b00011000) >> 3;
-        const contentLen = (b & 0b00000111);
-        return { type, contentLen, nameLen };
-    }
-    function readLenNum(bytes, i, len) {
-        switch (len) {
-            case 1:
-                return bytes[i];
-            case 2:
-                return big_endian_1.uintFrom2Bytes(bytes, i);
-            case 3:
-                return big_endian_1.uintFrom3Bytes(bytes, i);
-            case 4:
-                return big_endian_1.uintFrom4Bytes(bytes, i);
-            case 5:
-                return big_endian_1.uintFrom5Bytes(bytes, i);
-            case 6:
-                return big_endian_1.uintFrom6Bytes(bytes, i);
-            case 7:
-                return big_endian_1.uintFrom7Bytes(bytes, i);
-            default:
-                throw new Error(``);
-        }
-    }
-    function packNamedStrAttr(name, value) {
-        assert_1.assert((typeof name === 'string') && (name.length > 0) &&
-            (typeof value === 'string') && (value.length > 0));
-        const nameBin = Buffer.from(name, 'utf8');
-        const valueBin = Buffer.from(value, 'utf8');
-        return packNamedAttr(NAMED_UTF8_STR, nameBin, valueBin);
-    }
-    function packNamedBinaryAttr(name, value) {
-        assert_1.assert((typeof name === 'string') && (name.length > 0) &&
-            (value.length > 0));
-        const nameBin = Buffer.from(name, 'utf8');
-        return packNamedAttr(NAMED_BINARY, nameBin, value);
-    }
-    function packNamedJsonAttr(name, value) {
-        assert_1.assert((typeof name === 'string') && (name.length > 0) &&
-            (value !== undefined));
-        const nameBin = Buffer.from(name, 'utf8');
-        const valueBin = Buffer.from(JSON.stringify(value), 'utf8');
-        return packNamedAttr(NAMED_JSON, nameBin, valueBin);
-    }
-    function packNamedAttr(type, name, value) {
-        const nameLenLen = byteToStoreLen(name.length);
-        if (nameLenLen > 3) {
-            throw new Error(`Name is too long to pack`);
-        }
-        const contentLenLen = byteToStoreLen(value.length);
-        const b = Buffer.allocUnsafe(1 + nameLenLen + contentLenLen + name.length + value.length);
-        // first byte contains, left to right:
-        //  - 3 bits with type,
-        //  - 2 bits with number of bytes for name length, and
-        //  - 3 bits with number of bytes for value length
-        b[0] = (type << 5) | (nameLenLen << 3) | contentLenLen;
-        // bytes with length of name
-        let i = 1;
-        packUint(name.length, b, i, nameLenLen);
-        // bytes with length of content
-        i += nameLenLen;
-        packUint(value.length, b, i, contentLenLen);
-        // bytes with name
-        i += contentLenLen;
-        b.set(name, i);
-        // bytes with content
-        i += name.length;
-        b.set(value, i);
-        return b;
-    }
-    function byteToStoreLen(len) {
-        if (len <= 0xff) {
-            return 1;
-        }
-        else if (len <= 0xffff) {
-            return 2;
-        }
-        else if (len <= 0xffffff) {
-            return 3;
-        }
-        else if (len <= 0xffffffff) {
-            return 4;
-        }
-        else if (len <= 0xffffffffff) {
-            return 5;
-        }
-        else if (len <= 0xffffffffffff) {
-            return 6;
-        }
-        else {
-            return 7;
-        }
-    }
-    function packUint(u, b, i, byteToUse) {
-        switch (byteToUse) {
-            case 1:
-                b[i] = u;
-                break;
-            case 2:
-                big_endian_1.packUintTo2Bytes(u, b, i);
-                break;
-            case 3:
-                big_endian_1.packUintTo3Bytes(u, b, i);
-                break;
-            case 4:
-                big_endian_1.packUintTo4Bytes(u, b, i);
-                break;
-            case 5:
-                big_endian_1.packUintTo5Bytes(u, b, i);
-                break;
-            case 6:
-                big_endian_1.packUintTo6Bytes(u, b, i);
-                break;
-            case 7:
-                big_endian_1.packUintTo7Bytes(u, b, i);
-                break;
-            default:
-                assert_1.assert(false);
-        }
-    }
-    const FIXED_ATTRS_LEN = 1 + 6 + 6 + 8;
-    function packAttrs(attrs) {
-        const ext = [];
-        for (const xattr of Object.values(attrs.ext)) {
-            if (xattr.type === 'named-utf8str') {
-                ext.push(packNamedStrAttr(xattr.name, xattr.value));
-            }
-            else if (xattr.type === 'named-json') {
-                ext.push(packNamedJsonAttr(xattr.name, xattr.value));
-            }
-            else if (xattr.type === 'named-binary') {
-                ext.push(packNamedBinaryAttr(xattr.name, xattr.value));
-            }
-            else {
-                throw new Error(`Unknown type of named attribute`);
-            }
-        }
-        let attrsLen = FIXED_ATTRS_LEN + ext.reduce((len, b) => len + b.length, 0);
-        const bytes = Buffer.alloc(attrsLen, 0);
-        writeCommonAttrs(bytes, attrs);
-        let ofs = FIXED_ATTRS_LEN;
-        for (const buf of ext) {
-            bytes.set(buf, ofs);
-            ofs += buf.length;
-        }
-        return bytes;
-    }
-    attrV1.packAttrs = packAttrs;
-    function byteLenOf(attrs) {
-        return packAttrs(attrs).length;
-    }
-    attrV1.byteLenOf = byteLenOf;
-})(attrV1 || (attrV1 = {}));
-Object.freeze(attrV1);
-function parsingException(msg, cause) {
-    return {
-        runtimeException: true,
-        type: 'attrs-parsing',
-        cause, msg
-    };
-}
-function checkAttrs(json) {
-    assert_1.assert(isFSEntityType(json.type) &&
-        Number.isInteger(json.ctime) && Number.isInteger(json.mtime) &&
-        !!json.ext && (typeof json.ext === 'object'));
-    for (const n of Object.keys(json.ext)) {
-        const v = json.ext[n];
-        assert_1.assert(isNamedAttrType(v.type) && (typeof v.name === 'string'));
-        if (v.type === 'named-utf8str') {
-            assert_1.assert(typeof v.value === 'string');
-        }
-        else if (v.type === 'named-binary') {
-            assert_1.assert(Buffer.isBuffer(v.value));
-        }
-        else {
-            assert_1.assert((v.value !== undefined) && (typeof v.value !== 'string'));
-        }
-    }
-    return json;
-}
-function isFSEntityType(type) {
-    return ((typeof type === 'string') && ((type === 'file-v1-continuous') || (type === 'file-v1-w-layout') ||
-        (type === 'folder-json-v1') || (type === 'link-json-v1')));
-}
-function isNamedAttrType(type) {
-    return ((typeof type === 'string') && ((type === 'named-binary') || (type === 'named-json') ||
-        (type === 'named-utf8str')));
-}
-class AttrsHolder {
-    constructor(attrs, modifiable = false) {
-        this.attrs = attrs;
-        this.modifiable = modifiable;
-        Object.seal(this);
-    }
-    modifiableCopy() {
-        return new AttrsHolder(json_utils_1.copy(this.attrs), true);
-    }
-    static fromBytesReadonly(bytes) {
-        const attrs = readAttrs(buffer_utils_1.toBuffer(bytes));
-        return new AttrsHolder(attrs, false);
-    }
-    static fromJSONReadonly(attrs) {
-        return new AttrsHolder(checkAttrs(attrs), false);
-    }
-    static makeReadonlyForFile(now) {
-        const attrs = makeFileAttrs(now);
-        return new AttrsHolder(attrs, false);
-    }
-    static makeReadonlyForFolder(now) {
-        const attrs = makeFolderAttrs(now);
-        return new AttrsHolder(attrs, false);
-    }
-    static makeReadonlyForLink(now) {
-        const attrs = makeLinkAttrs(now);
-        return new AttrsHolder(attrs, false);
-    }
-    toBytes() {
-        return attrV1.packAttrs(this.attrs);
-    }
-    setReadonly() {
-        this.modifiable = false;
-    }
-    get isReadonly() {
-        return !this.modifiable;
-    }
-    throwIfReadonly() {
-        if (!this.modifiable) {
-            throw new Error(`Can't change readonly attributes`);
-        }
-    }
-    get ctime() {
-        return this.attrs.ctime;
-    }
-    set ctime(epoch) {
-        this.throwIfReadonly();
-        this.attrs.ctime = epoch;
-    }
-    get mtime() {
-        return this.attrs.mtime;
-    }
-    set mtime(epoch) {
-        this.throwIfReadonly();
-        this.attrs.mtime = epoch;
-    }
-    get type() {
-        return this.attrs.type;
-    }
-    get serializedLen() {
-        return attrV1.byteLenOf(this.attrs);
-    }
-    getFileLayoutOfs() {
-        if (this.attrs.type !== 'file-v1-w-layout') {
-            return;
-        }
-        return this.attrs.layoutOfs;
-    }
-    getFileSize() {
-        if (this.attrs.type !== 'file-v1-continuous') {
-            return;
-        }
-        return this.attrs.size;
-    }
-    setFileLayoutOfs(ofs) {
-        this.throwIfReadonly();
-        assert_1.assert(Number.isInteger(ofs) && (ofs >= 0));
-        if (this.attrs.type === 'file-v1-w-layout') {
-            this.attrs.layoutOfs = ofs;
-        }
-        else if (this.attrs.type === 'file-v1-continuous') {
-            delete this.attrs.size;
-            this.attrs.type = 'file-v1-w-layout';
-            this.attrs.layoutOfs = ofs;
-        }
-        else {
-            throw new Error(`Layout is not supported in attributes ${this.attrs.type}`);
-        }
-    }
-    setContinuousFileSize(size) {
-        this.throwIfReadonly();
-        assert_1.assert(Number.isInteger(size) && (size >= 0));
-        if (this.attrs.type === 'file-v1-continuous') {
-            this.attrs.size = size;
-        }
-        else if (this.attrs.type === 'file-v1-w-layout') {
-            delete this.attrs.layoutOfs;
-            this.attrs.type = 'file-v1-continuous';
-            this.attrs.size = size;
-        }
-        else {
-            throw new Error(`File size is not supported in attributes ${this.attrs.type}`);
-        }
-    }
-    getXAttr(xaName) {
-        const namedAttr = this.attrs.ext[xaName];
-        if (!namedAttr) {
-            return;
-        }
-        return namedAttr.value;
-    }
-    updateXAttrs(changes) {
-        this.throwIfReadonly();
-        if (Array.isArray(changes.remove)) {
-            for (const xaName of changes.remove) {
-                delete this.attrs.ext[xaName];
-            }
-        }
-        if ((typeof changes.set === 'object') && changes.set) {
-            for (const xaName of Object.keys(changes.set)) {
-                const value = changes.set[xaName];
-                if (value === undefined) {
-                    continue;
-                }
-                this.attrs.ext[xaName] = {
-                    name: xaName,
-                    type: attrType(value),
-                    value
-                };
-            }
-        }
-    }
-    listXAttrs() {
-        return Object.keys(this.attrs.ext);
-    }
-}
-exports.AttrsHolder = AttrsHolder;
-Object.freeze(AttrsHolder.prototype);
-Object.freeze(AttrsHolder);
-Object.freeze(exports);

package/build/lib-client/files/file-layout.d.ts

@@ -1,56 +0,0 @@
-import { ByteSource, Layout } from "xsp-files";
-declare type FileLayout = web3n.files.FileLayout;
-export interface ContentSection {
-    ofsInSrc?: number;
-    ofs: number;
-    len: number;
-}
-export declare class ROFileLayout {
-    private readonly sections;
-    private readonly layoutOfs;
-    private constructor();
-    static orderedWithSize(size: number): ROFileLayout;
-    static readFromSrc(src: ByteSource, layoutOfs: number): Promise<ROFileLayout>;
-    get contentSize(): number;
-    getSectionsIn(ofs: number, len: number | undefined): ContentSection[];
-    makeWritableClone(): RWFileLayout;
-}
-/**
- * This layout expects that writes of new bytes always append raw source,
- * while cuts in raw source remove base bytes, but don't remove already written
- * new bytes, leaving them as noise.
- */
-export declare class RWFileLayout {
-    private readonly sections;
-    private srcBaseLen;
-    private writePosition;
-    constructor(sections: ContentSection[], srcBaseLen: number);
-    static orderedWithBaseSize(size: number): RWFileLayout;
-    static readFromSrc(src: ByteSource, layoutOfs: number): Promise<RWFileLayout>;
-    get contentSize(): number;
-    getSectionsIn(ofs: number, len: number | undefined): ContentSection[];
-    getLayoutOfsInSink(): number;
-    packIfNotTrivial(sinkLen: {
-        size: number;
-        isEndless: boolean;
-    }): Uint8Array | undefined;
-    private isTrivialLayout;
-    toFileLayoutBasedOnSegs(segs: Layout): FileLayout;
-    private findOffsetPosition;
-    cutSection(ofs: number, len: number): Cut[];
-    private shiftSectonOffsets;
-    private turnToBaseCutsAdjustingSrcOfs;
-    private checkAndCompactFourSections;
-    appendEmptySection(len: number): void;
-    insertSection(ofs: number, len: number): number;
-}
-interface Cut {
-    ofs: number;
-    len: number;
-}
-export interface FileLayoutException extends web3n.RuntimeException {
-    type: 'file-layout';
-    msg: string;
-}
-export declare function fileLayoutException(msg: string, cause?: any): FileLayoutException;
-export {};