shinkansen-transmission 2.3.6 → 2.4.0

package/src/transmission/common/transform/index.d.mts

@@ -0,0 +1,18 @@
+type MemberArrayType = TransmissionTypes.MemberArrayType
+type MemberType = TransmissionTypes.MemberType
+
+type HashType = TransmissionTypes.HashType
+type SchemaType = TransmissionTypes.SchemaType
+type ParamsType = TransmissionTypes.ParamsType
+type DocumentType = TransmissionTypes.DocumentType
+
+export function toString (v: unknown) : string
+export function toNumber (v: unknown): number
+export function toBoolean (v: unknown) : boolean
+export function toNull (v: unknown): null
+
+export function mapToValue (array: MemberArrayType): (document: DocumentType | undefined) => MemberType | undefined
+
+export function fromDocumentToArray (document: DocumentType | undefined, array: MemberArrayType) : MemberType
+
+export function fromHashToArray (hash: HashType, uri: string, array: MemberArrayType): MemberType

package/src/transmission/common/transform/index.mjs

@@ -0,0 +1,128 @@
+/**
+ *  @typedef {TransmissionTypes.MemberArrayType} MemberArrayType
+ *  @typedef {TransmissionTypes.MemberType} MemberType
+ *
+ *  @typedef {TransmissionTypes.HashType} HashType
+ *  @typedef {TransmissionTypes.SchemaType} SchemaType
+ *  @typedef {TransmissionTypes.ParamsType} ParamsType
+ *  @typedef {TransmissionTypes.DocumentType} DocumentType
+ */
+
+import {
+  isPrimitive,
+  transformToValue
+} from '#transmission/transmission/common'
+
+/**
+ *  @param {unknown} v
+ *  @returns {string}
+ */
+export function toString (v) {
+  if (typeof v === 'string') return v
+  if (typeof v === 'number') return String(v)
+
+  return JSON.stringify(v)
+}
+
+/**
+ *  @param {unknown} v
+ *  @returns {number}
+ */
+export function toNumber (v) {
+  if (typeof v === 'number') return v
+  if (typeof v === 'boolean') return Number(v)
+
+  if (v) { // excludes zero-length strings
+    const n = (
+      isPrimitive(v) // excludes objects and arrays
+        ? Number(v) // +v // unary operator
+        : NaN
+    )
+
+    if (!isNaN(n)) return n
+  }
+
+  throw new Error('Invalid `number`')
+}
+
+/**
+ *  @param {unknown} v
+ *  @returns {boolean}
+ */
+export function toBoolean (v) {
+  if (typeof v === 'boolean') return v
+  if (v === 'true') return true
+  if (v === 'false') return false
+
+  throw new Error('Invalid `boolean`')
+}
+
+/**
+ *  @param {unknown} v
+ *  @returns {null}
+ */
+export function toNull (v) {
+  if (v === null || v === 'null') return null
+
+  throw new Error('Invalid `null`')
+}
+
+/**
+ *  @param {MemberArrayType} array
+ *  @returns {(document: DocumentType | undefined) => MemberType | undefined}
+ */
+export function mapToValue (array) {
+  /**
+   *  @param {DocumentType | undefined} document
+   *  @returns {MemberType | undefined}
+   */
+  return function toValue (document) {
+    return (
+      transformToValue(
+        fromDocumentToArray(document, array)
+      )
+    )
+  }
+}
+
+/**
+ *  @param {DocumentType | undefined} document
+ *  @param {MemberArrayType} array
+ *  @returns {MemberType}
+ */
+export function fromDocumentToArray (document, array) {
+  /*
+   *  log('fromDocumentToArray')
+   */
+
+  const i = Number(document)
+
+  /*
+   *  Return the the schema at `i`
+   */
+  if (!isNaN(i)) return array[i]
+
+  throw new Error('Invalid `document`')
+}
+
+/**
+ *  @param {HashType} hash
+ *  @param {string} uri
+ *  @param {MemberArrayType} array
+ *  @returns {MemberType}
+ */
+export function fromHashToArray (hash, uri, array) {
+  /*
+   *  log('fromHashToArray')
+   */
+
+  const v = hash[uri]
+  const i = Number(v)
+
+  /*
+    *  Return the the schema at `i`
+    */
+  if (!isNaN(i)) return array[i]
+
+  throw new Error('Invalid `hash`')
+}

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

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

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

@@ -1,52 +1,7 @@
-/**
- *  @typedef {TransmissionTypes.DocumentType} DocumentType
- *  @typedef {TransmissionTypes.SchemaType} SchemaType
- *  @typedef {TransmissionTypes.HashType} HashType
- */
-
 import debug from 'debug'
 
-import {
-  toString,
-  isArray,
-  getUri
-} from '#transmission/transmission/common'
-
-import {
-  transformArray
-} from '#transmission/transmission/from-document-to-hash'
-
 const log = debug('shinkansen-transmission/from-document-to-hash/array')
 
 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 transformArraySchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
-  log('transformArraySchema')
-
-  /*
-   *  Is `document` an array?
-   */
-  if (isArray(document)) {
-    /*
-     *  Yes, `document` is an array
-     */
-    return transformArray(document, schema, hash, parentUri, uri)
-  }
-
-  /*
-   *  The hash should contain only strings
-   */
-  hash[uri] = toString(document)
-
-  return hash
-}
+export { transformArraySchema as default } from '#transmission/transmission/from-document-to-hash'

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

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

package/src/transmission/from-document-to-hash/boolean/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/boolean')
@@ -37,25 +37,25 @@ export default function transformBooleanSchema (document, schema = {}, hash = {}
 
   if (hasEnum(schema)) {
     const array = getEnum(schema)
-    const index = getIndexByValue(array, document)
+    const value = transformIndexToValueByFindValue(array, document)
 
-    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-document-to-hash/index.d.mts

@@ -3,9 +3,16 @@ export type SchemaType = TransmissionTypes.SchemaType
 export type HashType = TransmissionTypes.HashType
 
 export function transformArrayFor (document: DocumentType[], schema: SchemaType, hash: HashType, parentUri: string): HashType
-export function transformObjectFor (document: Record<string, DocumentType>, schema: SchemaType, hash: HashType, parentUri: string): HashType
-
 export function transformArray (document: DocumentType[], schema: SchemaType, hash: HashType, parentUri: string, uri: string): HashType
+export function transformArraySchema (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType
+
+export function transformObjectFor (document: Record<string, DocumentType>, schema: SchemaType, hash: HashType, parentUri: string): HashType
 export function transformObject (document: Record<string, DocumentType>, schema: SchemaType, hash: HashType, parentUri: string, uri: string): HashType
+export function transformObjectSchema (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType
+
+export { default as transformStringSchema } from './string/index.mjs'
+export { default as transformNumberSchema } from './number/index.mjs'
+export { default as transformBooleanSchema } from './boolean/index.mjs'
+export { default as transformNullSchema } from './null/index.mjs'
 
-export default function transform (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType
+export default function fromDocumentToHash (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType

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

@@ -18,8 +18,8 @@ import {
   hasOneOf,
   getOneOf,
   getUri,
-  getIndexByValue,
-  getIndexByEqual,
+  transformIndexToValueByFindValue,
+  transformIndexToValueByFindEqual,
   transformToValue
 } from '#transmission/transmission/common'
 
@@ -44,25 +44,7 @@ function getReduceArrayFor (schema, parentUri) {
   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)
+    return fromDocumentToHash(document, getSchema(schema, parentUri, schemaUri), hash, schemaUri, schemaUri)
   }
 }
 
@@ -84,24 +66,6 @@ export function transformArrayFor (document, schema, hash, parentUri) { // }, ur
   )
 }
 
-/**
- *  @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(getReduceObjectFor(schema, parentUri), hash)
-  )
-}
-
 /**
  *  @param {Array<DocumentType>} document
  *  @param {SchemaType} schema
@@ -117,22 +81,25 @@ export function transformArray (document, schema, hash, parentUri, uri) {
 
   if (hasEnum(schema)) {
     const array = getEnum(schema)
+    const value = transformIndexToValueByFindEqual(array, document)
 
-    hash[uri] = document.map((value) => String(getIndexByValue(array, value)))
+    hash[uri] = value
 
     return hash
   } else {
     if (hasAnyOf(schema)) {
       const array = getAnyOf(schema)
+      const value = transformIndexToValueByFindEqual(array, document)
 
-      hash[uri] = document.map((value) => String(getIndexByValue(array, value)))
+      hash[uri] = value
 
       return hash
     } else {
       if (hasOneOf(schema)) {
         const array = getOneOf(schema)
+        const value = transformIndexToValueByFindEqual(array, document)
 
-        hash[uri] = document.map((value) => String(getIndexByValue(array, value)))
+        hash[uri] = value
 
         return hash
       }
@@ -145,6 +112,73 @@ export function transformArray (document, schema, hash, parentUri, uri) {
   return transformArrayFor(document, schema, hash, parentUri) // , uri) // schema not items
 }
 
+/**
+ *  Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export function transformArraySchema (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
+  log('transformArraySchema')
+
+  /*
+   *  Is `document` an array?
+   */
+  if (isArray(document)) {
+    /*
+     *  Yes, `document` is an array
+     */
+    return transformArray(document, schema, hash, parentUri, uri)
+  }
+
+  /*
+   *  The hash should contain only strings
+   */
+  hash[uri] = toString(document)
+
+  return hash
+}
+
+/**
+ *  @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 fromDocumentToHash(document, getSchema(schema, parentUri, schemaUri), hash, schemaUri, schemaUri)
+  }
+}
+
+/**
+ *  @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(getReduceObjectFor(schema, parentUri), hash)
+  )
+}
+
 /**
  *  @param {Record<string, DocumentType>} document
  *  @param {SchemaType} schema
@@ -160,33 +194,29 @@ export function transformObject (document, schema, hash, parentUri, uri) {
 
   if (hasEnum(schema)) {
     const array = getEnum(schema)
-    const index = String(getIndexByEqual(array, document))
+    const value = transformIndexToValueByFindEqual(array, document)
 
-    hash[uri] = String(index)
+    hash[uri] = value
 
     return hash
   } else {
     if (hasAnyOf(schema)) {
       const array = getAnyOf(schema)
-      const index = String(getIndexByEqual(array, document))
+      const value = transformIndexToValueByFindEqual(array, document)
 
-      hash[uri] = String(index)
+      hash[uri] = value
 
       return hash
     } else {
       if (hasOneOf(schema)) {
         const array = getOneOf(schema)
-        const index = String(getIndexByEqual(array, document))
+        const value = transformIndexToValueByFindEqual(array, document)
 
-        hash[uri] = String(index)
+        hash[uri] = value
 
         return hash
       }
     }
-
-    /**
-     *  We don't look at `properties` here like we look at `items` in `transformArray`
-     */
   }
 
   /*
@@ -205,7 +235,38 @@ export function transformObject (document, schema, hash, parentUri, uri) {
  *  @param {string} [uri]
  *  @returns {HashType}
  */
-export default function transform (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
+export 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
+}
+
+/**
+ *  Document can be `undefined`
+ *
+ *  @param {DocumentType} [document]
+ *  @param {SchemaType} [schema]
+ *  @param {HashType} [hash]
+ *  @param {string} [parentUri]
+ *  @param {string} [uri]
+ *  @returns {HashType}
+ */
+export default function fromDocumentToHash (document, schema = {}, hash = {}, parentUri = '#', uri = getUri(parentUri)) {
   log('fromDocumentToHash')
 
   /*
@@ -233,9 +294,9 @@ export default function transform (document, schema = {}, hash = {}, parentUri =
        */
       if (hasEnum(schema)) {
         const array = getEnum(schema)
-        const index = getIndexByValue(array, document)
+        const value = transformIndexToValueByFindValue(array, document)
 
-        hash[uri] = String(index)
+        hash[uri] = value
 
         return hash
       } else {
@@ -244,20 +305,20 @@ export default function transform (document, schema = {}, hash = {}, parentUri =
          */
         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 {
           /**
-           *  Is the schema an `oneOf`?
+           *  Is the schema a `oneOf`?
            */
           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-document-to-hash/null/index.d.mts

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

package/src/transmission/from-document-to-hash/null/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/null')
@@ -37,25 +37,25 @@ export default function transformNullSchema (document, schema = {}, hash = {}, p
 
   if (hasEnum(schema)) {
     const array = getEnum(schema)
-    const index = getIndexByValue(array, document)
+    const value = transformIndexToValueByFindValue(array, document)
 
-    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-document-to-hash/number/index.d.mts

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

package/src/transmission/from-document-to-hash/number/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/number')
@@ -37,25 +37,25 @@ export default function transformNumberSchema (document, schema = {}, hash = {},
 
   if (hasEnum(schema)) {
     const array = getEnum(schema)
-    const index = getIndexByValue(array, document)
+    const value = transformIndexToValueByFindValue(array, document)
 
-    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-document-to-hash/object/index.d.mts

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