@jumoo/usync 0.0.0-stage → 17.5.0

package/dist/utils/diff/json-diff.js

@@ -0,0 +1,300 @@
+import { deepEqual, isPlainObject, typeTag } from './deep-equal.js';
+import { elementPath, joinKey } from './format-value.js';
+import { tryParseJsonContainer } from './classify-change.js';
+import { USYNC_DIFF_LIMITS, } from './types.js';
+// A private sentinel for "this side has no value at all" - distinct from
+// `undefined`, which can legitimately appear as the result of a string
+// expansion round-trip. This keeps `{"a": null}` vs `{}` distinguishable from
+// a missing key.
+const MISSING = Symbol('usync-diff-missing');
+/**
+ * Composite identities are tried before single fields, and in the order
+ * listed - a block's `values` entries and property values key on
+ * alias(+culture/segment) almost always, and that composite survives
+ * serialisation round-trips even when raw GUIDs don't.
+ */
+export const USYNC_COMPOSITE_IDENTITIES = [
+    ['alias', 'culture', 'segment'], // block `values`, property values
+    ['propertyAlias', 'culture', 'segment'],
+    ['contentKey', 'culture', 'segment'],
+];
+// `$type` is deliberately excluded - it's a label, not an identity: it's
+// never unique within a block array.
+export const USYNC_IDENTITY_FIELDS = [
+    'key',
+    'udi',
+    'contentUdi',
+    'contentKey',
+    'settingsKey',
+    'id',
+    'alias',
+    'editorAlias',
+    'name',
+];
+function isUniqueAndIntersecting(a, b, keyOf) {
+    const aKeys = a.map((element) => keyOf(element));
+    const bKeys = b.map((element) => keyOf(element));
+    if (new Set(aKeys).size !== aKeys.length)
+        return false;
+    if (new Set(bKeys).size !== bKeys.length)
+        return false;
+    // The load-bearing check: Umbraco regenerates block `key` GUIDs on some
+    // serialisation paths. If both sides have unique but entirely disjoint
+    // keys, identity matching would report "everything removed, everything
+    // added" - strictly worse than index matching. Requiring a shared key
+    // means we only key when the key actually carries continuity across the
+    // two sides; otherwise we correctly fall back to index matching.
+    const bSet = new Set(bKeys);
+    return aKeys.some((key) => bSet.has(key));
+}
+function tryCompositeStrategy(fields, a, b) {
+    const primary = fields[0];
+    const hasPrimary = (elements) => elements.every((element) => {
+        if (!isPlainObject(element))
+            return false;
+        const value = element[primary];
+        return typeof value === 'string' && value.length > 0;
+    });
+    if (!hasPrimary(a) || !hasPrimary(b))
+        return null;
+    const keyOf = (element) => fields
+        .map((field) => typeof element[field] === 'string' ? element[field] : '')
+        .join('\u0000');
+    const labelOf = (element) => {
+        const primaryValue = String(element[primary]);
+        const culture = fields.includes('culture') ? element.culture : undefined;
+        return typeof culture === 'string' && culture.length > 0
+            ? `${primaryValue} (${culture})`
+            : primaryValue;
+    };
+    if (!isUniqueAndIntersecting(a, b, keyOf))
+        return null;
+    return { isComposite: true, keyOf, labelOf };
+}
+function trySingleFieldStrategy(field, a, b) {
+    const hasField = (elements) => elements.every((element) => {
+        if (!isPlainObject(element))
+            return false;
+        const value = element[field];
+        return typeof value === 'string' || typeof value === 'number';
+    });
+    if (!hasField(a) || !hasField(b))
+        return null;
+    const keyOf = (element) => String(element[field]);
+    const labelOf = (element) => String(element[field]);
+    if (!isUniqueAndIntersecting(a, b, keyOf))
+        return null;
+    return { isComposite: false, keyOf, labelOf };
+}
+/**
+ * Picks an identity strategy for matching elements of two arrays by identity
+ * rather than position, or `null` when neither array offers one (the caller
+ * should fall back to index matching).
+ */
+export function pickIdentity(a, b) {
+    if (a.length === 0 || b.length === 0)
+        return null;
+    if (!a.every(isPlainObject) || !b.every(isPlainObject))
+        return null;
+    for (const fields of USYNC_COMPOSITE_IDENTITIES) {
+        const strategy = tryCompositeStrategy(fields, a, b);
+        if (strategy)
+            return strategy;
+    }
+    for (const field of USYNC_IDENTITY_FIELDS) {
+        const strategy = trySingleFieldStrategy(field, a, b);
+        if (strategy)
+            return strategy;
+    }
+    return null;
+}
+function record(ctx, expansions, entry) {
+    ctx.totalCount++;
+    if (ctx.changes.length < ctx.maxChanges) {
+        // Any leaf recorded while inside an expanded encoded-JSON string
+        // carries `expanded: true`, not just the leaf that triggered the
+        // expansion - it's the whole subtree that crossed into a string.
+        ctx.changes.push(expansions > 0 ? { ...entry, expanded: true } : entry);
+    }
+    // Hard-stop: don't keep walking a wholesale change (e.g. a 5000-element
+    // array rewrite) just to increment a counter past a few times the cap.
+    if (ctx.totalCount > ctx.maxChanges * 4) {
+        ctx.stopped = true;
+    }
+}
+function identityChildPath(path, strategy, element, index) {
+    return strategy.isComposite
+        ? elementPath(path, element, { identityLabel: strategy.labelOf(element) })
+        : elementPath(path, element, { index });
+}
+function walk(ctx, path, a, b, depth, expansions) {
+    if (ctx.stopped)
+        return;
+    if (a === MISSING) {
+        record(ctx, expansions, { path, kind: 'added', newValue: b });
+        return;
+    }
+    if (b === MISSING) {
+        record(ctx, expansions, { path, kind: 'removed', oldValue: a });
+        return;
+    }
+    if (deepEqual(a, b))
+        return;
+    if (depth >= ctx.maxDepth) {
+        record(ctx, expansions, { path, kind: 'changed', oldValue: a, newValue: b });
+        return;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+        if (ctx.expandJsonStrings && expansions < ctx.maxStringExpansions) {
+            const ea = tryParseJsonContainer(a);
+            const eb = tryParseJsonContainer(b);
+            // Only expand when BOTH sides parse - expanding one side only
+            // would compare a JSON structure against a raw string.
+            if (ea.ok && eb.ok) {
+                walk(ctx, `${path} » `, ea.value, eb.value, depth + 1, expansions + 1);
+                return;
+            }
+        }
+        record(ctx, expansions, { path, kind: 'changed', oldValue: a, newValue: b });
+        return;
+    }
+    if (typeTag(a) !== typeTag(b)) {
+        record(ctx, expansions, { path, kind: 'changed', oldValue: a, newValue: b });
+        return;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        walkArray(ctx, path, a, b, depth, expansions);
+        return;
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        walkObject(ctx, path, a, b, depth, expansions);
+        return;
+    }
+    record(ctx, expansions, { path, kind: 'changed', oldValue: a, newValue: b });
+}
+function walkObject(ctx, path, a, b, depth, expansions) {
+    for (const key of Object.keys(a)) {
+        if (ctx.stopped)
+            return;
+        const childPath = joinKey(path, key);
+        const bHasKey = Object.prototype.hasOwnProperty.call(b, key);
+        walk(ctx, childPath, a[key], bHasKey ? b[key] : MISSING, depth + 1, expansions);
+    }
+    for (const key of Object.keys(b)) {
+        if (ctx.stopped)
+            return;
+        if (Object.prototype.hasOwnProperty.call(a, key))
+            continue;
+        walk(ctx, joinKey(path, key), MISSING, b[key], depth + 1, expansions);
+    }
+}
+function sameMultiset(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const sorted = (arr) => [...arr].sort();
+    const sa = sorted(a);
+    const sb = sorted(b);
+    return sa.every((key, i) => key === sb[i]);
+}
+function sameOrder(a, b) {
+    return a.length === b.length && a.every((key, i) => key === b[i]);
+}
+function walkArray(ctx, path, a, b, depth, expansions) {
+    const strategy = pickIdentity(a, b);
+    if (!strategy) {
+        walkArrayByIndex(ctx, path, a, b, depth, expansions);
+        return;
+    }
+    const aEntries = a.map((element, index) => ({
+        element: element,
+        index,
+        key: strategy.keyOf(element),
+    }));
+    const bEntries = b.map((element, index) => ({
+        element: element,
+        index,
+        key: strategy.keyOf(element),
+    }));
+    const bByKey = new Map(bEntries.map((entry) => [entry.key, entry]));
+    const aByKey = new Map(aEntries.map((entry) => [entry.key, entry]));
+    for (const aEntry of aEntries) {
+        if (ctx.stopped)
+            return;
+        const bEntry = bByKey.get(aEntry.key);
+        if (!bEntry) {
+            record(ctx, expansions, {
+                path: identityChildPath(path, strategy, aEntry.element, aEntry.index),
+                kind: 'removed',
+                oldValue: aEntry.element,
+            });
+            continue;
+        }
+        walk(ctx, identityChildPath(path, strategy, bEntry.element, bEntry.index), aEntry.element, bEntry.element, depth + 1, expansions);
+    }
+    for (const bEntry of bEntries) {
+        if (ctx.stopped)
+            return;
+        if (!aByKey.has(bEntry.key)) {
+            record(ctx, expansions, {
+                path: identityChildPath(path, strategy, bEntry.element, bEntry.index),
+                kind: 'added',
+                newValue: bEntry.element,
+            });
+        }
+    }
+    const aKeys = aEntries.map((entry) => entry.key);
+    const bKeys = bEntries.map((entry) => entry.key);
+    if (sameMultiset(aKeys, bKeys) && !sameOrder(aKeys, bKeys)) {
+        ctx.reordered.push(path.length > 0 ? path : '(root)');
+    }
+}
+function walkArrayByIndex(ctx, path, a, b, depth, expansions) {
+    const minLen = Math.min(a.length, b.length);
+    let start = 0;
+    while (start < minLen && deepEqual(a[start], b[start]))
+        start++;
+    let end = 0;
+    while (end < minLen - start &&
+        deepEqual(a[a.length - 1 - end], b[b.length - 1 - end])) {
+        end++;
+    }
+    const aMid = a.slice(start, a.length - end);
+    const bMid = b.slice(start, b.length - end);
+    const midLen = Math.max(aMid.length, bMid.length);
+    for (let i = 0; i < midLen; i++) {
+        if (ctx.stopped)
+            return;
+        const aEl = i < aMid.length ? aMid[i] : MISSING;
+        const bEl = i < bMid.length ? bMid[i] : MISSING;
+        const index = start + i;
+        const sample = aEl !== MISSING ? aEl : bEl;
+        const childPath = elementPath(path, sample, { index });
+        walk(ctx, childPath, aEl, bEl, depth + 1, expansions);
+    }
+}
+/**
+ * Structurally diffs two parsed JSON values, producing a flat list of leaf
+ * changes with readable paths instead of a wholesale before/after dump.
+ * Arrays are matched by identity where possible (see `pickIdentity`) so that
+ * inserting one block does not make every other block look changed.
+ */
+export function diffJsonValues(oldValue, newValue, options) {
+    const ctx = {
+        changes: [],
+        totalCount: 0,
+        reordered: [],
+        maxChanges: options?.maxChanges ?? USYNC_DIFF_LIMITS.maxLeafChanges,
+        maxDepth: options?.maxDepth ?? USYNC_DIFF_LIMITS.maxJsonDepth,
+        expandJsonStrings: options?.expandJsonStrings ?? true,
+        maxStringExpansions: options?.maxStringExpansions ?? USYNC_DIFF_LIMITS.maxStringExpansions,
+        stopped: false,
+    };
+    walk(ctx, '', oldValue, newValue, 0, 0);
+    return {
+        changes: ctx.changes,
+        totalCount: ctx.totalCount,
+        truncated: ctx.totalCount > ctx.changes.length,
+        stopped: ctx.stopped,
+        reordered: ctx.reordered,
+    };
+}

package/dist/utils/diff/line-diff.d.ts

@@ -0,0 +1,16 @@
+import { type USyncLineDiffBlock, type USyncLineDiffResult, type USyncLineDiffRow } from './types.js';
+/**
+ * Diffs two texts line by line. Normalises `\r\n` to `\n` before splitting
+ * (uSync files get written on one OS and imported on another - without this
+ * a line-ending-only change would diff the whole file), trims the identical
+ * common prefix/suffix so large files with one changed line stay cheap, and
+ * degrades to a wholesale remove/add - bounded, honest output - rather than
+ * letting the O(ND) middle blow up.
+ */
+export declare function diffTextLines(oldText: string, newText: string): USyncLineDiffResult;
+/**
+ * Collapses long runs of unchanged context rows down to a small lead-in/
+ * lead-out plus a single collapsed block, keeping the hidden rows so a
+ * consumer can splice them back in on click without re-diffing.
+ */
+export declare function collapseUnchanged(rows: USyncLineDiffRow[], context?: number): USyncLineDiffBlock[];

package/dist/utils/diff/line-diff.js

@@ -0,0 +1,199 @@
+import { USYNC_DIFF_LIMITS, } from './types.js';
+function normalize(text) {
+    return text.replace(/\r\n/g, '\n');
+}
+function contextRow(oldLine, newLine, text) {
+    return { type: 'context', oldLine, newLine, text };
+}
+function removeRow(oldLine, text) {
+    return { type: 'remove', oldLine, text };
+}
+function addRow(newLine, text) {
+    return { type: 'add', newLine, text };
+}
+/**
+ * Emits the whole [oldStart, oldEnd) / [newStart, newEnd) middle range as a
+ * wholesale remove-then-add - used both when the pathological-size guard
+ * trips and as the degrade path if Myers' `d` bound is hit.
+ */
+function wholesaleRows(oldLines, newLines, oldStart, oldEnd, newStart, newEnd) {
+    const rows = [];
+    for (let i = oldStart; i < oldEnd; i++)
+        rows.push(removeRow(i + 1, oldLines[i]));
+    for (let i = newStart; i < newEnd; i++)
+        rows.push(addRow(i + 1, newLines[i]));
+    return rows;
+}
+const MAX_D = 2000;
+/**
+ * Myers greedy forward diff (the classic O(ND) algorithm) over the given
+ * line ranges. Returns `null` if the edit distance exceeds `MAX_D`, in which
+ * case the caller should degrade to a wholesale remove/add instead of
+ * continuing to search.
+ */
+function myersDiff(oldLines, newLines, oldStart, oldEnd, newStart, newEnd) {
+    const n = oldEnd - oldStart;
+    const m = newEnd - newStart;
+    const max = Math.min(n + m, MAX_D);
+    if (n === 0 && m === 0)
+        return [];
+    const offset = max;
+    const v = new Int32Array(2 * max + 1);
+    const trace = [];
+    let found = false;
+    let foundD = -1;
+    for (let d = 0; d <= max; d++) {
+        const snapshot = v.slice();
+        trace.push(snapshot);
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && v[k - 1 + offset] < v[k + 1 + offset])) {
+                x = v[k + 1 + offset];
+            }
+            else {
+                x = v[k - 1 + offset] + 1;
+            }
+            let y = x - k;
+            while (x < n && y < m && oldLines[oldStart + x] === newLines[newStart + y]) {
+                x++;
+                y++;
+            }
+            v[k + offset] = x;
+            if (x >= n && y >= m) {
+                found = true;
+                foundD = d;
+                break;
+            }
+        }
+        if (found)
+            break;
+    }
+    if (!found)
+        return null;
+    // Backtrack through the trace to recover the edit script.
+    const rows = [];
+    let x = n;
+    let y = m;
+    for (let d = foundD; d > 0; d--) {
+        const vPrev = trace[d];
+        const k = x - y;
+        let prevK;
+        if (k === -d || (k !== d && vPrev[k - 1 + offset] < vPrev[k + 1 + offset])) {
+            prevK = k + 1;
+        }
+        else {
+            prevK = k - 1;
+        }
+        const prevX = vPrev[prevK + offset];
+        const prevY = prevX - prevK;
+        while (x > prevX && y > prevY) {
+            rows.push(contextRow(oldStart + x, newStart + y, oldLines[oldStart + x - 1]));
+            x--;
+            y--;
+        }
+        if (x === prevX) {
+            rows.push(addRow(newStart + y, newLines[newStart + y - 1]));
+        }
+        else {
+            rows.push(removeRow(oldStart + x, oldLines[oldStart + x - 1]));
+        }
+        x = prevX;
+        y = prevY;
+    }
+    while (x > 0 && y > 0) {
+        rows.push(contextRow(oldStart + x, newStart + y, oldLines[oldStart + x - 1]));
+        x--;
+        y--;
+    }
+    rows.reverse();
+    return rows;
+}
+/**
+ * Diffs two texts line by line. Normalises `\r\n` to `\n` before splitting
+ * (uSync files get written on one OS and imported on another - without this
+ * a line-ending-only change would diff the whole file), trims the identical
+ * common prefix/suffix so large files with one changed line stay cheap, and
+ * degrades to a wholesale remove/add - bounded, honest output - rather than
+ * letting the O(ND) middle blow up.
+ */
+export function diffTextLines(oldText, newText) {
+    const oldLines = normalize(oldText).split('\n');
+    const newLines = normalize(newText).split('\n');
+    const minLen = Math.min(oldLines.length, newLines.length);
+    let prefix = 0;
+    while (prefix < minLen && oldLines[prefix] === newLines[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < minLen - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) {
+        suffix++;
+    }
+    const oldMidStart = prefix;
+    const oldMidEnd = oldLines.length - suffix;
+    const newMidStart = prefix;
+    const newMidEnd = newLines.length - suffix;
+    const oldMidLen = oldMidEnd - oldMidStart;
+    const newMidLen = newMidEnd - newMidStart;
+    let degraded = false;
+    let middleRows;
+    if (oldMidLen * newMidLen > USYNC_DIFF_LIMITS.maxLineDiffArea) {
+        degraded = true;
+        middleRows = wholesaleRows(oldLines, newLines, oldMidStart, oldMidEnd, newMidStart, newMidEnd);
+    }
+    else {
+        const myers = myersDiff(oldLines, newLines, oldMidStart, oldMidEnd, newMidStart, newMidEnd);
+        if (myers === null) {
+            degraded = true;
+            middleRows = wholesaleRows(oldLines, newLines, oldMidStart, oldMidEnd, newMidStart, newMidEnd);
+        }
+        else {
+            middleRows = myers;
+        }
+    }
+    const rows = [];
+    for (let i = 0; i < prefix; i++)
+        rows.push(contextRow(i + 1, i + 1, oldLines[i]));
+    rows.push(...middleRows);
+    for (let i = 0; i < suffix; i++) {
+        const oldLine = oldLines.length - suffix + i;
+        const newLine = newLines.length - suffix + i;
+        rows.push(contextRow(oldLine + 1, newLine + 1, oldLines[oldLine]));
+    }
+    return { oldLines, newLines, degraded, rows };
+}
+/**
+ * Collapses long runs of unchanged context rows down to a small lead-in/
+ * lead-out plus a single collapsed block, keeping the hidden rows so a
+ * consumer can splice them back in on click without re-diffing.
+ */
+export function collapseUnchanged(rows, context = USYNC_DIFF_LIMITS.lineContext) {
+    const blocks = [];
+    let i = 0;
+    while (i < rows.length) {
+        if (rows[i].type !== 'context') {
+            blocks.push({ type: 'row', row: rows[i] });
+            i++;
+            continue;
+        }
+        let end = i;
+        while (end < rows.length && rows[end].type === 'context')
+            end++;
+        const run = rows.slice(i, end);
+        if (run.length <= 2 * context + 1) {
+            for (const row of run)
+                blocks.push({ type: 'row', row });
+        }
+        else {
+            const lead = run.slice(0, context);
+            const hidden = run.slice(context, run.length - context);
+            const trail = run.slice(run.length - context);
+            for (const row of lead)
+                blocks.push({ type: 'row', row });
+            blocks.push({ type: 'collapsed', count: hidden.length, rows: hidden });
+            for (const row of trail)
+                blocks.push({ type: 'row', row });
+        }
+        i = end;
+    }
+    return blocks;
+}

package/dist/utils/diff/types.d.ts

@@ -0,0 +1,62 @@
+export type USyncLeafChangeKind = 'added' | 'removed' | 'changed';
+export interface USyncLeafChange {
+    path: string;
+    kind: USyncLeafChangeKind;
+    oldValue?: unknown;
+    newValue?: unknown;
+    expanded?: boolean;
+}
+export interface USyncJsonDiffResult {
+    changes: USyncLeafChange[];
+    totalCount: number;
+    truncated: boolean;
+    /**
+     * True when the walk aborted early on a runaway subtree, which makes
+     * `totalCount` a floor rather than an exact count - report it as
+     * "N or more changes".
+     */
+    stopped: boolean;
+    reordered: string[];
+}
+export type USyncDiffStrategy = 'skip' | 'notice' | 'masked' | 'single' | 'json' | 'lines' | 'words' | 'scalar' | 'oversized';
+export interface USyncClassifiedChange {
+    strategy: USyncDiffStrategy;
+    oldText: string;
+    newText: string;
+    oldJson?: unknown;
+    newJson?: unknown;
+    language: 'json' | 'xml' | 'text';
+    bytes: number;
+}
+export type USyncLineRowType = 'context' | 'add' | 'remove';
+export interface USyncLineDiffRow {
+    type: USyncLineRowType;
+    oldLine?: number;
+    newLine?: number;
+    text: string;
+}
+export interface USyncLineDiffResult {
+    oldLines: string[];
+    newLines: string[];
+    degraded: boolean;
+    rows: USyncLineDiffRow[];
+}
+export type USyncLineDiffBlock = {
+    type: 'row';
+    row: USyncLineDiffRow;
+} | {
+    type: 'collapsed';
+    count: number;
+    rows: USyncLineDiffRow[];
+};
+export declare const USYNC_DIFF_LIMITS: {
+    readonly maxDiffBytes: 512000;
+    readonly maxWordDiffBytes: 8000;
+    readonly maxScalarWordDiffBytes: 2000;
+    readonly inlineScalarChars: 80;
+    readonly maxLeafChanges: 40;
+    readonly maxJsonDepth: 12;
+    readonly maxStringExpansions: 3;
+    readonly maxLineDiffArea: 4000000;
+    readonly lineContext: 3;
+};

package/dist/utils/diff/types.js

@@ -0,0 +1,12 @@
+// All thresholds in one exported const so they are tunable in one line.
+export const USYNC_DIFF_LIMITS = {
+    maxDiffBytes: 512000, // above: raw only, no walk/diff at all
+    maxWordDiffBytes: 8000, // diffWords is ~quadratic; also ~where a word diff stops being readable
+    maxScalarWordDiffBytes: 2000,
+    inlineScalarChars: 80, // at or below: render inline as "old → new"
+    maxLeafChanges: 40,
+    maxJsonDepth: 12,
+    maxStringExpansions: 3,
+    maxLineDiffArea: 4000000, // |old| * |new| lines before degrading
+    lineContext: 3,
+};

package/dist/workspace/components/events.d.ts

@@ -0,0 +1,31 @@
+import { SyncActionButton, SyncActionGroup, UploadImportResult } from '../../api';
+export declare const USYNC_FILE_PICKER_CHANGE_EVENT = "change";
+export declare const USYNC_FILE_PICKER_UPLOADED_EVENT = "uploaded";
+/**
+ * 'change' event fires when the file input changes, either by selecting a new file or removing the current one.
+ */
+export declare class uSyncFilePickerChangeEvent extends Event {
+    constructor(file: File | null | undefined);
+    file: File | null | undefined;
+}
+/**
+ * 'uploaded' event fires when a file has been successfully uploaded and extracted.
+ */
+export declare class uSyncFilePickerUploadedEvent extends Event {
+    constructor(result: UploadImportResult);
+    result: UploadImportResult;
+}
+export declare const USYNC_ACTION_BUTTON_CLICK_EVENT = "usync-action-click";
+export declare class uSyncActionButtonClickEvent extends Event {
+    constructor(button: SyncActionButton);
+    button: SyncActionButton;
+}
+export declare const USYNC_ACTION_PERFORM_EVENT = "perform-action";
+export declare class uSyncActionPerformEvent extends Event {
+    constructor(group: SyncActionGroup, key: string, force?: boolean, clean?: boolean, file?: boolean);
+    group: SyncActionGroup;
+    key: string;
+    force?: boolean;
+    clean?: boolean;
+    file?: boolean;
+}

package/dist/workspace/components/events.js

@@ -0,0 +1,54 @@
+export const USYNC_FILE_PICKER_CHANGE_EVENT = 'change';
+export const USYNC_FILE_PICKER_UPLOADED_EVENT = 'uploaded';
+/**
+ * 'change' event fires when the file input changes, either by selecting a new file or removing the current one.
+ */
+export class uSyncFilePickerChangeEvent extends Event {
+    constructor(file) {
+        super(USYNC_FILE_PICKER_CHANGE_EVENT, {
+            bubbles: true,
+            composed: true,
+            cancelable: false,
+        });
+        this.file = file;
+    }
+}
+/**
+ * 'uploaded' event fires when a file has been successfully uploaded and extracted.
+ */
+export class uSyncFilePickerUploadedEvent extends Event {
+    constructor(result) {
+        super(USYNC_FILE_PICKER_UPLOADED_EVENT, {
+            bubbles: true,
+            composed: true,
+            cancelable: false,
+        });
+        this.result = result;
+    }
+}
+export const USYNC_ACTION_BUTTON_CLICK_EVENT = 'usync-action-click';
+export class uSyncActionButtonClickEvent extends Event {
+    constructor(button) {
+        super(USYNC_ACTION_BUTTON_CLICK_EVENT, {
+            bubbles: true,
+            composed: true,
+            cancelable: false,
+        });
+        this.button = button;
+    }
+}
+export const USYNC_ACTION_PERFORM_EVENT = 'perform-action';
+export class uSyncActionPerformEvent extends Event {
+    constructor(group, key, force, clean, file) {
+        super(USYNC_ACTION_PERFORM_EVENT, {
+            bubbles: true,
+            composed: true,
+            cancelable: false,
+        });
+        this.group = group;
+        this.key = key;
+        this.force = force;
+        this.clean = clean;
+        this.file = file;
+    }
+}

package/dist/workspace/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from './usync-action-button.js';
+export * from './usync-file-picker.element.js';
+export * from './usync-file-upload.element.js';

package/dist/workspace/components/index.js

@@ -0,0 +1,3 @@
+export * from './usync-action-button.js';
+export * from './usync-file-picker.element.js';
+export * from './usync-file-upload.element.js';