shinkansen-transmission 2.2.234 → 2.3.0

package/src/transmission/to-zashiki/transform-root-schema.mjs

@@ -1,26 +1,22 @@
+/**
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.ValuesType} ValuesType
+ *  @typedef {TransmissionTypes.ParamsType} ParamsType
+ *
+ *  @typedef {TransmissionTypes.Zashiki.ZashikiType} ZashikiType
+ */
+
 import debug from 'debug'
 
 import {
   isArray,
   isObject,
-
   getSelectedItems,
-
   hasEnum,
-  getEnum,
   hasAnyOf,
   hasOneOf,
   hasAllOf,
-
-  normaliseUri,
-
-  getMetaProps,
-
-  getElementsProps,
-  getElementsFieldPropsForEnum,
-  getElementsFieldPropsForAnyOf,
-  getElementsFieldPropsForOneOf,
-  getElementsFieldPropsForAllOf
+  getMetaProps
 } from '#transmission/transmission/common'
 
 import {
@@ -30,225 +26,93 @@ import {
   mapTransformNullByIndex,
   mapTransformArrayByIndex,
   mapTransformObjectByIndex,
-
   mapTransformByIndex,
   getTransformByIndex,
+  mapTransformByKey
+} from './transform-schema.mjs'
 
-  mapTransformByKey,
-
-  renderNullForEnum,
-  renderNullForAnyOf,
-  renderNullForOneOf,
-  renderNullForAllOf,
-  renderNull,
-
-  renderBooleanForEnum,
-  renderBooleanForAnyOf,
-  renderBooleanForOneOf,
-  renderBooleanForAllOf,
-  renderBoolean,
-
-  renderObjectForEnum,
-  renderObjectForAnyOf,
-  renderObjectForOneOf,
-  renderObjectForAllOf,
-  renderObject,
-
-  renderArrayForEnum,
-  renderArrayForAnyOf,
-  renderArrayForOneOf,
-  renderArrayForAllOf,
-  renderArray,
-
-  renderNumberForEnum,
-  renderNumberForAnyOf,
-  renderNumberForOneOf,
-  renderNumberForAllOf,
-  renderNumber,
+import {
+  getRenderParamsForEnum,
+  getRenderParamsForAnyOf,
+  getRenderParamsForOneOf,
+  getRenderParamsForAllOf,
+  getRenderParams
+} from './render-params/root-schema/index.mjs'
 
+import {
   renderStringForEnum,
   renderStringForAnyOf,
   renderStringForOneOf,
   renderStringForAllOf,
   renderString
-} from './transform-schema.mjs'
-
-const log = debug('shinkansen-transmission/to-zashiki/root-schema')
+} from './render/string/index.mjs'
 
-log('`shinkansen` is awake')
-
-export function getRenderParamsForEnum (rootSchema, values, params) {
-  /*
-   *  log('getRenderParamsForEnum')
-   */
-
-  const {
-    parentUri = '#',
-    uri = '#/',
-    selectedItems = [],
-    items = []
-  } = params
-
-  const meta = Object.assign(getMetaProps(params, uri), {
-    schema: rootSchema,
-    selectedItems,
-    items
-  })
-
-  const elements = {
-    enum: Object.assign(getElementsFieldPropsForEnum(params, uri), {
-      selectedItems,
-      items
-    })
-  }
-
-  return Object.assign(params, {
-    parentUri,
-    uri,
-    [uri]: {
-      meta,
-      elements
-    }
-  })
-}
-
-export function getRenderParamsForAnyOf (rootSchema, values, params) {
-  /*
-   *  log('getRenderParamsForAnyOf')
-   */
-
-  const {
-    parentUri = '#',
-    uri = '#/',
-    selectedItems = [],
-    items = []
-  } = params
-
-  const meta = Object.assign(getMetaProps(params, uri), {
-    schema: rootSchema,
-    selectedItems,
-    items
-  })
-
-  const elements = {
-    anyOf: Object.assign(getElementsFieldPropsForAnyOf(params, uri), {
-      selectedItems,
-      items
-    })
-  }
-
-  return Object.assign(params, {
-    parentUri,
-    uri,
-    [uri]: {
-      meta,
-      elements
-    }
-  })
-}
-
-export function getRenderParamsForOneOf (rootSchema, values, params) {
-  /*
-   *  log('getRenderParamsForOneOf')
-   */
-
-  const {
-    parentUri = '#',
-    uri = '#/',
-    selectedItems = [],
-    items = []
-  } = params
-
-  const meta = Object.assign(getMetaProps(params, uri), {
-    schema: rootSchema,
-    selectedItems,
-    items
-  })
-
-  const elements = {
-    oneOf: Object.assign(getElementsFieldPropsForOneOf(params, uri), {
-      selectedItems,
-      items
-    })
-  }
-
-  return Object.assign(params, {
-    parentUri,
-    uri,
-    [uri]: {
-      meta,
-      elements
-    }
-  })
-}
-
-export function getRenderParamsForAllOf (rootSchema, values, params) {
-  /*
-   *  log('getRenderParamsForAllOf')
-   */
+import {
+  renderNumberForEnum,
+  renderNumberForAnyOf,
+  renderNumberForOneOf,
+  renderNumberForAllOf,
+  renderNumber
+} from './render/number/index.mjs'
 
-  const {
-    parentUri = '#',
-    uri = '#/'
-  } = params
+import {
+  renderArrayForEnum,
+  renderArrayForAnyOf,
+  renderArrayForOneOf,
+  renderArrayForAllOf,
+  renderArray
+} from './render/array/index.mjs'
 
-  const meta = Object.assign(getMetaProps(params, uri), {
-    schema: rootSchema
-  })
+import {
+  renderObjectForEnum,
+  renderObjectForAnyOf,
+  renderObjectForOneOf,
+  renderObjectForAllOf,
+  renderObject
+} from './render/object/index.mjs'
 
-  const elements = {
-    field: getElementsFieldPropsForAllOf(params, uri)
-  }
+import {
+  renderBooleanForEnum,
+  renderBooleanForAnyOf,
+  renderBooleanForOneOf,
+  renderBooleanForAllOf,
+  renderBoolean
+} from './render/boolean/index.mjs'
 
-  return Object.assign(params, {
-    parentUri,
-    uri,
-    [uri]: {
-      meta,
-      elements
-    }
-  })
-}
+import {
+  renderNullForEnum,
+  renderNullForAnyOf,
+  renderNullForOneOf,
+  renderNullForAllOf,
+  renderNull
+} from './render/null/index.mjs'
 
-export function getRenderParams (rootSchema, values, params) {
-  /*
-   *  log('getRenderParams')
-   */
+const log = debug('shinkansen-transmission/to-zashiki/transform-schema')
 
-  const {
-    parentUri = '#',
-    uri = '#/',
-    fields = []
-  } = params
+log('`shinkansen` is awake')
 
-  const meta = Object.assign(getMetaProps(params, uri), {
-    schema: rootSchema,
-    parentUri: normaliseUri(parentUri),
-    uri
-  })
-
-  const elements = Object.assign(getElementsProps(params, uri), {
-    fields
-  })
-
-  return Object.assign(params, {
-    parentUri,
-    uri,
-    [uri]: {
-      meta,
-      elements
-    }
-  })
+/**
+ *  @param {SchemaType} schemaProps
+ *  @param {SchemaType} item
+ *  @returns {SchemaType}
+ */
+function toSchema (schemaProps, item) {
+  return Object.assign(schemaProps, item)
 }
 
-/*
+/**
  *  Root schema
  *
  *  "enum"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNullForEnum (rootSchema, values, params) {
+export function transformStringForEnum (rootSchema, values, params) {
   /*
-   *  log('transformNullForEnum')
+   *  log('transformStringForEnum')
    */
 
   const {
@@ -259,19 +123,24 @@ export function transformNullForEnum (rootSchema, values, params) {
     selectedItems = getSelectedItems(values, uri) // uri
   } = getMetaProps(params, uri)
 
-  const items = getEnum(rootSchema)
+  const { enum: items = [] } = rootSchema // const items = getEnum(rootSchema)
 
-  return renderNullForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderStringForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "anyOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNullForAnyOf (rootSchema, values, params) {
+export function transformStringForAnyOf (rootSchema, values, params) {
   /*
-   *  log('transformNullForAnyOf')
+   *  log('transformStringForAnyOf')
    */
 
   const {
@@ -283,19 +152,24 @@ export function transformNullForAnyOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { anyOf = [] } = rootSchema
-  const items = anyOf.map(mapTransformNullByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = anyOf.filter(isObject).map(mapTransformStringByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderNullForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderStringForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "oneOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNullForOneOf (rootSchema, values, params) {
+export function transformStringForOneOf (rootSchema, values, params) {
   /*
-   *  log('transformNullForOneOf')
+   *  log('transformStringForOneOf')
    */
 
   const {
@@ -307,63 +181,86 @@ export function transformNullForOneOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { oneOf = [] } = rootSchema
-  const items = oneOf.map(mapTransformNullByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = oneOf.filter(isObject).map(mapTransformStringByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderNullForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderStringForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "allOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNullForAllOf (rootSchema, values, params) {
+export function transformStringForAllOf (rootSchema, values, params) {
   /*
-   *  log('transformNullForAllOf')
+   *  log('transformStringForAllOf')
    */
 
-  const { allOf = [], ...rest } = rootSchema
-  const itemSchema = allOf.reduce((accumulator, schema) => Object.assign(accumulator, schema), rest) // initialise with `rest`
+  const {
+    allOf = [],
+    ...schemaProps
+  } = rootSchema
+
+  /**
+   *  @type {SchemaType}
+   */
+  const itemSchema = allOf.filter(isObject).reduce(toSchema, structuredClone(schemaProps)) // initialise with `rest`
 
-  return renderNullForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, values, params))
+  return renderStringForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
+ *
+ *  @link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.3
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-// https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6
-export function transformNull (rootSchema, values, params) {
+export function transformString (rootSchema, values, params) {
   /*
-   *  log('transformNull')
+   *  log('transformString')
    */
 
   if (hasEnum(rootSchema)) {
-    return transformNullForEnum(rootSchema, values, params)
+    return transformStringForEnum(rootSchema, values, params)
   } else {
     if (hasAnyOf(rootSchema)) {
-      return transformNullForAnyOf(rootSchema, values, params)
+      return transformStringForAnyOf(rootSchema, values, params)
     } else {
       if (hasOneOf(rootSchema)) {
-        return transformNullForOneOf(rootSchema, values, params)
+        return transformStringForOneOf(rootSchema, values, params)
       } else {
         if (hasAllOf(rootSchema)) {
-          return transformNullForAllOf(rootSchema, values, params)
+          return transformStringForAllOf(rootSchema, values, params)
         }
       }
     }
   }
 
-  return renderNull(rootSchema, values, getRenderParams(rootSchema, values, params))
+  return renderString(rootSchema, values, getRenderParams(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "enum"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformBooleanForEnum (rootSchema, values, params) {
+export function transformNumberForEnum (rootSchema, values, params) {
   /*
-   *  log('transformBooleanForEnum')
+   *  log('transformNumberForEnum')
    */
 
   const {
@@ -374,19 +271,24 @@ export function transformBooleanForEnum (rootSchema, values, params) {
     selectedItems = getSelectedItems(values, uri) // uri
   } = getMetaProps(params, uri)
 
-  const items = getEnum(rootSchema)
+  const { enum: items = [] } = rootSchema // const items = getEnum(rootSchema)
 
-  return renderBooleanForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderNumberForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "anyOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformBooleanForAnyOf (rootSchema, values, params) {
+export function transformNumberForAnyOf (rootSchema, values, params) {
   /*
-   *  log('transformBooleanForAnyOf')
+   *  log('transformNumberForAnyOf')
    */
 
   const {
@@ -398,19 +300,24 @@ export function transformBooleanForAnyOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { anyOf = [] } = rootSchema
-  const items = anyOf.map(mapTransformBooleanByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = anyOf.filter(isObject).map(mapTransformNumberByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderBooleanForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderNumberForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "oneOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformBooleanForOneOf (rootSchema, values, params) {
+export function transformNumberForOneOf (rootSchema, values, params) {
   /*
-   *  log('transformBooleanForOneOf')
+   *  log('transformNumberForOneOf')
    */
 
   const {
@@ -422,63 +329,86 @@ export function transformBooleanForOneOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { oneOf = [] } = rootSchema
-  const items = oneOf.map(mapTransformBooleanByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = oneOf.filter(isObject).map(mapTransformNumberByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderBooleanForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderNumberForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "allOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformBooleanForAllOf (rootSchema, values, params) {
+export function transformNumberForAllOf (rootSchema, values, params) {
   /*
-   *  log('transformBooleanForAllOf')
+   *  log('transformNumberForAllOf')
    */
 
-  const { allOf = [], ...rest } = rootSchema
-  const itemSchema = allOf.reduce((accumulator, schema) => Object.assign(accumulator, schema), rest) // initialise with `rest`
+  const {
+    allOf = [],
+    ...schemaProps
+  } = rootSchema
+
+  /**
+   *  @type {SchemaType}
+   */
+  const itemSchema = allOf.filter(isObject).reduce(toSchema, structuredClone(schemaProps)) // initialise with `rest`
 
-  return renderBooleanForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, values, params))
+  return renderNumberForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
+ *
+ *  @link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.1
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-// https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6
-export function transformBoolean (rootSchema, values, params) {
+export function transformNumber (rootSchema, values, params) {
   /*
-   *  log('transformBoolean')
+   *  log('transformNumber')
    */
 
   if (hasEnum(rootSchema)) {
-    return transformBooleanForEnum(rootSchema, values, params)
+    return transformNumberForEnum(rootSchema, values, params)
   } else {
     if (hasAnyOf(rootSchema)) {
-      return transformBooleanForAnyOf(rootSchema, values, params)
+      return transformNumberForAnyOf(rootSchema, values, params)
     } else {
       if (hasOneOf(rootSchema)) {
-        return transformBooleanForOneOf(rootSchema, values, params)
+        return transformNumberForOneOf(rootSchema, values, params)
       } else {
         if (hasAllOf(rootSchema)) {
-          return transformBooleanForAllOf(rootSchema, values, params)
+          return transformNumberForAllOf(rootSchema, values, params)
         }
       }
     }
   }
 
-  return renderBoolean(rootSchema, values, getRenderParams(rootSchema, values, params))
+  return renderNumber(rootSchema, values, getRenderParams(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "enum"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformObjectForEnum (rootSchema, values, params) {
+export function transformArrayForEnum (rootSchema, values, params) {
   /*
-   *  log('renderObjectForEnum')
+   *  log('renderArrayForEnum')
    */
 
   const {
@@ -489,19 +419,24 @@ export function transformObjectForEnum (rootSchema, values, params) {
     selectedItems = getSelectedItems(values, uri) // uri
   } = getMetaProps(params, uri)
 
-  const items = getEnum(rootSchema)
+  const { enum: items = [] } = rootSchema // const items = getEnum(rootSchema)
 
-  return renderObjectForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderArrayForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "anyOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformObjectForAnyOf (rootSchema, values, params) {
+export function transformArrayForAnyOf (rootSchema, values, params) {
   /*
-   *  log('transformObjectForAnyOf')
+   *  log('transformArrayForAnyOf')
    */
 
   const {
@@ -513,19 +448,24 @@ export function transformObjectForAnyOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { anyOf = [] } = rootSchema
-  const items = anyOf.map(mapTransformObjectByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = anyOf.filter(isObject).map(mapTransformArrayByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderObjectForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderArrayForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "oneOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformObjectForOneOf (rootSchema, values, params) {
+export function transformArrayForOneOf (rootSchema, values, params) {
   /*
-   *  log('transformObjectForOneOf')
+   *  log('transformArrayForOneOf')
    */
 
   const {
@@ -537,78 +477,106 @@ export function transformObjectForOneOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { oneOf = [] } = rootSchema
-  const items = oneOf.map(mapTransformObjectByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = oneOf.filter(isObject).map(mapTransformArrayByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderObjectForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderArrayForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "allOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformObjectForAllOf (rootSchema, values, params) {
+export function transformArrayForAllOf (rootSchema, values, params) {
   /*
-   *  log('transformObjectForAllOf')
+   *  log('transformArrayForAllOf')
    */
 
-  const { allOf = [], ...rest } = rootSchema
-  const itemSchema = allOf.reduce((accumulator, schema) => Object.assign(accumulator, schema), rest) // initialise with `rest`
+  const {
+    allOf = [],
+    ...schemaProps
+  } = rootSchema
+
+  /**
+   *  @type {SchemaType}
+   */
+  const itemSchema = allOf.filter(isObject).reduce(toSchema, structuredClone(schemaProps)) // initialise with `rest`
 
-  return renderObjectForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, values, params))
+  return renderArrayForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
+ *
+ *  @link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.4
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-// https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.5
-export function transformObject (rootSchema, values, params) {
+export function transformArray (rootSchema, values, params) {
   /*
-   *  log('transformObject')
+   *  log('transformArray')
    */
 
   if (hasEnum(rootSchema)) {
-    return transformObjectForEnum(rootSchema, values, params)
+    return transformArrayForEnum(rootSchema, values, params)
   } else {
     if (hasAnyOf(rootSchema)) {
-      return transformObjectForAnyOf(rootSchema, values, params)
+      return transformArrayForAnyOf(rootSchema, values, params)
     } else {
       if (hasOneOf(rootSchema)) {
-        return transformObjectForOneOf(rootSchema, values, params)
+        return transformArrayForOneOf(rootSchema, values, params)
       } else {
         if (hasAllOf(rootSchema)) {
-          return transformObjectForAllOf(rootSchema, values, params)
+          return transformArrayForAllOf(rootSchema, values, params)
         }
       }
     }
   }
 
   const {
-    properties = {},
-    required = []
+    items = [] // array or object
   } = rootSchema
 
-  const {
-    uri = '#/'
-  } = params
+  if (isArray(items)) {
+    const fields = (
+      items.map(mapTransformByIndex(rootSchema, values, Object.assign(structuredClone(params), { parentUri: '#/' })))
+    )
 
-  const fields = (
-    Object
-      .entries(properties)
-      .map(mapTransformByKey(rootSchema, values, Object.assign(params, { parentUri: uri, required })))
-  )
+    return renderArray(rootSchema, values, getRenderParams(rootSchema, Object.assign(params, { fields })))
+  } else {
+    if (isObject(items)) {
+      const fields = [
+        getTransformByIndex(items, rootSchema, values, Object.assign(structuredClone(params), { parentUri: '#/' }))
+      ]
+
+      return renderArray(rootSchema, values, getRenderParams(rootSchema, Object.assign(params, { fields })))
+    }
+  }
 
-  return renderObject(rootSchema, values, getRenderParams(rootSchema, values, Object.assign(params, { fields })))
+  throw new Error('Invalid `array`')
 }
 
-/*
+/**
  *  Root schema
  *
  *  "enum"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformArrayForEnum (rootSchema, values, params) {
+export function transformObjectForEnum (rootSchema, values, params) {
   /*
-   *  log('renderArrayForEnum')
+   *  log('renderObjectForEnum')
    */
 
   const {
@@ -619,19 +587,24 @@ export function transformArrayForEnum (rootSchema, values, params) {
     selectedItems = getSelectedItems(values, uri) // uri
   } = getMetaProps(params, uri)
 
-  const items = getEnum(rootSchema)
+  const { enum: items = [] } = rootSchema // const items = getEnum(rootSchema)
 
-  return renderArrayForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderObjectForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "anyOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformArrayForAnyOf (rootSchema, values, params) {
+export function transformObjectForAnyOf (rootSchema, values, params) {
   /*
-   *  log('transformArrayForAnyOf')
+   *  log('transformObjectForAnyOf')
    */
 
   const {
@@ -643,19 +616,24 @@ export function transformArrayForAnyOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { anyOf = [] } = rootSchema
-  const items = anyOf.map(mapTransformArrayByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = anyOf.filter(isObject).map(mapTransformObjectByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderArrayForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderObjectForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "oneOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformArrayForOneOf (rootSchema, values, params) {
+export function transformObjectForOneOf (rootSchema, values, params) {
   /*
-   *  log('transformArrayForOneOf')
+   *  log('transformObjectForOneOf')
    */
 
   const {
@@ -667,81 +645,101 @@ export function transformArrayForOneOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { oneOf = [] } = rootSchema
-  const items = oneOf.map(mapTransformArrayByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = oneOf.filter(isObject).map(mapTransformObjectByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderArrayForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderObjectForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "allOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformArrayForAllOf (rootSchema, values, params) {
+export function transformObjectForAllOf (rootSchema, values, params) {
   /*
-   *  log('transformArrayForAllOf')
+   *  log('transformObjectForAllOf')
    */
 
-  const { allOf = [], ...rest } = rootSchema
-  const itemSchema = allOf.reduce((accumulator, schema) => Object.assign(accumulator, schema), rest) // initialise with `rest`
+  const {
+    allOf = [],
+    ...schemaProps
+  } = rootSchema
+
+  /**
+   *  @type {SchemaType}
+   */
+  const itemSchema = allOf.filter(isObject).reduce(toSchema, structuredClone(schemaProps)) // initialise with `rest`
 
-  return renderArrayForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, values, params))
+  return renderObjectForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
+ *
+ *  @link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.5
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-// https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.4
-export function transformArray (rootSchema, values, params) {
+export function transformObject (rootSchema, values, params) {
   /*
-   *  log('transformArray')
+   *  log('transformObject')
    */
 
   if (hasEnum(rootSchema)) {
-    return transformArrayForEnum(rootSchema, values, params)
+    return transformObjectForEnum(rootSchema, values, params)
   } else {
     if (hasAnyOf(rootSchema)) {
-      return transformArrayForAnyOf(rootSchema, values, params)
+      return transformObjectForAnyOf(rootSchema, values, params)
     } else {
       if (hasOneOf(rootSchema)) {
-        return transformArrayForOneOf(rootSchema, values, params)
+        return transformObjectForOneOf(rootSchema, values, params)
       } else {
         if (hasAllOf(rootSchema)) {
-          return transformArrayForAllOf(rootSchema, values, params)
+          return transformObjectForAllOf(rootSchema, values, params)
         }
       }
     }
   }
 
   const {
-    items = [] // array or object
+    properties = {},
+    required = []
   } = rootSchema
 
-  if (isArray(items)) {
-    const fields = (
-      items.map(mapTransformByIndex(rootSchema, values, Object.assign(params, { parentUri: '#/' })))
-    )
+  const {
+    uri = '#/'
+  } = params
 
-    return renderArray(rootSchema, values, getRenderParams(rootSchema, values, Object.assign(params, { fields })))
-  } else {
-    if (isObject(items)) {
-      const fields = [
-        getTransformByIndex(items, rootSchema, values, Object.assign(params, { parentUri: '#/' }))
-      ]
+  const fields = (
+    Object
+      .entries(properties)
+      .map(mapTransformByKey(rootSchema, values, Object.assign(structuredClone(params), { parentUri: uri, required })))
+  )
 
-      return renderArray(rootSchema, values, getRenderParams(rootSchema, values, Object.assign(params, { fields })))
-    }
-  }
+  return renderObject(rootSchema, values, getRenderParams(rootSchema, Object.assign(params, { fields })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "enum"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNumberForEnum (rootSchema, values, params) {
+export function transformBooleanForEnum (rootSchema, values, params) {
   /*
-   *  log('transformNumberForEnum')
+   *  log('transformBooleanForEnum')
    */
 
   const {
@@ -752,19 +750,24 @@ export function transformNumberForEnum (rootSchema, values, params) {
     selectedItems = getSelectedItems(values, uri) // uri
   } = getMetaProps(params, uri)
 
-  const items = getEnum(rootSchema)
+  const { enum: items = [] } = rootSchema // const items = getEnum(rootSchema)
 
-  return renderNumberForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderBooleanForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "anyOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNumberForAnyOf (rootSchema, values, params) {
+export function transformBooleanForAnyOf (rootSchema, values, params) {
   /*
-   *  log('transformNumberForAnyOf')
+   *  log('transformBooleanForAnyOf')
    */
 
   const {
@@ -776,19 +779,24 @@ export function transformNumberForAnyOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { anyOf = [] } = rootSchema
-  const items = anyOf.map(mapTransformNumberByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = anyOf.filter(isObject).map(mapTransformBooleanByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderNumberForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderBooleanForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "oneOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNumberForOneOf (rootSchema, values, params) {
+export function transformBooleanForOneOf (rootSchema, values, params) {
   /*
-   *  log('transformNumberForOneOf')
+   *  log('transformBooleanForOneOf')
    */
 
   const {
@@ -800,63 +808,86 @@ export function transformNumberForOneOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { oneOf = [] } = rootSchema
-  const items = oneOf.map(mapTransformNumberByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = oneOf.filter(isObject).map(mapTransformBooleanByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderNumberForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderBooleanForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "allOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformNumberForAllOf (rootSchema, values, params) {
+export function transformBooleanForAllOf (rootSchema, values, params) {
   /*
-   *  log('transformNumberForAllOf')
+   *  log('transformBooleanForAllOf')
    */
 
-  const { allOf = [], ...rest } = rootSchema
-  const itemSchema = allOf.reduce((accumulator, schema) => Object.assign(accumulator, schema), rest) // initialise with `rest`
+  const {
+    allOf = [],
+    ...schemaProps
+  } = rootSchema
+
+  /**
+   *  @type {SchemaType}
+   */
+  const itemSchema = allOf.filter(isObject).reduce(toSchema, structuredClone(schemaProps)) // initialise with `rest`
 
-  return renderNumberForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, values, params))
+  return renderBooleanForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
+ *
+ *  @link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-// https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.1
-export function transformNumber (rootSchema, values, params) {
+export function transformBoolean (rootSchema, values, params) {
   /*
-   *  log('transformNumber')
+   *  log('transformBoolean')
    */
 
   if (hasEnum(rootSchema)) {
-    return transformNumberForEnum(rootSchema, values, params)
+    return transformBooleanForEnum(rootSchema, values, params)
   } else {
     if (hasAnyOf(rootSchema)) {
-      return transformNumberForAnyOf(rootSchema, values, params)
+      return transformBooleanForAnyOf(rootSchema, values, params)
     } else {
       if (hasOneOf(rootSchema)) {
-        return transformNumberForOneOf(rootSchema, values, params)
+        return transformBooleanForOneOf(rootSchema, values, params)
       } else {
         if (hasAllOf(rootSchema)) {
-          return transformNumberForAllOf(rootSchema, values, params)
+          return transformBooleanForAllOf(rootSchema, values, params)
         }
       }
     }
   }
 
-  return renderNumber(rootSchema, values, getRenderParams(rootSchema, values, params))
+  return renderBoolean(rootSchema, values, getRenderParams(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "enum"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformStringForEnum (rootSchema, values, params) {
+export function transformNullForEnum (rootSchema, values, params) {
   /*
-   *  log('transformStringForEnum')
+   *  log('transformNullForEnum')
    */
 
   const {
@@ -867,19 +898,24 @@ export function transformStringForEnum (rootSchema, values, params) {
     selectedItems = getSelectedItems(values, uri) // uri
   } = getMetaProps(params, uri)
 
-  const items = getEnum(rootSchema)
+  const { enum: items = [] } = rootSchema // const items = getEnum(rootSchema)
 
-  return renderStringForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderNullForEnum(rootSchema, values, getRenderParamsForEnum(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "anyOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformStringForAnyOf (rootSchema, values, params) {
+export function transformNullForAnyOf (rootSchema, values, params) {
   /*
-   *  log('transformStringForAnyOf')
+   *  log('transformNullForAnyOf')
    */
 
   const {
@@ -891,19 +927,24 @@ export function transformStringForAnyOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { anyOf = [] } = rootSchema
-  const items = anyOf.map(mapTransformStringByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = anyOf.filter(isObject).map(mapTransformNullByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderStringForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderNullForAnyOf(rootSchema, values, getRenderParamsForAnyOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "oneOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformStringForOneOf (rootSchema, values, params) {
+export function transformNullForOneOf (rootSchema, values, params) {
   /*
-   *  log('transformStringForOneOf')
+   *  log('transformNullForOneOf')
    */
 
   const {
@@ -915,55 +956,79 @@ export function transformStringForOneOf (rootSchema, values, params) {
   } = getMetaProps(params, uri)
 
   const { oneOf = [] } = rootSchema
-  const items = oneOf.map(mapTransformStringByIndex(rootSchema, values, Object.assign(params, { selectedItems, parentUri: uri })))
+  const items = oneOf.filter(isObject).map(mapTransformNullByIndex(rootSchema, values, Object.assign(structuredClone(params), { selectedItems, parentUri: uri })))
 
-  return renderStringForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, values, Object.assign(params, { selectedItems, items })))
+  return renderNullForOneOf(rootSchema, values, getRenderParamsForOneOf(rootSchema, Object.assign(params, { selectedItems, items })))
 }
 
-/*
+/**
  *  Root schema
  *
  *  "allOf"
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-export function transformStringForAllOf (rootSchema, values, params) {
+export function transformNullForAllOf (rootSchema, values, params) {
   /*
-   *  log('transformStringForAllOf')
+   *  log('transformNullForAllOf')
    */
 
-  const { allOf = [], ...rest } = rootSchema
-  const itemSchema = allOf.reduce((accumulator, schema) => Object.assign(accumulator, schema), rest) // initialise with `rest`
+  const {
+    allOf = [],
+    ...schemaProps
+  } = rootSchema
+
+  /**
+   *  @type {SchemaType}
+   */
+  const itemSchema = allOf.filter(isObject).reduce(toSchema, structuredClone(schemaProps)) // initialise with `rest`
 
-  return renderStringForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, values, params))
+  return renderNullForAllOf(itemSchema, values, getRenderParamsForAllOf(rootSchema, params))
 }
 
-/*
+/**
  *  Root schema
+ *
+ *  @link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6
+ *
+ *  @param {SchemaType} rootSchema
+ *  @param {ValuesType} values
+ *  @param {ParamsType} params
+ *  @returns {ZashikiType}
  */
-// https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.3
-export function transformString (rootSchema, values, params) {
+export function transformNull (rootSchema, values, params) {
   /*
-   *  log('transformString')
+   *  log('transformNull')
    */
 
   if (hasEnum(rootSchema)) {
-    return transformStringForEnum(rootSchema, values, params)
+    return transformNullForEnum(rootSchema, values, params)
   } else {
     if (hasAnyOf(rootSchema)) {
-      return transformStringForAnyOf(rootSchema, values, params)
+      return transformNullForAnyOf(rootSchema, values, params)
     } else {
       if (hasOneOf(rootSchema)) {
-        return transformStringForOneOf(rootSchema, values, params)
+        return transformNullForOneOf(rootSchema, values, params)
       } else {
         if (hasAllOf(rootSchema)) {
-          return transformStringForAllOf(rootSchema, values, params)
+          return transformNullForAllOf(rootSchema, values, params)
         }
       }
     }
   }
 
-  return renderString(rootSchema, values, getRenderParams(rootSchema, values, params))
+  return renderNull(rootSchema, values, getRenderParams(rootSchema, params))
 }
 
+/**
+ *  @param {SchemaType} [rootSchema]
+ *  @param {ValuesType} [values]
+ *  @param {ParamsType} [params]
+ *  @returns {ZashikiType}
+ */
 export default function toZashiki (rootSchema = {}, values = {}, params = {}) {
   log('toZashiki')
 
@@ -971,25 +1036,24 @@ export default function toZashiki (rootSchema = {}, values = {}, params = {}) {
 
   // https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1
   switch (type) {
-    case 'null':
-      return transformNull(rootSchema, values, params)
-
-    case 'boolean':
-      return transformBoolean(rootSchema, values, params)
+    case 'string':
+      return transformString(rootSchema, values, params)
 
-    case 'object':
-      return transformObject(rootSchema, values, params)
+    case 'number':
+      return transformNumber(rootSchema, values, params)
 
     case 'array':
       return transformArray(rootSchema, values, params)
 
-    case 'number':
-      return transformNumber(rootSchema, values, params)
+    case 'object':
+      return transformObject(rootSchema, values, params)
 
-    case 'string':
-      return transformString(rootSchema, values, params)
+    case 'boolean':
+      return transformBoolean(rootSchema, values, params)
 
-    default:
-      throw new Error('Schema does not conform to Instance Data Model, https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1')
+    case 'null':
+      return transformNull(rootSchema, values, params)
   }
+
+  throw new Error('Schema does not conform to Instance Data Model, https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1')
 }