@es-joy/jsoe 0.24.3 → 0.25.0

package/dist/fundamentalTypes/nativeEnumType.d.ts

@@ -1,6 +0,0 @@
-export default nativeEnumType;
-/**
- * @type {import('../types.js').TypeObject}
- */
-declare const nativeEnumType: import("../types.js").TypeObject;
-//# sourceMappingURL=nativeEnumType.d.ts.map

package/dist/fundamentalTypes/nativeEnumType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nativeEnumType.d.ts","sourceRoot":"","sources":["../../src/fundamentalTypes/nativeEnumType.js"],"names":[],"mappings":";AAIA;;GAEG;AACH,8BAFU,OAAO,aAAa,EAAE,UAAU,CAqJxC"}

package/src/fundamentalTypes/catchType.js

@@ -1,140 +0,0 @@
-import {$e} from '../utils/templateUtils.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const catchType = {
-  option: ['Catch'],
-  stringRegex: /^catch\((.*)\)$/u,
-  valueMatch (x) {
-    // Todo: Should expand types here and in `toValue`
-    return ['number', 'string'].includes(typeof x);
-  },
-  toValue (s) {
-    const value = s.charAt(0) === '"' ? s.slice(1, -1) : Number(s);
-    return {value};
-  },
-  getInput ({root}) {
-    return /** @type {HTMLTextAreaElement} */ (
-      $e(root, 'input,textarea')
-    );
-  },
-  setValue ({root, value}) {
-    // input/textarea hasn't yet been added, so set timeout
-    setTimeout(() => {
-      this.getInput({root}).value = value;
-    });
-  },
-  getValue ({root}) {
-    return this.getInput({root}).value;
-  },
-  viewUI ({
-    specificSchemaObject, types,
-    resultType, typeNamespace, topRoot, format,
-    bringIntoFocus, buildTypeChoices, // schemaContent,
-    replaced, value
-  }) {
-    return ['span', {
-      dataset: {type: 'catch'},
-      title: specificSchemaObject?.description ?? '(a catch)'
-    }, [
-      ['b', ['Catch']],
-      ['br'],
-      'Default value',
-      ['br'],
-      ['div', {
-        class: 'defaultValue'
-      }, [
-        types.getUIForModeAndType({
-          readonly: true,
-          specificSchemaObject: /** @type {import('zodex').SzCatch} */ (
-            specificSchemaObject
-          )?.innerType,
-          hasValue: true,
-          value,
-          resultType, typeNamespace,
-          type: /** @type {import('../types.js').AvailableType} */ (
-            /** @type {import('zodex').SzCatch} */ (
-              specificSchemaObject
-            )?.innerType?.type
-          ),
-          topRoot, bringIntoFocus,
-          buildTypeChoices, format,
-          // schemaContent,
-          replaced
-        })
-      ]],
-      'Catch value',
-      ['br'],
-      ['div', {
-        class: 'catchValue'
-      }, [
-        types.getUIForModeAndType({
-          readonly: true,
-          specificSchemaObject: {
-            ...(/** @type {import('zodex').SzCatch} */ (
-              specificSchemaObject
-            )?.innerType),
-            description: '(catch value)'
-          },
-          hasValue: true,
-          value: /** @type {import('zodex').SzCatch} */ (
-            specificSchemaObject
-          ).value,
-          resultType, typeNamespace,
-          type: /** @type {import('../types.js').AvailableType} */ (
-            /** @type {import('zodex').SzCatch} */ (
-              specificSchemaObject
-            )?.innerType?.type
-          ),
-          topRoot, bringIntoFocus,
-          buildTypeChoices, format,
-          // schemaContent,
-          replaced
-        })
-      ]]
-    ]];
-  },
-  editUI ({
-    format, type, buildTypeChoices, specificSchemaObject,
-    topRoot, schemaContent, typeNamespace, value
-  }) {
-    const schemaValue =
-      /** @type {import('zodex').SzCatch} */ (
-        specificSchemaObject
-      )?.value;
-    return ['div', {
-      dataset: {type: 'catch'},
-      title: specificSchemaObject?.description ?? '(a `catch`)'
-    }, [
-      ['label', [
-        ['b', {
-          title: String(schemaValue)
-        }, ['Value']],
-        ' ',
-        ...(/** @type {import('../typeChoices.js').BuildTypeChoices} */ (
-          buildTypeChoices
-        )({
-          // resultType,
-          // eslint-disable-next-line object-shorthand -- TS
-          topRoot: /** @type {HTMLDivElement} */ (topRoot),
-          // eslint-disable-next-line object-shorthand -- TS
-          format: /** @type {import('../formats.js').AvailableFormat} */ (
-            format
-          ),
-          setValue: true,
-          value: value ?? schemaValue,
-          schemaOriginal: schemaContent,
-          schemaContent: /** @type {import('zodex').SzCatch} */ (
-            specificSchemaObject
-          )?.innerType,
-          state: type,
-          // itemIndex,
-          typeNamespace
-        }).domArray)
-      ]]
-    ]];
-  }
-};
-
-export default catchType;

package/src/fundamentalTypes/enumType.js

@@ -1,52 +0,0 @@
-import {$e} from '../utils/templateUtils.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const enumType = {
-  option: ['Enum'],
-  stringRegex: /^Enum\((.*)\)$/u,
-  valueMatch (x) {
-    return typeof x === 'string';
-  },
-  toValue (s) {
-    return {value: s.slice(1, -1)};
-  },
-  getInput ({root}) {
-    return /** @type {HTMLSelectElement} */ ($e(root, 'select'));
-  },
-  setValue ({root, value}) {
-    this.getInput({root}).value = value;
-  },
-  getValue ({root}) {
-    return this.getInput({root}).value;
-  },
-  viewUI ({value, specificSchemaObject}) {
-    return ['span', {
-      dataset: {type: 'enum'},
-      title: specificSchemaObject?.description ?? '(an enum)'
-    }, [
-      value
-    ]];
-  },
-  editUI ({typeNamespace, specificSchemaObject, value = ''}) {
-    return ['div', {
-      dataset: {type: 'enum'},
-      title: specificSchemaObject?.description ?? 'Enum'
-    }, [
-      ['select', {
-        name: `${typeNamespace}-enum`
-      }, /** @type {import('zodex').SzEnum} */ (
-        specificSchemaObject
-      )?.values.map((val) => {
-        return ['option', {
-          selected: value
-            ? value === val
-            : specificSchemaObject?.defaultValue === val
-        }, [val]];
-      })]
-    ]];
-  }
-};
-
-export default enumType;

package/src/fundamentalTypes/literalType.js

@@ -1,81 +0,0 @@
-import {$e} from '../utils/templateUtils.js';
-
-import booleanType from './booleanType.js';
-import numberType from './numberType.js';
-import stringType from './stringType.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const literalType = {
-  option: ['Literal'],
-  stringRegex: /^Literal\((.*)\)$/u,
-  valueMatch (x) {
-    // const schema =
-    //   /** @type {import('zodex').SzLiteral<any>} */ (cfg?.schema);
-    return (typeof x === 'boolean' || typeof x === 'number' ||
-      typeof x === 'string'); // && (!schema || schema.value === x);
-  },
-  toValue (s) {
-    const value = s === 'true'
-      ? true
-      : s === 'false'
-        ? false
-        : s.charAt(0) === '"'
-          ? s.slice(1, -1)
-          : Number(s);
-    return {value};
-  },
-  // Todo: Fix all the following methods up to `setValue` to work with children
-  getInput ({root}) {
-    return /** @type {HTMLTextAreaElement} */ ($e(root, 'input,textarea'));
-  },
-  setValue ({root, value}) {
-    this.getInput({root}).value = value;
-  },
-  getValue ({root, stateObj}) {
-    const innerTypeHolder = $e(root, '[data-type]');
-    const typeObject = stateObj?.types?.getTypeObject?.(
-      /** @type {import('../types.js').AvailableType} */ (
-        innerTypeHolder?.dataset.type
-      )
-    );
-    return /** @type {import('../types.js').TypeObject} */ (
-      typeObject
-    )?.getValue({root, stateObj});
-  },
-  viewUI ({value, specificSchemaObject}) {
-    return ['span', {
-      dataset: {type: 'literal'},
-      title: specificSchemaObject?.description ?? `(a literal ${typeof value})`
-    }, [`${value}`]];
-  },
-  editUI (arg) {
-    const {specificSchemaObject} = arg;
-    const {
-      value: val
-    } = /** @type {import('zodex').SzLiteral<any>} */ (specificSchemaObject);
-
-    let specificLiteralEditUI;
-    switch (typeof val) {
-    case 'boolean':
-      // arg.specificSchemaObject = {type: 'boolean'};
-      specificLiteralEditUI = booleanType.editUI(arg);
-      break;
-    case 'number':
-      // arg.specificSchemaObject = {type: 'number'};
-      specificLiteralEditUI = numberType.editUI(arg);
-      break;
-    case 'string': default:
-      // arg.specificSchemaObject = {type: 'string'};
-      specificLiteralEditUI = stringType.editUI(arg);
-      break;
-    }
-
-    return ['div', {dataset: {type: 'literal'}}, [
-      specificLiteralEditUI
-    ]];
-  }
-};
-
-export default literalType;

package/src/fundamentalTypes/nativeEnumType.js

@@ -1,157 +0,0 @@
-import {$e} from '../utils/templateUtils.js';
-import {escapeRegex} from '../types.js';
-import {jml} from '../vendor-imports.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const nativeEnumType = {
-  option: ['Native enum'],
-  stringRegex: /^nativeEnum\((.*)\)$/u,
-  valueMatch (x) {
-    return ['number', 'string'].includes(typeof x);
-  },
-  toValue (s, rootInfo) {
-    const key = s.charAt(0) === '"' ? s.slice(1, -1) : Number(s);
-
-    let schema = rootInfo?.schemaObject;
-    /* istanbul ignore else -- Most likely is if */
-    if (rootInfo?.schemaObject?.type === 'union') {
-      const schemas = /** @type {import('zodex').SzUnion} */ (
-        rootInfo.schemaObject
-      ).options.filter((option) => {
-        return option.type === 'nativeEnum';
-      });
-      schema = schemas.find((schema) => {
-        return key in schema.values;
-      });
-    }
-    const value = /** @type {import('zodex').SzNativeEnum} */ (schema)?.values[
-      key
-    ];
-    return {value};
-  },
-  getInput ({root}) {
-    return /** @type {HTMLTextAreaElement} */ ($e(root, 'input.nativeEnumKey'));
-  },
-  setValue ({root, value}) {
-    const input = /**
-    * @type {HTMLInputElement & {
-    *   $schemaNativeEnumValues: import('zodex').SzNativeEnum['values']
-    * }}
-    */ (this.getInput({root}));
-    input.value = Object.entries(
-      input.$schemaNativeEnumValues
-    ).find(([, val]) => {
-      return val === value;
-    })?.[0] ?? '';
-    if (input.value) { // If key was found, the value is ok
-      /** @type {HTMLSpanElement} */ (
-        $e(root, '.enumeratedValue')
-      ).textContent = value;
-    }
-  },
-  getValue ({root}) {
-    const {value, $schemaNativeEnumValues} =
-      /**
-       * @type {HTMLInputElement & {
-       *   $schemaNativeEnumValues: import('zodex').SzNativeEnum['values']
-       * }}
-       */ (
-        this.getInput({root})
-      );
-
-    return $schemaNativeEnumValues[value];
-  },
-  viewUI ({value, specificSchemaObject}) {
-    return ['div', [
-      'Native enum: ',
-      ['span', {
-        dataset: {type: 'nativeEnum'},
-        title: specificSchemaObject?.description ?? '(a native enum)'
-      }, [value]]
-    ]];
-  },
-  editUI (info) {
-    const {
-      specificSchemaObject,
-      value
-      // typeNamespace
-    } = info;
-    const schemaNativeEnumValues = /** @type {import('zodex').SzNativeEnum} */ (
-      specificSchemaObject
-    )?.values;
-    const nativeEnumKeys = Object.keys(schemaNativeEnumValues);
-
-    let keyForValue;
-    if (schemaNativeEnumValues && 'value' in info) {
-      keyForValue = Object.entries(schemaNativeEnumValues).find(([, val]) => {
-        return val === value;
-      })?.[0];
-    }
-
-    const nativeEnumPattern = nativeEnumKeys.map((nativeEnumKey) => {
-      // Zod seems to prohibit numerically-indexed strings so we prevent here,
-      //   but it seems the generated JavaScript allows them (?)
-      if (
-        (/^\d$/u).test(nativeEnumKey) &&
-        Object.values(schemaNativeEnumValues).includes(
-          Number.parseInt(nativeEnumKey)
-        )
-      ) {
-        return null;
-      }
-      return escapeRegex(nativeEnumKey);
-    }).filter(Boolean).join('|');
-
-    const input =
-      /**
-       * @type {HTMLInputElement & {
-       *   $schemaNativeEnumValues: import('zodex').SzNativeEnum['values']
-       * }}
-       */ (jml(
-        'input',
-        /** @type {import('jamilih').JamilihAttributes} */ ({
-          class: 'nativeEnumKey',
-          placeholder: nativeEnumPattern,
-          title: nativeEnumPattern,
-          // Implicitly already wrapped by HTML in `^(?:...)$`
-          pattern: nativeEnumPattern,
-          value: keyForValue ?? '',
-          $on: {
-            input () {
-              const ev = /** @type {HTMLSpanElement} */ (
-                this.parentElement?.parentElement?.querySelector(
-                  '.enumeratedValue'
-                )
-              );
-              ev.textContent = String(schemaNativeEnumValues[
-                /** @type {HTMLInputElement} */
-                (this).value
-              ] ?? '');
-            }
-          }
-        })
-      ));
-    input.$schemaNativeEnumValues = schemaNativeEnumValues;
-
-    return ['div', {
-      dataset: {type: 'nativeEnum'},
-      title: specificSchemaObject?.description ?? 'Native Enum'
-    }, [
-      ['label', [
-        'Enumerated key ',
-        input
-      ]],
-      ['br'],
-      'Enumerated value: ',
-      ['span', {
-        class: 'enumeratedValue'
-      }, [
-        value ?? ''
-      ]]
-    ]];
-  }
-};
-
-export default nativeEnumType;

package/src/fundamentalTypes/neverType.js

@@ -1,49 +0,0 @@
-import {$e} from '../utils/templateUtils.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const neverType = {
-  stringRegex: /^never$/u,
-  option: ['Never'],
-  /* istanbul ignore next -- Back-up in case shows */
-  valueMatch () {
-    /* istanbul ignore next -- Back-up in case shows */
-    return false;
-  },
-  toValue (/* _s */) {
-    throw new Error('Cannot convert to value');
-  },
-  getValue () {
-    return /** @type {import('../types.js').ToValue} */ (
-      this.toValue
-    )('');
-  },
-  /* istanbul ignore next -- Back-up in case shows */
-  viewUI ({specificSchemaObject}) {
-    /* istanbul ignore next -- Back-up in case shows */
-    return ['i', {
-      dataset: {type: 'never'},
-      title: specificSchemaObject?.description ?? '(a `never`)'
-    }, ['never']];
-  },
-  /* istanbul ignore next -- No dupe keys, array refs, or validation */
-  getInput ({root}) {
-    /* istanbul ignore next -- Back-up in case shows */
-    return /** @type {HTMLInputElement} */ ($e(root, 'input'));
-  },
-  editUI ({typeNamespace}) {
-    return ['div', {dataset: {type: 'never'}}, [
-      ['label', [
-        'Never (no value present here)',
-        ['input', {
-          type: 'checkbox',
-          name: `${typeNamespace}-never`,
-          hidden: true
-        }]
-      ]]
-    ]];
-  }
-};
-
-export default neverType;

package/src/fundamentalTypes/recordType.js

@@ -1,42 +0,0 @@
-import {toStringTag} from '../vendor-imports.js';
-import arrayType from './arrayType.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const recordType = {
-  option: ['Record'],
-  regexEndings: [',', '}'],
-  stringRegexBegin: /^Record\{/u,
-  stringRegexEnd: /^\}/u,
-  array: true,
-  record: true,
-  valueMatch (x) { // Like `object` type, can also match
-    return x && typeof x === 'object' &&
-      // Exclude other special object types
-      toStringTag(x) === 'Object';
-  },
-  toValue (...args) {
-    return /** @type {import('../types.js').ToValue} */ (
-      arrayType.toValue
-    ).apply(this, args);
-  },
-  getValue (...args) {
-    return arrayType.getValue.apply(this, args);
-  },
-  getInput (...args) {
-    return arrayType.getInput.apply(this, args);
-  },
-  viewUI ({...args}) {
-    return arrayType.viewUI.call(this, {
-      ...args, type: 'record'
-    });
-  },
-  editUI ({...args}) {
-    return arrayType.editUI.call(this, {
-      ...args, type: 'record'
-    });
-  }
-};
-
-export default recordType;

package/src/fundamentalTypes/tupleType.js

@@ -1,39 +0,0 @@
-import arrayType from './arrayType.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const tupleType = {
-  option: ['Tuple'],
-  array: true,
-  regexEndings: [',', ']'],
-  stringRegexBegin: /^Tuple\[/u,
-  stringRegexEnd: /^\]/u,
-  tuple: true,
-  valueMatch (x) {
-    return Array.isArray(x);
-  },
-  toValue (...args) {
-    return /** @type {import('../types.js').ToValue} */ (
-      arrayType.toValue
-    ).apply(this, args);
-  },
-  getValue (...args) {
-    return arrayType.getValue.apply(this, args);
-  },
-  getInput (...args) {
-    return arrayType.getInput.apply(this, args);
-  },
-  viewUI ({...args}) {
-    return arrayType.viewUI.call(this, {
-      ...args, type: 'tuple'
-    });
-  },
-  editUI ({...args}) {
-    return arrayType.editUI.call(this, {
-      ...args, type: 'tuple'
-    });
-  }
-};
-
-export default tupleType;

package/src/fundamentalTypes/voidType.js

@@ -1,48 +0,0 @@
-import {$e} from '../utils/templateUtils.js';
-
-/**
- * @type {import('../types.js').TypeObject}
- */
-const voidType = {
-  stringRegex: /^void$/u,
-  option: ['Void'],
-  valueMatch (x) {
-    return x === undefined;
-  },
-  toValue (/* _s */) {
-    return {value: undefined};
-  },
-  getValue () {
-    return /** @type {import('../types.js').ToValue} */ (
-      this.toValue
-    )('').value;
-  },
-  /* istanbul ignore next -- No dupe keys, array refs, or validation */
-  getInput ({root}) {
-    return /** @type {HTMLInputElement} */ ($e(root, 'input'));
-  },
-  viewUI ({specificSchemaObject}) {
-    return ['i', {
-      dataset: {type: 'void'},
-      title: specificSchemaObject?.description ?? '(a `void`)'
-    }, ['void']];
-  },
-  editUI ({typeNamespace, specificSchemaObject}) {
-    return ['div', {
-      dataset: {type: 'void'},
-      title: specificSchemaObject?.description ?? 'Void'
-    }, [
-      ['label', [
-        'Void',
-        ['input', {
-          type: 'checkbox',
-          name: `${typeNamespace}-void`,
-          checked: true,
-          disabled: true
-        }]
-      ]]
-    ]];
-  }
-};
-
-export default voidType;