@vorplex/core 0.0.4 → 0.0.9

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+export * from './consts/mime-type.const';
+export * from './consts/unit.const';
+export * from './functions/debounce.function';
+export * from './functions/is-node-environment.function';
+export * from './functions/parse-path-selector.function';
+export * from './functions/parse-url.function';
+export * from './interfaces/group.interface';
+export * from './interfaces/key-value.interface';
+export * from './modules/api/socket.model';
+export * from './modules/api/web-client.model';
+export * from './modules/array/array.util';
+export * from './modules/changes/changes.util';
+export * from './modules/color/color-data.interface';
+export * from './modules/color/color-formats.const';
+export * from './modules/color/color.type';
+export * from './modules/color/color.util';
+export * from './modules/color/colors.const';
+export * from './modules/color/hsl.interface';
+export * from './modules/color/hsv.interface';
+export * from './modules/color/rgb.interface';
+export * from './modules/compression/compression.util';
+export * from './modules/date/date.util';
+export * from './modules/enum/enum.util';
+export * from './modules/hash/hash.util';
+export * from './modules/id/id.util';
+export * from './modules/injector/injector.model';
+export * from './modules/injector/provider-scopes.enum';
+export * from './modules/injector/provider.interface';
+export * from './modules/injector/decorators/inject-token.decorator';
+export * from './modules/injector/decorators/injectable.decorator';
+export * from './modules/json-filter/json-filter.function';
+export * from './modules/logging/console-logger.model';
+export * from './modules/logging/logger.model';
+export * from './modules/logging/task';
+export * from './modules/math/line';
+export * from './modules/math/point';
+export * from './modules/math/polygon';
+export * from './modules/math/rect';
+export * from './modules/math/size';
+export * from './modules/number/number.util';
+export * from './modules/object/object.util';
+export * from './modules/path/path.util';
+export * from './modules/random/random.util';
+export * from './modules/readable-stream/readable-stream.util';
+export * from './modules/reflection/interfaces/parameter.interface';
+export * from './modules/reflection/models/attribute.model';
+export * from './modules/reflection/models/class-attribute.model';
+export * from './modules/reflection/models/method-attribute.model';
+export * from './modules/reflection/models/parameter-attribute.model';
+export * from './modules/reflection/models/property-attribute.model';
+export * from './modules/reflection/models/property-proxy-attribute.model';
+export * from './modules/reflection/types/constructor.type';
+export * from './modules/reflection/types/instance.type';
+export * from './modules/reflection/types/type.type';
+export * from './modules/reflection/utils/decorator.util';
+export * from './modules/reflection/utils/reflection.util';
+export * from './modules/router/router.util';
+export * from './modules/state/state.model';
+export * from './modules/state/update.type';
+export * from './modules/state/adaptors/array/array-adaptor.util';
+export * from './modules/state/adaptors/entity/entity-adaptor.util';
+export * from './modules/state/adaptors/entity/entity-map.type';
+export * from './modules/state/adaptors/entity/entity.interface';
+export * from './modules/string/string.util';
+export * from './modules/subscribable/subscribable.model';
+export * from './modules/subscribable/subscription.interface';
+export * from './modules/tson/error';
+export * from './modules/tson/schema';
+export * from './modules/tson/tson';
+export * from './modules/tson/type';
+export * from './modules/tson/schemas/any';
+export * from './modules/tson/schemas/array';
+export * from './modules/tson/schemas/boolean';
+export * from './modules/tson/schemas/enum';
+export * from './modules/tson/schemas/number';
+export * from './modules/tson/schemas/object';
+export * from './modules/tson/schemas/schema-base';
+export * from './modules/tson/schemas/string';
+export * from './modules/tson/schemas/union';
+export * from './modules/value/value.util';
+export * from './types/awaitable.type';
+export * from './types/camel-to-kebab.type';
+export * from './types/has-key.type';
+export * from './types/is-union.type';
+export * from './types/keys-of-type.type';
+export * from './types/keys-with-fix.type';
+export * from './types/optional-keys.type';
+export * from './types/partial.type';
+export * from './types/predicate.type';
+export * from './types/recursive-readonly.type';
+export * from './types/recursive-value.type';
+export * from './types/selector.type';

package/dist/index.js

@@ -0,0 +1,93 @@
+// **/*.ts
+export * from './consts/mime-type.const';
+export * from './consts/unit.const';
+export * from './functions/debounce.function';
+export * from './functions/is-node-environment.function';
+export * from './functions/parse-path-selector.function';
+export * from './functions/parse-url.function';
+export * from './interfaces/group.interface';
+export * from './interfaces/key-value.interface';
+export * from './modules/api/socket.model';
+export * from './modules/api/web-client.model';
+export * from './modules/array/array.util';
+export * from './modules/changes/changes.util';
+export * from './modules/color/color-data.interface';
+export * from './modules/color/color-formats.const';
+export * from './modules/color/color.type';
+export * from './modules/color/color.util';
+export * from './modules/color/colors.const';
+export * from './modules/color/hsl.interface';
+export * from './modules/color/hsv.interface';
+export * from './modules/color/rgb.interface';
+export * from './modules/compression/compression.util';
+export * from './modules/date/date.util';
+export * from './modules/enum/enum.util';
+export * from './modules/hash/hash.util';
+export * from './modules/id/id.util';
+export * from './modules/injector/injector.model';
+export * from './modules/injector/provider-scopes.enum';
+export * from './modules/injector/provider.interface';
+export * from './modules/injector/decorators/inject-token.decorator';
+export * from './modules/injector/decorators/injectable.decorator';
+export * from './modules/json-filter/json-filter.function';
+export * from './modules/logging/console-logger.model';
+export * from './modules/logging/logger.model';
+export * from './modules/logging/task';
+export * from './modules/math/line';
+export * from './modules/math/point';
+export * from './modules/math/polygon';
+export * from './modules/math/rect';
+export * from './modules/math/size';
+export * from './modules/number/number.util';
+export * from './modules/object/object.util';
+export * from './modules/path/path.util';
+export * from './modules/random/random.util';
+export * from './modules/readable-stream/readable-stream.util';
+export * from './modules/reflection/interfaces/parameter.interface';
+export * from './modules/reflection/models/attribute.model';
+export * from './modules/reflection/models/class-attribute.model';
+export * from './modules/reflection/models/method-attribute.model';
+export * from './modules/reflection/models/parameter-attribute.model';
+export * from './modules/reflection/models/property-attribute.model';
+export * from './modules/reflection/models/property-proxy-attribute.model';
+export * from './modules/reflection/types/constructor.type';
+export * from './modules/reflection/types/instance.type';
+export * from './modules/reflection/types/type.type';
+export * from './modules/reflection/utils/decorator.util';
+export * from './modules/reflection/utils/reflection.util';
+export * from './modules/router/router.util';
+export * from './modules/state/state.model';
+export * from './modules/state/update.type';
+export * from './modules/state/adaptors/array/array-adaptor.util';
+export * from './modules/state/adaptors/entity/entity-adaptor.util';
+export * from './modules/state/adaptors/entity/entity-map.type';
+export * from './modules/state/adaptors/entity/entity.interface';
+export * from './modules/string/string.util';
+export * from './modules/subscribable/subscribable.model';
+export * from './modules/subscribable/subscription.interface';
+export * from './modules/tson/error';
+export * from './modules/tson/schema';
+export * from './modules/tson/tson';
+export * from './modules/tson/type';
+export * from './modules/tson/schemas/any';
+export * from './modules/tson/schemas/array';
+export * from './modules/tson/schemas/boolean';
+export * from './modules/tson/schemas/enum';
+export * from './modules/tson/schemas/number';
+export * from './modules/tson/schemas/object';
+export * from './modules/tson/schemas/schema-base';
+export * from './modules/tson/schemas/string';
+export * from './modules/tson/schemas/union';
+export * from './modules/value/value.util';
+export * from './types/awaitable.type';
+export * from './types/camel-to-kebab.type';
+export * from './types/has-key.type';
+export * from './types/is-union.type';
+export * from './types/keys-of-type.type';
+export * from './types/keys-with-fix.type';
+export * from './types/optional-keys.type';
+export * from './types/partial.type';
+export * from './types/predicate.type';
+export * from './types/recursive-readonly.type';
+export * from './types/recursive-value.type';
+export * from './types/selector.type';

package/dist/interfaces/group.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Group<TKey, TValue> {
+    key: TKey;
+    items: TValue[];
+}

package/dist/interfaces/key-value.interface.d.ts

@@ -0,0 +1,4 @@
+export interface KeyValue<T> {
+    key: string;
+    value: T;
+}

package/dist/modules/api/socket.model.d.ts

@@ -0,0 +1,26 @@
+import { Emitter } from '../subscribable/subscribable.model';
+export declare class ISocket {
+    readyState: number;
+    OPEN: number;
+    onmessage: (message: any) => void;
+    onerror: (error: any) => void;
+    onclose: (event?: any) => void;
+    send: (data: any) => void;
+    onopen: (event: any) => void;
+    close: () => void;
+}
+export type SocketOptions = {
+    url: string;
+    autoReconnect?: boolean;
+    retryInterval?: number;
+};
+export declare class Socket {
+    private socket;
+    private state;
+    readonly stream: Emitter<any>;
+    get connected(): boolean;
+    private constructor();
+    static connect(options: SocketOptions): Promise<Socket>;
+    send(request: any): void;
+    disconnect(): void;
+}

package/dist/modules/api/socket.model.js

@@ -0,0 +1,66 @@
+import { $Object } from '../object/object.util';
+import { State } from '../state/state.model';
+import { Emitter } from '../subscribable/subscribable.model';
+const SOCKET = null;
+export class ISocket {
+    readyState;
+    OPEN;
+    onmessage;
+    onerror;
+    onclose;
+    send;
+    onopen;
+    close;
+}
+export class Socket {
+    socket;
+    state = new State(null);
+    stream = new Emitter();
+    get connected() {
+        return this.socket && this.socket.readyState === this.socket.OPEN;
+    }
+    constructor() { }
+    static async connect(options) {
+        options = $Object.getDefaults(options, { retryInterval: 1000 });
+        const connect = (socket) => {
+            return new Promise((resolve, reject) => {
+                const stream = (socket.socket = new SOCKET(options.url));
+                stream.onopen = () => {
+                    resolve(socket);
+                    socket.state.update('open');
+                };
+                stream.onmessage = (message) => socket.stream.emit(JSON.parse(message.data));
+                stream.onclose = () => {
+                    if (socket.state.value !== 'closed') {
+                        socket.state.update('closed');
+                        if (options.autoReconnect) {
+                            const retry = async () => {
+                                try {
+                                    await connect(socket);
+                                }
+                                catch {
+                                    await new Promise((resolve) => setTimeout(resolve, options.retryInterval));
+                                    await retry();
+                                }
+                            };
+                            retry();
+                        }
+                    }
+                };
+                stream.onerror = (error) => {
+                    reject(error);
+                    socket.stream.emit(error);
+                };
+            });
+        };
+        const socket = new Socket();
+        return connect(socket);
+    }
+    send(request) {
+        this.socket.send(JSON.stringify(request));
+    }
+    disconnect() {
+        this.state.update('closed');
+        this.socket.close();
+    }
+}

package/dist/modules/api/web-client.model.d.ts

@@ -0,0 +1,16 @@
+import { Emitter } from '../subscribable/subscribable.model';
+import { ISocket } from './socket.model';
+export declare class WebClient {
+    socket: ISocket;
+    address?: string;
+    private readonly state;
+    readonly id: string;
+    readonly stream: Emitter<any>;
+    get connected(): boolean;
+    readonly status: import("../..").Subscribable<import("../..").StateChange<"open" | "closed" | "none">> & {
+        readonly value: "open" | "closed" | "none";
+    };
+    constructor(socket: ISocket, address?: string);
+    send(packet: any): void;
+    disconnect(): void;
+}

package/dist/modules/api/web-client.model.js

@@ -0,0 +1,34 @@
+import { $Id } from '../id/id.util';
+import { State } from '../state/state.model';
+import { Emitter } from '../subscribable/subscribable.model';
+export class WebClient {
+    socket;
+    address;
+    state = new State('none');
+    id = $Id.uuid();
+    stream = new Emitter();
+    get connected() {
+        return this.socket && this.socket.readyState === this.socket.OPEN;
+    }
+    status = this.state.asReadOnly();
+    constructor(socket, address) {
+        this.socket = socket;
+        this.address = address;
+        socket.onopen = () => this.state.update('open');
+        socket.onclose = () => this.state.update('closed');
+        socket.onmessage = (message) => {
+            let data = message.data;
+            try {
+                data = JSON.parse(data);
+            }
+            catch { }
+            this.stream.emit(data);
+        };
+    }
+    send(packet) {
+        this.socket.send(JSON.stringify(packet));
+    }
+    disconnect() {
+        this.socket.close();
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Predicate } from '../../types/predicate.type';
+import type { Selector } from '../../types/selector.type';
+export declare class $Array {
+    static isUnique(array: any[]): boolean;
+    static removeWhere<T>(array: T[], predicate: Predicate<T>, first?: boolean): T[];
+    static remove<T>(array: T[], ...items: T[]): T[];
+    static toggle<T>(array: T[], ...items: T[]): T[];
+    static upsert<T>(array: T[], ...items: T[]): T[];
+    static removeAt<T>(array: T[], ...indexes: number[]): T[];
+    static swap<T>(array: T[], indexA: number, indexB: number): T[];
+    static insert<T>(array: T[], index: number, ...items: T[]): T[];
+    static move<T>(array: T[], item: T, index: number): T[];
+    static moveAt<T>(array: T[], sourceIndex: number, destinationIndex: number): T[];
+    static order<T>(array: T[], order?: 'asc' | 'desc'): T[];
+    static orderBy<T>(array: T[], selector: Selector<T>, order?: 'asc' | 'desc'): T[];
+    static last<T>(array: T[]): T;
+}

package/dist/modules/array/array.util.js

@@ -0,0 +1,105 @@
+export class $Array {
+    static isUnique(array) {
+        return new Set(array).size === array.length;
+    }
+    static removeWhere(array, predicate, first) {
+        const result = [...array];
+        for (const [index, item] of result.entries()) {
+            if (predicate(item)) {
+                result.splice(index, 1);
+                if (first)
+                    return result;
+            }
+        }
+        return result;
+    }
+    static remove(array, ...items) {
+        const result = [...array];
+        for (const item of items) {
+            const index = result.indexOf(item);
+            if (index !== -1)
+                result.splice(index, 1);
+        }
+        return result;
+    }
+    static toggle(array, ...items) {
+        const result = [...array];
+        for (const item of items) {
+            const index = result.indexOf(item);
+            if (index !== -1)
+                result.splice(index, 1);
+            else
+                result.push(item);
+        }
+        return result;
+    }
+    static upsert(array, ...items) {
+        const result = [...array];
+        for (const item of items) {
+            if (!result.includes(item))
+                result.push(item);
+        }
+        return result;
+    }
+    static removeAt(array, ...indexes) {
+        const result = [...array];
+        for (const index of indexes) {
+            result.splice(index, 1);
+        }
+        return result;
+    }
+    static swap(array, indexA, indexB) {
+        const result = [...array];
+        if (indexA === indexB)
+            return result;
+        const temp = result[indexA];
+        result[indexA] = result[indexB];
+        result[indexB] = temp;
+        return result;
+    }
+    static insert(array, index, ...items) {
+        const result = [...array];
+        result.splice(index, 0, ...items);
+        return result;
+    }
+    static move(array, item, index) {
+        return $Array.moveAt(array, array.indexOf(item), index);
+    }
+    static moveAt(array, sourceIndex, destinationIndex) {
+        const result = [...array];
+        const item = result[sourceIndex];
+        result.splice(sourceIndex, 1);
+        result.splice(destinationIndex, 0, item);
+        return result;
+    }
+    static order(array, order) {
+        return $Array.orderBy(array, (a) => a, order);
+    }
+    static orderBy(array, selector, order) {
+        const result = [...array];
+        const compare = (a, b) => {
+            if (a == null && b == null)
+                return 0;
+            if (a == null)
+                return 1;
+            if (b == null)
+                return -1;
+            if (typeof a === 'string' && typeof b === 'string')
+                return a.localeCompare(b);
+            if (a instanceof Date && b instanceof Date) {
+                a = a.getTime();
+                b = b.getTime();
+            }
+            if (a < b)
+                return -1;
+            if (a > b)
+                return 1;
+            return 0;
+        };
+        result.sort((a, b) => compare(selector(a), selector(b)) * (order === 'desc' ? -1 : 1));
+        return result;
+    }
+    static last(array) {
+        return array[array.length - 1];
+    }
+}

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

@@ -0,0 +1,45 @@
+export type ArrayChange = Record<`$${number}` | `$${number}+`, any | typeof $Changes.deleted>;
+export interface ChangeConflicts {
+    conflicts: any;
+    differences: any;
+}
+export interface ChangeRebase<T = any> {
+    result: T;
+    conflicts?: {
+        local: ChangeConflicts;
+        remote: ChangeConflicts;
+    };
+    merge?: {
+        source: T;
+        remote: T;
+        local: T;
+        result: T;
+    };
+}
+export declare class $Changes {
+    static readonly deleted: "[deleted]";
+    private static isArrayIndexChange;
+    static getArrayChanges(a: any[], b: any[]): ArrayChange | undefined;
+    static getObjectChanges(a: Record<string, any>, b: Record<string, any>): Record<string, any | typeof $Changes.deleted>;
+    static get(a: any, b: any): undefined | any | Record<string, any | typeof $Changes.deleted> | ArrayChange;
+    static classifyPathsByOverlap(changesA: any, changesB: any): {
+        conflicts: string[];
+        differences: string[];
+    };
+    static resolveConflicts(changesA: any, changesB: any): ChangeConflicts;
+    private static pathsOverlap;
+    static hasConflict(changesA: any, changesB: any): boolean;
+    static asValue(changes: any): any;
+    static apply(value: any, changes: any): any;
+    static rebase(source: any, local: any, remote: any): ChangeRebase;
+    /**
+     * Excludes specific paths from a changes object and cleans up empty containers.
+     * Empty objects {} left behind after exclusion are recursively cleaned up,
+     * unless they existed in the original changes (intentional {} changes are preserved).
+     *
+     * @param changes - The changes object to filter
+     * @param paths - Array of dot-notation paths to exclude (e.g., ['user.name', 'config.theme'])
+     * @returns The filtered changes object with empty containers cleaned up
+     */
+    static excludeChanges(changes: any, paths: string[]): any;
+}