@dmdata/telegram-json-types 1.0.5 → 1.0.9-jschema.0

package/dist/jschema-load.d.ts

@@ -0,0 +1 @@
+export declare function getJSchema(name: string): Promise<any> | null;

package/dist/jschema-load.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSchema = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("./config");
+const schemas = new Map();
+const jschemaList = (0, fs_1.readdirSync)(config_1.distDir).filter(file => /\.json$/.test(file));
+jschemaList.forEach(jschema => {
+    schemas.set(jschema.replace('.json', ''), (0, path_1.resolve)(config_1.distDir, jschema));
+});
+function getJSchema(name) {
+    const filePath = schemas.get(name);
+    if (!filePath) {
+        return null;
+    }
+    return Promise.resolve().then(() => __importStar(require(filePath)));
+}
+exports.getJSchema = getJSchema;

package/index.d.ts

@@ -1 +1,2 @@
 export * from './types';
+export * from './dist/jschema-load'

package/jschema/build.ts

@@ -0,0 +1,56 @@
+import { resolve } from 'path';
+import { mkdir, readdir, rm, writeFile } from 'fs/promises';
+import * as TJS from 'typescript-json-schema';
+
+import { basePath, distDir } from './config';
+
+
+
+
+const settings: TJS.PartialArgs = {
+  required: true,
+};
+
+const compilerOptions: TJS.CompilerOptions = {
+  strictNullChecks: true,
+};
+
+readdir(basePath)
+  .then(files => programTypescript(files));
+
+
+async function programTypescript(files: string[]) {
+  const tsTypeFiles = files.filter(file => /\.ts$/.test(file));
+  const filepath = tsTypeFiles.map(file => resolve(basePath, file));
+
+  const program = TJS.getProgramFromFiles(filepath, compilerOptions);
+  const generator = TJS.buildGenerator(program, settings);
+
+  const objectMaps = tsTypeFiles.map(file => tsTypeFileName2TypeSymbolName(file));
+
+  await rm(distDir, { recursive: true, force: true });
+  await mkdir(distDir, { recursive: true });
+  for (let i = 0; i < objectMaps.length; i++) {
+    const { schemaName, typeName } = objectMaps[i];
+    console.log(`Build ok: ${schemaName}: ${typeName}`);
+
+    const schema = generator?.getSchemaForSymbol(typeName, true);
+
+    await writeFile(
+      resolve(distDir, `${schemaName}.json`),
+      JSON.stringify(schema, undefined, 4)
+    );
+  }
+
+  console.log('Build complete');
+}
+
+function tsTypeFileName2TypeSymbolName(file: string) {
+  const schemaName = file.replace(/^([\w-]+?)(\.d)?\.ts$/, '$1');
+  const nameScope = schemaName.replace(/-(\w)|(^\w)/g, (match, p1 = '', p2 = '') => `${p1}${p2}`.toUpperCase());
+
+  return {
+    schemaName,
+    typeName: nameScope + '.Main'
+  };
+}

package/jschema/config.ts

@@ -0,0 +1,4 @@
+import { resolve } from 'path';
+
+export const basePath = resolve(__dirname, '../types/schema/');
+export const distDir = resolve(__dirname, '../dist/jschema/');

package/jschema/jschema-load.ts

@@ -0,0 +1,26 @@
+import { readdirSync } from 'fs';
+import { resolve } from 'path';
+
+import { distDir } from './config';
+
+const schemas = new Map<string, string>();
+
+const jschemaList = readdirSync(distDir).filter(file => /\.json$/.test(file));
+
+jschemaList.forEach(jschema => {
+  schemas.set(
+    jschema.replace('.json', ''),
+    resolve(distDir, jschema)
+  );
+});
+
+
+export function getJSchema(name: string) {
+  const filePath = schemas.get(name);
+
+  if (!filePath) {
+    return null;
+  }
+
+  return import(filePath);
+}

package/package.json

@@ -1,11 +1,21 @@
-{
-  "name": "@dmdata/telegram-json-types",
-  "version": "1.0.5",
-  "scripts": {
-    "publish:npm": "npm publish --access=public"
-  },
-  "types": "index.d.ts",
-  "keywords": [],
-  "author": "",
-  "license": "ISC"
-}
+{
+  "name": "@dmdata/telegram-json-types",
+  "version": "1.0.9-jschema.0",
+  "scripts": {
+    "build:jschema": "npx tsc --project tsconfig.jschema.json",
+    "build:dist-jschema": "npx ts-node ./dist/build.js",
+    "prepublishOnly": "npm run build:jschema && npm run build:dist-jschema",
+    "publish:npm": "npm version patch && npm publish --access=public"
+  },
+  "types": "index.d.ts",
+  "main": "./dist/jschema-load.js",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^14.18.9",
+    "typescript": "^4.5.5",
+    "ts-node": "^10.4.0",
+    "typescript-json-schema": "^0.53.0"
+  }
+}

package/tsconfig.jschema.json

@@ -0,0 +1,16 @@
+{
+  "extends": ".",
+  "compilerOptions": {
+    "declaration": true,
+    "rootDir": "jschema",
+    "outDir": "dist"
+  },
+  "include": [
+    "jschema/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "types",
+    "index.d.ts"
+  ]
+}

package/types/index.d.ts

@@ -1,2 +1,4 @@
-export * from './schema/earthquake-information';
-export * from './schema/weather-typhoon';
+export * from './schema/eew-information';
+export * from './schema/earthquake-information';
+export * from './schema/tsunami-information';
+export * from './schema/weather-typhoon';

package/types/schema/component/coordinate.d.ts

@@ -1,15 +1,15 @@
-import { UnitValue } from './unit-value';
-
-export type Coordinate<Geo = never> = {
-  latitude: { text: string, value: string };
-  longitude: { text: string, value: string };
-  height?: UnitValue<'深さ', 'km'>;
-  condition: undefined;
-  geodeticSystem: Geo;
-} | {
-  latitude: undefined;
-  longitude: undefined;
-  height: undefined;
-  geodeticSystem: never;
-  condition: '不明';
-}
+import { UnitValue } from './unit-value';
+
+export type Coordinate<Geo = never> = {
+  latitude: { text: string, value: string };
+  longitude: { text: string, value: string };
+  height?: UnitValue<'深さ', 'km'>;
+  condition: undefined;
+  geodeticSystem: Geo;
+} | {
+  latitude: never;
+  longitude: never;
+  height: never;
+  geodeticSystem: never;
+  condition: '不明';
+}

package/types/schema/component/earthquake.d.ts

@@ -1,56 +1,56 @@
-import { Coordinate } from './coordinate';
-import { UnitValueNotNull } from './unit-value';
-
-type Depth = {
-  type: '深さ';
-  unit: 'km';
-} & ({
-  value: null;
-  condition: '不明';
-} | {
-  value: '0';
-  condition: 'ごく浅い';
-} | {
-  value: '700';
-  condition: '７００ｋｍ以上';
-} | {
-  value: string;
-  condition: undefined;
-});
-type Magnitude = {
-  type: 'マグニチュード';
-  unit: 'Mj' | 'M';
-} & ({
-  value: null;
-  condition: 'Ｍ不明' | 'Ｍ８を超える巨大地震';
-} | {
-  value: string;
-  condition: undefined;
-});
-
-export interface Earthquake {
-  originTime: string;
-  arrivalTime: string;
-  hypocenter: {
-    name: string;
-    code: string;
-    coordinate: Coordinate<'日本測地系' | undefined>;
-    depth: Depth;
-    detailed?: {
-      code: string;
-      name: string;
-    };
-    auxiliary?: {
-      text: string;
-      code: string;
-      name: string;
-      direction: string;
-      distance: Omit<UnitValueNotNull<never, 'km'>, 'type' | 'condition'>;
-    };
-    source?: 'ＰＴＷＣ' | 'ＵＳＧＳ' | 'ＷＣＡＴＷＣ';
-  };
-  magnitude: Magnitude;
-}
-
-
-
+import { Coordinate } from './coordinate';
+import { UnitValueNotNull } from './unit-value';
+
+type Depth = {
+  type: '深さ';
+  unit: 'km';
+} & ({
+  value: null;
+  condition: '不明';
+} | {
+  value: '0';
+  condition: 'ごく浅い';
+} | {
+  value: '700';
+  condition: '７００ｋｍ以上';
+} | {
+  value: string;
+  condition: never;
+});
+type Magnitude = {
+  type: 'マグニチュード';
+  unit: 'Mj' | 'M';
+} & ({
+  value: null;
+  condition: 'Ｍ不明' | 'Ｍ８を超える巨大地震';
+} | {
+  value: string;
+  condition: never;
+});
+
+export interface Earthquake {
+  originTime: string;
+  arrivalTime: string;
+  hypocenter: {
+    name: string;
+    code: string;
+    coordinate: Coordinate<'日本測地系' | undefined>;
+    depth: Depth;
+    detailed?: {
+      code: string;
+      name: string;
+    };
+    auxiliary?: {
+      text: string;
+      code: string;
+      name: string;
+      direction: string;
+      distance: Omit<UnitValueNotNull<never, 'km'>, 'type' | 'condition'>;
+    };
+    source?: 'ＰＴＷＣ' | 'ＵＳＧＳ' | 'ＷＣＡＴＷＣ';
+  };
+  magnitude: Magnitude;
+}
+
+
+

package/types/schema/earthquake-information.d.ts

@@ -6,29 +6,29 @@ import { UnitValueNotNull } from './component/unit-value';
 export namespace EarthquakeInformation {
   export interface Schema {
     type: 'earthquake-information';
-    version: '1.0.0';
+    version: '1.1.0';
   }
 
-  export type Intensity = '1' | '2' | '3' | '4' | '5-' | '5+' | '6-' | '6+' | '7';
-  export type LpgmIntensity = '0' | '1' | '2' | '3' | '4';
+  export type IntensityClass = '1' | '2' | '3' | '4' | '5-' | '5+' | '6-' | '6+' | '7';
+  export type LpgmIntensityClass = '0' | '1' | '2' | '3' | '4';
   export type LpgmCategory = '1' | '2' | '3' | '4';
 
-  type OnRevise = { revise?: '上方修正' | '追加'; };
   export type IntensityMaxInt = {
     name: string;
     code: string;
-    maxInt: Intensity;
+    maxInt: IntensityClass;
   };
   export type IntensityMaxIntOnRevise = {
     name: string;
     code: string;
-    maxInt?: Intensity;
-  } & OnRevise;
+    maxInt?: IntensityClass;
+    revise?: '上方修正' | '追加';
+  }
 
   export type IntensityCity = {
     name: string;
     code: string;
-    maxInt?: Intensity;
+    maxInt?: IntensityClass;
     revise?: '上方修正' | '追加';
     condition?: '震度５弱以上未入電';
   };
@@ -36,21 +36,21 @@ export namespace EarthquakeInformation {
   export type IntensityStation = {
     name: string;
     code: string;
-    int: Intensity | '!5-';
+    int: IntensityClass | '!5-';
     revise?: '上方修正' | '追加';
     condition?: '震度５弱以上未入電';
   };
 
   export type IntensityLpgmMaxInt = IntensityMaxIntOnRevise & {
-    maxLpgmInt: LpgmIntensity;
+    maxLpgmInt: LpgmIntensityClass;
   };
   export type IntensityLpgmStationPrePeriod = {
     periodicBand: UnitValueNotNull<never, '秒台'>;
-    lpgmInt: LpgmIntensity;
+    lpgmInt: LpgmIntensityClass;
     sva: UnitValueNotNull<never, 'cm/s'>;
   };
   export type IntensityLpgmStation = IntensityStation & {
-    lpgmInt: LpgmIntensity;
+    lpgmInt: LpgmIntensityClass;
     sva: UnitValueNotNull<never, 'cm/s'>;
     prePeriods: IntensityLpgmStationPrePeriod[];
   }
@@ -69,13 +69,13 @@ export namespace EarthquakeInformation {
 
 
   export type IntensityVXSE51 = {
-    maxInt: Intensity;
+    maxInt: IntensityClass;
     prefectures: IntensityMaxInt[];
     regions: IntensityMaxInt[];
   };
 
   export type IntensityVXSE53 = {
-    maxInt: Intensity;
+    maxInt: IntensityClass;
     prefectures: IntensityMaxIntOnRevise[];
     regions: IntensityMaxIntOnRevise[];
     cities: IntensityCity[];
@@ -83,8 +83,8 @@ export namespace EarthquakeInformation {
   };
 
   export type IntensityVXSE62 = {
-    maxInt: Intensity;
-    maxLpgmInt: LpgmIntensity;
+    maxInt: IntensityClass;
+    maxLpgmInt: LpgmIntensityClass;
     lpgmCategory: LpgmCategory;
     prefectures: IntensityLpgmMaxInt[];
     regions: IntensityLpgmMaxInt[];
@@ -167,8 +167,12 @@ export namespace EarthquakeInformation {
   }
 
   export interface Channel extends TelegramJSONMain {
-    infoType: '取消';
+    _schema: Schema;
+    type: '震度速報' | '震源に関する情報' | '震源・震度に関する情報' | '長周期地震動に関する観測情報';
+    title: '震度速報' | '震源に関する情報' | '震源・震度情報' | '遠地地震に関する情報' | '長周期地震動に関する観測情報';
+    infoKind: '震度速報';
     eventId: string;
+    infoType: '取消';
     body: ChancelBody;
   }
 

package/types/schema/eew-information.d.ts

@@ -0,0 +1,167 @@
+import { TelegramJSONMain } from '../main';
+import { Coordinate } from './component/coordinate';
+import { UnitValueNotNull } from './component/unit-value';
+
+
+export namespace EewInformation {
+  export interface Schema {
+    type: 'eew-information';
+    version: '1.0.0';
+  }
+
+  export type IntensityClass = '0' | '1' | '2' | '3' | '4' | '5-' | '5+' | '6-' | '6+' | '7';
+  export type LpgmIntensityClass = '0' | '1' | '2' | '3' | '4';
+
+  export interface WarningAreaKind {
+    code: string;
+    name: string;
+    lastKind: {
+      code: string;
+      name: string;
+    };
+  }
+
+  export interface WarningArea {
+    code: string;
+    name: string;
+    kind: WarningAreaKind;
+  }
+
+  export interface EarthquakeHypocenterReduce {
+    code: string;
+    name: string;
+  }
+
+  export interface EarthquakeHypocenterAccuracy {
+    epicenters: [
+        '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8',
+        '0' | '1' | '2' | '3' | '4' | '9'
+    ];
+    depth: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8';
+    magnitudeCalculation: '0' | '2' | '3' | '4' | '5' | '6' | '8';
+    numberOfMagnitudeCalculation: '0' | '1' | '2' | '3' | '4' | '5';
+  }
+
+  export interface EarthquakeHypocenter {
+    code: string;
+    name: string;
+    coordinate: Coordinate<'日本測地系'>;
+    depth: UnitValueNotNull<'深さ', 'km'>;
+    reduce: EarthquakeHypocenterReduce;
+    landOrSea?: '内陸' | '海域';
+    accuracy: EarthquakeHypocenterAccuracy;
+  }
+
+  export interface EarthquakeMagnitude {
+    type: 'マグニチュード';
+    unit: 'Mj' | 'M';
+    value: string | null;
+    condition?: 'Ｍ不明';
+  }
+
+  export interface Earthquake {
+    originTime?: string;
+    arrivalTime: string;
+    condition?: '仮定震源要素';
+    hypocenter: EarthquakeHypocenter;
+    magnitude: EarthquakeMagnitude;
+  }
+
+  export interface IntensityForecastMaxInt {
+    from: IntensityClass | '不明';
+    to: IntensityClass | 'over' | '不明';
+  }
+
+  export interface IntensityForecastLpgmMaxInt {
+    from: LpgmIntensityClass | '不明';
+    to: LpgmIntensityClass | 'over' | '不明';
+  }
+
+  export interface IntensityAppendix {
+    maxIntChange: '0' | '1' | '2';
+    maxLpgmIntChange?: '0' | '1' | '2';
+    maxIntChangeReason: '0' | '1' | '2' | '3' | '4' | '9';
+  }
+
+  export interface IntensityRegion {
+    code: string;
+    name: string;
+    forecastMaxInt: IntensityForecastMaxInt;
+    forecastLpgmMaxInt?: IntensityForecastLpgmMaxInt;
+    kind: WarningAreaKind;
+  }
+
+
+  export interface Intensity {
+    forecastMaxInt: IntensityForecastMaxInt;
+    forecastLpgmMaxInt?: IntensityForecastLpgmMaxInt;
+    appendix?: IntensityAppendix;
+    regions: IntensityRegion[];
+  }
+
+
+  export type Comment = {
+    free?: string;
+    warning?: {
+      text: string;
+      codes: string[];
+    };
+  };
+
+  export interface PublicCommonBody {
+    isLastInfo: boolean;
+    zones?: WarningArea[];
+    prefectures?: WarningArea[];
+    regions?: WarningArea[];
+    earthquake: Earthquake;
+    intensity?: Intensity;
+    text?: string;
+    comments: Comment;
+  }
+
+  export interface PublicTesting {
+    isLastInfo: false;
+    text: string;
+  }
+
+  export interface ChancelBody {
+    isLastInfo: true;
+    text: string;
+  }
+
+  export interface PublicCommon extends TelegramJSONMain {
+    _schema: Schema;
+    type: '緊急地震速報（予報）' | '緊急地震速報（地震動予報）' | '緊急地震速報（警報）';
+    title: '緊急地震速報（予報）' | '緊急地震速報（地震動予報）' | '緊急地震速報（警報）';
+    infoKind: '緊急地震速報';
+    eventId: string;
+    serialNo: string;
+    infoType: '発表' | '訂正';
+    body: PublicCommonBody;
+  }
+
+  export interface PublicTesting extends TelegramJSONMain {
+    _schema: Schema;
+    type: '緊急地震速報テスト';
+    title: '緊急地震速報テスト';
+    infoKind: '緊急地震速報';
+    eventId: string;
+    serialNo: string;
+    infoType: '発表' | '訂正';
+    body: PublicTesting;
+  }
+
+  export interface Channel extends TelegramJSONMain {
+    _schema: Schema;
+    type: '緊急地震速報（予報）' | '緊急地震速報（地震動予報）' | '緊急地震速報（警報）' | '緊急地震速報テスト';
+    title: '緊急地震速報（予報）' | '緊急地震速報（地震動予報）' | '緊急地震速報（警報）' | '緊急地震速報テスト';
+    infoKind: '緊急地震速報';
+    eventId: string;
+    serialNo: string;
+    infoType: '取消';
+    body: ChancelBody;
+  }
+
+  export type Main = PublicCommon | PublicTesting | Channel;
+
+}