shinkansen-transmission 2.2.234 → 2.3.0

package/babel.config.cjs

@@ -38,6 +38,7 @@ const presets = [
   ]
 ]
 
+// @ts-ignore
 module.exports = (api) => {
   if (api) api.cache.using(env)
 

package/eslint.config.mjs

@@ -1,5 +1,7 @@
 import globals from 'globals'
+// @ts-ignore
 import standard from '@sequencemedia/eslint-config-standard/configs/recommended/merge'
+// @ts-ignore
 import typescript from '@sequencemedia/eslint-config-typescript/configs/recommended/merge'
 
 export default [
@@ -15,24 +17,22 @@ export default [
     files: [
       '**/*.{mjs,cjs,mts,cts}'
     ],
-    ignores: [
-      'src',
-      'test'
-    ],
     languageOptions: {
       globals: {
         ...globals.node
       }
-    }
-  }),
-  standard({
-    files: [
-      'src/**/*.{mjs,cjs,mts,cts}'
-    ],
-    languageOptions: {
-      globals: {
-        ...globals.browser
-      }
+    },
+    rules: {
+      '@stylistic/object-curly-newline': [
+        'error',
+        {
+          ImportDeclaration: 'always',
+          ExportDeclaration: {
+            multiline: true,
+            minProperties: 2
+          }
+        }
+      ]
     }
   }),
   standard({
@@ -52,29 +52,27 @@ export default [
     files: [
       '**/*.{mts,cts}'
     ],
-    ignores: [
-      'src',
-      'test'
-    ],
     languageOptions: {
       globals: {
-        ...globals.node
+        ...globals.node,
+        TransmissionTypes: 'readonly'
       }
+    },
+    rules: {
+      '@typescript-eslint/max-params': [
+        'error',
+        {
+          max: 5
+        }
+      ]
     }
   }),
-  typescript({
+  {
     files: [
-      'src/**/*.{mts,cts}',
-      'test/**/*.{mts,cts}'
+      'src/**/*.d.{mts,cts}'
     ],
-    languageOptions: {
-      globals: {
-        ...globals.browser,
-        ZashikiTypes: 'readonly'
-      }
-    },
     rules: {
-      '@typescript-eslint/max-params': ['error', { max: 5 }]
+      'no-redeclare': 'off'
     }
-  })
+  }
 ]

package/index.d.mts

@@ -1,45 +1,350 @@
 declare global {
-  namespace ZashikiTypes {
+  namespace TransmissionTypes {
     export type ObjectLiteralType = Record<PropertyKey, never>
     export type ObjectType = Record<PropertyKey, unknown>
     export type ArrayLiteralType = never[]
     export type ArrayType = unknown[]
 
+    export type ItemsType = string[] | number[] | object[] | boolean[] | null[]
+
+    export type SelectedItemsType = Array<string | number | boolean | null>
+
+    export interface EnumType {
+      id: string
+      name?: string
+      items?: ItemsType
+      selectedItems?: SelectedItemsType
+    }
+
+    export interface AnyOfType {
+      id: string
+      name?: string
+      items?: ItemsType
+      selectedItems?: SelectedItemsType
+    }
+
+    export interface OneOfType {
+      id: string
+      name?: string
+      items?: ItemsType
+      selectedItems?: SelectedItemsType
+    }
+
+    export interface FieldType {
+      id: string
+      name?: string
+      items?: ItemsType
+      selectedItems?: SelectedItemsType
+      value?: string | number | boolean | null | object | ItemsType
+      defaultValue?: string | number | boolean | null | object | ItemsType
+    }
+
     export interface SchemaType {
-      type: string
+      $id?: string
+      $schema?: string
+      type?: string
       title?: string
       description?: string
+      required?: string[]
       readOnly?: boolean
       writeOnly?: boolean
-      const?: unknown
-      default?: unknown
-      enum?: ObjectType | ObjectLiteralType | ArrayType | ArrayLiteralType
-      anyOf?: ObjectType | ObjectLiteralType | ArrayType | ArrayLiteralType
-      oneOf?: ObjectType | ObjectLiteralType | ArrayType | ArrayLiteralType
-      allOf: ObjectType | ObjectLiteralType | ArrayType | ArrayLiteralType
+      const?: string | number | object | boolean | null
+      default?: string | number | object | boolean | null
+      enum?: ItemsType
+      anyOf?: ItemsType
+      oneOf?: ItemsType
+      allOf?: ItemsType
       minimum?: number
       maximum?: number
       minLength?: number
       maxLength?: number
       minItems?: number
       maxItems?: number
-      hasUniqueItems?: boolean
+      uniqueItems?: boolean
       minContains?: number
       maxContains?: number
       minProperties?: number
       maxProperties?: number
-      isExclusiveMin?: boolean
-      isExclusiveMax?: boolean
+      exclusiveMinimum?: boolean
+      exclusiveMaximum?: boolean
       multipleOf?: number
+      items?: SchemaType | SchemaType[]
+      properties?: Record<string, SchemaType>
+      pattern?: RegExp
+    }
+
+    export interface StringSchemaType extends SchemaType {}
+
+    export interface NumberSchemaType extends SchemaType {}
+
+    export interface ArraySchemaType extends SchemaType {}
+
+    export interface ObjectSchemaType extends SchemaType {}
+
+    export interface BooleanSchemaType extends SchemaType {}
+
+    export interface NullSchemaType extends SchemaType {}
+
+    /**
+     *  String keys with string or string array values
+     */
+    export type ValuesType = Record<string, string | string[]> | Record<string, never>
+
+    interface MetaType extends ObjectType {
+      parentUri?: string
+      uri?: string
+      selectedItems?: SelectedItemsType
+      items?: ItemsType
+      item?: number
+    }
+
+    interface ElementsType extends ObjectType {
+      title?: string
+      description?: string
+    }
+
+    export namespace Transmission {
+      export interface StringMetaType extends MetaType {
+        minLength?: number
+        maxLength?: number
+        pattern?: RegExp
+        defaultValue?: string
+      }
+
+      export interface NumberMetaType extends MetaType {
+        min?: number
+        max?: number
+        step?: number
+        isExclusiveMin?: boolean
+        isExclusiveMax?: boolean
+      }
+
+      export interface ArrayMetaType extends MetaType {}
+
+      export interface ObjectMetaType extends MetaType {}
+
+      export interface BooleanMetaType extends MetaType {}
+
+      export interface NullMetaType extends MetaType {}
+
+      export interface StringElementsType extends ElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface NumberElementsType extends ElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface ArrayElementsType extends ElementsType {
+        field?: FieldType
+        fields?: Array<{
+          meta?: MetaType
+          elements?: ElementsType
+        }>
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface ObjectElementsType extends ElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface BooleanElementsType extends ElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface NullElementsType extends ElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      interface TransmissionType {
+        meta?: StringMetaType
+        elements?: StringElementsType
+      }
+
+      export interface StringType {
+        meta?: StringMetaType
+        elements?: StringElementsType
+      }
+
+      export interface NumberType {
+        meta?: NumberMetaType
+        elements?: NumberElementsType
+      }
+
+      export interface ArrayType {
+        meta?: ArrayMetaType
+        elements?: ArrayElementsType
+      }
+
+      export interface ObjectType {
+        meta?: ObjectMetaType
+        elements?: ObjectElementsType
+      }
+
+      export interface BooleanType {
+        meta?: BooleanMetaType
+        elements?: BooleanElementsType
+      }
+
+      export interface NullType {
+        meta?: NullMetaType
+        elements?: NullElementsType
+      }
     }
 
-    export type DocumentType = string | number | boolean | null | ObjectType | ObjectLiteralType | ArrayType | ArrayLiteralType | undefined
-    export type HashType = Record<PropertyKey, string> | Record<PropertyKey, never>
+    export namespace Zashiki {
+      interface ZashikiMetaType extends MetaType {
+        type?: string
+        schema?: SchemaType
+        value?: string
+        component?: string
+      }
+
+      interface ZashikiElementsType extends ElementsType {
+        title?: string
+        description?: string
+      }
+
+      export interface StringMetaType extends ZashikiMetaType {
+        minLength?: number
+        maxLength?: number
+        pattern?: RegExp
+        defaultValue?: string
+      }
+
+      export interface NumberMetaType extends ZashikiMetaType {
+        min?: number
+        max?: number
+        step?: number
+        isExclusiveMin?: boolean
+        isExclusiveMax?: boolean
+      }
+
+      export interface ArrayMetaType extends ZashikiMetaType {}
+
+      export interface ObjectMetaType extends ZashikiMetaType {}
+
+      export interface BooleanMetaType extends ZashikiMetaType {}
+
+      export interface NullMetaType extends ZashikiMetaType {}
 
-    export interface ZashikiType {
-      meta: ObjectType | ObjectLiteralType
-      elements: ObjectType | ObjectLiteralType
+      export interface StringElementsType extends ZashikiElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface NumberElementsType extends ZashikiElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface ArrayElementsType extends ZashikiElementsType {
+        field?: FieldType
+        fields?: Array<{
+          meta?: ZashikiMetaType
+          elements?: ZashikiElementsType
+        }>
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface ObjectElementsType extends ZashikiElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface BooleanElementsType extends ZashikiElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      export interface NullElementsType extends ZashikiElementsType {
+        field?: FieldType
+        enum?: EnumType
+        anyOf?: AnyOfType
+        oneOf?: OneOfType
+      }
+
+      interface ZashikiType {
+        meta?: ZashikiMetaType
+        elements?: ZashikiElementsType
+      }
+
+      export interface StringType {
+        meta?: StringMetaType
+        elements?: StringElementsType
+      }
+
+      export interface NumberType {
+        meta?: NumberMetaType
+        elements?: NumberElementsType
+      }
+
+      export interface ArrayType {
+        meta?: ArrayMetaType
+        elements?: ArrayElementsType
+      }
+
+      export interface ObjectType {
+        meta?: ObjectMetaType
+        elements?: ObjectElementsType
+      }
+
+      export interface BooleanType {
+        meta?: BooleanMetaType
+        elements?: BooleanElementsType
+      }
+
+      export interface NullType {
+        meta?: NullMetaType
+        elements?: NullElementsType
+      }
     }
+
+    export type ParamsType = Record<string, Transmission.StringType | Transmission.NumberType | Transmission.ArrayType | Transmission.ObjectType | Transmission.BooleanType | Transmission.NullType> & {
+      parentUri?: string
+      uri?: string
+      key?: string
+      index?: number
+      required?: string[]
+      fields?: Array<Transmission.StringType | Transmission.NumberType | Transmission.ArrayType | Transmission.ObjectType | Transmission.BooleanType | Transmission.NullType>
+    }
+
+    /**
+     *  A JSON Schema document
+     */
+    export type DocumentType = string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]
+
+    /**
+     *  String keys with string or string array values
+     */
+    export type HashType = Record<string, string | string[]> | Record<string, never>
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shinkansen-transmission",
-  "version": "2.2.234",
+  "version": "2.3.0",
   "description": "Shinkansen Transmission",
   "keywords": [
     "Shinkansen",
@@ -44,20 +44,20 @@
     "@babel/eslint-parser": "^7.26.8",
     "@babel/preset-env": "^7.26.9",
     "@babel/register": "^7.25.9",
-    "@sequencemedia/eslint-config-standard": "^0.2.28",
-    "@sequencemedia/eslint-config-typescript": "^0.1.39",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
+    "@sequencemedia/eslint-config-standard": "^0.2.29",
+    "@sequencemedia/eslint-config-typescript": "^0.1.43",
+    "@types/babel__register": "^7.17.3",
+    "@types/chai": "^5.0.1",
+    "@types/debug": "^4.1.12",
+    "@types/mocha": "^10.0.10",
     "c8": "^10.1.3",
     "chai": "^5.2.0",
     "core-js": "^3.40.0",
     "cross-env": "^7.0.3",
     "eslint": "^9.21.0",
-    "eslint-import-resolver-babel-module": "^5.3.2",
     "globals": "^16.0.0",
     "husky": "^9.1.7",
-    "mocha": "^11.1.0",
-    "rimraf": "^6.0.1"
+    "mocha": "^11.1.0"
   },
   "imports": {
     "#transmission": "./src/index.mjs",

package/src/index.cjs

@@ -1,3 +1,5 @@
+// @ts-nocheck
+
 require('@babel/register')({
   ignore: [
     /node_modules\/(?!shinkansen|@modernpoacher)/

package/src/index.d.mts

@@ -1,10 +1,11 @@
-declare module '#transmission' {
-  export * as common from '#transmission/transmission/common'
-  export { default as fromDocumentToHash } from '#transmission/transmission/from-document-to-hash'
-  export { default as fromHashToDocument } from '#transmission/transmission/from-hash-to-document'
-  export { default as toZashiki } from '#transmission/transmission/to-zashiki'
-}
+export type SchemaType = TransmissionTypes.SchemaType
 
-declare module 'shinkansen-transmission' {
-  export * from '#transmission'
-}
+export type DocumentType = TransmissionTypes.DocumentType
+export type HashType = TransmissionTypes.HashType
+
+export type ZashikiType = TransmissionTypes.Zashiki.ZashikiType
+
+export * as common from '#transmission/transmission/common'
+export { default as fromDocumentToHash } from '#transmission/transmission/from-document-to-hash'
+export { default as fromHashToDocument } from '#transmission/transmission/from-hash-to-document'
+export { default as toZashiki } from '#transmission/transmission/to-zashiki'