export function alongTheLine(
    start: PointLike,
    end: PointLike = [Infinity, Infinity],
    vector: PointLike = new Point(start, end),
    large = false,
): Point {
    const uVector = Point.from(vector).sign();
    const sNode = large ? PointCall(start, 'mul', 0.05) : Point.from(start);
    const eNode = large ? PointCall(end, 'mul', 0.05) : Point.from(end);

    // 起点并不是导线或者起点等于终点，直接返回
    if (!isLine(sNode) || sNode.isEqual(eNode)) {
        return Point.from(start);
    }

    let node = sNode, next = node.add(uVector);
    // 当前点没有到达终点，还在导线所在直线内部，那就前进
    while (isLine(next) && !node.isEqual(eNode)) {
        if (hasConnect(node, next)) {
            node = next;
            next = node.add(uVector);
        }
        else {
            break;
        }
    }

    return large ? node.mul(20) : node;
}

 points: Electronics[prop.type].points.map(({ direction, position }) => ({
     size: -1,
     class: 'part-point-open' as 'part-point-open',
     direction: Point.from(direction),
     position: Point.from(position),
     originPosition: Point.from(position),
 })),

    test('create a instance', () => {
        expect(Point.from(5)).toEqual(new Point(5, 5));
        expect(Point.from([0, 0])).toEqual(new Point(0, 0));
        expect(Point.from([5, 4])).toEqual(new Point(5, 4));
        expect(new Point([0, 1], [10, 0])).toEqual(new Point(10, -1));

        expect(Point.from(5)).toEqual(Point.from([5, 5]));
    });

export function deleteConnect(point: PointLike, connect: PointLike, large = false): boolean {
    const origin = large ? PointCall(point, 'mul', 0.05) : Point.from(point);
    const check = large ? PointCall(connect, 'mul', 0.05) : Point.from(connect);
    const key = point2key(origin);
    const data = $map[key];

    if (!data) {
        throw new Error(`(map) space point: ${key}`);
    }

    return data.connect.delete((node) => node.isEqual(check));
}

export function addConnect(point: PointLike, connect: PointLike, large = false): void {
    const origin = large ? PointCall(point, 'mul', 0.05) : Point.from(point);
    const check = large ? PointCall(connect, 'mul', 0.05) : Point.from(connect);
    const key = point2key(origin);
    const data = $map[key];

    if (!data) {
        throw new Error(`(map) space point: ${key}`);
    }

    if (!hasConnect(origin, check)) {
        data.connect.push(check);
    }
}

    /**
     * 终点（起点）指向某点
     *  - 导线节点数量少于`1`则忽略
     */
    endToPoint(node: Point, mode: 'start' | 'end' = 'end'): this {
        if (this.length <= 1) {
            return this;
        }

        let last, prev;
        if (mode === 'end') {
            last = this.length - 1;
            prev = this.length - 2;
        }
        else if (mode === 'start') {
            last = 0;
            prev = 1;
        }
        else {
            throw new Error('LineWay: Illegal mode');
        }

        if (this[last][0] === this[prev][0]) {
            this[prev][0] = node[0];
        }
        else {
            this[prev][1] = node[1];
        }
        this[last] = Point.from(node);

        return this;
    }

/**
 * 返回地图标记数据的副本
 * @param {NodeInputData} data 原始数据
 * @returns {NodeData}
 */
function dataClone(data: NodeInputData): NodeData {
    return {
        id: data.id,
        type: data.type,
        point: Point.from(data.point),
        connect: data.connect ? data.connect.map(Point.from) : [],
    };
}

    static from(points: Point[] | PointLike[]) {
        const way = new LineWay(points.length);

        for (let i = 0; i < points.length; i++) {
            way[i] = Point.from(points[i]);
        }

        return way;
    }