@es-joy/jsoe 0.0.1

package/src/fundamentalTypes/bigintType.js

@@ -0,0 +1,53 @@
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {TypeObject}
+ */
+const bigintType = {
+  option: ['BigInt'],
+  stringRegex: new RegExp(
+    '^' + // No leading content.
+      '-?' + // Optional negative sign.
+      // How many digits?
+      '[0-9]{1,}' +
+      'n' +
+      '$', // No trailing content.
+    'u'
+  ),
+  toValue (s) {
+    return {value: BigInt(s.slice(0, -1))};
+  },
+  getInput ({root}) {
+    return $e(root, 'input');
+  },
+  setValue ({root, value}) {
+    this.getInput({root}).value = String(value);
+  },
+  validate ({root}) {
+    const val = this.getInput({root}).value;
+    return {
+      message: 'Not a valid BigInt',
+      valid: val && val.match(/^-?(\d+)$/u)
+    };
+  },
+  getValue ({root}) {
+    return BigInt(this.getInput({root}).value);
+  },
+  /* schema:
+  viewSchemaUI () {
+    // Todo?
+  },
+  */
+  viewUI ({value}) {
+    return ['i', {dataset: {type: 'bigint'}}, [`${String(value)}n`]];
+  },
+  editUI ({typeNamespace, value = ''}) {
+    return ['div', {dataset: {type: 'bigint'}}, [
+      ['input', {
+        name: `${typeNamespace}-bigint`, type: 'number', step: 'any', value
+      }]
+    ]];
+  }
+};
+
+export default bigintType;

package/src/fundamentalTypes/dateType.js

@@ -0,0 +1,129 @@
+import {$e} from '../utils/templateUtils.js';
+import {jml} from '../../node_modules/jamilih/dist/jml-es.js';
+import Types from '../types.js';
+
+/**
+ * @type {TypeObject}
+ */
+const dateType = {
+  option: ['Date'],
+  // ISO Date string
+  dateRegex: /^(?:\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}\.\d{3}Z)?|(?:\+|-)\d{6}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)$/u, // eslint-disable-line unicorn/no-unsafe-regex
+  stringRegex () {
+    const regex = this.dateRegex;
+    if (!this.valid) {
+      const {source} = regex;
+      return new RegExp('^' + '(?:InvalidDate)|' + source.slice(1), 'u');
+    }
+    return new RegExp(regex, 'u');
+  },
+  toValue (s) {
+    return {value: new Date(s)};
+  },
+  getInput ({root}) {
+    return $e(root, 'input[type="date"]');
+  },
+  setValue ({root, value}) {
+    const notANum = value && Number.isNaN(value.getTime());
+    if (notANum) {
+      $e(root, '.invalidDate').$setValidity(true);
+      return;
+    }
+    const dateStr = new Date(Date.parse(value)).toISOString();
+    this.getInput({root}).value = dateStr.length === 24
+      ? dateStr.slice(0, 10)
+      // eslint-disable-next-line max-len -- Long
+      /* istanbul ignore next -- 6 digits year not reliable through `Date.parse` */
+      : dateStr.slice(3, 13); // Will cut off ten/hundred thousand years
+  },
+  validate ({root}) {
+    if (this.isInvalid({root})) {
+      return {
+        valid: true
+      };
+    }
+    const val = this.getInput({root}).value;
+    if (!val) {
+      return {
+        valid: false,
+        message: 'Must not be empty`'
+      };
+    }
+    return {
+      valid: val.match(new RegExp(this.dateRegex, 'u')),
+      message: 'Must match a valid date'
+    }; // Input shouldn't allow anyways
+  },
+  isInvalid ({root}) {
+    return !this.valid && $e(root, '.invalidDate').checked;
+  },
+  getValue ({root}) {
+    if (this.isInvalid({root})) {
+      return this.toValue('NaN').value;
+    }
+    return this.toValue(this.getInput({root}).value).value;
+  },
+  isValueInvalid (value) {
+    return value && Number.isNaN(value.getTime());
+  },
+  viewUI ({value}) {
+    return !this.valid && this.isValueInvalid(value)
+      ? ['i', {
+        dataset: {type: 'date'}, class: 'InvalidDate'
+      }, ['InvalidDate']]
+      : ['i', {dataset: {type: 'date'}, class: 'ValidDate'}, [
+        value.toISOString().slice(0, 10)
+      ]];
+  },
+  // Change to default to `new Date()` when can't be `NaN`
+  //   value (keys)?
+  editUI ({topRoot, typeNamespace, value = ''}) {
+    const notANum = this.isValueInvalid(value);
+    const invalid = this.valid
+      ? ''
+      : jml('div', [
+        ['label', [
+          'Invalid date',
+          ['input', {
+            type: 'checkbox',
+            class: 'invalidDate',
+            checked: notANum,
+            name: `${typeNamespace}-invalidDate`,
+            $custom: {
+              $setValidity (legitimateInvalid) {
+                console.log('legitimateInvalid', legitimateInvalid);
+                if (legitimateInvalid === true) {
+                  this.checked = true;
+                }
+                const label = invalid.previousElementSibling;
+                label.hidden = Boolean(legitimateInvalid);
+                const root = label.parentElement;
+                Types.validate({type: 'date', root, topRoot});
+              }
+            },
+            $on: {
+              click (e) {
+                this.$setValidity();
+              }
+            }
+          }]
+        ]]
+      ]);
+    return ['div', {dataset: {type: this.valid ? 'ValidDate' : 'date'}}, [
+      ['label', {
+        hidden: notANum
+      }, [
+        'Date: ',
+        ['input', {
+          name: `${typeNamespace}-date`,
+          type: 'date',
+          // Required yyyy-MM-dd format
+          value: !value || notANum ? '' : value.toISOString().slice(0, 10)
+        }]
+      ]],
+      invalid
+    ]];
+  }
+};
+
+export default dateType;

package/src/fundamentalTypes/nullType.js

@@ -0,0 +1,33 @@
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {TypeObject}
+ */
+const nullType = {
+  option: ['Null'],
+  stringRegex: /^null$/u,
+  toValue: () => ({value: null}),
+  getValue: () => null,
+  viewUI () {
+    return ['i', {dataset: {type: 'null'}}, ['null']];
+  },
+  /* istanbul ignore next -- No dupe keys, array refs, or validation */
+  getInput ({root}) {
+    return $e(root, 'input');
+  },
+  editUI ({typeNamespace}) {
+    return ['div', {dataset: {type: 'null'}}, [
+      ['label', [
+        'Null',
+        ['input', {
+          type: 'checkbox',
+          name: `${typeNamespace}-null`,
+          checked: true,
+          disabled: true
+        }]
+      ]]
+    ]];
+  }
+};
+
+export default nullType;

package/src/fundamentalTypes/numberType.js

@@ -0,0 +1,56 @@
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {TypeObject}
+ */
+const numberType = {
+  option: ['Number'],
+  stringRegex: new RegExp(
+    '^' + // No leading content.
+      '[-+]?' + // Optional sign.
+      // Optionally 0-30 decimal digits of mantissa.
+      '(?:[0-9]{0,30}\\.)?' +
+      // 1-30 decimal digits of integer or fraction.
+      '[0-9]{1,30}' +
+      // Optional exponent 0-29 for scientific notation.
+      '(?:[Ee][-+]?[1-2]?[0-9])?' +
+      '$', // No trailing content.
+    'u'
+  ),
+  toValue (s) {
+    return {value: Number(s)};
+  },
+  getInput ({root}) {
+    return $e(root, 'input');
+  },
+  setValue ({root, value}) {
+    this.getInput({root}).value = String(value);
+  },
+  validate ({root}) {
+    const val = this.getInput({root}).value;
+    return {
+      message: 'Not a valid (finite) number',
+      valid: val && val.match(/^-?(\d+|\d*\.\d+)$/u)
+    };
+  },
+  getValue ({root}) {
+    return Number.parseFloat(this.getInput({root}).value);
+  },
+  /* schema
+  viewSchemaUI () {
+    // Todo?
+  },
+  */
+  viewUI ({value}) {
+    return ['i', {dataset: {type: 'number'}}, [String(value)]];
+  },
+  editUI ({typeNamespace, value = ''}) {
+    return ['div', {dataset: {type: 'number'}}, [
+      ['input', {
+        name: `${typeNamespace}-number`, type: 'number', step: 'any', value
+      }]
+    ]];
+  }
+};
+
+export default numberType;

package/src/fundamentalTypes/objectReferenceType.js

@@ -0,0 +1,51 @@
+import Types from '../types.js';
+
+/**
+ * @type {TypeObject}
+ */
+const objectReferenceType = {
+  option: ['Object reference'],
+  type: 'object',
+  stringRegex: /^objectRef\((?:|\/[^)]*)\)$/u,
+  toValue (...args) {
+    return Types.availableTypes.arrayReference.toValue.apply(this, args);
+  },
+  resolveReference (...args) {
+    return Types.availableTypes.arrayReference.resolveReference.apply(
+      this, args
+    );
+  },
+  stateDependent: {
+    structuredCloning: {
+      after: 'object',
+      contexts: [
+        'arrayNonindexKeys',
+        // 'sparseArrays',
+        'object'
+      ]
+    }
+  },
+  getInput (...args) {
+    return Types.availableTypes.arrayReference.getInput.apply(this, args);
+  },
+  setValue (...args) {
+    return Types.availableTypes.arrayReference.setValue.apply(this, args);
+  },
+  getValue (...args) {
+    return Types.availableTypes.arrayReference.getValue.apply(this, args);
+  },
+  validate (...args) {
+    return Types.availableTypes.arrayReference.validate.apply(this, args);
+  },
+  validateAll (...args) {
+    return Types.availableTypes.arrayReference.validateAll.apply(this, args);
+  },
+  viewUI (...args) {
+    return Types.availableTypes.arrayReference.viewUI.apply(this, args);
+  },
+  editUI (...args) {
+    return Types.availableTypes.arrayReference.editUI.apply(this, args);
+  }
+};
+
+export default objectReferenceType;

package/src/fundamentalTypes/objectType.js

@@ -0,0 +1,30 @@
+import Types from '../types.js';
+
+/**
+ * @type {TypeObject}
+ */
+const objectType = {
+  option: ['Object'],
+  regexEndings: [',', '}'],
+  stringRegexBegin: /^\{/u,
+  stringRegexEnd: /^\}/u,
+  toValue (...args) {
+    return Types.availableTypes.array.toValue.apply(this, args);
+  },
+  getValue (...args) {
+    return Types.availableTypes.array.getValue.apply(this, args);
+  },
+  getInput (...args) {
+    return Types.availableTypes.array.getInput.apply(this, args);
+  },
+  viewUI (...args) {
+    return Types.availableTypes.array.viewUI.apply(this, args);
+  },
+  editUI ({...args}) {
+    return Types.availableTypes.array.editUI.call(this, {
+      ...args, type: 'object'
+    });
+  }
+};
+
+export default objectType;

package/src/fundamentalTypes/regexpType.js

@@ -0,0 +1,95 @@
+import {$e} from '../utils/templateUtils.js';
+import {jml} from '../../node_modules/jamilih/dist/jml-es.js';
+import Types from '../types.js';
+
+/**
+ * @type {TypeObject}
+ */
+const regexpType = {
+  option: ['RegExp'],
+  stringRegex (nonGrouping) {
+    const parenth = nonGrouping ? '(?:' : '(';
+    return new RegExp(`^/${parenth}.*)/${parenth}[${
+      this.allowedFlags.join('')
+    }]{0,${
+      this.allowedFlags.length
+    }})$`, 'u');
+  },
+  toValue (s) {
+    const [, str, flags] = s.match(this.stringRegex());
+    return {value: new RegExp(str, flags)};
+  },
+  getInput ({root}) {
+    return $e(root, 'input');
+  },
+  setValue ({root, value}) {
+    this.getInput({root}).value = value.source;
+    this.getSelect({root}).$set([...value.flags]);
+  },
+  getSelect ({root}) {
+    return $e(root, 'select');
+  },
+  validate ({root}) {
+    try {
+      this.getValue({root});
+      return {valid: true};
+    } catch (err) {
+      return {
+        valid: false,
+        message: err.message
+      };
+    }
+  },
+  getValue ({root}) {
+    return new RegExp(
+      this.getInput({root}).value, // .replace(/\\/g, '\\\\'),
+      [...this.getSelect({root}).selectedOptions].reduce((s, opt) => {
+        return s + opt.value;
+      }, '')
+    );
+  },
+  allowedFlags: ['g', 'i', 'm', 'u', 'y', 's'],
+  viewUI ({value}) {
+    return ['i', {dataset: {type: 'regexp'}}, [String(value)]];
+  },
+  editUI ({typeNamespace, value = {source: '', flags: ''}}) {
+    // Todo (low): Add RegExp syntax highlighter
+    const select = jml(
+      'select',
+      {multiple: true, size: 5, $custom: {
+        $set (valArr) { // A useful reusable method for multiple selects
+          [...this.options].forEach((opt) => {
+            opt.selected = valArr.includes(opt.value);
+          });
+        }
+      }},
+      this.allowedFlags.map((flag) => {
+        return ['option', {
+          selected: value.flags.includes(flag)
+        }, [flag]];
+      })
+    );
+    const root = jml('div', {dataset: {type: 'regexp'}}, [
+      ['label', [
+        'Source ',
+        ['input', {
+          name: `${typeNamespace}-regexp`, type: 'text',
+          value: value.source
+        }]
+      ]],
+      ['br'],
+      ['label', [
+        'Flags ',
+        select
+      ]]
+    ]);
+    // Could be disallowed flags; we might instead try in
+    //   advance which will work
+    select.addEventListener('change', () => {
+      Types.validate({type: 'regexp', root});
+    });
+    return [root];
+  }
+};
+
+export default regexpType;

package/src/fundamentalTypes/sparseUndefinedType.js

@@ -0,0 +1,43 @@
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {TypeObject}
+ */
+const sparseUndefinedType = {
+  option: ['Sparse undefined'],
+  stateDependent: {
+    structuredCloning: {
+      after: 'undef',
+      contexts: [
+        'arrayNonindexKeys'
+        // 'sparseArrays'
+      ]
+    }
+  },
+  /* istanbul ignore next -- Catching instead of this placeholder */
+  viewUI (/* {value} */) {
+    return ['i', {
+      dataset: {type: 'sparseUndefined'}
+    }, [`undefined (sparse)`]];
+  },
+  /* istanbul ignore next -- Catching instead of this placeholder */
+  getInput ({root}) {
+    return $e(root, 'input');
+  },
+  /* istanbul ignore next -- Catching instead of this placeholder */
+  editUI ({typeNamespace}) {
+    return ['div', [
+      ['label', {dataset: {type: 'sparseUndefined'}}, [
+        'Sparse undefined',
+        ['input', {
+          type: 'checkbox',
+          name: `${typeNamespace}-sparseUndefined`,
+          checked: true,
+          disabled: true
+        }]
+      ]]
+    ]];
+  }
+};
+
+export default sparseUndefinedType;

package/src/fundamentalTypes/stringType.js

@@ -0,0 +1,31 @@
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {TypeObject}
+ */
+const stringType = {
+  option: ['String'],
+  stringRegex: /^"(?:[^\\"]|\\\\|\\")*"$/u,
+  toValue (s) {
+    return {value: s.slice(1, -1)};
+  },
+  getInput ({root}) {
+    return $e(root, 'textarea');
+  },
+  setValue ({root, value}) {
+    this.getInput({root}).value = value;
+  },
+  getValue ({root}) {
+    return this.getInput({root}).value;
+  },
+  viewUI ({value}) {
+    return ['span', {dataset: {type: 'string'}}, [value]];
+  },
+  editUI ({typeNamespace, value = ''}) {
+    return ['div', {dataset: {type: 'string'}}, [
+      ['textarea', {name: `${typeNamespace}-string`}, [value]]
+    ]];
+  }
+};
+
+export default stringType;

package/src/fundamentalTypes/undefinedType.js

@@ -0,0 +1,37 @@
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {TypeObject}
+ */
+const undefinedType = {
+  stringRegex: /^undefined$/u,
+  option: ['Explicit undefined'], // Explicit undefined only
+  toValue (_s) {
+    return {value: undefined};
+  },
+  getValue () {
+    return this.toValue().value;
+  },
+  viewUI (/* {value} */) {
+    return ['i', {dataset: {type: 'undef'}}, ['undefined']];
+  },
+  /* istanbul ignore next -- No dupe keys, array refs, or validation */
+  getInput ({root}) {
+    return $e(root, 'input');
+  },
+  editUI ({typeNamespace}) {
+    return ['div', {dataset: {type: 'undef'}}, [
+      ['label', [
+        'Undefined',
+        ['input', {
+          type: 'checkbox',
+          name: `${typeNamespace}-undef`,
+          checked: true,
+          disabled: true
+        }]
+      ]]
+    ]];
+  }
+};
+
+export default undefinedType;

package/src/index.js

@@ -0,0 +1,7 @@
+export {default as Types} from './types.js';
+
+export {default as Formats} from './formats.js';
+
+export {
+  default as typeChoices, getFormatAndSchemaChoices
+} from './typeChoices.js';