shinkansen-transmission 2.2.235 → 2.3.1

package/src/transmission/common/index.mjs

@@ -1,3 +1,41 @@
+/**
+ *  @typedef {TransmissionTypes.ObjectLiteralType} ObjectLiteralType
+ *  @typedef {TransmissionTypes.ObjectType} ObjectType
+ *
+ *  @typedef {TransmissionTypes.ItemsType} ItemsType
+ *
+ *  @typedef {TransmissionTypes.Transmission.StringMetaType} TransmissionStringMetaType
+ *  @typedef {TransmissionTypes.Transmission.NumberMetaType} TransmissionNumberMetaType
+ *  @typedef {TransmissionTypes.Transmission.ArrayMetaType} TransmissionArrayMetaType
+ *  @typedef {TransmissionTypes.Transmission.ObjectMetaType} TransmissionObjectMetaType
+ *  @typedef {TransmissionTypes.Transmission.BooleanMetaType} TransmissionBooleanMetaType
+ *  @typedef {TransmissionTypes.Transmission.NullMetaType} TransmissionNullMetaType
+ *
+ *  @typedef {TransmissionTypes.Transmission.StringElementsType} TransmissionStringElementsType
+ *  @typedef {TransmissionTypes.Transmission.NumberElementsType} TransmissionNumberElementsType
+ *  @typedef {TransmissionTypes.Transmission.ArrayElementsType} TransmissionArrayElementsType
+ *  @typedef {TransmissionTypes.Transmission.ObjectElementsType} TransmissionObjectElementsType
+ *  @typedef {TransmissionTypes.Transmission.BooleanElementsType} TransmissionBooleanElementsType
+ *  @typedef {TransmissionTypes.Transmission.NullElementsType} TransmissionNullElementsType
+ *
+ *  @typedef {TransmissionTypes.EnumType} EnumType
+ *  @typedef {TransmissionTypes.AnyOfType} AnyOfType
+ *  @typedef {TransmissionTypes.OneOfType} OneOfType
+ *  @typedef {TransmissionTypes.FieldType} FieldType
+ *
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *
+ *  @typedef {TransmissionTypes.StringSchemaType} StringSchemaType
+ *  @typedef {TransmissionTypes.NumberSchemaType} NumberSchemaType
+ *  @typedef {TransmissionTypes.ArraySchemaType} ArraySchemaType
+ *  @typedef {TransmissionTypes.ObjectSchemaType} ObjectSchemaType
+ *  @typedef {TransmissionTypes.BooleanSchemaType} BooleanSchemaType
+ *  @typedef {TransmissionTypes.NullSchemaType} NullSchemaType
+ *
+ *  @typedef {TransmissionTypes.ValuesType} ValuesType
+ *  @typedef {TransmissionTypes.ParamsType} ParamsType
+ */
+
 import debug from 'debug'
 
 import equal from 'fast-deep-equal'
@@ -6,41 +44,111 @@ const log = debug('shinkansen-transmission/transmission/common')
 
 log('`shinkansen` is awake')
 
+/**
+ *  @param {unknown} [v]
+ *  @returns {v is (Record<PropertyKey, string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]> | Record<PropertyKey, never>)}
+ */
 export const isObject = (v) => (v || false) instanceof Object && !isArray(v)
 
+/**
+ *  @param {unknown} [v]
+ *  @returns {v is (string[] | number[] | object[] | boolean[] | null[])} //  | SchemaType)[]}
+ */
 export const isArray = (v) => Array.isArray(v)
 
+/**
+ *  @param {unknown} [v]
+ *  @returns {v is (string | number | boolean | null)}
+ */
 export const isPrimitive = (v) => !isObject(v) && !isArray(v)
 
-export const isSchema = (v = {}) => Reflect.has(v, 'type')
+/**
+ *  @param {SchemaType | object} [v]
+ *  @returns {v is SchemaType}
+ */
+export const isSchema = (v = {}) => 'type' in v // Reflect.has(v, 'type')
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {schema is StringSchemaType}
+ */
 export const isStringSchema = ({ type } = {}) => type === 'string'
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {schema is NumberSchemaType}
+ */
 export const isNumberSchema = ({ type } = {}) => type === 'number'
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {schema is ArraySchemaType}
+ */
 export const isArraySchema = ({ type } = {}) => type === 'array'
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {schema is ObjectSchemaType}
+ */
 export const isObjectSchema = ({ type } = {}) => type === 'object'
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {schema is BooleanSchemaType}
+ */
 export const isBooleanSchema = ({ type } = {}) => type === 'boolean'
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {schema is NullSchemaType}
+ */
 export const isNullSchema = ({ type } = {}) => type === 'null'
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {{ title: string} | {}}
+ */
 export const getTitle = ({ title } = {}) => (title ? { title } : {})
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {{ description: string} | {}}
+ */
 export const getDescription = ({ description } = {}) => (description ? { description } : {})
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {{ readOnly: boolean } | {}}
+ */
 export const getIsReadOnly = ({ readOnly = false } = {}) => (readOnly ? { readOnly } : {})
 
+/**
+ *  @param {SchemaType} schema
+ *  @returns {{ writeOnly: boolean } | {}}
+ */
 export const getIsWriteOnly = ({ writeOnly = false } = {}) => (writeOnly ? { writeOnly } : {})
 
-const getUriForRegExp = (uri) => uri.endsWith('/') ? uri : uri.concat('/')
-
+/**
+ *  @param {string} uri
+ *  @returns {string}
+ */
+const getUriForRegExp = (uri) => uri.endsWith('/') ? uri : uri + '/'
+
+/**
+ *  @param {Record<string, string | number | boolean | null | string[] | number[] | boolean[] | null[]>} [values]
+ *  @param {string} [uri]
+ *  @returns {(
+ *    string |
+ *    number |
+ *    boolean |
+ *    null
+ *  )[]}
+ */
 export function getSelectedItems (values = {}, uri = '#') {
   const u = normaliseUri(uri)
 
-  if (Reflect.has(values, u)) {
-    const v = Reflect.get(values, u)
+  if (u in values) { // if (Reflect.has(values, u)) {
+    const v = values[u] // Reflect.get(values, u)
 
     // transformByKeyForEnum
     // transformByKeyForAnyOf
@@ -83,12 +191,18 @@ export function getSelectedItems (values = {}, uri = '#') {
         const v = isArray(value) ? value[i] : value
         const n = Number(v)
 
-        if (!isNaN(n)) return n
-        return v
+        return isNaN(n)
+          ? v
+          : n
       })
   )
 }
 
+/**
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {boolean}
+ */
 export function isParentUri (parentUri = '#', uri = '#') {
   return (
     parentUri !== '#' &&
@@ -96,20 +210,44 @@ export function isParentUri (parentUri = '#', uri = '#') {
   )
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {TransmissionStringMetaType | TransmissionNumberMetaType | TransmissionArrayMetaType | TransmissionObjectMetaType | TransmissionBooleanMetaType | TransmissionNullMetaType | Record<string, never>}
+ */
 export function getMetaProps (params = {}, uri = '#') {
-  let meta
-  if (Reflect.has(params, uri)) {
-    ({
-      meta
-    } = Reflect.get(params, uri))
+  if (uri in params) { // if (Reflect.has(params, uri)) {
+    const {
+      meta = {}
+    } = params[uri] // Reflect.get(params, uri))
+
+    return meta
+  }
+
+  return {}
+}
+
+/**
+ *  @param {SchemaType} [schema]
+ *  @returns {boolean}
+ */
+export function hasMetaDefaultValue (schema = {}) {
+  if ('default' in schema) { // if (Reflect.has(schema, 'default') {
+    const defaultValue = schema.default // Reflect.get(schema, 'default')
+
+    return isPrimitive(defaultValue)
   }
 
-  return meta || {}
+  return false
 }
 
+/**
+ *  @param {SchemaType} [schema]
+ *  @returns {{ defaultValue: string } | {}}
+ */
 export function getMetaDefaultValue (schema = {}) {
-  if (Reflect.has(schema, 'default')) {
-    const defaultValue = Reflect.get(schema, 'default')
+  if ('default' in schema) { // if (Reflect.has(schema, 'default') {
+    const defaultValue = schema.default // Reflect.get(schema, 'default')
 
     return { defaultValue: String(defaultValue) }
   }
@@ -117,15 +255,21 @@ export function getMetaDefaultValue (schema = {}) {
   return {}
 }
 
+/**
+ *  @param {ValuesType} [values]
+ *  @param {string} [uri]
+ *  @param {SchemaType} [schema]
+ *  @returns {boolean}
+ */
 export function hasMetaValue (values = {}, uri = '#', schema = {}) {
-  if (Reflect.has(values, uri)) {
-    const value = Reflect.get(values, uri)
+  if (uri in values) { // Reflect.has(values, uri)) {
+    const value = values[uri] // Reflect.get(values, uri)
 
     return isPrimitive(value)
   }
 
-  if (Reflect.has(schema, 'const')) {
-    const constValue = Reflect.get(schema, 'const')
+  if ('const' in schema) { // Reflect.has(schema, 'const')) {
+    const constValue = schema.const // Reflect.get(schema, 'const')
 
     return isPrimitive(constValue)
   }
@@ -133,17 +277,23 @@ export function hasMetaValue (values = {}, uri = '#', schema = {}) {
   return false
 }
 
+/**
+ *  @param {ValuesType} [values]
+ *  @param {string} [uri]
+ *  @param {SchemaType} [schema]
+ *  @returns {{ value: string } | {}}
+ */
 export function getMetaValue (values = {}, uri = '#', schema = {}) {
-  if (Reflect.has(values, uri)) {
-    const value = Reflect.get(values, uri)
+  if (uri in values) { // if (Reflect.has(values, uri)) {
+    const value = values[uri] // Reflect.get(values, uri)
 
     if (isPrimitive(value)) {
       return { value: String(value) }
     }
   }
 
-  if (Reflect.has(schema, 'const')) {
-    const constValue = Reflect.get(schema, 'const')
+  if ('const' in schema) { // if (Reflect.has(schema, 'const')) {
+    const constValue = schema.const // Reflect.get(schema, 'const')
 
     if (isPrimitive(constValue)) {
       return { value: String(constValue) }
@@ -153,18 +303,31 @@ export function getMetaValue (values = {}, uri = '#', schema = {}) {
   return {}
 }
 
-export function transformValue (schema) {
-  return (
-    isObject(schema)
-      ? hasConst(schema)
-        ? getConst(schema)
-        : hasDefault(schema)
-          ? getDefault(schema)
-          : schema
-      : schema
-  )
+/**
+ *  @param {string | number | object | boolean | null} [item]
+ *  @returns {string | number | object | boolean | null | undefined}
+ */
+export function transformToValue (item) {
+  if (isPrimitive(item)) return item
+
+  if (isObject(item)) {
+    if (hasConst(item)) {
+      return getConst(item)
+    } else {
+      if (hasDefault(item)) {
+        return getDefault(item)
+      }
+    }
+  }
+
+  return item
 }
 
+/**
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {(key: string | number) => boolean}
+ */
 export function findByKey (parentUri, uri) {
   /*
    *  log('findByKey')
@@ -173,62 +336,106 @@ export function findByKey (parentUri, uri) {
     /*
      *  log('find')
      */
-    return getUri(parentUri, key) === uri
+
+    return (
+      getUri(parentUri, key) === uri
+    )
   }
 }
 
+/**
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {(item: SchemaType, index: number) => boolean}
+ */
 export function findByIndex (parentUri, uri) {
   /*
    *  log('findByIndex')
    */
-  return function find (schema, index) {
+  return function find (item, index) {
     /*
      *  log('find')
      */
-    if (hasEnum(schema)) {
-      return getUri(parentUri, index) === uri
-    }
 
-    if (hasAnyOf(schema)) {
-      const array = getAnyOf(schema)
+    /**
+     *  It's a schema not a value
+     */
 
-      return array.find(findByIndex(parentUri, uri))
+    if (hasEnum(item)) {
+      /**
+       *  Do the `parentUri` and `uri` match?
+       */
+
+      return (
+        getUri(parentUri, index) === uri
+      )
+    } else {
+      if (hasAnyOf(item)) {
+        const array = getAnyOf(item)
+
+        return (
+          array.filter(isObject).some(findByIndex(parentUri, uri))
+        )
+      } else {
+        if (hasOneOf(item)) {
+          const array = getOneOf(item)
+
+          return (
+            array.filter(isObject).some(findByIndex(parentUri, uri))
+          )
+        }
+      }
     }
 
-    if (hasOneOf(schema)) {
-      const array = getOneOf(schema)
-
-      return array.find(findByIndex(parentUri, uri))
-    }
+    /**
+     *  It's any other kind of schema/sub-schema
+     */
 
-    return getUri(parentUri, index) === uri
+    return (
+      getUri(parentUri, index) === uri
+    )
   }
 }
 
+/**
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {(item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean}
+ */
 export function findByValue (value) {
   /*
    *  log('findByValue')
    */
-  return function find (schema) {
+  return function find (item) {
     /*
      *  log('find')
      */
-    return value === transformValue(schema)
+
+    return (
+      value === transformToValue(item)
+    )
   }
 }
 
+/**
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {(item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean}
+ */
 export function findByEqual (value) {
   /*
    *  log('findByEqual')
    */
-  return function find (schema) {
+  return function find (item) {
     /*
      *  log('find')
      */
-    return equal(value, transformValue(schema))
+    return equal(value, transformToValue(item))
   }
 }
 
+/**
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {string}
+ */
 export function toString (value) {
   /*
    *  log('toString')
@@ -236,57 +443,114 @@ export function toString (value) {
   return (value !== undefined) ? String(value) : ''
 }
 
-export function getObject ({ properties = {} /* object */ } = {}, parentUri = '', uri = '') {
+/**
+ *  @param {{ items?: SchemaType | SchemaType[] }} [schema]
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {SchemaType | undefined}
+ */
+export function getArray ({ items /* array or object */ } = {}, parentUri = '', uri = '') {
   /*
-   *  log('getObject')
+   *  log('getArray')
    */
-  return (
-    Reflect.get(properties, (
-      Object.keys(properties)
-        .find(findByKey(parentUri, uri))
-    ))
-  )
+
+  if (isArray(items)) {
+    const find = findByIndex(parentUri, uri)
+
+    return (
+      items.find(find)
+    )
+  }
+
+  if (isObject(items)) return items
+
+  return undefined
 }
 
-export function getArray ({ items = {} /* array or object */ } = {}, parentUri = '', uri = '') {
+/**
+ *  @param {{ properties?: Record<string, SchemaType> }} [schema]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {SchemaType | undefined}
+ */
+export function getObject ({ properties /* object */ } = {}, parentUri = '', uri = '') {
   /*
-   *  log('getArray')
+   *  log('getObject')
    */
-  return (isArray(items))
-    ? items.find(findByIndex(parentUri, uri))
-    : items
+
+  if (isObject(properties)) {
+    const find = findByKey(parentUri, uri)
+    const key = Object.keys(properties).find(find)
+
+    if (key) {
+      return (
+        properties[key]
+      )
+    }
+  }
+
+  return undefined
 }
 
+/**
+ *  @overload
+ *  @param {(
+ *    StringSchemaType |
+ *    NumberSchemaType |
+ *    ArraySchemaType |
+ *    ObjectSchemaType |
+ *    BooleanSchemaType |
+ *    NullSchemaType
+ *  )} schema
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {SchemaType | undefined}
+ *
+ *
+ *  @param {*} [schema]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {* | undefined}
+ */
 export function getSchema (schema = {}, parentUri = '', uri = '') {
   /*
    *  log('getSchema')
    */
-  const { type } = schema
 
-  switch (type) {
-    case 'object':
-      return getObject(schema, parentUri, uri)
+  const {
+    type
+  } = schema
 
+  switch (type) {
     case 'array':
       return getArray(schema, parentUri, uri)
 
+    case 'object':
+      return getObject(schema, parentUri, uri)
+
     default:
       return schema
   }
 }
 
+/**
+ *  @param {string[] | number[] | object[] | boolean[] | null[]} array
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {string}
+ */
 export function transformValueIndexFor (array, value) {
   /*
-   *  log('transformValueIndexFor')
+   *  log('transformEqualIndexFor')
    */
+
   const find = findByValue(value)
 
   if (array.some(find)) {
     const index = array.findIndex(find)
 
     /*
-     *  Transform a number to a string
-     */
+      *  Transform a number to a string
+      */
     return String(index)
   }
 
@@ -296,10 +560,16 @@ export function transformValueIndexFor (array, value) {
   return toString(value)
 }
 
+/**
+ *  @param {string[] | number[] | object[] | boolean[] | null[]} array
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {string}
+ */
 export function transformEqualIndexFor (array, value) {
   /*
    *  log('transformEqualIndexFor')
    */
+
   const find = findByEqual(value)
 
   if (array.some(find)) {
@@ -317,15 +587,21 @@ export function transformEqualIndexFor (array, value) {
   return toString(value)
 }
 
+/**
+ *  @param {ValuesType} [values]
+ *  @param {string} [uri]
+ *  @param {SchemaType} [schema]
+ *  @returns {boolean}
+ */
 export function hasValue (values = {}, uri = '#', schema = {}) {
-  if (Reflect.has(values, uri)) {
-    const value = Reflect.get(values, uri)
+  if (uri in values) { // if (Reflect.has(values, uri)) {
+    const value = values[uri] // Reflect.get(values, uri)
 
     return isPrimitive(value)
   }
 
-  if (Reflect.has(schema, 'const')) {
-    const constValue = Reflect.get(schema, 'const')
+  if ('const' in schema) { // if (Reflect.has(schema, 'const')) {
+    const constValue = schema.const // Reflect.get(schema, 'const')
 
     return isPrimitive(constValue)
   }
@@ -333,34 +609,53 @@ export function hasValue (values = {}, uri = '#', schema = {}) {
   return false
 }
 
+/**
+ *  @param {ValuesType} [values]
+ *  @param {string} [uri]
+ *  @param {SchemaType} [schema]
+ *  @returns {string}
+ */
 export function getValue (values = {}, uri = '#', schema = {}) {
-  if (Reflect.has(values, uri)) {
-    const value = Reflect.get(values, uri)
+  if (uri in values) { // if (Reflect.has(values, uri)) {
+    const value = values[uri] // Reflect.get(values, uri)
 
     if (isPrimitive(value)) {
       return String(value)
     }
   }
 
-  if (Reflect.has(schema, 'const')) {
-    const constValue = Reflect.get(schema, 'const')
+  if ('const' in schema) { // if (Reflect.has(schema, 'const')) {
+    const constValue = schema.const // Reflect.get(schema, 'const')
 
     if (isPrimitive(constValue)) {
       return String(constValue)
     }
   }
+
+  return ''
 }
 
+/**
+ *  @deprecated
+ *
+ *  @param {string | number} v
+ *  @param {{ enum?: ItemsType }} [schema]
+ *  @returns {string}
+ */
 export function getValueForEnum (v, { enum: items = [] } = {}) {
-  if (Reflect.has(items, v)) {
-    const enumValue = Reflect.get(items, v)
+  if (v in items) { // @ts-ignore // if (Reflect.has(items, v)) {
+    const enumValue = items[v] // Reflect.get(items, v)
 
     return String(enumValue)
   }
+
+  return ''
 }
 
-/*
+/**
  *  Use `index` `item` `arrayIndex`
+ *
+ *  @deprecated
  */
 export function getIndexForEnum (values = {}, parentUri = '#', uri = '#', schema = {}) {
   if (/\/\d+$/.test(uri)) {
@@ -373,20 +668,31 @@ export function getIndexForEnum (values = {}, parentUri = '#', uri = '#', schema
   return NaN
 }
 
+/**
+ *  @deprecated
+ *
+ *  @param {string | number} v
+ *  @param {{ anyOf?: ItemsType }} [schema]
+ *  @returns {string}
+ */
 export function getValueForAnyOf (v, { anyOf: items = [] } = {}) {
-  if (Reflect.has(items, v)) {
-    const anyOf = Reflect.get(items, v)
+  if (v in items) { // @ts-ignore // if (Reflect.has(items, v)) {
+    const anyOf = items[v] // Reflect.get(items, v)
 
-    const anyOfValue = transformValue(anyOf)
+    const anyOfValue = transformToValue(anyOf)
 
     if (isPrimitive(anyOfValue)) {
       return String(anyOfValue)
     }
   }
+
+  return ''
 }
 
-/*
+/**
  *  Use `index` `item` `arrayIndex`
+ *
+ *  @deprecated
  */
 export function getIndexForAnyOf (values = {}, parentUri = '#', uri = '#', schema = {}) {
   if (/\/\d+$/.test(uri)) {
@@ -399,20 +705,31 @@ export function getIndexForAnyOf (values = {}, parentUri = '#', uri = '#', schem
   return NaN
 }
 
+/**
+ *  @deprecated
+ *
+ *  @param {string | number} v
+ *  @param {{ oneOf?: ItemsType }} [schema]
+ *  @returns {string}
+ */
 export function getValueForOneOf (v, { oneOf: items = [] } = {}) {
-  if (Reflect.has(items, v)) {
-    const oneOf = Reflect.get(items, v)
+  if (v in items) { // @ts-ignore // if (Reflect.has(items, v)) {
+    const oneOf = items[v] // Reflect.get(items, v)
 
-    const oneOfValue = transformValue(oneOf)
+    const oneOfValue = transformToValue(oneOf)
 
     if (isPrimitive(oneOfValue)) {
       return String(oneOfValue)
     }
   }
+
+  return ''
 }
 
-/*
+/**
  *  Use `index` `item` `arrayIndex`
+ *
+ *  @deprecated
  */
 export function getIndexForOneOf (values = {}, parentUri = '#', uri = '#', schema = {}) {
   if (/\/\d+$/.test(uri)) {
@@ -425,127 +742,158 @@ export function getIndexForOneOf (values = {}, parentUri = '#', uri = '#', schem
   return NaN
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {TransmissionStringElementsType | TransmissionNumberElementsType | TransmissionArrayElementsType | TransmissionObjectElementsType | TransmissionBooleanElementsType | TransmissionNullElementsType | Record<string, never>}
+ */
 export function getElementsProps (params = {}, uri = '#') {
-  let elements
-  if (Reflect.has(params, uri)) {
-    ({
+  if (uri in params) { // if (Reflect.has(values, uri)) {
+    const {
       elements = {}
-    } = Reflect.get(params, uri))
-  }
+    } = params[uri] // Reflect.get(values, uri)
 
-  return elements || {}
-}
-
-export function getElementsTitleProps (params = {}, uri = '#') {
-  let title
-  if (Reflect.has(params, uri)) {
-    ({
-      elements: {
-        title
-      } = {}
-    } = Reflect.get(params, uri))
-  }
-
-  return title || {}
-}
-
-export function getElementsDescriptionProps (params = {}, uri = '#') {
-  let description
-  if (Reflect.has(params, uri)) {
-    ({
-      elements: {
-        description
-      } = {}
-    } = Reflect.get(params, uri))
+    return elements
   }
 
-  return description || {}
+  return {}
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {EnumType | ObjectLiteralType}
+ */
 export function getElementsFieldPropsForEnum (params = {}, uri = '#') {
-  let field
-  if (Reflect.has(params, uri)) {
-    ({
+  if (uri in params) { // if (Reflect.has(values, uri)) {
+    /**
+     *  @type {{ elements?: { enum?: EnumType | ObjectLiteralType } }}
+     */
+    const {
       elements: {
-        enum: field
+        enum: value = {}
       } = {}
-    } = Reflect.get(params, uri))
+    } = params[uri] // Reflect.get(values, uri)
+
+    return value
   }
 
-  return field || {}
+  return {}
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {OneOfType | ObjectLiteralType}
+ */
 export function getElementsFieldPropsForOneOf (params = {}, uri = '#') {
-  let field
-  if (Reflect.has(params, uri)) {
-    ({
+  if (uri in params) { // if (Reflect.has(values, uri)) {
+    /**
+     *  @type {{ elements?: { oneOf?: OneOfType | ObjectLiteralType } }}
+     */
+    const {
       elements: {
-        oneOf: field
+        oneOf: value = {}
       } = {}
-    } = Reflect.get(params, uri))
+    } = params[uri] // Reflect.get(values, uri)
+
+    return value
   }
 
-  return field || {}
+  return {}
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {AnyOfType | ObjectLiteralType}
+ */
 export function getElementsFieldPropsForAnyOf (params = {}, uri = '#') {
-  let field
-  if (Reflect.has(params, uri)) {
-    ({
+  if (uri in params) { // if (Reflect.has(values, uri)) {
+    /**
+     *  @type {{ elements?: { anyOf?: AnyOfType | ObjectLiteralType } }}
+     */
+    const {
       elements: {
-        anyOf: field
+        anyOf: value = {}
       } = {}
-    } = Reflect.get(params, uri))
+    } = params[uri] // Reflect.get(values, uri)
+
+    return value
   }
 
-  return field || {}
+  return {}
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {FieldType | ObjectLiteralType}
+ */
 export function getElementsFieldPropsForAllOf (params = {}, uri = '#') {
-  let field
-  if (Reflect.has(params, uri)) {
-    ({
+  if (uri in params) { // if (Reflect.has(values, uri)) {
+    /**
+     *  @type {{ elements?: { field?: FieldType | ObjectLiteralType } }}
+     */
+    const {
       elements: {
-        field
+        field: value = {}
       } = {}
-    } = Reflect.get(params, uri))
+    } = params[uri] // Reflect.get(values, uri)
+
+    return value
   }
 
-  return field || {}
+  return {}
 }
 
+/**
+ *  @param {ParamsType} [params]
+ *  @param {string} [uri]
+ *  @returns {FieldType | ObjectLiteralType}
+ */
 export function getElementsFieldProps (params = {}, uri = '#') {
-  let field
-  if (Reflect.has(params, uri)) {
-    ({
+  if (uri in params) { // if (Reflect.has(values, uri)) {
+    /**
+     *  @type {{ elements?: { field?: FieldType | ObjectLiteralType } }}
+     */
+    const {
       elements: {
-        field
+        field: value = {}
       } = {}
-    } = Reflect.get(params, uri))
+    } = params[uri] // Reflect.get(values, uri)
+
+    return value
   }
 
-  return field || {}
+  return {}
 }
 
+/**
+ *  @param {ValuesType} [values]
+ *  @param {string} [uri]
+ *  @param {SchemaType} [schema]
+ *  @returns {{ value: string } | {}}
+ */
 export function getElementsFieldValue (values = {}, uri = '#', schema = {}) {
-  if (Reflect.has(values, uri)) {
-    const value = Reflect.get(values, uri)
+  if (uri in values) { // (Reflect.has(values, uri)) {
+    const value = values[uri] // Reflect.get(values, uri)
 
     if (isPrimitive(value)) {
       return { value: String(value) }
     }
   }
 
-  if (Reflect.has(schema, 'const')) {
-    const constValue = Reflect.get(schema, 'const')
+  if ('const' in schema) { // Reflect.has(schema, 'const')) {
+    const constValue = schema.const // Reflect.get(schema, 'const')
 
     if (isPrimitive(constValue)) {
       return { value: String(constValue) }
     }
   }
 
-  if (Reflect.has(schema, 'default')) {
-    const defaultValue = Reflect.get(schema, 'default')
+  if ('default' in schema) { // Reflect.has(schema, 'default')) {
+    const defaultValue = schema.default // Reflect.get(schema, 'default')
 
     if (isPrimitive(defaultValue)) {
       return { value: String(defaultValue) }
@@ -555,67 +903,182 @@ export function getElementsFieldValue (values = {}, uri = '#', schema = {}) {
   return {}
 }
 
-export const hasEnum = (schema = {}) => Reflect.has(schema, 'enum')
-export const getEnum = (schema = {}) => Reflect.get(schema, 'enum')
+/**
+ *  @param {{ 'enum'?: ItemsType }} [schema]
+ *  @returns {schema is { 'enum': ItemsType }}
+ */
+export const hasEnum = (schema = {}) => 'enum' in schema // Reflect.has(schema, 'enum')
+
+/**
+ *  @overload
+ *  @param {{ 'enum': ItemsType }} schema
+ *  @returns {ItemsType}
+ *
+ *  @param {{ 'enum'?: ItemsType }} [schema]
+ *  @returns {ItemsType | undefined}
+ */
+export const getEnum = (schema = {}) => schema.enum // Reflect.get(schema, 'enum')
 
-export const hasConst = (schema = {}) => Reflect.has(schema, 'const')
-export const getConst = (schema = {}) => Reflect.get(schema, 'const')
+/**
+ *  @param {{ 'const'?: string | number | object | boolean | null }} [schema]
+ *  @returns {schema is { 'const': string | number | object | boolean | null }}
+ */
+export const hasConst = (schema = {}) => 'const' in schema // Reflect.has(schema, 'const')
+
+/**
+ *  @overload
+ *  @param {{ 'const': string | number | object | boolean | null }} schema
+ *  @returns {string | number | object | boolean | null}
+ *
+ *  @param {{ 'const'?: string | number | object | boolean | null }} [schema]
+ *  @returns {string | number | object | boolean | null | undefined}
+ */
+export const getConst = (schema = {}) => schema.const // Reflect.get(schema, 'const')
 
-export const hasDefault = (schema = {}) => Reflect.has(schema, 'default')
-export const getDefault = (schema = {}) => Reflect.get(schema, 'default')
+/**
+ *  @param {{ 'default'?: string | number | object | boolean | null }} [schema]
+ *  @returns {schema is { 'default': string | number | object | boolean | null }}
+ */
+export const hasDefault = (schema = {}) => 'default' in schema // Reflect.has(schema, 'default')
+
+/**
+ *  @overload
+ *  @param {{ 'default': string | number | object | boolean | null }} schema
+ *  @returns {string | number | object | boolean | null}
+ *
+ *  @param {{ 'default'?: string | number | object | boolean | null }} [schema]
+ *  @returns {string | number | object | boolean | null | undefined}
+ */
+export const getDefault = (schema = {}) => schema.default // Reflect.get(schema, 'default')
 
-export const hasAnyOf = (schema = {}) => Reflect.has(schema, 'anyOf')
-export const getAnyOf = (schema = {}) => Reflect.get(schema, 'anyOf')
+/**
+ *  @param {{ 'anyOf'?: ItemsType }} [schema]
+ *  @returns {schema is { 'anyOf': ItemsType }}
+ */
+export const hasAnyOf = (schema = {}) => 'anyOf' in schema // Reflect.has(schema, 'anyOf')
+
+/**
+ *  @overload
+ *  @param {{ 'anyOf': ItemsType }} schema
+ *  @returns {ItemsType}
+ *
+ *  @param {{ 'anyOf'?: ItemsType }} [schema]
+ *  @returns {ItemsType | undefined}
+ */
+export const getAnyOf = (schema = {}) => schema.anyOf // Reflect.get(schema, 'anyOf')
 
-export const hasOneOf = (schema = {}) => Reflect.has(schema, 'oneOf')
-export const getOneOf = (schema = {}) => Reflect.get(schema, 'oneOf')
+/**
+ *  @param {{ 'oneOf'?: ItemsType }} [schema]
+ *  @returns {schema is { 'oneOf': ItemsType }}
+ */
+export const hasOneOf = (schema = {}) => 'oneOf' in schema // Reflect.has(schema, 'oneOf')
+
+/**
+ *  @overload
+ *  @param {{ 'oneOf': ItemsType }} schema
+ *  @returns {ItemsType}
+ *
+ *  @param {{ 'oneOf'?: ItemsType }} schema
+ *  @returns {ItemsType | undefined}
+ */
+export const getOneOf = (schema = {}) => schema.oneOf // Reflect.get(schema, 'oneOf')
 
-export const hasAllOf = (schema = {}) => Reflect.has(schema, 'allOf')
-export const getAllOf = (schema = {}) => Reflect.get(schema, 'allOf')
+/**
+ *  @param {{ 'allOf'?: ItemsType }} [schema]
+ *  @returns {schema is { 'allOf': ItemsType }}
+ */
+export const hasAllOf = (schema = {}) => 'allOf' in schema // Reflect.has(schema, 'allOf')
+
+/**
+ *  @overload
+ *  @param {{ 'allOf': ItemsType }} schema
+ *  @returns {ItemsType}
+ *
+ *  @param {{ 'allOf'?: ItemsType }} [schema]
+ *  @returns {ItemsType | undefined}
+ */
+export const getAllOf = (schema = {}) => schema.allOf // Reflect.get(schema, 'allOf')
 
-export const getUri = (uri = '#', resource = '') => (uri.endsWith('/') ? uri : uri.concat('/')).concat(resource)
+/**
+ *  @param {string} [uri]
+ *  @param {string | number} [resource]
+ *  @returns {string}
+ */
+export const getUri = (uri = '#', resource = '') => (uri.endsWith('/') ? uri : uri + '/') + String(resource)
 
+/**
+ *  @param {string} [uri]
+ *  @returns {string}
+ */
 export const normaliseUri = (uri = '#') => uri === '#' ? '#/' : uri
 
+/**
+ *  @param {{ minimum?: number }} schema
+ *  @returns {{ min: number } | {}}
+ */
 export function getMin ({ minimum } = {}) {
   const value = Number(minimum)
 
   return isNaN(value) ? {} : { min: value }
 }
 
+/**
+ *  @param {{ maximum?: number }} schema
+ *  @returns {{ max: number } | {}}
+ */
 export function getMax ({ maximum } = {}) {
   const value = Number(maximum)
 
   return isNaN(value) ? {} : { max: value }
 }
 
+/**
+ *  @param {{ minLength?: number }} schema
+ *  @returns {{ minLength: number } | {}}
+ */
 export function getMinLength ({ minLength } = {}) {
   const value = Number(minLength)
 
   return isNaN(value) ? {} : { minLength: value }
 }
 
+/**
+ *  @param {{ maxLength?: number }} schema
+ *  @returns {{ maxLength: number } | {}}
+ */
 export function getMaxLength ({ maxLength } = {}) {
   const value = Number(maxLength)
 
   return isNaN(value) ? {} : { maxLength: value }
 }
 
+/**
+ *  @param {{ minItems?: number }} schema
+ *  @returns {{ minItems: number } | {}}
+ */
 export function getMinItems ({ minItems } = {}) {
   const value = Number(minItems)
 
   return isNaN(value) ? {} : { minItems: value }
 }
 
+/**
+ *  @param {{ maxItems?: number }} schema
+ *  @returns {{ maxItems: number } | {}}
+ */
 export function getMaxItems ({ maxItems } = {}) {
   const value = Number(maxItems)
 
   return isNaN(value) ? {} : { maxItems: value }
 }
 
+/**
+ *  @param {{ uniqueItems?: boolean }} schema
+ *  @returns {{ hasUniqueItems: boolean } | {}}
+ */
 export function getHasUniqueItems (schema = {}) {
-  if (Reflect.has(schema, 'uniqueItems')) {
-    const value = Reflect.get(schema, 'uniqueItems')
+  if ('uniqueItems' in schema) { // if (Reflect.has(schema, 'uniqueItems') {
+    const value = schema.uniqueItems // Reflect.get(schema, 'uniqueItems')
 
     return (typeof value === 'boolean') ? { hasUniqueItems: value } : {}
   }
@@ -623,33 +1086,53 @@ export function getHasUniqueItems (schema = {}) {
   return {}
 }
 
+/**
+ *  @param {{ minContains?: number }} schema
+ *  @returns {{ minContains: number } | {}}
+ */
 export function getMinContains ({ minContains } = {}) {
   const value = Number(minContains)
 
   return isNaN(value) ? {} : { minContains: value }
 }
 
+/**
+ *  @param {{ maxContains?: number }} schema
+ *  @returns {{ maxContains: number } | {}}
+ */
 export function getMaxContains ({ maxContains } = {}) {
   const value = Number(maxContains)
 
   return isNaN(value) ? {} : { maxContains: value }
 }
 
+/**
+ *  @param {{ minProperties?: number }} schema
+ *  @returns {{ minProperties: number } | {}}
+ */
 export function getMinProperties ({ minProperties } = {}) {
   const value = Number(minProperties)
 
   return isNaN(value) ? {} : { minProperties: value }
 }
 
+/**
+ *  @param {{ maxProperties?: number }} schema
+ *  @returns {{ maxProperties: number } | {}}
+ */
 export function getMaxProperties ({ maxProperties } = {}) {
   const value = Number(maxProperties)
 
   return isNaN(value) ? {} : { maxProperties: value }
 }
 
+/**
+ *  @param {{ exclusiveMinimum?: boolean }} schema
+ *  @returns {{ isExclusiveMin: boolean } | {}}
+ */
 export function getIsExclusiveMin (schema = {}) {
-  if (Reflect.has(schema, 'exclusiveMinimum')) {
-    const value = Reflect.get(schema, 'exclusiveMinimum')
+  if ('exclusiveMinimum' in schema) { // if (Reflect.has(schema, 'exclusiveMinimum') {
+    const value = schema.exclusiveMinimum // Reflect.get(schema, 'exclusiveMinimum')
 
     return (typeof value === 'boolean') ? { isExclusiveMin: value } : {}
   }
@@ -657,9 +1140,13 @@ export function getIsExclusiveMin (schema = {}) {
   return {}
 }
 
+/**
+ *  @param {{ exclusiveMaximum?: boolean }} schema
+ *  @returns {{ isExclusiveMax: boolean } | {}}
+ */
 export function getIsExclusiveMax (schema = {}) {
-  if (Reflect.has(schema, 'exclusiveMaximum')) {
-    const value = Reflect.get(schema, 'exclusiveMaximum')
+  if ('exclusiveMaximum' in schema) { // if (Reflect.has(schema, 'exclusiveMaximum') {
+    const value = schema.exclusiveMaximum // Reflect.get(schema, 'exclusiveMaximum')
 
     return (typeof value === 'boolean') ? { isExclusiveMax: value } : {}
   }
@@ -667,8 +1154,16 @@ export function getIsExclusiveMax (schema = {}) {
   return {}
 }
 
+/**
+ *  @param {{ pattern?: RegExp }} schema
+ *  @returns {{ pattern: RegExp } | {}}
+ */
 export const getPattern = ({ pattern } = {}) => (pattern ? { pattern } : {})
 
+/**
+ *  @param {{ multipleOf?: number }} schema
+ *  @returns {{ step: number } | {}}
+ */
 export function getStep ({ multipleOf } = {}) {
   const value = Number(multipleOf)