geometric-library 1.3.0 → 1.4.0

package/dist/types/index.d.ts

@@ -1,16 +1,4 @@
-export { Angle } from './abstracts/Angle';
-export { Figure } from './abstracts/Figure';
-export { Flag } from './abstracts/Flag';
-export { Magnitude } from './abstracts/Magnitude';
-export { Point } from './abstracts/Point';
-export { Vector } from './abstracts/Vector.js';
-export { ArcCurve } from './figures/ArcCurve';
-export { Circle } from './figures/Circle';
-export { CubicBezierCurve } from './figures/CubicBezierCurve';
-export { Ellipse } from './figures/Ellipse';
-export { Line } from './figures/Line';
-export { Polygon } from './figures/Polygon';
-export { QuadraticBezierCurve } from './figures/QuadraticBezierCurve';
-export { Calculator } from './utilities/Calculator';
+export * from './abstracts';
+export * from './figures';
 export * from './utilities';
 export * from './types';

package/dist/types/types/index.d.ts

@@ -1,4 +1,3 @@
-export type TSegment = [IPoint, IPoint];
 export type TAxis = 'x' | 'y';
 export type TAxii = ['x', 'y'];
 export interface IBoundingBox {
@@ -14,131 +13,3 @@ export interface ISize {
 export interface IClonable<T> {
     clone(): T;
 }
-export interface IFlag extends IClonable<IFlag> {
-    readonly value: boolean;
-    invert(): this;
-    replace(value: boolean): this;
-    valueOf(): number;
-}
-export type TAngleUnit = 'radians' | 'degrees';
-export interface IAngle extends IClonable<IAngle> {
-    readonly cos: number;
-    readonly cot: number;
-    readonly degrees: number;
-    readonly radians: number;
-    readonly sin: number;
-    readonly tan: number;
-    normalize(): this;
-    replace(value: number, unit: TAngleUnit): this;
-    scale(factor: number): this;
-    valueOf(): number;
-}
-export type TAngleRange = [IAngle, IAngle];
-export interface IMagnitude extends IClonable<IMagnitude> {
-    replace(value: number): this;
-    scale(factor: number): this;
-    valueOf(): number;
-}
-export type TPointValues = [number, number];
-export interface IPoint extends IClonable<IPoint> {
-    readonly values: TPointValues;
-    readonly x: number;
-    readonly y: number;
-    reflect(about: IPoint): this;
-    replace(point: IPoint): this;
-    rotate(phi: IAngle, about?: IPoint): this;
-    translate(vector: IVector): this;
-}
-export type TVectorValues = [number, number];
-export interface IVector extends IClonable<IVector> {
-    readonly dx: number;
-    readonly dy: number;
-    readonly values: TVectorValues;
-    angleTo(vector: IVector): IAngle;
-    dotProduct(vector: IVector): number;
-    reflect(about: {
-        x: boolean;
-        y: boolean;
-    }): this;
-    replace(vector: IVector): this;
-    rotate(phi: IAngle): this;
-    scale(factor: number): this;
-}
-export type TFigureValue = IFlag | IMagnitude | IAngle | IPoint | IVector;
-export type TFigureValues = [IPoint, ...TFigureValue[]];
-export interface IFigure {
-    readonly boundingBox: IBoundingBox;
-    readonly values: TFigureValues;
-    reflect(about: IPoint | ILine): this;
-    rotate(phi: IAngle, about?: IPoint): this;
-    scale(factor: number, about?: IPoint): this;
-    translate(vector: IVector): this;
-}
-export type TLineRelativeValues = [IPoint, IVector];
-export type TLineAbsoluteValues = [IPoint, IPoint];
-export type TLineValues = TLineAbsoluteValues | TLineRelativeValues;
-export interface ILine extends IFigure, IClonable<ILine> {
-    readonly P0: IPoint;
-    readonly P1: IPoint;
-    readonly V: IVector;
-    readonly a: number;
-    readonly b: number;
-    readonly c: number;
-    readonly isHorizontal: boolean;
-    readonly isVertical: boolean;
-    readonly reciprocal: number | undefined;
-    readonly slope: number | undefined;
-    readonly xIntercept: number | undefined;
-    readonly yIntercept: number | undefined;
-    angleTo(reference: ILine | IVector): IAngle;
-    getIntersectionPoint(line: ILine): IPoint | undefined;
-    getPerpendicularProjection(point: IPoint): IPoint;
-    getPerpendicularThrough(point: IPoint): ILine;
-    getPointAtParameter(t: number): IPoint | undefined;
-    getXValueAtY(y: number): number | undefined;
-    getYValueAtX(x: number): number | undefined;
-    hasPoint(point: IPoint): boolean;
-    isParallelTo(line: ILine): boolean;
-    isPerpendicularTo(line: ILine): boolean;
-}
-export type TEllipseValues = [IPoint, IMagnitude, IMagnitude, IAngle];
-export type TEllipseCriticalPoints = [IPoint, IPoint, IPoint, IPoint];
-export interface IEllipse extends IFigure, IClonable<IEllipse> {
-    readonly center: IPoint;
-    readonly criticalPoints: TEllipseCriticalPoints;
-    readonly phi: IAngle;
-    readonly rx: IMagnitude;
-    readonly ry: IMagnitude;
-    computePointForTheta(theta: IAngle): IPoint;
-    computeThetaForPoint(point: IPoint): IAngle;
-}
-export type TCircleValues = [IPoint, IMagnitude];
-export interface ICircle extends IFigure, IClonable<ICircle> {
-    readonly center: IPoint;
-    readonly criticalPoints: TEllipseCriticalPoints;
-    readonly phi: IAngle;
-    readonly radius: IMagnitude;
-}
-export type TArcAbsoluteValues = [IPoint, IMagnitude, IMagnitude, IAngle, IFlag, IFlag, IPoint];
-export type TArcRelativeValues = [IPoint, IMagnitude, IMagnitude, IAngle, IFlag, IFlag, IVector];
-export type TArcValues = TArcAbsoluteValues | TArcRelativeValues;
-export interface IArcCurve extends IFigure, IClonable<IArcCurve> {
-    readonly center: IPoint;
-    readonly criticalPoints: IPoint[];
-}
-export type TCubicBezierAbsoluteValues = [IPoint, IPoint, IPoint, IPoint];
-export type TCubicBezierRelativeValues = [IPoint, IVector, IVector, IVector];
-export type TCubicBezierValues = TCubicBezierAbsoluteValues | TCubicBezierRelativeValues;
-export interface ICubicBezierCurve extends IFigure, IClonable<ICubicBezierCurve> {
-    readonly criticalPoints: IPoint[];
-}
-export type TQuadraticBezierAbsoluteValues = [IPoint, IPoint, IPoint];
-export type TQuadraticBezierRelativeValues = [IPoint, IVector, IVector];
-export type TQuadraticBezierValues = TQuadraticBezierAbsoluteValues | TQuadraticBezierRelativeValues;
-export interface IQuadraticBezierCurve extends IFigure, IClonable<IQuadraticBezierCurve> {
-    readonly criticalPoints: IPoint[];
-}
-export type TPolygonValues = [IPoint, IPoint, IPoint, ...IPoint[]];
-export interface IPolygon extends IClonable<IPolygon> {
-    readonly sides: number;
-}

package/dist/types/utilities/{Calculator.d.ts → calculator/Calculator.d.ts}

@@ -1,5 +1,7 @@
 type TInput = Calculator | number;
 export declare class Calculator {
+    static readonly EPSILON: number;
+    static readonly PI2: number;
     private _instance;
     constructor(arg: number);
     static abs(arg: TInput): Calculator;
@@ -9,6 +11,8 @@ export declare class Calculator {
     static atan2(first: TInput, second: TInput): Calculator;
     static cos(arg: TInput): Calculator;
     static div(first: TInput, second: TInput): Calculator;
+    static isEqual(a: number, b: number): boolean;
+    static isNearZero(a: number): boolean;
     static max(args: TInput[]): Calculator;
     static min(args: TInput[]): Calculator;
     static mod(first: TInput, second: TInput): Calculator;

package/dist/types/utilities/calculator/index.d.ts

@@ -0,0 +1 @@
+export * from './Calculator';

package/dist/types/utilities/index.d.ts

@@ -1,6 +1,4 @@
-import { Point } from '../abstracts/Point';
-import { Line } from '../figures/Line';
+import { Point } from '../abstracts';
+export * from './calculator';
 export declare const coordinateOrigin: Point;
-export declare const xAxis: Line;
-export declare const yAxis: Line;
 export declare const PI2: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geometric-library",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "A Node based, visually agnostic implementation of geometric functions, both abstract and finite.",
   "keywords": [
     "geometry",
@@ -24,12 +24,12 @@
   "types": "dist/types/index.d.ts",
   "scripts": {
     "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types",
-    "build:cjs": "tsc --project tsconfig.cjs.json",
-    "build:esm": "tsc --project tsconfig.esm.json",
-    "build:types": "tsc --declaration --emitDeclarationOnly --outDir dist/types",
+    "build:cjs": "tsc --project tsconfig.cjs.json && tsc-alias -p tsconfig.cjs.json",
+    "build:esm": "tsc --project tsconfig.esm.json && tsc-alias -p tsconfig.esm.json",
+    "build:types": "tsc --project tsconfig.types.json && tsc-alias -p tsconfig.types.json",
     "clean": "rm -rf dist",
-    "lint": "npx eslint ./src --ext .js,.ts",
-    "lint:fix": "npx eslint ./src --ext .js,.ts --fix",
+    "lint": "npx eslint ./src",
+    "lint:fix": "npx eslint ./src --fix",
     "prepare": "husky",
     "prettier": "npx prettier . --write",
     "test": "vitest --watch false",
@@ -40,21 +40,27 @@
     "decimal.js": "^10.4.3"
   },
   "devDependencies": {
-    "@types/node": "^20.14.2",
-    "@typescript-eslint/eslint-plugin": "^7.12.0",
-    "@typescript-eslint/parser": "^7.12.0",
-    "@vitest/coverage-v8": "^1.6.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.1",
+    "@commitlint/cli": "^20.4.1",
+    "@commitlint/config-conventional": "^20.4.1",
+    "@eslint/js": "^9.39.2",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^22.19.8",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import-x": "^4.16.1",
+    "globals": "^17.3.0",
     "husky": "^9.0.11",
     "prettier": "^3.3.2",
     "prettier-eslint": "^16.3.0",
-    "prettier-plugin-packagejson": "^2.5.0",
+    "prettier-plugin-packagejson": "^3.0.0",
+    "semantic-release": "^25.0.3",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.1.6",
-    "vite-tsconfig-paths": "^4.3.2",
-    "vitest": "^1.6.0"
+    "typescript-eslint": "^8.54.0",
+    "vite-tsconfig-paths": "^6.0.5",
+    "vitest": "^4.0.18"
   }
 }

package/dist/cjs/figures/ArcCurve.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArcCurve = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Point_1 = require("../abstracts/Point");
-const Figure_1 = require("../abstracts/Figure");
-const Ellipse_1 = require("./Ellipse");
-class ArcCurve extends Figure_1.Figure {
-    ellipse;
-    largeArcFlag;
-    phi;
-    rx;
-    ry;
-    sweepFlag;
-    constructor(values) {
-        super(values);
-        const [, rx, ry, phi, largeArcFlag, sweepFlag] = values;
-        this.rx = rx;
-        this.ry = ry;
-        this.phi = phi;
-        this.largeArcFlag = largeArcFlag;
-        this.sweepFlag = sweepFlag;
-        this.adjustRadii();
-        const center = this.computeCenter();
-        this.ellipse = new Ellipse_1.Ellipse([center, rx, ry, phi]);
-    }
-    get boundingBox() {
-        const { P0, P1 } = this;
-        const points = [P0, P1, ...this.criticalPoints];
-        return Figure_1.Figure.computeBoundingBox(points);
-    }
-    get center() {
-        return this.ellipse.center;
-    }
-    get criticalPoints() {
-        const { ellipse } = this;
-        const [minTheta, maxTheta] = this.computeThetaRange();
-        return ellipse.criticalPoints.filter((point) => {
-            const { P0, P1 } = this;
-            if ((point.x === P0.x && point.y === P0.y) || (point.x === P1.x && point.y === P1.y)) {
-                return false;
-            }
-            const theta = ellipse.computeThetaForPoint(point);
-            return +theta >= +minTheta && +theta <= +maxTheta;
-        });
-    }
-    get P0() {
-        return this.points[0];
-    }
-    get P1() {
-        if (this.isRelative) {
-            return this.P0.clone().translate(this.vectors[0]);
-        }
-        return this.points[1];
-    }
-    clone() {
-        const values = this.values.map((value) => (typeof value === 'object' && 'clone' in value ? value.clone() : value));
-        return new ArcCurve(values);
-    }
-    reflect(about) {
-        super.reflect(about);
-        this.sweepFlag.invert();
-        return this;
-    }
-    adjustRadii() {
-        const { rx, ry } = this;
-        const P0_prime = this.computeP0Prime();
-        const { x: x1_prime, y: y1_prime } = P0_prime;
-        const rx_sq = Calculator_1.Calculator.pow(+rx, 2);
-        const ry_sq = Calculator_1.Calculator.pow(+ry, 2);
-        const x1_prime_sq = Calculator_1.Calculator.pow(x1_prime, 2);
-        const y1_prime_sq = Calculator_1.Calculator.pow(y1_prime, 2);
-        const radii_check = x1_prime_sq.div(rx_sq).add(y1_prime_sq.div(ry_sq));
-        if (+radii_check > 1) {
-            rx.replace(+Calculator_1.Calculator.mul(+rx, radii_check.sqrt()));
-            ry.replace(+Calculator_1.Calculator.mul(+ry, radii_check.sqrt()));
-        }
-    }
-    computeCenter() {
-        const { P0, P1, phi } = this;
-        const center_prime = this.computeCenterPrime();
-        const { x: x1, y: y1 } = P0;
-        const { x: x2, y: y2 } = P1;
-        const { x: cx_prime, y: cy_prime } = center_prime;
-        const dx = Calculator_1.Calculator.add(x1, x2).div(2);
-        const dy = Calculator_1.Calculator.add(y1, y2).div(2);
-        const cx = Calculator_1.Calculator.mul(phi.cos, cx_prime).sub(Calculator_1.Calculator.mul(phi.sin, cy_prime)).add(dx);
-        const cy = Calculator_1.Calculator.mul(phi.sin, cx_prime).add(Calculator_1.Calculator.mul(phi.cos, cy_prime)).add(dy);
-        return new Point_1.Point([+cx, +cy]);
-    }
-    computeCenterPrime() {
-        const { largeArcFlag, sweepFlag, rx, ry } = this;
-        const P0_prime = this.computeP0Prime();
-        const { x: x1_prime, y: y1_prime } = P0_prime;
-        const rx_sq = Calculator_1.Calculator.pow(+rx, 2);
-        const ry_sq = Calculator_1.Calculator.pow(+ry, 2);
-        const x1_prime_sq = Calculator_1.Calculator.pow(x1_prime, 2);
-        const y1_prime_sq = Calculator_1.Calculator.pow(y1_prime, 2);
-        const sign = new Calculator_1.Calculator(+largeArcFlag === +sweepFlag ? -1 : 1);
-        let sq = rx_sq
-            .mul(ry_sq)
-            .sub(rx_sq.mul(y1_prime_sq))
-            .sub(ry_sq.mul(x1_prime_sq))
-            .div(rx_sq.mul(y1_prime_sq).add(ry_sq.mul(x1_prime_sq)));
-        sq = +sq < 0 ? new Calculator_1.Calculator(0) : sq;
-        const coef = sign.mul(sq.sqrt());
-        const cx_prime = coef.mul(Calculator_1.Calculator.mul(+rx, y1_prime).div(+ry));
-        const cy_prime = coef.mul(Calculator_1.Calculator.mul(+ry, x1_prime).div(+rx).neg());
-        return new Point_1.Point([+cx_prime, +cy_prime]);
-    }
-    computeP0Prime() {
-        const { P0, P1, phi } = this;
-        const { x: x1, y: y1 } = P0;
-        const { x: x2, y: y2 } = P1;
-        const mx = Calculator_1.Calculator.sub(x1, x2).div(2);
-        const my = Calculator_1.Calculator.sub(y1, y2).div(2);
-        const x1_prime = Calculator_1.Calculator.mul(phi.cos, mx).add(Calculator_1.Calculator.mul(phi.sin, my));
-        const y1_prime = Calculator_1.Calculator.mul(phi.sin, mx).neg().add(Calculator_1.Calculator.mul(phi.cos, my));
-        return new Point_1.Point([+x1_prime, +y1_prime]);
-    }
-    computeThetaRange() {
-        const { P0, P1, ellipse, sweepFlag } = this;
-        const theta1 = ellipse.computeThetaForPoint(P0);
-        const theta2 = ellipse.computeThetaForPoint(P1);
-        if (+theta2 === 0 && !sweepFlag.value) {
-            theta2.replace(360, 'degrees');
-        }
-        const thetaRange = [theta1, theta2].sort((a, b) => +Calculator_1.Calculator.sub(a.radians, b.radians));
-        return thetaRange;
-    }
-}
-exports.ArcCurve = ArcCurve;

package/dist/cjs/figures/Ellipse.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ellipse = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Angle_1 = require("../abstracts/Angle");
-const Point_1 = require("../abstracts/Point");
-const Figure_1 = require("../abstracts/Figure");
-const utilities_1 = require("../utilities");
-class Ellipse extends Figure_1.Figure {
-    _center;
-    _criticalPoints;
-    _phi;
-    _rx;
-    _ry;
-    constructor(values) {
-        super(values);
-        const [center, rx, ry, phi] = values;
-        this._center = center;
-        this._rx = rx;
-        this._ry = ry;
-        this._phi = phi;
-        this._criticalPoints = this.computeCriticalPoints({ center, rx, ry, phi });
-    }
-    get boundingBox() {
-        return Figure_1.Figure.computeBoundingBox(this.criticalPoints);
-    }
-    get center() {
-        return this._center;
-    }
-    get criticalPoints() {
-        return this._criticalPoints;
-    }
-    get isCircle() {
-        return +this.rx === +this.ry;
-    }
-    get phi() {
-        return this._phi;
-    }
-    get rx() {
-        return this._rx;
-    }
-    get ry() {
-        return this._ry;
-    }
-    clone() {
-        const values = this.values.map((value) => value.clone());
-        return new Ellipse(values);
-    }
-    computePointForTheta(theta, ellipse = this) {
-        const { center, rx, ry, phi } = ellipse;
-        const x = +Calculator_1.Calculator.mul(+rx, phi.cos).mul(theta.cos).sub(Calculator_1.Calculator.mul(+ry, phi.sin).mul(theta.sin)).add(center.x);
-        const y = +Calculator_1.Calculator.mul(+rx, phi.sin).mul(theta.cos).add(Calculator_1.Calculator.mul(+ry, phi.cos).mul(theta.sin)).add(center.y);
-        return new Point_1.Point([x, y]);
-    }
-    computeThetaForPoint({ x, y }) {
-        const { center, phi, rx, ry } = this;
-        const { x: cx, y: cy } = center;
-        const dy = Calculator_1.Calculator.sub(y, cy);
-        const dx = Calculator_1.Calculator.sub(x, cx);
-        const sinTheta = dy.mul(phi.cos).sub(dx.mul(phi.sin)).div(+ry);
-        const cosTheta = dx.mul(phi.cos).add(dy.mul(phi.sin)).div(+rx);
-        const theta = new Angle_1.Angle(+Calculator_1.Calculator.atan2(sinTheta, cosTheta), 'radians').normalize();
-        return theta;
-    }
-    reflect(about) {
-        super.reflect(about);
-        if (!this.isCircle && 'V' in about) {
-            const alpha = about.angleTo(utilities_1.xAxis);
-            this._phi.replace(+Calculator_1.Calculator.mul(2, alpha.radians).sub(this.phi.radians), 'radians');
-            this._phi.normalize();
-        }
-        this.recompute();
-        return this;
-    }
-    rotate(alpha, about) {
-        this._center.rotate(alpha, about);
-        if (!this.isCircle) {
-            this._phi.replace(+Calculator_1.Calculator.add(this.phi.radians, alpha.radians), 'radians');
-            this._phi.normalize();
-        }
-        this.recompute();
-        return this;
-    }
-    scale(factor, about = new Point_1.Point([0, 0])) {
-        super.scale(factor, about);
-        this.recompute();
-        return this;
-    }
-    translate(vector) {
-        this._center.translate(vector);
-        this.recompute();
-        return this;
-    }
-    computeCriticalPoints(ellipse = this) {
-        const { rx, ry, phi } = ellipse;
-        const { computePointForTheta } = this;
-        const xThetaPrincipal = new Angle_1.Angle(+Calculator_1.Calculator.neg(+ry).mul(phi.tan).div(+rx).atan(), 'radians');
-        const yThetaPrincipal = new Angle_1.Angle(+Calculator_1.Calculator.mul(+ry, phi.cot).div(+rx).atan(), 'radians');
-        const xThetaSecondary = new Angle_1.Angle(+Calculator_1.Calculator.add(+xThetaPrincipal, Math.PI), 'radians');
-        const yThetaSecondary = new Angle_1.Angle(+Calculator_1.Calculator.add(+yThetaPrincipal, Math.PI), 'radians');
-        const firstPoint = computePointForTheta(xThetaPrincipal, ellipse);
-        const secondPoint = computePointForTheta(yThetaPrincipal, ellipse);
-        const thirdPoint = computePointForTheta(xThetaSecondary, ellipse);
-        const fourthPoint = computePointForTheta(yThetaSecondary, ellipse);
-        return [firstPoint, secondPoint, thirdPoint, fourthPoint];
-    }
-    recompute() {
-        this._criticalPoints = this.computeCriticalPoints();
-    }
-}
-exports.Ellipse = Ellipse;

package/dist/cjs/figures/Polygon.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Polygon = void 0;
-const Figure_1 = require("../abstracts/Figure");
-class Polygon extends Figure_1.Figure {
-    constructor(values) {
-        super(values);
-    }
-    get sides() {
-        return this.points.length;
-    }
-    clone() {
-        const values = this.values.map((value) => value.clone());
-        return new Polygon(values);
-    }
-}
-exports.Polygon = Polygon;

package/dist/esm/figures/Polygon.js

@@ -1,13 +0,0 @@
-import { Figure } from '../abstracts/Figure';
-export class Polygon extends Figure {
-    constructor(values) {
-        super(values);
-    }
-    get sides() {
-        return this.points.length;
-    }
-    clone() {
-        const values = this.values.map((value) => value.clone());
-        return new Polygon(values);
-    }
-}

package/dist/types/figures/Polygon.d.ts

@@ -1,7 +0,0 @@
-import { IPolygon, TPolygonValues } from '../types';
-import { Figure } from '../abstracts/Figure';
-export declare class Polygon extends Figure implements IPolygon {
-    constructor(values: TPolygonValues);
-    get sides(): number;
-    clone(): Polygon;
-}