@es-joy/jsoe 0.30.0 → 0.32.0

package/src/search/subTypes/blobHTMLSearchType.js

@@ -1,13 +1,105 @@
 import {
-  buildPathLabel, findOwnControl, isExemptedByAncestorHasProperty
+  buildPathLabel, findOwnControl, isExemptedByAncestorHasProperty, extractLeafOfKind
 } from '../searchUtils.js';
 import {makeBlobHTMLLeaf} from '../queryTreeBuilders.js';
-import {getQueryViaElement} from '../searchElementUtils.js';
+import {getQueryViaElement, applyQueryViaElement} from '../searchElementUtils.js';
+import regexpType from '../../fundamentalTypes/regexpType.js';
 
 /**
  * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
  */
 
+/**
+ * Live syntax-checks a blobHTML Value against its currently-chosen Mode -
+ * a CSS selector and an XPath expression are each tried against a detached,
+ * inert target (a fragment for the selector, the live `document` itself,
+ * required by `Element.prototype.evaluate`'s own contract, for the XPath -
+ * neither actually has to *match* anything, only parse without throwing),
+ * and a regex is tried via the same `new RegExp(value, flags)` constructor
+ * `readLiteralRegexQuery` relies on elsewhere - a "Full text search" value
+ * is a plain phrase with no format to violate, so it always passes.
+ * @param {string} mode
+ * @param {string} value
+ * @param {string} flags
+ * @returns {string}
+ */
+function computeBlobHTMLValueMessage (mode, value, flags) {
+  if (!value) {
+    return '';
+  }
+  try {
+    switch (mode) {
+    case 'cssSelector':
+      document.createDocumentFragment().querySelector(value);
+      break;
+    case 'xpath':
+      document.evaluate(value, document, null, XPathResult.ANY_TYPE, null);
+      break;
+    case 'rawHTMLRegex':
+      // eslint-disable-next-line no-new -- Testing
+      new RegExp(value, flags);
+      break;
+    default:
+      break;
+    }
+    return '';
+  } catch {
+    switch (mode) {
+    case 'cssSelector':
+      return 'Enter a valid CSS selector.';
+    case 'xpath':
+      return 'Enter a valid XPath expression.';
+    case 'rawHTMLRegex':
+      return 'Enter a valid regular expression.';
+    default:
+      return '';
+    }
+  }
+}
+
+/**
+ * Re-runs `computeBlobHTMLValueMessage` against whichever of the input/
+ * textarea pair the current Mode makes active, clearing the other one's
+ * custom validity (a hidden-but-still-`required` control would otherwise
+ * keep blocking the form, the same reasoning `buildUI`'s own doc gives for
+ * toggling `required` alongside `hidden`) - call on every `input` on either
+ * value control, `change` on the Mode `<select>`, and `change` on the Flags
+ * multi-select (changing flags can itself flip a regex between valid and
+ * invalid, e.g. the `u`/`v` flags' stricter escape rules).
+ * @param {Element|null} container
+ * @returns {void}
+ */
+function syncBlobHTMLValueValidity (container) {
+  if (!container) {
+    return;
+  }
+  const mode = /** @type {HTMLSelectElement|undefined} */ (
+    findOwnControl(container, 'select.jsoeSearchBlobHTMLMode')
+  )?.value ?? '';
+  const input = /** @type {HTMLInputElement|undefined} */ (
+    findOwnControl(container, 'input.jsoeSearchBlobHTMLValue')
+  );
+  const textarea = /** @type {HTMLTextAreaElement|undefined} */ (
+    findOwnControl(container, 'textarea.jsoeSearchBlobHTMLValue')
+  );
+  const flagsSelect = /** @type {HTMLSelectElement|undefined} */ (
+    findOwnControl(container, 'select.jsoeSearchBlobHTMLFlags')
+  );
+  const flags = mode === 'rawHTMLRegex'
+    ? [...(flagsSelect?.selectedOptions ?? [])].map((opt) => opt.value).join('')
+    : '';
+  const active = mode === 'fullText' ? textarea : input;
+  if (input && input !== active) {
+    input.setCustomValidity('');
+  }
+  if (textarea && textarea !== active) {
+    textarea.setCustomValidity('');
+  }
+  if (active) {
+    active.setCustomValidity(computeBlobHTMLValueMessage(mode, active.value, flags));
+  }
+}
+
 /**
  * Blob HTML: XPath, CSS selectors, full text search, regex search of raw
  * HTML (README) - a mode `<select>` plus one value control, the same
@@ -23,7 +115,8 @@ import {getQueryViaElement} from '../searchElementUtils.js';
  * of the pair is ever `required` (toggled alongside `hidden` by the mode
  * `change` handler): a `required` field that's merely hidden, rather than
  * also un-required, still blocks the form's validity even though the user
- * has no way to see or fill it.
+ * has no way to see or fill it. "CSS selector" is listed ahead of "XPath"
+ * (and is the default mode) as the option most jsoe users will recognize.
  *
  * The `change` handler also checks `isExemptedByAncestorHasProperty` before
  * (re-)asserting `required` on the now-visible control: nested as an
@@ -35,6 +128,15 @@ import {getQueryViaElement} from '../searchElementUtils.js';
  * check, that synthetic event would immediately reassert `required` on
  * whichever control the current mode makes visible, undoing the exemption
  * `setDescendantsRequired` had just granted.
+ *
+ * "Regex search of raw HTML" gets its own Flags multi-select (the same
+ * `regexpType.js` `allowedFlags` list `stringSearchType.js`'s literal/regex
+ * control passes as `buildLiteralRegexControls`'s `flagOptions`), shown only
+ * while that mode is chosen, folded into the `blobHTML` leaf's own
+ * `$options` (mirroring `QueryRegexLeaf`'s field of the same name) - and,
+ * via `syncBlobHTMLValueValidity`, included when syntax-checking the Value
+ * itself, since the chosen flags can affect whether a given pattern is
+ * actually valid.
  * @type {SearchTypeObject}
  */
 const blobHTMLSearchType = {
@@ -60,11 +162,56 @@ const blobHTMLSearchType = {
           if (!value || !mode) {
             return undefined;
           }
+          const flags = mode === 'rawHTMLRegex'
+            ? [...(/** @type {HTMLSelectElement|undefined} */ (
+              findOwnControl(this, 'select.jsoeSearchBlobHTMLFlags')
+            )?.selectedOptions ?? [])].map((opt) => opt.value).join('')
+            : '';
           return makeBlobHTMLLeaf(
             searchPath,
             /** @type {import('../queryTree.js').QueryBlobHTMLLeaf['mode']} */ (mode),
-            value
+            value,
+            flags || undefined
+          );
+        },
+        /**
+         * @this {HTMLElement}
+         * @param {import('../queryTree.js').QueryNode|undefined} queryNode
+         * @returns {void}
+         */
+        applyQuery (queryNode) {
+          const {matched} = extractLeafOfKind(queryNode, 'blobHTML');
+          const modeEl = /** @type {HTMLSelectElement|undefined} */ (
+            findOwnControl(this, 'select.jsoeSearchBlobHTMLMode')
+          );
+          if (!modeEl) {
+            return;
+          }
+          const mode = matched?.mode ?? 'cssSelector';
+          modeEl.value = mode;
+          // Dispatching `change` runs the Mode `<select>`'s own handler
+          // first, which shows/hides the correct Value control and the
+          // Flags label before either is touched below.
+          modeEl.dispatchEvent(new Event('change'));
+          const activeEl = /** @type {HTMLInputElement|HTMLTextAreaElement|undefined} */ (
+            findOwnControl(
+              this, `${mode === 'fullText' ? 'textarea' : 'input'}.jsoeSearchBlobHTMLValue`
+            )
+          );
+          if (activeEl) {
+            activeEl.value = matched?.value ?? '';
+            activeEl.dispatchEvent(new Event('input'));
+          }
+          const flagsEl = /** @type {HTMLSelectElement|undefined} */ (
+            findOwnControl(this, 'select.jsoeSearchBlobHTMLFlags')
           );
+          if (flagsEl) {
+            const flagChars = new Set((matched?.$options ?? '').split(''));
+            [...flagsEl.options].forEach((opt) => {
+              opt.selected = flagChars.has(opt.value);
+            });
+            flagsEl.dispatchEvent(new Event('change'));
+          }
         }
       }
     }, [
@@ -83,8 +230,11 @@ const blobHTMLSearchType = {
               const textarea = /** @type {HTMLTextAreaElement|null|undefined} */ (
                 container?.querySelector('textarea.jsoeSearchBlobHTMLValue')
               );
-              const isFullText = /** @type {HTMLSelectElement} */ (this).value ===
-                'fullText';
+              const flagsLabel = /** @type {HTMLElement|null|undefined} */ (
+                container?.querySelector('.jsoeSearchBlobHTMLFlagsLabel')
+              );
+              const mode = /** @type {HTMLSelectElement} */ (this).value;
+              const isFullText = mode === 'fullText';
               const exempted = container !== null &&
                 isExemptedByAncestorHasProperty(container);
               if (input) {
@@ -95,11 +245,15 @@ const blobHTMLSearchType = {
                 textarea.hidden = !isFullText;
                 textarea.required = isFullText && !exempted;
               }
+              if (flagsLabel) {
+                flagsLabel.hidden = mode !== 'rawHTMLRegex';
+              }
+              syncBlobHTMLValueValidity(container);
             }
           }
         }, [
-          ['option', {value: 'xpath'}, ['XPath']],
           ['option', {value: 'cssSelector'}, ['CSS selector']],
+          ['option', {value: 'xpath'}, ['XPath']],
           ['option', {value: 'fullText'}, ['Full text search']],
           ['option', {value: 'rawHTMLRegex'}, ['Regex search of raw HTML']]
         ]]
@@ -108,15 +262,37 @@ const blobHTMLSearchType = {
         'Value: ',
         ['input', {
           type: 'text', name: `${name}-value`, class: 'jsoeSearchBlobHTMLValue',
-          required: true
+          required: true,
+          $on: {
+            input () {
+              syncBlobHTMLValueValidity(this.closest('jsoe-search-blob-html'));
+            }
+          }
         }],
         ['textarea', {
-          name: `${name}-value`, class: 'jsoeSearchBlobHTMLValue', hidden: true
+          name: `${name}-value`, class: 'jsoeSearchBlobHTMLValue', hidden: true,
+          $on: {
+            input () {
+              syncBlobHTMLValueValidity(this.closest('jsoe-search-blob-html'));
+            }
+          }
         }]
+      ]],
+      ['label', {class: 'jsoeSearchBlobHTMLFlagsLabel', hidden: true}, [
+        'Flags: ',
+        ['select', {
+          name: `${name}-flags`, multiple: true, class: 'jsoeSearchBlobHTMLFlags',
+          $on: {
+            change () {
+              syncBlobHTMLValueValidity(this.closest('jsoe-search-blob-html'));
+            }
+          }
+        }, regexpType.allowedFlags.map((flag) => ['option', {value: flag}, [flag]])]
       ]]
     ]];
   },
-  getQuery: getQueryViaElement
+  getQuery: getQueryViaElement,
+  applyQuery: applyQueryViaElement
 };
 
 export default blobHTMLSearchType;

package/src/search/subTypes/recordSearchType.js

@@ -1,9 +1,13 @@
 import {
-  buildPathLabel, buildCheckbox, readCheckbox, buildOptInFieldset,
-  readOptInChecked, wireOptInFieldset, buildAtLeastOneSentinel, syncAtLeastOneCheck
+  buildPathLabel, buildCheckbox, readCheckbox, applyCheckbox, buildOptInFieldset,
+  readOptInChecked, wireOptInFieldset, applyOptIn, buildAtLeastOneSentinel,
+  syncAtLeastOneCheck, extractLeafOfKind
 } from '../searchUtils.js';
 import {makeMapRecordJointLeaf} from '../queryTreeBuilders.js';
-import {findSearchElement, getQueryViaElement, hasGetQuery} from '../searchElementUtils.js';
+import {
+  findSearchElement, getQueryViaElement, hasGetQuery,
+  applyQueryViaElement, hasApplyQuery
+} from '../searchElementUtils.js';
 import {buildSearchWidget} from '../searchDispatch.js';
 
 /**
@@ -85,6 +89,27 @@ const recordSearchType = {
           }
           const joint = readCheckbox(this);
           return makeMapRecordJointLeaf(searchPath, joint, keyQuery, valueQuery);
+        },
+        /**
+         * @this {HTMLElement}
+         * @param {import('../queryTree.js').QueryNode|undefined} queryNode
+         * @returns {void}
+         */
+        applyQuery (queryNode) {
+          const searchPath = this.dataset.searchPath ?? '';
+          const {matched: jointLeaf} = extractLeafOfKind(queryNode, 'mapRecordJoint');
+          applyCheckbox(this, Boolean(jointLeaf?.joint));
+          applyOptIn(this, jointLeaf?.keyQuery !== undefined, 'key');
+          applyOptIn(this, jointLeaf?.valueQuery !== undefined, 'value');
+          const keyEl = findSearchElement(this, `${searchPath}/*key`);
+          if (keyEl && hasApplyQuery(keyEl)) {
+            keyEl.applyQuery(jointLeaf?.keyQuery);
+          }
+          const valueEl = findSearchElement(this, `${searchPath}/*value`);
+          if (valueEl && hasApplyQuery(valueEl)) {
+            valueEl.applyQuery(jointLeaf?.valueQuery);
+          }
+          syncKeyValueValidity(this);
         }
       }
     }, [
@@ -99,7 +124,8 @@ const recordSearchType = {
       buildAtLeastOneSentinel()
     ]];
   },
-  getQuery: getQueryViaElement
+  getQuery: getQueryViaElement,
+  applyQuery: applyQueryViaElement
 };
 
 export default recordSearchType;

package/src/search/subTypes/tupleSearchType.js

@@ -1,10 +1,13 @@
 import {
-  buildPathLabel, buildLengthSizeControls, readLengthSizeQuery,
-  buildOptInFieldset, readOptInChecked, wireOptInFieldset,
-  buildAtLeastOneSentinel, syncAtLeastOneCheck
+  buildPathLabel, buildLengthSizeControls, readLengthSizeQuery, applyLengthSizeQuery,
+  buildOptInFieldset, readOptInChecked, wireOptInFieldset, applyOptIn,
+  buildAtLeastOneSentinel, syncAtLeastOneCheck, extractLeafOfKind, extractClauseForPath
 } from '../searchUtils.js';
 import {combineAnd} from '../queryTreeBuilders.js';
-import {findSearchElement, getQueryViaElement, hasGetQuery} from '../searchElementUtils.js';
+import {
+  findSearchElement, getQueryViaElement, hasGetQuery,
+  applyQueryViaElement, hasApplyQuery
+} from '../searchElementUtils.js';
 import {buildSearchWidget} from '../searchDispatch.js';
 
 /**
@@ -142,11 +145,46 @@ const tupleSearchType = {
             ? restEl.getQuery()
             : undefined;
           return combineAnd([...itemLeaves, lengthLeaf, restLeaf]);
+        },
+        /**
+         * @this {HTMLElement}
+         * @param {import('../queryTree.js').QueryNode|undefined} queryNode
+         * @returns {void}
+         */
+        applyQuery (queryNode) {
+          const searchPath = this.dataset.searchPath ?? '';
+          const itemCount = Number(this.dataset.itemCount ?? '0');
+          const hasRest = this.dataset.hasRest === 'true';
+          let remaining = queryNode;
+          Array.from({length: itemCount}, (_v, idx) => idx).forEach((idx) => {
+            const childPath = `${searchPath}/${idx}`;
+            const {matched, rest} = extractClauseForPath(remaining, childPath);
+            remaining = rest;
+            applyOptIn(this, matched !== undefined, String(idx));
+            const itemEl = findSearchElement(this, childPath);
+            if (itemEl && hasApplyQuery(itemEl)) {
+              itemEl.applyQuery(matched);
+            }
+          });
+          if (hasRest) {
+            const {matched: lengthLeaf, rest: afterLength} = extractLeafOfKind(remaining, 'lengthSize');
+            applyLengthSizeQuery(this, lengthLeaf);
+            remaining = afterLength;
+            const restPath = `${searchPath}/*`;
+            const {matched: restMatched} = extractClauseForPath(remaining, restPath);
+            applyOptIn(this, restMatched !== undefined, 'rest');
+            const restEl = findSearchElement(this, restPath);
+            if (restEl && hasApplyQuery(restEl)) {
+              restEl.applyQuery(restMatched);
+            }
+          }
+          syncTupleValidity(this);
         }
       }
     }, children];
   },
-  getQuery: getQueryViaElement
+  getQuery: getQueryViaElement,
+  applyQuery: applyQueryViaElement
 };
 
 export default tupleSearchType;

package/src/search/superTypes/SpecialRealNumberSearchType.js

@@ -1,6 +1,8 @@
-import {buildPathLabel, buildMultiSelect, readMultiSelect} from '../searchUtils.js';
+import {
+  buildPathLabel, buildMultiSelect, readMultiSelect, applyMultiSelect, extractLeafOfKind
+} from '../searchUtils.js';
 import {makeMultiSelectLeaf} from '../queryTreeBuilders.js';
-import {getQueryViaElement} from '../searchElementUtils.js';
+import {getQueryViaElement, applyQueryViaElement} from '../searchElementUtils.js';
 
 /**
  * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
@@ -27,6 +29,15 @@ const SpecialRealNumberSearchType = {
           return selected.length
             ? makeMultiSelectLeaf(this.dataset.searchPath ?? '', {$in: selected})
             : undefined;
+        },
+        /**
+         * @this {HTMLElement}
+         * @param {import('../queryTree.js').QueryNode|undefined} queryNode
+         * @returns {void}
+         */
+        applyQuery (queryNode) {
+          const {matched} = extractLeafOfKind(queryNode, 'multiSelect');
+          applyMultiSelect(this, matched?.$in ?? []);
         }
       }
     }, [
@@ -36,7 +47,8 @@ const SpecialRealNumberSearchType = {
       })
     ]];
   },
-  getQuery: getQueryViaElement
+  getQuery: getQueryViaElement,
+  applyQuery: applyQueryViaElement
 };
 
 export default SpecialRealNumberSearchType;

package/src/search/superTypes/buffersourceSearchType.js

@@ -1,8 +1,9 @@
 import {
-  buildPathLabel, buildRangeInputsPair, readRangeInputsPair, syncRangeValidity
+  buildPathLabel, buildRangeInputsPair, readRangeInputsPair, syncRangeValidity,
+  applyRangeQuery, extractLeafOfKind
 } from '../searchUtils.js';
 import {makeRangeLeaf} from '../queryTreeBuilders.js';
-import {getQueryViaElement} from '../searchElementUtils.js';
+import {getQueryViaElement, applyQueryViaElement} from '../searchElementUtils.js';
 
 /**
  * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
@@ -40,6 +41,15 @@ const buffersourceSearchType = {
             ...(gte === '' ? {} : {$gte: Number(gte)}),
             ...(lte === '' ? {} : {$lte: Number(lte)})
           });
+        },
+        /**
+         * @this {HTMLElement}
+         * @param {import('../queryTree.js').QueryNode|undefined} queryNode
+         * @returns {void}
+         */
+        applyQuery (queryNode) {
+          const {matched} = extractLeafOfKind(queryNode, 'range');
+          applyRangeQuery(this, matched);
         }
       }
     }, [
@@ -47,7 +57,8 @@ const buffersourceSearchType = {
       ...buildRangeInputsPair({name, min: 0})
     ]];
   },
-  getQuery: getQueryViaElement
+  getQuery: getQueryViaElement,
+  applyQuery: applyQueryViaElement
 };
 
 export default buffersourceSearchType;

package/src/search/unions/unionFamilySearchType.js

@@ -1,7 +1,10 @@
 import {jml} from '../../vendor-imports.js';
-import {buildPathLabel, findOwnControl} from '../searchUtils.js';
+import {buildPathLabel, findOwnControl, extractLeafOfKind} from '../searchUtils.js';
 import {makeTypeOfLeaf, combineAnd} from '../queryTreeBuilders.js';
-import {findSearchElement, getQueryViaElement, hasGetQuery} from '../searchElementUtils.js';
+import {
+  findSearchElement, getQueryViaElement, hasGetQuery,
+  applyQueryViaElement, hasApplyQuery
+} from '../searchElementUtils.js';
 import {getSearchSchemaType, buildSearchWidget} from '../searchDispatch.js';
 
 /**
@@ -101,6 +104,44 @@ export function makeUnionFamilySearchType ({tagName, discriminated}) {
               ? branchEl.getQuery()
               : undefined;
             return combineAnd([typeOfLeaf, branchQuery]);
+          },
+          /**
+           * Drives the existing "Has type" `<select>`'s own `change`
+           * listener (defined below, per-instance and so already safe to
+           * close over `branches`) rather than reimplementing branch-DOM
+           * construction here - `$define` methods are installed once on the
+           * tag's shared prototype the first time it's defined (this
+           * function's own doc), so `applyQuery` can't close over
+           * `branches` itself, but dispatching a real `change` event lets
+           * the per-instance listener that *can* do the rebuild for us.
+           * @this {HTMLElement}
+           * @param {import('../queryTree.js').QueryNode|undefined} queryNode
+           * @returns {void}
+           */
+          applyQuery (queryNode) {
+            const select = /** @type {HTMLSelectElement|undefined} */ (
+              findOwnControl(this, 'select.jsoeSearchTypeOf')
+            );
+            if (!select) {
+              return;
+            }
+            const {matched, rest} = extractLeafOfKind(queryNode, 'typeOf');
+            const optionMatch = matched && [...select.options].find((opt) => (
+              opt.dataset.searchType === matched.searchType &&
+              (opt.dataset.discriminatorValue === undefined
+                ? matched.discriminatorValue === undefined
+                : JSON.parse(opt.dataset.discriminatorValue) === matched.discriminatorValue)
+            ));
+            select.value = optionMatch ? optionMatch.value : '';
+            select.dispatchEvent(new Event('change'));
+            if (!optionMatch) {
+              return;
+            }
+            const searchPath = this.dataset.searchPath ?? '';
+            const branchEl = findSearchElement(this, searchPath);
+            if (branchEl && hasApplyQuery(branchEl)) {
+              branchEl.applyQuery(rest);
+            }
           }
         }
       }, [
@@ -163,6 +204,7 @@ export function makeUnionFamilySearchType ({tagName, discriminated}) {
         ['div', {class: 'searchUnionBranch'}]
       ]];
     },
-    getQuery: getQueryViaElement
+    getQuery: getQueryViaElement,
+    applyQuery: applyQueryViaElement
   };
 }

package/src/utils/json6Stringify.js

@@ -0,0 +1,50 @@
+const identifierKeyRegex = (/^[A-Za-z_$][\w$]*$/u);
+
+/**
+ * A minimal JSON6-*subset* stringifier: unquotes object keys that are valid
+ *   identifiers (for the "simplified" display the JSON6 mode is meant to
+ *   give), while always fully quoting string *values* via `JSON.stringify`.
+ *
+ *   `JSON6.stringify` (from the `json-6` package) was tried first but has a
+ *   real bug: it runs the same identifier-unquoting logic it uses for keys
+ *   on string *values* too, so e.g. the value `"hello"` is emitted as the
+ *   bare word `hello` — not valid JS/JSON6 syntax as a value, and not even
+ *   re-parseable by the package's own `JSON6.parse`. Hand-rolling this
+ *   avoids depending on that broken path while still using `JSON6.parse`
+ *   (which is correct) to read the text back after editing.
+ * @param {unknown} value
+ * @param {string} indent
+ * @param {string} curIndent
+ * @returns {string}
+ */
+export const stringifyJSON6 = (value, indent, curIndent) => {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value);
+  }
+  const nextIndent = curIndent + indent;
+  if (Array.isArray(value)) {
+    if (!value.length) {
+      return '[]';
+    }
+    const items = value.map((item) => {
+      return `${nextIndent}${stringifyJSON6(item, indent, nextIndent)}`;
+    });
+    return `[\n${items.join(',\n')}\n${curIndent}]`;
+  }
+  const keys = Object.keys(value);
+  if (!keys.length) {
+    return '{}';
+  }
+  const items = keys.map((key) => {
+    const keyText = identifierKeyRegex.test(key)
+      ? key
+      : JSON.stringify(key);
+    return `${nextIndent}${keyText}: ${
+      stringifyJSON6(
+        /** @type {{[key: string]: unknown}} */ (value)[key], indent,
+        nextIndent
+      )
+    }`;
+  });
+  return `{\n${items.join(',\n')}\n${curIndent}}`;
+};

package/src/utils/rawTypesonEditor.js

@@ -6,6 +6,7 @@ import {
 } from '../vendor-imports.js';
 import {structuredCloningJsoe} from '../formats/structuredCloning.js';
 import {parseValue} from '../formats/schema.js';
+import {stringifyJSON6} from './json6Stringify.js';
 
 /**
  * @returns {import('typeson').Typeson}
@@ -14,8 +15,6 @@ const buildTypeson = () => {
   return new Typeson().register(structuredCloningJsoe);
 };
 
-const identifierKeyRegex = (/^[A-Za-z_$][\w$]*$/u);
-
 /** @type {ReadonlySet<string>} */
 const typedArrayTagNames = new Set([
   'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array',
@@ -45,55 +44,6 @@ const bytesToBase64 = (bytes) => {
   return btoa(binary);
 };
 
-/**
- * A minimal JSON6-*subset* stringifier: unquotes object keys that are valid
- *   identifiers (for the "simplified" display the JSON6 mode is meant to
- *   give), while always fully quoting string *values* via `JSON.stringify`.
- *
- *   `JSON6.stringify` (from the `json-6` package) was tried first but has a
- *   real bug: it runs the same identifier-unquoting logic it uses for keys
- *   on string *values* too, so e.g. the value `"hello"` is emitted as the
- *   bare word `hello` — not valid JS/JSON6 syntax as a value, and not even
- *   re-parseable by the package's own `JSON6.parse`. Hand-rolling this
- *   avoids depending on that broken path while still using `JSON6.parse`
- *   (which is correct) to read the text back after editing.
- * @param {unknown} value
- * @param {string} indent
- * @param {string} curIndent
- * @returns {string}
- */
-const stringifyJSON6 = (value, indent, curIndent) => {
-  if (value === null || typeof value !== 'object') {
-    return JSON.stringify(value);
-  }
-  const nextIndent = curIndent + indent;
-  if (Array.isArray(value)) {
-    if (!value.length) {
-      return '[]';
-    }
-    const items = value.map((item) => {
-      return `${nextIndent}${stringifyJSON6(item, indent, nextIndent)}`;
-    });
-    return `[\n${items.join(',\n')}\n${curIndent}]`;
-  }
-  const keys = Object.keys(value);
-  if (!keys.length) {
-    return '{}';
-  }
-  const items = keys.map((key) => {
-    const keyText = identifierKeyRegex.test(key)
-      ? key
-      : JSON.stringify(key);
-    return `${nextIndent}${keyText}: ${
-      stringifyJSON6(
-        /** @type {{[key: string]: unknown}} */ (value)[key], indent,
-        nextIndent
-      )
-    }`;
-  });
-  return `{\n${items.join(',\n')}\n${curIndent}}`;
-};
-
 /**
  * Builds the Typeson/JSON6 text shown by both the view-mode "View raw"
  *   button and, seeded, the edit-mode "Edit raw" button's Typeson mode.

package/vendor/zod/classic/schemas.d.ts

@@ -788,7 +788,9 @@ export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
-    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+    properties<Shape extends {
+        [k in keyof T as T[k] extends Function ? never : k]?: core.$ZodType<unknown, T[k]>;
+    }>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
 }
 export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;

package/vendor/zod/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 6,
-    patch: 4,
+    patch: 5,
 };