shinkansen-transmission 2.2.235 → 2.3.1

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -14,7 +20,17 @@ const log = debug('shinkansen-transmission/from-document-to-hash/array')
 
 log('`shinkansen` is awake')
 
-export default function transformArraySchema (document, schema = {}, values = {}, parentUri = '#', uri = getUri(parentUri)) {
+/**
+ * Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export default function transformArraySchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('transformArraySchema')
 
   /*
@@ -24,13 +40,13 @@ export default function transformArraySchema (document, schema = {}, values = {}
     /*
      *  Yes, `document` is an array
      */
-    return transformArray(document, schema, values, parentUri, uri)
+    return transformArray(document, schema, hash, parentUri, uri)
   }
 
   /*
    *  The hash should contain only strings
    */
-  values[uri] = toString(document)
+  hash[uri] = toString(document)
 
-  return values
+  return hash
 }

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -16,29 +22,39 @@ const log = debug('shinkansen-transmission/from-document-to-hash/boolean')
 
 log('`shinkansen` is awake')
 
-export default function transformBooleanSchema (document, schema = {}, values = {}, parentUri = '#', uri = getUri(parentUri)) {
+/**
+ * Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export default function transformBooleanSchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('transformBooleanSchema')
 
   if (hasEnum(schema)) {
     const items = getEnum(schema)
 
-    values[uri] = transformValueIndexFor(items, document)
+    hash[uri] = transformValueIndexFor(items, document)
 
-    return values
+    return hash
   } else {
     if (hasAnyOf(schema)) {
       const items = getAnyOf(schema)
 
-      values[uri] = transformValueIndexFor(items, document)
+      hash[uri] = transformValueIndexFor(items, document)
 
-      return values
+      return hash
     } else {
       if (hasOneOf(schema)) {
         const items = getOneOf(schema)
 
-        values[uri] = transformValueIndexFor(items, document)
+        hash[uri] = transformValueIndexFor(items, document)
 
-        return values
+        return hash
       }
     }
   }
@@ -46,7 +62,7 @@ export default function transformBooleanSchema (document, schema = {}, values =
   /*
    *  The hash should contain only strings
    */
-  values[uri] = toString(document)
+  hash[uri] = toString(document)
 
-  return values
+  return hash
 }

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

@@ -1,22 +1,11 @@
-declare module '#transmission/transmission/from-document-to-hash' {
-  type ObjectLiteralType = ZashikiTypes.ObjectLiteralType
-  type ObjectType = ZashikiTypes.ObjectType
+type DocumentType = TransmissionTypes.DocumentType
+type SchemaType = TransmissionTypes.SchemaType
+type HashType = TransmissionTypes.HashType
 
-  type SchemaType = ZashikiTypes.SchemaType
+export function transformArrayFor (document: DocumentType[], schema: { type: string }, hash: HashType, parentUri: string): HashType
+export function transformObjectFor (document: Record<string, DocumentType>, schema: { type: string }, hash: HashType, parentUri: string): HashType
 
-  type DocumentType = ZashikiTypes.DocumentType
-  type HashType = ZashikiTypes.HashType
+export function transformArray (document: DocumentType[], schema: { type: string }, hash: HashType, parentUri: string, uri: string): HashType
+export function transformObject (document: Record<string, DocumentType>, schema: { type: string }, hash: HashType, parentUri: string, uri: string): HashType
 
-  export function transformArrayFor (document: DocumentType | undefined, schema: SchemaType | undefined, values: ObjectType | ObjectLiteralType | undefined, parentUri: string | undefined, uri: string | undefined): HashType | undefined
-  export function transformObjectFor (document: DocumentType | undefined, schema: SchemaType | undefined, values: ObjectType | ObjectLiteralType | undefined, parentUri: string | undefined, uri: string | undefined): HashType | undefined
-
-  export function transformArray (document: DocumentType | undefined, schema: SchemaType | undefined, values: ObjectType | ObjectLiteralType | undefined, parentUri: string | undefined, uri: string | undefined): HashType | undefined
-  export function transformObject (document: DocumentType | undefined, schema: SchemaType | undefined, values: ObjectType | ObjectLiteralType | undefined, parentUri: string | undefined, uri: string | undefined): HashType | undefined
-
-  export default function transform (document: DocumentType | undefined, schema: SchemaType | undefined, values: ObjectType | ObjectLiteralType | undefined, parentUri: string | undefined, uri: string | undefined): HashType | undefined
-}
-
-declare module 'shinkansen-transmission/transmission/from-document-to-hash' {
-  export { default } from '#transmission/transmission/from-document-to-hash'
-  export * from '#transmission/transmission/from-document-to-hash'
-}
+export default function transform (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -14,45 +20,96 @@ import {
   getUri,
   transformValueIndexFor,
   transformEqualIndexFor,
-  transformValue
+  transformToValue
 } from '#transmission/transmission/common'
 
 const log = debug('shinkansen-transmission/from-document-to-hash')
 
 log('`shinkansen` is awake')
 
-export {
-  transformValue
+export { transformToValue }
+
+/**
+ *  @param {SchemaType} schema
+ *  @param {string} parentUri
+ *  @returns {(hash: HashType, document: DocumentType, index: number) => HashType}
+ */
+function getReduceArrayFor (schema, parentUri) {
+  /**
+   *  @param {HashType} hash
+   *  @param {DocumentType} document
+   *  @param {number} index
+   *  @returns {HashType}
+   */
+  return function reduce (hash, document, index) {
+    const schemaUri = getUri(parentUri, index)
+
+    return transform(document, getSchema(schema, parentUri, schemaUri), hash, schemaUri, schemaUri)
+  }
 }
 
+/**
+ *  @param {SchemaType} schema
+ *  @param {string} parentUri
+ *  @returns {(hash: HashType, entry: [key: string, document: DocumentType]) => HashType}
+ */
+function getReduceObjectFor (schema, parentUri) {
+  /**
+   *  @param {HashType} hash
+   *  @param {[key: string, document: DocumentType]} entry
+   *  @returns {HashType}
+   */
+  return function reduce (hash, [key, document]) {
+    const schemaUri = getUri(parentUri, key)
+
+    return transform(document, getSchema(schema, parentUri, schemaUri), hash, schemaUri, schemaUri)
+  }
+}
+
+/**
+ *  @param {Array<DocumentType>} document
+ *  @param {SchemaType} schema
+ *  @param {HashType} hash
+ *  @param {string} parentUri
+ *  @returns {HashType}
+ */
 export function transformArrayFor (document, schema, hash, parentUri) { // }, uri) {
   /*
    *  log('transformArrayFor')
    */
+
   return (
     document
-      .reduce((hash, value, index) => {
-        const schemaUri = getUri(parentUri, index)
-
-        return transform(value, getSchema(schema, parentUri, schemaUri), hash, schemaUri, schemaUri)
-      }, hash)
+      .reduce(getReduceArrayFor(schema, parentUri), hash)
   )
 }
 
+/**
+ *  @param {Record<string, DocumentType>} document
+ *  @param {SchemaType} schema
+ *  @param {HashType} hash
+ *  @param {string} parentUri
+ *  @returns {HashType}
+ */
 export function transformObjectFor (document, schema, hash, parentUri) { // }, uri) {
   /*
    *  log('transformObjectFor')
    */
+
   return (
     Object.entries(document)
-      .reduce((hash, [key, value]) => {
-        const schemaUri = getUri(parentUri, key)
-
-        return transform(value, getSchema(schema, parentUri, schemaUri), hash, schemaUri, schemaUri)
-      }, hash)
+      .reduce(getReduceObjectFor(schema, parentUri), hash)
   )
 }
 
+/**
+ *  @param {Array<DocumentType>} document
+ *  @param {SchemaType} schema
+ *  @param {HashType} hash
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {HashType}
+ */
 export function transformArray (document, schema, hash, parentUri, uri) {
   /*
    *  log('transformArray')
@@ -85,7 +142,7 @@ export function transformArray (document, schema, hash, parentUri, uri) {
           /*
            *  Items is an array of schemas
            */
-          return transformArrayFor(document, schema, hash, parentUri, uri)
+          return transformArrayFor(document, schema, hash, parentUri) // , uri)
         } else {
           if (isObject(items)) {
             /*
@@ -123,9 +180,17 @@ export function transformArray (document, schema, hash, parentUri, uri) {
   /*
    *  Transform schema
    */
-  return transformArrayFor(document, schema, hash, parentUri, uri) // schema not items
+  return transformArrayFor(document, schema, hash, parentUri) // , uri) // schema not items
 }
 
+/**
+ *  @param {Record<string, DocumentType>} document
+ *  @param {SchemaType} schema
+ *  @param {HashType} hash
+ *  @param {string} parentUri
+ *  @param {string} uri
+ *  @returns {HashType}
+ */
 export function transformObject (document, schema, hash, parentUri, uri) {
   /*
    *  log('transformObject')
@@ -161,6 +226,16 @@ export function transformObject (document, schema, hash, parentUri, uri) {
   return transformObjectFor(document, schema, hash, parentUri) // , uri)
 }
 
+/**
+ * Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
 export default function transform (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('fromDocumentToHash')
 
@@ -182,6 +257,11 @@ export default function transform (document, schema = {}, hash = {}, parentUri =
        */
       return transformObject(document, schema, hash, parentUri, uri)
     } else {
+      /**
+       *  `document` is a primitive or is undefined
+       *
+       *  Is the schema an `enum`?
+       */
       if (hasEnum(schema)) {
         const items = getEnum(schema)
 
@@ -189,6 +269,9 @@ export default function transform (document, schema = {}, hash = {}, parentUri =
 
         return hash
       } else {
+        /**
+         *  Is the schema an `anyOf`?
+         */
         if (hasAnyOf(schema)) {
           const items = getAnyOf(schema)
 
@@ -196,6 +279,9 @@ export default function transform (document, schema = {}, hash = {}, parentUri =
 
           return hash
         } else {
+          /**
+           *  Is the schema an `oneOf`?
+           */
           if (hasOneOf(schema)) {
             const items = getOneOf(schema)
 
@@ -209,7 +295,7 @@ export default function transform (document, schema = {}, hash = {}, parentUri =
   }
 
   /*
-   *  The hash should contain only strings
+   *  Transform the primitive or undefined `document` to a string
    */
   hash[uri] = toString(document)
 

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -16,29 +22,39 @@ const log = debug('shinkansen-transmission/from-document-to-hash/null')
 
 log('`shinkansen` is awake')
 
-export default function transformNullSchema (document, schema = {}, values = {}, parentUri = '#', uri = getUri(parentUri)) {
+/**
+ * Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export default function transformNullSchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('transformNullSchema')
 
   if (hasEnum(schema)) {
     const items = getEnum(schema)
 
-    values[uri] = transformValueIndexFor(items, document)
+    hash[uri] = transformValueIndexFor(items, document)
 
-    return values
+    return hash
   } else {
     if (hasAnyOf(schema)) {
       const items = getAnyOf(schema)
 
-      values[uri] = transformValueIndexFor(items, document)
+      hash[uri] = transformValueIndexFor(items, document)
 
-      return values
+      return hash
     } else {
       if (hasOneOf(schema)) {
         const items = getOneOf(schema)
 
-        values[uri] = transformValueIndexFor(items, document)
+        hash[uri] = transformValueIndexFor(items, document)
 
-        return values
+        return hash
       }
     }
   }
@@ -46,7 +62,7 @@ export default function transformNullSchema (document, schema = {}, values = {},
   /*
    *  The hash should contain only strings
    */
-  values[uri] = toString(document)
+  hash[uri] = toString(document)
 
-  return values
+  return hash
 }

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -16,29 +22,39 @@ const log = debug('shinkansen-transmission/from-document-to-hash/number')
 
 log('`shinkansen` is awake')
 
-export default function transformNumberSchema (document, schema = {}, values = {}, parentUri = '#', uri = getUri(parentUri)) {
+/**
+ * Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export default function transformNumberSchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('transformNumberSchema')
 
   if (hasEnum(schema)) {
     const items = getEnum(schema)
 
-    values[uri] = transformValueIndexFor(items, document)
+    hash[uri] = transformValueIndexFor(items, document)
 
-    return values
+    return hash
   } else {
     if (hasAnyOf(schema)) {
       const items = getAnyOf(schema)
 
-      values[uri] = transformValueIndexFor(items, document)
+      hash[uri] = transformValueIndexFor(items, document)
 
-      return values
+      return hash
     } else {
       if (hasOneOf(schema)) {
         const items = getOneOf(schema)
 
-        values[uri] = transformValueIndexFor(items, document)
+        hash[uri] = transformValueIndexFor(items, document)
 
-        return values
+        return hash
       }
     }
   }
@@ -46,7 +62,7 @@ export default function transformNumberSchema (document, schema = {}, values = {
   /*
    *  The hash should contain only strings
    */
-  values[uri] = toString(document)
+  hash[uri] = toString(document)
 
-  return values
+  return hash
 }

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -14,7 +20,17 @@ const log = debug('shinkansen-transmission/from-document-to-hash/object')
 
 log('`shinkansen` is awake')
 
-export default function transformObjectSchema (document, schema = {}, values = {}, parentUri = '#', uri = getUri(parentUri)) {
+/**
+ * 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')
 
   /*
@@ -22,15 +38,15 @@ export default function transformObjectSchema (document, schema = {}, values = {
    */
   if (isObject(document)) {
     /*
-      *  Yes, `document` is an object
-      */
-    return transformObject(document, schema, values, parentUri, uri)
+     *  Yes, `document` is an object
+     */
+    return transformObject(document, schema, hash, parentUri, uri)
   }
 
   /*
    *  The hash should contain only strings
    */
-  values[uri] = toString(document)
+  hash[uri] = toString(document)
 
-  return values
+  return hash
 }

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

@@ -1,3 +1,9 @@
+/**
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.HashType} HashType
+ */
+
 import debug from 'debug'
 
 import {
@@ -16,29 +22,39 @@ const log = debug('shinkansen-transmission/from-document-to-hash/string')
 
 log('`shinkansen` is awake')
 
-export default function transformStringSchema (document, schema = {}, values = {}, parentUri = '#', uri = getUri(parentUri)) {
+/**
+ * Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export default function transformStringSchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('transformStringSchema')
 
   if (hasEnum(schema)) {
     const items = getEnum(schema)
 
-    values[uri] = transformValueIndexFor(items, document)
+    hash[uri] = transformValueIndexFor(items, document)
 
-    return values
+    return hash
   } else {
     if (hasAnyOf(schema)) {
       const items = getAnyOf(schema)
 
-      values[uri] = transformValueIndexFor(items, document)
+      hash[uri] = transformValueIndexFor(items, document)
 
-      return values
+      return hash
     } else {
       if (hasOneOf(schema)) {
         const items = getOneOf(schema)
 
-        values[uri] = transformValueIndexFor(items, document)
+        hash[uri] = transformValueIndexFor(items, document)
 
-        return values
+        return hash
       }
     }
   }
@@ -46,7 +62,7 @@ export default function transformStringSchema (document, schema = {}, values = {
   /*
    *  The hash should contain only strings
    */
-  values[uri] = toString(document)
+  hash[uri] = toString(document)
 
-  return values
+  return hash
 }

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

@@ -1,3 +1,10 @@
+/**
+ *  @typedef {TransmissionTypes.HashType} HashType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.ParamsType} ParamsType
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ */
+
 import debug from 'debug'
 
 import {
@@ -12,19 +19,29 @@ const log = debug('shinkansen-transmission/from-hash-to-document/array')
 
 log('`shinkansen` is awake')
 
-export default function transformArraySchema (values = {}, schema = {}, params = {}) {
+/**
+ * Hash can be `undefined`
+ *
+ *  @param {HashType} [hash]
+ *  @param {SchemaType} [schema]
+ *  @param {ParamsType} [params]
+ *  @returns {DocumentType | undefined}
+ */
+export default function transformArraySchema (hash = {}, schema = {}, params = {}) {
   log('transformArraySchema')
 
-  const { type } = schema
+  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
+      uri: parentUri = '#',
+      index: arrayIndex // number | undefined
     } = params
 
-    return transformArray(values, schema, parentUri, getUri(parentUri, arrayIndex))
+    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')

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

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