asterix-parser 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chung5072
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# asterix-parser
+### 기능
+**asterix-validator를 활용한 Asterix 데이터 파싱 모듈**
+
+- 모듈로 확인할 수 있는 내용
+    - 배열 내의 객체 형태로 Asterix 데이터 파싱 결과. 
+    - 현재 구현된 내용: Category 021
+
+**기술 스택**
+
+![TypeScript](https://img.shields.io/badge/typescript-%23007ACC.svg?style=for-the-badge&logo=typescript&logoColor=white)
+![Jest](https://img.shields.io/badge/-jest-%23C21325?style=for-the-badge&logo=jest&logoColor=white)
+
+---
+### 사용 예시
+```
+parse("확인하고_싶은_데이터_문자열");
+```
+**결과 구조**
+```
+/* typescript */
+[
+    {
+        '021_010_SAC': 01,
+        '021_010_SIC': 01,
+    },
+    ...
+]
+```
+**예시**
+```
+console.log(parse("3E0006800102"));
+```
+---
+### 참고 링크
+[Asterix CAT021](https://www.eurocontrol.int/publication/cat021-eurocontrol-specification-surveillance-data-exchange-asterix-part-12-category-21)

package/build/src/main/app.d.ts

@@ -0,0 +1,8 @@
+import { Record } from './util/process/cat021';
+/**
+ * Asterix 데이터 파싱
+ * @param input 16진수 문자열 데이터
+ * @returns 파싱 결과
+ */
+declare const parse: (input: string) => Record[];
+export { parse };

package/build/src/main/app.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const asterix_validator_1 = require("asterix-validator");
+const preprocess_1 = require("./util/preprocess");
+const cat021_1 = require("./util/varlen/cat021");
+const cat021_2 = require("./util/process/cat021");
+/**
+ * Asterix 데이터 파싱
+ * @param input 16진수 문자열 데이터
+ * @returns 파싱 결과
+ */
+const parse = (input) => {
+    // 데이터 확인
+    const { category, length, bitArr } = (0, asterix_validator_1.inputData)(input); // 카테도리, 데이터 길이, 바이트 값
+    // 데이터 순회 인덱스
+    let pos = 3;
+    const records = [];
+    const record = {};
+    // 패킷 데이터 순회
+    while (pos < length) {
+        const { fieldSpec, recordIndex } = (0, preprocess_1.getFieldSpec)(category, bitArr, pos);
+        // 현재 레코드 안에서 움직일 포인터를 하나 만듭니다.
+        let currentPos = recordIndex;
+        for (const [dataItem, length] of Object.entries(fieldSpec)) {
+            if (dataItem === 'SPARE') {
+                // 사용하지 않는 데이터 아이템 넘김
+                continue;
+            }
+            let diLength = 0;
+            if (length !== -1) {
+                // 고정 길이
+                diLength = length;
+            }
+            else {
+                // 가변 길이
+                switch (category) {
+                    case 21: {
+                        diLength = (0, cat021_1.cat021VarLen)(bitArr, currentPos, dataItem);
+                        break;
+                    }
+                    default:
+                        diLength = 0;
+                        break;
+                }
+            }
+            record[dataItem] = diLength;
+            switch (category) {
+                case 21: {
+                    (0, cat021_2.cat021Process)(record, bitArr, currentPos, dataItem, diLength);
+                    break;
+                }
+                default:
+                    break;
+            }
+            // 포인터 이동
+            currentPos += diLength;
+        }
+        // 다음 레코드는 마지막으로 읽은 위치(currentPos)부터 시작
+        pos = currentPos;
+        // 객체 복사 후 삽입
+        records.push(Object.assign({}, record));
+    }
+    return records;
+};
+exports.parse = parse;

package/build/src/main/data/uap/cat021.d.ts

@@ -0,0 +1,6 @@
+interface UapdataItem {
+    dataItem: string;
+    length: number;
+}
+declare const CAT021_UAP: Record<number, Record<number, UapdataItem>>;
+export { CAT021_UAP };

package/build/src/main/data/uap/cat021.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAT021_UAP = void 0;
+const CAT021_UAP = {
+    1: {
+        1: {
+            dataItem: "di010",
+            length: 2
+        },
+        2: {
+            dataItem: "di040",
+            length: -1
+        },
+        3: {
+            dataItem: "di161",
+            length: 2
+        },
+        4: {
+            dataItem: "di015",
+            length: 1
+        },
+        5: {
+            dataItem: "di071",
+            length: 3
+        },
+        6: {
+            dataItem: "di130",
+            length: 6
+        },
+        7: {
+            dataItem: "di131",
+            length: 8
+        },
+    },
+    2: {
+        1: {
+            dataItem: "di072",
+            length: 3
+        },
+        2: {
+            dataItem: "di150",
+            length: 2
+        },
+        3: {
+            dataItem: "di151",
+            length: 2
+        },
+        4: {
+            dataItem: "di080",
+            length: 3
+        },
+        5: {
+            dataItem: "di073",
+            length: 3
+        },
+        6: {
+            dataItem: "di074",
+            length: 4
+        },
+        7: {
+            dataItem: "di075",
+            length: 3
+        },
+    },
+    3: {
+        1: {
+            dataItem: "di076",
+            length: 4
+        },
+        2: {
+            dataItem: "di140",
+            length: 2
+        },
+        3: {
+            dataItem: "di090",
+            length: -1
+        },
+        4: {
+            dataItem: "di210",
+            length: 1
+        },
+        5: {
+            dataItem: "di070",
+            length: 2
+        },
+        6: {
+            dataItem: "di230",
+            length: 2
+        },
+        7: {
+            dataItem: "di145",
+            length: 2
+        },
+    },
+    4: {
+        1: {
+            dataItem: "di152",
+            length: 2
+        },
+        2: {
+            dataItem: "di200",
+            length: 1
+        },
+        3: {
+            dataItem: "di155",
+            length: 2
+        },
+        4: {
+            dataItem: "di157",
+            length: 2
+        },
+        5: {
+            dataItem: "di160",
+            length: 4
+        },
+        6: {
+            dataItem: "di165",
+            length: 2
+        },
+        7: {
+            dataItem: "di077",
+            length: 3
+        },
+    },
+    5: {
+        1: {
+            dataItem: "di170",
+            length: 6
+        },
+        2: {
+            dataItem: "di020",
+            length: 1
+        },
+        3: {
+            dataItem: "di220",
+            length: -1
+        },
+        4: {
+            dataItem: "di146",
+            length: 2
+        },
+        5: {
+            dataItem: "di148",
+            length: 2
+        },
+        6: {
+            dataItem: "di110",
+            length: -1
+        },
+        7: {
+            dataItem: "di016",
+            length: 1
+        },
+    },
+    6: {
+        1: {
+            dataItem: "di008",
+            length: 1
+        },
+        2: {
+            dataItem: "di271",
+            length: -1
+        },
+        3: {
+            dataItem: "di132",
+            length: 1
+        },
+        4: {
+            dataItem: "di250",
+            length: -1
+        },
+        5: {
+            dataItem: "di260",
+            length: 7
+        },
+        6: {
+            dataItem: "di400",
+            length: 1
+        },
+        7: {
+            dataItem: "di295",
+            length: -1
+        },
+    },
+    7: {
+        1: {
+            dataItem: "SPARE",
+            length: 0
+        },
+        2: {
+            dataItem: "SPARE",
+            length: 0
+        },
+        3: {
+            dataItem: "SPARE",
+            length: 0
+        },
+        4: {
+            dataItem: "SPARE",
+            length: 0
+        },
+        5: {
+            dataItem: "SPARE",
+            length: 0
+        },
+        6: {
+            dataItem: "RE",
+            length: -1
+        },
+        7: {
+            dataItem: "SP",
+            length: -1
+        },
+    }
+};
+exports.CAT021_UAP = CAT021_UAP;

package/build/src/main/util/common.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 비트가 켜져있는지 확인
+ * @param bits 비트 데이터
+ * @param fieldPos 확인하고자 하는 필드 위치
+ * @param headerLen 어떤 필드가 존재하는지 알려주는 primary octet
+ * @returns fieldPos의 비트가 켜져있는지
+ */
+declare const isBitSet: (bits: number, fieldPos: number, headerLen: number) => boolean;
+/**
+ * 특정 범위 내부에서 비트가 1인 위치의 값을 전부 합침
+ * 시작 인덱스 >= 값 >= 끝 인덱스
+ * @param bits 비트 데이터
+ * @param startIndex 범위의 시작 인덱스
+ * @param endIndex 범위의 끝 인덱스
+ * @param pow 계산할 제곱값
+ * @returns 범위 값
+ */
+declare const octetOfRange: (bits: number, startIndex: number, endIndex: number, pow: number) => number;
+/**
+ * 2의 보수 처리
+ * @param octets 보수 처리 전의 값
+ * @param bitCount 범위 최대치 위치
+ * @returns 보수 처리 후 값
+ */
+declare const twosCompliment: (octets: number, bitCount: number) => number;
+declare const getChar: (key: number) => string;
+export { isBitSet, octetOfRange, twosCompliment, getChar };

package/build/src/main/util/common.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChar = exports.twosCompliment = exports.octetOfRange = exports.isBitSet = void 0;
+/**
+ * 비트가 켜져있는지 확인
+ * @param bits 비트 데이터
+ * @param fieldPos 확인하고자 하는 필드 위치
+ * @param headerLen 어떤 필드가 존재하는지 알려주는 primary octet
+ * @returns fieldPos의 비트가 켜져있는지
+ */
+const isBitSet = (bits, fieldPos, headerLen) => {
+    const totalBits = headerLen * 7;
+    // fieldPos는 1부터 시작
+    const shift = totalBits - fieldPos;
+    return (shift >= 0) && ((bits & (1 << shift)) != 0);
+};
+exports.isBitSet = isBitSet;
+/**
+ * 특정 범위 내부에서 비트가 1인 위치의 값을 전부 합침
+ * 시작 인덱스 >= 값 >= 끝 인덱스
+ * @param bits 비트 데이터
+ * @param startIndex 범위의 시작 인덱스
+ * @param endIndex 범위의 끝 인덱스
+ * @param pow 계산할 제곱값
+ * @returns 범위 값
+ */
+const octetOfRange = (bits, startIndex, endIndex, pow) => {
+    let result = 0;
+    for (let index = startIndex; index >= endIndex; index--, pow--) {
+        if ((bits & (1 << index)) !== 0) {
+            result |= (1 << pow);
+        }
+    }
+    return result;
+};
+exports.octetOfRange = octetOfRange;
+/**
+ * 2의 보수 처리
+ * @param octets 보수 처리 전의 값
+ * @param bitCount 범위 최대치 위치
+ * @returns 보수 처리 후 값
+ */
+const twosCompliment = (octets, bitCount) => {
+    // 최상위 비트를 부호 비트로 식별
+    const signBit = 1 << (bitCount - 1);
+    // 최대값 범위 계산
+    const maxRange = 1 << bitCount;
+    // 음수 변환 조건
+    // 부호 비트가 1이면 음수로 변환
+    return (octets >= signBit) ? (octets - maxRange) : octets;
+};
+exports.twosCompliment = twosCompliment;
+// 배열 선언
+const CHAR_ARRAY = new Array(58);
+// 초기화 로직 - A-Z (인덱스 1-26)
+const startCharA = 'A'.charCodeAt(0);
+for (let i = 1; i <= 26; i++) {
+    CHAR_ARRAY[i] = String.fromCharCode(startCharA + i - 1);
+}
+// 초기화 로직 - 0-9 (인덱스 48-57)
+const startChar0 = '0'.charCodeAt(0);
+for (let i = 48; i <= 57; i++) {
+    CHAR_ARRAY[i] = String.fromCharCode(startChar0 + i - 48);
+}
+const getChar = (key) => {
+    // 혹시라도 소수점이 들어올 경우를 대비해 정수로 변환 (Java의 (int)key 대응)
+    const intKey = Math.floor(key);
+    // 배열 범위 확인
+    if (intKey < 0 || intKey >= CHAR_ARRAY.length) {
+        return "";
+    }
+    const result = CHAR_ARRAY[intKey];
+    // 할당되지 않은 인덱스(undefined) 처리 (Java의 null 체크 대응)
+    if (result === undefined) {
+        return "";
+    }
+    return result;
+};
+exports.getChar = getChar;

package/build/src/main/util/preprocess.d.ts

@@ -0,0 +1,33 @@
+type FieldSpec = {
+    [dataItem: string]: number;
+};
+/**
+ * UAP 정보를 통해 FieldSpec을 반환하는 함수
+ * @param category 카테고리
+ * @param data 바이트 데이터
+ * @param pos 데이터 순회 인덱스
+ * @returns FieldSpec과 다음 인덱스
+ */
+declare const getFieldSpec: (category: number, bitArr: Uint8Array, pos: number) => {
+    fieldSpec: FieldSpec;
+    recordIndex: number;
+};
+/**
+ * FX 비트를 체크하여 확장되는 헤더를 읽고 { 비트조합, 헤더길이 }를 반환
+ * @param bitArr 비트 데이터
+ * @param recordIndex record 시작 인덱스
+ * @returns { 비트 조합, 헤더 길이 }
+ */
+declare const parseIndicator: (bitArr: Uint8Array, recordIndex: number) => {
+    bits: number;
+    headerLen: number;
+};
+/**
+ * SP과 RE에서 사용
+ * @param bitArr Asterix 바이트 데이터
+ * @param currentPos 데이터 아이템 시작 인덱스
+ * @param length 데이터 길이
+ * @returns 문자열
+ */
+declare const getHexString: (bitArr: number[] | Uint8Array, currentPos: number, length: number) => string;
+export { FieldSpec, getFieldSpec, parseIndicator, getHexString };

package/build/src/main/util/preprocess.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHexString = exports.parseIndicator = exports.getFieldSpec = void 0;
+const cat021_1 = require("../data/uap/cat021");
+/**
+ * UAP 정보를 통해 FieldSpec을 반환하는 함수
+ * @param category 카테고리
+ * @param data 바이트 데이터
+ * @param pos 데이터 순회 인덱스
+ * @returns FieldSpec과 다음 인덱스
+ */
+const getFieldSpec = (category, bitArr, pos) => {
+    const fieldSpec = {};
+    // 행 번호
+    let block = 1;
+    // * 현재 바이트의 마지막 비트가 0일 때까지 반복
+    while (true) {
+        const currentByte = bitArr[pos++];
+        for (let bit = 7; bit >= 1; bit--) {
+            // * 해당 비트가 0이면 data item이 없다는 뜻이므로 넘김
+            if ((currentByte & (1 << bit)) === 0) {
+                continue;
+            }
+            // 열 번호
+            const frn = 7 - bit + 1;
+            if (category === 21) {
+                const dataItem = cat021_1.CAT021_UAP[block][frn].dataItem;
+                const length = cat021_1.CAT021_UAP[block][frn].length;
+                fieldSpec[dataItem] = length;
+            }
+        }
+        // * 마지막 비트가 0이면 종료
+        if ((currentByte & 1) === 0) {
+            break;
+        }
+        block++;
+    }
+    const recordIndex = pos;
+    return { fieldSpec, recordIndex };
+};
+exports.getFieldSpec = getFieldSpec;
+/**
+ * FX 비트를 체크하여 확장되는 헤더를 읽고 { 비트조합, 헤더길이 }를 반환
+ * @param bitArr 비트 데이터
+ * @param recordIndex record 시작 인덱스
+ * @returns { 비트 조합, 헤더 길이 }
+ */
+const parseIndicator = (bitArr, recordIndex) => {
+    let hasExtension = true;
+    let bits = 0;
+    let headerLen = 0;
+    while (hasExtension) {
+        const currentByte = bitArr[recordIndex++];
+        hasExtension = (currentByte & 1) != 0;
+        // FX 비트를 제거한 후 합침
+        bits = (bits << 7) | (currentByte >> 1);
+        headerLen++;
+    }
+    return { bits, headerLen };
+};
+exports.parseIndicator = parseIndicator;
+/**
+ * SP과 RE에서 사용
+ * @param bitArr Asterix 바이트 데이터
+ * @param currentPos 데이터 아이템 시작 인덱스
+ * @param length 데이터 길이
+ * @returns 문자열
+ */
+const getHexString = (bitArr, currentPos, length) => {
+    const hexArray = "0123456789abcdef";
+    const result = [];
+    for (let i = 0; i < length; i++) {
+        // 배열 범위를 벗어나는지 체크 (안전장치, 필요 없으면 생략 가능)
+        if (currentPos + i >= bitArr.length)
+            break;
+        const v = bitArr[currentPos + i] & 0xFF;
+        result.push(hexArray[v >> 4]);
+        result.push(hexArray[v & 0x0F]);
+    }
+    return result.join('');
+};
+exports.getHexString = getHexString;

package/build/src/main/util/process/cat021.d.ts

@@ -0,0 +1,13 @@
+type Record = {
+    [dataItem: string]: {};
+};
+/**
+ * CAT 021 파싱
+ * @param record 단일 Record 파싱 결과
+ * @param bitArr Asterix 바이트 데이터
+ * @param currentPos 데이터 아이템 시작 인덱스
+ * @param dataItem 데이터 아이템 이름
+ * @param diLength 데이터 아이템 길이
+ */
+declare const cat021Process: (record: Record, bitArr: Uint8Array, currentPos: number, dataItem: string, diLength: number) => void;
+export { Record, cat021Process };