@pacem/pacem-foundation 1.0.0-abel

package/dist/esm/keygenerator.js

@@ -0,0 +1,20 @@
+// namespace Pacem {
+export class Keys {
+    static #seed;
+    static uniqueId() {
+        let seed = Keys.#seed || Date.now();
+        return Keys.#seed = ++seed;
+    }
+    static uniqueCode() {
+        const newid = Keys.uniqueId();
+        return newid.toBase62();
+    }
+    static randomString(length) {
+        let retval = '';
+        do {
+            retval += (Math.random() * 62).toBase62();
+        } while (retval.length < length);
+        return retval;
+    }
+}
+// }

package/dist/esm/matrix2d.js

@@ -0,0 +1,133 @@
+/// <reference path="geom.ts" />
+;
+export class Matrix2D {
+    static isIdentity(m) {
+        return m.a === 1 && m.d === 1 && m.b === 0 && m.f === 0 && m.c === 0 && m.e === 0;
+    }
+    static get identity() {
+        return { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+    }
+    static copy(m) {
+        return { a: m.a, b: m.b, c: m.c, d: m.d, e: m.e, f: m.f };
+    }
+    static scale(m, sx, sy = sx) {
+        return { a: m.a * sx, b: m.b, c: m.c, d: m.d * sy, e: m.e, f: m.f };
+    }
+    static translate(m, t) {
+        return { a: m.a, b: m.b, c: m.c, d: m.d, e: m.e + t.x, f: m.f + t.y };
+    }
+    static rotate(m, rad) {
+        const cos = Math.cos(rad), sin = Math.sin(rad);
+        return Matrix2D.multiply(m, { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 });
+    }
+    static multiply(m1, m2) {
+        if ("x" in m1 && "y" in m1) {
+            if (typeof m2 === 'number') {
+                return { x: m1.x * m2, y: m1.y * m2 };
+            }
+            else {
+                return { x: m1.x * m2.a + m1.y * m2.c + m2.e, y: m1.x * m2.b + m1.y * m2.d + m2.f };
+            }
+        }
+        if (typeof m2 === 'number') {
+            return {
+                a: m1.a * m2, b: m1.b * m2, c: m1.c * m2, d: m1.d * m2, e: m1.e * m2, f: m1.f * m2
+            };
+        }
+        return {
+            a: m1.a * m2.a + m1.b * m2.c,
+            b: m1.a * m2.b + m1.b * m2.d,
+            c: m1.c * m2.a + m1.d * m2.c,
+            d: m1.c * m2.b + m1.d * m2.d,
+            e: m1.e * m2.a + m1.f * m2.c + m2.e,
+            f: m1.e * m2.b + m1.f * m2.d + m2.f
+        };
+    }
+    static det(m) {
+        return m.a * m.d - m.c * m.b;
+    }
+    static invert(m) {
+        const det = this.det(m);
+        if (det === 0) {
+            // NaM(2D) ? 
+            return null;
+        }
+        const invdet = 1 / det;
+        /*
+         * 1. swap a, d
+         * 2. swap c, b and change signs
+         * 3. e := -e*d + f*c
+         * 4. f := e*b - f*a
+         * 5. divide everything by [det]
+        */
+        return this.multiply({
+            a: m.d,
+            b: -m.b,
+            c: -m.c,
+            d: m.a,
+            e: -m.e * m.d + m.c * m.f,
+            f: m.e * m.b - m.a * m.f
+        }, invdet);
+    }
+    static toComponents(m, transformOrigin = { x: 0, y: 0 }) {
+        const scaleX = Math.sqrt(m.a * m.a + m.c * m.c);
+        const scaleY = Math.sqrt(m.b * m.b + m.d * m.d);
+        const cos = scaleX != 0 ? m.a / scaleX : 0;
+        const sin = scaleX != 0 ? m.c / scaleX : 0;
+        const rotation = Math.atan2(sin, cos);
+        const { x: px, y: py } = transformOrigin;
+        const translation = {
+            x: m.e - px * (scaleX * cos - 1) + py * scaleX * sin,
+            y: m.f - py * (scaleY * cos - 1) - px * scaleY * sin,
+        };
+        return {
+            scaleX, scaleY, rotation,
+            translation
+        };
+    }
+    /**
+     * Returns the matrix that transforms the triangle defined by the points p0, p1, p2 into the triangle defined by the points q0, q1, q2.
+     * @param param0 Triangle defined by the points p0, p1, p2 (before transformation).
+     * @param param1 Triangle defined by the points q0, q1, q2 (after transformation).
+     * @returns Transformation matrix.
+     */
+    static fromTransform([p0, p1, p2], [q0, q1, q2]) {
+        const det = p0.x * (p1.y - p2.y) -
+            p0.y * (p1.x - p2.x) +
+            (p1.x * p2.y - p2.x * p1.y);
+        if (Math.abs(det) < 1e-10) {
+            throw new Error("Points are collinear; matrix is singular and cannot be solved.");
+        }
+        const idet = 1 / det;
+        // Matrix inversion of the 3x3 augmented source points
+        // then multiplied by the destination points to get rows 1 and 2
+        return {
+            a: idet * (q0.x * (p1.y - p2.y) + q1.x * (p2.y - p0.y) + q2.x * (p0.y - p1.y)),
+            b: idet * (q0.y * (p1.y - p2.y) + q1.y * (p2.y - p0.y) + q2.y * (p0.y - p1.y)),
+            c: idet * (q0.x * (p2.x - p1.x) + q1.x * (p0.x - p2.x) + q2.x * (p1.x - p0.x)),
+            d: idet * (q0.y * (p2.x - p1.x) + q1.y * (p0.x - p2.x) + q2.y * (p1.x - p0.x)),
+            e: idet * (q0.x * (p1.x * p2.y - p2.x * p1.y) +
+                q1.x * (p2.x * p0.y - p0.x * p2.y) +
+                q2.x * (p0.x * p1.y - p1.x * p0.y)),
+            f: idet * (q0.y * (p1.x * p2.y - p2.x * p1.y) +
+                q1.y * (p2.x * p0.y - p0.x * p2.y) +
+                q2.y * (p0.x * p1.y - p1.x * p0.y))
+        };
+    }
+    /**
+     * Returns whether two matrices are equal to each other, within a certain precision (number of decimal digits).
+     * @param m1
+     * @param m2
+     * @param precision
+     * @returns
+     */
+    static areClose(m1, m2, precision = 12) {
+        return m1.a.isCloseTo(m2.a, precision)
+            && m1.b.isCloseTo(m2.b, precision)
+            && m1.c.isCloseTo(m2.c, precision)
+            && m1.d.isCloseTo(m2.d, precision)
+            && m1.e.isCloseTo(m2.e, precision)
+            && m1.f.isCloseTo(m2.f, precision);
+    }
+}
+// }

package/dist/esm/null-checker.js

@@ -0,0 +1,23 @@
+/// <reference path="dates.ts" />
+import { Dates } from "./dates";
+// namespace Pacem {
+export class NullChecker {
+    static isNull(o) {
+        return o === null || o === void 0;
+    }
+    static isEmpty(o) {
+        try {
+            return (Array.isArray(o) && o.length === 0)
+                || (typeof o === 'string' && o === '')
+                || (typeof o === 'object' && Object.keys(o).length === 0 && !Dates.isDate(o) && !(o instanceof RegExp) && !(o instanceof FileSystemDirectoryHandle) && !(o instanceof FileSystemFileHandle));
+        }
+        catch (e) {
+            // Object.keys(null) would throw...
+            return false;
+        }
+    }
+    static isNullOrEmpty(o) {
+        return NullChecker.isNull(o) || NullChecker.isEmpty(o);
+    }
+}
+//}

package/dist/esm/number-extensions.js

@@ -0,0 +1,33 @@
+Number.prototype.isCloseTo = function (other, precision = 14) {
+    const delta = Number(`1e-${precision}`);
+    return this > (other - delta) && this < (other + delta);
+    //return this.toFixed(precision) === other.toFixed(precision);  
+};
+Number.prototype.roundoff = function (precision = 14) {
+    return parseFloat(this.toFixed(precision));
+};
+Number.prototype.clamp = function (min, max) {
+    let value = this;
+    if (min != null && !isNaN(min)) {
+        value = Math.max(value, min);
+    }
+    if (max != null && !isNaN(max)) {
+        value = Math.min(value, max);
+    }
+    return value;
+};
+Number.prototype.toBase62 = function () {
+    var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    var temp = this;
+    var sb = '';
+    while (temp != 0) {
+        var mod = temp % 62;
+        sb = alphabet.charAt(mod) + sb;
+        temp = Math.floor(temp / 62);
+    }
+    return sb;
+};
+Number.prototype.toBase36 = function () {
+    return this.toString(36);
+};
+export {};

package/dist/esm/numbers.js

@@ -0,0 +1,18 @@
+// namespace Pacem {
+export class Numbers {
+    static round(x, step = 1.0) {
+        return Math.round(x / step) * step;
+    }
+    static log(x, base) {
+        return Math.log10(x) / Math.log10(base);
+    }
+    static rebase(v, from, to) {
+        const vStr = v.toString();
+        const firstPass = parseInt(vStr, from);
+        if (!vStr.endsWith(firstPass.toString(from))) {
+            return Number.NaN.toString();
+        }
+        return parseInt(v.toString(), from).toString(to);
+    }
+}
+//}

package/dist/esm/rect.js

@@ -0,0 +1,128 @@
+import { Matrix2D } from './matrix2d';
+import { parseAsNumericalArray, Point, Size } from "./geom";
+export class Rect {
+    static parse(rect) {
+        let arr = parseAsNumericalArray(rect);
+        if (arr && arr.length === 4) {
+            return { x: arr[0], y: arr[1], width: arr[2], height: arr[3] };
+        }
+        throw new Error(`Cannot parse "${rect}" as a valid Rect.`);
+    }
+    static isRect(obj) {
+        return Point.isPoint(obj) && Size.isSize(obj);
+    }
+    static _stretch(from, to) {
+        return { a: to.width / from.width, b: 0, c: 0, d: to.height / from.height, e: to.x - from.x, f: to.y - from.y };
+    }
+    static _contain(from, to, align, valign) {
+        let scale = 1;
+        const fromRatio = from.width / from.height, toRatio = to.width / to.height;
+        if (fromRatio >= toRatio) {
+            // constraining width
+            scale = to.width / from.width;
+        }
+        else {
+            // constraining height
+            scale = to.height / from.height;
+        }
+        const w = from.width * scale, h = from.height * scale;
+        const translation = this._align({ x: from.x, y: from.y, width: w, height: h }, to, align, valign);
+        return Matrix2D.translate({ a: scale, b: 0, c: 0, d: scale, e: 0, f: 0 }, translation);
+    }
+    static _cover(from, to, align, valign) {
+        let scale = 1;
+        const fromRatio = from.width / from.height, toRatio = to.width / to.height;
+        if (fromRatio < toRatio) {
+            // constraining width
+            scale = to.width / from.width;
+        }
+        else {
+            // constraining height
+            scale = to.height / from.height;
+        }
+        const w = from.width * scale, h = from.height * scale;
+        const translation = this._align({ x: from.x, y: from.y, width: w, height: h }, to, align, valign);
+        return Matrix2D.translate({ a: scale, b: 0, c: 0, d: scale, e: 0, f: 0 }, translation);
+    }
+    static _align(from, to, align, valign) {
+        let x = 0, y = 0;
+        switch (align) {
+            case 'left':
+                x = to.x - from.x;
+                break;
+            case 'right':
+                x = (to.x + to.width - from.width) - from.x;
+                break;
+            default:
+                x = (to.x + to.width * .5 - from.width * .5) - from.x;
+                break;
+        }
+        switch (valign) {
+            case 'top':
+                y = to.y - from.y;
+                break;
+            case 'bottom':
+                y = (to.y + to.height - from.height) - from.y;
+                break;
+            default:
+                y = (to.y + to.height * .5 - from.height * .5) - from.y;
+                break;
+        }
+        return { x, y };
+    }
+    /**
+     * Computes the 2D matrix that transforms one rect into another.
+     * @param a Rect from
+     * @param b Rect to
+     * @param mode Transformation mode
+     * @param align Horizontal alignment
+     * @param valign Vertical alignment
+     */
+    static findTransform(a, b, mode = 'stretch', align = 'center', valign = 'middle') {
+        switch (mode) {
+            case 'contain':
+                return this._contain(a, b, align, valign);
+            case 'cover':
+                return this._cover(a, b, align, valign);
+            default:
+                return this._stretch(a, b);
+        }
+    }
+    /**
+     * Computes the intersection rect among a set of provided rects.
+     * @param rects Rects to intersect
+     */
+    static intersect(...rects) {
+        const empty = { x: 0, y: 0, height: 0, width: 0 }, arr = Array.from(rects || []);
+        if (arr.length <= 0) {
+            return empty;
+        }
+        var rect = arr[0];
+        for (var i = 1; i < arr.length; i++) {
+            const r = arr[i];
+            const x = Math.max(r.x, rect.x), y = Math.max(r.y, rect.y), xw = Math.min(r.x + r.width, rect.x + rect.width), xh = Math.min(r.y + r.height, rect.y + rect.height), w = xw - x, h = xh - y;
+            if (w < 0 || h <= 0) {
+                // no intersection
+                return empty;
+            }
+            rect = { x: x, y: y, width: w, height: h };
+        }
+        return rect;
+    }
+    static expand(rect, ...args) {
+        const arr = Array.from(args || []);
+        let x0 = rect.x, y0 = rect.y, x1 = x0, y1 = y0;
+        if (Rect.isRect(rect)) {
+            x1 += rect.width;
+            y1 += rect.height;
+        }
+        for (let p of arr) {
+            x0 = Math.min(p.x, x0);
+            y0 = Math.min(p.y, y0);
+            x1 = Math.max(p.x, x1);
+            y1 = Math.max(p.y, y1);
+        }
+        return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+    }
+}
+//}

package/dist/esm/strings.js

@@ -0,0 +1,184 @@
+// namespace Pacem {
+import { NullChecker } from "./null-checker";
+/**
+ * Computes the Longest Common Subsequence (LCS) table for two arrays of strings.
+ * @param aTokens Array of strings from the first input.
+ * @param bTokens Array of strings from the second input.
+ * @returns The DP table for LCS lengths.
+ */
+function lcs(aTokens, bTokens) {
+    const m = aTokens.length;
+    const n = bTokens.length;
+    // Initialize DP table with zeros
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    // Fill DP table
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (aTokens[i - 1] === bTokens[j - 1]) {
+                // Tokens match, increment LCS length
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                // Tokens don't match, take max length from previous states
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp;
+}
+/**
+ * Internal diff implementation using backtracking on the LCS DP table.
+ * Works on token arrays (characters, words, lines).
+ * @param aTokens Array of strings from the first input.
+ * @param bTokens Array of strings from the second input.
+ * @param dp The precomputed LCS DP table.
+ * @param joiner The string to use when joining tokens of the same type (e.g., "" for chars, "\n" for lines).
+ * For word diffing, joiner is effectively "" because whitespace is part of the tokens.
+ * @returns An array of DiffTokens representing the differences.
+ */
+function diffInternal(aTokens, bTokens, dp, joiner = '') {
+    const m = aTokens.length;
+    const n = bTokens.length;
+    const result = [];
+    let i = m, j = n;
+    let currentToken = null;
+    const finalizeToken = () => {
+        if (currentToken) {
+            result.push(currentToken);
+            currentToken = null;
+        }
+    };
+    // Backtrack through the DP table
+    while (i > 0 || j > 0) { // Continue until both sequences are fully processed
+        var currentType = null;
+        let currentValue = null;
+        if (i > 0 && j > 0 && aTokens[i - 1] === bTokens[j - 1]) {
+            // Common token
+            currentType = '=';
+            currentValue = aTokens[i - 1];
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            // Token added in b
+            currentType = '+';
+            currentValue = bTokens[j - 1];
+            j--;
+        }
+        else if (i > 0 && (j === 0 || dp[i - 1][j] > dp[i][j - 1])) {
+            // Token removed from a
+            currentType = '-';
+            currentValue = aTokens[i - 1];
+            i--;
+        }
+        if (currentType && currentValue !== null) {
+            if (currentToken && currentToken.type === currentType) {
+                // Prepend the value to the existing token
+                currentToken.value = currentValue + (currentToken.value ? joiner : '') + currentToken.value;
+            }
+            else {
+                // Finalize the previous token (if different type) and start a new one
+                finalizeToken();
+                currentToken = { type: currentType, value: currentValue };
+            }
+        }
+        else {
+            // Should not happen in standard LCS backtracking, but finalize just in case
+            finalizeToken();
+        }
+    }
+    finalizeToken(); // Add the last accumulated token
+    return result.reverse(); // Reverse to get the correct order
+}
+/**
+* Performs character-level diffing.
+* @param a The first string.
+* @param b The second string.
+* @returns An array of DiffTokens.
+*/
+function diffChars(a, b) {
+    const aTokens = a.split(''); // Split into characters
+    const bTokens = b.split(''); // Split into characters
+    const dp = lcs(aTokens, bTokens);
+    // No joiner needed as characters are concatenated directly
+    return diffInternal(aTokens, bTokens, dp, '');
+}
+/**
+ * Performs word-level diffing, preserving whitespace and line breaks.
+ * It tokenizes based on sequences of non-whitespace (\S+) or whitespace (\s+).
+ * @param a The first string.
+ * @param b The second string.
+ * @returns An array of DiffTokens.
+ */
+function diffWords(a, b) {
+    // Tokenize into words (\S+) and whitespace/newlines (\s+)
+    // This preserves the original spacing and line breaks.
+    const wordRegex = /(\S+|\s+)/g;
+    const aTokens = a.match(wordRegex) || [];
+    const bTokens = b.match(wordRegex) || [];
+    const dp = lcs(aTokens, bTokens);
+    // No joiner needed; whitespace tokens handle spacing.
+    return diffInternal(aTokens, bTokens, dp, '');
+}
+/**
+ * Performs line-level diffing.
+ * @param a The first string.
+ * @param b The second string.
+ * @returns An array of DiffTokens where each token's value can contain multiple lines.
+ */
+function diffLines(a, b) {
+    // Split by newline characters, keeping the EOL character concept separate
+    // The result of split does not contain the separators themselves.
+    const lineRegex = /\r?\n/;
+    const aTokens = a.split(lineRegex);
+    const bTokens = b.split(lineRegex);
+    // Handle potential empty string added by split if text ends with a newline
+    // (This behavior is often desired, representing an empty line after the last newline)
+    // Example: "a\nb\n".split(/\n/) -> ["a", "b", ""]
+    const dp = lcs(aTokens, bTokens);
+    // Join consecutive lines of the same type with newline characters
+    return diffInternal(aTokens, bTokens, dp, '\n');
+}
+//#endregion
+export class Strings {
+    /** @deprecated Use String.prototype.padStart() instead. */
+    static leftPad(v, targetLength, padChar) {
+        let retval = v.toString();
+        return retval.padStart(targetLength, padChar);
+        //while (retval.length < targetLength)
+        //    retval = padChar + retval;
+        //return retval;
+    }
+    static format(template, ...args) {
+        const array = Array.from(args);
+        let retval = template;
+        for (let j = 0; j < array.length; j++) {
+            const regex = new RegExp('(^|[^\\{])\\{' + j + '\\}($|[^\\}])', 'g');
+            retval = retval.replaceAll(regex, (match, ...args0) => {
+                return match.replace('{' + j + '}', array[j]);
+            });
+        }
+        const check = /(^|[^\{}])\{(\d+)\}($|[^\}])/.exec(retval);
+        if (!NullChecker.isNullOrEmpty(check)) {
+            throw new Error(`Missing argument at index ${check[2]}.`);
+        }
+        return retval;
+    }
+    static diff(a, b, mode = 'char') {
+        switch (mode) {
+            case 'line':
+                return diffLines(a, b);
+            case 'word':
+                return diffWords(a, b);
+            default:
+                return diffChars(a, b);
+        }
+    }
+    static async hash(input, algo = 'SHA-256') {
+        const hashBuffer = await crypto.subtle.digest(algo, new TextEncoder().encode(input));
+        return Array.from(new Uint8Array(hashBuffer))
+            .map(byte => byte.toString(16).padStart(2, '0'))
+            .join('');
+    }
+}
+// }

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@pacem/pacem-foundation",
+  "files": [
+    "dist/browser/*.*",
+    "dist/bundle/*.*",
+    "dist/esm/*.*",
+    "typings/*.*",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "package.json"
+  ],
+  "type": "module",
+  "main": "./dist/esm/index.js",
+  "module": "./dist/esm/index.js",
+  "typings": "./typings/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "types": "./typings/index.d.ts"
+    },
+    "./bundle": {
+      "import": "./dist/bundle/pacem-foundation.mjs",
+      "types": "./typings/index.d.ts"
+    }
+  },
+  "version": "1.0.0-abel",
+  "author": {
+    "name": "Pacem",
+    "url": "https://pacem.it"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://js.pacem.it",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pacem-it/pacem.git"
+  }
+}