@es-joy/jsoe 0.16.0 → 0.17.0

package/src/formats/structuredCloning.js

@@ -20,14 +20,17 @@ import json from './json.js';
 };
 
 /**
+ * Delegates data-based UI building to method for adding child elements (a
+ *   method which is housed in the array type object).
  * @typedef {(info: {
  *   propName: string,
  *   type: import('../types.js').AvailableType,
  *   value: import('../formats.js').StructuredCloneValue,
  *   bringIntoFocus?: boolean,
  *   setAValue?: boolean,
- *   schemaContent?: object,
- *   schemaState?: import('../types.js').GetPossibleSchemasForPathAndType
+ *   schemaContent?: import('../formats/schema.js').ZodexSchema,
+ *   mustBeOptional?: boolean,
+ *   schemaIdx?: number
  * }) => HTMLElement|null} AddAndSetArrayElement
  */
 
@@ -36,6 +39,8 @@ import json from './json.js';
  */
 
 /**
+ * Obtains state-specific data and returns an observer that can build a UI based
+ *   on data it receives.
  * @param {import('../types.js').StateObject} stateObj
  * @returns {EncapsulateObserver}
  */
@@ -43,19 +48,26 @@ const encapsulateObserver = (stateObj) => {
   const {
     typeNamespace, readonly, format: frmt, schemaContent,
     formats,
-    types,
-    getPossibleSchemasForPathAndType
+    types
   } = stateObj;
 
   const format = /** @type {import('../formats.js').AvailableFormat} */ (frmt);
 
   /**
+   * Matches keypaths to the HTML UI Element.
    * @type {{[key: string]: HTMLElement & {
    *   $addAndSetArrayElement: AddAndSetArrayElement
    * }}}
    */
   const parents = {};
 
+  /**
+   * @type {{
+   *   [key: string]: [import('zodex').SzType, number|undefined]|undefined
+   * }}
+   */
+  const schemaParents = {};
+
   /** @type {string[]} */
   const mapPaths = [];
 
@@ -110,17 +122,39 @@ const encapsulateObserver = (stateObj) => {
       ? 'arrayNonindexKeys'
     // ? 'sparseArrays'
       : 'array';
+
+    const li = keypath.lastIndexOf('.');
+    const arrayOrObjectPropertyName =
+      unescapeKeyPathComponent(keypath.slice(li + 1));
+    const parentPath = li === -1 ? '' : keypath.slice(0, li);
+
+    let schema, schemaIdx, mustBeOptional;
     if (typeof cyclicKeypath === 'string') {
       newValue = typesonPathToJSONPointer(cyclicKeypath);
       newType = type === 'array' ? 'arrayReference' : 'objectReference';
-      newType = canonicalToAvailableType(
+      ({
+        newType, schema, schemaIdx, mustBeOptional
+      } = canonicalTypeToAvailableTypeAndSchema(
         /** @type {import('../types.js').default} */ (types),
         /** @type {import('../formats.js').default} */ (formats),
-        format, state, newType, value
-      ); // Todo (low): Add accurate state for second argument
+        format, state, newType, value,
+        arrayOrObjectPropertyName,
+        schemaParents[parentPath],
+        stateObj
+      )); // Todo (low): Add accurate state for second argument
     } else {
+      // console.log(
+      //   // keypath
+      //   'schemaParents', keypath, parentPath, value,
+      //   arrayOrObjectPropertyName, schemaParents[parentPath]
+      // );
       try {
-        newType = canonicalToAvailableType(
+        // console.log(
+        //   'VVVV0', JSON.stringify(parentPath), schemaParents // , stateObj
+        // );
+        ({
+          newType, schema, schemaIdx, mustBeOptional
+        } = canonicalTypeToAvailableTypeAndSchema(
           /** @type {import('../types.js').default} */ (types),
           /** @type {import('../formats.js').default} */ (formats),
           format,
@@ -129,8 +163,14 @@ const encapsulateObserver = (stateObj) => {
            * @type {import('../types.js').AvailableType}
            */
           (type),
-          value
-        ); // Todo (low): Add state for second argument
+          value,
+          arrayOrObjectPropertyName,
+          schemaParents[parentPath],
+          stateObj
+        )); // Todo (low): Add state for second argument
+        // console.log('VVVV1', value, schema);
+        // console.log('VVVV2',
+        //   JSON.stringify(stateObj.schemaContent, null, 2));
       } catch (err) {
         console.log('err', type, err);
         stateObj.error = /** @type {Error} */ (err);
@@ -138,13 +178,8 @@ const encapsulateObserver = (stateObj) => {
       }
     }
 
-    const li = keypath.lastIndexOf('.');
-    const arrayOrObjectPropertyName =
-      unescapeKeyPathComponent(keypath.slice(li + 1));
-    const parentPath = li === -1 ? '' : keypath.slice(0, li);
-
     const hasChildren = [
-      'array', 'object', 'set', 'map',
+      'array', 'object', 'set', 'map', 'tuple', 'record', 'filelist',
       // 'sparseArrays',
       'arrayNonindexKeys'
     ].includes(newType);
@@ -157,6 +192,18 @@ const encapsulateObserver = (stateObj) => {
       mapPaths.push(keypath);
     }
 
+    if (schema) {
+      stateObj.specificSchema = schema;
+      if (!stateObj.specificSchemas) {
+        stateObj.specificSchemas = [];
+      }
+      stateObj.specificSchemas.push(schema);
+    }
+
+    // console.log('is', stateObj.schemaContent);
+    // console.log('but could set to', schema);
+    // console.log('arrayOrObjectPropertyName', arrayOrObjectPropertyName);
+
     if (!stateObj.rootUI) {
       // console.log('vvvv0', newType, newValue);
       stateObj.rootUI = types?.getUIForModeAndType({
@@ -166,16 +213,8 @@ const encapsulateObserver = (stateObj) => {
         bringIntoFocus: false,
         buildTypeChoices,
         format,
-        schemaContent,
-        schemaState: getPossibleSchemasForPathAndType,
-        /* schema:
-        &&
-        getPossibleSchemasForPathAndType({
-          keypath,
-          parentPath: '',
-          valueType: newType
-        }),
-        */
+        specificSchemaObject: schema,
+        schemaContent: schema ?? schemaContent,
         value: newValue,
         hasValue: true,
         // Not currently in use but may be convenient for a
@@ -187,6 +226,10 @@ const encapsulateObserver = (stateObj) => {
       *   {$addAndSetArrayElement: AddAndSetArrayElement}}
       */ (stateObj.rootUI);
 
+      if (schema) {
+        schemaParents[''] = [schema, schemaIdx];
+      }
+
       // 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)
@@ -201,6 +244,14 @@ const encapsulateObserver = (stateObj) => {
       return;
     }
 
+    if (schema) {
+      schemaParents[keypath] = [schema, schemaIdx];
+    }
+    // console.log(
+    //   'schemaParents', newValue, JSON.stringify(parentPath),
+    //   schema, schemaParents
+    // );
+
     // Todo (low): If could be async, use async encapsulate method
     // Todo (low): Handle `awaitingTypesonPromise` with place-holder
     // Todo (low): Handle `resolvingTypesonPromise` to replace place-holder
@@ -235,20 +286,13 @@ const encapsulateObserver = (stateObj) => {
       // console.log('vvvv', newType, '::', newValue, '::', newValue?.cause);
 
       const root = ui.$addAndSetArrayElement({
+        mustBeOptional,
         propName: arrayOrObjectPropertyName,
         type: newType,
         value: newValue,
         bringIntoFocus: false,
-        schemaContent,
-        schemaState: getPossibleSchemasForPathAndType
-        /* schema:
-          && getPossibleSchemasForPathAndType({
-            keypath,
-            parentPath,
-            arrayOrObjectPropertyName,
-            valueType: newType
-          })
-        */
+        schemaIdx,
+        schemaContent: schema ?? schemaContent
       });
 
       /* istanbul ignore if -- Guard for `null` return */
@@ -267,7 +311,9 @@ const encapsulateObserver = (stateObj) => {
           type: newType,
           // eslint-disable-next-line object-shorthand -- TS
           root: /** @type {HTMLDivElement} */ (root),
-          topRoot: /** @type {HTMLDivElement} */ (stateObj.rootUI)
+          topRoot: /** @type {HTMLDivElement} */ (stateObj.rootUI),
+          // We don't want focus when values auto-added
+          avoidReport: true
         });
       }
 
@@ -296,6 +342,7 @@ const encapsulateObserver = (stateObj) => {
 };
 
 /**
+ * Performs replacements on a list of types.
  * @param {string[]} originTypes
  * @param {[originType: string, replacementType: string][]} replacements
  * @returns {void}
@@ -307,21 +354,40 @@ 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
- * @param {import('../formats.js').StructuredCloneValue} v
- * @throws {Error}
- * @returns {import('../types.js').AvailableType}
+ * Converts a (typeson structured cloning) type to a type name relevant for the
+ *   format, state, value, and schema content, and may supply a child type if
+ *   there is a match. Also returns relevant schema for the type.
+ * @param {import('../types.js').default} types The Types object containing
+ *   type-specific data.
+ * @param {import('../formats.js').default} formats The Formats object
+ *   containing format-specific data.
+ * @param {import('../formats.js').AvailableFormat} format The current format.
+ * @param {string} state The current state.
+ * @param {import('../types.js').AvailableType} valType The value type being
+ *   checked.
+ * @param {import('../formats.js').StructuredCloneValue} v The value being
+ *   checked.
+ * @param {string} arrayOrObjectPropertyName
+ * @param {[import('zodex').SzType, number|undefined]|undefined} parentSchema
+ * @param {import('../types.js').StateObject} stateObj The schema content
+ *   being checked.
+ * @throws {Error} May throw if data found to be invalid.
+ * @returns {{
+ *   newType: import('../types.js').AvailableType,
+ *   schema?: import('zodex').SzType|undefined,
+ *   mustBeOptional?: boolean,
+ *   schemaIdx?: number
+ * }} Schema and type info.
  */
-const canonicalToAvailableType = (
-  types, formats, format, state, valType, v
+const canonicalTypeToAvailableTypeAndSchema = (
+  types, formats, format, state, valType, v, arrayOrObjectPropertyName,
+  parentSchema, stateObj
 ) => {
   const frmt = formats.getAvailableFormat(format);
-  const {getTypesForState, convertFromTypeson, testInvalid} = frmt;
-  const allowableTypes = getTypesForState.call(frmt, types, state);
+  const {getTypesAndSchemasForState, convertFromTypeson, testInvalid} = frmt;
+  const allowableTypes = getTypesAndSchemasForState.call(
+    frmt, types, state, stateObj.schemaContent
+  )?.types;
   /* istanbul ignore if -- Guard */
   if (!allowableTypes) {
     throw new Error('Unexpected undefined type for state');
@@ -331,41 +397,60 @@ const canonicalToAvailableType = (
    * @type {import('../types.js').AvailableType|undefined}
    */
   let ret;
-  // console.log('format, state, valType, v', format, state, valType, v);
 
   /**
-   * @param {string} newValType
-   * @throws {Error}
-   * @returns {never}
+   * Throws an error with information about the new value type.
+   * @param {string} newValType The new value type being recorded.
+   * @throws {Error} The invalid Error being thrown.
+   * @returns {never} Always throws instead of returning.
    */
   const isInvalid = (newValType) => {
-    console.log('newValType', newValType);
-    const err = new Error('Invalid');
-    /** @type {Error & {newValType: string}} */ (err).newValType = newValType;
+    const err = /** @type {Error & {newValType: string}} */ (
+      new Error('Invalid')
+    );
+    err.newValType = newValType;
     throw err;
   };
+  let schema;
   if (convertFromTypeson) {
-    const newValType = convertFromTypeson(valType);
+    let newValType;
+    let mustBeOptional;
+    let schemaIdx;
+    ({
+      type: newValType,
+      schema,
+      schemaIdx,
+      mustBeOptional
+    } = convertFromTypeson(
+      valType, types, v, arrayOrObjectPropertyName, parentSchema, stateObj
+    ));
     if (typeof newValType === 'string') {
       if (testInvalid && testInvalid(newValType, v)) {
         return isInvalid(newValType);
       }
       valType = newValType;
+      if (schema) {
+        return {
+          newType: valType,
+          schema,
+          schemaIdx,
+          mustBeOptional
+        };
+      }
     }
   }
 
-  // console.log('ret', ret);
   allowableTypes.some((allowableType) => {
-    // eslint-disable-next-line @stylistic/max-len -- Long
-    const typeObj = /** @type {import('../types.js').TypeObject & {childTypes: string[]}} */ (
-      types.getTypeObject(allowableType)
-    );
+    const typeObj =
+      /** @type {import('../types.js').TypeObject & {childTypes: string[]}} */ (
+        types.getTypeObject(allowableType)
+      );
     const {
       valueMatch, superType, childTypes
     } = typeObj;
     if (
       (superType && valueMatch &&
-        // Currently using for `true` and `false`
+        // Using, e.g., for `true` and `false` subtypes
         superType === valType && valueMatch(v)) ||
       (childTypes && childTypes.includes(valType))
     ) {
@@ -375,7 +460,7 @@ const canonicalToAvailableType = (
 
     return false;
   });
-  // console.log('ret2', ret);
+
   if (ret === undefined) {
     // We run this separately from the `childTypes` check above
     //    to ensure `childTypes` have priority regardless of position
@@ -387,29 +472,25 @@ const canonicalToAvailableType = (
       return false;
     });
     if (ret === undefined) {
+      console.log('AALLLowableTypes', state, allowableTypes, '::', valType);
       return isInvalid(valType);
     }
   }
-  return ret;
+  return {
+    newType: ret,
+    schema
+  };
 };
 
-/**
- * @callback FormatIterator
- * @param {import('../formats.js').StructuredCloneValue} records
- * @param {import('../types.js').StateObject} stateObj
- * @returns {Promise<Element>}
- */
-
 /** @type {import('../formats.js').Format} */
 const structuredCloning = {
   iterate (records, stateObj) {
-    // console.log('records', records);
     /* istanbul ignore if -- Just a guard */
     if (!stateObj.format) {
       stateObj.format = 'structuredCloning';
     }
     // Todo: Replace this with async typeson?
-    // eslint-disable-next-line promise/avoid-new
+    // eslint-disable-next-line promise/avoid-new -- Our own API for now
     return new Promise((resolve, reject) => {
       const structuredCloningFixed = structuredCloningThrowing.filter(
         (typeSpecSet) => {
@@ -441,13 +522,13 @@ const structuredCloning = {
       } else {
         resolve(/** @type {Required<import('../types.js').StateObject>} */ (
           stateObj
-        ).rootUI);
+        ));
       }
     });
   },
-  getTypesForState (types, state) {
+  getTypesAndSchemasForState (types, state) {
     if (state && types.getContextInfo('structuredCloning', state)) {
-      const typesForFormat = this.getTypesForState(types) ||
+      const typesForFormat = this.getTypesAndSchemasForState(types)?.types ||
         /* istanbul ignore next -- types should be an array */
         [];
       const contextInfo = types.getContextInfo('structuredCloning', state);
@@ -455,22 +536,39 @@ const structuredCloning = {
         const precedingIdx = typesForFormat.indexOf(after);
         typesForFormat.splice(precedingIdx + 1, 0, type);
       });
-      return typesForFormat;
+      return {
+        types: typesForFormat,
+        schemaObjects: []
+      };
     }
-    // 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
+    // Todo: Introduce new keys (to `Types.contexts`?) which could be used to
+    //         determine a delimited group of children (rather
+    //         than manual exception handling as we do here)
     if (state === 'errorsArray') {
-      return ['error', 'errors'];
+      return {
+        types: ['error', 'errors'],
+        schemaObjects: []
+      };
     }
     if (state === 'filelistArray') {
-      return ['file'];
+      return {
+        types: ['file'],
+        schemaObjects: []
+      };
     }
-    return this.types();
+    return {
+      types: this.types(),
+      schemaObjects: []
+    };
     /*
-    // Todo (low): These need to specify their own inner contexts
+    // These have their children determined internally to array
     if (['map', 'set'].includes(state)) {return;}
-    if ('int8array', 'uint8array', 'uint8clampedarray',
+    */
+
+    // These have their own internal numeric children instead
+    /*
+    if (
+      'int8array', 'uint8array', 'uint8clampedarray',
       'int16array', 'uint16array', 'int32array',
       'uint32array', 'float32array', 'float64array'
     ).includes(state)) {return;}
@@ -481,6 +579,8 @@ const structuredCloning = {
     replaceTypes(jsonTypes, [
       [
         'array',
+        // We can rename to this instead of `arrayNonindexKeys` if we change
+        //  typeson-registry name
         // 'sparseArrays',
         'arrayNonindexKeys'
       ]
@@ -493,6 +593,7 @@ const structuredCloning = {
       ...jsonTypes,
       'undef', // Explicit undefined only
       'bigint',
+      'bigintObject',
       'SpecialNumber', // '`NaN`, `Infinity`, `-Infinity`, `-0`
       'date',
       'regexp',

package/src/formats.js

@@ -1,6 +1,7 @@
 import indexedDBKey from './formats/indexedDBKey.js';
 import json from './formats/json.js';
 import structuredCloning from './formats/structuredCloning.js';
+import schema from './formats/schema.js';
 
 /**
  * An arbitrary Structured Clone, JSON, etc. value.
@@ -8,11 +9,15 @@ import structuredCloning from './formats/structuredCloning.js';
  */
 
 /**
- * @callback GetTypesForFormatAndState
+ * @callback GetTypesAndSchemasForFormatAndState
  * @param {import('./types.js').default} types
  * @param {AvailableFormat} format
  * @param {string} [state]
- * @returns {import('./types.js').AvailableType[]|undefined}
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaObject]
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaOriginal]
+ * @returns {TypesAndSchemaObjects|undefined}
  */
 
 /* schema:
@@ -25,25 +30,57 @@ export const getTypeForFormatStateAndValue = ({format, state, value}) => {
 */
 
 /**
- * @typedef {"indexedDBKey"|"json"|"structuredCloning"} AvailableFormat
+ * @typedef {"indexedDBKey"|"json"|"structuredCloning"|"schema"} AvailableFormat
  */
 
 /**
  * @typedef {{
- *   types: () => (import('./types.js').AvailableType)[],
- *   testInvalid?: (
+ *   types: (import('./types.js').AvailableType)[],
+ *   schemaObjects: import('./formats/schema.js').ZodexSchema[]
+ * }} TypesAndSchemaObjects
+ */
+
+/**
+ * Responsible for traversing over data (along with state information) to build
+ *   and return a relevant UI element.
+ * @callback FormatIterator
+ * @param {StructuredCloneValue} records
+ * @param {import('./types.js').StateObject} stateObj
+ * @returns {Promise<Required<import('./types.js').StateObject>>}
+ */
+
+/**
+ * @typedef {object} Format
+ * @property {() => (import('./types.js').AvailableType)[]} types Returns list
+ *   of types generally available to structured cloning. See
+ *   {@link getTypesAndSchemasForState} for context-dependent method.
+ * @property {FormatIterator} iterate Traverses over data to build and return
+ *   a relevant UI element.
+ * @property {(
+ *   types: import('./types.js').default,
+ *   state?: string,
+ *   schemaObject?: import('./formatAndTypeChoices.js').ZodexSchema|
+ *     undefined,
+ *   schemaOriginal?: import('./formatAndTypeChoices.js').ZodexSchema|
+ *     undefined
+ * ) => TypesAndSchemaObjects|undefined} getTypesAndSchemasForState Gets the
+ *   specific types (and schemas) relevant to a given state.
+ * @property {(
  *     newType: string, value: Date|Array<StructuredCloneValue>
- *   ) => boolean|undefined,
- *   convertFromTypeson?: (
- *     typesonType: import('./types.js').AvailableType
- *   ) => import('./types.js').AvailableType|undefined,
- *   iterate: import('./formats/structuredCloning.js').FormatIterator,
- *   getTypesForState: (
- *     types: import('./types.js').default,
- *     state?: string
- *   ) => undefined|
- *     (import('./types.js').AvailableType)[]
- * }} Format
+ *   ) => boolean|undefined} [testInvalid]
+ * @property {(
+ *   typesonType: import('./types.js').AvailableType,
+ *   types: import('./types.js').default,
+ *   v?: import('./formats.js').StructuredCloneValue,
+ *   arrayOrObjectPropertyName?: string,
+ *   parentSchema?: [import('zodex').SzType, number|undefined]|undefined,
+ *   stateObj?: import('./types.js').StateObject,
+ * ) => {
+ *   type: import('./types.js').AvailableType|undefined
+ *   schema?: import('zodex').SzType|undefined,
+ *   mustBeOptional?: boolean,
+ *   schemaIdx?: number
+ * }} [convertFromTypeson]
  */
 
 /**
@@ -80,11 +117,7 @@ class Formats {
     this.availableFormats = /** @type {{[key: string]: Format}} */ ({
       indexedDBKey,
       json,
-      // Todo (readme): these too? getTypesForState(types, state)
-      /* schema:
-      schemaAndArbitrary,
-      schemaOnly,
-      */
+      schema,
       structuredCloning
     });
   }
@@ -94,7 +127,7 @@ class Formats {
    * @param {AvailableFormat} format
    * @param {StructuredCloneValue} record
    * @param {import('./types.js').StateObject} stateObj
-   * @returns {Promise<Element>}
+   * @returns {Promise<Required<import('./types.js').StateObject>>}
    */
   async getControlsForFormatAndValue (types, format, record, stateObj) {
     return await this.availableFormats[format].
@@ -109,12 +142,14 @@ class Formats {
   }
 
   /**
-   * @type {GetTypesForFormatAndState}
+   * @type {GetTypesAndSchemasForFormatAndState}
    */
-  getTypesForFormatAndState (
-    types, format, state
+  getTypesAndSchemasForFormatAndState (
+    types, format, state, schemaObject, schemaOriginal
   ) {
-    return this.availableFormats[format].getTypesForState(types, state);
+    return this.availableFormats[format].getTypesAndSchemasForState(
+      types, state, schemaObject, schemaOriginal
+    );
   }
 
   /**

package/src/fundamentalTypes/BooleanObjectType.js

@@ -1,3 +1,4 @@
+import {toStringTag} from '../vendor-imports.js';
 import {$e, $$e} from '../utils/templateUtils.js';
 
 /**
@@ -6,9 +7,13 @@ import {$e, $$e} from '../utils/templateUtils.js';
 const BooleanObjectType = {
   option: ['BooleanObject'],
   stringRegex: /^Boolean\((.*)\)$/u,
+  valueMatch (x) {
+    return toStringTag(x) === 'Boolean' && typeof x === 'object';
+  },
   toValue (s) {
     return {
-      // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
+      // eslint-disable-next-line @stylistic/max-len -- Long
+      // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins -- Deliberate creation here
       value: new Boolean(s === 'true')
     };
   },
@@ -27,16 +32,23 @@ const BooleanObjectType = {
     const input = inputs[value.valueOf() ? 0 : 1];
     input.checked = true;
   },
-  viewUI ({value}) {
-    return ['i', {dataset: {type: 'BooleanObject'}}, [`Boolean(${value})`]];
+  viewUI ({value, specificSchemaObject}) {
+    return ['i', {
+      dataset: {type: 'BooleanObject'},
+      title: specificSchemaObject?.description ?? '(a Boolean Object)'
+    }, [specificSchemaObject ? `${value}` : `Boolean(${value})`]];
   },
   ct: 0,
   editUI ({
-    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
-    typeNamespace, value = new Boolean(true)
+    // eslint-disable-next-line @stylistic/max-len -- Long
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins -- Deliberate creation here
+    typeNamespace, specificSchemaObject, value = new Boolean(true)
   }) {
     this.ct++;
-    return ['div', {dataset: {type: 'BooleanObject'}}, [
+    return ['div', {
+      dataset: {type: 'BooleanObject'},
+      title: specificSchemaObject?.description ?? 'Boolean object'
+    }, [
       ['label', [
         'True',
         ['input', {