dxf-json 0.0.21 → 0.0.22

package/src/types/entity.ts

@@ -1,7 +0,0 @@
-import type { Matrix3 } from 'three';
-
-export interface CommonEntityDecomposeOption {
-    layer?: string;
-    color: number;
-    extrusionTransform?: Matrix3;
-}

package/src/types/index.ts

@@ -1,30 +0,0 @@
-export * from './color';
-export * from './dxfHeader';
-export * from './entity';
-
-export interface Point2D {
-    x: number;
-    y: number;
-}
-
-export interface Point3D {
-    x: number;
-    y: number;
-    z: number;
-}
-
-export interface Bound {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> &
-    Partial<Pick<T, K>>;
-
-export type Indexed<T, P extends string> = {
-    [key in P]: T;
-} & {
-    index: number;
-};

package/src/utils/binarySearch.ts

@@ -1,20 +0,0 @@
-export function createMaxLessOrEqualFinder<T>(comp: (a: T, b: T) => number) {
-    return (list: T[], target: T) => {
-        let l = 0;
-        let r = list.length - 1;
-
-        while (l < r) {
-            const m = Math.ceil((l + r) / 2);
-
-            if (comp(list[m], target) > 0) {
-                r = m - 1;
-            } else {
-                l = m;
-            }
-        }
-
-        if (comp(list[r], target) > 0) return -1;
-
-        return r;
-    };
-}

package/src/utils/disjointSet.ts

@@ -1,52 +0,0 @@
-export function createDisjointSet(initialSize: number) {
-    const roots = Array.from(new Array(initialSize), (_, index) => index);
-    const sizes = roots.map(() => 1);
-    let groups = initialSize;
-
-    // return the id of the set which given index-th element exists.
-    // but set id may changes if further union operations are done.
-    function find(index: number): number {
-        if (roots[index] === index) return index;
-        return (roots[index] = find(roots[index]));
-    }
-
-    function union(ia: number, ib: number): void {
-        let ra = find(ia);
-        let rb = find(ib);
-
-        if (ra === rb) return;
-
-        if (sizes[ra] < sizes[rb]) {
-            [ra, rb] = [rb, ra];
-        }
-
-        roots[rb] = ra;
-        sizes[ra] += sizes[rb];
-        groups -= 1;
-    }
-
-    // return the size of the set which has index-th element.
-    // if index is not given, return the number of dijoint sets.
-    function size(index?: number): number {
-        if (index === undefined) return groups;
-        return sizes[find(index)];
-    }
-
-    function getSets() {
-        const map: Record<number, number[]> = {};
-        for (let i = 0; i < roots.length; ++i) {
-            const rootIndex = find(i);
-
-            map[rootIndex] ??= [];
-            map[rootIndex].push(i);
-        }
-        return map;
-    }
-
-    return {
-        find,
-        union,
-        size,
-        getSets,
-    };
-}

package/src/utils/flooding.ts

@@ -1,37 +0,0 @@
-interface FloodingParams<T> {
-    seeds: T[];
-    spanner(seed: T): T[];
-    serializer(seed: T): number | string;
-    iterationLimit?: number;
-}
-
-export function flooding<T>({
-    seeds,
-    spanner,
-    serializer,
-    iterationLimit = Infinity,
-}: FloodingParams<T>) {
-    const memo = new Set<string | number>();
-    let iterations = 0;
-
-    return seeds
-        .map((seed) => {
-            const group: T[] = [];
-            const stack: [T, string | number][] = [[seed, serializer(seed)]];
-
-            while (stack.length && iterations++ < iterationLimit) {
-                const [current, key] = stack.pop()!;
-
-                if (memo.has(key)) continue;
-                memo.add(key);
-                group.push(current);
-
-                for (const next of spanner(current)) {
-                    stack.push([next, serializer(next)]);
-                }
-            }
-
-            return group;
-        })
-        .filter((group) => group.length);
-}

package/src/utils/functional.ts

@@ -1,124 +0,0 @@
-export function* adjacentPairs<T>(
-    itr: Iterable<T>,
-    n: number,
-    isClosed?: boolean,
-) {
-    const first = new Array(n - 1) as T[];
-    const buffer = new Array(n) as T[];
-    let count = 0;
-    for (const value of itr) {
-        pull(buffer, value);
-
-        if (++count >= n) {
-            yield [...buffer];
-        } else if (count < n) {
-            first[count - 1] = value;
-        }
-    }
-    if (count >= n && isClosed) {
-        for (const value of first) {
-            pull(buffer, value);
-            yield [...buffer];
-        }
-    }
-}
-
-function pull<T>(values: T[], newValue: T) {
-    for (let i = 0; i < values.length - 1; ++i) {
-        values[i] = values[i + 1];
-    }
-    values[values.length - 1] = newValue;
-}
-
-export function argmin<T>(itr: Iterable<T>, evaluator: (value: T) => number) {
-    let score = Infinity;
-    let target: T = null as T;
-    let index = -1;
-    let count = 0;
-
-    for (const value of itr) {
-        const newScore = evaluator(value);
-
-        if (score > newScore) {
-            score = newScore;
-            target = value;
-            index = count;
-        }
-
-        ++count;
-    }
-
-    return { target, score, index };
-}
-
-export function* subIterator<T>(array: T[], start: number, end: number) {
-    for (let i = start; i <= end; ++i) {
-        yield array[i];
-    }
-}
-
-export function* reverseIterator<T>(array: T[]) {
-    for (let i = array.length - 1; i >= 0; --i) {
-        yield array[i];
-    }
-}
-
-export function separate<T>(
-    predicate: (value: T) => boolean,
-    itr: Iterable<T>,
-) {
-    const truthy: T[] = [];
-    const falsy: T[] = [];
-
-    for (const value of itr) {
-        if (predicate(value)) {
-            truthy.push(value);
-        } else {
-            falsy.push(value);
-        }
-    }
-
-    return [truthy, falsy];
-}
-
-export function findLast<T>(
-    predicate: (value: T) => boolean,
-    isIncremental: boolean, // true일 경우, predicate가 실패하는 즉시 종료
-    itr: Iterable<T>,
-): [T | undefined, number] {
-    let lastSatisfyingIndex = -1;
-    let lastSatisfying: T | undefined = undefined;
-    let index = 0;
-
-    for (const value of itr) {
-        if (predicate(value)) {
-            lastSatisfyingIndex = index;
-            lastSatisfying = value;
-        } else if (isIncremental) {
-            break;
-        }
-        index += 1;
-    }
-
-    return [lastSatisfying, lastSatisfyingIndex];
-}
-
-/**
- * size개씩 자른 것을 생성한다. 만약 마지막에 size개가 안되면 그냥 되는대로 준다.
- * @param size
- * @param iterable
- */
-export function* groupPairs<T>(size: number, iterable: Iterable<T>) {
-    let pairs: T[] = [];
-    for (const value of iterable) {
-        pairs.push(value);
-
-        if (pairs.length >= size) {
-            yield pairs;
-            pairs = [];
-        }
-    }
-    if (pairs.length) {
-        yield pairs;
-    }
-}

package/src/utils/graph.ts

@@ -1,53 +0,0 @@
-// index로 연결하는 복수 개의 간선을 갖는 것들
-export interface Edge<E> {
-    index: number; // vertex
-    values: E[];
-}
-
-/**
- * 정수로 표현하는 무향 비단순 그래프
- * 두 정점 사이에 간선이 여러 개 존재할 수 있음
- * 인접 리스트를 사용
- * 간선에 값을 할당할 수 있음
- */
-export class UndirectedMultiGraph<T> {
-    vertices = new Set<number>();
-    edges = [] as Edge<T>[][];
-
-    addEdge(u: number, v: number, value: T) {
-        this.vertices.add(u);
-        this.vertices.add(v);
-        this.connectDirected(u, v, value);
-        this.connectDirected(v, u, value);
-    }
-
-    getDegree(v: number) {
-        return this.edges[v].reduce(
-            (acc, neighbor) => neighbor.values.length + acc,
-            0,
-        );
-    }
-
-    getEdgeCount(u: number, v: number) {
-        return (
-            this.edges[u]?.find(({ index }) => index === v)?.values.length ?? 0
-        );
-    }
-
-    *getNeighbors(u: number) {
-        if (this.edges[u]?.length) {
-            yield* this.edges[u][Symbol.iterator]();
-        }
-    }
-
-    private connectDirected(u: number, v: number, value: T) {
-        this.edges[u] ??= [];
-
-        let neighbor = this.edges[u].find(({ index }) => index === v);
-        if (!neighbor) {
-            neighbor = { index: v, values: [] };
-            this.edges[u].push(neighbor);
-        }
-        neighbor.values.push(value);
-    }
-}

package/src/utils/index.ts

@@ -1,102 +0,0 @@
-export * from './binarySearch';
-export * from './disjointSet';
-export * from './graph';
-export * from './functional';
-export * from './flooding';
-export * from './triangle';
-export * from './queue';
-
-import { reduce } from '@fxts/core';
-import { Vector2, Vector3 } from 'three';
-import type { Bound, Point2D, Point3D } from '../types';
-
-export function pointToVector2(point: Point3D | Point2D): Vector2 {
-    return new Vector2(point.x, point.y);
-}
-
-export function pointToVector3(point: Point3D | Point2D): Vector3 {
-    return new Vector3(point.x, point.y, (point as Point3D).z ?? 0);
-}
-
-export function swapVector(v1: Vector2, v2: Vector2): void {
-    let temp = v1.x;
-    v1.x = v2.x;
-    v2.x = temp;
-    temp = v1.y;
-    v1.y = v2.y;
-    v2.y = temp;
-}
-
-export function classify<T>(
-    iterable: Iterable<T>,
-    keySelector: (value: T) => string | undefined,
-) {
-    const result: Record<string, T[]> = {};
-    for (const value of iterable) {
-        const key = keySelector(value);
-
-        if (key != null) {
-            result[key] ??= [];
-            result[key].push(value);
-        }
-    }
-    return result;
-}
-
-export function updateBounds(v: Point2D, bounds?: Bound) {
-    bounds ??= { minX: v.x, maxX: v.x, minY: v.y, maxY: v.y };
-    bounds.minX = Math.min(bounds.minX, v.x);
-    bounds.maxX = Math.max(bounds.maxX, v.x);
-    bounds.minY = Math.min(bounds.minY, v.y);
-    bounds.maxY = Math.max(bounds.maxY, v.y);
-    return bounds;
-}
-
-export function getBoundBox(vertices: Iterable<Point2D>) {
-    return reduce(
-        (bound, v) => updateBounds(v, bound),
-        {
-            minX: Infinity,
-            maxX: -Infinity,
-            minY: Infinity,
-            maxY: -Infinity,
-        },
-        vertices,
-    );
-}
-
-/**
- * 정수 생성기
- *
- * @param start Inclusive
- * @param end Exclusive
- * @param increment Default = 1
- */
-export function* generateIntegers(
-    start: number,
-    end: number = Infinity,
-    increment: number = 1,
-) {
-    for (let n = start; n !== end; n += increment) {
-        yield n;
-    }
-}
-
-export function swap<T>(list: T[], i1: number, i2: number) {
-    const temp = list[i1];
-    list[i1] = list[i2];
-    list[i2] = temp;
-}
-
-export function pushIfNotEqual(v: Vector2, vertices: Vector2[]) {
-    if (!vertices.length) {
-        vertices.push(v);
-        return;
-    }
-
-    const u = vertices.at(-1)!;
-
-    if (v.x !== u.x || v.y !== u.y) {
-        vertices.push(v);
-    }
-}

package/src/utils/queue.ts

@@ -1,77 +0,0 @@
-export class Queue<T> implements Iterable<T> {
-    private data: T[] = new Array(4);
-    private head: number = 0;
-    private tail: number = 0;
-    private _size: number = 0;
-
-    constructor(public readonly growthRate: number = 2) {}
-
-    private grow(): void {
-        const length = this.data.length;
-        this.data = this.data
-            .slice(this.head, length)
-            .concat(this.data.slice(0, this.head))
-            .concat(
-                new Array(Math.max(1, Math.floor(length * this.growthRate))),
-            );
-        this.head = 0;
-        this.tail = length;
-    }
-
-    public push(el: T): T {
-        this.data[this.tail] = el;
-        this.tail = (this.tail + 1) % this.data.length;
-        if (this.tail === this.head) {
-            this.grow();
-        }
-        this._size += 1;
-        return el;
-    }
-
-    public pop(): T | undefined {
-        if (this._size <= 0) return undefined;
-        const result = this.data[this.head];
-        this.head = (this.head + 1) % this.data.length;
-        this._size -= 1;
-        return result;
-    }
-
-    public front(): T | undefined {
-        if (this._size <= 0) return undefined;
-        return this.data[this.head];
-    }
-
-    public size(): number {
-        return this._size;
-    }
-
-    public [Symbol.iterator](): IterableIterator<T> {
-        const data = [...this.data];
-        const tail = this.tail;
-        let currentIndex = this.head;
-
-        return {
-            next(): IteratorResult<T> {
-                if (currentIndex === tail)
-                    return { value: undefined, done: true };
-                const oldIndex = currentIndex;
-                currentIndex = (currentIndex + 1) % data.length;
-                return {
-                    value: data[oldIndex],
-                    done: false,
-                };
-            },
-            [Symbol.iterator]() {
-                return this;
-            },
-        };
-    }
-
-    public isNotEmpty(): this is NonEmptyQueue<T> {
-        return this._size > 0;
-    }
-}
-
-interface NonEmptyQueue<T> extends Queue<T> {
-    pop(): T;
-}

package/src/utils/triangle.ts

@@ -1,28 +0,0 @@
-import { Vector2 } from 'three';
-
-const ZeroVector = new Vector2();
-
-// 끝점을 position을 가리키도록 설정
-export function createTriangle(
-    position: Vector2,
-    angle: number,
-    width: number,
-    height: number,
-): Vector2[] {
-    return [
-        position.clone(),
-        position
-            .clone()
-            .add(
-                new Vector2(-width, height / 2).rotateAround(ZeroVector, angle),
-            ),
-        position
-            .clone()
-            .add(
-                new Vector2(-width, -height / 2).rotateAround(
-                    ZeroVector,
-                    angle,
-                ),
-            ),
-    ];
-}

package/tsconfig.json

@@ -1,37 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es2019", // 어떤 버전으로 컴파일
-        "allowSyntheticDefaultImports": true, // default export가 없는 모듈에서 default imports를 허용
-        "experimentalDecorators": true, // decorator 실험적 허용
-        "emitDecoratorMetadata": true, // 데코레이터가 있는 선언에 대해 특정 타입의 메타 데이터를 내보내는 실험적인 지원
-        "skipLibCheck": true, // 정의 파일 타입 체크 여부
-        "moduleResolution": "node", // commonJS -> node 에서 동작
-        "module": "commonjs", // import 문법
-        "strict": true, // 타입 검사 엄격하게
-        "pretty": true, // error 메시지 예쁘게
-        "sourceMap": true, // 소스맵 파일 생성 -> .ts가 .js 파일로 트랜스 시 .js.map 생성
-        "outDir": "./dist", // 트랜스 파일 (.js) 저장 경로
-        "allowJs": true, // js 파일 ts에서 import 허용
-        "esModuleInterop": true, // ES6 모듈 사양을 준수하여 CommonJS 모듈을 가져올 수 있게 허용
-        "typeRoots": [
-            "./src/types/express.d.ts", // 타입(*.d.ts)파일을 가져올 디렉토리 설정
-            "./node_modules/@types" // 설정 안할시 기본적으로 ./node_modules/@types
-        ],
-        "baseUrl": "./src",
-        "declaration": true,
-        "declarationDir": "./dist",
-        "emitDeclarationOnly": true,
-        "plugins": [
-            {
-                "transform": "typia/lib/transform"
-            }
-        ]
-    },
-    "include": [
-        "./src/**/*" // build 시 포함
-    ],
-    "exclude": [
-        "node_modules", // build 시 제외
-        "tests"
-    ]
-}

package/webpack.config.js

@@ -1,53 +0,0 @@
-import path from "path";
-
-const __dirname = path.resolve();
-
-export default {
-    mode: 'production',
-    output: {
-        path: `${__dirname}/dist`,
-        filename: 'bundle.js',
-        publicPath: '/',
-    },
-    entry: './src/index.ts',
-    resolve: {
-        alias: {
-            '@src': path.resolve(__dirname, './src/'),
-        },
-        extensions: [
-            '.webpack.js',
-            '.web.js',
-            '.ts',
-            '.js',
-            '.d.ts',
-            '...',
-        ],
-        modules: ['src', 'node_modules'],
-    },
-    module: {
-        rules: [
-            {
-                test: /\.(js|ts)?$/,
-                exclude: /(node_modules|__tests__)/,
-                use: {
-                    loader: 'swc-loader',
-                    options: {
-                        jsc: {
-                            parser: {
-                                syntax: "typescript"
-                            }
-                        }
-                    }
-                },
-                resolve: {
-                    fullySpecified: false,
-                }
-            },
-        ],
-    },
-    performance: {
-        hints: false,
-        maxEntrypointSize: 512000,
-        maxAssetSize: 512000
-    }
-}