@r2digisolutions/components 0.1.1

package/dist/utils/advancedFilters.js

@@ -0,0 +1,384 @@
+/** Advanced filter query tree: operators, value kinds, groups, serialize. */
+export const FILTER_OPERATORS = [
+    'eq',
+    'neq',
+    'in',
+    'nin',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'contains',
+    'not_contains',
+    'starts_with',
+    'ends_with',
+    'between',
+    'is_empty',
+    'is_not_empty',
+    'exists',
+    'not_exists'
+];
+export const OP_LABELS = {
+    eq: 'is',
+    neq: 'is not',
+    in: 'is one of',
+    nin: 'is not one of',
+    gt: '>',
+    gte: '≥',
+    lt: '<',
+    lte: '≤',
+    contains: 'contains',
+    not_contains: 'does not contain',
+    starts_with: 'starts with',
+    ends_with: 'ends with',
+    between: 'between',
+    is_empty: 'is empty',
+    is_not_empty: 'is not empty',
+    exists: 'exists',
+    not_exists: 'does not exist'
+};
+export const DEFAULT_OPS = {
+    text: ['eq', 'neq', 'contains', 'not_contains', 'starts_with', 'ends_with', 'is_empty', 'is_not_empty'],
+    number: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'between', 'is_empty', 'is_not_empty'],
+    select: ['eq', 'neq', 'in', 'nin', 'is_empty', 'is_not_empty'],
+    multiselect: ['in', 'nin', 'is_empty', 'is_not_empty'],
+    date: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'between', 'is_empty', 'is_not_empty'],
+    boolean: ['eq', 'exists', 'not_exists']
+};
+const NO_VALUE_OPS = [
+    'is_empty',
+    'is_not_empty',
+    'exists',
+    'not_exists'
+];
+export function isFilterOperator(v) {
+    return FILTER_OPERATORS.includes(v);
+}
+export function operatorsForField(field) {
+    return field.operators ?? DEFAULT_OPS[field.type] ?? ['eq'];
+}
+export function resolveValueKind(field, op) {
+    if (NO_VALUE_OPS.includes(op))
+        return 'none';
+    if (op === 'between') {
+        return field.type === 'date' ? 'range-date' : 'range-number';
+    }
+    if (op === 'in' || op === 'nin') {
+        if (field.options?.length)
+            return 'multiselect';
+        return 'text';
+    }
+    switch (field.type) {
+        case 'number':
+            return 'number';
+        case 'date':
+            return 'date';
+        case 'boolean':
+            return 'boolean';
+        case 'select':
+            return field.options?.length ? 'select' : 'text';
+        case 'multiselect':
+            return field.options?.length ? 'multiselect' : 'text';
+        default:
+            return 'text';
+    }
+}
+export function emptyFilterGroup(combinator = 'and') {
+    return {
+        id: uid('g'),
+        type: 'group',
+        combinator,
+        rules: []
+    };
+}
+export function emptyFilterRule(fieldId = '', op = 'eq') {
+    return {
+        id: uid('r'),
+        type: 'rule',
+        field: fieldId,
+        op,
+        value: null
+    };
+}
+function uid(prefix) {
+    return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+}
+export function isGroup(node) {
+    return node.type === 'group';
+}
+export function isRule(node) {
+    return node.type === 'rule';
+}
+/** Flatten rules (ignore group structure) — useful for chips / legacy. */
+export function flattenRules(node) {
+    if (isRule(node))
+        return [node];
+    return node.rules.flatMap(flattenRules);
+}
+export function countRules(node) {
+    return flattenRules(node).length;
+}
+/** Convert legacy flat clauses → root AND group */
+export function clausesToGroup(clauses) {
+    return {
+        id: uid('g'),
+        type: 'group',
+        combinator: 'and',
+        rules: clauses.map((c) => ({
+            id: c.id,
+            type: 'rule',
+            field: c.field,
+            op: c.op,
+            value: c.value
+        }))
+    };
+}
+export function groupToClauses(group) {
+    return flattenRules(group).map((r) => ({
+        id: r.id,
+        field: r.field,
+        op: r.op,
+        value: r.value
+    }));
+}
+export function formatRuleLabel(rule, fields = []) {
+    const field = fields.find((f) => f.id === rule.field);
+    const name = field?.label ?? rule.field;
+    const op = OP_LABELS[rule.op] ?? rule.op;
+    if (NO_VALUE_OPS.includes(rule.op))
+        return `${name} ${op}`;
+    const val = formatValue(rule.value, rule.op);
+    return `${name} ${op} ${val}`;
+}
+function formatValue(value, op) {
+    if (value === null || value === undefined)
+        return '…';
+    if (Array.isArray(value)) {
+        return value.join(op === 'between' ? ' – ' : ', ');
+    }
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return String(value);
+}
+export function encodeFilterValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'boolean')
+        return value ? '1' : '0';
+    if (Array.isArray(value)) {
+        if (value.length === 2 && typeof value[0] === 'number' && typeof value[1] === 'number') {
+            return `${value[0]}~${value[1]}`;
+        }
+        if (value.length === 2 && typeof value[0] === 'string' && typeof value[1] === 'string') {
+            return `${encodeURIComponent(value[0])}~${encodeURIComponent(value[1])}`;
+        }
+        return value.map(encodeURIComponent).join(',');
+    }
+    return encodeURIComponent(String(value));
+}
+export function decodeFilterValue(op, raw) {
+    if (!raw && NO_VALUE_OPS.includes(op))
+        return null;
+    if (op === 'between') {
+        const [a, b] = raw.split('~');
+        const n1 = Number(a);
+        const n2 = Number(b);
+        if (!Number.isNaN(n1) && !Number.isNaN(n2) && a !== '' && !Number.isNaN(Number(a))) {
+            return [n1, n2];
+        }
+        return [decodeURIComponent(a ?? ''), decodeURIComponent(b ?? '')];
+    }
+    if (op === 'in' || op === 'nin') {
+        if (!raw)
+            return [];
+        return raw.split(',').map((v) => decodeURIComponent(v));
+    }
+    if (raw === '1' || raw === '0') {
+        // boolean-ish; callers may coerce
+    }
+    return decodeURIComponent(raw);
+}
+/**
+ * Serialize group tree.
+ * Flat AND of rules → legacy `field:op:value;field:op:value`
+ * Nested → `and(rule,or(rule,rule),rule)`
+ */
+export function serializeAdvancedGroup(group) {
+    if (!countRules(group))
+        return null;
+    if (canUseLegacyFlat(group)) {
+        return group.rules
+            .filter(isRule)
+            .map((r) => serializeRule(r))
+            .join(';');
+    }
+    return serializeNode(group);
+}
+function canUseLegacyFlat(group) {
+    return group.combinator === 'and' && group.rules.every(isRule);
+}
+function serializeRule(rule) {
+    if (NO_VALUE_OPS.includes(rule.op))
+        return `${rule.field}:${rule.op}:`;
+    return `${rule.field}:${rule.op}:${encodeFilterValue(rule.value)}`;
+}
+function serializeNode(node) {
+    if (isRule(node))
+        return serializeRule(node);
+    const inner = node.rules.map(serializeNode).join(',');
+    return `${node.combinator}(${inner})`;
+}
+/** Parse `a` param — supports legacy `;` and nested `and(...)` / `or(...)`. */
+export function parseAdvancedGroup(raw) {
+    if (!raw?.trim())
+        return emptyFilterGroup();
+    const trimmed = raw.trim();
+    if (/^(and|or)\(/i.test(trimmed)) {
+        const node = parseNode(trimmed);
+        if (node && isGroup(node))
+            return node;
+        return { ...emptyFilterGroup(), rules: node ? [node] : [] };
+    }
+    // legacy flat
+    const rules = trimmed
+        .split(';')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map(parseRuleToken)
+        .filter((r) => r !== null);
+    return { id: uid('g'), type: 'group', combinator: 'and', rules };
+}
+function parseRuleToken(part) {
+    const [field, op, ...rest] = part.split(':');
+    const valueRaw = rest.join(':');
+    if (!field || !op || !isFilterOperator(op))
+        return null;
+    return {
+        id: uid('r'),
+        type: 'rule',
+        field,
+        op,
+        value: decodeFilterValue(op, valueRaw)
+    };
+}
+function parseNode(input) {
+    const s = input.trim();
+    const groupMatch = /^(and|or)\((.*)\)$/is.exec(s);
+    if (groupMatch) {
+        const combinator = groupMatch[1].toLowerCase();
+        const inner = groupMatch[2];
+        const parts = splitTopLevel(inner);
+        return {
+            id: uid('g'),
+            type: 'group',
+            combinator,
+            rules: parts.map(parseNode).filter((n) => n !== null)
+        };
+    }
+    return parseRuleToken(s);
+}
+/** Split by commas not inside parentheses */
+function splitTopLevel(input) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === '(')
+            depth++;
+        if (ch === ')')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            if (current.trim())
+                parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+export function matchRuleValue(raw, op, value) {
+    if (op === 'exists')
+        return raw !== undefined && raw !== null && raw !== '';
+    if (op === 'not_exists')
+        return raw === undefined || raw === null || raw === '';
+    if (op === 'is_empty') {
+        if (Array.isArray(raw))
+            return raw.length === 0;
+        return raw === undefined || raw === null || raw === '';
+    }
+    if (op === 'is_not_empty') {
+        if (Array.isArray(raw))
+            return raw.length > 0;
+        return !(raw === undefined || raw === null || raw === '');
+    }
+    if (op === 'between' && Array.isArray(value) && value.length === 2) {
+        if (typeof value[0] === 'number' && typeof value[1] === 'number') {
+            const n = Number(raw);
+            return n >= value[0] && n <= value[1];
+        }
+        const left = String(raw ?? '');
+        return left >= String(value[0]) && left <= String(value[1]);
+    }
+    if ((op === 'in' || op === 'nin') && Array.isArray(value)) {
+        const list = value.map(String);
+        let hit;
+        if (Array.isArray(raw))
+            hit = raw.some((v) => list.includes(String(v)));
+        else
+            hit = list.includes(String(raw));
+        return op === 'in' ? hit : !hit;
+    }
+    const left = String(raw ?? '').toLowerCase();
+    const right = String(value ?? '').toLowerCase();
+    if (op === 'eq') {
+        if (typeof value === 'boolean' || typeof raw === 'boolean') {
+            return Boolean(raw) === (value === true || value === '1' || value === 'true');
+        }
+        return left === right;
+    }
+    if (op === 'neq')
+        return left !== right;
+    if (op === 'contains')
+        return left.includes(right);
+    if (op === 'not_contains')
+        return !left.includes(right);
+    if (op === 'starts_with')
+        return left.startsWith(right);
+    if (op === 'ends_with')
+        return left.endsWith(right);
+    const ln = Number(raw);
+    const rn = Number(value);
+    if (op === 'gt')
+        return ln > rn;
+    if (op === 'gte')
+        return ln >= rn;
+    if (op === 'lt')
+        return ln < rn;
+    if (op === 'lte')
+        return ln <= rn;
+    return true;
+}
+export function matchGroup(group, getField) {
+    if (!group.rules.length)
+        return true;
+    const results = group.rules.map((node) => {
+        if (isGroup(node))
+            return matchGroup(node, getField);
+        return matchRuleValue(getField(node.field), node.op, node.value);
+    });
+    return group.combinator === 'and' ? results.every(Boolean) : results.some(Boolean);
+}
+/** Normalize CatalogFilterState.advanced which may be clauses[] or a group */
+export function asFilterGroup(advanced) {
+    if (!advanced)
+        return emptyFilterGroup();
+    if (Array.isArray(advanced))
+        return clausesToGroup(advanced);
+    if (advanced.type === 'group')
+        return advanced;
+    return emptyFilterGroup();
+}

package/dist/utils/chart.d.ts

@@ -0,0 +1,28 @@
+/** Shared SVG chart geometry helpers (ported from Atom progreso / check-in). */
+export interface ChartXY {
+    x: number;
+    y: number;
+    value: number;
+    index: number;
+}
+export interface ChartPad {
+    t: number;
+    r: number;
+    b: number;
+    l: number;
+}
+export declare const DEFAULT_PAD: ChartPad;
+export declare function scaleDomain(values: number[], padRatio?: number): {
+    min: number;
+    max: number;
+};
+export declare function mapPoints(values: number[], width: number, height: number, pad?: ChartPad, domain?: {
+    min: number;
+    max: number;
+}): ChartXY[];
+/** Smooth cubic path (Atom progreso style). */
+export declare function smoothLinePath(points: ChartXY[]): string;
+export declare function linearLinePath(points: ChartXY[]): string;
+export declare function areaPath(linePath: string, points: ChartXY[], height: number, pad: ChartPad): string;
+export declare function tipAlign(leftPct: number): 'start' | 'center' | 'end';
+export declare function formatTick(n: number, digits?: number): string;

package/dist/utils/chart.js

@@ -0,0 +1,68 @@
+/** Shared SVG chart geometry helpers (ported from Atom progreso / check-in). */
+export const DEFAULT_PAD = { t: 16, r: 12, b: 28, l: 36 };
+export function scaleDomain(values, padRatio = 0.08) {
+    if (values.length === 0)
+        return { min: 0, max: 1 };
+    let min = Math.min(...values);
+    let max = Math.max(...values);
+    if (min === max) {
+        const bump = min === 0 ? 1 : Math.abs(min) * 0.05 || 1;
+        min -= bump;
+        max += bump;
+    }
+    const span = max - min;
+    return { min: min - span * padRatio, max: max + span * padRatio };
+}
+export function mapPoints(values, width, height, pad = DEFAULT_PAD, domain) {
+    if (values.length === 0)
+        return [];
+    const { min, max } = domain ?? scaleDomain(values);
+    const range = max - min || 1;
+    const innerW = width - pad.l - pad.r;
+    const innerH = height - pad.t - pad.b;
+    const span = Math.max(values.length - 1, 1);
+    return values.map((value, index) => {
+        const x = values.length === 1 ? pad.l + innerW / 2 : pad.l + (index / span) * innerW;
+        const y = pad.t + (1 - (value - min) / range) * innerH;
+        return { x, y, value, index };
+    });
+}
+/** Smooth cubic path (Atom progreso style). */
+export function smoothLinePath(points) {
+    if (points.length === 0)
+        return '';
+    if (points.length === 1)
+        return `M ${points[0].x} ${points[0].y}`;
+    return points.reduce((acc, p, idx) => {
+        if (idx === 0)
+            return `M ${p.x} ${p.y}`;
+        const prev = points[idx - 1];
+        const cpX = (prev.x + p.x) / 2;
+        return `${acc} C ${cpX} ${prev.y}, ${cpX} ${p.y}, ${p.x} ${p.y}`;
+    }, '');
+}
+export function linearLinePath(points) {
+    return points
+        .map((p, i) => `${i === 0 ? 'M' : 'L'} ${p.x.toFixed(2)} ${p.y.toFixed(2)}`)
+        .join(' ');
+}
+export function areaPath(linePath, points, height, pad) {
+    if (!linePath || points.length === 0)
+        return '';
+    const bottom = height - pad.b;
+    const startX = points[0].x;
+    const endX = points[points.length - 1].x;
+    return `${linePath} L ${endX} ${bottom} L ${startX} ${bottom} Z`;
+}
+export function tipAlign(leftPct) {
+    if (leftPct < 28)
+        return 'start';
+    if (leftPct > 72)
+        return 'end';
+    return 'center';
+}
+export function formatTick(n, digits = 1) {
+    if (Math.abs(n) >= 100)
+        return String(Math.round(n));
+    return n.toFixed(digits).replace(/\.0$/, '');
+}

package/dist/utils/diff.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Line/word diff helpers (no deps). LCS-based for readable patches.
+ */
+export type DiffOpType = 'equal' | 'insert' | 'delete';
+export type DiffOp = {
+    type: DiffOpType;
+    value: string;
+    /** 1-based line number in the "before" text */
+    oldLine?: number;
+    /** 1-based line number in the "after" text */
+    newLine?: number;
+};
+export type SplitRow = {
+    left: {
+        type: 'equal' | 'delete' | 'empty';
+        text: string;
+        line?: number;
+    } | null;
+    right: {
+        type: 'equal' | 'insert' | 'empty';
+        text: string;
+        line?: number;
+    } | null;
+    /** Word-level parts when both sides are a change pair */
+    leftParts?: DiffPart[];
+    rightParts?: DiffPart[];
+};
+export type DiffPart = {
+    text: string;
+    changed: boolean;
+};
+export type DiffStats = {
+    additions: number;
+    deletions: number;
+    unchanged: number;
+};
+/** Line-level diff via LCS backtrack. */
+export declare function diffLines(before: string, after: string): DiffOp[];
+/** Word-level parts highlighting differences between two strings. */
+export declare function diffWords(before: string, after: string): {
+    left: DiffPart[];
+    right: DiffPart[];
+};
+export declare function diffStats(ops: DiffOp[]): DiffStats;
+/**
+ * Build side-by-side rows. Consecutive delete+insert pairs become a single
+ * modification row with optional word highlighting.
+ */
+export declare function toSplitRows(ops: DiffOp[], wordDiff?: boolean): SplitRow[];

package/dist/utils/diff.js

@@ -0,0 +1,173 @@
+/**
+ * Line/word diff helpers (no deps). LCS-based for readable patches.
+ */
+function splitLines(text) {
+    if (text === '')
+        return [];
+    // Preserve trailing newline as empty trailing line only if present meaningfully
+    const lines = text.split('\n');
+    if (text.endsWith('\n'))
+        lines.pop();
+    return lines;
+}
+/** Classic LCS length table for string arrays. */
+function lcsTable(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    return dp;
+}
+/** Line-level diff via LCS backtrack. */
+export function diffLines(before, after) {
+    const a = splitLines(before);
+    const b = splitLines(after);
+    const dp = lcsTable(a, b);
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    let oldLine = 1;
+    let newLine = 1;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            ops.push({ type: 'equal', value: a[i], oldLine, newLine });
+            i += 1;
+            j += 1;
+            oldLine += 1;
+            newLine += 1;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            ops.push({ type: 'delete', value: a[i], oldLine });
+            i += 1;
+            oldLine += 1;
+        }
+        else {
+            ops.push({ type: 'insert', value: b[j], newLine });
+            j += 1;
+            newLine += 1;
+        }
+    }
+    while (i < a.length) {
+        ops.push({ type: 'delete', value: a[i], oldLine });
+        i += 1;
+        oldLine += 1;
+    }
+    while (j < b.length) {
+        ops.push({ type: 'insert', value: b[j], newLine });
+        j += 1;
+        newLine += 1;
+    }
+    return ops;
+}
+/** Tokenize for inline word diff (keeps whitespace as tokens). */
+function tokenize(s) {
+    return s.match(/(\s+|[^\s]+)/g) ?? [s];
+}
+/** Word-level parts highlighting differences between two strings. */
+export function diffWords(before, after) {
+    const a = tokenize(before);
+    const b = tokenize(after);
+    const dp = lcsTable(a, b);
+    const left = [];
+    const right = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            left.push({ text: a[i], changed: false });
+            right.push({ text: b[j], changed: false });
+            i += 1;
+            j += 1;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            left.push({ text: a[i], changed: true });
+            i += 1;
+        }
+        else {
+            right.push({ text: b[j], changed: true });
+            j += 1;
+        }
+    }
+    while (i < a.length) {
+        left.push({ text: a[i], changed: true });
+        i += 1;
+    }
+    while (j < b.length) {
+        right.push({ text: b[j], changed: true });
+        j += 1;
+    }
+    return { left, right };
+}
+export function diffStats(ops) {
+    let additions = 0;
+    let deletions = 0;
+    let unchanged = 0;
+    for (const op of ops) {
+        if (op.type === 'insert')
+            additions += 1;
+        else if (op.type === 'delete')
+            deletions += 1;
+        else
+            unchanged += 1;
+    }
+    return { additions, deletions, unchanged };
+}
+/**
+ * Build side-by-side rows. Consecutive delete+insert pairs become a single
+ * modification row with optional word highlighting.
+ */
+export function toSplitRows(ops, wordDiff = true) {
+    const rows = [];
+    let i = 0;
+    while (i < ops.length) {
+        const op = ops[i];
+        if (op.type === 'equal') {
+            rows.push({
+                left: { type: 'equal', text: op.value, line: op.oldLine },
+                right: { type: 'equal', text: op.value, line: op.newLine }
+            });
+            i += 1;
+            continue;
+        }
+        // Gather consecutive deletes then inserts (or mix) into paired rows
+        const deletes = [];
+        const inserts = [];
+        while (i < ops.length && ops[i].type === 'delete') {
+            deletes.push(ops[i]);
+            i += 1;
+        }
+        while (i < ops.length && ops[i].type === 'insert') {
+            inserts.push(ops[i]);
+            i += 1;
+        }
+        const n = Math.max(deletes.length, inserts.length);
+        for (let k = 0; k < n; k++) {
+            const d = deletes[k];
+            const ins = inserts[k];
+            if (d && ins && wordDiff) {
+                const parts = diffWords(d.value, ins.value);
+                rows.push({
+                    left: { type: 'delete', text: d.value, line: d.oldLine },
+                    right: { type: 'insert', text: ins.value, line: ins.newLine },
+                    leftParts: parts.left,
+                    rightParts: parts.right
+                });
+            }
+            else {
+                rows.push({
+                    left: d
+                        ? { type: 'delete', text: d.value, line: d.oldLine }
+                        : { type: 'empty', text: '' },
+                    right: ins
+                        ? { type: 'insert', text: ins.value, line: ins.newLine }
+                        : { type: 'empty', text: '' }
+                });
+            }
+        }
+    }
+    return rows;
+}