@es-joy/jsoe 0.28.2 → 0.30.0

package/src/search/unions/unionFamilySearchType.js

@@ -0,0 +1,168 @@
+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',
+            // The "(any)" placeholder's `value: ''` below is exactly what
+            // native `required` treats as "nothing selected", so choosing
+            // any real branch already satisfies it - no custom validity
+            // code needed. A union/xor/discriminatedUnion has no other
+            // possible constraint (unlike `mapSearchType.js`'s key/value or
+            // `objectSearchType.js`'s properties), so this alone is "no
+            // absent values" for the whole widget, not just one facet of it.
+            required: true,
+            $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/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"]
+  "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"]
 }