@es-joy/jsoe 0.28.1 → 0.29.0

package/src/search/superTypes/buffersourceSearchType.js

@@ -0,0 +1,47 @@
+import {buildPathLabel, buildRangeInputsPair, readRangeInputsPair} from '../searchUtils.js';
+import {makeRangeLeaf} from '../queryTreeBuilders.js';
+import {getQueryViaElement} from '../searchElementUtils.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * BufferSource: OR Range/Is Not Range (README) - a byte-length range, per
+ * the build order's own note that `buffersource` (like `function`) is
+ * "fuzzy" enough in the README to ship as a minimal, honest stub rather
+ * than over-build past what the spec defines. `buffersource` is one of
+ * jsoe's "checked" types (`{type: 'any', checks: [{name: 'buffersource'}]}`)
+ * with no schema-level byte-length bounds to read `min`/`max` HTML
+ * attributes from, unlike `array`'s `minLength`/`maxLength`.
+ * @type {SearchTypeObject}
+ */
+const buffersourceSearchType = {
+  buildUI ({schemaObject, path, typeNamespace}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-buffersource`;
+    return ['jsoe-search-buffersource', {
+      dataset: {searchPath: path, searchKind: 'buffersource'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          const {gte, lte} = readRangeInputsPair(this);
+          if (gte === '' && lte === '') {
+            return undefined;
+          }
+          return makeRangeLeaf(this.dataset.searchPath ?? '', 'buffersource', {
+            ...(gte === '' ? {} : {$gte: Number(gte)}),
+            ...(lte === '' ? {} : {$lte: Number(lte)})
+          });
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [`${label} (byte length)`]],
+      ...buildRangeInputsPair({name, min: 0})
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default buffersourceSearchType;

package/src/search/superTypes/dommatrixSearchType.js

@@ -0,0 +1,24 @@
+import {makeDomShapeSearchType} from '../searchElementUtils.js';
+
+/**
+ * DOMMatrix: numeric search ranges for children; "Is/Is not Readonly";
+ * "Is/Is not 3d" (README) - see `searchElementUtils.js`'s
+ * `makeDomShapeSearchType` for the shared implementation. `dimensionKeys`
+ * covers both the 2D (`a`-`f`) and 3D (`m11`-`m44`) property sets at once;
+ * see that factory's doc for why.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const dommatrixSearchType = makeDomShapeSearchType({
+  tagName: 'jsoe-search-dommatrix',
+  dimensionKeys: [
+    'a', 'b', 'c', 'd', 'e', 'f',
+    'm11', 'm12', 'm13', 'm14',
+    'm21', 'm22', 'm23', 'm24',
+    'm31', 'm32', 'm33', 'm34',
+    'm41', 'm42', 'm43', 'm44'
+  ],
+  includeReadonly: true,
+  includeDimensionCheck: true
+});
+
+export default dommatrixSearchType;

package/src/search/superTypes/dompointSearchType.js

@@ -0,0 +1,15 @@
+import {makeDomShapeSearchType} from '../searchElementUtils.js';
+
+/**
+ * DOMPoint: numeric search ranges for children; "Is/Is not Readonly"
+ * (README) - see `searchElementUtils.js`'s `makeDomShapeSearchType` for the
+ * shared implementation.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const dompointSearchType = makeDomShapeSearchType({
+  tagName: 'jsoe-search-dompoint',
+  dimensionKeys: ['x', 'y', 'z', 'w'],
+  includeReadonly: true
+});
+
+export default dompointSearchType;

package/src/search/superTypes/domrectSearchType.js

@@ -0,0 +1,15 @@
+import {makeDomShapeSearchType} from '../searchElementUtils.js';
+
+/**
+ * DOMRect: numeric search ranges for children; "Is/Is not Readonly"
+ * (README) - see `searchElementUtils.js`'s `makeDomShapeSearchType` for the
+ * shared implementation.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const domrectSearchType = makeDomShapeSearchType({
+  tagName: 'jsoe-search-domrect',
+  dimensionKeys: ['x', 'y', 'width', 'height'],
+  includeReadonly: true
+});
+
+export default domrectSearchType;

package/src/search/superTypes/errorsSpecialSearchType.js

@@ -0,0 +1,15 @@
+import {makeErrorFamilySearchType} from '../searchElementUtils.js';
+
+/**
+ * Special Errors (RangeError/TypeError/SyntaxError/AggregateError/etc.):
+ * Literal/Regex search of child string properties, numeric of number
+ * children (README, same bullet as plain `Error`) - see
+ * `searchElementUtils.js`'s `makeErrorFamilySearchType` for the shared
+ * implementation.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const errorsSpecialSearchType = makeErrorFamilySearchType({
+  tagName: 'jsoe-search-errors-special'
+});
+
+export default errorsSpecialSearchType;

package/src/search/unions/discriminatedUnionSearchType.js

@@ -0,0 +1,16 @@
+import {makeUnionFamilySearchType} from './unionFamilySearchType.js';
+
+/**
+ * Discriminated Union: "Has type <type pull-down>", using the
+ * discriminator of discriminated union (README) - the type pull-down's
+ * options are labelled by each branch's discriminator value (e.g.
+ * `'circle'`/`'square'`) rather than a generic type name, and the resulting
+ * `typeOf` leaf carries that value too (`queryTree.js`). See
+ * `unionFamilySearchType.js` for the shared implementation.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const discriminatedUnionSearchType = makeUnionFamilySearchType({
+  tagName: 'jsoe-search-discriminated-union', discriminated: true
+});
+
+export default discriminatedUnionSearchType;

package/src/search/unions/unionFamilySearchType.js

@@ -0,0 +1,160 @@
+import {jml} from '../../vendor-imports.js';
+import {buildPathLabel, findOwnControl} from '../searchUtils.js';
+import {makeTypeOfLeaf, combineAnd} from '../queryTreeBuilders.js';
+import {findSearchElement, getQueryViaElement, hasGetQuery} from '../searchElementUtils.js';
+import {getSearchSchemaType, buildSearchWidget} from '../searchDispatch.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * @param {HTMLElement} el
+ * @returns {el is HTMLSelectElement}
+ */
+function isSelectElement (el) {
+  return el.nodeName.toLowerCase() === 'select';
+}
+
+/**
+ * @typedef {{
+ *   discriminator?: string,
+ *   options: import('../../formats/schema.js').ZodexSchema[]
+ * }} UnionLikeSchemaObject
+ */
+
+/**
+ * Shared implementation behind `unionSearchType.js`, `xorSearchType.js` and
+ * `discriminatedUnionSearchType.js`: all three share the exact same
+ * "has type <type pull-down>" shape (README) - `SzUnion`/`SzXor` carry
+ * only `options`, `SzDiscriminatedUnion` additionally carries a
+ * `discriminator` field name (`zodexy`'s schema types), so `discriminated`
+ * is the only behavioral difference. Picking a branch also renders that
+ * branch's own recursively-built search widget below the pull-down (not
+ * just "is type X" - "X matches Y" too), matching every other composite
+ * built so far.
+ *
+ * Each `<option>` carries its branch's search-dispatch key and (for a
+ * discriminated union) its discriminator value as `data-*` attributes,
+ * since `getQuery()` runs as a `$define` mixin method installed once on the
+ * tag's shared prototype - the branch metadata needs to be read back off
+ * the currently-selected `<option>` itself at query time, not closed over
+ * from this factory's one-time call.
+ * @param {{tagName: string, discriminated: boolean}} cfg
+ * @returns {SearchTypeObject}
+ */
+export function makeUnionFamilySearchType ({tagName, discriminated}) {
+  return {
+    buildUI ({schemaObject, path, typeNamespace, topRoot, types, originalJSON}) {
+      const label = buildPathLabel(schemaObject, path);
+      const name = `${typeNamespace}-${tagName}`;
+      const unionLikeSchemaObject = /** @type {UnionLikeSchemaObject} */ (
+        /** @type {unknown} */ (schemaObject)
+      );
+      const {options} = unionLikeSchemaObject;
+      const discriminator = discriminated
+        ? unionLikeSchemaObject.discriminator
+        : undefined;
+
+      const branches = options.map((option, idx) => {
+        const searchType = getSearchSchemaType(option);
+        let discriminatorValue;
+        if (discriminator) {
+          const discSchema = /** @type {{properties?: {[key: string]: any}}} */ (
+            option
+          ).properties?.[discriminator];
+          if (discSchema?.type === 'literal') {
+            [discriminatorValue] = discSchema.values;
+          }
+        }
+        const optLabel = discriminatorValue === undefined
+          ? (buildPathLabel(option, `${path}/${idx}`) || searchType)
+          : String(discriminatorValue);
+        return {idx, option, searchType, discriminatorValue, optLabel};
+      });
+
+      return [tagName, {
+        dataset: {searchPath: path, searchKind: tagName},
+        title: label,
+        $define: {
+          /** @this {HTMLElement} */
+          getQuery () {
+            const searchPath = this.dataset.searchPath ?? '';
+            const select = /** @type {HTMLSelectElement|undefined} */ (
+              findOwnControl(this, 'select.jsoeSearchTypeOf')
+            );
+            if (!select || select.value === '') {
+              return undefined;
+            }
+            const selectedOption = select.selectedOptions[0];
+            const searchType = selectedOption?.dataset.searchType ?? '';
+            const rawDiscriminatorValue = selectedOption?.dataset.discriminatorValue;
+            const typeOfLeaf = makeTypeOfLeaf(
+              searchPath,
+              searchType,
+              rawDiscriminatorValue === undefined
+                ? undefined
+                : JSON.parse(rawDiscriminatorValue)
+            );
+            const branchEl = findSearchElement(this, searchPath);
+            const branchQuery = branchEl && hasGetQuery(branchEl)
+              ? branchEl.getQuery()
+              : undefined;
+            return combineAnd([typeOfLeaf, branchQuery]);
+          }
+        }
+      }, [
+        ['span', {class: 'searchLabel'}, [label]],
+        ['label', [
+          'Has type: ',
+          ['select', {
+            name,
+            class: 'jsoeSearchTypeOf',
+            $on: {
+              change () {
+                if (!isSelectElement(this)) {
+                  return;
+                }
+                const container = this.closest(tagName)?.querySelector(
+                  '.searchUnionBranch'
+                );
+                if (!container) {
+                  return;
+                }
+                container.textContent = '';
+                if (this.value === '') {
+                  return;
+                }
+                const branch = branches[Number(this.value)];
+                const branchArr = buildSearchWidget({
+                  schemaObject: branch.option,
+                  path,
+                  typeNamespace,
+                  topRoot,
+                  types,
+                  originalJSON
+                });
+                container.append(/** @type {HTMLElement} */ (jml(...branchArr)));
+              }
+            }
+          }, [
+            ['option', {value: ''}, ['(any)']],
+            ...branches.map(({idx, searchType, discriminatorValue, optLabel}) => (
+              ['option', {
+                value: String(idx),
+                dataset: {
+                  searchType,
+                  ...(discriminatorValue === undefined
+                    ? {}
+                    : {discriminatorValue: JSON.stringify(discriminatorValue)})
+                }
+              }, [optLabel]]
+            ))
+          ]]
+        ]],
+        ['div', {class: 'searchUnionBranch'}]
+      ]];
+    },
+    getQuery: getQueryViaElement
+  };
+}

package/src/search/unions/unionSearchType.js

@@ -0,0 +1,12 @@
+import {makeUnionFamilySearchType} from './unionFamilySearchType.js';
+
+/**
+ * Union: "Has type <type pull-down>" (README) - see
+ * `unionFamilySearchType.js` for the shared implementation.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const unionSearchType = makeUnionFamilySearchType({
+  tagName: 'jsoe-search-union', discriminated: false
+});
+
+export default unionSearchType;

package/src/search/unions/xorSearchType.js

@@ -0,0 +1,16 @@
+import {makeUnionFamilySearchType} from './unionFamilySearchType.js';
+
+/**
+ * Xor (exclusive union): "Has type <type pull-down>" (README) - see
+ * `unionFamilySearchType.js` for the shared implementation.
+ * `getXorBranchMatchInfo` (`src/formats/schema.js`) is deliberately not
+ * reused here, same as the search plan already rules out for xor generally
+ * (§4): it requires a concrete value to test branch match, which the search
+ * side never has.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const xorSearchType = makeUnionFamilySearchType({
+  tagName: 'jsoe-search-xor', discriminated: false
+});
+
+export default xorSearchType;

package/src/superTypes/buffersourceType.js

@@ -72,26 +72,26 @@ const getMinMaxForTypedArray = (typedArray) => {
 };
 
 /**
- * @typedef {"Int8Array"|"Uint8Array"|"Uint8ClampedArray"|
- *   "Int16Array"|"Uint16Array"|"Int32Array"|"Uint32Array"|
- *   "Float32Array"|"Float64Array"|"BigInt64Array"|
- *   "BigUint64Array"} TypedArray
+ * @typedef {"Int8Array"|"Uint8Array"|"Uint8ClampedArray"
+ *   |"Int16Array"|"Uint16Array"|"Int32Array"|"Uint32Array"
+ *   |"Float32Array"|"Float64Array"|"BigInt64Array"
+ *   |"BigUint64Array"} TypedArray
  */
 
 /**
- * @typedef {Int8Array|Uint8Array|Uint8ClampedArray|
- *   Int16Array|Uint16Array|Int32Array|Uint32Array|
- *   Float32Array|Float64Array|BigInt64Array|
- *   BigUint64Array} TypedArrayInstance
+ * @typedef {Int8Array|Uint8Array|Uint8ClampedArray
+ *   |Int16Array|Uint16Array|Int32Array|Uint32Array
+ *   |Float32Array|Float64Array|BigInt64Array
+ *   |BigUint64Array} TypedArrayInstance
  */
 
 /**
  * @param {TypedArray} prop
- * @returns {Int8ArrayConstructor|Uint8ArrayConstructor|
- *   Uint8ClampedArrayConstructor|Int16ArrayConstructor|
- *   Uint16ArrayConstructor|Int32ArrayConstructor|Uint32ArrayConstructor|
- *   Float32ArrayConstructor|Float64ArrayConstructor|
- *   BigInt64ArrayConstructor|BigUint64ArrayConstructor}
+ * @returns {Int8ArrayConstructor|Uint8ArrayConstructor
+ *   |Uint8ClampedArrayConstructor|Int16ArrayConstructor
+ *   |Uint16ArrayConstructor|Int32ArrayConstructor|Uint32ArrayConstructor
+ *   |Float32ArrayConstructor|Float64ArrayConstructor
+ *   |BigInt64ArrayConstructor|BigUint64ArrayConstructor}
  */
 const getTypedArray = (prop) => {
   switch (prop) {
@@ -164,7 +164,6 @@ const buffersourceType = {
       dataViewByteOffset,
       dataViewByteLength, length
     } = o;
-    // @ts-expect-error Ok
     const buffer = new ArrayBuffer(byteLength, {maxByteLength});
 
     let typedArray, TypedArray;
@@ -471,7 +470,6 @@ const buffersourceType = {
             );
 
             const buffer = new ArrayBuffer(
-              // @ts-expect-error New ArrayBuffer argument
               byteLengthVal, maxByteLength ? {maxByteLength} : undefined
             );
 

package/src/typeChoices.js

@@ -29,7 +29,7 @@ import deepEqual from 'fast-deep-equal/es6/index.js';
  */
 /**
  * @callback Validate
- * @param {{avoidReport?: boolean}} cfg
+ * @param {{avoidReport?: boolean}} [cfg]
  * @returns {boolean}
  */
 /**
@@ -127,7 +127,7 @@ import deepEqual from 'fast-deep-equal/es6/index.js';
 /**
  * @callback SetValue
  * @param {import('./formats.js').StructuredCloneValue} value
- * @param {import('./types.js').StateObject} stateObj
+ * @param {import('./types.js').StateObject} [stateObj]
  * @returns {Promise<void>}
  */
 

package/src/types.js

@@ -641,8 +641,8 @@ class Types {
   /**
    * @param {import('./formats.js').AvailableFormat} format
    * @param {StructuredCloneValue} record
-   * @param {StateObject} stateObj
-   * @returns {Promise<Element>}
+   * @param {StateObject} [stateObj]
+   * @returns {Promise<HTMLElement>}
    */
   async getControlsForFormatAndValue (
     format, record, stateObj

package/src/utils/rawTypesonEditor.js

@@ -613,11 +613,22 @@ export async function openRawEditorDialog ({
     ['div', {class: editorClass}]
   ];
 
+  // `dialogs.js`'s default `remove` behavior detaches the `<dialog>` from
+  //   the document on close, but never tears down the `EditorView` mounted
+  //   into it; left as-is, every "Edit raw"/"View raw" use leaks a live
+  //   `EditorView` (and its internal `ResizeObserver`/DOM observers) bound
+  //   to an already-detached subtree. Destroy it alongside the dialog.
+  const close = () => {
+    view.destroy();
+  };
+
   const dialog = readonly
     // @ts-expect-error TS bug
-    ? dialogs.makeCancelDialog({children})
+    ? dialogs.makeCancelDialog({children, close})
     : dialogs.makeSubmitDialog({
       submitText: 'Save',
+      // @ts-expect-error TS bug
+      close,
       async submit ({dialog: dlg}) {
         const text = view.state.doc.toString();
         showError(dlg, '');
@@ -652,7 +663,6 @@ export async function openRawEditorDialog ({
         }
         dlg.close();
       },
-      // @ts-expect-error TS bug
       children
     });
 

package/tsconfig-prod.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.js", "typings/sceditor.d.ts", "typings/json-6.d.ts"]
+}

package/tsconfig.json

@@ -1,20 +1,15 @@
 {
   "compilerOptions": {
-    "lib": ["es2023", "DOM"],
-    "skipLibCheck": true,
+    "lib": ["ESNext", "dom"],
     "moduleResolution": "nodenext",
     "module": "NodeNext",
     "allowJs": true,
     "checkJs": true,
-    "noEmit": false,
-    "declaration": true,
-    "declarationMap": true,
-    "emitDeclarationOnly": true,
     "strict": true,
+    "noEmit": true,
     "target": "es2020",
-    "rootDir": "src",
-    "outDir": "dist"
+    "types": ["node"]
   },
-  "include": ["src/**/*.js", "typings/sceditor.d.ts", "typings/json-6.d.ts"],
-  "exclude": ["node_modules", "src/deepEqual.js", "src/formats/schema.js", "./src/index.ts", "./dist/**/*.js"]
+  "include": ["**/*.ts", "**/*.js", "../typings/CypressPlugins.d.ts", "../typings/sceditor.d.ts", "../typings/json-6.d.ts"],
+  "exclude": ["rollup.config.js", ".agents", "vendor", "coverage", "instrumented", "node_modules", "dist", "src/deepEqual.js"]
 }