@xlabs-store/core 0.0.1

package/dist/collection/utils/form/frameworks.js

@@ -0,0 +1,37 @@
+/**
+ * React Hook for using AbstractControl in functional components
+ * Syncs value and status changes with React's re-render cycle
+ *
+ * Usage:
+ *   const form = useForm(fb.group({ ... }));
+ *   return <input value={form.controls.email.value} onChange={(e) => form.controls.email.setValue(e.target.value)} />
+ */
+export function useForm(control) {
+    const react = require('react');
+    const [, forceUpdate] = react.useState(0);
+    react.useEffect(() => {
+        const unsubValues = control.valueChanges(() => forceUpdate((s) => s + 1));
+        const unsubStatus = control.statusChanges(() => forceUpdate((s) => s + 1));
+        return () => {
+            unsubValues();
+            unsubStatus();
+        };
+    }, [control]);
+    return control;
+}
+/**
+ * Vue Composable for using AbstractControl in Setup API
+ * Converts AbstractControl into a reactive-like object
+ */
+export function useVueForm(control) {
+    const vue = require('vue');
+    const state = vue.reactive({
+        valueChange: 0
+    });
+    control.valueChanges(() => { state.valueChange++; });
+    control.statusChanges(() => { state.valueChange++; });
+    return control;
+}
+/**
+ * Angular adapter is built-in as the API matches 1:1
+ */

package/dist/collection/utils/form/types.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/utils/form/validators/validators.js

@@ -0,0 +1,198 @@
+const EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+/**
+ * Validators — Mirrors Angular's Validators class 100%
+ * All built-in validators + compose utilities
+ */
+export class Validators {
+    // ─── Built-in Validators ─────────────────────────────────────
+    static required(control) {
+        const v = control.value;
+        if (v === null || v === undefined || v === '' || (Array.isArray(v) && v.length === 0)) {
+            return { required: true };
+        }
+        return null;
+    }
+    static requiredTrue(control) {
+        return control.value === true ? null : { required: true };
+    }
+    static email(control) {
+        if (!control.value)
+            return null;
+        return EMAIL_REGEXP.test(control.value) ? null : { email: true };
+    }
+    static minLength(minLength) {
+        return (control) => {
+            if (!control.value)
+                return null;
+            const length = control.value.length ?? 0;
+            return length < minLength
+                ? { minlength: { requiredLength: minLength, actualLength: length } }
+                : null;
+        };
+    }
+    static maxLength(maxLength) {
+        return (control) => {
+            if (!control.value)
+                return null;
+            const length = control.value.length ?? 0;
+            return length > maxLength
+                ? { maxlength: { requiredLength: maxLength, actualLength: length } }
+                : null;
+        };
+    }
+    static min(min) {
+        return (control) => {
+            if (control.value === null || control.value === '')
+                return null;
+            const v = parseFloat(control.value);
+            return !isNaN(v) && v < min ? { min: { min, actual: v } } : null;
+        };
+    }
+    static max(max) {
+        return (control) => {
+            if (control.value === null || control.value === '')
+                return null;
+            const v = parseFloat(control.value);
+            return !isNaN(v) && v > max ? { max: { max, actual: v } } : null;
+        };
+    }
+    static pattern(pattern) {
+        if (!pattern)
+            return Validators.nullValidator;
+        let regex;
+        let regexStr;
+        if (typeof pattern === 'string') {
+            regexStr = pattern.charAt(0) === '^' ? pattern : `^${pattern}$`;
+            regex = new RegExp(regexStr);
+        }
+        else {
+            regexStr = pattern.toString();
+            regex = pattern;
+        }
+        return (control) => {
+            if (!control.value)
+                return null;
+            return regex.test(control.value)
+                ? null
+                : { pattern: { requiredPattern: regexStr, actualValue: control.value } };
+        };
+    }
+    static nullValidator(_control) {
+        return null;
+    }
+    // ─── Custom Validators ────────────────────────────────────────
+    static url(control) {
+        if (!control.value)
+            return null;
+        try {
+            new URL(control.value);
+            return null;
+        }
+        catch {
+            return { url: true };
+        }
+    }
+    static integer(control) {
+        if (!control.value && control.value !== 0)
+            return null;
+        return Number.isInteger(Number(control.value)) ? null : { integer: true };
+    }
+    static numeric(control) {
+        if (!control.value && control.value !== 0)
+            return null;
+        return isNaN(Number(control.value)) ? { numeric: true } : null;
+    }
+    static whitespace(control) {
+        if (!control.value)
+            return null;
+        const isWhitespace = (control.value || '').trim().length === 0;
+        return isWhitespace ? { whitespace: true } : null;
+    }
+    static range(min, max) {
+        return (control) => {
+            if (!control.value && control.value !== 0)
+                return null;
+            const v = Number(control.value);
+            if (isNaN(v))
+                return { range: { min, max, actual: control.value } };
+            return v >= min && v <= max ? null : { range: { min, max, actual: v } };
+        };
+    }
+    /**
+     * Validates that password and confirmPassword match
+     */
+    static mustMatch(controlName, matchingControlName) {
+        return (group) => {
+            const control = group.get(controlName);
+            const matching = group.get(matchingControlName);
+            if (!control || !matching)
+                return null;
+            if (matching.errors && !matching.errors['mustMatch'])
+                return null;
+            if (control.value !== matching.value) {
+                matching.setErrors({ mustMatch: true });
+                return { mustMatch: true };
+            }
+            else {
+                matching.setErrors(null);
+                return null;
+            }
+        };
+    }
+    // ─── Compose Utilities ────────────────────────────────────────
+    /**
+     * Compose multiple validators into one (stops at first error OR merges all)
+     */
+    static compose(validators) {
+        if (!validators)
+            return null;
+        const presentValidators = validators.filter(v => v != null);
+        if (presentValidators.length === 0)
+            return null;
+        return (control) => {
+            const errors = mergeErrors(executeValidators(control, presentValidators));
+            return errors ? errors : null;
+        };
+    }
+    /**
+     * Compose async validators
+     */
+    static composeAsync(validators) {
+        if (!validators)
+            return null;
+        const presentValidators = validators.filter(v => v != null);
+        if (presentValidators.length === 0)
+            return null;
+        return (control) => {
+            const promises = presentValidators.map(v => v(control));
+            return Promise.all(promises).then(errors => mergeErrors(errors));
+        };
+    }
+    // ─── Async Validator Factories ────────────────────────────────
+    /**
+     * Creates an async validator that checks uniqueness via a custom check fn
+     * Example: Validators.uniqueAsync(async (v) => await checkEmailExists(v))
+     */
+    static uniqueAsync(checkFn) {
+        return async (control) => {
+            if (!control.value)
+                return null;
+            const exists = await checkFn(control.value);
+            return exists ? { unique: true } : null;
+        };
+    }
+}
+function executeValidators(control, validators) {
+    return validators.map(v => v(control));
+}
+function mergeErrors(arrayOfErrors) {
+    const res = {};
+    let hasError = false;
+    arrayOfErrors.forEach(errors => {
+        if (errors) {
+            Object.assign(res, errors);
+            hasError = true;
+        }
+    });
+    return hasError ? res : null;
+}

package/dist/collection/utils/index.js

@@ -0,0 +1,3 @@
+export * from './tree.service';
+export * from './cascader.service';
+export * from './table.service';

package/dist/collection/utils/qr-code/cache/qr.cache.js

@@ -0,0 +1,20 @@
+export class QRCache {
+    map = new Map();
+    max = 100;
+    get(k) {
+        if (!this.map.has(k))
+            return;
+        const v = this.map.get(k);
+        this.map.delete(k);
+        this.map.set(k, v);
+        return v;
+    }
+    set(k, v) {
+        if (this.map.size >= this.max) {
+            const f = this.map.keys().next().value;
+            this.map.delete(f);
+        }
+        this.map.set(k, v);
+    }
+}
+export const qrCache = new QRCache();

package/dist/collection/utils/qr-code/engine/qr.engine.js

@@ -0,0 +1,130 @@
+import { getVersion } from "./qr.version";
+import { reedSolomon } from "./qr.rs";
+import { applyMask, score } from "./qr.mask";
+export class QREngine {
+    data;
+    ec;
+    size;
+    matrix;
+    reserved;
+    constructor(data, ec = 'M') {
+        this.data = data;
+        this.ec = ec;
+        const v = getVersion(data.length, ec);
+        this.size = 21 + (v - 1) * 4;
+        this.matrix = Array.from({ length: this.size }, () => Array(this.size).fill(0));
+        this.reserved = Array.from({ length: this.size }, () => Array(this.size).fill(false));
+    }
+    set(x, y, v) {
+        this.matrix[y][x] = v;
+        this.reserved[y][x] = true;
+    }
+    patterns() {
+        const drawFinder = (x, y) => {
+            for (let r = -1; r <= 7; r++) {
+                for (let c = -1; c <= 7; c++) {
+                    const row = y + r, col = x + c;
+                    if (row >= 0 && row < this.size && col >= 0 && col < this.size) {
+                        const v = (r === 0 || r === 6 || c === 0 || c === 6 || (r >= 2 && r <= 4 && c >= 2 && c <= 4)) ? 1 : 0;
+                        this.set(col, row, v);
+                    }
+                }
+            }
+        };
+        drawFinder(0, 0);
+        drawFinder(this.size - 7, 0);
+        drawFinder(0, this.size - 7);
+        for (let i = 8; i < this.size - 8; i++) {
+            this.set(i, 6, i % 2 === 0 ? 1 : 0);
+            this.set(6, i, i % 2 === 0 ? 1 : 0);
+        }
+        this.set(8, this.size - 8, 1);
+    }
+    formatInfo(mask) {
+        const ech = { 'L': 1, 'M': 0, 'Q': 3, 'H': 2 };
+        let bits = (ech[this.ec] << 3) | mask;
+        let rem = bits;
+        for (let i = 0; i < 10; i++)
+            rem = (rem << 1) ^ ((rem >> 9) ? 0x537 : 0);
+        let data = ((bits << 10) | rem) ^ 0x5412;
+        for (let i = 0; i < 15; i++) {
+            const v = (data >> i) & 1;
+            if (i < 6)
+                this.matrix[i][8] = v;
+            else if (i < 8)
+                this.matrix[i + 1][8] = v;
+            else
+                this.matrix[this.size - 15 + i][8] = v;
+            if (i < 8)
+                this.matrix[8][this.size - 1 - i] = v;
+            else if (i < 9)
+                this.matrix[8][15 - i + 7 - 1] = v;
+            else
+                this.matrix[8][15 - i - 1] = v;
+        }
+    }
+    encode() {
+        const bits = [];
+        bits.push(0, 1, 0, 0);
+        for (let i = 7; i >= 0; i--)
+            bits.push((this.data.length >> i) & 1);
+        new TextEncoder().encode(this.data).forEach(b => {
+            for (let i = 7; i >= 0; i--)
+                bits.push((b >> i) & 1);
+        });
+        return bits;
+    }
+    place(bits) {
+        let col = this.size - 1, row = this.size - 1, dir = -1, i = 0;
+        while (col > 0) {
+            if (col === 6)
+                col--;
+            for (let r = 0; r < this.size; r++) {
+                let y = row + dir * r;
+                if (y < 0 || y >= this.size)
+                    continue;
+                for (let j = 0; j < 2; j++) {
+                    let x = col - j;
+                    if (this.reserved[y][x])
+                        continue;
+                    this.matrix[y][x] = bits[i++] || 0;
+                }
+            }
+            col -= 2;
+            dir *= -1;
+        }
+    }
+    build() {
+        this.patterns();
+        const bits = this.encode();
+        const bytes = [];
+        for (let i = 0; i < bits.length; i += 8) {
+            let b = 0;
+            for (let j = 0; j < 8; j++)
+                b = (b << 1) | (bits[i + j] || 0);
+            bytes.push(b);
+        }
+        const ecCount = { 1: { L: 7, M: 10, Q: 13, H: 17 }, 2: { L: 10, M: 16, Q: 22, H: 28 } }[this.size === 21 ? 1 : 2][this.ec];
+        const ec = reedSolomon(bytes, ecCount);
+        const full = [...bytes, ...ec];
+        const fullBits = [];
+        full.forEach(b => {
+            for (let i = 7; i >= 0; i--)
+                fullBits.push((b >> i) & 1);
+        });
+        this.place(fullBits);
+        let bestScore = 1000000, best = this.matrix;
+        for (let m = 0; m < 8; m++) {
+            const temp = this.matrix.map(r => [...r]);
+            applyMask(temp, this.reserved, m);
+            this.matrix = temp; // temporary for formatInfo
+            this.formatInfo(m);
+            const s = score(temp);
+            if (s < bestScore) {
+                bestScore = s;
+                best = this.matrix.map(r => [...r]);
+            }
+        }
+        return best;
+    }
+}

package/dist/collection/utils/qr-code/engine/qr.gf.js

@@ -0,0 +1,22 @@
+export const GF_EXP = new Array(512);
+export const GF_LOG = new Array(256);
+(function init() {
+    let x = 1;
+    for (let i = 0; i < 256; i++) {
+        GF_EXP[i] = x;
+        GF_LOG[x] = i;
+        x <<= 1;
+        if (x & 0x100)
+            x ^= 0x11d;
+    }
+    for (let i = 256; i < 512; i++)
+        GF_EXP[i] = GF_EXP[i - 256];
+})();
+export function gfMul(x, y) {
+    if (x === 0 || y === 0)
+        return 0;
+    return GF_EXP[GF_LOG[x] + GF_LOG[y]];
+}
+export function gfPow(x, y) {
+    return GF_EXP[(GF_LOG[x] * y) % 255];
+}

package/dist/collection/utils/qr-code/engine/qr.mask.js

@@ -0,0 +1,54 @@
+export function applyMask(matrix, reserved, mask) {
+    const n = matrix.length;
+    for (let y = 0; y < n; y++) {
+        for (let x = 0; x < n; x++) {
+            if (reserved[y][x])
+                continue;
+            let cond = false;
+            switch (mask) {
+                case 0:
+                    cond = (x + y) % 2 === 0;
+                    break;
+                case 1:
+                    cond = y % 2 === 0;
+                    break;
+                case 2:
+                    cond = x % 3 === 0;
+                    break;
+                case 3:
+                    cond = (x + y) % 3 === 0;
+                    break;
+                case 4:
+                    cond = (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0;
+                    break;
+                case 5:
+                    cond = (x * y) % 2 + (x * y) % 3 === 0;
+                    break;
+                case 6:
+                    cond = ((x * y) % 2 + (x * y) % 3) % 2 === 0;
+                    break;
+                case 7:
+                    cond = ((x * y) % 3 + (x + y) % 2) % 2 === 0;
+                    break;
+            }
+            if (cond)
+                matrix[y][x] ^= 1;
+        }
+    }
+}
+export function score(m) {
+    const n = m.length;
+    // Penalty N1 & N2 omitted for brevity, but let's at least check balance
+    let blocks = 0;
+    for (let y = 0; y < n - 1; y++)
+        for (let x = 0; x < n - 1; x++)
+            if (m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1])
+                blocks++;
+    let dark = 0;
+    for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++)
+            if (m[y][x])
+                dark++;
+    const ratio = Math.abs(dark / (n * n) - 0.5) * 20;
+    return blocks * 3 + ratio * 10;
+}

package/dist/collection/utils/qr-code/engine/qr.rs.js

@@ -0,0 +1,29 @@
+import { gfMul, GF_EXP } from "./qr.gf";
+const POLYS = {};
+function getPoly(n) {
+    if (POLYS[n])
+        return POLYS[n];
+    let p = [1];
+    for (let i = 0; i < n; i++) {
+        const next = new Array(p.length + 1).fill(0);
+        for (let j = 0; j < p.length; j++) {
+            next[j] ^= gfMul(p[j], GF_EXP[i]);
+            next[j + 1] ^= p[j];
+        }
+        p = next;
+    }
+    return POLYS[n] = p;
+}
+export function reedSolomon(data, ecCount) {
+    const poly = getPoly(ecCount);
+    const res = [...data, ...new Array(ecCount).fill(0)];
+    for (let i = 0; i < data.length; i++) {
+        const factor = res[i];
+        if (factor !== 0) {
+            for (let j = 0; j < poly.length; j++) {
+                res[i + j] ^= gfMul(poly[j], factor);
+            }
+        }
+    }
+    return res.slice(data.length);
+}

package/dist/collection/utils/qr-code/engine/qr.version.js

@@ -0,0 +1,11 @@
+export const CAP = {
+    1: { L: 17, M: 14, Q: 11, H: 7 },
+    2: { L: 32, M: 26, Q: 20, H: 14 },
+};
+export function getVersion(len, ec) {
+    for (let v in CAP) {
+        if (len <= CAP[v][ec])
+            return Number(v);
+    }
+    return 1;
+}

package/dist/collection/utils/qr-code/renderer/canvas.renderer.js

@@ -0,0 +1,36 @@
+export async function renderCanvas(canvas, matrix, size, options = {}) {
+    const { logo, color = '#000', bgColor = '#fff' } = options;
+    const ctx = canvas.getContext('2d');
+    const n = matrix.length;
+    const cell = size / n;
+    canvas.width = size;
+    canvas.height = size;
+    // Draw background
+    ctx.fillStyle = bgColor;
+    ctx.fillRect(0, 0, size, size);
+    // Draw QR cells
+    ctx.fillStyle = color;
+    for (let y = 0; y < n; y++) {
+        for (let x = 0; x < n; x++) {
+            if (matrix[y][x]) {
+                // Use floor/ceil to avoid sub-pixel gaps
+                ctx.fillRect(Math.floor(x * cell), Math.floor(y * cell), Math.ceil(cell), Math.ceil(cell));
+            }
+        }
+    }
+    // Draw logo
+    if (logo) {
+        const img = new Image();
+        img.src = logo;
+        await new Promise((resolve, reject) => {
+            img.onload = resolve;
+            img.onerror = reject;
+        });
+        const logoSize = size * 0.2;
+        const pos = (size - logoSize) / 2;
+        // Clear area behind logo
+        ctx.fillStyle = bgColor;
+        ctx.fillRect(pos - 2, pos - 2, logoSize + 4, logoSize + 4);
+        ctx.drawImage(img, pos, pos, logoSize, logoSize);
+    }
+}

package/dist/collection/utils/qr-code/renderer/svg.renderer.js

@@ -0,0 +1,33 @@
+export function renderSVG(matrix, size, options = {}) {
+    const { gradient, logo, color = '#000', bgColor = '#fff' } = options;
+    const n = matrix.length;
+    const cell = size / n;
+    let path = '';
+    for (let y = 0; y < n; y++) {
+        for (let x = 0; x < n; x++) {
+            if (matrix[y][x]) {
+                path += `M${x * cell},${y * cell}h${cell}v${cell}h-${cell}z `;
+            }
+        }
+    }
+    const id = `qr-grad-${Math.random().toString(36).substr(2, 9)}`;
+    let svg = `<svg width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" xmlns="http://www.w3.org/2000/svg">`;
+    if (gradient) {
+        svg += `
+      <defs>
+        <linearGradient id="${id}" x1="0%" y1="0%" x2="100%" y2="100%">
+          <stop offset="0%" stop-color="#4f46e5" />
+          <stop offset="100%" stop-color="#9333ea" />
+        </linearGradient>
+      </defs>`;
+    }
+    svg += `<rect width="100%" height="100%" fill="${bgColor}"/>`;
+    svg += `<path d="${path.trim()}" fill="${gradient ? `url(#${id})` : color}"/>`;
+    if (logo) {
+        const logoSize = size * 0.2;
+        const pos = (size - logoSize) / 2;
+        svg += `<image href="${logo}" x="${pos}" y="${pos}" width="${logoSize}" height="${logoSize}" />`;
+    }
+    svg += `</svg>`;
+    return svg;
+}

package/dist/collection/utils/qr-code/worker/worker.manager.js

@@ -0,0 +1,24 @@
+import { QREngine } from "../engine/qr.engine";
+export class QRWorkerManager {
+    static instance;
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    constructor() { }
+    static getInstance() {
+        if (!QRWorkerManager.instance) {
+            QRWorkerManager.instance = new QRWorkerManager();
+        }
+        return QRWorkerManager.instance;
+    }
+    /**
+     * Generates a QR matrix.
+     * Note: Worker support has been removed to ensure compatibility across all platforms.
+     */
+    async generate(value, ec) {
+        const qr = new QREngine(value, ec);
+        return qr.build();
+    }
+    terminate() {
+        // No-op: Worker support removed
+    }
+}
+export const qrWorkerManager = QRWorkerManager.getInstance();