shinkansen-transmission 2.3.3 → 2.3.5

package/index.d.mts

@@ -73,17 +73,29 @@ declare global {
       pattern?: RegExp
     }
 
-    export interface StringSchemaType extends SchemaType {}
+    export interface StringSchemaType extends SchemaType {
+      type?: 'string'
+    }
 
-    export interface NumberSchemaType extends SchemaType {}
+    export interface NumberSchemaType extends SchemaType {
+      type?: 'number'
+    }
 
-    export interface ArraySchemaType extends SchemaType {}
+    export interface ArraySchemaType extends SchemaType {
+      type?: 'array'
+    }
 
-    export interface ObjectSchemaType extends SchemaType {}
+    export interface ObjectSchemaType extends SchemaType {
+      type?: 'object'
+    }
 
-    export interface BooleanSchemaType extends SchemaType {}
+    export interface BooleanSchemaType extends SchemaType {
+      type?: 'boolean'
+    }
 
-    export interface NullSchemaType extends SchemaType {}
+    export interface NullSchemaType extends SchemaType {
+      type?: 'null'
+    }
 
     /**
      *  String keys with string or string array values
@@ -93,9 +105,16 @@ declare global {
     interface MetaType extends ObjectType {
       parentUri?: string
       uri?: string
+      schema?: SchemaType
+      rootSchema?: SchemaType
+      value?: string
+      defaultValue?: string
+      item?: number
+      name?: string
       selectedItems?: SelectedItemsType
       items?: ItemsType
-      item?: number
+      isRequired?: boolean
+      component?: string
     }
 
     interface ElementsType extends ObjectType {
@@ -104,14 +123,26 @@ declare global {
     }
 
     export namespace Transmission {
-      export interface StringMetaType extends MetaType {
+      interface TransmissionMetaType extends MetaType {}
+
+      interface TransmissionElementsType extends ElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+        fields?: Array<{
+          meta?: TransmissionMetaType
+          elements?: TransmissionElementsType
+        }>
+      }
+
+      export interface StringMetaType extends TransmissionMetaType {
         minLength?: number
         maxLength?: number
         pattern?: RegExp
-        defaultValue?: string
       }
 
-      export interface NumberMetaType extends MetaType {
+      export interface NumberMetaType extends TransmissionMetaType {
         min?: number
         max?: number
         step?: number
@@ -119,59 +150,34 @@ declare global {
         isExclusiveMax?: boolean
       }
 
-      export interface ArrayMetaType extends MetaType {}
+      export interface ArrayMetaType extends TransmissionMetaType {
+        minItems?: number
+        maxItems?: number
+        hasUniqueItems?: boolean
+        minContains?: number
+        maxContains?: number
+      }
 
-      export interface ObjectMetaType extends MetaType {}
+      export interface ObjectMetaType extends TransmissionMetaType {
+        minProperties?: number
+        maxProperties?: number
+      }
 
-      export interface BooleanMetaType extends MetaType {}
+      export interface BooleanMetaType extends TransmissionMetaType {}
 
-      export interface NullMetaType extends MetaType {}
+      export interface NullMetaType extends TransmissionMetaType {}
 
-      export interface StringElementsType extends ElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface StringElementsType extends TransmissionElementsType {}
 
-      export interface NumberElementsType extends ElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface NumberElementsType extends TransmissionElementsType {}
 
-      export interface ArrayElementsType extends ElementsType {
-        field?: FieldType
-        fields?: Array<{
-          meta?: MetaType
-          elements?: ElementsType
-        }>
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface ArrayElementsType extends TransmissionElementsType {}
 
-      export interface ObjectElementsType extends ElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface ObjectElementsType extends TransmissionElementsType {}
 
-      export interface BooleanElementsType extends ElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface BooleanElementsType extends TransmissionElementsType {}
 
-      export interface NullElementsType extends ElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface NullElementsType extends TransmissionElementsType {}
 
       interface TransmissionType {
         meta?: StringMetaType
@@ -212,21 +218,20 @@ declare global {
     export namespace Zashiki {
       interface ZashikiMetaType extends MetaType {
         type?: string
-        schema?: SchemaType
-        value?: string
-        component?: string
       }
 
       interface ZashikiElementsType extends ElementsType {
-        title?: string
-        description?: string
+        field?: FieldType
+        fields?: Array<{
+          meta?: ZashikiMetaType
+          elements?: ZashikiElementsType
+        }>
       }
 
       export interface StringMetaType extends ZashikiMetaType {
         minLength?: number
         maxLength?: number
         pattern?: RegExp
-        defaultValue?: string
       }
 
       export interface NumberMetaType extends ZashikiMetaType {
@@ -237,59 +242,34 @@ declare global {
         isExclusiveMax?: boolean
       }
 
-      export interface ArrayMetaType extends ZashikiMetaType {}
+      export interface ArrayMetaType extends ZashikiMetaType {
+        minItems?: number
+        maxItems?: number
+        hasUniqueItems?: boolean
+        minContains?: number
+        maxContains?: number
+      }
 
-      export interface ObjectMetaType extends ZashikiMetaType {}
+      export interface ObjectMetaType extends ZashikiMetaType {
+        minProperties?: number
+        maxProperties?: number
+      }
 
       export interface BooleanMetaType extends ZashikiMetaType {}
 
       export interface NullMetaType extends ZashikiMetaType {}
 
-      export interface StringElementsType extends ZashikiElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface StringElementsType extends ZashikiElementsType {}
 
-      export interface NumberElementsType extends ZashikiElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface NumberElementsType extends ZashikiElementsType {}
 
-      export interface ArrayElementsType extends ZashikiElementsType {
-        field?: FieldType
-        fields?: Array<{
-          meta?: ZashikiMetaType
-          elements?: ZashikiElementsType
-        }>
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface ArrayElementsType extends ZashikiElementsType {}
 
-      export interface ObjectElementsType extends ZashikiElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface ObjectElementsType extends ZashikiElementsType {}
 
-      export interface BooleanElementsType extends ZashikiElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface BooleanElementsType extends ZashikiElementsType {}
 
-      export interface NullElementsType extends ZashikiElementsType {
-        field?: FieldType
-        enum?: EnumType
-        anyOf?: AnyOfType
-        oneOf?: OneOfType
-      }
+      export interface NullElementsType extends ZashikiElementsType {}
 
       interface ZashikiType {
         meta?: ZashikiMetaType

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shinkansen-transmission",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "description": "Shinkansen Transmission",
   "keywords": [
     "Shinkansen",
@@ -19,7 +19,7 @@
   },
   "license": "ISC",
   "engines": {
-    "node": ">=18.12.0"
+    "node": ">=23.0.0"
   },
   "repository": {
     "type": "git",

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

@@ -63,10 +63,10 @@ export function getMetaValue (values?: ValuesType, uri?: string, schema?: Schema
 
 export function transformToValue (schema?: string | number | object | boolean | null): string | number | object | boolean | null | undefined
 
-export function findByKey (parentUri: string, uri: string): (key: string | number) => boolean
-export function findByIndex (parentUri: string, uri: string): (item: SchemaType, index: number) => boolean
-export function findByValue (value?: string | number | object | boolean | null): (item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean
-export function findByEqual (value?: string | number | object | boolean | null): (item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean
+export function getFindByKey (parentUri: string, uri: string): (key: string | number) => boolean
+export function getFindByIndex (parentUri: string, uri: string): (item: SchemaType, index: number) => boolean
+export function getFindByValue (value?: string | number | object | boolean | null): (item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean
+export function getFindByEqual (value?: string | number | object | boolean | null): (item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean
 
 export function toString (value?: string | number | object | boolean | null): string
 
@@ -97,6 +97,9 @@ export { getSchema }
 export function transformValueIndexFor (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): string
 export function transformEqualIndexFor (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): string
 
+export function getIndexByValue (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): number
+export function getIndexByEqual (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): number
+
 export function hasValue (values?: ValuesType, uri?: string, schema?: SchemaType): boolean
 export function getValue (values?: ValuesType, uri?: string, schema?: SchemaType): string
 

package/src/transmission/common/index.mjs

@@ -308,8 +308,12 @@ export function getMetaValue (values = {}, uri = '#', schema = {}) {
  *  @returns {string | number | object | boolean | null | undefined}
  */
 export function transformToValue (item) {
+  if (item === undefined) return item
+
   if (isPrimitive(item)) return item
 
+  if (isArray(item)) return item // .map(transformToValue)
+
   if (isObject(item)) {
     if (hasConst(item)) {
       return getConst(item)
@@ -318,9 +322,9 @@ export function transformToValue (item) {
         return getDefault(item)
       }
     }
-  }
 
-  return item
+    return item
+  }
 }
 
 /**
@@ -328,15 +332,14 @@ export function transformToValue (item) {
  *  @param {string} uri
  *  @returns {(key: string | number) => boolean}
  */
-export function findByKey (parentUri, uri) {
+export function getFindByKey (parentUri, uri) {
   /*
-   *  log('findByKey')
+   *  log('getFindByKey')
    */
   return function find (key) {
     /*
      *  log('find')
      */
-
     return (
       getUri(parentUri, key) === uri
     )
@@ -346,51 +349,16 @@ export function findByKey (parentUri, uri) {
 /**
  *  @param {string} parentUri
  *  @param {string} uri
- *  @returns {(item: SchemaType, index: number) => boolean}
+ *  @returns {(schema: SchemaType, index: number) => boolean}
  */
-export function findByIndex (parentUri, uri) {
+export function getFindByIndex (parentUri, uri) {
   /*
-   *  log('findByIndex')
+   *  log('getFindByIndex')
    */
-  return function find (item, index) {
+  return function find (schema, index) {
     /*
      *  log('find')
      */
-
-    /**
-     *  It's a schema not a value
-     */
-
-    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))
-          )
-        }
-      }
-    }
-
-    /**
-     *  It's any other kind of schema/sub-schema
-     */
-
     return (
       getUri(parentUri, index) === uri
     )
@@ -401,15 +369,14 @@ export function findByIndex (parentUri, 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) {
+export function getFindByValue (value) {
   /*
-   *  log('findByValue')
+   *  log('getFindByValue')
    */
   return function find (item) {
     /*
      *  log('find')
      */
-
     return (
       value === transformToValue(item)
     )
@@ -420,9 +387,9 @@ export function findByValue (value) {
  *  @param {string | number | object | boolean | null} [value]
  *  @returns {(item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean}
  */
-export function findByEqual (value) {
+export function getFindByEqual (value) {
   /*
-   *  log('findByEqual')
+   *  log('getFindByEqual')
    */
   return function find (item) {
     /*
@@ -455,15 +422,17 @@ export function getArray ({ items /* array or object */ } = {}, parentUri = '',
    */
 
   if (isArray(items)) {
-    const find = findByIndex(parentUri, uri)
-
     return (
-      items.find(find)
+      items.find(getFindByIndex(parentUri, uri))
     )
+  } else {
+    if (isObject(items)) {
+      return (
+        items
+      )
+    }
   }
 
-  if (isObject(items)) return items
-
   return undefined
 }
 
@@ -479,8 +448,7 @@ export function getObject ({ properties /* object */ } = {}, parentUri = '', uri
    */
 
   if (isObject(properties)) {
-    const find = findByKey(parentUri, uri)
-    const key = Object.keys(properties).find(find)
+    const key = Object.keys(properties).find(getFindByKey(parentUri, uri))
 
     if (key) {
       return (
@@ -543,14 +511,14 @@ export function transformValueIndexFor (array, value) {
    *  log('transformEqualIndexFor')
    */
 
-  const find = findByValue(value)
+  const find = getFindByValue(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)
   }
 
@@ -560,6 +528,21 @@ export function transformValueIndexFor (array, value) {
   return toString(value)
 }
 
+/**
+ *  @param {string[] | number[] | object[] | boolean[] | null[]} array
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {number}
+ */
+export function getIndexByValue (array, value) {
+  /*
+   *  log('transformEqualIndexFor')
+   */
+
+  return (
+    array.findIndex(getFindByValue(value))
+  )
+}
+
 /**
  *  @param {string[] | number[] | object[] | boolean[] | null[]} array
  *  @param {string | number | object | boolean | null} [value]
@@ -570,7 +553,7 @@ export function transformEqualIndexFor (array, value) {
    *  log('transformEqualIndexFor')
    */
 
-  const find = findByEqual(value)
+  const find = getFindByEqual(value)
 
   if (array.some(find)) {
     const index = array.findIndex(find)
@@ -587,6 +570,21 @@ export function transformEqualIndexFor (array, value) {
   return toString(value)
 }
 
+/**
+ *  @param {string[] | number[] | object[] | boolean[] | null[]} array
+ *  @param {string | number | object | boolean | null} [value]
+ *  @returns {string}
+ */
+export function getIndexByEqual (array, value) {
+  /*
+   *  log('transformEqualIndexFor')
+   */
+
+  return (
+    array.findIndex(getFindByEqual(value))
+  )
+}
+
 /**
  *  @param {ValuesType} [values]
  *  @param {string} [uri]

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

@@ -21,7 +21,7 @@ const log = debug('shinkansen-transmission/from-document-to-hash/array')
 log('`shinkansen` is awake')
 
 /**
- * Document can be `undefined`
+ *  Document can be `undefined`
  *
  *  @param {DocumentType} [document]
  *  @param {SchemaType} [schema]

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

@@ -15,7 +15,7 @@ import {
   hasOneOf,
   getOneOf,
   getUri,
-  transformValueIndexFor
+  getIndexByValue
 } from '#transmission/transmission/common'
 
 const log = debug('shinkansen-transmission/from-document-to-hash/boolean')
@@ -23,7 +23,7 @@ const log = debug('shinkansen-transmission/from-document-to-hash/boolean')
 log('`shinkansen` is awake')
 
 /**
- * Document can be `undefined`
+ *  Document can be `undefined`
  *
  *  @param {DocumentType} [document]
  *  @param {SchemaType} [schema]
@@ -36,23 +36,26 @@ export default function transformBooleanSchema (document, schema = {}, hash = {}
   log('transformBooleanSchema')
 
   if (hasEnum(schema)) {
-    const items = getEnum(schema)
+    const array = getEnum(schema)
+    const index = getIndexByValue(array, document)
 
-    hash[uri] = transformValueIndexFor(items, document)
+    hash[uri] = String(index)
 
     return hash
   } else {
     if (hasAnyOf(schema)) {
-      const items = getAnyOf(schema)
+      const array = getAnyOf(schema)
+      const index = getIndexByValue(array, document)
 
-      hash[uri] = transformValueIndexFor(items, document)
+      hash[uri] = String(index)
 
       return hash
     } else {
       if (hasOneOf(schema)) {
-        const items = getOneOf(schema)
+        const array = getOneOf(schema)
+        const index = getIndexByValue(array, document)
 
-        hash[uri] = transformValueIndexFor(items, document)
+        hash[uri] = String(index)
 
         return hash
       }

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

@@ -2,10 +2,10 @@ export type DocumentType = TransmissionTypes.DocumentType
 export type SchemaType = TransmissionTypes.SchemaType
 export type HashType = TransmissionTypes.HashType
 
-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
+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: { 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 transformArray (document: DocumentType[], schema: SchemaType, hash: HashType, parentUri: string, uri: string): HashType
+export function transformObject (document: Record<string, DocumentType>, schema: SchemaType, hash: HashType, parentUri: string, uri: string): HashType
 
 export default function transform (document?: DocumentType, schema?: SchemaType, hash?: HashType, parentUri?: string, uri?: string): HashType