rm-build-dxf 0.1.186

package/src/pages/CubeView.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    containerRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/src/pages/DxfPreview.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    src: string;
+    $props: {
+        readonly src?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    container: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/src/pages/Editor.vue.d.ts

@@ -0,0 +1,8 @@
+import { Manager } from 'split-window';
+type __VLS_Props = {
+    manager: Manager;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    dom: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/src/pages/ExportGLB.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/src/pages/ImagePreview.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    src?: string | undefined;
+    $props: {
+        readonly src?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    imageRef: HTMLImageElement;
+}, HTMLDivElement>;
+export default _default;

package/src/pages/ModelView.vue.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    url: string;
+    type?: string | undefined;
+    $props: {
+        readonly url?: string | undefined;
+        readonly type?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    container: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/src/pages/Setting.vue.d.ts

@@ -0,0 +1,6 @@
+import { TabPageEventPanel } from 'split-window';
+type __VLS_Props = {
+    eventPanel: TabPageEventPanel;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/src/pages/Todo.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/src/pages/WallView.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    url?: Record<string, any> | undefined;
+    $props: {
+        readonly url?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    elRef: HTMLDivElement;
+}, any>;
+export default _default;

package/src/pages/WindowManager.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/src/pages/buildJson.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    dom: HTMLDivElement;
+}, any>;
+export default _default;

package/src/pages/modelCarrier/index.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    elRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/src/router/index.d.ts

@@ -0,0 +1,2 @@
+import { App } from 'vue';
+export declare function useRouter(app: App): void;

package/src/utils/EventDispatcher.d.ts

@@ -0,0 +1,18 @@
+import { EventDispatcher as ED, EventListener } from 'three';
+export declare class EventDispatcher<TEventMap extends {} = {}> extends ED<TEventMap> {
+    uuid: string;
+    addEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this>, option?: {
+        once: boolean;
+    }): () => void;
+    private eventRecordStack;
+    addEventRecord(name: string | string[], ...cancels: (() => void)[]): {
+        add: (cancel: () => void) => {
+            add: /*elided*/ any;
+        };
+    };
+    /** 取消事件记录
+     * @param name
+     * @returns
+     */
+    cancelEventRecord(name: string | string[]): void;
+}

package/src/utils/algorithms/AlignToParallelSegments.d.ts

@@ -0,0 +1,25 @@
+import { LineSegment } from './LineSegment';
+type OnGroupFun = (group: LineSegment[], projValues: number[], axis: LineSegment) => void;
+export interface AlignDescriptor {
+    esp?: number;
+    gap?: number;
+    onMergeLine?: (target: LineSegment, source: LineSegment) => void;
+    onGroup?: OnGroupFun;
+    onSegmentClippedAway?: (target: LineSegment, clipLines: LineSegment[]) => void;
+    onLayoutDesign?: (lines: LineSegment[], DELETE_SYMBOL: symbol) => void;
+}
+/** 通过平行轴和垂直轴分组对齐线段，搭配垂直纠正使用
+ */
+export declare class AlignToParallelSegments {
+    /** 拟合并对齐线段
+     * @param groups
+     * @param verticalLines
+     */
+    static fittingAlignment(groups: LineSegment[][], verticalLines: LineSegment[], opt?: AlignDescriptor): LineSegment<Record<string, any>>[];
+    /** 对齐到平行线段, 请在垂直纠正（AxisAlignCorr）后使用
+     * @param lines
+     * @returns
+     */
+    static align(lines: LineSegment[], opt?: AlignDescriptor): LineSegment<Record<string, any>>[];
+}
+export {};

package/src/utils/algorithms/AxisAlignCorr.d.ts

@@ -0,0 +1,38 @@
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+export declare class AxisAlignCorr {
+    static start(lines: LineSegment[], targettLine: LineSegment, excludeLines?: LineSegment[]): LineSegment<any>[];
+    private lines;
+    private baseline;
+    private excludeLines;
+    private grid;
+    constructor(lines: LineSegment[], baseline: LineSegment, excludeLines?: LineSegment[]);
+    private visited;
+    private newLines;
+    private start;
+    /** 添加
+     * @param lines
+     * @returns
+     */
+    private addVisited;
+    private queryPoint;
+    /** 纠正
+     * @param line
+     * @param targettLine
+     */
+    private correction;
+    /** 递归执行
+     * @param line
+     * @param enterPoint
+     */
+    private recursion;
+    /** 构建连接
+     */
+    private establishConnection;
+    point: Point<Record<string, any>>;
+    /** 旋转
+     * @param line
+     * @param errAngle
+     */
+    private rotate;
+}

package/src/utils/algorithms/Box2.d.ts

@@ -0,0 +1,96 @@
+import { LineSegment } from './LineSegment';
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+export declare class Box2 {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    get points(): Point<Record<string, any>>[];
+    get width(): number;
+    get height(): number;
+    get center(): Point<Record<string, any>>;
+    constructor(minX?: number, maxX?: number, minY?: number, maxY?: number);
+    /**
+     *
+     * @param z
+     * @returns
+     */
+    getPaths3D(z?: number): number[];
+    /**
+     * 判断线段是与包围盒相交
+     * @description Liang-Barsky算法的变种
+     * @param line
+     */
+    intersectLineSegment(line: LineSegment): boolean;
+    /**
+     * 判断线段是在包围盒内
+     * @param line
+     */
+    containsLineSegment(line: LineSegment): boolean;
+    /**
+     * 判断矩形与包围盒相交
+     * @param rectangle
+     */
+    intersectRectangle(rectangle: Rectangle): boolean;
+    /**
+     * 判断矩形是在包围盒内
+     * @param rectangle
+     */
+    containsRectangle(rectangle: Rectangle): boolean;
+    /**
+     * 判断包围盒与包围盒相交
+     * @param box
+     */
+    intersectBox(box: Box2): boolean;
+    /**
+     * 判断包围盒是在包围盒内
+     * @param box
+     */
+    containsBox(box: Box2): boolean;
+    /** 判断点是在包围盒内
+     * @param point
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     *
+     * @param minX
+     * @param minY
+     * @param maxX
+     * @param maxY
+     * @returns
+     */
+    set(minX: number, minY: number, maxX: number, maxY: number): this;
+    /**
+     *
+     * @param maxWidth
+     * @param maxHeight
+     * @param mode
+     * @returns
+     */
+    scaleSize(maxWidth: number, maxHeight: number, mode?: 'min' | 'max'): number;
+    /**
+     *
+     * @param scalar
+     * @returns
+     */
+    multiplyScalar(scalar: number): this;
+    expansion(w: number): this;
+    /**
+     *
+     * @returns
+     */
+    clone(): Box2;
+    /**
+     *
+     * @param points
+     * @returns
+     */
+    static fromByPoints(...points: Point[]): Box2;
+    /**
+     *
+     * @param points
+     * @returns
+     */
+    static fromByLineSegment<T = any>(...lines: LineSegment<T>[]): Box2;
+}

package/src/utils/algorithms/CheckPointCloudContinuity.d.ts

@@ -0,0 +1,63 @@
+import { Vector3 } from 'three';
+type Point3D = {
+    x: number;
+    y: number;
+    z: number;
+};
+type LineSegmentType = {
+    start: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    end: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+};
+/**
+ * 检测点云在分部轴上的连续性，z朝上
+ */
+export declare class CheckPointCloudContinuity {
+    static continuity(ts: number[], len: number, gridSize?: number, ratio?: number): boolean;
+    /** 多轴投影连续性检测
+     * @param points
+     */
+    static checkByProjectionContinuity(points: Point3D[], opt?: {
+        ratio?: number;
+        gridSize?: number;
+        axisLine?: LineSegmentType;
+    }): boolean;
+    /** 通过区域投影面积占比检测
+     * @param points
+     * @returns
+     */
+    static checkByVoxelDensity(points: Point3D[], opt?: {
+        /**
+         * 体素大小
+         */
+        gridSize?: number;
+        /**
+         * 竖直轴占比比例
+         */
+        xRatio?: number;
+        /**
+         * 水平轴占比比例
+         */
+        yRatio?: number;
+        /**
+         * 总占比比例
+         */
+        overallRatio?: number;
+        axisLine?: LineSegmentType;
+    }): boolean;
+    /** 获取投影值
+     * @param points
+     * @param start
+     * @param end
+     * @returns
+     */
+    static projectPoint(points: Point3D[], start: Vector3, end: Vector3): number[];
+}
+export {};

package/src/utils/algorithms/ConstraintSystem.d.ts

@@ -0,0 +1,17 @@
+export declare class Variable {
+    value: number;
+    fixed: boolean;
+    constructor(value: number, fixed?: boolean);
+}
+export interface Constraint {
+    evaluate(): number[];
+}
+export declare class ConstraintSystem {
+    constraints: Constraint[];
+    variables: Variable[];
+    addConstraint(c: Constraint): void;
+    addVariable(v: Variable): void;
+    residuals(): number[];
+    jacobian(eps?: number): number[][];
+    solve(iterations?: number): void;
+}

package/src/utils/algorithms/ConvexHullGraham.d.ts

@@ -0,0 +1,16 @@
+interface Point {
+    x: number;
+    y: number;
+}
+export declare class ConvexHullAndrew {
+    private static cross;
+    /**
+     * Andrew 单调链算法计算凸包
+     * @param points 输入点集
+     * @param includeCollinear 是否保留共线点
+     *                        false（默认）：严格凸包，只保留顶点
+     *                        true：边上共线点也保留
+     */
+    static convexHull(points: Point[], includeCollinear?: boolean): Point[];
+}
+export {};

package/src/utils/algorithms/Debouncing.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 防抖
+ */
+export declare class Debouncing {
+    private timeoutId;
+    private delay;
+    constructor(delay: number);
+    debounce(func: () => void): void;
+    cancle(): void;
+}

package/src/utils/algorithms/LineIndexGenerator.d.ts

@@ -0,0 +1,12 @@
+import { LineSegment } from './LineSegment';
+export declare class LineIndexGenerator {
+    private index;
+    get size(): number;
+    constructor(lines?: LineSegment[]);
+    private next;
+    reset(): void;
+    map: Map<LineSegment<Record<string, any>>, number>;
+    lineMap: Map<number, LineSegment<Record<string, any>>>;
+    getIndex(key: LineSegment): number;
+    getLine(index: number): LineSegment | undefined;
+}

package/src/utils/algorithms/LineQueryer.d.ts

@@ -0,0 +1,42 @@
+import { LineSegment } from './LineSegment';
+import { LineSegmentSpatialHash } from './LineSegmentSpatialHash';
+import { Point } from './Point';
+import { PointSpatialHash } from './PointSpatialHash';
+export declare class LineQueryer {
+    pointVirtualGrid: PointSpatialHash<LineSegment>;
+    lsh: LineSegmentSpatialHash;
+    constructor(lines: LineSegment[]);
+    update(lines: LineSegment[]): void;
+    clear(): void;
+    /**
+     * @param point
+     * @param radius
+     * @param opt
+     * @returns
+     */
+    queryNearestPoint(point: Point, opt?: {
+        resultIndex?: number;
+        radius?: number;
+        condition?: (node: {
+            point: Point<Record<string, any>>;
+            userData?: LineSegment<Record<string, any>> | undefined;
+        }) => boolean;
+    }): {
+        point: Point<Record<string, any>>;
+        line: LineSegment;
+    } | null;
+    /**
+     * @param point
+     * @param radius
+     * @param opt
+     * @returns
+     */
+    queryNearestLine(point: Point, opt?: {
+        resultIndex?: number;
+        radius?: number;
+        condition?: (target_line: LineSegment, point: Point) => boolean;
+    }): {
+        point: Point<Record<string, any>>;
+        line: LineSegment<Record<string, any>>;
+    } | null;
+}