dxf-json 0.0.21 → 0.0.22

package/src/parser/shared/parserGenerator.ts

@@ -1,180 +0,0 @@
-import { isMatched } from '.';
-import type DxfArrayScanner from '../DxfArrayScanner';
-import { ScannerGroup } from '../DxfArrayScanner';
-import { parsePoint } from './parsePoint';
-
-export const Abort = Symbol();
-
-// Snippet은 스트림에서 code를 읽었을 때 적절한 원자 파서를
-// 대응해 주는 역할을 한다.
-// Snippet은 스택에 쌓이며, 여러 Snippet이 동일한 code를
-// 소비할 수 있을 때, 가장 위에 쌓인 Snippet이 우선순위를 갖는다.
-export interface DXFParserSnippet {
-    code: number | number[]; // 복수의 코드를 다 한 곳으로 몰아넣기
-    name?: string; // 파싱한 값을 넣을 오브젝트 속성 명, 없으면 등록 안하고 패스함
-
-    // 추가로 더 읽어야 할 때만 scanner 사용하고, 새 값은 읽어놓지 말 것
-    // 반환되는 값이 entity[name]에 대입되므로 특별한 경우엔 entity 건들지 말고
-    // 사용할 경우, 최종값이 반환되도록 잘 건드릴 것
-    // 만약 Abort 심볼이 반환될 경우 값에 대입하지 않고 읽은 것을 한 칸 되돌리고
-    // 종료함
-    parser?(curr: ScannerGroup, scanner: DxfArrayScanner, entity: any): any;
-    isMultiple?: boolean; // code가 여러 번 들어올 수 있는 경우, true로 표기
-
-    // https://github.com/connect-for-you/cadview-front/issues/41
-    // 이 스니펫을 기점으로 맥락을 바꿈
-    pushContext?: boolean;
-}
-
-// 만약 파서가 어떤 유의미한 snippet도 찾지 못한 경우 전진하지 말고 false 반환
-// 만약 파서가 유의미한 snippet을 찾아서 사용한 경우 반드시 한 칸 전진시키고 true 반환
-// 즉 새로운 애를 하나는 무조건 읽어놓음
-export type DXFParser = (
-    curr: ScannerGroup,
-    scanner: DxfArrayScanner,
-    target: any,
-) => boolean;
-
-export function createParser(
-    snippets: DXFParserSnippet[],
-    defaultObject?: any,
-): DXFParser {
-    return (curr, scanner, target) => {
-        const snippetMaps = createSnippetMaps(snippets);
-        let isReadOnce = false;
-        let contextIndex = snippetMaps.length - 1;
-
-        while (!isMatched(curr, 0, 'EOF')) {
-            const snippetMap = findSnippetMap(
-                snippetMaps,
-                curr.code,
-                contextIndex,
-            );
-            const snippet = snippetMap?.[curr.code].at(-1);
-
-            if (!snippetMap || !snippet) {
-                scanner.rewind();
-                break;
-            }
-
-            if (!snippet.isMultiple) {
-                snippetMap[curr.code].pop();
-            }
-
-            const { name, parser, isMultiple } = snippet;
-            const parsedValue = parser?.(curr, scanner, target);
-
-            if (parsedValue === Abort) {
-                scanner.rewind();
-                break;
-            }
-
-            if (name) {
-                const [leaf, fieldName] = getObjectByPath(target, name);
-
-                if (isMultiple) {
-                    // prototype으로 디폴트값 넣어준 경우 nullish coalescing으로 해결 안됨 
-                    // @ts-ignore
-                    if (!Object.hasOwn(leaf, fieldName)) {
-                        leaf[fieldName] = [];
-                    }
-                    leaf[fieldName].push(parsedValue);
-                } else {
-                    leaf[fieldName] = parsedValue;
-                }
-            }
-
-            if (snippet.pushContext) {
-                contextIndex -= 1;
-            }
-
-            isReadOnce = true;
-            curr = scanner.next();
-        }
-
-        if (defaultObject) {
-            Object.setPrototypeOf(target, defaultObject);
-        }
-
-        return isReadOnce;
-    };
-}
-
-function createSnippetMaps(snippets: DXFParserSnippet[]) {
-    return snippets.reduce(
-        (acc, snippet) => {
-            if (snippet.pushContext) {
-                acc.push({});
-            }
-
-            const context = acc[acc.length - 1];
-            const codes =
-                typeof snippet.code === 'number'
-                    ? [snippet.code]
-                    : snippet.code;
-
-            for (const code of codes) {
-                const bin = (context[code] ??= []);
-
-                if (snippet.isMultiple && bin.length) {
-                    console.warn(
-                        `Snippet ${bin.at(-1)!.name
-                        } for code(${code}) is shadowed by ${snippet.name}`,
-                    );
-                }
-                bin.push(snippet);
-            }
-
-            return acc;
-        },
-        [{}] as Record<number, DXFParserSnippet[]>[],
-    );
-}
-
-function findSnippetMap(
-    snippetMaps: Record<number, DXFParserSnippet[]>[],
-    code: number,
-    contextIndex: number,
-) {
-    return snippetMaps.find(
-        (map, index) => index >= contextIndex && map[code]?.length,
-    );
-}
-
-/**
- * path를 .으로 나누고, 그 서브패스의 값을 설정할 수 있게 함.
- * 값이 없으면 알아서 만듦
- *
- * ex) a.b -> target[a]를 반환하여 b를 대입할 수 있게 함
- *     a.b.c -> target[a][b]를 반환하여 c를 대입할 수 있게 함
- *
- * @param target .으로 구분된 경로
- * @param path
- * @return [finalTargetObject, name]
- */
-function getObjectByPath(target: any, path: string) {
-    const fragments = path.split('.');
-
-    let currentTarget = target;
-    for (let depth = 0; depth < fragments.length - 1; ++depth) {
-        const currentName = fragments[depth];
-        // @ts-ignore
-        if (!Object.hasOwn(currentTarget, currentName)) {
-            currentTarget[currentName] = {};
-        }
-        currentTarget = currentTarget[currentName];
-    }
-    return [currentTarget, fragments.at(-1)!];
-}
-
-export function Identity({ value }: ScannerGroup) {
-    return value;
-}
-
-export function PointParser(_: any, scanner: DxfArrayScanner) {
-    return parsePoint(scanner);
-}
-
-export function ToBoolean({ value }: ScannerGroup) {
-    return !!value;
-}

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

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

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

@@ -1,85 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

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

@@ -1,49 +0,0 @@
-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

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