@json-layout/vocabulary 0.9.1 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-layout/vocabulary",
-  "version": "0.9.1",
+  "version": "0.11.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 }
 }
 
@@ -209,15 +232,16 @@ const getType = (schemaFragment) => {
  * @param {SchemaFragment} schemaFragment
  * @param {string} schemaPath
  * @param {(text: string) => string} markdown
+ * @param {string[]} optionsKeys
  * @param {'oneOf'} [arrayChild]
  * @returns {{normalized: CompObject, errors: string[]}}
  */
-function getCompObject (layoutKeyword, schemaFragment, schemaPath, markdown, arrayChild) {
+function getCompObject (layoutKeyword, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild) {
   /** @type {string[]} */
   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 }
@@ -243,14 +267,14 @@ function getCompObject (layoutKeyword, schemaFragment, schemaPath, markdown, arr
 
   // @ts-ignore
   if (compositeCompNames.includes(partial.comp)) {
-    partial.title = partial.title ?? schemaFragment.title ?? null
+    if (!('title' in partial)) partial.title = schemaFragment.title ?? null
     partial.children = getChildren(getDefaultChildren(schemaFragment), partial.children)
   } else if (partial.comp === 'list') {
-    partial.title = partial.title ?? schemaFragment.title ?? key
+    if (!('title' in partial)) partial.title = schemaFragment.title ?? key
     partial.listEditMode = partial.listEditMode ?? (schemaFragment.items.type === 'object' ? 'inline-single' : 'inline')
     partial.listActions = partial.listActions ?? ['add', 'edit', 'delete', 'duplicate', 'sort']
   } else {
-    partial.label = partial.label ?? schemaFragment.title ?? key
+    if (!('label' in partial)) partial.label = schemaFragment.title ?? key
   }
 
   if (['select', 'autocomplete', 'combobox'].includes(partial.comp) && !partial.items) {
@@ -298,6 +322,20 @@ function getCompObject (layoutKeyword, schemaFragment, schemaPath, markdown, arr
     partial.defaultData = ''
   }
 
+  // options can be set directly in layout and normalized in layout.options
+  // TODO: fetch this list from the schema ?
+  for (const optionKey of optionsKeys) {
+    if (optionKey in partial) {
+      partial.options = partial.options ?? {}
+      partial.options[optionKey] = partial[optionKey]
+      delete partial[optionKey]
+    }
+  }
+  if (schemaFragment.readOnly) {
+    partial.options = partial.options ?? {}
+    if (!('readOnly' in partial.options)) partial.options.readOnly = true
+  }
+
   if (partial.getOptions !== undefined) partial.getOptions = normalizeExpression(partial.getOptions)
   if (partial.getDefaultData !== undefined) partial.getDefaultData = normalizeExpression(partial.getDefaultData)
   if (partial.getConstData !== undefined) partial.getConstData = normalizeExpression(partial.getConstData)
@@ -371,10 +409,11 @@ function getCompObject (layoutKeyword, schemaFragment, schemaPath, markdown, arr
  * @param {SchemaFragment} schemaFragment
  * @param {string} schemaPath
  * @param {(text: string) => string} markdown
+ * @param {string[]} optionsKeys
  * @param {'oneOf'} [arrayChild]
  * @returns {{normalized: NormalizedLayout, errors: string[]}}
  */
-function getNormalizedLayout (layoutKeyword, schemaFragment, schemaPath, markdown, arrayChild) {
+function getNormalizedLayout (layoutKeyword, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild) {
   if (isPartialSwitch(layoutKeyword)) {
     /** @type {CompObject[]} */
     const normalizedSwitchCases = []
@@ -385,13 +424,13 @@ function getNormalizedLayout (layoutKeyword, schemaFragment, schemaPath, markdow
     }
     for (let i = 0; i < switchCases.length; i++) {
       const switchCase = switchCases[i]
-      const compObjectResult = getCompObject(switchCase, schemaFragment, schemaPath, markdown, arrayChild)
+      const compObjectResult = getCompObject(switchCase, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild)
       normalizedSwitchCases.push(compObjectResult.normalized)
       for (const error of compObjectResult.errors) errors.push(`switch ${i} - ${error}`)
     }
     return { normalized: { switch: normalizedSwitchCases }, errors: [] }
   } else {
-    return getCompObject(layoutKeyword, schemaFragment, schemaPath, markdown, arrayChild)
+    return getCompObject(layoutKeyword, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild)
   }
 }
 
@@ -423,14 +462,18 @@ function lighterValidationErrors (errors) {
   return errors.map(e => e.message ?? e.keyword)
 }
 
+const defaultOptionsKeys = ['readOnly', 'summary', 'titleDepth', 'density', 'removeAdditional', 'validateOn', 'initialValidation', 'defaultOn', 'readOnlyPropertiesMode']
+
 /**
  * @param {SchemaFragment} schemaFragment
  * @param {string} schemaPath
  * @param {(text: string) => string} markdown
+ * @param {string[]} [optionsKeys]
  * @param {'oneOf'} [arrayChild]
  * @returns {{layout: NormalizedLayout, errors: string[]}}
  */
-export function normalizeLayoutFragment (schemaFragment, schemaPath, markdown = (src) => src, arrayChild) {
+export function normalizeLayoutFragment (schemaFragment, schemaPath, markdown = (src) => src, optionsKeys, arrayChild) {
+  optionsKeys = optionsKeys ? optionsKeys.concat(defaultOptionsKeys) : defaultOptionsKeys
   let layoutKeyword
   if (arrayChild === 'oneOf') {
     layoutKeyword = schemaFragment.oneOfLayout ?? {}
@@ -440,15 +483,15 @@ export function normalizeLayoutFragment (schemaFragment, schemaPath, markdown =
   if (!validateLayoutKeyword(layoutKeyword)) {
     console.error(`layout keyword validation errors at path ${schemaPath}`, layoutKeyword, validateLayoutKeyword.errors)
     return {
-      layout: getNormalizedLayout({}, schemaFragment, schemaPath, markdown, arrayChild).normalized,
+      layout: getNormalizedLayout({}, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild).normalized,
       errors: lighterValidationErrors(validateLayoutKeyword.errors)
     }
   }
-  const normalizedLayout = getNormalizedLayout(layoutKeyword, schemaFragment, schemaPath, markdown, arrayChild)
+  const normalizedLayout = getNormalizedLayout(layoutKeyword, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild)
   if (!validateNormalizedLayout(normalizedLayout.normalized)) {
     console.error(`normalized layout validation errors at path ${schemaPath}`, normalizedLayout, validateNormalizedLayout.errors)
     return {
-      layout: getNormalizedLayout({}, schemaFragment, schemaPath, markdown, arrayChild).normalized,
+      layout: getNormalizedLayout({}, schemaFragment, schemaPath, markdown, optionsKeys, arrayChild).normalized,
       errors: lighterValidationErrors(validateNormalizedLayout.errors)
     }
     // throw new Error(`invalid layout at path ${schemaPath}`, { cause: validateNormalizedLayout.errors })

package/src/normalized-layout/schema.js

@@ -1033,7 +1033,65 @@ export default {
                 "default",
                 "comfortable",
                 "compact"
+              ],
+              "default": "default"
+            },
+            "removeAdditional": {
+              "description": "true is the same as 'unknown', false is the same as 'none'",
+              "default": "error",
+              "oneOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "enum": [
+                    "unknown",
+                    "error",
+                    "none"
+                  ]
+                }
               ]
+            },
+            "validateOn": {
+              "type": "string",
+              "enum": [
+                "input",
+                "blur",
+                "submit"
+              ],
+              "default": "input"
+            },
+            "initialValidation": {
+              "type": "string",
+              "enum": [
+                "never",
+                "always",
+                "withData"
+              ],
+              "default": "withData"
+            },
+            "defaultOn": {
+              "type": "string",
+              "enum": [
+                "missing",
+                "empty",
+                "never"
+              ],
+              "default": "empty"
+            },
+            "autofocus": {
+              "type": "boolean",
+              "default": false
+            },
+            "readOnlyPropertiesMode": {
+              "type": "string",
+              "enum": [
+                "remove",
+                "hide",
+                "show"
+              ],
+              "default": "show"
             }
           }
         }

package/src/normalized-layout/schema.json

@@ -487,7 +487,39 @@
             "readOnly": {"type": "boolean", "default": false},
             "summary": {"type": "boolean", "default": false},
             "titleDepth": {"type": "integer", "minimum": 1, "maximum": 6, "default": 2},
-            "density": {"type": "string", "enum": ["default", "comfortable", "compact"]}
+            "density": {"type": "string", "enum": ["default", "comfortable", "compact"], "default": "default"},
+            "removeAdditional": {
+              "description": "true is the same as 'unknown', false is the same as 'none'",
+              "default": "error",
+              "oneOf": [
+                {"type": "boolean"},
+                {
+                  "type": "string",
+                  "enum": ["unknown", "error", "none"]
+                }
+              ]
+            },
+            "validateOn": {
+              "type": "string",
+              "enum": ["input", "blur", "submit"],
+              "default": "input"
+            },
+            "initialValidation": {
+              "type": "string",
+              "enum": ["never", "always", "withData"],
+              "default": "withData"
+            },
+            "defaultOn": {
+              "type": "string",
+              "enum": ["missing", "empty", "never"],
+              "default": "empty"
+            },
+            "autofocus": {"type": "boolean", "default": false},
+            "readOnlyPropertiesMode": {
+              "type": "string",
+              "enum": ["remove", "hide", "show"],
+              "default": "show"
+            }
           }
         }
       ]

package/src/normalized-layout/types.ts

@@ -51,6 +51,15 @@ export type StateNodeOptionsBase = StateNodeOptionsBaseLib & {
   summary?: boolean;
   titleDepth?: number;
   density?: "default" | "comfortable" | "compact";
+  /**
+   * true is the same as 'unknown', false is the same as 'none'
+   */
+  removeAdditional?: boolean | ("unknown" | "error" | "none");
+  validateOn?: "input" | "blur" | "submit";
+  initialValidation?: "never" | "always" | "withData";
+  defaultOn?: "missing" | "empty" | "never";
+  autofocus?: boolean;
+  readOnlyPropertiesMode?: "remove" | "hide" | "show";
   [k: string]: unknown;
 };
 export type Cols = number;