circuitscript 0.0.22 → 0.0.25

package/dist/cjs/geometry.js

@@ -0,0 +1,450 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerticalAlign = exports.HorizontalAlign = exports.Geometry = exports.GeometryProp = exports.Label = void 0;
+const core_1 = __importDefault(require("@flatten-js/core"));
+const sizing_js_1 = require("./sizing.js");
+const globals_js_1 = require("./globals.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+class Label extends core_1.default.Polygon {
+    get box() {
+        return this.polygon.box;
+    }
+    constructor(id, text, anchorPoint, polygon, style, bounds) {
+        super(polygon.vertices);
+        this.anchorPoint = [0, 0];
+        this.boundingBox = { width: -1, height: -1 };
+        this.font = 'default';
+        this.id = id;
+        this.text = text;
+        this.anchorPoint = anchorPoint;
+        this.style = style;
+        this.boundingBox = polygon.box;
+        this.polygon = polygon;
+        this.textMeasurementBounds = bounds;
+    }
+    static fromPoint(id, x, y, text, style) {
+        let useText;
+        if (typeof text === 'number') {
+            useText = text.toString();
+        }
+        else if (typeof text === 'object'
+            && text instanceof ParamDefinition_js_1.NumericValue) {
+            useText = text.toDisplayString();
+        }
+        else if (typeof text === 'string') {
+            useText = text;
+        }
+        else {
+            throw 'Invalid string passed into label';
+        }
+        const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', } = style ?? {};
+        const { width, height, box } = (0, sizing_js_1.measureTextSize2)(useText, globals_js_1.defaultFont, fontSize, fontWeight, anchor, vanchor);
+        const polygonCoords = [
+            [box.x, box.y],
+            [box.x2, box.y],
+            [box.x2, box.y2],
+            [box.x, box.y2],
+            [box.x, box.y],
+        ];
+        const polygon = new core_1.default.Polygon(polygonCoords);
+        return new Label(id, useText, [x, y], polygon, style, box);
+    }
+    rotate(angle, origin) {
+        const feature = super.rotate(angle, origin);
+        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
+    }
+    transform(matrix) {
+        const feature = super.transform(matrix);
+        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
+    }
+    getLabelPosition() {
+        return this.anchorPoint;
+    }
+}
+exports.Label = Label;
+class GeometryProp {
+    constructor(name, value) {
+        this.name = name;
+        this.value = value;
+    }
+}
+exports.GeometryProp = GeometryProp;
+class Geometry {
+    static point(x, y) {
+        return new core_1.default.Point(x, y);
+    }
+    static line(x1, y1, x2, y2) {
+        return new core_1.default.Line(Geometry.point(x1, y1), Geometry.point(x2, y2));
+    }
+    static label(id, x, y, text, style) {
+        return Label.fromPoint(id, x, y, text, style);
+    }
+    static segment(start, end) {
+        return new core_1.default.Segment(Geometry.point(start[0], start[1]), Geometry.point(end[0], end[1]));
+    }
+    static polygon(coords) {
+        return new core_1.default.Polygon(coords);
+    }
+    static multiline(coords) {
+        const segments = [];
+        for (let i = 0; i < coords.length - 1; i++) {
+            segments.push(new core_1.default.Segment(Geometry.point(coords[i][0], coords[i][1]), Geometry.point(coords[i + 1][0], coords[i + 1][1])));
+        }
+        return new core_1.default.Multiline(segments);
+    }
+    static arc(center, radius, startAngle, endAngle, sweepDirection) {
+        return new core_1.default.Arc(Geometry.point(center[0], center[1]), radius, startAngle, endAngle, sweepDirection);
+    }
+    static getCoords(item) {
+        const points = item.vertices.map(vertex => {
+            return [vertex.x, vertex.y];
+        });
+        return points;
+    }
+    static rotateDegs(feature, angleDegrees, center) {
+        const angleRads = angleDegrees * Math.PI / 180;
+        return feature.rotate(angleRads, Geometry.point(center[0], center[1]));
+    }
+    static flip(feature, flipX, flipY) {
+        const flipMatrix = (new core_1.default.Matrix()).scale(flipX === 0 ? 1 : -1, flipY == 0 ? 1 : -1);
+        return feature.transform(flipMatrix);
+    }
+    static groupRotate(features, angle, center) {
+        const angleRads = angle * Math.PI / 180;
+        const rotateAboutPoint = Geometry.point(center[0], center[1]);
+        return features.map(feature => {
+            return feature.rotate(angleRads, rotateAboutPoint);
+        });
+    }
+    static groupFlip(features, flipX, flipY) {
+        const flipMatrix = (new core_1.default.Matrix()).scale(flipX === 0 ? 1 : -1, flipY == 0 ? 1 : -1);
+        return features.map(feature => {
+            return feature.transform(flipMatrix);
+        });
+    }
+    static groupBounds(features) {
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        features.forEach(feature => {
+            const box = feature.box;
+            if (feature instanceof Label
+                && typeof feature.text === 'string'
+                && feature.text.trim().length === 0) {
+                return;
+            }
+            if (box.xmin === undefined) {
+                throw "Invalid box!";
+            }
+            minX = Math.min(minX, box.xmin);
+            minY = Math.min(minY, box.ymin);
+            maxX = Math.max(maxX, box.xmax);
+            maxY = Math.max(maxY, box.ymax);
+        });
+        return {
+            start: [minX, minY],
+            end: [maxX, maxY],
+            width: maxX - minX,
+            height: maxY - minY,
+        };
+    }
+    static getType(feature) {
+        if (feature instanceof Label) {
+            return 'label';
+        }
+        else if (feature instanceof core_1.default.Polygon) {
+            return 'polygon';
+        }
+        else if (feature instanceof core_1.default.Segment) {
+            return 'segment';
+        }
+        console.log('unknown type', feature);
+    }
+    static featuresToPath(items) {
+        const paths = [];
+        let isClosedPolygon = false;
+        items.forEach(item => {
+            if (item instanceof Label) {
+                return;
+            }
+            const path = [];
+            if (item instanceof core_1.default.Arc) {
+                const x = item.center.x;
+                const y = item.center.y;
+                const radius = item.r;
+                let useEndAngle = item.endAngle;
+                let extraEnd = '';
+                if (item.startAngle === 0 && item.endAngle === Geometry.FullCircleRadians) {
+                    useEndAngle = 359.9999 * Math.PI / 180;
+                    isClosedPolygon = true;
+                    extraEnd = ' Z';
+                }
+                const startPoint = getArcPointRadians(x, y, radius, item.startAngle);
+                const endPoint = getArcPointRadians(x, y, radius, useEndAngle);
+                paths.push('M', startPoint[0], startPoint[1], 'A', radius, radius, 0, 1, 1, endPoint[0], endPoint[1], extraEnd);
+            }
+            else {
+                const coords = Geometry.getCoords(item);
+                if (item instanceof core_1.default.Polygon) {
+                    isClosedPolygon = true;
+                }
+                for (let i = 0; i < coords.length; i++) {
+                    const [x, y] = coords[i];
+                    const command = (i === 0) ? 'M' : 'L';
+                    path.push(`${command}`, x, y);
+                }
+                if (isClosedPolygon) {
+                    path.push('Z');
+                }
+                paths.push(...path);
+            }
+        });
+        return {
+            path: this.roundPathValues(paths),
+            isClosedPolygon,
+        };
+    }
+    static roundPathValues(pathItems) {
+        return pathItems.map(item => {
+            if (typeof item === 'number') {
+                return (+item.toFixed(7)).toString();
+            }
+            return item;
+        }).join(" ");
+    }
+    static angle(dx, dy) {
+        const line = new core_1.default.Segment(new core_1.default.Point(0, 0), new core_1.default.Point(dx, dy));
+        return line.slope * 180 / Math.PI;
+    }
+    static getQuadrant(dx, dy) {
+        const angle = Geometry.angle(dx, dy);
+        return Number(Math.floor(angle / 90));
+    }
+    static mergeWires(wirePoints) {
+        const existingSegments = [];
+        wirePoints.forEach(points => {
+            const tmpPoints = points.map(pt => {
+                return new core_1.default.Point(pt.x, pt.y);
+            });
+            for (let i = 0; i < tmpPoints.length - 1; i++) {
+                const pt1 = tmpPoints[i];
+                const pt2 = tmpPoints[i + 1];
+                const newSegments = [
+                    new core_1.default.Segment(pt1, pt2)
+                ];
+                for (let j = 0; j < existingSegments.length; j++) {
+                    const currentSegment = existingSegments[j];
+                    for (let k = 0; k < newSegments.length; k++) {
+                        const newSegment = newSegments[k];
+                        const segmentsAreSame = newSegment.equalTo(currentSegment) || newSegment.reverse().equalTo(currentSegment);
+                        if (segmentsAreSame) {
+                            newSegments.splice(k, 1);
+                            j = Math.max(0, j - 1);
+                            break;
+                        }
+                        const intersectPoints = currentSegment.intersect(newSegment);
+                        if (intersectPoints.length > 0) {
+                            const endToEndIntersect = intersectPoints.length === 1 &&
+                                (currentSegment.end.equalTo(newSegment.start) || currentSegment.end.equalTo(newSegment.end) ||
+                                    currentSegment.start.equalTo(newSegment.start) || currentSegment.start.equalTo(newSegment.end));
+                            if (endToEndIntersect) {
+                                continue;
+                            }
+                            const splitSegments = [];
+                            intersectPoints.forEach(intersectPoint => {
+                                const splitResult1 = currentSegment.split(intersectPoint);
+                                const splitResult2 = newSegment.split(intersectPoint);
+                                [...splitResult1, ...splitResult2].forEach(segment => {
+                                    if (segment !== null) {
+                                        const matchingSegmentIndex = splitSegments.findIndex(item => {
+                                            return item.equalTo(segment);
+                                        });
+                                        if (matchingSegmentIndex === -1 &&
+                                            !segment.equalTo(currentSegment) && !segment.equalTo(newSegment)) {
+                                            splitSegments.push(segment);
+                                        }
+                                    }
+                                });
+                            });
+                            const splitCurrentSegments = [];
+                            const splitNewSegments = [];
+                            splitSegments.forEach(segment => {
+                                if (currentSegment.contains(segment.start) && currentSegment.contains(segment.end)) {
+                                    splitCurrentSegments.push(segment);
+                                }
+                                else {
+                                    splitNewSegments.push(segment);
+                                }
+                            });
+                            replaceSegments(existingSegments, j, splitCurrentSegments);
+                            replaceSegments(newSegments, k, splitNewSegments);
+                            j = Math.max(0, j - 1);
+                        }
+                    }
+                }
+                newSegments.forEach(segment => {
+                    existingSegments.push(segment);
+                });
+            }
+        });
+        const trackWirePoints = [];
+        existingSegments.forEach(segment => {
+            trackWirePoints.push([segment.start.x, segment.start.y]);
+            trackWirePoints.push([segment.end.x, segment.end.y]);
+        });
+        const accumPoints = trackWirePoints.reduce((accum, point) => {
+            const found = accum.find(item => {
+                return item[0] === point[0] && item[1] === point[1];
+            });
+            if (found) {
+                found[2]++;
+            }
+            else {
+                accum.push([point[0], point[1], 1]);
+            }
+            return accum;
+        }, []);
+        const intersectPoints = accumPoints.reduce((accum, entry) => {
+            if (entry[2] > 2) {
+                accum.push(entry);
+            }
+            return accum;
+        }, []);
+        const segments = existingSegments.map(segment => {
+            return [
+                [segment.start.x, segment.start.y],
+                [segment.end.x, segment.end.y]
+            ];
+        });
+        return {
+            intersectPoints,
+            segments,
+        };
+    }
+}
+exports.Geometry = Geometry;
+Geometry.FullCircleRadians = 2 * Math.PI;
+function replaceSegments(segments, index, replacedSegments) {
+    if (replacedSegments.length > 0) {
+        segments.splice(index, 1);
+    }
+    let counter = 0;
+    replacedSegments.forEach(item => {
+        if (item !== null) {
+            segments.splice(index + counter, 0, item);
+            counter++;
+        }
+    });
+    return counter;
+}
+function labelPolygonForAnchors(x, y, width, height, hAnchor, vAnchor) {
+    let coordVectors = [];
+    if (hAnchor === HorizontalAlign.Left) {
+        if (vAnchor === VerticalAlign.Bottom) {
+            coordVectors = [
+                [0, 0],
+                [0, -1],
+                [1, -1],
+                [1, 1],
+            ];
+        }
+        else if (vAnchor === VerticalAlign.Middle) {
+            coordVectors = [
+                [0, -0.5],
+                [0, 0.5],
+                [1, 0.5],
+                [1, -0.5],
+            ];
+        }
+        else if (vAnchor === VerticalAlign.Top) {
+            coordVectors = [
+                [0, 0],
+                [1, 0],
+                [1, 1],
+                [0, 1],
+            ];
+        }
+    }
+    else if (hAnchor === HorizontalAlign.Right) {
+        if (vAnchor === VerticalAlign.Bottom) {
+            coordVectors = [
+                [0, 0],
+                [-1, 0],
+                [-1, -1],
+                [0, -1],
+            ];
+        }
+        else if (vAnchor === VerticalAlign.Middle) {
+            coordVectors = [
+                [0, -0.5],
+                [0, 0.5],
+                [-1, 0.5],
+                [-1, -0.5],
+            ];
+        }
+        else if (vAnchor === VerticalAlign.Top) {
+            coordVectors = [
+                [0, 0],
+                [0, 1],
+                [-1, 1],
+                [-1, 0]
+            ];
+        }
+    }
+    else if (hAnchor === HorizontalAlign.Middle) {
+        if (vAnchor === VerticalAlign.Bottom) {
+            coordVectors = [
+                [-0.5, 0],
+                [-0.5, -1],
+                [0.5, -1],
+                [0.5, 0]
+            ];
+        }
+        else if (vAnchor === VerticalAlign.Middle) {
+            coordVectors = [
+                [-0.5, 0.5],
+                [-0.5, -0.5],
+                [0.5, -0.5],
+                [0.5, 0.5],
+            ];
+        }
+        else if (vAnchor === VerticalAlign.Top) {
+            coordVectors = [
+                [0.5, 0],
+                [0.5, 1],
+                [-0.5, 1],
+                [-0.5, 0]
+            ];
+        }
+    }
+    return coordVectors.map(([vx, vy]) => {
+        return [
+            x + vx * width,
+            y + vy * height
+        ];
+    });
+}
+var HorizontalAlign;
+(function (HorizontalAlign) {
+    HorizontalAlign["Left"] = "left";
+    HorizontalAlign["Middle"] = "middle";
+    HorizontalAlign["Right"] = "right";
+})(HorizontalAlign || (exports.HorizontalAlign = HorizontalAlign = {}));
+var VerticalAlign;
+(function (VerticalAlign) {
+    VerticalAlign["Top"] = "top";
+    VerticalAlign["Middle"] = "middle";
+    VerticalAlign["Bottom"] = "bottom";
+})(VerticalAlign || (exports.VerticalAlign = VerticalAlign = {}));
+function getArcPointRadians(centerX, centerY, radius, angleRads) {
+    const dx = Math.cos(angleRads);
+    const dy = Math.sin(angleRads);
+    return [
+        centerX + dx * radius,
+        centerY + dy * radius
+    ];
+}

package/dist/cjs/globals.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockTypes = exports.ReferenceTypes = exports.ComponentTypes = exports.wireColor = exports.junctionColor = exports.junctionSize = exports.bodyColor = exports.defaultFontSize = exports.defaultFontBold = exports.defaultFont = exports.portHeight = exports.portWidth = exports.SymbolPinSide = exports.LayoutDirection = exports.ParamKeys = exports.NoNetText = exports.GlobalNames = void 0;
+var GlobalNames;
+(function (GlobalNames) {
+    GlobalNames["__root"] = "__root";
+    GlobalNames["gnd"] = "gnd";
+    GlobalNames["DefaultResistor"] = "res";
+    GlobalNames["DefaultCapacitor"] = "cap";
+    GlobalNames["DefaultInductor"] = "ind";
+    GlobalNames["symbol"] = "symbol";
+})(GlobalNames || (exports.GlobalNames = GlobalNames = {}));
+exports.NoNetText = 'NO_NET';
+var ParamKeys;
+(function (ParamKeys) {
+    ParamKeys["__is_net"] = "__is_net";
+    ParamKeys["__is_label"] = "__is_label";
+    ParamKeys["priority"] = "priority";
+    ParamKeys["net_name"] = "net_name";
+})(ParamKeys || (exports.ParamKeys = ParamKeys = {}));
+var LayoutDirection;
+(function (LayoutDirection) {
+    LayoutDirection["RIGHT"] = "RIGHT";
+    LayoutDirection["LEFT"] = "LEFT";
+})(LayoutDirection || (exports.LayoutDirection = LayoutDirection = {}));
+var SymbolPinSide;
+(function (SymbolPinSide) {
+    SymbolPinSide["Left"] = "left";
+    SymbolPinSide["Right"] = "right";
+})(SymbolPinSide || (exports.SymbolPinSide = SymbolPinSide = {}));
+exports.portWidth = 20;
+exports.portHeight = 2;
+exports.defaultFont = 'Open Sans-Regular, Arial';
+exports.defaultFontBold = 'Open Sans-Bold, Arial-Bold, Arial';
+exports.defaultFontSize = 10;
+exports.bodyColor = '#FFFEAF';
+exports.junctionSize = 5;
+exports.junctionColor = 'rgb(0, 132, 0)';
+exports.wireColor = 'rgb(0, 132, 0)';
+var ComponentTypes;
+(function (ComponentTypes) {
+    ComponentTypes["gnd"] = "gnd";
+    ComponentTypes["net"] = "net";
+    ComponentTypes["label"] = "label";
+    ComponentTypes["point"] = "point";
+})(ComponentTypes || (exports.ComponentTypes = ComponentTypes = {}));
+var ReferenceTypes;
+(function (ReferenceTypes) {
+    ReferenceTypes["function"] = "function";
+    ReferenceTypes["value"] = "value";
+    ReferenceTypes["variable"] = "variable";
+    ReferenceTypes["instance"] = "instance";
+})(ReferenceTypes || (exports.ReferenceTypes = ReferenceTypes = {}));
+var BlockTypes;
+(function (BlockTypes) {
+    BlockTypes[BlockTypes["Branch"] = 1] = "Branch";
+    BlockTypes[BlockTypes["Join"] = 2] = "Join";
+    BlockTypes[BlockTypes["Parallel"] = 3] = "Parallel";
+    BlockTypes[BlockTypes["Point"] = 4] = "Point";
+})(BlockTypes || (exports.BlockTypes = BlockTypes = {}));