@es-joy/jsoe 0.2.0 → 0.4.0

package/src/formatAndTypeChoices.js

@@ -1,4 +1,4 @@
-import {jml} from '../vendor/jamilih/dist/jml-es.js';
+import {jml} from './vendor-imports.js';
 import {buildTypeChoices} from './typeChoices.js';
 import Types from './types.js';
 import {getControlsForFormatAndValue} from './formats.js';
@@ -16,7 +16,8 @@ import {$e, DOM} from './utils/templateUtils.js';
  */
 export const getFormatAndSchemaChoices = ({schema, hasKeyPath} = {}) => {
   const hasSchema = typeof schema === 'string';
-  return [
+  // eslint-disable-next-line max-len -- Long
+  return /** @type {[optText: string, opts: {value: string, selected?: boolean}][]} */ ([
     ['JSON only', {value: 'json'}],
     ...(hasKeyPath
       ? []
@@ -48,14 +49,26 @@ export const getFormatAndSchemaChoices = ({schema, hasKeyPath} = {}) => {
               'for structured cloning'
         }]
     */
-  ].map(([optText, optAtts]) => {
-    return jml('option', optAtts, [optText]);
-  }).reduce((frag, option) => {
+  ]).map(([optText, optAtts]) => {
+    return /** @type {HTMLOptionElement} */ (
+      jml('option', optAtts, [optText])
+    );
+  }).reduce((
+    frag,
+    option
+  ) => {
     frag.append(option);
     return frag;
   }, document.createDocumentFragment());
 };
 
+/**
+ * @callback SetValue
+ * @param {import('./formats.js').StructuredCloneValue} value
+ * @param {import('./types.js').StateObject} stateObj
+ * @returns {Promise<void>}
+ */
+
 /**
  * Builds a selector and container for types.
  * @param {object} cfg
@@ -77,9 +90,10 @@ export const getFormatAndSchemaChoices = ({schema, hasKeyPath} = {}) => {
  *   typesHolder: TypesHolder,
  *   domArray: [formatChoices: FormatChoices, typesHolder: TypesHolder],
  *   getValue: (stateObj: import('./types.js').StateObject,
- *     currentPath: string) => StructuredCloneValue,
- *   getType: () => string|undefined,
- *   validValuesSet: () => boolean
+ *     currentPath: string) => import('./formats.js').StructuredCloneValue,
+ *   getType: () => string|null|undefined,
+ *   validValuesSet: () => boolean,
+ *   setValue: SetValue
  * }} The selector for types and the container for them. Both should be
  *   added to the page.
  */
@@ -92,7 +106,7 @@ export function formatAndTypeChoices ({
   typeNamespace
 }) {
   const format = 'structuredCloning';
-  const formatChoices = jml('select', {
+  const formatChoices = /** @type {HTMLSelectElement} */ (jml('select', {
     class: 'formatChoices',
     hidden: singleValue,
     // is: 'main-type-choices',
@@ -130,8 +144,10 @@ export function formatAndTypeChoices ({
       $buildTypeChoices () {
         DOM.removeChildren(typesHolder);
         jml({'#': buildTypeChoices({
-          topRoot: $e(typesHolder, 'div[data-type]'),
-          resultType: 'both',
+          topRoot: /** @type {HTMLDivElement} */ (
+            $e(typesHolder, 'div[data-type]')
+          ),
+          // resultType: 'both',
           format: this.value,
           typeNamespace,
           requireObject: hasKeyPath,
@@ -142,18 +158,20 @@ export function formatAndTypeChoices ({
       }
     },
     $on: {change () {
-      this.$buildTypeChoices();
+      /** @type {Element & {$buildTypeChoices: TypeChoiceBuilder}} */ (
+        this
+      ).$buildTypeChoices();
     }}
-  }, [getFormatAndSchemaChoices({schema, hasKeyPath})]);
+  }, [getFormatAndSchemaChoices({schema, hasKeyPath})]));
 
   /**
    * @callback TypeRootGetter
-   * @returns {void}
+   * @returns {Element|null}
    */
 
   /**
    * @callback TypeSelectGetter
-   * @returns {void}
+   * @returns {HTMLSelectElement|null}
    */
 
   /**
@@ -162,24 +180,30 @@ export function formatAndTypeChoices ({
    * @property {TypeSelectGetter} $getTypeSelect
    */
 
-  const typesHolder = jml('div', {class: 'typesHolder', $custom: {
-    /**
-     * @type {TypeRootGetter}
-     */
-    $getTypeRoot () {
-      return $e(this, 'div[data-type]');
-    },
-    /**
-     * @type {TypeSelectGetter}
-     */
-    $getTypeSelect () {
-      return $e(this, `.typeChoices-${typeNamespace}`);
-    }
-  }});
+  const typesHolder = /** @type {HTMLDivElement} */ (
+    jml('div', {class: 'typesHolder', $custom: {
+      /**
+       * @type {TypeRootGetter}
+       * @this {Element}
+       */
+      $getTypeRoot () {
+        return $e(this, 'div[data-type]');
+      },
+      /**
+       * @type {TypeSelectGetter}
+       * @this {HTMLSelectElement}
+       */
+      $getTypeSelect () {
+        return /** @type {HTMLSelectElement} */ (
+          $e(this, `.typeChoices-${typeNamespace}`)
+        );
+      }
+    }})
+  );
 
   jml({'#': buildTypeChoices({
-    resultType: 'both',
-    topRoot: $e(typesHolder, 'div[data-type]'),
+    // resultType: 'both',
+    topRoot: /** @type {HTMLDivElement} */ ($e(typesHolder, 'div[data-type]')),
     format,
     typeNamespace,
     requireObject: hasKeyPath,
@@ -200,46 +224,67 @@ export function formatAndTypeChoices ({
      * @param {import('./types.js').StateObject} [stateObj] Will
      *   auto-set `typeNamespace` and `format`
      * @param {string} [currentPath]
-     * @returns {StructuredCloneValue}
+     * @returns {import('./formats.js').StructuredCloneValue}
      */
     getValue (stateObj, currentPath) {
-      const root = typesHolder.$getTypeRoot();
-      return Types.getValueForRoot(root, {
+      // eslint-disable-next-line max-len -- Long
+      const root = /** @type {HTMLDivElement & {$getTypeRoot: TypeRootGetter}} */ (
+        typesHolder
+      ).$getTypeRoot();
+      return Types.getValueForRoot(/** @type {HTMLDivElement} */ (root), {
         typeNamespace,
-        format: formatChoices.value,
+        format: /** @type {import('./formats.js').AvailableFormat} */ (
+          formatChoices.value
+        ),
         ...stateObj
       }, currentPath);
     },
 
     /**
-     * @returns {string|undefined}
+     * @returns {string|null|undefined}
      */
     getType () {
-      const root = typesHolder.$getTypeRoot();
-      return Types.getTypeForRoot(root);
+      // eslint-disable-next-line max-len -- Long
+      const root = /** @type {HTMLDivElement & {$getTypeRoot: TypeRootGetter}} */ (
+        typesHolder
+      ).$getTypeRoot();
+      return Types.getTypeForRoot(/** @type {HTMLDivElement} */ (root));
     },
 
     /**
      * @returns {boolean}
      */
     validValuesSet () {
-      const root = typesHolder.$getTypeRoot();
-      const form = root.closest('form');
+      // eslint-disable-next-line max-len -- Long
+      const root = /** @type {HTMLDivElement & {$getTypeRoot: TypeRootGetter}} */ (
+        typesHolder
+      ).$getTypeRoot();
+      const form = /** @type {HTMLFormElement} */ (
+        /** @type {Element} */ (root).closest('form')
+      );
       return Types.validValuesSet({form, typeNamespace});
     },
 
-    /**
-     * @param {StructuredCloneValue} value
-     * @param {import('./types.js').StateObject} stateObj
-     * @returns {Promise<void>}
-     */
+    /** @type {SetValue} */
     async setValue (value, stateObj) {
-      const rootEditUI = await getControlsForFormatAndValue(
-        formatChoices.value, value, stateObj
+      const rootEditUI = /** @type {HTMLDivElement} */ (
+        await getControlsForFormatAndValue(
+          /** @type {import('./formats.js').AvailableFormat} */ (
+            formatChoices.value
+          ),
+          value,
+          stateObj
+        )
       );
-      const type = Types.getTypeForRoot(rootEditUI);
-      const sel = typesHolder.$getTypeSelect();
-      sel.$addTypeAndEditUI({type, editUI: rootEditUI});
+      const type = /** @type {string} */ (Types.getTypeForRoot(rootEditUI));
+      // eslint-disable-next-line max-len -- Long
+      const sel = /** @type {HTMLDivElement & {$getTypeSelect: TypeSelectGetter}} */ (
+        typesHolder
+      ).$getTypeSelect();
+      // eslint-disable-next-line max-len -- Long
+      /** @type {HTMLSelectElement & {$addTypeAndEditUI: import('./typeChoices.js').AddTypeAndEditUI}} */ (
+        sel
+      ).$addTypeAndEditUI({type, editUI: rootEditUI});
     }
   };
 }

package/src/formats/indexedDBKey.js

@@ -1,66 +1,59 @@
-import * as structuredCloning from './structuredCloning.js';
+import structuredCloning from './structuredCloning.js';
 
-// Todo (low): Support ArrayBuffer
-/**
- * @returns {string[]}
- */
-export const types = () => [
-  'number', 'Infinities', 'string', 'ValidDate', 'array'
-];
-
-// A hack until we simply pass in our own types or do own parsing
-
-/**
- * @param {string} newType
- * @param {Date|GenericArray} value
- * @returns {boolean}
- */
-export const testInvalid = (newType, value) => {
-  switch (newType) {
-  /* istanbul ignore next -- Shouldn't occur as it is a preset */
-  case 'Infinities':
+/** @type {import('../formats.js').Format} */
+const indexedDBKey = {
+  types: () => [
+    'number', 'SpecialRealNumber', 'string', 'ValidDate', 'array'
+  ],
+  // A hack until we simply pass in our own types or do own parsing
+  testInvalid (newType, value) {
+    switch (newType) {
     /* istanbul ignore next -- Shouldn't occur as it is a preset */
-    return Number.isNaN(value);
-  case 'ValidDate':
-    return Number.isNaN(value.getTime());
-  case 'array':
-    return Object.keys(value).length !== value.length;
-  /* istanbul ignore next -- Shouldn't occur */
-  default:
+    case 'SpecialRealNumber':
+      /* istanbul ignore next -- Shouldn't occur as it is a preset */
+      return Number.isNaN(value);
+    case 'ValidDate':
+      return Number.isNaN(/** @type {Date} */ (value).getTime());
+    case 'array':
+      return Object.keys(value).length !==
+      /** @type {Array<import('../formats.js').StructuredCloneValue>} */ (
+        value
+      ).length;
     /* istanbul ignore next -- Shouldn't occur */
+    default:
+      /* istanbul ignore next -- Shouldn't occur */
+      return false; // Todo: Should this throw?
+    }
+  },
+  convertFromTypeson (typesonType) {
+    return typesonToIndexedDBKey.get(typesonType);
+  },
+  iterate (records, stateObj) {
+    stateObj.format = 'indexedDBKey';
+    return structuredCloning.iterate(records, stateObj);
+  },
+  getTypesForState (state) {
+    if (!state || ['array'].includes(state)) {
+      return this.types();
+    }
+    /* istanbul ignore next -- Can't be object, so shouldn't reach here */
     return undefined; // Todo: Should this throw?
   }
 };
 
-/**
- * @param {string} typesonType
- * @returns {string}
- */
-export const convertFromTypeson = (typesonType) => {
-  return {
-    SpecialNumber: 'Infinities', // This shouldn't occur as it is a preset
-    date: 'ValidDate',
-    // sparseArrays: 'array',
-    arrayNonindexKeys: 'array'
-  }[typesonType];
-};
+// Todo (low): Support ArrayBuffer
 
 /**
- * @type {import('./structuredCloning.js').FormatIterator}
- */
-export const iterate = (records, stateObj) => {
-  stateObj.format = 'indexedDBKey';
-  return structuredCloning.iterate(records, stateObj);
-};
+ * @type {Map<import('../types.js').AvailableType,
+*   import('../types.js').AvailableType>
+* }
+*/
+const typesonToIndexedDBKey = new Map([
+  // This shouldn't occur as it is a preset
+  ['SpecialNumber', 'SpecialRealNumber'],
+  ['date', 'ValidDate'],
+  // 'sparseArrays', 'array',
+  ['arrayNonindexKeys', 'array']
+]);
 
-/**
- * @param {"array"|undefined} state
- * @returns {undefined|string[]}
- */
-export const getTypesForState = function (state) {
-  if (!state || ['array'].includes(state)) {
-    return this.types();
-  }
-  /* istanbul ignore next -- Can't be object, so shouldn't reach here */
-  return undefined; // Todo: Should this throw?
-};
+export default indexedDBKey;

package/src/formats/json.js

@@ -1,64 +1,55 @@
-import * as structuredCloning from './structuredCloning.js';
+import structuredCloning from './structuredCloning.js';
 
 /**
- * @returns {string[]}
+ * @type {Map<import('../types.js').AvailableType,
+ *   import('../types.js').AvailableType>
+ * }
  */
-export const types = () => [
-  'null', 'true', 'false', 'number', 'string', 'array', 'object'
-];
+const typesonToJson = new Map([
+  ['arrayNonindexKeys', 'array']
+]);
 
-/**
- * @type {import('./structuredCloning.js').FormatIterator}
- */
-export const iterate = (records, stateObj) => {
-  // Todo (low): Add a more optimal (`JSON.stringify`-based iterator)
-  const recs = records;
-  // I believe this escaping should be by Typeson itself
-  // if (records && typeof records === 'object' && records.$types) {
-  //   recs = {$: records, $types: true};
-  // }
-  stateObj.format = 'json';
-  return structuredCloning.iterate(recs, stateObj);
-};
-
-// A hack until we simply pass in our own types or do own parsing
-/**
- * @param {string} typesonType
- * @returns {string}
- */
-export const convertFromTypeson = (typesonType) => {
-  return {
-    // sparseArrays: 'array',
-    arrayNonindexKeys: 'array'
-  }[typesonType];
-};
-
-/**
- * @param {string} newType
- * @param {GenericArray} value
- * @returns {boolean|undefined}
- */
-export const testInvalid = (newType, value) => {
-  switch (newType) {
-  case 'array':
-    return Object.keys(value).length !== value.length;
-  /* istanbul ignore next -- Shouldn't occur */
-  default:
+/** @type {import('../formats.js').Format} */
+const json = {
+  types: () => [
+    'null', 'true', 'false', 'number', 'string', 'array', 'object'
+  ],
+  iterate (records, stateObj) {
+    // Todo (low): Add a more optimal (`JSON.stringify`-based iterator)
+    const recs = records;
+    // I believe this escaping should be by Typeson itself
+    // if (records && typeof records === 'object' && records.$types) {
+    //   recs = {$: records, $types: true};
+    // }
+    stateObj.format = 'json';
+    return structuredCloning.iterate(recs, stateObj);
+  },
+  // A hack until we simply pass in our own types or do own parsing
+  convertFromTypeson (typesonType) {
+    return typesonToJson.get(typesonType);
+  },
+  testInvalid (newType, value) {
+    switch (newType) {
+    case 'array':
+      return Object.keys(value).length !==
+      /** @type {Array<import('../formats.js').StructuredCloneValue>} */ (
+        value
+      ).length;
     /* istanbul ignore next -- Shouldn't occur */
-    return undefined; // Todo: Fix?
+    default:
+      /* istanbul ignore next -- Shouldn't occur */
+      return undefined; // Todo: Fix?
+    }
+  },
+  getTypesForState (state) {
+    /* istanbul ignore else -- No other states apparently */
+    if (!state || ['array', 'object'].includes(state)) {
+      return this.types();
+    }
+    // Todo: Should this throw?
+    /* istanbul ignore next -- No other states apparently */
+    return undefined;
   }
 };
 
-/**
- * @param {string} state
- * @returns {string[]|undefined}
- */
-export const getTypesForState = function (state) {
-  /* istanbul ignore else -- No other states apparently */
-  if (!state || ['array', 'object'].includes(state)) {
-    return this.types();
-  }
-  // Todo: Should this throw?
-  /* istanbul ignore next -- No other states apparently */
-  return undefined;
-};
+export default json;

package/src/formats/schemaOnly.js

@@ -3,10 +3,13 @@
   sonarjs/no-empty-collection,
   sonarjs/no-identical-conditions,
   no-constant-binary-expression -- Just debugging */
-import Formats from '../formats.js';
+import {getTypeForFormatStateAndValue} from '../formats.js';
 import * as structuredCloning from './structuredCloning.js';
 import deepEqual from '../deepEqual.js';
 
+/**
+ * @typedef {import('./formats.js').StructuredCloneValue} StructuredCloneValue
+ */
 /**
  * @type {import('./structuredCloning.js').FormatIterator}
  */
@@ -31,11 +34,18 @@ export const iterate = (records, stateObj) => {
   const resolveRef = (/* {schema, possibleSchemaObject} */) => {
     // Todo?
   };
+
+  /**
+   * @param {object} cfg
+   * @param {StructuredCloneValue[]} cfg.list
+   * @param {StructuredCloneValue} cfg.value
+   * @returns {boolean}
+   */
   const valueInEnumList = ({list, value}) => {
     return list.some((en) => deepEqual(en, value));
   };
   const getTypesForValues = ({enumList}) => enumList.map(
-    (value) => Formats.getTypeForFormatStateAndValue({
+    (value) => getTypeForFormatStateAndValue({
       value,
       format: 'structuredCloning',
       state: 'arrayNonindexKeys'