hadron-document 7.6.0 → 7.9.0

package/lib/editor/date.js

@@ -0,0 +1,151 @@
+"use strict";
+
+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 _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); 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 } }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var TypeChecker = require('hadron-type-checker');
+
+var Events = require('../element-events');
+
+var _require = require('../utils'),
+    fieldStringLen = _require.fieldStringLen;
+
+var StandardEditor = require('./standard');
+/**
+ * CRUD editor for date values.
+ */
+
+
+var DateEditor = /*#__PURE__*/function (_StandardEditor) {
+  _inherits(DateEditor, _StandardEditor);
+
+  var _super = _createSuper(DateEditor);
+
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  function DateEditor(element) {
+    _classCallCheck(this, DateEditor);
+
+    return _super.call(this, element);
+  }
+  /**
+   * Complete the date edit by converting the valid string to a date
+   * object or leaving as invalid.
+   */
+
+
+  _createClass(DateEditor, [{
+    key: "complete",
+    value: function complete() {
+      if (this.element.isCurrentTypeValid()) {
+        this.element.edit(TypeChecker.cast(this._formattedValue(), 'Date'));
+      }
+    }
+    /**
+     * Edit the element with the provided value.
+     *
+     * @param {Object} value - The new value.
+     */
+
+  }, {
+    key: "edit",
+    value: function edit(value) {
+      try {
+        var date = TypeChecker.cast(value, 'Date');
+
+        if (date.toString() === 'Invalid Date') {
+          this.element.setInvalid(value, 'Date', "".concat(value, " is not in a valid date format"));
+        } else {
+          this.element.currentValue = value;
+          this.element.setValid();
+
+          this.element._bubbleUp(Events.Edited, this.element);
+        }
+      } catch (e) {
+        this.element.setInvalid(value, this.element.currentType, e.message);
+      }
+    }
+    /**
+     * Get the number of characters the value should display.
+     *
+     * @param {Boolean} editMode - If the element is being edited.
+     *
+     * @returns {Number} The number of characters.
+     */
+
+  }, {
+    key: "size",
+    value: function size(editMode) {
+      var value = this.element.currentValue;
+
+      if (editMode) {
+        return fieldStringLen(value);
+      }
+
+      return this.element.isCurrentTypeValid() ? fieldStringLen(this._formattedValue()) : fieldStringLen(value);
+    }
+    /**
+     * Start the date edit.
+     *
+     * @param {Object} value - The value in the field.
+     */
+
+  }, {
+    key: "start",
+    value: function start() {
+      if (this.element.isCurrentTypeValid()) {
+        this.edit(this._formattedValue());
+      }
+    }
+    /**
+     * Get the value being edited.
+     *
+     * @param {Boolean} editMode - If the UI is in edit mode.
+     *
+     * @returns {String} The value.
+     */
+
+  }, {
+    key: "value",
+    value: function value(editMode) {
+      var value = this.element.currentValue;
+
+      if (!editMode && this.element.isCurrentTypeValid()) {
+        return this._formattedValue();
+      }
+
+      return value;
+    }
+  }, {
+    key: "_formattedValue",
+    value: function _formattedValue() {
+      return new Date(this.element.currentValue).toISOString().replace('Z', '+00:00');
+    }
+  }]);
+
+  return DateEditor;
+}(StandardEditor);
+
+module.exports = DateEditor;

package/lib/editor/decimal128.js

@@ -0,0 +1,88 @@
+"use strict";
+
+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 _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); 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 } }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var TypeChecker = require('hadron-type-checker');
+
+var Events = require('../element-events');
+
+var StandardEditor = require('./standard');
+/**
+ * CRUD editor for decimal128 values.
+ */
+
+
+var Decimal128Editor = /*#__PURE__*/function (_StandardEditor) {
+  _inherits(Decimal128Editor, _StandardEditor);
+
+  var _super = _createSuper(Decimal128Editor);
+
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  function Decimal128Editor(element) {
+    _classCallCheck(this, Decimal128Editor);
+
+    return _super.call(this, element);
+  }
+  /**
+   * Complete the decimal128 edit by converting the valid string to a decimal128
+   * value or leaving as invalid.
+   */
+
+
+  _createClass(Decimal128Editor, [{
+    key: "complete",
+    value: function complete() {
+      if (this.element.isCurrentTypeValid()) {
+        this.element.edit(TypeChecker.cast(this.element.currentValue, 'Decimal128'));
+      }
+    }
+    /**
+     * Edit Decimal128 element. Check if the value is a Decimal128 before setting typed
+     * up value.
+     *
+     * @param {Object} value - The new value.
+     */
+
+  }, {
+    key: "edit",
+    value: function edit(value) {
+      try {
+        TypeChecker.cast(value, 'Decimal128');
+        this.element.currentValue = value;
+        this.element.setValid();
+
+        this.element._bubbleUp(Events.Edited, this.element);
+      } catch (error) {
+        this.element.setInvalid(value, this.element.currentType, error.message);
+      }
+    }
+  }]);
+
+  return Decimal128Editor;
+}(StandardEditor);
+
+module.exports = Decimal128Editor;

package/lib/editor/double.js

@@ -0,0 +1,113 @@
+"use strict";
+
+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 _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); 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 } }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var TypeChecker = require('hadron-type-checker');
+
+var Events = require('../element-events');
+
+var _require = require('../utils'),
+    fieldStringLen = _require.fieldStringLen;
+
+var StandardEditor = require('./standard');
+/**
+ * CRUD editor for double values.
+ */
+
+
+var DoubleEditor = /*#__PURE__*/function (_StandardEditor) {
+  _inherits(DoubleEditor, _StandardEditor);
+
+  var _super = _createSuper(DoubleEditor);
+
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  function DoubleEditor(element) {
+    _classCallCheck(this, DoubleEditor);
+
+    return _super.call(this, element);
+  }
+  /**
+   * Complete the double edit by converting the valid string to a double
+   * value or leaving as invalid.
+   */
+
+
+  _createClass(DoubleEditor, [{
+    key: "complete",
+    value: function complete() {
+      if (this.element.isCurrentTypeValid()) {
+        this.element.edit(TypeChecker.cast(this.element.currentValue, 'Double'));
+      }
+    }
+    /**
+     * Edit Double element. Check if the value is a Double before setting tped
+     * up value.
+     *
+     * @param {Object} value - The new value.
+     */
+
+  }, {
+    key: "edit",
+    value: function edit(value) {
+      try {
+        var _double = TypeChecker.cast(value, 'Double');
+
+        if (isNaN(_double.value)) {
+          this.element.setInvalid(value, 'Double', "".concat(value, " is not a valid double format"));
+        } else {
+          this.element.currentValue = value;
+          this.element.setValid();
+
+          this.element._bubbleUp(Events.Edited, this.element);
+        }
+      } catch (error) {
+        this.element.setInvalid(value, this.element.currentType, error.message);
+      }
+    }
+    /**
+     * Get the number of characters the value should display.
+     *
+     * @param {Boolean} editMode - If the element is being edited.
+     *
+     * @returns {Number} The number of characters.
+     */
+
+  }, {
+    key: "size",
+    value: function size() {
+      var currentValue = this.element.currentValue;
+      return fieldStringLen( // Not all values that will be checked here are bson types with a `value`
+      // property, using valueOf is a more resilient way of getting the "native"
+      // value from `currentValue`
+      typeof currentValue.valueOf === 'function' ? currentValue.valueOf() : currentValue);
+    }
+  }]);
+
+  return DoubleEditor;
+}(StandardEditor);
+
+module.exports = DoubleEditor;

package/lib/editor/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var StandardEditor = require('./standard');
+
+var StringEditor = require('./string');
+
+var Decimal128Editor = require('./decimal128');
+
+var Int32Editor = require('./int32');
+
+var Int64Editor = require('./int64');
+
+var DoubleEditor = require('./double');
+
+var DateEditor = require('./date');
+
+var NullEditor = require('./null');
+
+var UndefinedEditor = require('./undefined');
+
+var ObjectIdEditor = require('./objectid');
+
+var init = function init(element) {
+  return {
+    Standard: new StandardEditor(element),
+    String: new StringEditor(element),
+    Decimal128: new Decimal128Editor(element),
+    Date: new DateEditor(element),
+    Double: new DoubleEditor(element),
+    Int32: new Int32Editor(element),
+    Int64: new Int64Editor(element),
+    Null: new NullEditor(element),
+    Undefined: new UndefinedEditor(element),
+    ObjectId: new ObjectIdEditor(element)
+  };
+};
+
+Object.assign(init, {
+  DateEditor: DateEditor,
+  StandardEditor: StandardEditor,
+  StringEditor: StringEditor,
+  Decimal128Editor: Decimal128Editor,
+  DoubleEditor: DoubleEditor,
+  Int32Editor: Int32Editor,
+  Int64Editor: Int64Editor,
+  NullEditor: NullEditor,
+  UndefinedEditor: UndefinedEditor,
+  ObjectIdEditor: ObjectIdEditor
+});
+module.exports = init;

package/lib/editor/int32.js

@@ -0,0 +1,68 @@
+"use strict";
+
+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 _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); 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 } }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var _require = require('../utils'),
+    fieldStringLen = _require.fieldStringLen;
+
+var StandardEditor = require('./standard');
+/**
+ * CRUD editor for int32 values.
+ */
+
+
+var Int32Editor = /*#__PURE__*/function (_StandardEditor) {
+  _inherits(Int32Editor, _StandardEditor);
+
+  var _super = _createSuper(Int32Editor);
+
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  function Int32Editor(element) {
+    _classCallCheck(this, Int32Editor);
+
+    return _super.call(this, element);
+  }
+  /**
+   * Get the number of characters the value should display.
+   *
+   * @param {Boolean} editMode - If the element is being edited.
+   *
+   * @returns {Number} The number of characters.
+   */
+
+
+  _createClass(Int32Editor, [{
+    key: "size",
+    value: function size() {
+      return fieldStringLen(this.element.currentValue.valueOf());
+    }
+  }]);
+
+  return Int32Editor;
+}(StandardEditor);
+
+module.exports = Int32Editor;

package/lib/editor/int64.js

@@ -0,0 +1,88 @@
+"use strict";
+
+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 _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); 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 } }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var TypeChecker = require('hadron-type-checker');
+
+var Events = require('../element-events');
+
+var StandardEditor = require('./standard');
+/**
+ * CRUD editor for int32 values.
+ */
+
+
+var Int64Editor = /*#__PURE__*/function (_StandardEditor) {
+  _inherits(Int64Editor, _StandardEditor);
+
+  var _super = _createSuper(Int64Editor);
+
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  function Int64Editor(element) {
+    _classCallCheck(this, Int64Editor);
+
+    return _super.call(this, element);
+  }
+  /**
+   * Complete the int64 edit by converting the valid string to a int64
+   * value or leaving as invalid.
+   */
+
+
+  _createClass(Int64Editor, [{
+    key: "complete",
+    value: function complete() {
+      if (this.element.isCurrentTypeValid()) {
+        this.element.edit(TypeChecker.cast(this.element.currentValue, 'Int64'));
+      }
+    }
+    /**
+     * Edit Int64 element. Check if the value is a Int64 before setting typed
+     * up value.
+     *
+     * @param {Object} value - The new value.
+     */
+
+  }, {
+    key: "edit",
+    value: function edit(value) {
+      try {
+        TypeChecker.cast(value, 'Int64');
+        this.element.currentValue = value;
+        this.element.setValid();
+
+        this.element._bubbleUp(Events.Edited, this.element);
+      } catch (error) {
+        this.element.setInvalid(value, this.element.currentType, error.message);
+      }
+    }
+  }]);
+
+  return Int64Editor;
+}(StandardEditor);
+
+module.exports = Int64Editor;

package/lib/editor/null.js

@@ -0,0 +1,81 @@
+"use strict";
+
+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 _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); 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 } }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var StandardEditor = require('./standard');
+/**
+ * Null is always 'null'
+ */
+
+
+var VALUE = 'null';
+/**
+ * CRUD editor for null values.
+ */
+
+var NullEditor = /*#__PURE__*/function (_StandardEditor) {
+  _inherits(NullEditor, _StandardEditor);
+
+  var _super = _createSuper(NullEditor);
+
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  function NullEditor(element) {
+    _classCallCheck(this, NullEditor);
+
+    return _super.call(this, element);
+  }
+  /**
+   * Get the number of characters the value should display.
+   *
+   * @param {Boolean} editMode - If the element is being edited.
+   *
+   * @returns {Number} The number of characters.
+   */
+
+
+  _createClass(NullEditor, [{
+    key: "size",
+    value: function size() {
+      return 4;
+    }
+    /**
+     * Get the value being edited.
+     *
+     * @returns {Object} The value.
+     */
+
+  }, {
+    key: "value",
+    value: function value() {
+      return VALUE;
+    }
+  }]);
+
+  return NullEditor;
+}(StandardEditor);
+
+module.exports = NullEditor;