hadron-document 7.6.0 → 7.9.0

package/src/editor/date.js

@@ -0,0 +1,95 @@
+const TypeChecker = require('hadron-type-checker');
+const Events = require('../element-events');
+const { fieldStringLen } = require('../utils');
+const StandardEditor = require('./standard');
+
+/**
+ * CRUD editor for date values.
+ */
+class DateEditor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(element);
+  }
+
+  /**
+   * Complete the date edit by converting the valid string to a date
+   * object or leaving as invalid.
+   */
+  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.
+   */
+  edit(value) {
+    try {
+      const date = TypeChecker.cast(value, 'Date');
+      if (date.toString() === 'Invalid Date') {
+        this.element.setInvalid(value, 'Date', `${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.
+   */
+  size(editMode) {
+    const 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.
+   */
+  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.
+   */
+  value(editMode) {
+    const value = this.element.currentValue;
+    if (!editMode && this.element.isCurrentTypeValid()) {
+      return this._formattedValue();
+    }
+    return value;
+  }
+
+  _formattedValue() {
+    return new Date(this.element.currentValue).toISOString().replace('Z', '+00:00');
+  }
+}
+
+module.exports = DateEditor;

package/src/editor/decimal128.js

@@ -0,0 +1,46 @@
+const TypeChecker = require('hadron-type-checker');
+const Events = require('../element-events');
+const StandardEditor = require('./standard');
+
+/**
+ * CRUD editor for decimal128 values.
+ */
+class Decimal128Editor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(element);
+  }
+
+  /**
+   * Complete the decimal128 edit by converting the valid string to a decimal128
+   * value or leaving as invalid.
+   */
+  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.
+   */
+  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);
+    }
+  }
+}
+
+module.exports = Decimal128Editor;

package/src/editor/double.js

@@ -0,0 +1,70 @@
+const TypeChecker = require('hadron-type-checker');
+const Events = require('../element-events');
+const { fieldStringLen } = require('../utils');
+const StandardEditor = require('./standard');
+
+/**
+ * CRUD editor for double values.
+ */
+class DoubleEditor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(element);
+  }
+
+  /**
+   * Complete the double edit by converting the valid string to a double
+   * value or leaving as invalid.
+   */
+  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.
+   */
+  edit(value) {
+    try {
+      const double = TypeChecker.cast(value, 'Double');
+      if (isNaN(double.value)) {
+        this.element.setInvalid(value, 'Double', `${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.
+   */
+  size() {
+    const 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
+    );
+  }
+}
+
+module.exports = DoubleEditor;

package/src/editor/index.js

@@ -0,0 +1,40 @@
+const StandardEditor = require('./standard');
+const StringEditor = require('./string');
+const Decimal128Editor = require('./decimal128');
+const Int32Editor = require('./int32');
+const Int64Editor = require('./int64');
+const DoubleEditor = require('./double');
+const DateEditor = require('./date');
+const NullEditor = require('./null');
+const UndefinedEditor = require('./undefined');
+const ObjectIdEditor = require('./objectid');
+
+const 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,
+  StandardEditor,
+  StringEditor,
+  Decimal128Editor,
+  DoubleEditor,
+  Int32Editor,
+  Int64Editor,
+  NullEditor,
+  UndefinedEditor,
+  ObjectIdEditor
+});
+
+module.exports = init;

package/src/editor/int32.js

@@ -0,0 +1,29 @@
+const { fieldStringLen } = require('../utils');
+const StandardEditor = require('./standard');
+
+/**
+ * CRUD editor for int32 values.
+ */
+class Int32Editor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(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.
+   */
+  size() {
+    return fieldStringLen(this.element.currentValue.valueOf());
+  }
+}
+
+module.exports = Int32Editor;

package/src/editor/int64.js

@@ -0,0 +1,46 @@
+const TypeChecker = require('hadron-type-checker');
+const Events = require('../element-events');
+const StandardEditor = require('./standard');
+
+/**
+ * CRUD editor for int32 values.
+ */
+class Int64Editor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(element);
+  }
+
+  /**
+   * Complete the int64 edit by converting the valid string to a int64
+   * value or leaving as invalid.
+   */
+  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.
+   */
+  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);
+    }
+  }
+}
+
+module.exports = Int64Editor;

package/src/editor/null.js

@@ -0,0 +1,42 @@
+const StandardEditor = require('./standard');
+
+/**
+ * Null is always 'null'
+ */
+const VALUE = 'null';
+
+/**
+ * CRUD editor for null values.
+ */
+class NullEditor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(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.
+   */
+  size() {
+    return 4;
+  }
+
+  /**
+   * Get the value being edited.
+   *
+   * @returns {Object} The value.
+   */
+  value() {
+    return VALUE;
+  }
+}
+
+module.exports = NullEditor;

package/src/editor/objectid.js

@@ -0,0 +1,54 @@
+const TypeChecker = require('hadron-type-checker');
+const Events = require('../element-events');
+const StandardEditor = require('./standard');
+
+/**
+ * CRUD editor for object id values.
+ */
+class ObjectIdEditor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(element);
+  }
+
+  /**
+   * Complete the object id edit by converting the valid string to an object id
+   * object or leaving as invalid.
+   */
+  complete() {
+    if (this.element.isCurrentTypeValid()) {
+      this.element.edit(TypeChecker.cast(this.element.currentValue, 'ObjectId'));
+    }
+  }
+
+  /**
+   * Edit the element with the provided value.
+   *
+   * @param {Object} value - The new value.
+   */
+  edit(value) {
+    try {
+      TypeChecker.cast(value, 'ObjectId');
+      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);
+    }
+  }
+
+  /**
+   * Start the object id edit.
+   */
+  start() {
+    if (this.element.isCurrentTypeValid()) {
+      this.edit(String(this.element.currentValue));
+    }
+  }
+}
+
+module.exports = ObjectIdEditor;

package/src/editor/standard.js

@@ -0,0 +1,78 @@
+const TypeChecker = require('hadron-type-checker');
+const Events = require('../element-events');
+const { fieldStringLen } = require('../utils');
+
+/**
+ * Regex to match an array or object string.
+ */
+const ARRAY_OR_OBJECT = /^(\[|\{)(.+)(\]|\})$/;
+
+/**
+ * CRUD editor for standard values.
+ */
+class StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    this.element = element;
+  }
+
+  /**
+   * Edit the element with the provided value.
+   *
+   * @param {Object} value - The new value.
+   */
+  edit(value) {
+    const currentType = this.element.currentType;
+    try {
+      const newValue = TypeChecker.cast(value, currentType);
+      this.element.edit(newValue);
+    } catch (e) {
+      this.element.setInvalid(value, currentType, e.message);
+    }
+  }
+
+  /**
+   * Edit the element via a paste.
+   *
+   * @param {String} value - The balue.
+   */
+  paste(value) {
+    if (value.match(ARRAY_OR_OBJECT)) {
+      this.edit(JSON.parse(value));
+      this.element._bubbleUp(Events.Converted, this.element);
+    } else {
+      this.edit(value);
+    }
+  }
+
+
+  /**
+   * Get the number of characters the value should display.
+   *
+   * @param {Boolean} editMode - If the element is being edited.
+   *
+   * @returns {Number} The number of characters.
+   */
+  size() {
+    return fieldStringLen(this.element.currentValue);
+  }
+
+  /**
+   * Get the value being edited.
+   *
+   * @returns {Object} The value.
+   */
+  value() {
+    return this.element.currentValue;
+  }
+
+  // Standard editing requires no special start/complete behaviour.
+  start() {}
+  complete() {}
+}
+
+module.exports = StandardEditor;

package/src/editor/string.js

@@ -0,0 +1,20 @@
+const StandardEditor = require('./standard');
+
+const STRING_TYPE = 'String';
+
+/**
+ * CRUD editor for string values.
+ */
+class StringEditor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(element);
+  }
+}
+
+module.exports = StringEditor;
+module.exports.STRING_TYPE = STRING_TYPE;

package/src/editor/undefined.js

@@ -0,0 +1,42 @@
+const StandardEditor = require('./standard');
+
+/**
+ * Undefined is always 'undefined'
+ */
+const VALUE = 'undefined';
+
+/**
+ * CRUD editor for undefined values.
+ */
+class UndefinedEditor extends StandardEditor {
+  /**
+   * Create the editor with the element.
+   *
+   * @param {Element} element - The hadron document element.
+   */
+  constructor(element) {
+    super(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.
+   */
+  size() {
+    return VALUE.length;
+  }
+
+  /**
+   * Get the value being edited.
+   *
+   * @returns {Object} The value.
+   */
+  value() {
+    return VALUE;
+  }
+}
+
+module.exports = UndefinedEditor;

package/src/element-events.js

@@ -0,0 +1,14 @@
+/**
+ * The event constant.
+ */
+const Events = {
+  Added: 'Element::Added',
+  Edited: 'Element::Edited',
+  Removed: 'Element::Removed',
+  Reverted: 'Element::Reverted',
+  Converted: 'Element::Converted',
+  Invalid: 'Element::Invalid',
+  Valid: 'Element::Valid'
+};
+
+module.exports = Events;