dxf-json 0.0.1

package/src/parser/shared/xdata/interpreter.test.ts

@@ -0,0 +1,85 @@
+import { createXDataControlInterpreter } from './interpreter';
+
+describe('xdata:interpreter', () => {
+    it('xdata 엔트리들이 name-value 쌍이면 객체에 snippet대로 풀어서 반환한다', () => {
+        const interpreter = createXDataControlInterpreter([
+            {
+                code: 40,
+                name: '$DIMSCALE',
+            },
+            {
+                code: 172,
+                name: 'dim-line-forced',
+            },
+            {
+                code: 175,
+                name: 'dim-line-inside',
+            },
+        ]);
+
+        const result = interpreter([
+            {
+                value: 40,
+            },
+            {
+                value: 2.0,
+            },
+            {
+                value: 175,
+            },
+            {
+                value: 0,
+            },
+            {
+                value: 172,
+            },
+            {
+                value: 1,
+            },
+        ]);
+        // @ts-ignore
+        expect(result['$DIMSCALE']).toBe(2.0);
+        // @ts-ignore
+        expect(result['dim-line-forced']).toBe(1);
+        // @ts-ignore
+        expect(result['dim-line-inside']).toBe(0);
+    });
+
+    it('snippet에 없는 쌍은 무시한다.', () => {
+        const interpreter = createXDataControlInterpreter([
+            {
+                code: 40,
+                name: '$DIMSCALE',
+                type: 'real',
+            },
+        ]);
+
+        const result = interpreter([
+            {
+                value: 175,
+            },
+            {
+                value: 0,
+            },
+            {
+                value: 40,
+            },
+            {
+                value: 2.0,
+            },
+            {
+                value: 172,
+            },
+            {
+                value: 1,
+            },
+        ]);
+
+        // @ts-ignore
+        expect(result['$DIMSCALE']).toBe(2.0);
+        // @ts-ignore
+        expect(result['dim-line-forced']).toBe(undefined);
+        // @ts-ignore
+        expect(result['dim-line-inside']).toBe(undefined);
+    });
+});

package/src/parser/shared/xdata/interpreter.ts

@@ -0,0 +1,65 @@
+import type { XData, XDataEntry } from './types';
+
+export type XDataInterpreterSnippet<Name extends string> = {
+    code: number;
+    name: Name;
+};
+
+type PackPairType<Snippets> = Snippets extends readonly [infer X, ...infer R]
+    ? X extends XDataInterpreterSnippet<infer N>
+    ? { [key in N]?: any } & PackPairType<R>
+    : PackPairType<R>
+    : {};
+
+/**
+ * xdata가 code-value의 연속인 경우에 사용 가능
+ * ex) DSTYLE
+ */
+export function createXDataControlInterpreter<
+    T extends readonly XDataInterpreterSnippet<string>[],
+    >(snippets: T) {
+    return (entries: XDataEntry[]): PackPairType<T> => {
+        const result = {} as PackPairType<T>;
+
+        for (let i = 0; i < entries.length; i += 2) {
+            const snippet = snippets.find(
+                ({ code }) => code === entries[i].value,
+            );
+
+            if (!snippet) continue;
+            // @ts-ignore
+            result[snippet.name] = entries[i + 1]?.value;
+        }
+
+        return result;
+    };
+}
+
+interface CreateXDataCatcherParams {
+    appName?: string;
+    catcher(entry: XDataEntry): boolean;
+    escaper?(entry: XDataEntry, count: number): boolean; // 몇 번째인지. 1부터 셈.
+}
+
+export function createXDataCatcher({
+    appName = 'ACAD',
+    catcher,
+    escaper,
+}: CreateXDataCatcherParams) {
+    return function* (xdata?: XData) {
+        if (xdata?.appName !== appName) return;
+
+        let isCatchable = false;
+        let startIndex = -1;
+        for (const [index, entry] of xdata.value.entries()) {
+            if (isCatchable) {
+                yield entry;
+
+                if (escaper?.(entry, index - startIndex)) return;
+            } else if (catcher(entry)) {
+                isCatchable = true;
+                startIndex = index;
+            }
+        }
+    };
+}

package/src/parser/shared/xdata/parser.test.ts

@@ -0,0 +1,66 @@
+import DxfArrayScanner from '../../DxfArrayScanner';
+import { parseXData } from './parser';
+
+describe('xdata:parser', () => {
+    it('xdata entry를 순차적으로 파싱하여 배열로 반환해야 한다', () => {
+        const scanner = new DxfArrayScanner(
+            `1001
+ACAD
+1000
+DSTYLE
+1070
+171
+`.split('\n'),
+        );
+        const curr = scanner.next();
+        const result = parseXData(curr, scanner);
+
+        expect(result.appName).toBe('ACAD');
+        expect(result.value.length).toBe(2);
+        expect(result.value[0].value).toBe('DSTYLE');
+        expect(result.value[1].value).toBe(171);
+    });
+
+    it('중첩된 xdata entry를 중첩된 배열로 반환해야 한다.', () => {
+        const scanner = new DxfArrayScanner(
+            `1001
+ACAD
+1000
+a
+1002
+{
+1000
+b
+1000
+c
+1002
+}
+1000
+d
+`.split('\n'),
+        );
+        const curr = scanner.next();
+        const result = parseXData(curr, scanner);
+
+        expect(result.value).toMatchObject([
+            {
+                type: 'string',
+                value: 'a',
+            },
+            [
+                {
+                    type: 'string',
+                    value: 'b',
+                },
+                {
+                    type: 'string',
+                    value: 'c',
+                },
+            ],
+            {
+                type: 'string',
+                value: 'd',
+            },
+        ]);
+    });
+});

package/src/parser/shared/xdata/parser.ts

@@ -0,0 +1,140 @@
+import { isMatched } from '..';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import { parsePoint } from '../parsePoint';
+import { DXFParserSnippet } from '../parserGenerator';
+import type { XData, XDataEntry } from './types';
+
+export const XDataParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 1001,
+        name: 'xdata',
+        parser: parseXData,
+    },
+];
+
+export function parseXData(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    if (!isMatched(curr, 1001)) {
+        throw new Error('XData must starts with code 1001');
+    }
+
+    const xdata: XData = {
+        appName: curr.value,
+        value: [] as XDataEntry[],
+    };
+
+    curr = scanner.next();
+
+    const stack = [xdata.value] as any[][];
+
+    while (!isMatched(curr, 0, 'EOF') && curr.code >= 1000) {
+        const top = stack.at(-1)!;
+
+        switch (curr.code) {
+            case 1002:
+                if (curr.value === '{') {
+                    stack.push([]);
+                } else {
+                    stack.pop();
+                    stack.at(-1)?.push(top);
+                }
+                break;
+            case 1000: // string
+            case 1004: // hex string
+            case 1040: // real
+            case 1070: // integer
+            case 1071: // long
+                top.push({
+                    type: getType(curr.code),
+                    value: curr.value,
+                });
+                break;
+            case 1003:
+                top.push({
+                    name: 'layer',
+                    type: getType(curr.code),
+                    value: curr.value,
+                });
+                break;
+            case 1005:
+                top.push({
+                    name: 'handle',
+                    type: getType(curr.code),
+                    value: curr.value,
+                });
+                break;
+            case 1010: // just 3 reals
+                top.push({
+                    type: getType(curr.code),
+                    value: parsePoint(scanner),
+                });
+                break;
+            case 1011:
+                top.push({
+                    name: 'worldSpacePosition',
+                    type: getType(curr.code),
+                    value: parsePoint(scanner),
+                });
+                break;
+            case 1012:
+                top.push({
+                    name: 'worldSpaceDisplacement',
+                    type: getType(curr.code),
+                    value: parsePoint(scanner),
+                });
+                break;
+            case 1013:
+                top.push({
+                    name: 'worldSpaceDirection',
+                    type: getType(curr.code),
+                    value: parsePoint(scanner),
+                });
+                break;
+            case 1041:
+                top.push({
+                    name: 'distance',
+                    type: getType(curr.code),
+                    value: curr.value,
+                });
+                break;
+            case 1042:
+                top.push({
+                    name: 'scale',
+                    type: getType(curr.code),
+                    value: curr.value,
+                });
+                break;
+        }
+
+        curr = scanner.next();
+    }
+
+    scanner.rewind();
+    return xdata;
+}
+
+function getType(code: number) {
+    switch (code) {
+        case 1000:
+        case 1003:
+        case 1005:
+            return 'string';
+        case 1004:
+            return 'hex';
+        case 1040:
+        case 1041:
+        case 1042:
+            return 'real';
+        case 1070:
+            return 'integer';
+        case 1071:
+            return 'long';
+        case 1010:
+        case 1011:
+        case 1012:
+        case 1013:
+            return 'point';
+        default:
+            return '';
+    }
+}

package/src/parser/shared/xdata/types.ts

@@ -0,0 +1,22 @@
+import type { Point3D } from '../../../types';
+
+/*
+  https://help.autodesk.com/view/OARX/2023/ENU/?guid=GUID-A2A628B0-3699-4740-A215-C560E7242F63
+
+  확장 데이터는 LISP 언어 형식으로 작성되는데, 대충 재귀적인 배열 구조라고 생각하면 된다.
+  이 구조는 AutoCAD 혹은 서드파티가 알아서 정의하고 쓰므로 신경꺼도 좋다.
+  (ex: [1, 2, 'babo', [3], 3.14, [[]]])
+
+  각 깊이는 1002번 코드의 {로 시작하여 }로 끝난다.
+  이 값들은 DXF 일반 코드와 다르게 이름이 있기도 하고 없기도 하여, 아래와 같은 자료 구조로 저장한다.
+*/
+
+export interface XData {
+  appName: string;
+  value: XDataEntry[];
+}
+
+export interface XDataEntry {
+  name?: string;
+  value: XDataEntry[] | number | string | Point3D;
+}

package/src/parser/tables/blockRecord/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './parser';

package/src/parser/tables/blockRecord/parser.ts

@@ -0,0 +1,49 @@
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+} from '../../shared/parserGenerator';
+import { CommonTableEntryParserSnippets } from '../shared';
+
+const BlockRecordTableParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 310,
+        name: 'bmpPreview',
+        parser: Identity,
+    },
+    {
+        code: 281,
+        name: 'scalability',
+        parser: Identity,
+    },
+    {
+        code: 280,
+        name: 'explodability',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'insertionUnits',
+        parser: Identity,
+    },
+    {
+        code: 340,
+        name: 'layoutObjects',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'name',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...CommonTableEntryParserSnippets,
+];
+
+export const parseBlockRecordTable = createParser(
+    BlockRecordTableParserSnippets,
+);

package/src/parser/tables/blockRecord/types.ts

@@ -0,0 +1,11 @@
+import type { CommonDxfTableEntry } from '../types';
+
+export interface BlockRecordTableEntry extends CommonDxfTableEntry {
+    subclassMarker: 'AcDbBlockTableRecord';
+    name: string;
+    layoutObjects: string;
+    insertionUnits: number;
+    explodability: number;
+    scalability: number;
+    bmpPreview: string;
+}