@es-joy/jsoe 0.31.0 → 0.32.0

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.