@es-joy/jsoe 0.5.1 → 0.6.0

package/src/formats/structuredCloning.js

@@ -17,9 +17,10 @@ import json from './json.js';
  *   type: import('../types.js').AvailableType,
  *   value: import('../formats.js').StructuredCloneValue,
  *   bringIntoFocus?: boolean,
+ *   setAValue?: boolean,
  *   schemaContent?: object,
  *   schemaState?: import('../types.js').GetPossibleSchemasForPathAndType
- * }) => HTMLElement} AddAndSetArrayElement
+ * }) => HTMLElement|null} AddAndSetArrayElement
  */
 
 /**
@@ -44,6 +45,10 @@ const encapsulateObserver = (stateObj) => {
    * }}}
    */
   const parents = {};
+
+  /** @type {string[]} */
+  const mapPaths = [];
+
   return (observerObj) => {
     const {
       type,
@@ -57,13 +62,15 @@ const encapsulateObserver = (stateObj) => {
       endIterateUnsetNumeric,
       clone
     } = observerObj;
-    // console.log('observerObj', observerObj);
     if ('replaced' in observerObj) {
       return;
     }
     if (cyclic === 'readonly' && !Array.isArray(observerObj.value)) {
       return;
     }
+    if (cyclic === 'readonly' && type === 'set') {
+      return;
+    }
     if (endIterateIn || endIterateOwn) {
       return;
     }
@@ -73,6 +80,12 @@ const encapsulateObserver = (stateObj) => {
       return;
     }
 
+    // What other situations is this firing twice, and it
+    //   shouldn't reach here?
+    if (observerObj.replacing && type === 'negativeZero') {
+      return;
+    }
+
     /* istanbul ignore if -- Not part of format */
     if (type === 'sparseUndefined') { // We'll handle otherwise
       return;
@@ -119,12 +132,21 @@ const encapsulateObserver = (stateObj) => {
     const parentPath = li === -1 ? '' : keypath.slice(0, li);
 
     const hasChildren = [
-      'array', 'object',
+      'array', 'object', 'set', 'map',
       // 'sparseArrays',
       'arrayNonindexKeys'
     ].includes(newType);
 
+    // Maps are followed up by arrays which we don't want as such;
+    //  we track the paths to avoid reporting these child arrays
+    const mapType = type === 'map' &&
+      Object.prototype.toString.call(value) === '[object Map]';
+    if (mapType) {
+      mapPaths.push(keypath);
+    }
+
     if (!stateObj.rootUI) {
+      // console.log('vvvv0', newType, newValue);
       stateObj.rootUI = Types.getUIForModeAndType({
         readonly,
         typeNamespace,
@@ -152,6 +174,18 @@ const encapsulateObserver = (stateObj) => {
       * @type {HTMLElement &
       *   {$addAndSetArrayElement: AddAndSetArrayElement}}
       */ (stateObj.rootUI);
+
+      // Since we're skipping the array elements, we need to add the
+      //   map element to the array index where the array children
+      //   will be found (which we do want)
+      if (mapType) {
+        /** @type {Map<any, any>} */ [...value].forEach((_, i) => {
+          parents[i] = /**
+          * @type {HTMLElement &
+          *   {$addAndSetArrayElement: AddAndSetArrayElement}}
+          */ (stateObj.rootUI);
+        });
+      }
       return;
     }
 
@@ -172,6 +206,22 @@ const encapsulateObserver = (stateObj) => {
         return;
       }
 
+      // Skip the array structures immediately following the Map,
+      //   as map needs to handle
+      if (!mapType && mapPaths.some((mapPath) => {
+        if (mapPath === keypath ||
+          (mapPath === '' && (/^\d+$/u).test(keypath))) {
+          return true;
+        }
+        const trailingIndex = keypath.match(/\.\d+$/u);
+        return (trailingIndex && mapPath !== '' &&
+          keypath.slice(0, -trailingIndex[0].length) === mapPath);
+      })) {
+        return;
+      }
+
+      // console.log('vvvv', newType, '::', newValue, '::', newValue?.cause);
+
       const root = ui.$addAndSetArrayElement({
         propName: arrayOrObjectPropertyName,
         type: newType,
@@ -188,7 +238,16 @@ const encapsulateObserver = (stateObj) => {
           })
         */
       });
+
+      /* istanbul ignore if -- Guard for `null` return */
+      if (!root) {
+        return;
+      }
+
       if (!readonly) {
+        // Todo: Redundant with `typeObj.setValue`? Ensure `idb-manager`
+        //    does not need both; this write-only would seem preferable
+        //    to the block in `arrayType.js` if readonly indeed not needed
         Types.setValue({
           type: newType,
           // eslint-disable-next-line object-shorthand -- TS
@@ -210,6 +269,18 @@ const encapsulateObserver = (stateObj) => {
           */ (
             root
           );
+
+        // Since we're skipping the array elements, we need to add the
+        //   map element to the array index where the array children
+        //   will be found (which we do want)
+        if (mapType) {
+          /** @type {Map<any, any>} */ [...value].forEach((_, i) => {
+            parents[`${keypath}.${i}`] = /**
+            * @type {HTMLElement &
+            *   {$addAndSetArrayElement: AddAndSetArrayElement}}
+            */ (root);
+          });
+        }
       }
     });
   };
@@ -247,7 +318,7 @@ const canonicalToAvailableType = (format, state, valType, v) => {
    * @type {import('../types.js').AvailableType|undefined}
    */
   let ret;
-  console.log('format, state, valType, v', format, state, valType, v);
+  // console.log('format, state, valType, v', format, state, valType, v);
 
   /**
    * @param {string} newValType
@@ -278,9 +349,9 @@ const canonicalToAvailableType = (format, state, valType, v) => {
   })) {
     return /** @type {import('../types.js').AvailableType} */ (ret);
   }
-  console.log('ret', ret);
+  // console.log('ret', ret);
   allowableTypes.some((allowableType) => {
-    // eslint-disable-next-line max-len -- Long
+    // eslint-disable-next-line @stylistic/max-len -- Long
     const typeObj = /** @type {import('../types.js').TypeObject & {childTypes: string[]}} */ (
       Types.availableTypes[allowableType]
     );
@@ -298,7 +369,7 @@ const canonicalToAvailableType = (format, state, valType, v) => {
     }
     return false;
   });
-  console.log('ret2', ret);
+  // console.log('ret2', ret);
   if (ret === undefined) {
     return isInvalid(valType);
   }
@@ -315,7 +386,7 @@ const canonicalToAvailableType = (format, state, valType, v) => {
 /** @type {import('../formats.js').Format} */
 const structuredCloning = {
   iterate (records, stateObj) {
-    console.log('records', records);
+    // console.log('records', records);
     if (!stateObj.format) {
       stateObj.format = 'structuredCloning';
     }
@@ -348,6 +419,12 @@ const structuredCloning = {
       });
       return typesForFormat;
     }
+    // Todo: Could we implement schemas here by introducing new keys to
+    //         `Types.contexts` which could be used rather than manual
+    //         handling to determine a delimited group of children
+    if (state === 'errorsArray') {
+      return ['error', 'errors'];
+    }
     return this.types();
     /*
     // Todo (low): These need to specify their own inner contexts
@@ -375,35 +452,33 @@ const structuredCloning = {
       ...jsonTypes,
       'undef', // Explicit undefined only
       'bigint',
-      'SpecialNumber', // '`NaN`, `Infinity`, `-Infinity`'},
+      'SpecialNumber', // '`NaN`, `Infinity`, `-Infinity`, `-0`
       'date',
       'regexp',
       'BooleanObject',
       'NumberObject',
       'StringObject',
-      'blobHTML'
+      'error',
+      'errors',
+      'blobHTML',
+      'set',
+      'map'
       // Ok, but will need some work
-      //     'map', 'set',
-      //     'blob', 'file', 'filelist'
-      //     'arraybuffer', 'arraybufferview'
+      //     'blob', 'file', 'filelist',
+      //     'arraybuffer',
       //     'dataview', 'imagedata', 'imagebitmap',
       /*
-              // Typed Arrays
-              'int8array',
-              'uint8array',
-              'uint8clampedarray',
-              'int16array',
-              'uint16array',
-              'int32array',
-              'uint32array',
-              'float32array',
-              'float64array',
-
-              // Intl (imperfect)
-              'IntlCollator',
-              'IntlDateTimeFormat',
-              'IntlNumberFormat'
-              */
+      // Typed Arrays
+        'int8array',
+        'uint8array',
+        'uint8clampedarray',
+        'int16array',
+        'uint16array',
+        'int32array',
+        'uint32array',
+        'float32array',
+        'float64array',
+      */
     ];
   }
 };

package/src/formats.js

@@ -56,8 +56,8 @@ const Formats = {
  * @returns {Promise<Element>}
  */
 export async function getControlsForFormatAndValue (format, record, stateObj) {
-  return await Formats.availableFormats[format]
-    .iterate(record, {
+  return await Formats.availableFormats[format].
+    iterate(record, {
       ...stateObj,
       // This had been before `stateObj` but should apparently have precedence
       //   or just avoid passing `format` to this function

package/src/fundamentalTypes/arrayReferenceType.js

@@ -35,7 +35,7 @@ const arrayReferenceType = {
     structuredCloning: {
       // after: 'sparseArrays',
       after: 'arrayNonindexKeys',
-      contexts: ['arrayNonindexKeys', 'object']
+      contexts: ['arrayNonindexKeys', 'object', 'set']
       // contexts: ['sparseArrays', 'object']
     }
   },
@@ -47,7 +47,7 @@ const arrayReferenceType = {
   },
   getValue ({root, stateObj, currentPath}) {
     const referentPath = this.getInput({root}).value;
-    // eslint-disable-next-line max-len -- Long
+    // eslint-disable-next-line @stylistic/max-len -- Long
     /* istanbul ignore else -- ArrayRef will not be a root, so should have stateObj */
     if (stateObj) {
       if (!stateObj.paths) {
@@ -97,7 +97,7 @@ const arrayReferenceType = {
         'arrayNonindexKeys'
         // 'sparseArrays'
       ].includes(
-        /** @type {string} */ (Types.getTypeForRoot(referent))
+        Types.getTypeForRoot(referent)
       );
     };
     let message;