@json-layout/vocabulary 0.10.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-layout/vocabulary",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Main JSON Layout vocabulary as JSON schemas and Typescript types. Also contains some small utility functions to validate and normalize annotations.",
   "type": "module",
   "exports": {

package/src/index.js

@@ -1,4 +1,4 @@
 /** @typedef {import("./types.js").SchemaFragment} SchemaFragment */
 export * from './layout-keyword/index.js'
 export * from './normalized-layout/index.js'
-export { normalizeLayoutFragment } from './normalize.js'
+export { normalizeLayoutFragment, getSchemaFragmentType } from './normalize.js'

package/src/normalize.js

@@ -18,7 +18,7 @@ import { validateNormalizedLayout, compositeCompNames } from './normalized-layou
  * @returns {Children}
  */
 function getDefaultChildren (schemaFragment) {
-  const { type } = getType(schemaFragment)
+  const { type } = getSchemaFragmentType(schemaFragment)
   /** @type {Children} */
   const children = []
   if (type === 'object') {
@@ -87,8 +87,8 @@ function getChildren (defaultChildren, partialChildren) {
  * @returns {import('./index.js').ComponentName}
  */
 function getDefaultComp (partial, schemaFragment, arrayChild) {
-  const { type } = getType(schemaFragment)
-  const hasSimpleType = ['string', 'integer', 'number'].includes(type)
+  const { type } = getSchemaFragmentType(schemaFragment)
+  const hasSimpleType = type && ['string', 'integer', 'number'].includes(type)
   if (arrayChild === 'oneOf') return 'one-of-select'
   if (hasSimpleType && schemaFragment.enum) return schemaFragment.enum.length > 20 ? 'autocomplete' : 'select'
   if (hasSimpleType && schemaFragment.oneOf) return schemaFragment.oneOf.length > 20 ? 'autocomplete' : 'select'
@@ -162,8 +162,8 @@ function normalizeExpression (expression, defaultType = 'js-eval') {
  */
 function getItemsFromSchema (schemaFragment) {
   if (!schemaFragment) return null
-  const { type } = getType(schemaFragment)
-  const hasSimpleType = ['string', 'integer', 'number'].includes(type)
+  const { type } = getSchemaFragmentType(schemaFragment)
+  const hasSimpleType = type && ['string', 'integer', 'number'].includes(type)
   if (schemaFragment.enum && hasSimpleType) {
     return schemaFragment.enum.map((/** @type {string} */ value) => ({ key: value + '', title: value + '', value }))
   }
@@ -194,13 +194,36 @@ function getItemsFromSchema (schemaFragment) {
 
 /**
  * @param {SchemaFragment} schemaFragment
- * @returns {{type: string, nullable: boolean}}
+ * @returns {{type: string | undefined, nullable: boolean}}
  */
-const getType = (schemaFragment) => {
+export const getSchemaFragmentType = (schemaFragment) => {
   if (Array.isArray(schemaFragment.type) && schemaFragment.type.length === 2 && schemaFragment.type.includes('null')) {
     const type = schemaFragment.type.find(t => t !== 'null')
     return { type, nullable: true }
   }
+
+  if (!schemaFragment.type && schemaFragment.properties) {
+    return { type: 'object', nullable: false }
+  }
+
+  // case where type is not defined but can be deduced from children oneOf/allOf/anyOf
+  /** @type {any[]} */
+  if (!schemaFragment.type) {
+    /** @type {string[]} */
+    const combinationTypes = []
+    for (const combinationKey of ['allOf', 'anyOf', 'oneOf']) {
+      // @ts-ignore
+      if (schemaFragment[combinationKey]) {
+        // @ts-ignore
+        for (const subSchema of schemaFragment[combinationKey]) {
+          const { type: subType } = getSchemaFragmentType(subSchema)
+          if (subType && !combinationTypes.includes(subType)) combinationTypes.push(subType)
+        }
+      }
+    }
+    if (combinationTypes.length === 1) return { type: combinationTypes[0], nullable: false }
+  }
+
   return { type: schemaFragment.type, nullable: false }
 }
 
@@ -218,7 +241,7 @@ function getCompObject (layoutKeyword, schemaFragment, schemaPath, markdown, opt
   const errors = []
   const key = schemaPath.slice(schemaPath.lastIndexOf('/') + 1)
 
-  const { type, nullable } = getType(schemaFragment)
+  const { type, nullable } = getSchemaFragmentType(schemaFragment)
 
   if ('const' in schemaFragment) return { normalized: { comp: 'none' }, errors }
   if (!type) return { normalized: { comp: 'none' }, errors }
@@ -439,7 +462,7 @@ function lighterValidationErrors (errors) {
   return errors.map(e => e.message ?? e.keyword)
 }
 
-const defaultOptionsKeys = ['readOnly', 'summary', 'titleDepth', 'density', 'removeAdditional', 'validateOn', 'initialValidation', 'defaultOn', 'readOnlyPropertiesMode']
+const defaultOptionsKeys = ['readOnly', 'summary', 'titleDepth', 'density', 'removeAdditional', 'validateOn', 'initialValidation', 'defaultOn', 'readOnlyPropertiesMode', 'debounceInputMs']
 
 /**
  * @param {SchemaFragment} schemaFragment

package/src/normalized-layout/index.js

@@ -69,6 +69,10 @@ export function isSectionLayout (layout) {
 
 export const compositeCompNames = ['section', 'tabs', 'vertical-tabs', 'expansion-panels', 'stepper']
 
+// these components can received keybord inputs and emit blur events
+// they will be debounced and validateOn=blur is applicable
+export const editableCompNames = ['text-field', 'number-field', 'textarea', 'markdown']
+
 /** @type {(layout: CompObject) => layout is CompositeCompObject} */
 export function isCompositeLayout (layout) {
   return compositeCompNames.includes(layout.comp)

package/src/normalized-layout/schema.js

@@ -1092,6 +1092,11 @@ export default {
                 "show"
               ],
               "default": "show"
+            },
+            "debounceInputMs": {
+              "type": "integer",
+              "minimum": 0,
+              "default": 300
             }
           }
         }

package/src/normalized-layout/schema.json

@@ -519,6 +519,11 @@
               "type": "string",
               "enum": ["remove", "hide", "show"],
               "default": "show"
+            },
+            "debounceInputMs": {
+              "type": "integer",
+              "minimum": 0,
+              "default": 300
             }
           }
         }

package/src/normalized-layout/types.ts

@@ -60,6 +60,7 @@ export type StateNodeOptionsBase = StateNodeOptionsBaseLib & {
   defaultOn?: "missing" | "empty" | "never";
   autofocus?: boolean;
   readOnlyPropertiesMode?: "remove" | "hide" | "show";
+  debounceInputMs?: number;
   [k: string]: unknown;
 };
 export type Cols = number;