@es-joy/jsoe 0.16.0 → 0.17.0

package/src/types.js

@@ -12,18 +12,27 @@ import {$e, $$e} from './utils/templateUtils.js';
 import nullType from './fundamentalTypes/nullType.js';
 import trueType from './subTypes/trueType.js';
 import falseType from './subTypes/falseType.js';
+import nanType from './fundamentalTypes/nanType.js';
+import symbolType from './fundamentalTypes/symbolType.js';
 import blobHTMLType from './subTypes/blobHTMLType.js';
+import booleanType from './fundamentalTypes/booleanType.js';
 import numberType from './fundamentalTypes/numberType.js';
 import bigintType from './fundamentalTypes/bigintType.js';
+import bigintObjectType from './fundamentalTypes/bigintObjectType.js';
 import stringType from './fundamentalTypes/stringType.js';
 import arrayReferenceType from './fundamentalTypes/arrayReferenceType.js';
 import objectReferenceType from './fundamentalTypes/objectReferenceType.js';
 import arrayType from './fundamentalTypes/arrayType.js';
+import tupleType from './fundamentalTypes/tupleType.js';
 import objectType from './fundamentalTypes/objectType.js';
+import recordType from './fundamentalTypes/recordType.js';
 import dateType from './fundamentalTypes/dateType.js';
+import enumType from './fundamentalTypes/enumType.js';
 import setType from './fundamentalTypes/setType.js';
 import mapType from './fundamentalTypes/mapType.js';
+import literalType from './fundamentalTypes/literalType.js';
 import undefinedType from './fundamentalTypes/undefinedType.js';
+import voidType from './fundamentalTypes/voidType.js';
 import regexpType from './fundamentalTypes/regexpType.js';
 import BooleanObjectType from './fundamentalTypes/BooleanObjectType.js';
 import NumberObjectType from './fundamentalTypes/NumberObjectType.js';
@@ -43,6 +52,11 @@ import dompointType from './superTypes/dompointType.js';
 import dommatrixType from './superTypes/dommatrixType.js';
 import buffersourceType from './superTypes/buffersourceType.js';
 import noneditableType from './fundamentalTypes/noneditableType.js';
+import neverType from './fundamentalTypes/neverType.js';
+import promiseType from './fundamentalTypes/promiseType.js';
+import functionType from './fundamentalTypes/functionType.js';
+import catchType from './fundamentalTypes/catchType.js';
+import nativeEnumType from './fundamentalTypes/nativeEnumType.js';
 
 /**
  * Utility to retrieve the property value given a legend element.
@@ -113,9 +127,15 @@ export const getPropertyValueFromLegend = (legend) => {
  *   HTMLButtonElement}
  */
 
+/**
+ * @typedef {number} Integer
+ */
+
 /**
  * @callback GetOptionForType
  * @param {AvailableType} type
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaContent]
  * @returns {[string, {value: AvailableType, title?: string}]}
  */
 
@@ -123,18 +143,16 @@ export const getPropertyValueFromLegend = (legend) => {
  * @callback GetTypeOptionsForFormatAndState
  * @param {import('./formats.js').AvailableFormat} format
  * @param {string} [parserState]
- * @returns {[string, {value: AvailableType, title?: string}][]}
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaContent]
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaOriginal]
+ * @returns {{
+ *   typeOptions: [string, {value: AvailableType, title?: string}][],
+ *   schemaObjects: import('./formats/schema.js').ZodexSchema[]
+ * }}
  */
 
-/**
- * @typedef {(
-*   keypath: string,
-*   parentPath: string,
-*   arrayOrObjectPropertyName: string,
-*   valueType: string
-* ) => StateObject} GetPossibleSchemasForPathAndType
-*/
-
 /**
 * @typedef {{
 *   typeNamespace?: string,
@@ -145,8 +163,10 @@ export const getPropertyValueFromLegend = (legend) => {
 *   error?: Error,
 *   rootUI?: Element,
 *   schema?: string,
-*   schemaContent?: object,
-*   getPossibleSchemasForPathAndType?: GetPossibleSchemasForPathAndType,
+*   schemaParent?: import('./formats/schema.js').ZodexSchema,
+*   schemaContent?: import('./formats/schema.js').ZodexSchema,
+*   specificSchema?: import('./formats/schema.js').ZodexSchema,
+*   specificSchemas?: import('./formats/schema.js').ZodexSchema[],
 *   paths?: {[currentPath: string]: {
 *     referentPath: string,
 *     expectArrayReferent: boolean
@@ -166,11 +186,12 @@ export const getPropertyValueFromLegend = (legend) => {
  *   bringIntoFocus?: boolean|undefined,
  *   buildTypeChoices?: import('./typeChoices.js').BuildTypeChoices,
  *   format: import('./formats.js').AvailableFormat,
- *   schemaContent?: object
- *   schemaState?: GetPossibleSchemasForPathAndType,
+ *   schemaContent?: import('./formats/schema.js').ZodexSchema
+ *   specificSchemaObject?: import('./formats/schema.js').ZodexSchema
  *   value: StructuredCloneValue,
  *   hasValue: boolean,
  *   replaced?: StructuredCloneValue,
+ *   schemaFallingBack?: boolean
  * }) => HTMLElement} GetUIForModeAndType
  */
 /* eslint-enable jsdoc/valid-types -- readonly reserved */
@@ -193,7 +214,8 @@ export const getPropertyValueFromLegend = (legend) => {
  * @typedef {(cfg: {
  *   type: AvailableType,
  *   root: RootElement,
- *   topRoot?: RootElement
+ *   topRoot?: RootElement,
+ *   avoidReport?: boolean
  * }) => boolean} Validate
  */
 
@@ -218,7 +240,9 @@ export const getPropertyValueFromLegend = (legend) => {
  *     path: string
  *   ][],
  *   parent?: {[key: string]: any},
- *   parentPath?: string|number
+ *   parentPath?: string|number,
+ *   schemaObject?: import('./formatAndTypeChoices.js').ZodexSchema|undefined
+ *   schemaOriginal?: import('./formatAndTypeChoices.js').ZodexSchema|undefined
  * }) => [
 *   value: StructuredCloneValue,
 *   remnant: string,
@@ -256,6 +280,7 @@ export const getPropertyValueFromLegend = (legend) => {
  *   parent?: object,
  *   parentPath?: string|number,
  *   types?: Types
+ *   schemaObject?: import('./formatAndTypeChoices.js').ZodexSchema|undefined
  * }} RootInfo
  */
 
@@ -289,6 +314,10 @@ export const getPropertyValueFromLegend = (legend) => {
  *   it is a `Map`. Do not use in other types.
  * @property {boolean} [set] Private context variable. Whether or not
  *   it is a `Set`. Do not use in other types.
+ * @property {boolean} [record] Private context variable. Whether or not
+ *   it is a `Record`. Do not use in other types.
+ * @property {boolean} [tuple] Private context variable. Whether or not
+ *   it is a tuple type. Do not use in other types.
  * @property {boolean} [filelist] Private context variable. Whether or not
  *   it is a `FileList` type. Do not use in other types.
  * @property {boolean} [sparse] Private context variable. Whether or not
@@ -303,8 +332,10 @@ export const getPropertyValueFromLegend = (legend) => {
  *   present, use `stringRegex`
  * @property {RegExp} [stringRegexEnd] Used for string parsing. If not
  *   present, use `stringRegex`
- * @property {(v: StructuredCloneValue) => boolean} [valueMatch] Function to
- *   check whether this subtype matches
+ * @property {(
+ *   v: StructuredCloneValue
+ * ) => boolean} [valueMatch] Function to check whether this type or subtype
+ *   matches
  * @property {string} [superType] The greater fundamental type to which
  *   the type belongs
  * @property {ToValue} [toValue] Converts from string to value. May use
@@ -325,7 +356,12 @@ export const getPropertyValueFromLegend = (legend) => {
  *   topRoot?: HTMLDivElement,
  *   resultType?: "keys"|"values"|"both",
  *   format: import('./formats.js').AvailableFormat,
+ *   specificSchemaObject?: import('./formats/schema.js').ZodexSchema,
  *   types: Types
+ *   bringIntoFocus?: boolean|undefined,
+ *   buildTypeChoices?: import('./typeChoices.js').BuildTypeChoices,
+ *   schemaContent?: import('./formats/schema.js').ZodexSchema
+ *   replaced?: any
  * }) => JamilihArray} viewUI
  * @property {(info: {
  *   value?: StructuredCloneValue,
@@ -336,9 +372,12 @@ export const getPropertyValueFromLegend = (legend) => {
  *   types: Types,
  *   resultType?: "keys"|"values"|"both",
  *   type?: AvailableType,
- *   arrayState?: string,
+ *   forcedState?: string,
  *   buildTypeChoices?: import('./typeChoices.js').BuildTypeChoices,
  *   topRoot?: HTMLDivElement
+ *   schemaContent?: import('./formats/schema.js').ZodexSchema,
+ *   specificSchemaObject?: import('./formats/schema.js').ZodexSchema,
+ *   schemaFallingBack?: boolean
  * }) => JamilihArray} editUI
  * @property {(info: {root: HTMLDivElement}) =>
  *   HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement|
@@ -368,7 +407,8 @@ export const getPropertyValueFromLegend = (legend) => {
  */
 
 /**
- * @typedef {"null"|"true"|"false"|"number"|"bigint"|"string"|"arrayReference"|
+ * @typedef {"null"|"true"|"false"|"number"|"bigint"|"bigintObject"|
+ *   "string"|"arrayReference"|
  *   "objectReference"|"array"|"object"|"date"|"userObject"|"undef"|
  *   "SpecialRealNumber"|"SpecialNumber"|"regexp"|"BooleanObject"|
  *   "NumberObject"|"StringObject"|"map"|"set"|"file"|"filelist"|"blobHTML"|
@@ -376,8 +416,12 @@ export const getPropertyValueFromLegend = (legend) => {
  *   "int8array"|"uint8array"|"uint8clampedarray"|"int16array"|"uint16array"|
  *   "int32array"|"uint32array"|"float32array"|"float64array"|"ValidDate"|
  *   "arrayNonindexKeys"|"error"|"errors"|"blob"|"domexception"|"domrect"|
- *   "dompoint"|"dommatrix"|"resurrectable"} AvailableType
+ *   "dompoint"|"dommatrix"|"resurrectable"|"boolean"|"nan"|"tuple"|
+ *   "record"|"void"|"enum"|"literal"|"symbol"|"never"|"promise"|
+ *   "function"|"catch"|"nativeEnum"
+ * } AvailableType
  */
+// Todo: When done with function/promise/symbol, move off here
 
 /**
  * @typedef {TypeObject & {
@@ -406,17 +450,24 @@ class Types {
       null: nullType,
       true: trueType,
       false: falseType,
+      nan: nanType, // Schema type
+      symbol: symbolType, // Non-cloning type
+      boolean: booleanType, // Schema type
       number: numberType,
       bigint: bigintType,
+      bigintObject: bigintObjectType,
       string: stringType,
       arrayReference: arrayReferenceType,
       objectReference: objectReferenceType,
       array: arrayType,
+      tuple: tupleType, // Schema type
       // Note: We don't do for BooleanObject/NumberObject/StringObject, date,
       //   regexp, as added properties on them are not being cloned (in Chrome
       //   at least)
       object: objectType,
+      record: recordType, // Schema type
       date: dateType,
+      enum: enumType,
 
       // This type is only for throwing upon cloning errors:
       // 'checkDataCloneException'
@@ -424,6 +475,7 @@ class Types {
       //   passed in:
       userObject: ['User objects'],
       undef: undefinedType,
+      void: voidType,
       SpecialRealNumber: SpecialRealNumberSuperType,
       SpecialNumber: SpecialNumberSuperType,
 
@@ -435,6 +487,8 @@ class Types {
       NumberObject: NumberObjectType,
       StringObject: StringObjectType,
 
+      literal: literalType,
+
       map: mapType,
       set: setType,
 
@@ -449,6 +503,11 @@ class Types {
       dommatrix: dommatrixType,
 
       resurrectable: noneditableType,
+      never: neverType,
+      promise: promiseType,
+      function: functionType,
+      catch: catchType,
+      nativeEnum: nativeEnumType,
 
       buffersource: buffersourceType,
       dataview: {
@@ -575,9 +634,9 @@ class Types {
   async getControlsForFormatAndValue (
     format, record, stateObj
   ) {
-    return await this.formats.getControlsForFormatAndValue(
+    return (await this.formats.getControlsForFormatAndValue(
       this, format, record, stateObj
-    );
+    )).rootUI;
   }
 
   /**
@@ -647,7 +706,7 @@ class Types {
   }
 
   /** @type {GetOptionForType} */
-  getOptionForType (type) {
+  getOptionForType (type, schemaContent = undefined) {
     const availableType = /** @type {TypeObject} */ (
       this.availableTypes[type]
     );
@@ -655,46 +714,64 @@ class Types {
     const optInfo = [
       ...availableType.option
     ];
-    optInfo[1] = {value: type, ...(optInfo[1])};
+
+    if (schemaContent && schemaContent.description) {
+      optInfo[0] = `${optInfo[0]} (${schemaContent.description})`;
+    }
+
+    optInfo[1] = {
+      value: type,
+      ...(optInfo[1])
+    };
     return /** @type {[string, {value: AvailableType, title?: string}]} */ (
       optInfo
     );
   }
 
   /** @type {GetTypeOptionsForFormatAndState} */
-  getTypeOptionsForFormatAndState (format, parserState) {
-    const typesForFormatAndState = this.formats.getTypesForFormatAndState(
-      this, format, parserState
-    );
+  getTypeOptionsForFormatAndState (
+    format, parserState, schemaContent, schemaOriginal
+  ) {
+    const typesForFormatAndState =
+      this.formats.getTypesAndSchemasForFormatAndState(
+        this, format, parserState, schemaContent, schemaOriginal
+      );
     if (!typesForFormatAndState) {
       throw new Error('Unexpected type for format and state');
     }
 
-    return typesForFormatAndState.map((type) => {
-      return this.getOptionForType(type);
-    });
+    return {
+      typeOptions: typesForFormatAndState.types.map((type, idx) => {
+        return this.getOptionForType(
+          type, typesForFormatAndState.schemaObjects[idx]
+        );
+      }),
+      schemaObjects: typesForFormatAndState.schemaObjects
+    };
   }
 
   /** @type {GetUIForModeAndType} */
   getUIForModeAndType ({
     readonly, resultType, typeNamespace, type, topRoot, bringIntoFocus,
-    buildTypeChoices, format, schemaContent, schemaState, value, hasValue,
-    replaced
+    buildTypeChoices, format, schemaContent, value, hasValue,
+    replaced, specificSchemaObject, schemaFallingBack
   }) {
     const typeObj = /** @type {TypeObject} */ (this.availableTypes[type]);
     const arg = hasValue
       ? {
         typeNamespace, type, buildTypeChoices,
-        format, schemaContent, schemaState,
+        format, schemaContent,
         resultType, topRoot, bringIntoFocus, value,
         replaced,
+        specificSchemaObject, schemaFallingBack,
         types: this
       }
       : {
         typeNamespace, type, buildTypeChoices,
-        format, schemaContent, schemaState,
+        format, schemaContent,
         resultType, topRoot, bringIntoFocus,
         replaced,
+        specificSchemaObject, schemaFallingBack,
         types: this
       };
     const root = /** @type {HTMLDivElement} */ (jml(
@@ -734,7 +811,7 @@ class Types {
   }
 
   /** @type {Validate} */
-  validate ({type, root, topRoot}) {
+  validate ({type, root, topRoot, avoidReport}) {
     const typeObj = /** @type {TypeObject} */ (this.availableTypes[type]);
     // Todo (low): We limit for now to input boxes which have `validate`
     if (typeObj.validate) {
@@ -746,7 +823,13 @@ class Types {
           /* istanbul ignore next -- Should always have a message */
           : message || 'Invalid'
       );
-      formControl.reportValidity();
+
+      // We don't want a focus as `reportValidity` does in at least
+      //  some cases, but blur() would cause user to
+      //   leave input (used during input handler)
+      if (!avoidReport) {
+        formControl.reportValidity();
+      }
       return valid;
     }
     return true;
@@ -772,11 +855,11 @@ class Types {
   /** @type {GetValueForString} */
   getValueForString (s, {
     format, state, endMatchTypeObjs = [], firstRun = true,
-    rootHolder = [], parent, parentPath
+    rootHolder = [], parent, parentPath, schemaObject, schemaOriginal
   }) {
-    const allowedTypes = this.formats.getTypesForFormatAndState(
-      this, format, state
-    );
+    const allowedTypes = this.formats.getTypesAndSchemasForFormatAndState(
+      this, format, state, schemaObject, schemaOriginal
+    )?.types;
     if (!allowedTypes) {
       throw new Error('Could not get types for format and state');
     }
@@ -866,7 +949,8 @@ class Types {
             remnant,
             rootHolder,
             parent,
-            parentPath
+            parentPath,
+            schemaObject
           }
         );
       /* istanbul ignore next -- Good regexes should prevent */
@@ -982,9 +1066,9 @@ Types.validValuesSet = ({form, typeNamespace, keySelectClass}) => {
  * @param {string} str
  * @returns {string}
  */
-function escapeRegex (str) {
+export function escapeRegex (str) {
   return String(str).
-    replaceAll(/[.\\+*?^[\]$(){}=!<>|:-]/gu, '\\$&');
+    replaceAll(/[.\\+*?^[\]$(){}=!<>|:-]/gu, String.raw`\$&`);
 }
 
 export default Types;

package/src/utils/FileList.js

@@ -9,7 +9,7 @@ class FileList {
    * Set private properties and length.
    */
   constructor () {
-    // eslint-disable-next-line prefer-rest-params
+    // eslint-disable-next-line prefer-rest-params -- Keep API
     this._files = arguments[0];
     this.length = this._files.length;
   }
@@ -20,12 +20,12 @@ class FileList {
   item (index) {
     return this._files[index];
   }
-  /* eslint-disable class-methods-use-this */
+  /* eslint-disable class-methods-use-this -- API */
   /**
    * @returns {"FileList"}
    */
   get [Symbol.toStringTag] () {
-    /* eslint-enable class-methods-use-this */
+    /* eslint-enable class-methods-use-this -- API */
     return 'FileList';
   }
 }

package/src/utils/dialogs.js

@@ -1,4 +1,4 @@
-/* eslint-disable promise/avoid-new */
+/* eslint-disable promise/avoid-new -- Our own API */
 import {jml, nbsp, body} from '../vendor-imports.js';
 import {$e} from './templateUtils.js';
 
@@ -45,9 +45,7 @@ const dialogs = {
         atts.$on.close = /** @type {import('jamilih').EventHandler} */ (close);
       }
     }
-    const dialog = /** @type {HTMLDialogElement} */ (
-      jml('dialog', atts, children, body)
-    );
+    const dialog = jml('dialog', atts, children, body);
     dialog.showModal();
     if (remove) {
       dialog.addEventListener('close', () => {
@@ -134,7 +132,7 @@ const dialogs = {
     const {submitClass = 'submit'} = message;
     const {message: outputMessage} = message;
     return new Promise((resolve /* , _reject */) => {
-      const dialog = /** @type {HTMLDialogElement} */ (jml('dialog', [
+      const dialog = jml('dialog', [
         /** @type {string|import('jamilih').JamilihArray} */ (outputMessage),
         ['br'], ['br'],
         ['div', {class: submitClass}, [
@@ -143,7 +141,7 @@ const dialogs = {
             resolve();
           }}}, [this.localeStrings.ok]]
         ]]
-      ], body));
+      ], body);
       dialog.showModal();
     });
   },
@@ -160,7 +158,7 @@ const dialogs = {
       resolve,
       reject
     ) => {
-      const dialog = /** @type {HTMLDialogElement} */ (jml('dialog', atts, [
+      const dialog = jml('dialog', atts, [
         message,
         ['br'], ['br'],
         ['div', {class: submitClass}, [
@@ -174,7 +172,7 @@ const dialogs = {
             reject(new Error('cancelled'));
           }}}, [this.localeStrings.cancel]]
         ]]
-      ], body));
+      ], body);
       dialog.showModal();
     });
   }

package/src/utils/objects.js

@@ -0,0 +1,22 @@
+/**
+ * @typedef {any} ArbitraryObject
+ */
+/**
+ * @typedef {{[key: string]: string|NestedObject}} NestedObject
+ */
+
+/**
+ * @param {ArbitraryObject} obj
+ * @returns {ArbitraryObject}
+ */
+export function copyObject (obj) {
+  const newObj = Array.isArray(obj)
+    ? /** @type {Array<ArbitraryObject> & {[key: string]: ArbitraryObject}} */ (
+      []
+    )
+    : /** @type {NestedObject} */ ({});
+  for (const [prop, val] of Object.entries(obj)) {
+    newObj[prop] = val && typeof val === 'object' ? copyObject(val) : val;
+  }
+  return newObj;
+}

package/src/vendor-imports.js

@@ -3,6 +3,6 @@ export {jml, body, nbsp, $} from 'jamilih';
 
 export {
   getJSONType, Typeson, unescapeKeyPathComponent, structuredCloningThrowing,
-  resurrectable, toStringTag
+  resurrectable, toStringTag, hasConstructorOf
 } from 'typeson-registry';
 // } from '../node_modules/typeson-registry/dist/index.js';

package/tsconfig.json

@@ -10,9 +10,9 @@
     "declarationMap": true,
     "emitDeclarationOnly": true,
     "strict": true,
-    "target": "es6",
+    "target": "es2020",
     "outDir": "dist"
   },
   "include": ["src/**/*.js", "typings/sceditor.d.ts"],
-  "exclude": ["node_modules", "src/deepEqual.js", "src/formats/schemaOnly.js", "src/formats/schemaAndArbitrary.js", "./src/index.ts", "./dist/**/*.js"]
+  "exclude": ["node_modules", "src/deepEqual.js", "src/formats/schema.js", "./src/index.ts", "./dist/**/*.js"]
 }

package/vendor/jamilih/dist/jml-es.js

@@ -766,15 +766,27 @@ function getMatchingPlugin(opts, pluginName) {
   });
 }
 
+/* eslint-disable jsdoc/valid-types -- pratt parser bug  */
+/**
+ * @template T
+ * @typedef {T[keyof T]} ValueOf
+ */
+/* eslint-enable jsdoc/valid-types -- pratt parser bug  */
+
+/* eslint-disable jsdoc/valid-types -- pratt parser bug  */
 /**
  * Creates an XHTML or HTML element (XHTML is preferred, but only in browsers
  * that support); any element after element can be omitted, and any subsequent
  * type or types added afterwards.
- * @param {JamilihArray} args
- * @returns {JamilihReturn} The newly created (and possibly already appended)
+ * @template {JamilihArray} T
+ * @param {T} args
+ * @returns {T extends [keyof HTMLElementTagNameMap, any?, any?, any?]
+ *   ? HTMLElementTagNameMap[T[0]] : JamilihReturn}
+ * The newly created (and possibly already appended)
  *   element or array of elements
  */
 const jml = function jml(...args) {
+  /* eslint-enable jsdoc/valid-types -- pratt parser bug  */
   if (!win) {
     throw new Error('No window object');
   }
@@ -1353,9 +1365,11 @@ const jml = function jml(...args) {
       case 'null':
         // null always indicates a place-holder (only needed for last argument if want array returned)
         if (i === argc - 1) {
-          return nodes.length <= 1 ? nodes[0]
-          // eslint-disable-next-line unicorn/no-array-callback-reference
-          : nodes.reduce(_fragReducer, doc.createDocumentFragment()); // nodes;
+          // Casting needing unless changing `jml()` signature with overloads
+          return (/** @type {ArbitraryValue} */nodes.length <= 1 ? nodes[0]
+            // eslint-disable-next-line unicorn/no-array-callback-reference
+            : nodes.reduce(_fragReducer, doc.createDocumentFragment())
+          ); // nodes;
         }
 
         throw new TypeError(`\`null\` values not allowed except as final Jamilih argument; index ${i} on args: ${JSON.stringify(args)}`);
@@ -1567,7 +1581,10 @@ const jml = function jml(...args) {
   if (isRoot && opts.$map && /** @type {MapWithRoot} */opts.$map.root) {
     setMap(true);
   }
-  return ret;
+
+  // Casting needing unless changing `jml()` signature with overloads
+  return (/** @type {ArbitraryValue} */ret
+  );
 };
 
 /**