hadron-document 7.6.0 → 7.9.0

package/.depcheckrc

@@ -1,8 +1,6 @@
 ignores: [
   "debug",
   "lodash.foreach",
-  "react",
-  "react-dom",
   "@babel/register",
   "babel-loader"
 ]

package/index.d.ts

@@ -0,0 +1,192 @@
+import type { TypeCastTypes, TypeCastMap } from 'hadron-type-checker';
+
+declare class EventEmitter {
+  on(name: string, fn: Function): void;
+  off(name: string, fn: Function): void;
+  emit(name: string, ...args: unknown[]): void;
+}
+
+declare class LinkedList<T> {
+  size: number;
+  at(index: number): T | undefined;
+  get(key: string): T | undefined;
+  insertAfter(
+    el: T,
+    key: string,
+    value: unknown,
+    added?: boolean,
+    parent?: T
+  ): T;
+  updateKeys(el: T, add: 1 | -1): void;
+  handleEmptyKeys(el: T): void;
+  insertBefore(
+    el: T,
+    key: string,
+    value: unknown,
+    added?: boolean,
+    parent?: T
+  ): T;
+  insertBeginning(key: string, value: unknown, added?: boolean, parent?: T): T;
+  insertEnd(key: string, value: unknown, added?: boolean, parent?: T): T;
+  flush(): void;
+  [Symbol.iterator](): IterableIterator<T>;
+  remove(el: T): this;
+}
+
+declare const HadronElementEvents: {
+  Added: 'Element::Added';
+  Edited: 'Element::Edited';
+  Removed: 'Element::Removed';
+  Reverted: 'Element::Reverted';
+  Converted: 'Element::Converted';
+  Invalid: 'Element::Invalid';
+  Valid: 'Element::Valid';
+};
+
+declare class HadronElement extends EventEmitter {
+  constructor(
+    key: string,
+    value: unknown,
+    added: boolean,
+    parent: HadronDocument | HadronElement | null,
+    previousElement: HadronElement | null,
+    nextElement: HadronElement | null
+  );
+  uuid: string;
+  key: string;
+  currentKey: string;
+  parent: HadronDocument | HadronElement | null;
+  previousElement: HadronElement | null;
+  nextElement: HadronElement | null;
+  added: boolean;
+  removed: boolean;
+  type: TypeCastTypes;
+  currentType: TypeCastTypes;
+  currentTypeValid: boolean;
+  invalidTypeMessage?: string;
+  elements?: LinkedList<HadronElement>;
+  originalExpandableValue?: TypeCastMap[typeof this.type];
+  value?: TypeCastMap[typeof this.type];
+  currentValue: TypeCastMap[typeof this.type];
+  level: number;
+  bulkEdit(value: string): void;
+  cancel(): void;
+  edit(value: unknown): void;
+  changeType(newType: TypeCastTypes): void;
+  get(key: string): HadronElement | undefined;
+  at(i: number): HadronElement | undefined;
+  next(): HadronElement;
+  rename(key: string): void;
+  generateObject(): unknown;
+  generateOriginalObject(): unknown;
+  insertAfter(element: HadronElement, key: string, value: unknown): HadronElement;
+  insertEnd(key: string, value: unknown): HadronElement;
+  insertPlaceholder(): HadronElement;
+  insertSiblingPlaceholder(): HadronElement;
+  isAdded(): boolean;
+  isBlank(): boolean;
+  isCurrentTypeValid(): boolean;
+  setValid(): void;
+  setInvalid(value: unknown, newType: string, message: string): void;
+  isDuplicateKey(key: string): boolean;
+  isEdited(): boolean;
+  isLast(): boolean;
+  isRenamed(): boolean;
+  isRevertable(): boolean;
+  isRemovable(): boolean;
+  isNotActionable(): boolean;
+  isValueEditable(): boolean;
+  isParentEditable(): boolean;
+  isKeyEditable(): boolean;
+  isModified(): boolean;
+  isRemoved(): boolean;
+  isRoot(): false;
+  remove(): void;
+  revert(): void;
+  static Events: typeof HadronElementEvents;
+}
+
+declare const HadronDocumentEvents: {
+  Cancel: 'Document::Cancel';
+};
+
+declare class HadronDocument extends EventEmitter {
+  constructor(doc: unknown, cloned: boolean);
+  uuid: string;
+  type: 'Document';
+  currentType: 'Document';
+  elements: LinkedList<HadronElement>;
+  cancel(): void;
+  apply(doc: unknown): void;
+  generateObject(): unknown;
+  generateOriginalObject(): unknown;
+  generateUpdateUnlessChangedInBackgroundQuery(
+    alwaysIncludeKeys: null | unknown
+  ): { query: unknown; updateDoc: unknown };
+  get(key: string): HadronElement;
+  getChild(path: string[]): HadronElement;
+  getId(): unknown | null;
+  getOriginalKeysAndValuesForFieldsThatWereUpdated(
+    alwaysIncludeKeys: null | unknown
+  ): unknown;
+  getOriginalKeysAndValuesForSpecifiedKeys(keys: unknown): unknown;
+  getSetUpdateForDocumentChanges(): unknown;
+  getStringId(): string;
+  getUnsetUpdateForDocumentChanges(): unknown;
+  insertPlaceholder(): HadronElement;
+  insertEnd(key: string, value: unknown): HadronElement;
+  insertBeginning(key: string, value: unknown): HadronElement;
+  insertAfter(
+    element: HadronElement,
+    key: string,
+    value: unknown
+  ): HadronElement;
+  isAdded(): false;
+  isModified(): boolean;
+  isRemoved(): false;
+  isRoot(): true;
+  next(): void;
+  static Events: typeof HadronDocumentEvents;
+}
+
+export declare class Editor {
+  constructor(element: HadronElement);
+  element: HadronElement;
+  edit(value: unknown): void;
+  paste(value: string): void;
+  size(): number;
+  value(): unknown;
+  start(): void;
+  complete(): void;
+}
+
+declare const ElementEditor: {
+  (element: HadronElement): {
+    Standard: Editor;
+    String: Editor;
+    Decimal128: Editor;
+    Date: Editor;
+    Double: Editor;
+    Int32: Editor;
+    Int64: Editor;
+    Null: Editor;
+    Undefined: Editor;
+    ObjectId: Editor;
+  };
+  DateEditor: typeof Editor;
+  StandardEditor: typeof Editor;
+  StringEditor: typeof Editor;
+  Decimal128Editor: typeof Editor;
+  DoubleEditor: typeof Editor;
+  Int32Editor: typeof Editor;
+  Int64Editor: typeof Editor;
+  NullEditor: typeof Editor;
+  UndefinedEditor: typeof Editor;
+  ObjectIdEditor: typeof Editor;
+};
+
+export default HadronDocument;
+export { HadronDocumentEvents as DocumentEvents };
+export { HadronElement as Element };
+export { HadronElementEvents as ElementEvents };
+export { ElementEditor };

package/lib/document.js

@@ -1,26 +1,42 @@
 'use strict';
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
@@ -36,6 +52,8 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 
 var EventEmitter = require('eventemitter3');
 
+var uuid = require('uuid');
+
 var Element = require('./element');
 
 var LinkedList = Element.LinkedList;
@@ -75,18 +93,15 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
     _classCallCheck(this, Document);
 
     _this = _super.call(this);
+    _this.uuid = uuid.v4();
     _this.doc = doc;
     _this.cloned = cloned || false;
     _this.isUpdatable = true;
     _this.elements = _this._generateElements();
+    _this.type = 'Document';
+    _this.currentType = 'Document';
     return _this;
   }
-  /**
-   * Generate the javascript object for this document.
-   *
-   * @returns {Object} The javascript object.
-   */
-
 
   _createClass(Document, [{
     key: "cancel",
@@ -95,22 +110,52 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
      * Send cancel event.
      */
     function cancel() {
-      var _iterator = _createForOfIteratorHelper(this.elements),
-          _step;
+      // Cancel will remove elements from iterator, clone it before iterating
+      // otherwise we will skip items
+      for (var _i = 0, _Array$from = Array.from(this.elements); _i < _Array$from.length; _i++) {
+        var element = _Array$from[_i];
+        element.cancel();
+      }
 
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var element = _step.value;
-          element.cancel();
+      this.emit(Events.Cancel);
+    }
+  }, {
+    key: "apply",
+    value: function apply(doc) {
+      var updatedKeys = [];
+      var prevKey = null;
+
+      for (var _i2 = 0, _Object$entries = Object.entries(doc); _i2 < _Object$entries.length; _i2++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2),
+            key = _Object$entries$_i[0],
+            value = _Object$entries$_i[1];
+
+        if (this.get(key)) {
+          this.get(key).edit(value);
+        } else if (prevKey) {
+          this.insertAfter(this.get(prevKey), key, value);
+        } else {
+          this.insertBeginning(key, value);
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+
+        prevKey = key;
+        updatedKeys.push(key);
       }
 
-      this.emit(Events.Cancel);
+      for (var _i3 = 0, _arr2 = _toConsumableArray(this.elements); _i3 < _arr2.length; _i3++) {
+        var el = _arr2[_i3];
+
+        if (!updatedKeys.includes(el.currentKey)) {
+          el.remove();
+        }
+      }
     }
+    /**
+     * Generate the javascript object for this document.
+     *
+     * @returns {Object} The javascript object.
+     */
+
   }, {
     key: "generateObject",
     value: function generateObject() {
@@ -245,12 +290,12 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
       var object = {};
 
       if (this.elements) {
-        var _iterator2 = _createForOfIteratorHelper(this.elements),
-            _step2;
+        var _iterator = _createForOfIteratorHelper(this.elements),
+            _step;
 
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var element = _step2.value;
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var element = _step.value;
 
             if (element.isModified() && !element.isAdded() || alwaysIncludeKeys && element.key in alwaysIncludeKeys) {
               // Using `.key` instead of `.currentKey` to ensure we look at
@@ -267,9 +312,9 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
             }
           }
         } catch (err) {
-          _iterator2.e(err);
+          _iterator.e(err);
         } finally {
-          _iterator2.f();
+          _iterator.f();
         }
       }
 
@@ -293,12 +338,12 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
       var object = {};
 
       if (this.elements) {
-        var _iterator3 = _createForOfIteratorHelper(this.elements),
-            _step3;
+        var _iterator2 = _createForOfIteratorHelper(this.elements),
+            _step2;
 
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var element = _step3.value;
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var element = _step2.value;
 
             if (element.key in keys) {
               // Using `.key` instead of `.currentKey` to ensure we look at
@@ -307,9 +352,9 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
             }
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator2.e(err);
         } finally {
-          _iterator3.f();
+          _iterator2.f();
         }
       }
 
@@ -328,12 +373,12 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
       var object = {};
 
       if (this.elements) {
-        var _iterator4 = _createForOfIteratorHelper(this.elements),
-            _step4;
+        var _iterator3 = _createForOfIteratorHelper(this.elements),
+            _step3;
 
         try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            var element = _step4.value;
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var element = _step3.value;
 
             if (!element.isRemoved() && element.currentKey !== '' && element.isModified()) {
               // Include the full modified element.
@@ -347,9 +392,9 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
             }
           }
         } catch (err) {
-          _iterator4.e(err);
+          _iterator3.e(err);
         } finally {
-          _iterator4.f();
+          _iterator3.f();
         }
       }
 
@@ -387,12 +432,12 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
       var object = {};
 
       if (this.elements) {
-        var _iterator5 = _createForOfIteratorHelper(this.elements),
-            _step5;
+        var _iterator4 = _createForOfIteratorHelper(this.elements),
+            _step4;
 
         try {
-          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-            var element = _step5.value;
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var element = _step4.value;
 
             if (!element.isAdded() && element.isRemoved() && element.key !== '') {
               object[element.key] = true;
@@ -404,9 +449,9 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
             }
           }
         } catch (err) {
-          _iterator5.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator5.f();
+          _iterator4.f();
         }
       }
 
@@ -432,11 +477,31 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
      * @returns {Element} The new element.
      */
 
+  }, {
+    key: "insertBeginning",
+    value: function insertBeginning(key, value) {
+      var newElement = this.elements.insertBeginning(key, value, true, this);
+
+      newElement._bubbleUp(Element.Events.Added, newElement, this);
+
+      return newElement;
+    }
+    /**
+     * Add a new element to this document.
+     *
+     * @param {String} key - The element key.
+     * @param {Object} value - The value.
+     *
+     * @returns {Element} The new element.
+     */
+
   }, {
     key: "insertEnd",
     value: function insertEnd(key, value) {
       var newElement = this.elements.insertEnd(key, value, true, this);
-      this.emit(Element.Events.Added);
+
+      newElement._bubbleUp(Element.Events.Added, newElement, this);
+
       return newElement;
     }
     /**
@@ -453,7 +518,9 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
     key: "insertAfter",
     value: function insertAfter(element, key, value) {
       var newElement = this.elements.insertAfter(element, key, value, true, this);
-      this.emit(Element.Events.Added);
+
+      newElement._bubbleUp(Element.Events.Added, newElement, this);
+
       return newElement;
     }
     /**
@@ -476,21 +543,21 @@ var Document = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "isModified",
     value: function isModified() {
-      var _iterator6 = _createForOfIteratorHelper(this.elements),
-          _step6;
+      var _iterator5 = _createForOfIteratorHelper(this.elements),
+          _step5;
 
       try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var element = _step6.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var element = _step5.value;
 
           if (element.isModified()) {
             return true;
           }
         }
       } catch (err) {
-        _iterator6.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator6.f();
+        _iterator5.f();
       }
 
       return false;