@r2digisolutions/components 0.1.6 → 0.2.0

package/dist/utils/queryBridge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bridge between QueryBar DSL strings and AdvancedFilterGroup trees.
+ */
+import { type AdvancedFilterGroup, type AdvancedFilterRule, type FilterFieldDef } from './advancedFilters.js';
+/** Parse a QueryBar-style string into a flat AND AdvancedFilterGroup. */
+export declare function queryStringToGroup(query: string, fields?: FilterFieldDef[]): AdvancedFilterGroup;
+/** Serialize flat rules to a QueryBar-ish AND string (ignores nested groups). */
+export declare function groupToQueryString(group: AdvancedFilterGroup, fields?: FilterFieldDef[]): string;
+/** Active filter chips derived from a group. */
+export declare function groupToFilterItems(group: AdvancedFilterGroup, fields?: FilterFieldDef[]): {
+    id: string;
+    label: string;
+    rule: AdvancedFilterRule;
+}[];
+/** Remove a rule by id from a (possibly nested) group; returns a new tree. */
+export declare function removeRuleFromGroup(group: AdvancedFilterGroup, ruleId: string): AdvancedFilterGroup;
+/** Replace root rules with a flat AND list (drops nesting). */
+export declare function setFlatRules(rules: AdvancedFilterRule[], combinator?: 'and' | 'or'): AdvancedFilterGroup;

package/dist/utils/queryBridge.js

@@ -0,0 +1,118 @@
+/**
+ * Bridge between QueryBar DSL strings and AdvancedFilterGroup trees.
+ */
+import { emptyFilterGroup, emptyFilterRule, flattenRules, formatRuleLabel } from './advancedFilters.js';
+import { parseSimpleClauses } from './queryBar.js';
+const OP_FROM_DSL = {
+    ':': 'eq',
+    '=': 'eq',
+    '!=': 'neq',
+    '>': 'gt',
+    '>=': 'gte',
+    '<': 'lt',
+    '<=': 'lte',
+    '~': 'contains'
+};
+const DSL_FROM_OP = {
+    eq: ':',
+    neq: '!=',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    contains: '~',
+    not_contains: '~',
+    starts_with: ':',
+    ends_with: ':',
+    in: ':',
+    nin: '!=',
+    between: ':',
+    is_empty: ':',
+    is_not_empty: ':',
+    exists: ':',
+    not_exists: ':'
+};
+function quoteValue(value) {
+    if (/[\s()]/.test(value) || value.includes('"')) {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+function ruleValueToString(rule) {
+    const v = rule.value;
+    if (v === null || v === undefined)
+        return '';
+    if (Array.isArray(v))
+        return v.join(',');
+    return String(v);
+}
+/** Parse a QueryBar-style string into a flat AND AdvancedFilterGroup. */
+export function queryStringToGroup(query, fields = []) {
+    const group = emptyFilterGroup('and');
+    const clauses = parseSimpleClauses(query);
+    const fieldIds = new Set(fields.map((f) => f.id));
+    for (const c of clauses) {
+        if (fields.length && !fieldIds.has(c.field))
+            continue;
+        const op = OP_FROM_DSL[c.op] ?? 'eq';
+        const field = fields.find((f) => f.id === c.field);
+        let value = c.value;
+        if (field?.type === 'number') {
+            const n = Number(c.value);
+            if (!Number.isNaN(n))
+                value = n;
+        }
+        else if (field?.type === 'boolean') {
+            value = c.value === 'true' || c.value === '1';
+        }
+        const rule = emptyFilterRule(c.field, op);
+        rule.value = value;
+        group.rules.push(rule);
+    }
+    return group;
+}
+/** Serialize flat rules to a QueryBar-ish AND string (ignores nested groups). */
+export function groupToQueryString(group, fields = []) {
+    const rules = flattenRules(group).filter((r) => r.field);
+    if (!rules.length)
+        return '';
+    return rules
+        .map((r) => {
+        const dslOp = DSL_FROM_OP[r.op] ?? ':';
+        const raw = ruleValueToString(r);
+        if (r.op === 'is_empty' ||
+            r.op === 'is_not_empty' ||
+            r.op === 'exists' ||
+            r.op === 'not_exists') {
+            return `${r.field}${dslOp}${r.op}`;
+        }
+        return `${r.field}${dslOp}${quoteValue(raw)}`;
+    })
+        .join(' AND ');
+}
+/** Active filter chips derived from a group. */
+export function groupToFilterItems(group, fields = []) {
+    return flattenRules(group).map((rule) => ({
+        id: rule.id,
+        label: formatRuleLabel(rule, fields),
+        rule
+    }));
+}
+/** Remove a rule by id from a (possibly nested) group; returns a new tree. */
+export function removeRuleFromGroup(group, ruleId) {
+    return {
+        ...group,
+        rules: group.rules
+            .filter((n) => !(n.type === 'rule' && n.id === ruleId))
+            .map((n) => (n.type === 'group' ? removeRuleFromGroup(n, ruleId) : n))
+    };
+}
+/** Replace root rules with a flat AND list (drops nesting). */
+export function setFlatRules(rules, combinator = 'and') {
+    return {
+        id: `g-${Date.now().toString(36)}`,
+        type: 'group',
+        combinator,
+        rules: rules.map((r) => ({ ...r, type: 'rule' }))
+    };
+}

package/dist/utils/videoSequence.d.ts

@@ -0,0 +1,13 @@
+import { type MediaAsset, type MediaTrack } from './mediaTracks.js';
+export interface VideoSequence {
+    version: 1;
+    width: number;
+    height: number;
+    fps: number;
+    durationMs: number;
+    background: string;
+    tracks: MediaTrack[];
+    assets: MediaAsset[];
+}
+export declare function emptyVideoSequence(partial?: Partial<Omit<VideoSequence, 'version'>>): VideoSequence;
+export declare function createDemoVideoSequence(): VideoSequence;

package/dist/utils/videoSequence.js

@@ -0,0 +1,63 @@
+import { createMediaTrack, uid } from './mediaTracks.js';
+export function emptyVideoSequence(partial) {
+    return {
+        version: 1,
+        width: partial?.width ?? 1280,
+        height: partial?.height ?? 720,
+        fps: partial?.fps ?? 30,
+        durationMs: partial?.durationMs ?? 30_000,
+        background: partial?.background ?? '#0a0a0a',
+        tracks: partial?.tracks ?? [
+            createMediaTrack({ name: 'V1', kind: 'video' }),
+            createMediaTrack({ name: 'A1', kind: 'audio' })
+        ],
+        assets: partial?.assets ?? []
+    };
+}
+export function createDemoVideoSequence() {
+    const seq = emptyVideoSequence({ durationMs: 20_000 });
+    const vTrack = seq.tracks[0];
+    const aTrack = seq.tracks[1];
+    return {
+        ...seq,
+        tracks: [
+            {
+                ...vTrack,
+                clips: [
+                    {
+                        id: uid('clip'),
+                        trackId: vTrack.id,
+                        name: 'Title card',
+                        kind: 'image',
+                        startMs: 0,
+                        endMs: 4000,
+                        color: '#3b82f6'
+                    },
+                    {
+                        id: uid('clip'),
+                        trackId: vTrack.id,
+                        name: 'B-roll',
+                        kind: 'video',
+                        startMs: 4000,
+                        endMs: 12000,
+                        color: '#8b5cf6'
+                    }
+                ]
+            },
+            {
+                ...aTrack,
+                clips: [
+                    {
+                        id: uid('clip'),
+                        trackId: aTrack.id,
+                        name: 'Voiceover',
+                        kind: 'audio',
+                        startMs: 1000,
+                        endMs: 14000,
+                        color: '#10b981'
+                    }
+                ]
+            }
+        ]
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@r2digisolutions/components",
-	"version": "0.1.6",
+	"version": "0.2.0",
 	"private": false,
 	"description": "R2DigiSolutions Svelte 5 component library — Atomic Design, Tailwind 4, Light/Dark mode",
 	"license": "MIT",
@@ -107,5 +107,8 @@
 		"ui",
 		"tailwindcss",
 		"atomic-design"
-	]
+	],
+	"dependencies": {
+		"@xyflow/svelte": "^1.6.2"
+	}
 }