@vorplex/core 0.0.8 → 0.0.9

package/dist/modules/json-filter/json-filter.function.js

@@ -0,0 +1,75 @@
+import { $Object } from '../object/object.util';
+import { $Reflection } from '../reflection/utils/reflection.util';
+export const JsonFilters = {
+    query: (selector, operator) => (value) => operator(selector(value)),
+    and: (...operators) => (value) => operators.every((arg) => arg(value)),
+    or: (...operators) => (value) => operators.some((arg) => arg(value)),
+    not: (operator) => (value) => !operator(value),
+    equals: (arg) => (value) => value === arg || String(value).toLowerCase() === String(arg).toLowerCase(),
+    length: (arg) => (value) => (Array.isArray(value) ? value.length === arg : typeof value === 'object' ? Object.keys(value).length === arg : String(value).length === arg),
+    contains: (arg) => (value) => value === arg || String(value).toLowerCase().includes(String(arg).toLowerCase()),
+    starts: (arg) => (value) => value === arg || String(value).toLowerCase().startsWith(String(arg).toLowerCase()),
+    ends: (arg) => (value) => value === arg || String(value).toLowerCase().endsWith(String(arg).toLowerCase()),
+    greater: (arg) => (value) => {
+        switch ($Reflection.getSimpleTypeName(value)) {
+            case 'array':
+                return value.length > Number(arg);
+            case 'string':
+                return String(value).length > Number(arg);
+            case 'number':
+                return Number(value) > Number(arg);
+            case 'date':
+                return new Date(value) > new Date(arg);
+        }
+    },
+    less: (arg) => (value) => {
+        switch ($Reflection.getSimpleTypeName(value)) {
+            case 'array':
+                return value.length < Number(arg);
+            case 'string':
+                return String(value).length < Number(arg);
+            case 'number':
+                return Number(value) < Number(arg);
+            case 'date':
+                return new Date(value) < new Date(arg);
+        }
+    },
+};
+export const JsonFilterOperators = {
+    and: (arg, options) => JsonFilters.and(...arg.map((arg) => jsonFilter(arg, { ...options, operator: 'and' }))),
+    or: (arg, options) => JsonFilters.or(...arg.map((arg) => jsonFilter(arg, { ...options, operator: 'or' }))),
+    not: (arg, options) => JsonFilters.not(jsonFilter(arg, options)),
+    equals: JsonFilters.equals,
+    contains: JsonFilters.contains,
+    starts: JsonFilters.starts,
+    ends: JsonFilters.ends,
+    greater: JsonFilters.greater,
+    less: JsonFilters.less,
+};
+export const DefaultJsonFilterOptions = {
+    operatorPrefix: '$',
+    operator: 'and',
+    operators: JsonFilterOperators,
+};
+export function jsonFilter(query, options = {}) {
+    options = $Object.getDefaults(options, DefaultJsonFilterOptions);
+    const filters = [];
+    for (const property in query) {
+        const value = query[property];
+        let filter;
+        if (property.startsWith(options.operatorPrefix)) {
+            const operator = options.operators[property.substring(1)];
+            if (operator) {
+                filter = operator(value, options);
+            }
+            else {
+                throw new Error(`Unknown operator '${property.substring(1)}'`);
+            }
+        }
+        else {
+            filter = JsonFilters.query((item) => item[property], jsonFilter(value, options));
+        }
+        filters.push(filter);
+    }
+    return options.operator === 'and' ? JsonFilters.and(...filters) : JsonFilters.or(...filters);
+}

package/dist/modules/logging/console-logger.model.d.ts

@@ -0,0 +1,36 @@
+import { Logger } from './logger.model';
+export declare class Chalk {
+    static readonly Reset: "\u001B[0m";
+    static readonly Normal: "\u001B[22m";
+    static readonly Bright: "\u001B[1m";
+    static readonly Dim: "\u001B[2m";
+    static readonly Underscore: "\u001B[4m";
+    static readonly Blink: "\u001B[5m";
+    static readonly Reverse: "\u001B[7m";
+    static readonly Hidden: "\u001B[8m";
+    static readonly Black: "\u001B[30m";
+    static readonly Red: "\u001B[31m";
+    static readonly Green: "\u001B[32m";
+    static readonly Yellow: "\u001B[33m";
+    static readonly Orange: "\u001B[38;5;172m";
+    static readonly Blue: "\u001B[34m";
+    static readonly Magenta: "\u001B[35m";
+    static readonly Cyan: "\u001B[36m";
+    static readonly White: "\u001B[37m";
+    static readonly DarkGray: "\u001B[38;5;244m";
+    static readonly Gray: "\u001B[38;5;247m";
+    static readonly BlackBackground: "\u001B[40m";
+    static readonly RedBackground: "\u001B[41m";
+    static readonly GreenBackground: "\u001B[42m";
+    static readonly YellowBackground: "\u001B[43m";
+    static readonly BlueBackground: "\u001B[44m";
+    static readonly MagentaBackground: "\u001B[45m";
+    static readonly CyanBackground: "\u001B[46m";
+    static readonly WhiteBackground: "\u001B[47m";
+    static hue(hue: number): string;
+}
+export declare class ConsoleLogger extends Logger {
+    log(...message: string[]): void;
+    warn(...message: string[]): void;
+    error(error: string | Error): void;
+}

package/dist/modules/logging/console-logger.model.js

@@ -0,0 +1,44 @@
+import { Logger } from './logger.model';
+export class Chalk {
+    static Reset = '\u001b[0m';
+    static Normal = '\u001b[22m';
+    static Bright = '\u001b[1m';
+    static Dim = '\u001b[2m';
+    static Underscore = '\u001b[4m';
+    static Blink = '\u001b[5m';
+    static Reverse = '\u001b[7m';
+    static Hidden = '\u001b[8m';
+    static Black = '\u001b[30m';
+    static Red = '\u001b[31m';
+    static Green = '\u001b[32m';
+    static Yellow = '\u001b[33m';
+    static Orange = '\u001b[38;5;172m';
+    static Blue = '\u001b[34m';
+    static Magenta = '\u001b[35m';
+    static Cyan = '\u001b[36m';
+    static White = '\u001b[37m';
+    static DarkGray = '\u001b[38;5;244m';
+    static Gray = '\u001b[38;5;247m';
+    static BlackBackground = '\u001b[40m';
+    static RedBackground = '\u001b[41m';
+    static GreenBackground = '\u001b[42m';
+    static YellowBackground = '\u001b[43m';
+    static BlueBackground = '\u001b[44m';
+    static MagentaBackground = '\u001b[45m';
+    static CyanBackground = '\u001b[46m';
+    static WhiteBackground = '\u001b[47m';
+    static hue(hue) {
+        return `\u001b[38;5;${hue}m`;
+    }
+}
+export class ConsoleLogger extends Logger {
+    log(...message) {
+        console.log([Chalk.DarkGray, ...message, Chalk.Reset].join(''));
+    }
+    warn(...message) {
+        console.warn([Chalk.Orange, ...message, Chalk.Reset].join(''));
+    }
+    error(error) {
+        console.error([Chalk.Red, error instanceof Error ? error.message : error, Chalk.Reset].join(''));
+    }
+}

package/dist/modules/logging/logger.model.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class Logger {
+    static readonly empty: Logger;
+    abstract log(...message: string[]): void;
+    abstract warn(message: string): void;
+    abstract error(error: string | Error): void;
+}

package/dist/modules/logging/logger.model.js

@@ -0,0 +1,7 @@
+export class Logger {
+    static empty = {
+        log: () => { },
+        warn: () => { },
+        error: () => { },
+    };
+}

package/dist/modules/logging/task.d.ts

@@ -0,0 +1,38 @@
+import { Subscribable } from '../subscribable/subscribable.model';
+export declare const TaskStatus: {
+    readonly Busy: "busy";
+    readonly Failed: "failed";
+    readonly Done: "done";
+};
+export type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];
+export interface Attachment {
+    type: 'json' | 'yaml' | 'text' | 'typescript';
+    value: string;
+}
+export interface Log {
+    timestamp: number;
+    message: string;
+    level: 'info' | 'warning' | 'error';
+    attachments: Record<string, Attachment>;
+}
+export declare class Task extends Subscribable<Task> {
+    startTimestamp: number;
+    finishTimestamp: number;
+    status: TaskStatus;
+    name: string;
+    parent?: Task;
+    tasks: Task[];
+    logs: Log[];
+    constructor(name: string, task?: Task);
+    do<T>(name: string, callback: (task: Task) => Promise<T> | T): Promise<T>;
+    static do<T>(name: string, callback: (task: Task) => Promise<T> | T): Promise<T>;
+    log(message: string, options?: {
+        level?: 'info' | 'warning' | 'error';
+        attachments?: Record<string, Attachment>;
+    }): void;
+    fail(error?: string | Error): void;
+    complete(): void;
+    getStatus(): TaskStatus;
+    hasWarning(): boolean;
+    toConsoleLog(): string;
+}

package/dist/modules/logging/task.js

@@ -0,0 +1,133 @@
+import { Unit } from '../../consts/unit.const';
+import { $Array } from '../array/array.util';
+import { $Date } from '../date/date.util';
+import { $Number } from '../number/number.util';
+import { $String } from '../string/string.util';
+import { Subscribable } from '../subscribable/subscribable.model';
+import { Chalk } from './console-logger.model';
+export const TaskStatus = {
+    Busy: 'busy',
+    Failed: 'failed',
+    Done: 'done',
+};
+export class Task extends Subscribable {
+    startTimestamp = Date.now();
+    finishTimestamp;
+    status = TaskStatus.Busy;
+    name;
+    parent;
+    tasks = [];
+    logs = [];
+    constructor(name, task) {
+        super();
+        this.name = name;
+        this.parent = task;
+        this.subscribe(task => task.parent?.emit(this.parent));
+    }
+    async do(name, callback) {
+        const task = new Task(name, this);
+        this.tasks.push(task);
+        this.emit(this);
+        try {
+            const result = await callback(task);
+            task.complete();
+            return result;
+        }
+        catch (error) {
+            task.fail();
+            throw error;
+        }
+    }
+    static async do(name, callback) {
+        const task = new Task(name);
+        try {
+            return await callback(task);
+        }
+        catch (error) {
+            task.fail(error);
+            throw error;
+        }
+        finally {
+            task.complete();
+        }
+    }
+    log(message, options) {
+        this.logs.push({
+            timestamp: Date.now(),
+            message,
+            level: options?.level ?? 'info',
+            attachments: options?.attachments ?? {}
+        });
+        this.emit(this);
+    }
+    fail(error) {
+        if (this.status !== 'failed') {
+            if (error)
+                this.log(error instanceof Error ? error.stack ?? error.message : error, { level: 'error' });
+            this.status = 'failed';
+            this.finishTimestamp = Date.now();
+            this.emit(this);
+        }
+    }
+    complete() {
+        if (this.status === 'busy') {
+            this.status = 'done';
+            this.finishTimestamp = Date.now();
+            this.emit(this);
+        }
+    }
+    getStatus() {
+        let failed;
+        for (const task of this.tasks) {
+            const status = task.getStatus();
+            if (status === 'failed')
+                failed = true;
+            if (status === 'busy')
+                return 'busy';
+        }
+        if (failed)
+            return 'failed';
+        return this.status;
+    }
+    hasWarning() {
+        for (const log of this.logs) {
+            if (log.level === 'warning')
+                return true;
+        }
+        for (const task of this.tasks) {
+            const warning = task.hasWarning();
+            if (warning)
+                return true;
+        }
+        return false;
+    }
+    toConsoleLog() {
+        const formatter = {
+            task: (task) => {
+                const status = { done: `${Chalk.White}★ [Done]`, busy: `${Chalk.Orange}★ [Busy]`, failed: `${Chalk.Red}★ [Failed]` }[task.getStatus()];
+                const date = $Date.format(new Date(task.startTimestamp), '[YYYY-MM-DD hh:mm:ss]');
+                const duration = $Number.toUnitString(task.finishTimestamp - task.startTimestamp, Unit.Time);
+                return `${status} ${date} ${task.name} ${Chalk.Dim}${duration}${Chalk.Reset}`;
+            },
+            log: (log) => {
+                const color = { info: Chalk.DarkGray, warning: Chalk.Orange, error: Chalk.Red }[log.level];
+                const level = { info: '●', warning: 'o', error: 'x' }[log.level];
+                const date = $Date.format(new Date(log.timestamp), '[YYYY-MM-DD hh:mm:ss]');
+                let message = $String.indent(log.message, 2).slice(2);
+                let attachments = '';
+                for (const [attachmentName, attachmentValue] of Object.entries(log.attachments)) {
+                    message = message.replaceAll(`$[${attachmentName}]`, attachmentName);
+                    attachments += `\n${attachmentName}: ${attachmentValue.value == null ? 'null' : attachmentValue.value === '' ? "" : attachmentValue.value}`;
+                }
+                return `${color}${level} ${date} ${message}${Chalk.Dim}${attachments ? $String.indent(attachments, 2) : ''}${Chalk.Reset}`;
+            }
+        };
+        const items = $Array.orderBy([...this.logs.map(log => ({ type: 'log', value: log })), ...this.tasks.map(task => ({ type: 'task', value: task }))], item => item.type === 'task' ? item.value.startTimestamp : item.value.timestamp);
+        let log = `${formatter.task(this)}\n`;
+        for (const item of items) {
+            const entry = item.type === 'task' ? item.value.toConsoleLog() : formatter.log(item.value);
+            log += `${$String.indent(entry, 2)}\n`;
+        }
+        return log.trim();
+    }
+}

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

@@ -0,0 +1,12 @@
+import { type Point } from './point';
+export interface Line {
+    start: Point;
+    end: Point;
+}
+export declare class Line {
+    static contains(line: Line, point: Point): boolean;
+    static getMiddle(line: Line): Point;
+    static getIntersect(a: Line, b: Line): Point;
+    static equals(a: Line, b: Line): boolean;
+    static toString(line: Line): string;
+}

package/dist/modules/math/line.js

@@ -0,0 +1,50 @@
+import { $Point } from './point';
+export class Line {
+    static contains(line, point) {
+        const { x: x1, y: y1 } = line.start;
+        const { x: x2, y: y2 } = line.end;
+        const { x, y } = point;
+        // Check if the point is within the bounding box of the line segment
+        const withinBoundingBox = x >= Math.min(x1, x2) && x <= Math.max(x1, x2) && y >= Math.min(y1, y2) && y <= Math.max(y1, y2);
+        if (!withinBoundingBox) {
+            return false;
+        }
+        // Check if the point satisfies the line equation
+        const slope = (y2 - y1) / (x2 - x1);
+        const equation = y - y1 === slope * (x - x1);
+        return equation;
+    }
+    static getMiddle(line) {
+        return {
+            x: (line.start.x + line.end.x) / 2,
+            y: (line.start.y + line.end.y) / 2,
+        };
+    }
+    static getIntersect(a, b) {
+        const { x: x1, y: y1 } = a.start;
+        const { x: x2, y: y2 } = a.end;
+        const { x: x3, y: y3 } = b.start;
+        const { x: x4, y: y4 } = b.end;
+        const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+        if (denom === 0) {
+            return null; // Lines are parallel or coincident
+        }
+        const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;
+        const ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom;
+        if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
+            // Intersection point lies within both line segments
+            const x = x1 + ua * (x2 - x1);
+            const y = y1 + ua * (y2 - y1);
+            return $Point.create(x, y);
+        }
+        else {
+            return null; // Intersection point is outside the line segments
+        }
+    }
+    static equals(a, b) {
+        return $Point.equals(a.start, b.start) && $Point.equals(a.end, b.end);
+    }
+    static toString(line) {
+        return `${line.start.toString()}${line.end.toString()}`;
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Rect } from './rect';
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare class $Point {
+    private static parse;
+    static create(): Point;
+    static create(value: number): Point;
+    static create(x: number, y: number): Point;
+    static create(point: Partial<Point>): Point;
+    static create(...args: [] | [number] | [number, number] | [Partial<Point>]): Point;
+    static plus(point: Point, value: number): Point;
+    static plus(point: Point, x: number, y: number): Point;
+    static plus(a: Point, b: Partial<Point>): Point;
+    static minus(point: Point, value: number): Point;
+    static minus(point: Point, x: number, y: number): Point;
+    static minus(a: Point, b: Partial<Point>): Point;
+    static times(point: Point, value: number): Point;
+    static times(point: Point, x: number, y: number): Point;
+    static times(a: Point, b: Partial<Point>): Point;
+    static divide(point: Point, value: number): Point;
+    static divide(point: Point, x: number, y: number): Point;
+    static divide(a: Point, b: Partial<Point>): Point;
+    static distance({ x: x1, y: y1 }: Point, { x: x2, y: y2 }?: Point): number;
+    static isPointInCircle({ x, y, r }: Point & {
+        r: number;
+    }, point: Point): boolean;
+    static isPointInRect(point: Point, rect: Rect): boolean;
+    static move(point: Point, length: number, radian?: number): Point;
+    static equals(a: Point, b: Point): boolean;
+    static snap({ x, y }: Point, snap: number): Point;
+    static toString(value: Point): string;
+}

package/dist/modules/math/point.js

@@ -0,0 +1,71 @@
+import { $Number } from '../number/number.util';
+import { $Object } from '../object/object.util';
+export class $Point {
+    static parse(...args) {
+        return $Point.create(...args);
+    }
+    static create(...args) {
+        let value;
+        if (args.length === 0) {
+            value = { x: 0, y: 0 };
+        }
+        else if (args.length === 1) {
+            if (typeof args[0] === 'number') {
+                value = { x: args[0], y: args[0] };
+            }
+            else {
+                value = $Object.getDefaults(args[0], { x: 0, y: 0 });
+            }
+        }
+        else {
+            value = { x: args[0], y: args[1] };
+        }
+        return { x: value.x, y: value.y };
+    }
+    static plus(...params) {
+        const value = $Point.parse(...params.slice(1));
+        return {
+            x: params[0].x + value.x, y: params[0].y + value.y
+        };
+    }
+    static minus(...params) {
+        const value = $Point.parse(...params.slice(1));
+        return {
+            x: params[0].x - value.x, y: params[0].y - value.y
+        };
+    }
+    static times(...params) {
+        const value = $Point.parse(...params.slice(1));
+        return { x: params[0].x * value.x, y: params[0].y * value.y };
+    }
+    static divide(...params) {
+        const value = $Point.parse(...params.slice(1));
+        return { x: params[0].x / value.x, y: params[0].y / value.y };
+    }
+    static distance({ x: x1, y: y1 }, { x: x2, y: y2 } = $Point.create()) {
+        const x = x1 - x2;
+        const y = y1 - y2;
+        return Math.sqrt(x * x + y * y);
+    }
+    static isPointInCircle({ x, y, r }, point) {
+        return $Point.distance($Point.parse(x, y), point) < r;
+    }
+    static isPointInRect(point, rect) {
+        return rect.x <= point.x && point.x <= rect.x + rect.width && rect.y <= point.y && point.y <= rect.y + rect.height;
+    }
+    static move(point, length, radian = 0) {
+        return $Point.create({
+            x: point.x + length * Math.cos(radian),
+            y: point.y + length * Math.sin(radian),
+        });
+    }
+    static equals(a, b) {
+        return a === b || (a?.x === b?.x && a?.y === b?.y);
+    }
+    static snap({ x, y }, snap) {
+        return { x: $Number.snap(x, snap), y: $Number.snap(y, snap) };
+    }
+    static toString(value) {
+        return `(${value.x}, ${value.y})`;
+    }
+}

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

@@ -0,0 +1,45 @@
+import { Line } from './line';
+import { type Point } from './point';
+export type PolygonIntersection = {
+    polygonA: Polygon;
+    polygonB: Polygon;
+    edgeIndexA: number;
+    edgeIndexB: number;
+    edgeA: Line;
+    edgeB: Line;
+    point: Point;
+};
+export declare class Polygon {
+    readonly vertices: Point[];
+    constructor(vertices: Point[]);
+    static getEdge(polygon: Polygon, index: number): Line;
+    getEdge(index: number): Line;
+    static getEdges(polygon: Polygon): Line[];
+    getEdges(): Line[];
+    static containsPoint(polygon: Polygon, point: Point): boolean;
+    containsPoint(point: Point): boolean;
+    static move(polygon: Polygon, position: Point): Polygon;
+    move(position: Point): Polygon;
+    static getIntersections(a: Polygon, b: Polygon, unique?: boolean): {
+        intersections: PolygonIntersection[];
+        edges: Record<string, PolygonIntersection[]>;
+        points: Record<string, PolygonIntersection>;
+    };
+    getIntersections(polygon: Polygon, unique?: boolean): {
+        intersections: PolygonIntersection[];
+        edges: Record<string, PolygonIntersection[]>;
+        points: Record<string, PolygonIntersection>;
+    };
+    static getLineIntersections(polygon: Polygon, line: Line): {
+        edgeIndex: number;
+        edge: Line;
+        point: Point;
+    }[];
+    getLineIntersections(polygon: Polygon, line: Line): {
+        edgeIndex: number;
+        edge: Line;
+        point: Point;
+    }[];
+    static subtract(a: Polygon, b: Polygon): Polygon[];
+    subtract(polygon: Polygon): Polygon[];
+}