@vorplex/core 0.0.4 → 0.0.9

package/dist/modules/math/polygon.js

@@ -0,0 +1,273 @@
+import { $Value } from '../value/value.util';
+import { Line } from './line';
+import { $Point } from './point';
+export class Polygon {
+    vertices;
+    constructor(vertices) {
+        this.vertices = vertices;
+    }
+    static getEdge(polygon, index) {
+        if (index < 0)
+            index += polygon.vertices.length;
+        return {
+            start: polygon.vertices[index],
+            end: polygon.vertices[index + 1] ?? polygon.vertices[0],
+        };
+    }
+    getEdge(index) {
+        return Polygon.getEdge(this, index);
+    }
+    static getEdges(polygon) {
+        return polygon.vertices.map((vertex, index) => ({
+            start: vertex,
+            end: polygon.vertices[index === polygon.vertices.length - 1 ? 0 : index + 1],
+        }));
+    }
+    getEdges() {
+        return Polygon.getEdges(this);
+    }
+    static containsPoint(polygon, point) {
+        const { x, y } = point;
+        let inside = false;
+        for (let i = 0, j = polygon.vertices.length - 1; i < polygon.vertices.length; j = i++) {
+            const xi = polygon.vertices[i].x, yi = polygon.vertices[i].y;
+            const xj = polygon.vertices[j].x, yj = polygon.vertices[j].y;
+            const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+            if (intersect)
+                inside = !inside;
+        }
+        return inside;
+    }
+    containsPoint(point) {
+        return Polygon.containsPoint(this, point);
+    }
+    static move(polygon, position) {
+        const vertices = polygon.vertices.map((vertex) => $Point.plus(vertex, position));
+        return new Polygon(vertices);
+    }
+    move(position) {
+        return Polygon.move(this, position);
+    }
+    static getIntersections(a, b, unique) {
+        const intersections = {
+            intersections: [],
+            edges: {},
+            points: {},
+        };
+        for (let vertexIndexA = 0; vertexIndexA < a.vertices.length; vertexIndexA++) {
+            const edgeA = a.getEdge(vertexIndexA);
+            const startWithinB = b.containsPoint(edgeA.start);
+            const endWithinB = b.containsPoint(edgeA.end);
+            if (!startWithinB || !endWithinB) {
+                for (let vertexIndexB = 0; vertexIndexB < b.vertices.length; vertexIndexB++) {
+                    const edgeB = b.getEdge(vertexIndexB);
+                    const intersectionPoint = Line.getIntersect(edgeA, edgeB);
+                    if (intersectionPoint) {
+                        if (unique && intersections.points[intersectionPoint.toString()])
+                            continue;
+                        const intersection = {
+                            polygonA: a,
+                            polygonB: b,
+                            edgeA,
+                            edgeB,
+                            edgeIndexA: vertexIndexA,
+                            edgeIndexB: vertexIndexB,
+                            point: intersectionPoint,
+                        };
+                        intersections.intersections.push(intersection);
+                        intersections.edges[edgeA.toString()] = (intersections.edges[edgeA.toString()] ?? []).concat(intersection);
+                        intersections.edges[edgeB.toString()] = (intersections.edges[edgeB.toString()] ?? []).concat(intersection);
+                        intersections.points[intersectionPoint.toString()] = intersection;
+                    }
+                }
+            }
+        }
+        return intersections;
+    }
+    getIntersections(polygon, unique) {
+        return Polygon.getIntersections(this, polygon, unique);
+    }
+    static getLineIntersections(polygon, line) {
+        const intersections = [];
+        for (let vertexIndex = 0; vertexIndex < polygon.vertices.length; vertexIndex++) {
+            const edge = Polygon.getEdge(polygon, vertexIndex);
+            const point = Line.getIntersect(edge, line);
+            if (point)
+                intersections.push({ edgeIndex: vertexIndex, edge, point });
+        }
+        return intersections;
+    }
+    getLineIntersections(polygon, line) {
+        return Polygon.getLineIntersections(polygon, line);
+    }
+    static subtract(a, b) {
+        const polygons = [];
+        const intersections = Polygon.getIntersections(a, b, true);
+        const visitedIntersections = {};
+        const trailA = (vertex, vertices = []) => {
+            if (typeof vertex === 'number' && vertex < 0)
+                vertex = a.vertices.length - 1;
+            if (vertex == null) {
+                if (Polygon.containsPoint(b, a.vertices[0])) {
+                    return trailA(0, vertices);
+                }
+                else {
+                    vertices.push(a.vertices[0]);
+                    vertices.push(...trailA(0, vertices));
+                }
+            }
+            else {
+                const edgeIndex = typeof vertex === 'object' ? vertex.edgeIndexA : vertex;
+                const edge = Polygon.getEdge(a, edgeIndex);
+                if (typeof vertex === 'object') {
+                    if ($Point.equals(vertex.point, edge.start)) {
+                        visitedIntersections[$Point.toString(vertex.point)] = intersections.points[$Point.toString(vertex.point)];
+                        return vertices;
+                    }
+                    const directionalLine = {
+                        start: vertex.point,
+                        end: edge.end,
+                    };
+                    const intersection = intersections.edges[edge.toString()]
+                        ?.filter((intersection) => intersection.point !== vertex.point && Line.contains(directionalLine, intersection.point))
+                        .sort((a, b) => $Point.distance(edge.start, a.point) - $Point.distance(edge.start, b.point))[0];
+                    if (intersection) {
+                        visitedIntersections[$Point.toString(intersection.point)] = intersection;
+                        vertices.push(intersection.point);
+                        vertices.push(...trailB(intersection, vertices));
+                    }
+                    else {
+                        if ($Point.equals(vertices[0], edge.end))
+                            return vertices;
+                        vertices.push(edge.end);
+                        vertices.push(...trailA(vertex.edgeIndexA + 1, vertices));
+                    }
+                }
+                else {
+                    const intersection = (vertices.length ? intersections.edges[edge.toString()] : intersections.edges[edge.toString()]?.filter((intersection) => !$Point.equals(intersection.point, edge.start)))?.sort((a, b) => $Point.distance(edge.start, a.point) - $Point.distance(edge.start, b.point))[0];
+                    if (intersection) {
+                        if (!$Point.equals(intersection.edgeB.start, intersection.point) && !$Point.equals(intersection.edgeB.end, intersection.point))
+                            visitedIntersections[$Point.toString(intersection.point)] = intersection;
+                        if ($Point.equals(vertices[0], intersection.point))
+                            return vertices;
+                        vertices.push(intersection.point);
+                        if (vertices.length > 1) {
+                            vertices.push(...trailB(intersection, vertices));
+                        }
+                        else {
+                            vertices.push(...trailA(intersection, vertices));
+                        }
+                    }
+                    else if (Polygon.containsPoint(b, edge.end)) {
+                        return trailA(vertex + 1, vertices);
+                    }
+                    else {
+                        if ($Point.equals(vertices[0], edge.end))
+                            return vertices;
+                        vertices.push(edge.end);
+                        return trailA(vertex + 1, vertices);
+                    }
+                }
+            }
+            return vertices;
+        };
+        const trailB = (vertex, vertices = [], trailDirectionFactor) => {
+            if (typeof vertex === 'number' && vertex < 0)
+                vertex = b.vertices.length - 1;
+            const edgeIndex = typeof vertex === 'object' ? vertex.edgeIndexB : vertex;
+            const edge = b.getEdge(edgeIndex);
+            if (typeof vertex === 'object') {
+                let directionFactor;
+                if (Polygon.containsPoint(a, edge.start)) {
+                    directionFactor = -1;
+                }
+                else if (Polygon.containsPoint(a, edge.end)) {
+                    directionFactor = 1;
+                }
+                else {
+                    const intersection = intersections.edges[edge.toString()]
+                        ?.filter((intersection) => intersection.point !== vertex.point &&
+                        Polygon.containsPoint(a, Line.getMiddle({
+                            start: vertex.point,
+                            end: intersection.point,
+                        })))
+                        .sort((a, b) => $Point.distance(edge.start, a.point) - $Point.distance(edge.start, b.point))[0];
+                    visitedIntersections[$Point.toString(intersection.point)] = intersection;
+                    if ($Point.equals(vertices[0], intersection.point))
+                        return vertices;
+                    vertices.push(intersection.point);
+                    vertices.push(...trailA(intersection, vertices));
+                    return vertices;
+                }
+                const targetVertex = directionFactor === 1 ? edge.end : edge.start;
+                const directionalLine = {
+                    start: vertex.point,
+                    end: targetVertex,
+                };
+                const intersection = intersections.edges[edge.toString()]
+                    ?.filter((intersection) => intersection.point !== vertex.point && Line.contains(directionalLine, intersection.point))
+                    .sort((a, b) => $Point.distance(trailDirectionFactor === 1 ? edge.end : edge.start, a.point) - $Point.distance(trailDirectionFactor === 1 ? edge.end : edge.start, b.point))[0];
+                if (intersection) {
+                    visitedIntersections[$Point.toString(intersection.point)] = intersection;
+                    if ($Point.equals(vertices[0], intersection.point))
+                        return vertices;
+                    vertices.push(intersection.point);
+                    vertices.push(...trailA(intersection, vertices));
+                }
+                else {
+                    if ($Point.equals(vertices[0], targetVertex))
+                        return vertices;
+                    vertices.push(targetVertex);
+                    vertices.push(...trailB(vertex.edgeIndexB + directionFactor, vertices, directionFactor));
+                }
+            }
+            else {
+                const intersection = intersections.edges[edge.toString()]?.sort((a, b) => $Point.distance(trailDirectionFactor === 1 ? edge.end : edge.start, a.point) - $Point.distance(trailDirectionFactor === 1 ? edge.end : edge.start, b.point))[0];
+                if (intersection) {
+                    visitedIntersections[$Point.toString(intersection.point)] = intersection;
+                    if ($Point.equals(vertices[0], intersection.point))
+                        return vertices;
+                    vertices.push(intersection.point);
+                    vertices.push(...trailA(intersection, vertices));
+                }
+                else if (Polygon.containsPoint(a, trailDirectionFactor === 1 ? edge.end : edge.start)) {
+                    if ($Point.equals(vertices[0], trailDirectionFactor === 1 ? edge.end : edge.start))
+                        return vertices;
+                    vertices.push(trailDirectionFactor === 1 ? edge.end : edge.start);
+                    return trailB(vertex + trailDirectionFactor, vertices, trailDirectionFactor);
+                }
+                else {
+                    if ($Point.equals(vertices[0], trailDirectionFactor === 1 ? edge.start : edge.end))
+                        return vertices;
+                    vertices.push(trailDirectionFactor === 1 ? edge.end : edge.start);
+                    return trailB(vertex + trailDirectionFactor, vertices, trailDirectionFactor);
+                }
+            }
+            return vertices;
+        };
+        console.group('Start');
+        while (Object.keys(visitedIntersections).length !== intersections.intersections.length) {
+            let vertices;
+            if (Object.keys(visitedIntersections).length === 0)
+                vertices = trailA();
+            else {
+                const intersection = intersections.intersections.find((intersection) => !visitedIntersections[$Point.toString(intersection.point)]);
+                console.log({
+                    intersection,
+                    visitedIntersections: $Value.clone(visitedIntersections),
+                    intersections,
+                    visitedIntersectionsCount: Object.keys(visitedIntersections).length,
+                    intersectionsCount: intersections.intersections.length,
+                });
+                vertices = trailA(intersection, [intersection.point]);
+                visitedIntersections[$Point.toString(intersection.point)] = intersection;
+            }
+            polygons.push(new Polygon(vertices));
+        }
+        console.groupEnd();
+        return polygons;
+    }
+    subtract(polygon) {
+        return Polygon.subtract(this, polygon);
+    }
+}

package/dist/modules/math/rect.d.ts

@@ -0,0 +1,6 @@
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/dist/modules/math/size.d.ts

@@ -0,0 +1,4 @@
+export interface Size {
+    width: number;
+    height: number;
+}

package/dist/modules/number/number.util.d.ts

@@ -0,0 +1,9 @@
+import type { Unit } from '../../consts/unit.const';
+export declare class $Number {
+    static snap(number: number, value?: number): number;
+    static toUnitString(number: number, units: Record<string, number> | typeof Unit): string;
+    static round(number: number, decimals?: number): number;
+    static min(value: number, min: number): number;
+    static max(value: number, max: number): number;
+    static clamp(number: number, min: number, max: number): number;
+}

package/dist/modules/number/number.util.js

@@ -0,0 +1,27 @@
+export class $Number {
+    static snap(number, value) {
+        return Math.floor(number / value) * value;
+    }
+    static toUnitString(number, units) {
+        const sortedUnits = Object.entries(units).sort(([, a], [, b]) => b - a);
+        for (const [unitName, unitValue] of sortedUnits) {
+            const converted = number / unitValue;
+            if (converted >= 1 || unitValue === sortedUnits[sortedUnits.length - 1][1]) {
+                const formatted = Number(converted.toFixed(2));
+                return `${formatted} ${unitName}`;
+            }
+        }
+    }
+    static round(number, decimals) {
+        return Math.round(number * 10 ** decimals) / 10 ** decimals;
+    }
+    static min(value, min) {
+        return Math.max(value, min);
+    }
+    static max(value, max) {
+        return Math.min(value, max);
+    }
+    static clamp(number, min, max) {
+        return Math.min(max, Math.max(min, number));
+    }
+}

package/dist/modules/object/object.util.d.ts

@@ -0,0 +1,7 @@
+export declare class $Object {
+    static hasKeys<T = any>(value: any, ...keys: Extract<keyof T, string>[]): boolean;
+    static freeze(value: any): void;
+    static getDefaults<T extends object>(object: T, defaults?: Partial<T>): T;
+    static getPaths(value: any): string[];
+    static isEmptyObject(value: any): boolean;
+}

package/dist/modules/object/object.util.js

@@ -0,0 +1,63 @@
+export class $Object {
+    static hasKeys(value, ...keys) {
+        return value != null && typeof value === 'object' && keys.every((key) => key in value);
+    }
+    static freeze(value) {
+        if ((value !== null && typeof value === 'object') || typeof value === 'function') {
+            Object.freeze(value);
+            for (const key in value) {
+                $Object.freeze(value[key]);
+            }
+        }
+    }
+    static getDefaults(object, defaults = {}) {
+        const result = { ...object };
+        for (const key in defaults) {
+            if (result[key] == null) {
+                result[key] = defaults[key];
+            }
+        }
+        return result;
+    }
+    static getPaths(value) {
+        const paths = [];
+        function addPath(path) {
+            if (path.length)
+                paths.push(path.join('.'));
+        }
+        function traverse(value, path) {
+            if (value == null || typeof value !== 'object') {
+                addPath(path);
+            }
+            else if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    addPath(path);
+                }
+                else {
+                    for (let i = 0; i < value.length; i++) {
+                        traverse(value[i], [...path, String(i)]);
+                    }
+                }
+            }
+            else {
+                const keys = Object.keys(value);
+                if (keys.length === 0) {
+                    addPath(path);
+                }
+                else {
+                    for (const key of keys) {
+                        traverse(value[key], [...path, key]);
+                    }
+                }
+            }
+        }
+        traverse(value, []);
+        return paths;
+    }
+    static isEmptyObject(value) {
+        return typeof value === 'object'
+            && value !== null
+            && !Array.isArray(value)
+            && Object.keys(value).length === 0;
+    }
+}

package/dist/modules/path/path.util.d.ts

@@ -0,0 +1,11 @@
+export declare class $Path {
+    static isAbsolute(path: string): boolean;
+    static relative(path: string): string;
+    static absolute(path: string): string;
+    static join(...paths: string[]): string;
+    static getDirectory(path: string): string;
+    static entryName(path: string): string;
+    static fileName(path: string): string | null;
+    static getExtension(path: string): string | null;
+    static setExtension(path: string, extension: string): string;
+}

package/dist/modules/path/path.util.js

@@ -0,0 +1,59 @@
+export class $Path {
+    static isAbsolute(path) {
+        return path.startsWith('/') || path.startsWith('\\');
+    }
+    static relative(path) {
+        return `./${$Path.absolute(path)}`;
+    }
+    static absolute(path) {
+        return $Path.join(path);
+    }
+    static join(...paths) {
+        const separator = '/';
+        const path = paths.join(separator);
+        const protocol = path.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/\/?)/)?.[1] ?? '';
+        return (protocol +
+            path
+                .substring(protocol.length)
+                .split(/[/\\]+/)
+                .reduce((stack, segment) => {
+                if (segment === '' || segment === '.')
+                    return stack;
+                if (segment === '..')
+                    stack.pop();
+                else
+                    stack.push(segment);
+                return stack;
+            }, [])
+                .join(separator));
+    }
+    static getDirectory(path) {
+        const index = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
+        if (index > -1)
+            return path.substring(0, index);
+        return path;
+    }
+    static entryName(path) {
+        const index = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
+        return path.substring(index + 1);
+    }
+    static fileName(path) {
+        const name = $Path.entryName(path);
+        return name.includes('.') ? name : null;
+    }
+    static getExtension(path) {
+        const indexes = {
+            slash: Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\')),
+            dot: path.lastIndexOf('.'),
+        };
+        return indexes.dot > -1 && indexes.dot > indexes.slash ? path.substring(indexes.dot).toLowerCase() : null;
+    }
+    static setExtension(path, extension) {
+        extension = extension.startsWith('.') ? extension : '.' + extension;
+        const indexes = {
+            slash: Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\')),
+            dot: path.lastIndexOf('.'),
+        };
+        return indexes.dot > indexes.slash ? path.slice(0, indexes.dot) + extension : path + extension;
+    }
+}

package/dist/modules/random/random.util.d.ts

@@ -0,0 +1,17 @@
+export declare class $Random {
+    /**
+     * Returns a random number inclusive to the `min` and `max` number.
+     * @param min The minimum value the random number can be.
+     * @param max The maximum value the random number can be.
+     * @returns A random number inclusive to the `min` and `max` number.
+     */
+    static random(min: number, max: number): number;
+    static convertSeedToNumber(seed: string): number;
+    static generateSeed(length: number): string;
+    static seededRandom(seed: string, offset?: number): number;
+    static normalizeWeights(items: Record<string, number>): Record<string, number>;
+    static getItem(items: Record<string, number>, options?: {
+        seed?: string;
+        seedOffset?: number;
+    }): string;
+}

package/dist/modules/random/random.util.js

@@ -0,0 +1,57 @@
+export class $Random {
+    /**
+     * Returns a random number inclusive to the `min` and `max` number.
+     * @param min The minimum value the random number can be.
+     * @param max The maximum value the random number can be.
+     * @returns A random number inclusive to the `min` and `max` number.
+     */
+    static random(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    static convertSeedToNumber(seed) {
+        let number = 0;
+        for (let i = 0; i < seed.length; i++) {
+            number = (number * 31 + seed.charCodeAt(i)) % 100000;
+        }
+        return number;
+    }
+    static generateSeed(length) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let seed = '';
+        for (let i = 0; i < length; i++) {
+            const randomIndex = Math.floor(Math.random() * chars.length);
+            seed += chars[randomIndex];
+        }
+        return seed;
+    }
+    static seededRandom(seed, offset = 0) {
+        const number = $Random.convertSeedToNumber(seed + offset);
+        const x = Math.sin(number) * 10000;
+        return x - Math.floor(x);
+    }
+    static normalizeWeights(items) {
+        const result = {};
+        const total = Object.values(items).reduce((sum, weight) => sum + weight, 0);
+        for (const item in items) {
+            result[item] = items[item] / total;
+        }
+        return result;
+    }
+    static getItem(items, options) {
+        const random = $Random.seededRandom(options?.seed ?? $Random.generateSeed(10), options?.seedOffset ?? 0);
+        const normalizedItems = $Random.normalizeWeights(items);
+        const keys = Object.keys(normalizedItems);
+        const weights = Object.values(normalizedItems);
+        const cumulativeWeights = [];
+        let cumulativeSum = 0;
+        for (let i = 0; i < weights.length; i++) {
+            cumulativeSum += weights[i];
+            cumulativeWeights.push(cumulativeSum);
+        }
+        for (let i = 0; i < cumulativeWeights.length; i++) {
+            if (random <= cumulativeWeights[i]) {
+                return keys[i];
+            }
+        }
+    }
+}

package/dist/modules/readable-stream/readable-stream.util.d.ts

@@ -0,0 +1,3 @@
+export declare class $ReadableStream {
+    static toArrayBuffer(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
+}

package/dist/modules/readable-stream/readable-stream.util.js

@@ -0,0 +1,26 @@
+export class $ReadableStream {
+    static async toArrayBuffer(stream) {
+        const chunks = [];
+        const reader = stream.getReader();
+        let totalLength = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                chunks.push(value);
+                totalLength += value.length;
+            }
+            const result = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const chunk of chunks) {
+                result.set(chunk, offset);
+                offset += chunk.length;
+            }
+            return result.buffer;
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/modules/reflection/interfaces/parameter.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Parameter {
+    index: number;
+    name: string;
+}

package/dist/modules/reflection/models/attribute.model.d.ts

@@ -0,0 +1,12 @@
+export declare abstract class Attribute<T = any> {
+    data?: T;
+    /** The key used to store the metadata. */
+    readonly key: string;
+    /** The prototype which the attribute is applied to. */
+    prototype: object;
+    constructor(prototype: object, data?: T);
+    /** Executed when the attribute is applied. */
+    onAttributeInit(): void;
+    /** Executed when the attribute is removed. */
+    onAttributeDestroy(): void;
+}

package/dist/modules/reflection/models/attribute.model.js

@@ -0,0 +1,17 @@
+import { $Id } from '../../id/id.util';
+export class Attribute {
+    data;
+    /** The key used to store the metadata. */
+    key;
+    /** The prototype which the attribute is applied to. */
+    prototype;
+    constructor(prototype, data) {
+        this.prototype = prototype;
+        this.key = $Id.uuid();
+        this.data = data;
+    }
+    /** Executed when the attribute is applied. */
+    onAttributeInit() { }
+    /** Executed when the attribute is removed. */
+    onAttributeDestroy() { }
+}

package/dist/modules/reflection/models/class-attribute.model.d.ts

@@ -0,0 +1,4 @@
+import { Attribute } from './attribute.model';
+export declare abstract class ClassAttribute<T = any> extends Attribute<T> {
+    constructor(constructor: Function, data?: T);
+}

package/dist/modules/reflection/models/class-attribute.model.js

@@ -0,0 +1,6 @@
+import { Attribute } from './attribute.model';
+export class ClassAttribute extends Attribute {
+    constructor(constructor, data) {
+        super(constructor.prototype, data);
+    }
+}

package/dist/modules/reflection/models/method-attribute.model.d.ts

@@ -0,0 +1,5 @@
+import { Attribute } from './attribute.model';
+export declare abstract class MethodAttribute<T = any> extends Attribute<T> {
+    method: string;
+    constructor(prototype: object, method: string, data?: T);
+}

package/dist/modules/reflection/models/method-attribute.model.js

@@ -0,0 +1,8 @@
+import { Attribute } from './attribute.model';
+export class MethodAttribute extends Attribute {
+    method;
+    constructor(prototype, method, data) {
+        super(prototype, data);
+        this.method = method;
+    }
+}

package/dist/modules/reflection/models/parameter-attribute.model.d.ts

@@ -0,0 +1,7 @@
+import { Attribute } from './attribute.model';
+export declare abstract class ParameterAttribute<T = any> extends Attribute<T> {
+    method: string;
+    name: string;
+    index: number;
+    constructor(prototype: object, method: string, index: number, data?: T);
+}