@es-joy/jsoe 0.12.4 → 0.13.1

package/src/formats/json.js

@@ -41,7 +41,7 @@ const json = {
       return undefined; // Todo: Fix?
     }
   },
-  getTypesForState (state) {
+  getTypesForState (types, state) {
     /* istanbul ignore else -- No other states apparently */
     if (!state || ['array', 'object'].includes(state)) {
       return this.types();

package/src/formats/schemaAndArbitrary.js

@@ -15,6 +15,6 @@ export const iterate = (records, stateObj) => {
  */
 export const getTypesForState = (state) => {
   return structuredCloning.getTypesForState.call(
-    this, state
+    this, types, state
   );
 };

package/src/formats/schemaOnly.js

@@ -534,6 +534,6 @@ export const iterate = (records, stateObj) => {
  */
 export const getTypesForState = (state) => {
   return structuredCloning.getTypesForState.call(
-    this, state
+    this, types, state
   );
 };

package/src/formats/structuredCloning.js

@@ -2,8 +2,6 @@ import {
   Typeson, unescapeKeyPathComponent, structuredCloningThrowing
 } from '../vendor-imports.js';
 
-import Formats from '../formats.js';
-import Types from '../types.js';
 import {buildTypeChoices} from '../typeChoices.js';
 import {
   typesonPathToJSONPointer
@@ -34,6 +32,8 @@ import json from './json.js';
 const encapsulateObserver = (stateObj) => {
   const {
     typeNamespace, readonly, format: frmt, schemaContent,
+    formats,
+    types,
     getPossibleSchemasForPathAndType
   } = stateObj;
 
@@ -106,11 +106,15 @@ const encapsulateObserver = (stateObj) => {
       newValue = typesonPathToJSONPointer(cyclicKeypath);
       newType = type === 'array' ? 'arrayReference' : 'objectReference';
       newType = canonicalToAvailableType(
+        /** @type {import('../types.js').default} */ (types),
+        /** @type {import('../formats.js').default} */ (formats),
         format, state, newType, value
       ); // Todo (low): Add accurate state for second argument
     } else {
       try {
         newType = canonicalToAvailableType(
+          /** @type {import('../types.js').default} */ (types),
+          /** @type {import('../formats.js').default} */ (formats),
           format,
           state,
           /**
@@ -147,7 +151,7 @@ const encapsulateObserver = (stateObj) => {
 
     if (!stateObj.rootUI) {
       // console.log('vvvv0', newType, newValue);
-      stateObj.rootUI = Types.getUIForModeAndType({
+      stateObj.rootUI = types?.getUIForModeAndType({
         readonly,
         typeNamespace,
         type: newType,
@@ -245,13 +249,13 @@ const encapsulateObserver = (stateObj) => {
       }
 
       if (!readonly) {
-        Types.setValue({
+        types?.setValue({
           type: newType,
           // eslint-disable-next-line object-shorthand -- TS
           root: /** @type {HTMLDivElement} */ (root),
           value: newValue
         });
-        Types.validate({
+        types?.validate({
           type: newType,
           // eslint-disable-next-line object-shorthand -- TS
           root: /** @type {HTMLDivElement} */ (root),
@@ -295,6 +299,8 @@ const replaceTypes = (originTypes, replacements) => {
 };
 
 /**
+ * @param {import('../types.js').default} types
+ * @param {import('../formats.js').default} formats
  * @param {import('../formats.js').AvailableFormat} format
  * @param {string} state
  * @param {import('../types.js').AvailableType} valType
@@ -302,10 +308,12 @@ const replaceTypes = (originTypes, replacements) => {
  * @throws {Error}
  * @returns {import('../types.js').AvailableType}
  */
-const canonicalToAvailableType = (format, state, valType, v) => {
-  const frmt = Formats.availableFormats[format];
+const canonicalToAvailableType = (
+  types, formats, format, state, valType, v
+) => {
+  const frmt = formats.getAvailableFormat(format);
   const {getTypesForState, convertFromTypeson, testInvalid} = frmt;
-  const allowableTypes = getTypesForState.call(frmt, state);
+  const allowableTypes = getTypesForState.call(frmt, types, state);
   /* istanbul ignore if -- Guard */
   if (!allowableTypes) {
     throw new Error('Unexpected undefined type for state');
@@ -342,7 +350,7 @@ const canonicalToAvailableType = (format, state, valType, v) => {
   allowableTypes.some((allowableType) => {
     // eslint-disable-next-line @stylistic/max-len -- Long
     const typeObj = /** @type {import('../types.js').TypeObject & {childTypes: string[]}} */ (
-      Types.availableTypes[allowableType]
+      types.getTypeObject(allowableType)
     );
     const {
       valueMatch, superType, childTypes
@@ -409,12 +417,13 @@ const structuredCloning = {
       }
     });
   },
-  getTypesForState (state) {
-    if (state && Types.contexts.structuredCloning[state]) {
-      const typesForFormat = this.getTypesForState() ||
+  getTypesForState (types, state) {
+    if (state && types.getContextInfo('structuredCloning', state)) {
+      const typesForFormat = this.getTypesForState(types) ||
         /* istanbul ignore next -- types should be an array */
         [];
-      Types.contexts.structuredCloning[state].forEach(({type, after}) => {
+      const contextInfo = types.getContextInfo('structuredCloning', state);
+      contextInfo.forEach(({type, after}) => {
         const precedingIdx = typesForFormat.indexOf(after);
         typesForFormat.splice(precedingIdx + 1, 0, type);
       });

package/src/formats.js

@@ -7,6 +7,14 @@ import structuredCloning from './formats/structuredCloning.js';
  * @typedef {any} StructuredCloneValue
  */
 
+/**
+ * @callback GetTypesForFormatAndState
+ * @param {import('./types.js').default} types
+ * @param {AvailableFormat} format
+ * @param {string} [state]
+ * @returns {import('./types.js').AvailableType[]|undefined}
+ */
+
 /* schema:
 export const getTypeForFormatStateAndValue = ({format, state, value}) => {
   const valType = new Typeson().register(
@@ -30,39 +38,92 @@ export const getTypeForFormatStateAndValue = ({format, state, value}) => {
  *     typesonType: import('./types.js').AvailableType
  *   ) => import('./types.js').AvailableType|undefined,
  *   iterate: import('./formats/structuredCloning.js').FormatIterator,
- *   getTypesForState: (state?: string) => undefined|
+ *   getTypesForState: (
+ *     types: import('./types.js').default,
+ *     state?: string
+ *   ) => undefined|
  *     (import('./types.js').AvailableType)[]
  * }} Format
  */
 
-// Using methods ensure we have fresh copies
-const Formats = {
-  availableFormats: /** @type {{[key: string]: Format}} */ ({
-    indexedDBKey,
-    json,
-    // Todo (readme): these too? getTypesForState(state)
-    /* schema:
-    schemaAndArbitrary,
-    schemaOnly,
-    */
-    structuredCloning
-  })
-};
-
 /**
- * @param {AvailableFormat} format
- * @param {StructuredCloneValue} record
- * @param {import('./types.js').StateObject} stateObj
- * @returns {Promise<Element>}
+ * Class for processing multiple formats.
  */
-export async function getControlsForFormatAndValue (format, record, stateObj) {
-  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
-      format
+class Formats {
+  /**
+   *
+   */
+  constructor () {
+    // Can enable later (and add tests)
+    // if (formats) {
+    //   this.availableFormats = {};
+    //   formats.forEach((format) => {
+    //     let formatValue;
+    //     switch (format) {
+    //     case 'indexedDBKey':
+    //       formatValue = indexedDBKey;
+    //       break;
+    //     case 'json':
+    //       formatValue = json;
+    //       break;
+    //     case 'structuredCloning':
+    //       formatValue = structuredCloning;
+    //       break;
+    //     default:
+    //       throw new Error('Unknown format');
+    //     }
+    //     this.availableFormats[format] = formatValue;
+    //   });
+    //   return;
+    // }
+    // Using methods ensure we have fresh copies
+    this.availableFormats = /** @type {{[key: string]: Format}} */ ({
+      indexedDBKey,
+      json,
+      // Todo (readme): these too? getTypesForState(types, state)
+      /* schema:
+      schemaAndArbitrary,
+      schemaOnly,
+      */
+      structuredCloning
     });
+  }
+
+  /**
+   * @param {import('./types.js').default} types
+   * @param {AvailableFormat} format
+   * @param {StructuredCloneValue} record
+   * @param {import('./types.js').StateObject} stateObj
+   * @returns {Promise<Element>}
+   */
+  async getControlsForFormatAndValue (types, format, record, stateObj) {
+    return await this.availableFormats[format].
+      iterate(record, {
+        ...stateObj,
+        types,
+        formats: this,
+        // This had been before `stateObj` but should apparently have precedence
+        //   or just avoid passing `format` to this function
+        format
+      });
+  }
+
+  /**
+   * @type {GetTypesForFormatAndState}
+   */
+  getTypesForFormatAndState (
+    types, format, state
+  ) {
+    return this.availableFormats[format].getTypesForState(types, state);
+  }
+
+  /**
+   * @param {AvailableFormat} format
+   * @returns {Format}
+   */
+  getAvailableFormat (format) {
+    return this.availableFormats[format];
+  }
 }
 
 export default Formats;

package/src/fundamentalTypes/arrayReferenceType.js

@@ -176,12 +176,12 @@ const arrayReferenceType = {
       valid: true
     };
   },
-  validateAll ({topRoot}) {
+  validateAll ({types, topRoot}) {
     const type = /** @type {import('../types.js').AvailableType} */ (
       `${this.type}Reference`
     );
     $$e(topRoot, `div[data-type="${type}"]`).forEach((root) => {
-      Types.validate({
+      types.validate({
         type,
         // eslint-disable-next-line object-shorthand -- TS
         root: /** @type {HTMLDivElement} */ (root),

package/src/fundamentalTypes/arrayType.js

@@ -1,6 +1,6 @@
 import {jml, nbsp} from '../vendor-imports.js';
 
-import Types, {getPropertyValueFromLegend} from '../types.js';
+import {getPropertyValueFromLegend} from '../types.js';
 import {$e, U, DOM} from '../utils/templateUtils.js';
 import dialogs from '../utils/dialogs.js';
 import {
@@ -97,7 +97,10 @@ const arrayType = {
     } = /** @type {import('../types.js').RootInfo} */ (info);
     // eslint-disable-next-line prefer-destructuring -- TS
     const format = /** @type {import('../types.js').RootInfo} */ (info).format;
-
+    // eslint-disable-next-line prefer-destructuring -- TS
+    const types = /** @type {import('../types.js').default} */ (
+      /** @type {import('../types.js').RootInfo} */ (info).types
+    );
     const {sparse} = this;
     const state = sparse
       ? 'arrayNonindexKeys'
@@ -148,7 +151,7 @@ const arrayType = {
         }
         let v, beginOnly, assign;
         try {
-          [v, stringVal, beginOnly, assign] = Types.getValueForString(
+          [v, stringVal, beginOnly, assign] = types.getValueForString(
             stringVal,
             {
               firstRun: false,
@@ -205,7 +208,7 @@ const arrayType = {
       stringVal = stringVal.slice(propAndColon[0].length);
       let v, beginOnly, assign;
       try {
-        [v, stringVal, beginOnly, assign] = Types.getValueForString(
+        [v, stringVal, beginOnly, assign] = types.getValueForString(
           stringVal,
           {
             firstRun: false, format, state,
@@ -234,7 +237,13 @@ const arrayType = {
     parse();
     return {value: retObj, remnant: stringVal};
   },
-  getValue ({root, stateObj = {}, currentPath = ''}) {
+  getValue ({root, stateObj, currentPath = ''}) {
+    /* istanbul ignore if */
+    if (!stateObj) {
+      throw new Error('TS guard'); // TS guard
+    }
+    // eslint-disable-next-line prefer-destructuring -- TS
+    const types = /** @type {import('../types.js').default} */ (stateObj.types);
     const top = currentPath === '';
     const arrayItems =
       /**
@@ -267,10 +276,10 @@ const arrayType = {
      * @returns {[boolean, any?]}
      */
     const getValOrRef = (root, currentPathPart) => {
-      const value = Types.getValueForRoot(
+      const value = types.getValueForRoot(
         root, stateObj, currentPath + '/' + currentPathPart
       );
-      if (stateObj.handlingReference) {
+      if ('handlingReference' in stateObj && stateObj.handlingReference) {
         // We deal with references later once object is fully constructed
         stateObj.handlingReference = false;
         return [false];
@@ -346,7 +355,7 @@ const arrayType = {
   },
 
   // Try to keep in sync with basic structure of `editUI`
-  viewUI ({typeNamespace, type, value, topRoot, resultType, format}) {
+  viewUI ({typeNamespace, type, types, value, topRoot, resultType, format}) {
     // const {sparse} = this;
     let itemIndex = -1;
 
@@ -403,7 +412,7 @@ const arrayType = {
             schemaContent, schemaState
           }) {
             if (parentType === 'map') {
-              const root = Types.getUIForModeAndType({
+              const root = types.getUIForModeAndType({
                 resultType,
                 readonly: true,
                 typeNamespace, type, topRoot,
@@ -434,7 +443,7 @@ const arrayType = {
             }
 
             const fieldset = this.$addArrayElement({propName});
-            const root = Types.getUIForModeAndType({
+            const root = types.getUIForModeAndType({
               resultType,
               readonly: true,
               typeNamespace, type, topRoot,
@@ -544,6 +553,7 @@ const arrayType = {
   //    population of the array in the callback
   editUI ({
     typeNamespace, buildTypeChoices, format, // resultType,
+    formats, types,
     type, arrayState, topRoot, value, bringIntoFocus = true
   }) {
     const {sparse} = this;
@@ -634,7 +644,7 @@ const arrayType = {
       } else {
         group.before(swapGroup);
       }
-      Types.validateAllReferences({
+      types.validateAllReferences({
         // eslint-disable-next-line object-shorthand -- TS
         topRoot: /** @type {HTMLDivElement} */ (topRoot)
       }); // Needed
@@ -817,7 +827,7 @@ const arrayType = {
                 (this).$validateMapKey();
 
                 // Needed?
-                Types.validateAllReferences({
+                types.validateAllReferences({
                   // eslint-disable-next-line object-shorthand -- TS
                   topRoot: /** @type {HTMLDivElement} */ (topRoot)
                 });
@@ -902,7 +912,7 @@ const arrayType = {
                   /* await */ this.$validateLegend();
                   // Todo (low): We could make this more efficient by waiting
                   //   until all added (when pre-populating)
-                  Types.validateAllReferences({
+                  types.validateAllReferences({
                     // eslint-disable-next-line object-shorthand -- TS
                     topRoot: /** @type {HTMLDivElement} */ (topRoot)
                   }); // Needed
@@ -1157,7 +1167,17 @@ const arrayType = {
                       parentTypeObject.getValue.call({
                         ...parentTypeObject,
                         set: false
-                      }, {root})
+                      }, {
+                        root,
+                        stateObj: {
+                          types,
+                          // eslint-disable-next-line object-shorthand -- TS
+                          formats:
+                          /** @type {import('../formats.js').default} */ (
+                            formats
+                          )
+                        }
+                      })
                     );
                     // console.log('values', values);
 
@@ -1179,7 +1199,7 @@ const arrayType = {
                       if (!root) {
                         return null;
                       }
-                      return Types.getFormControlForRoot(root);
+                      return types.getFormControlForRoot(root);
                     });
 
                     const control = controls[dupeIndex];
@@ -1281,7 +1301,7 @@ const arrayType = {
           }
           // Maybe not needed as addition (without renumbering)
           //   wouldn't yet add type
-          Types.validateAllReferences({
+          types.validateAllReferences({
             // eslint-disable-next-line object-shorthand -- TS
             topRoot: /** @type {HTMLDivElement} */ (topRoot)
           });
@@ -1307,7 +1327,7 @@ const arrayType = {
                   });
                 }
                 // Maybe not needed as removal would remove circular
-                Types.validateAllReferences({
+                types.validateAllReferences({
                   // eslint-disable-next-line object-shorthand -- TS
                   topRoot: /** @type {HTMLDivElement} */ (topRoot)
                 });
@@ -1419,7 +1439,7 @@ const arrayType = {
           (this).$addArrayElement({alwaysFocus: true});
           // Maybe not needed as addition (without renumbering)
           //   wouldn't yet add type
-          Types.validateAllReferences({
+          types.validateAllReferences({
             // eslint-disable-next-line object-shorthand -- TS
             topRoot: /** @type {HTMLDivElement} */ (topRoot)
           });
@@ -1471,7 +1491,7 @@ const arrayType = {
                       fieldset.remove();
                     });
                     // Maybe not needed as removal would remove circular
-                    Types.validateAllReferences({
+                    types.validateAllReferences({
                       // eslint-disable-next-line object-shorthand -- TS
                       topRoot: /** @type {HTMLDivElement} */ (topRoot)
                     });
@@ -1565,7 +1585,7 @@ const arrayType = {
             ).$redrawMoveArrows();
           }
           // Maybe not needed as removal would remove circular
-          Types.validateAllReferences({
+          types.validateAllReferences({
             // eslint-disable-next-line object-shorthand -- TS
             topRoot: /** @type {HTMLDivElement} */ (topRoot)
           });
@@ -1587,7 +1607,7 @@ const arrayType = {
             itemIndex = -1;
           }
           // Maybe not needed as removal would remove circular
-          Types.validateAllReferences({
+          types.validateAllReferences({
             // eslint-disable-next-line object-shorthand -- TS
             topRoot: /** @type {HTMLDivElement} */ (topRoot)
           });
@@ -1642,13 +1662,13 @@ const arrayType = {
             //   from `errorsSpecialType` (and `filelistType`)
             if (setAValue) {
               const typeObj = /** @type {import('../types.js').TypeObject} */ (
-                Types.availableTypes[type]
+                types.getTypeObject(type)
               );
               if (typeObj.setValue) {
                 typeObj.setValue({root, value});
               }
             }
-            Types.validate({type, root, topRoot});
+            types.validate({type, root, topRoot});
             return root;
           },
 

package/src/fundamentalTypes/dateType.js

@@ -1,6 +1,5 @@
 import {jml} from '../vendor-imports.js';
 import {$e} from '../utils/templateUtils.js';
-import Types from '../types.js';
 
 /**
  * @typedef {(
@@ -94,7 +93,7 @@ const dateType = {
   },
   // Change to default to `new Date()` when can't be `NaN`
   //   value (keys)?
-  editUI ({typeNamespace, value = ''}) {
+  editUI ({typeNamespace, types, value = ''}) {
     const notANum = this.isValueInvalid(value);
     const invalid = this.valid
       ? ''
@@ -124,7 +123,7 @@ const dateType = {
                 const root = /** @type {HTMLDivElement} */ (
                   label.parentElement
                 );
-                Types.validate({type: 'date', root});
+                types.validate({type: 'date', root});
               }
             },
             $on: {

package/src/fundamentalTypes/errorType.js

@@ -169,7 +169,7 @@ const errorType = {
     return errObj;
   },
   viewUI (
-    {value: o, format}
+    {value: o, types, format}
   ) {
     return /** @type {import('jamilih').JamilihArray} */ ([
       'div', {dataset: {type: 'error'}}, [
@@ -208,7 +208,8 @@ const errorType = {
             o.cause
               ? this.viewUI({
                 format,
-                value: o.cause
+                value: o.cause,
+                types
               })
               : ''
           ]]
@@ -216,7 +217,7 @@ const errorType = {
       ]
     ]);
   },
-  editUI ({typeNamespace, value = {
+  editUI ({typeNamespace, types, value = {
     message: '',
     name: '',
     fileName: '',
@@ -382,6 +383,7 @@ const errorType = {
                 if (!causeContents?.children.length) {
                   const editui = component.editUI({
                     typeNamespace,
+                    types,
                     value: value.cause
                   });
                   jml(...editui, causeContents);

package/src/fundamentalTypes/regexpType.js

@@ -1,6 +1,5 @@
 import {jml} from '../vendor-imports.js';
 import {$e} from '../utils/templateUtils.js';
-import Types from '../types.js';
 
 /**
  * @type {import('../types.js').TypeObject & {allowedFlags: string[]}}
@@ -65,7 +64,7 @@ const regexpType = {
   viewUI ({value}) {
     return ['i', {dataset: {type: 'regexp'}}, [String(value)]];
   },
-  editUI ({typeNamespace, value = {source: '', flags: ''}}) {
+  editUI ({typeNamespace, types, value = {source: '', flags: ''}}) {
     // Todo (low): Add RegExp syntax highlighter
     const select = /** @type {HTMLSelectElement} */ (jml(
       'select',
@@ -107,7 +106,7 @@ const regexpType = {
     // Could be disallowed flags; we might instead try in
     //   advance which will work
     select.addEventListener('change', () => {
-      Types.validate({type: 'regexp', root});
+      types.validate({type: 'regexp', root});
     });
     return [root];
   }

package/src/index.js

@@ -11,7 +11,7 @@
 
 export {default as Types} from './types.js';
 
-export {default as Formats, getControlsForFormatAndValue} from './formats.js';
+export {default as Formats} from './formats.js';
 
 export {
   buildTypeChoices as typeChoices