shinkansen-transmission 2.3.6 → 2.4.0

package/src/transmission/from-document-to-hash/object/index.mjs

@@ -1,52 +1,7 @@
-/**
- *  @typedef {TransmissionTypes.DocumentType} DocumentType
- *  @typedef {TransmissionTypes.SchemaType} SchemaType
- *  @typedef {TransmissionTypes.HashType} HashType
- */
-
 import debug from 'debug'
 
-import {
-  toString,
-  isObject,
-  getUri
-} from '#transmission/transmission/common'
-
-import {
-  transformObject
-} from '#transmission/transmission/from-document-to-hash'
-
 const log = debug('shinkansen-transmission/from-document-to-hash/object')
 
 log('`shinkansen` is awake')
 
-/**
- * Document can be `undefined`
- *
- *  @param {DocumentType} [document]
- *  @param {SchemaType} [schema]
- *  @param {HashType} [hash]
- *  @param {string} [parentUri]
- *  @param {string} [uri]
- *  @returns {HashType}
- */
-export default function transformObjectSchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
-  log('transformObjectSchema')
-
-  /*
-   *  Is `document` an object?
-   */
-  if (isObject(document)) {
-    /*
-     *  Yes, `document` is an object
-     */
-    return transformObject(document, schema, hash, parentUri, uri)
-  }
-
-  /*
-   *  The hash should contain only strings
-   */
-  hash[uri] = toString(document)
-
-  return hash
-}
+export { transformObjectSchema as default } from '#transmission/transmission/from-document-to-hash'

package/src/transmission/from-document-to-hash/string/index.d.mts

@@ -0,0 +1,5 @@
+type DocumentType = TransmissionTypes.DocumentType
+type SchemaType = TransmissionTypes.SchemaType
+type HashType = TransmissionTypes.HashType
+
+export default function transformStringSchema (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType

package/src/transmission/from-document-to-hash/string/index.mjs

@@ -15,7 +15,7 @@ import {
   hasOneOf,
   getOneOf,
   getUri,
-  getIndexByValue
+  transformIndexToValueByFindValue
 } from '#transmission/transmission/common'
 
 const log = debug('shinkansen-transmission/from-document-to-hash/string')
@@ -40,28 +40,28 @@ export default function transformStringSchema (document, schema = {}, hash = {},
      *  https://json-schema.org/draft/2019-09/json-schema-validation#rfc.section.6.1.2
      */
     const array = getEnum(schema)
-    const index = getIndexByValue(array, document)
+    const value = transformIndexToValueByFindValue(array, document)
 
     /**
-     *  `document` is the string representation of an index to an item in the `enum`
+     *  `document` is the string representation of an value to an item in the `enum`
      */
-    hash[uri] = String(index)
+    hash[uri] = value
 
     return hash
   } else {
     if (hasAnyOf(schema)) {
       const array = getAnyOf(schema)
-      const index = getIndexByValue(array, document)
+      const value = transformIndexToValueByFindValue(array, document)
 
-      hash[uri] = String(index)
+      hash[uri] = value
 
       return hash
     } else {
       if (hasOneOf(schema)) {
         const array = getOneOf(schema)
-        const index = getIndexByValue(array, document)
+        const value = transformIndexToValueByFindValue(array, document)
 
-        hash[uri] = String(index)
+        hash[uri] = value
 
         return hash
       }

package/src/transmission/from-hash-to-document/array/index.d.mts

@@ -0,0 +1,4 @@
+export {
+  transformArray,
+  transformArraySchema as default
+} from '#transmission/transmission/from-hash-to-document'

package/src/transmission/from-hash-to-document/array/index.mjs

@@ -1,48 +1,10 @@
-/**
- *  @typedef {TransmissionTypes.HashType} HashType
- *  @typedef {TransmissionTypes.SchemaType} SchemaType
- *  @typedef {TransmissionTypes.ParamsType} ParamsType
- *  @typedef {TransmissionTypes.DocumentType} DocumentType
- */
-
 import debug from 'debug'
 
-import {
-  getUri
-} from '#transmission/transmission/common'
-
-import {
-  transformArray
-} from '#transmission/transmission/from-hash-to-document'
-
 const log = debug('shinkansen-transmission/from-hash-to-document/array')
 
 log('`shinkansen` is awake')
 
-/**
- * Hash can be `undefined`
- *
- *  @param {HashType} [hash]
- *  @param {SchemaType} [schema]
- *  @param {ParamsType} [params]
- *  @returns {DocumentType}
- */
-export default function transformArraySchema (hash = {}, schema = {}, params = {}) {
-  log('transformArraySchema')
-
-  const {
-    type
-  } = schema
-
-  // https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.4.2.1
-  if (type === 'array') {
-    const {
-      uri: parentUri = '#',
-      index: arrayIndex // number | undefined
-    } = params
-
-    return transformArray(hash, schema, parentUri, getUri(parentUri, arrayIndex))
-  }
-
-  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')
-}
+export {
+  transformArray,
+  transformArraySchema as default
+} from '#transmission/transmission/from-hash-to-document'

package/src/transmission/from-hash-to-document/boolean/index.d.mts

@@ -0,0 +1,8 @@
+export type SchemaType = TransmissionTypes.SchemaType
+export type ParamsType = TransmissionTypes.ParamsType
+export type DocumentType = TransmissionTypes.DocumentType
+export type HashType = TransmissionTypes.HashType
+
+export function transformBoolean (hash: HashType, schema: SchemaType, parentUri: string, uri: string): boolean | undefined
+
+export default function transformBooleanSchema (hash?: HashType, schema?: SchemaType, params?: ParamsType): DocumentType | undefined

package/src/transmission/from-hash-to-document/boolean/index.mjs

@@ -8,19 +8,100 @@
 import debug from 'debug'
 
 import {
+  isArray,
+  hasEnum,
+  getEnum,
+  hasAnyOf,
+  getAnyOf,
+  hasOneOf,
+  getOneOf,
+  transformToValue,
   getUri
 } from '#transmission/transmission/common'
 
 import {
-  transformBoolean
-} from '#transmission/transmission/from-hash-to-document'
+  fromDocumentToArray,
+  mapToValue,
+  toBoolean
+} from '#transmission/transmission/common/transform'
 
 const log = debug('shinkansen-transmission/from-hash-to-document/boolean')
 
 log('`shinkansen` is awake')
 
 /**
- * Hash can be `undefined`
+ * @overload
+ * @param {unknown} error
+ * @returns {void}
+ *
+ * @param {{ message?: string }} error
+ * @returns {void}
+ */
+function handleError ({ message = 'No error message defined' }) { log(message) }
+
+/**
+ *  @param {HashType} hash
+ *  @param {SchemaType} schema
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {DocumentType | undefined}
+ */
+export function transformBoolean (hash, schema, parentUri, uri) {
+  /*
+   *  log('transformBoolean')
+   */
+
+  if (uri in hash) { // Reflect.has(hash, uri)) {
+    const document = hash[uri] // Reflect.get(hash, uri)
+
+    if (hasEnum(schema)) {
+      const array = getEnum(schema)
+
+      if (isArray(document)) return document.map(mapToValue(array))
+      return (
+        transformToValue(
+          fromDocumentToArray(document, array)
+        )
+      )
+    } else {
+      if (hasAnyOf(schema)) {
+        const array = getAnyOf(schema)
+
+        if (isArray(document)) return document.map(mapToValue(array))
+        return (
+          transformToValue(
+            fromDocumentToArray(document, array)
+          )
+        )
+      } else {
+        if (hasOneOf(schema)) {
+          const array = getOneOf(schema)
+
+          if (isArray(document)) return document.map(mapToValue(array))
+          return (
+            transformToValue(
+              fromDocumentToArray(document, array)
+            )
+          )
+        }
+      }
+    }
+
+    try {
+      if (isArray(document)) return document.map(toBoolean)
+      return (
+        toBoolean(document)
+      )
+    } catch (e) {
+      handleError(e)
+    }
+
+    return document
+  }
+}
+
+/**
+ *  Hash can be `undefined`
  *
  *  @param {HashType} [hash]
  *  @param {SchemaType} [schema]

package/src/transmission/from-hash-to-document/index.d.mts

@@ -4,29 +4,36 @@ export type ArrayLiteralType = TransmissionTypes.ArrayLiteralType
 export type ArrayType = TransmissionTypes.ArrayType
 
 export type SchemaType = TransmissionTypes.SchemaType
+export type ParamsType = TransmissionTypes.ParamsType
 export type DocumentType = TransmissionTypes.DocumentType
 export type HashType = TransmissionTypes.HashType
 
-export function toNull (v: unknown): null
-export function toBoolean (v: unknown): boolean
-export function toString (v: unknown): string
-export function toNumber (v: unknown): number
-
-export function transformValueFor (document: DocumentType, array?: ArrayLiteralType | ArrayType): DocumentType
-
-export function getArrayFor (hash: HashType, array?: ArrayLiteralType | ArrayType, uri?: string): ArrayLiteralType | ArrayType
-
 export function transformArrayFor (hash: HashType, schema: SchemaType, parentUri?: string, uri?: string): ArrayLiteralType | ArrayType
-export function transformObjectFor (hash: HashType, schema: SchemaType, parentUri?: string, uri?: string): ObjectLiteralType | ObjectType
+export function transformArray (hash: HashType, schema: SchemaType, parentUri: string, uri: string): DocumentType | undefined
+export function transformArraySchema (hash?: HashType, schema?: SchemaType, params?: ParamsType): DocumentType | undefined
 
-export function transformItemsArrayFor (hash: HashType, items?: ArrayLiteralType | ArrayType, parentUri?: string, uri?: string): ArrayLiteralType | ArrayType | undefined
-export function transformItemsObjectFor (hash: HashType, items?: ObjectLiteralType | ObjectType, parentUri?: string, uri?: string): ArrayLiteralType | ArrayType | undefined
-
-export function transformNull (hash: HashType, schema: SchemaType, parentUri: string, uri: string): null | undefined
-export function transformBoolean (hash: HashType, schema: SchemaType, parentUri: string, uri: string): boolean | undefined
-export function transformObject (hash: HashType, schema: SchemaType, parentUri: string, uri: string): ObjectLiteralType | ObjectType
-export function transformArray (hash: HashType, schema: SchemaType, parentUri: string, uri: string): ArrayLiteralType | ArrayType
-export function transformNumber (hash: HashType, schema: SchemaType, parentUri: string, uri: string): number | undefined
-export function transformString (hash: HashType, schema: SchemaType, parentUri: string, uri: string): string | undefined
-
-export default function transform (hash?: HashType, rootSchema?: SchemaType, parentUri?: string, uri?: string): DocumentType | undefined
+export function transformObjectFor (hash: HashType, schema: SchemaType, parentUri?: string, uri?: string): ObjectLiteralType | ObjectType
+export function transformObject (hash: HashType, schema: SchemaType, parentUri: string, uri: string): DocumentType | undefined
+export function transformObjectSchema (hash?: HashType, schema?: SchemaType, params?: ParamsType): DocumentType | undefined
+
+export {
+  transformString,
+  default as transformStringSchema
+} from './string/index.mjs'
+
+export {
+  transformNumber,
+  default as transformNumberSchema
+} from './number/index.mjs'
+
+export {
+  transformBoolean,
+  default as transformBooleanSchema
+} from './boolean/index.mjs'
+
+export {
+  transformNull,
+  default as transformNullSchema
+} from './null/index.mjs'
+
+export default function fromHashToDocument (hash?: HashType, rootSchema?: SchemaType, parentUri?: string, uri?: string): DocumentType | undefined