@vorplex/core 0.0.8 → 0.0.9

package/dist/modules/changes/changes.util.js

@@ -0,0 +1,330 @@
+import { parsePath } from '../../functions/parse-path-selector.function';
+import { $Object } from '../object/object.util';
+import { $Value } from '../value/value.util';
+export class $Changes {
+    static deleted = '[deleted]';
+    static isArrayIndexChange(change) {
+        if (change == null || typeof change !== 'object' || Array.isArray(change))
+            return false;
+        if (!Object.keys(change).length)
+            return;
+        for (const k of Object.keys(change)) {
+            if (!k.startsWith('$'))
+                return false;
+            const key = k.endsWith('+') ? k.slice(1, -1) : k.slice(1);
+            const index = Number.parseInt(key, 10);
+            if (Number.isNaN(index))
+                return false;
+        }
+        return true;
+    }
+    static getArrayChanges(a, b) {
+        if ($Value.equals(a, b))
+            return;
+        const result = {};
+        let i = 0; // index in a
+        let j = 0; // index in b
+        while (i < a.length && j < b.length) {
+            if ($Value.equals(a[i], b[j])) {
+                i++;
+                j++;
+                continue;
+            }
+            // Look for matches further ahead to detect multiple deletions/insertions
+            let foundDeletion = false;
+            for (let lookAhead = i + 1; lookAhead < a.length; lookAhead++) {
+                if ($Value.equals(a[lookAhead], b[j])) {
+                    // Found a match - mark all items between as deleted
+                    for (let k = i; k < lookAhead; k++) {
+                        result[`$${k}`] = $Changes.deleted;
+                    }
+                    i = lookAhead;
+                    foundDeletion = true;
+                    break;
+                }
+            }
+            if (foundDeletion)
+                continue;
+            // Look for insertions
+            let foundInsertion = false;
+            for (let lookAhead = j + 1; lookAhead < b.length; lookAhead++) {
+                if ($Value.equals(a[i], b[lookAhead])) {
+                    // Found a match - mark all items between as insertions
+                    for (let k = j; k < lookAhead; k++) {
+                        result[`$${k}+`] = b[k];
+                    }
+                    j = lookAhead;
+                    foundInsertion = true;
+                    break;
+                }
+            }
+            if (foundInsertion)
+                continue;
+            // Replace
+            result[`$${i}`] = $Changes.get(a[i], b[j]);
+            i++;
+            j++;
+        }
+        // Remaining items in a were deleted
+        for (; i < a.length; i++)
+            result[`$${i}`] = $Changes.deleted;
+        // Remaining items in b were appended (inserts at end)
+        for (; j < b.length; j++)
+            result[`$${j}+`] = b[j];
+        return Object.keys(result).length ? result : undefined;
+    }
+    static getObjectChanges(a, b) {
+        const changes = {};
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        for (const key of keys) {
+            if (!(key in b)) {
+                changes[key] = $Changes.deleted;
+            }
+            else if (!(key in a)) {
+                changes[key] = b[key];
+            }
+            else {
+                const change = $Changes.get(a[key], b[key]);
+                if (change !== undefined) {
+                    changes[key] = change;
+                }
+            }
+        }
+        return Object.keys(changes).length ? changes : undefined;
+    }
+    static get(a, b) {
+        if (a === b)
+            return;
+        if (a == null || b == null)
+            return b;
+        if (typeof a !== 'object')
+            return b;
+        if (typeof a !== typeof b)
+            return b;
+        if (Array.isArray(a) !== Array.isArray(b))
+            return b;
+        if (Array.isArray(a) && Array.isArray(b))
+            return $Changes.getArrayChanges(a, b);
+        return $Changes.getObjectChanges(a, b);
+    }
+    static classifyPathsByOverlap(changesA, changesB) {
+        const aPaths = $Object.getPaths(changesA);
+        const bPaths = $Object.getPaths(changesB);
+        const conflicts = new Set();
+        const differences = new Set();
+        for (const aPath of aPaths) {
+            if (bPaths.some(bPath => this.pathsOverlap(aPath, bPath)))
+                conflicts.add(aPath);
+            else
+                differences.add(aPath);
+        }
+        for (const bPath of bPaths) {
+            if (aPaths.some(aPath => this.pathsOverlap(aPath, bPath)))
+                conflicts.add(bPath);
+            else
+                differences.add(bPath);
+        }
+        return {
+            conflicts: Array.from(conflicts),
+            differences: Array.from(differences)
+        };
+    }
+    static resolveConflicts(changesA, changesB) {
+        const { conflicts, differences } = this.classifyPathsByOverlap(changesA, changesB);
+        return {
+            differences: $Changes.excludeChanges(changesB, conflicts),
+            conflicts: $Changes.excludeChanges(changesB, differences)
+        };
+    }
+    static pathsOverlap(a, b) {
+        const selectorsA = parsePath(a);
+        const selectorsB = parsePath(b);
+        const length = Math.min(selectorsA.length, selectorsB.length);
+        for (let i = 0; i < length; i++) {
+            if (selectorsA[i] !== selectorsB[i])
+                return false;
+        }
+        return true;
+    }
+    static hasConflict(changesA, changesB) {
+        const aPaths = $Object.getPaths(changesA);
+        const bPaths = $Object.getPaths(changesB);
+        for (const bPath of bPaths) {
+            for (const aPath of aPaths) {
+                if (this.pathsOverlap(aPath, bPath))
+                    return true;
+            }
+        }
+        return false;
+    }
+    static asValue(changes) {
+        if (changes === undefined)
+            return undefined;
+        if (Array.isArray(changes)) {
+            return changes.map(item => $Changes.asValue(item));
+        }
+        if (typeof changes === 'object' && changes !== null) {
+            // cannot materialize array index changes without a base; strip them
+            if ($Changes.isArrayIndexChange(changes))
+                return undefined;
+            const result = {};
+            for (const [key, value] of Object.entries(changes)) {
+                if (value === $Changes.deleted)
+                    continue;
+                result[key] = $Changes.asValue(value);
+            }
+            return result;
+        }
+        return changes;
+    }
+    static apply(value, changes) {
+        function applyArrayChange(originalArray, change) {
+            if (!$Changes.isArrayIndexChange(change))
+                return $Value.clone(change);
+            const result = $Value.clone(originalArray);
+            const entries = Object.entries(change)
+                .map(([k, v]) => {
+                const isInsert = k.endsWith('+');
+                const nStr = isInsert ? k.slice(1, -1) : k.slice(1);
+                return [Number.parseInt(nStr, 10), isInsert, v];
+            })
+                .filter(([i]) => !Number.isNaN(i))
+                .sort(([iA, insA, vA], [iB, insB, vB]) => {
+                const aDel = vA === $Changes.deleted;
+                const bDel = vB === $Changes.deleted;
+                // deletes first, highest -> lowest
+                if (aDel !== bDel)
+                    return aDel ? -1 : 1;
+                if (aDel && bDel)
+                    return iB - iA;
+                // inserts next, lowest -> highest
+                if (insA !== insB)
+                    return insA ? -1 : 1;
+                if (insA && insB)
+                    return iA - iB;
+                // sets last, lowest -> highest
+                return iA - iB;
+            });
+            for (const [index, isInsert, op] of entries) {
+                if (op === $Changes.deleted) {
+                    if (index >= 0 && index < result.length)
+                        result.splice(index, 1);
+                }
+                else if (isInsert) {
+                    const v = $Value.clone(op);
+                    const idx = Math.min(Math.max(index, 0), result.length);
+                    result.splice(idx, 0, v);
+                }
+                else {
+                    if (index >= result.length)
+                        result.length = index + 1;
+                    result[index] = $Changes.apply(result[index], op);
+                }
+            }
+            return result;
+        }
+        if (changes === undefined)
+            return value;
+        if (value == null || typeof changes !== 'object')
+            return $Changes.asValue(changes);
+        if (Array.isArray(value)) {
+            return applyArrayChange(value, changes);
+        }
+        else if (typeof value === 'object') {
+            if (Array.isArray(changes))
+                return $Changes.asValue(changes);
+            const result = { ...value };
+            for (const [key, change] of Object.entries(changes)) {
+                if (change === $Changes.deleted) {
+                    delete result[key];
+                }
+                else if (Array.isArray(result[key])) {
+                    result[key] = applyArrayChange(result[key] || [], change);
+                }
+                else if (typeof change === 'object' && change !== null) {
+                    result[key] = $Changes.apply(result[key], change);
+                }
+                else {
+                    result[key] = change;
+                }
+            }
+            return result;
+        }
+        return $Changes.asValue(changes);
+    }
+    static rebase(source, local, remote) {
+        const localChanges = $Changes.get(source, local);
+        const remoteChanges = $Changes.get(source, remote);
+        if (localChanges === undefined || $Value.equals(localChanges, remoteChanges)) {
+            return { result: $Changes.apply(source, remoteChanges) };
+        }
+        if (remoteChanges === undefined) {
+            return { result: $Changes.apply(source, localChanges) };
+        }
+        else if (!$Changes.hasConflict(remoteChanges, localChanges)) {
+            let result = $Changes.apply(source, localChanges);
+            result = $Changes.apply(result, remoteChanges);
+            return { result };
+        }
+        else {
+            const localConflict = $Changes.resolveConflicts(remoteChanges, localChanges);
+            const remoteConflict = $Changes.resolveConflicts(localChanges, remoteChanges);
+            const sourceWithDifferences = $Changes.apply($Changes.apply(source, remoteConflict.differences), localConflict.differences);
+            const mergedWithLocalDifferences = $Changes.apply(remote, localConflict.differences);
+            return {
+                conflicts: {
+                    local: localConflict,
+                    remote: remoteConflict,
+                },
+                merge: {
+                    source: sourceWithDifferences,
+                    remote: $Changes.apply(sourceWithDifferences, remoteConflict.conflicts),
+                    local: $Changes.apply(sourceWithDifferences, localConflict.conflicts),
+                    result: mergedWithLocalDifferences
+                },
+                result: $Changes.apply(mergedWithLocalDifferences, localConflict.conflicts)
+            };
+        }
+    }
+    /**
+     * 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, paths) {
+        if (!paths.length)
+            return changes;
+        if (typeof changes !== 'object' || changes == null || Array.isArray(changes))
+            return changes;
+        const result = $Value.clone(changes);
+        for (const pathString of paths) {
+            $Value.unset(result, pathString);
+        }
+        function cleanupEmptyObjects(current, original) {
+            if (current == null || typeof current !== 'object')
+                return current;
+            if (Array.isArray(current))
+                return current.map((item, index) => cleanupEmptyObjects(item, original?.[index]));
+            const cleaned = {};
+            for (const [key, value] of Object.entries(current)) {
+                if (value === $Changes.deleted) {
+                    cleaned[key] = value;
+                    continue;
+                }
+                const cleanedValue = cleanupEmptyObjects(value, original?.[key]);
+                if (cleanedValue === undefined)
+                    continue;
+                if (!$Object.isEmptyObject(cleanedValue) || $Object.isEmptyObject(original?.[key]))
+                    cleaned[key] = cleanedValue;
+            }
+            if (Object.keys(cleaned).length === 0)
+                return $Object.isEmptyObject(original) ? {} : undefined;
+            return cleaned;
+        }
+        return cleanupEmptyObjects(result, changes);
+    }
+}

package/dist/modules/color/color-data.interface.d.ts

@@ -0,0 +1,10 @@
+import type { HSL } from './hsl.interface';
+import type { HSV } from './hsv.interface';
+import type { RGB } from './rgb.interface';
+export interface ColorData {
+    hex0: number;
+    hex: string;
+    rgb: RGB;
+    hsl: HSL;
+    hsv: HSV;
+}

package/dist/modules/color/color-formats.const.d.ts

@@ -0,0 +1,9 @@
+export declare const ColorFormats: {
+    readonly RGB: "RGB";
+    readonly HSL: "HSL";
+    readonly HSV: "HSV";
+    readonly Hex: "Hex";
+    readonly Hex0: "Hex0";
+    readonly Name: "Name";
+};
+export type ColorFormats = (typeof ColorFormats)[keyof typeof ColorFormats];

package/dist/modules/color/color-formats.const.js

@@ -0,0 +1,8 @@
+export const ColorFormats = {
+    RGB: 'RGB',
+    HSL: 'HSL',
+    HSV: 'HSV',
+    Hex: 'Hex',
+    Hex0: 'Hex0',
+    Name: 'Name',
+};

package/dist/modules/color/color.type.d.ts

@@ -0,0 +1,4 @@
+import type { HSL } from './hsl.interface';
+import type { HSV } from './hsv.interface';
+import type { RGB } from './rgb.interface';
+export type Color = RGB | HSL | HSV | string | number;

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

@@ -0,0 +1,41 @@
+import type { Color } from './color.type';
+import type { ColorData } from './color-data.interface';
+import { ColorFormats } from './color-formats.const';
+import type { HSL } from './hsl.interface';
+import type { HSV } from './hsv.interface';
+import type { RGB } from './rgb.interface';
+export declare class $Color {
+    private constructor();
+    static random(format: '#'): string;
+    static random(format: '0x'): number;
+    static from(value?: Color): ColorData;
+    static equal(target: Color, value: Color): boolean;
+    static isRgb(value: Color): boolean;
+    static isHsl(value: Color): boolean;
+    static isHsv(value: Color): boolean;
+    static isHex(value: Color): boolean;
+    static convertHexToHex0(hex: string): number;
+    static convertHex0ToHex(hex: number): string;
+    static convertHexToRgb(hex: string): RGB;
+    static convertRgbToCss(rgb: RGB): string;
+    static convertHslToCss(hsl: HSL): string;
+    static convertRgbToHsl(rgb: RGB): HSL;
+    static convertHslToRgb(hsl: HSL): RGB;
+    static convertHslToHsv(hsl: HSL): HSV;
+    static convertHsvToHsl(hsv: HSV): HSL;
+    static convertHexToHsv(hex: string): HSV;
+    static convertHslToHex(hsl: HSL, type?: '#'): string;
+    static convertHslToHex(hsl: HSL, type?: '0x'): number;
+    static convertHexToHsl(hex: string): HSL;
+    static convertHsvToRgb(hsv: HSV): RGB;
+    static convertHsvToHex(hsv: HSV, type?: '#'): string;
+    static convertHsvToHex(hsv: HSV, type?: '0x'): number;
+    static convertRgbToHex(rgb: RGB, type?: '#'): string;
+    static convertRgbToHex(rgb: RGB, type?: '0x'): number;
+    static convertRgbToHsv(rgb: RGB): HSV;
+    static convertHexToName(hex: string): string;
+    static convertNameToHex(name: string, type?: '#'): string;
+    static convertNameToHex(name: string, type?: '0x'): number;
+    static getFormat(color: string | number): ColorFormats;
+    static parse(color: string | number): ColorData;
+}