hadron-document 7.8.0 → 7.11.0

package/dist/element.js

@@ -0,0 +1,669 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedList = exports.Element = exports.isInternalFieldPath = exports.Events = exports.DATE_FORMAT = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+const lodash_keys_1 = __importDefault(require("lodash.keys"));
+const lodash_isplainobject_1 = __importDefault(require("lodash.isplainobject"));
+const lodash_isarray_1 = __importDefault(require("lodash.isarray"));
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const lodash_isstring_1 = __importDefault(require("lodash.isstring"));
+const object_generator_1 = __importDefault(require("./object-generator"));
+const hadron_type_checker_1 = __importDefault(require("hadron-type-checker"));
+const bson_1 = require("bson");
+const date_1 = __importDefault(require("./editor/date"));
+const element_events_1 = __importDefault(require("./element-events"));
+exports.Events = element_events_1.default;
+const _1 = require(".");
+exports.DATE_FORMAT = 'YYYY-MM-DD HH:mm:ss.SSS';
+const ID = '_id';
+function isInternalFieldPath(path) {
+    return typeof path === 'string' && /^__safeContent__($|\.)/.test(path);
+}
+exports.isInternalFieldPath = isInternalFieldPath;
+const UNEDITABLE_TYPES = [
+    'Binary',
+    'Code',
+    'MinKey',
+    'MaxKey',
+    'Timestamp',
+    'BSONRegExp',
+    'Undefined',
+    'Null',
+    'DBRef',
+];
+const CURLY = '{';
+const BRACKET = '[';
+const ARRAY_OR_OBJECT = /^(\[|\{)(.+)(\]|\})$/;
+class Element extends eventemitter3_1.default {
+    constructor(key, value, added = false, parent = null, previousElement = null, nextElement = null) {
+        super();
+        this.uuid = new bson_1.UUID().toHexString();
+        this.key = key;
+        this.currentKey = key;
+        this.parent = parent;
+        this.previousElement = previousElement;
+        this.nextElement = nextElement;
+        this.added = added;
+        this.removed = false;
+        this.type = hadron_type_checker_1.default.type(value);
+        this.currentType = this.type;
+        this.level = this._getLevel();
+        this.setValid();
+        if (this._isExpandable(value)) {
+            this.elements = this._generateElements(value);
+            this.originalExpandableValue = value;
+        }
+        else {
+            this.value = value;
+            this.currentValue = value;
+        }
+        let parentValue;
+        if (this.parent) {
+            parentValue = this.parent.isRoot()
+                ? this.parent.doc
+                : this.parent.originalExpandableValue;
+        }
+        const parentDecryptedKeys = parentValue && parentValue[Symbol.for('@@mdb.decryptedKeys')];
+        this.decrypted = (parentDecryptedKeys || [])
+            .map(String)
+            .includes(String(key));
+    }
+    bulkEdit(value) {
+        if (ARRAY_OR_OBJECT.exec(value)) {
+            this.edit(JSON.parse(value));
+            this._bubbleUp(element_events_1.default.Converted, this);
+        }
+        else {
+            this.edit(value);
+        }
+    }
+    cancel() {
+        if (this.elements) {
+            for (const element of Array.from(this.elements)) {
+                element.cancel();
+            }
+        }
+        if (this.isModified()) {
+            this.revert();
+        }
+    }
+    _getLevel() {
+        let level = -1;
+        let parent = this.parent;
+        while (parent) {
+            level++;
+            parent = parent.parent;
+        }
+        return level;
+    }
+    edit(value) {
+        this.currentType = hadron_type_checker_1.default.type(value);
+        if (this._isExpandable(value) && !this._isExpandable(this.currentValue)) {
+            this.currentValue = null;
+            this.elements = this._generateElements(value);
+        }
+        else if (!this._isExpandable(value) && this.elements) {
+            this.currentValue = value;
+            this.elements = undefined;
+        }
+        else {
+            this.currentValue = value;
+        }
+        this.setValid();
+        this._bubbleUp(element_events_1.default.Edited, this);
+    }
+    changeType(newType) {
+        if (newType === 'Object') {
+            this.edit('{');
+            this.next();
+        }
+        else if (newType === 'Array') {
+            this.edit('[');
+            this.next();
+        }
+        else {
+            try {
+                if (newType === 'Date') {
+                    const editor = new date_1.default(this);
+                    editor.edit(this.generateObject());
+                    editor.complete();
+                }
+                else {
+                    this.edit(hadron_type_checker_1.default.cast(this.generateObject(), newType));
+                }
+            }
+            catch (e) {
+                this.setInvalid(this.currentValue, newType, e.message);
+            }
+        }
+    }
+    getRoot() {
+        var _a;
+        let parent = this.parent;
+        while ((_a = parent) === null || _a === void 0 ? void 0 : _a.parent) {
+            parent = parent.parent;
+        }
+        return parent;
+    }
+    get(key) {
+        return this.elements ? this.elements.get(key) : undefined;
+    }
+    at(i) {
+        return this.elements ? this.elements.at(i) : undefined;
+    }
+    next() {
+        if (this.currentValue === CURLY) {
+            return this._convertToEmptyObject();
+        }
+        else if (this.currentValue === BRACKET) {
+            return this._convertToEmptyArray();
+        }
+        return this._next();
+    }
+    rename(key) {
+        if (this.parent) {
+            const elm = this.parent.elements._map[this.currentKey];
+            delete this.parent.elements._map[this.currentKey];
+            this.parent.elements._map[key] = elm;
+        }
+        this.currentKey = key;
+        this._bubbleUp(element_events_1.default.Edited, this);
+    }
+    generateObject(options) {
+        if (this.currentType === 'Array') {
+            return object_generator_1.default.generateArray(this.elements, options);
+        }
+        if (this.currentType === 'Object') {
+            return object_generator_1.default.generate(this.elements, options);
+        }
+        return this.currentValue;
+    }
+    generateOriginalObject(options) {
+        if (this.type === 'Array') {
+            const originalElements = this._generateElements(this.originalExpandableValue);
+            return object_generator_1.default.generateOriginalArray(originalElements, options);
+        }
+        if (this.type === 'Object') {
+            const originalElements = this._generateElements(this.originalExpandableValue);
+            return object_generator_1.default.generateOriginal(originalElements, options);
+        }
+        return this.value;
+    }
+    insertAfter(element, key, value) {
+        if (!this.elements) {
+            throw new Error('Cannot insert values on non-array/non-object elements');
+        }
+        if (this.currentType === 'Array') {
+            if (element.currentKey === '') {
+                this.elements.handleEmptyKeys(element);
+            }
+            key = element.currentKey + 1;
+        }
+        const newElement = this.elements.insertAfter(element, key, value, true, this);
+        if (this.currentType === 'Array') {
+            this.elements.updateKeys(newElement, 1);
+        }
+        newElement._bubbleUp(element_events_1.default.Added, newElement, this);
+        return newElement;
+    }
+    insertEnd(key, value) {
+        if (!this.elements) {
+            throw new Error('Cannot insert values on non-array/non-object elements');
+        }
+        if (this.currentType === 'Array') {
+            this.elements.flush();
+            key = 0;
+            if (this.elements.lastElement) {
+                if (this.elements.lastElement.currentKey === '') {
+                    this.elements.handleEmptyKeys(this.elements.lastElement);
+                }
+                key = this.elements.lastElement.currentKey + 1;
+            }
+        }
+        const newElement = this.elements.insertEnd(key, value, true, this);
+        this._bubbleUp(element_events_1.default.Added, newElement);
+        return newElement;
+    }
+    insertPlaceholder() {
+        return this.insertEnd('', '');
+    }
+    insertSiblingPlaceholder() {
+        return this.parent.insertAfter(this, '', '');
+    }
+    isAdded() {
+        var _a;
+        return this.added || !!((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isAdded());
+    }
+    isBlank() {
+        return this.currentKey === '' && this.currentValue === '';
+    }
+    isCurrentTypeValid() {
+        return !!this.currentTypeValid;
+    }
+    setValid() {
+        this.currentTypeValid = true;
+        this.invalidTypeMessage = undefined;
+        this._bubbleUp(element_events_1.default.Valid, this);
+    }
+    setInvalid(value, newType, message) {
+        this.currentValue = value;
+        this.currentType = newType;
+        this.currentTypeValid = false;
+        this.invalidTypeMessage = message;
+        this._bubbleUp(element_events_1.default.Invalid, this);
+    }
+    isDuplicateKey(value) {
+        var _a, _b;
+        if (value === '') {
+            return false;
+        }
+        for (const element of (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.elements) !== null && _b !== void 0 ? _b : []) {
+            if (element.uuid !== this.uuid && element.currentKey === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isEdited() {
+        return ((this.isRenamed() ||
+            !this._valuesEqual() ||
+            this.type !== this.currentType) &&
+            !this.isAdded());
+    }
+    _valuesEqual() {
+        if (this.currentType === 'Date' && (0, lodash_isstring_1.default)(this.currentValue)) {
+            return (0, lodash_isequal_1.default)(this.value, new Date(this.currentValue));
+        }
+        else if (this.currentType === 'ObjectId' && (0, lodash_isstring_1.default)(this.currentValue)) {
+            return this._isObjectIdEqual();
+        }
+        return (0, lodash_isequal_1.default)(this.value, this.currentValue);
+    }
+    _isObjectIdEqual() {
+        try {
+            return this.value.toHexString() === this.currentValue;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    isLast() {
+        var _a, _b;
+        return ((_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.elements) === null || _b === void 0 ? void 0 : _b.lastElement) === this;
+    }
+    isRenamed() {
+        let keyChanged = false;
+        if (!this.parent ||
+            this.parent.isRoot() ||
+            this.parent.currentType === 'Object') {
+            keyChanged = this.key !== this.currentKey;
+        }
+        return keyChanged;
+    }
+    isRevertable() {
+        return this.isEdited() || this.isRemoved();
+    }
+    isRemovable() {
+        return !this.parent.isRemoved();
+    }
+    isNotActionable() {
+        return (((this.key === ID || this.isInternalField()) && !this.isAdded()) ||
+            !this.isRemovable());
+    }
+    isValueDecrypted() {
+        return this.decrypted;
+    }
+    containsDecryptedChildren() {
+        if (this.isValueDecrypted()) {
+            return true;
+        }
+        for (const element of this.elements || []) {
+            if (element.containsDecryptedChildren()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isValueEditable() {
+        return (this._isKeyLegallyEditable() &&
+            !UNEDITABLE_TYPES.includes(this.currentType));
+    }
+    isParentEditable() {
+        if (this.parent && !this.parent.isRoot()) {
+            return this.parent._isKeyLegallyEditable();
+        }
+        return true;
+    }
+    _isKeyLegallyEditable() {
+        return (this.isParentEditable() &&
+            (this.isAdded() || (this.currentKey !== ID && !this.isInternalField())));
+    }
+    isKeyEditable() {
+        return this._isKeyLegallyEditable() && !this.containsDecryptedChildren();
+    }
+    isInternalField() {
+        if (!this.parent)
+            return false;
+        if (!this.parent.isRoot() && this.parent.isInternalField()) {
+            return true;
+        }
+        if (this.parent.isRoot() && isInternalFieldPath(this.currentKey)) {
+            return true;
+        }
+        return false;
+    }
+    isModified() {
+        if (this.elements) {
+            for (const element of this.elements) {
+                if (element.isModified()) {
+                    return true;
+                }
+            }
+        }
+        return this.isAdded() || this.isEdited() || this.isRemoved();
+    }
+    isRemoved() {
+        return this.removed;
+    }
+    isRoot() {
+        return false;
+    }
+    remove() {
+        this.revert();
+        this.removed = true;
+        if (this.parent) {
+            this._bubbleUp(element_events_1.default.Removed, this, this.parent);
+        }
+    }
+    revert() {
+        var _a;
+        if (this.isAdded()) {
+            if (((_a = this.parent) === null || _a === void 0 ? void 0 : _a.currentType) === 'Array') {
+                this.parent.elements.updateKeys(this, -1);
+            }
+            this.parent.elements.remove(this);
+            this._bubbleUp(element_events_1.default.Removed, this, this.parent);
+            this.parent = null;
+        }
+        else {
+            if (this.originalExpandableValue) {
+                this.elements = this._generateElements(this.originalExpandableValue);
+                this.currentValue = undefined;
+            }
+            else {
+                if (this.currentValue === null && this.value !== null) {
+                    this.elements = null;
+                }
+                else {
+                    this._removeAddedElements();
+                }
+                this.currentValue = this.value;
+            }
+            this.currentKey = this.key;
+            this.currentType = this.type;
+            this.removed = false;
+        }
+        this.setValid();
+        this._bubbleUp(element_events_1.default.Reverted, this);
+    }
+    _bubbleUp(evt, ...data) {
+        this.emit(evt, ...data);
+        const element = this.parent;
+        if (element) {
+            if (element.isRoot()) {
+                element.emit(evt, ...data);
+            }
+            else {
+                element._bubbleUp(evt, ...data);
+            }
+        }
+    }
+    _convertToEmptyObject() {
+        this.edit({});
+        this.insertPlaceholder();
+    }
+    _convertToEmptyArray() {
+        this.edit([]);
+        this.insertPlaceholder();
+    }
+    _isElementEmpty(element) {
+        return !!element && element.isAdded() && element.isBlank();
+    }
+    _isExpandable(value) {
+        return (0, lodash_isplainobject_1.default)(value) || (0, lodash_isarray_1.default)(value);
+    }
+    _generateElements(object) {
+        return new LinkedList(this, object);
+    }
+    _key(key, index) {
+        return this.currentType === 'Array' ? index : key;
+    }
+    _next() {
+        if (!this._isElementEmpty(this.nextElement) &&
+            !this._isElementEmpty(this)) {
+            this.parent.insertAfter(this, '', '');
+        }
+    }
+    _removeAddedElements() {
+        if (this.elements) {
+            for (const element of this.elements) {
+                if (element.isAdded()) {
+                    this.elements.remove(element);
+                }
+            }
+        }
+    }
+    static get Events() {
+        return _1.ElementEvents;
+    }
+}
+exports.Element = Element;
+class LinkedList {
+    constructor(doc, originalDoc) {
+        this.firstElement = null;
+        this.lastElement = null;
+        this.doc = doc;
+        this.originalDoc = originalDoc;
+        this.keys = (0, lodash_keys_1.default)(this.originalDoc);
+        if (this.doc.currentType === 'Array') {
+            this.keys = this.keys.map((k) => parseInt(k, 10));
+        }
+        this.size = this.keys.length;
+        this.loaded = 0;
+        this._map = {};
+    }
+    at(index) {
+        this.flush();
+        if (!Number.isInteger(index)) {
+            return undefined;
+        }
+        let element = this.firstElement;
+        for (let i = 0; i < index; i++) {
+            if (!element) {
+                return undefined;
+            }
+            element = element.nextElement;
+        }
+        return element === null ? undefined : element;
+    }
+    get(key) {
+        this.flush();
+        return this._map[key];
+    }
+    insertAfter(element, key, value, added, parent) {
+        this.flush();
+        return this._insertAfter(element, key, value, added, parent);
+    }
+    updateKeys(element, add) {
+        this.flush();
+        while (element.nextElement) {
+            element.nextElement.currentKey += add;
+            element = element.nextElement;
+        }
+    }
+    handleEmptyKeys(element) {
+        if (element.currentKey === '') {
+            let e = element;
+            while (e.currentKey === '') {
+                if (!e.previousElement) {
+                    e.currentKey = 0;
+                    break;
+                }
+                else {
+                    e = e.previousElement;
+                }
+            }
+            while (e.nextElement) {
+                e.nextElement.currentKey = e.currentKey + 1;
+                e = e.nextElement;
+            }
+        }
+    }
+    insertBefore(element, key, value, added, parent) {
+        this.flush();
+        return this._insertBefore(element, key, value, added, parent);
+    }
+    insertBeginning(key, value, added, parent) {
+        this.flush();
+        return this._insertBeginning(key, value, added, parent);
+    }
+    insertEnd(key, value, added, parent) {
+        this.flush();
+        if (!this.lastElement) {
+            return this.insertBeginning(key, value, added, parent);
+        }
+        return this.insertAfter(this.lastElement, key, value, added, parent);
+    }
+    flush() {
+        var _a;
+        if (this.loaded < this.size) {
+            for (const element of this) {
+                (_a = element === null || element === void 0 ? void 0 : element.elements) === null || _a === void 0 ? void 0 : _a.flush();
+            }
+        }
+    }
+    *[Symbol.iterator]() {
+        let currentElement;
+        let index = 0;
+        while (true) {
+            if (this._needsLazyLoad(index)) {
+                const key = this.keys[index];
+                index += 1;
+                currentElement = this._lazyInsertEnd(key);
+                yield currentElement;
+            }
+            else if (this._needsStandardIteration(index)) {
+                if (currentElement) {
+                    currentElement = currentElement.nextElement;
+                }
+                else {
+                    currentElement = this.firstElement;
+                }
+                if (currentElement) {
+                    index += 1;
+                    yield currentElement;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                break;
+            }
+        }
+    }
+    _needsLazyLoad(index) {
+        return ((index === 0 && this.loaded === 0 && this.size > 0) ||
+            (this.loaded <= index && index < this.size));
+    }
+    _needsStandardIteration(index) {
+        return this.loaded > 0 && index < this.loaded && index < this.size;
+    }
+    _lazyInsertEnd(key) {
+        this.size -= 1;
+        return this._insertEnd(key, this.originalDoc[key], this.doc.cloned, this.doc);
+    }
+    _insertEnd(key, value, added, parent) {
+        if (!this.lastElement) {
+            return this._insertBeginning(key, value, added, parent);
+        }
+        return this._insertAfter(this.lastElement, key, value, added, parent);
+    }
+    _insertBefore(element, key, value, added, parent) {
+        const newElement = new Element(key, value, added, parent, element.previousElement, element);
+        if (element.previousElement) {
+            element.previousElement.nextElement = newElement;
+        }
+        else {
+            this.firstElement = newElement;
+        }
+        element.previousElement = newElement;
+        this._map[newElement.key] = newElement;
+        this.size += 1;
+        this.loaded += 1;
+        return newElement;
+    }
+    _insertBeginning(key, value, added, parent) {
+        if (!this.firstElement) {
+            const element = new Element(key, value, added, parent, null, null);
+            this.firstElement = this.lastElement = element;
+            this.size += 1;
+            this.loaded += 1;
+            this._map[element.key] = element;
+            return element;
+        }
+        const newElement = this.insertBefore(this.firstElement, key, value, added, parent);
+        this._map[newElement.key] = newElement;
+        return newElement;
+    }
+    _insertAfter(element, key, value, added, parent) {
+        const newElement = new Element(key, value, added, parent, element, element.nextElement);
+        if (element.nextElement) {
+            element.nextElement.previousElement = newElement;
+        }
+        else {
+            this.lastElement = newElement;
+        }
+        element.nextElement = newElement;
+        this._map[newElement.key] = newElement;
+        this.size += 1;
+        this.loaded += 1;
+        return newElement;
+    }
+    remove(element) {
+        this.flush();
+        if (element.previousElement) {
+            element.previousElement.nextElement = element.nextElement;
+        }
+        else {
+            this.firstElement = element.nextElement;
+        }
+        if (element.nextElement) {
+            element.nextElement.previousElement = element.previousElement;
+        }
+        else {
+            this.lastElement = element.previousElement;
+        }
+        element.nextElement = element.previousElement = null;
+        delete this._map[element.currentKey];
+        this.size -= 1;
+        this.loaded -= 1;
+        return this;
+    }
+    findIndex(el) {
+        let idx = 0;
+        for (const item of this) {
+            if (item === el) {
+                return idx;
+            }
+            idx++;
+        }
+        return -1;
+    }
+}
+exports.LinkedList = LinkedList;
+exports.default = Element;
+//# sourceMappingURL=element.js.map