@bpmnkit/operate 0.0.5

package/dist/operate.js

@@ -0,0 +1,308 @@
+import { applyTheme, injectUiStyles, loadPersistedTheme } from "@bpmnkit/ui";
+import { injectOperateStyles } from "./css.js";
+import { createRouter } from "./router.js";
+import { DashboardStore } from "./stores/dashboard.js";
+import { DecisionsStore } from "./stores/decisions.js";
+import { DefinitionsStore } from "./stores/definitions.js";
+import { IncidentsStore } from "./stores/incidents.js";
+import { InstancesStore } from "./stores/instances.js";
+import { JobsStore } from "./stores/jobs.js";
+import { TasksStore } from "./stores/tasks.js";
+import { createDashboardView } from "./views/dashboard.js";
+import { createDecisionDetailView } from "./views/decision-detail.js";
+import { createDecisionsView } from "./views/decisions.js";
+import { createDefinitionDetailView } from "./views/definition-detail.js";
+import { createDefinitionsView } from "./views/definitions.js";
+import { createHeader } from "./views/header.js";
+import { createIncidentDetailView } from "./views/incident-detail.js";
+import { createIncidentsView } from "./views/incidents.js";
+import { createInstanceDetailView } from "./views/instance-detail.js";
+import { createInstancesView } from "./views/instances.js";
+import { createJobsView } from "./views/jobs.js";
+import { createMessagesView } from "./views/messages.js";
+import { createNav } from "./views/nav.js";
+import { createTaskDetailView } from "./views/task-detail.js";
+import { createTasksView } from "./views/tasks.js";
+export function createOperate(options) {
+    injectUiStyles();
+    injectOperateStyles();
+    const { container, proxyUrl = "http://localhost:3033", pollInterval = 30_000, mock = false, } = options;
+    let profile = options.profile ?? null;
+    const initialTheme = loadPersistedTheme() ?? options.theme ?? "auto";
+    // ── Root element ──────────────────────────────────────────────────────────
+    const el = document.createElement("div");
+    el.className = "op-root";
+    applyTheme(el, initialTheme);
+    container.appendChild(el);
+    // ── Stores ────────────────────────────────────────────────────────────────
+    const dashStore = new DashboardStore();
+    const defStore = new DefinitionsStore();
+    const decStore = new DecisionsStore();
+    const instStore = new InstancesStore();
+    const incStore = new IncidentsStore();
+    const jobStore = new JobsStore();
+    const taskStore = new TasksStore();
+    function disconnectAll() {
+        dashStore.disconnect();
+        defStore.disconnect();
+        decStore.disconnect();
+        instStore.disconnect();
+        incStore.disconnect();
+        jobStore.disconnect();
+        taskStore.disconnect();
+    }
+    let reconnectCurrent = null;
+    function connectAll() {
+        reconnectCurrent?.();
+    }
+    // ── Profiles ──────────────────────────────────────────────────────────────
+    let profiles = [];
+    if (!mock) {
+        fetchProfiles();
+    }
+    else {
+        profiles = [{ name: "demo", active: true, apiType: "saas", baseUrl: null, authType: "none" }];
+    }
+    function fetchProfiles() {
+        fetch(`${proxyUrl}/profiles`)
+            .then((r) => r.json())
+            .then((data) => {
+            profiles = data;
+            const active = data.find((p) => p.active);
+            if (!profile && active)
+                profile = active.name;
+            header.setProfiles(profiles, profile);
+        })
+            .catch(() => { });
+    }
+    // ── Layout ────────────────────────────────────────────────────────────────
+    const layout = document.createElement("div");
+    layout.className = "op-layout";
+    el.appendChild(layout);
+    const router = createRouter();
+    const nav = createNav((path) => router.navigate(path));
+    layout.appendChild(nav.el);
+    const main = document.createElement("div");
+    main.className = "op-main";
+    layout.appendChild(main);
+    const header = createHeader((name) => {
+        profile = name;
+        connectAll();
+    }, (theme, resolved) => {
+        el.setAttribute("data-theme", resolved);
+        currentTheme = theme;
+        currentViewSetTheme?.(resolved);
+    }, initialTheme);
+    header.setProfiles(profiles, profile);
+    main.appendChild(header.el);
+    const content = document.createElement("div");
+    content.className = "op-content";
+    main.appendChild(content);
+    // ── Router ────────────────────────────────────────────────────────────────
+    let destroyView = null;
+    let currentTheme = initialTheme;
+    let currentViewSetTheme = null;
+    function showView(viewEl, destroy, setTheme) {
+        destroyView?.();
+        destroyView = destroy;
+        currentViewSetTheme = setTheme ?? null;
+        content.innerHTML = "";
+        content.appendChild(viewEl);
+    }
+    function getTheme() {
+        return el.getAttribute("data-theme") === "light" ? "light" : "dark";
+    }
+    router.on("/", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            dashStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Dashboard");
+        nav.setActive("/");
+        const { el: vEl, destroy } = createDashboardView(dashStore, (path) => router.navigate(path));
+        showView(vEl, destroy);
+    });
+    router.on("/definitions", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            defStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Processes");
+        nav.setActive("/definitions");
+        const { el: vEl, destroy } = createDefinitionsView(defStore, (def) => {
+            router.navigate(`/definitions/${def.processDefinitionKey ?? ""}`);
+        });
+        showView(vEl, destroy);
+    });
+    router.on("/definitions/:key", (params) => {
+        disconnectAll();
+        reconnectCurrent = () => {
+            disconnectAll();
+        };
+        header.setTitle("Process Definition");
+        nav.setActive("/definitions");
+        const { el: vEl, destroy, setTheme, } = createDefinitionDetailView(params.key ?? "", defStore, { proxyUrl, profile, mock, theme: getTheme(), navigate: (path) => router.navigate(path) }, () => router.navigate("/definitions"));
+        showView(vEl, destroy, setTheme);
+    });
+    router.on("/decisions", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            decStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Decisions");
+        nav.setActive("/decisions");
+        const { el: vEl, destroy } = createDecisionsView(decStore, (def) => {
+            router.navigate(`/decisions/${def.decisionDefinitionKey}`);
+        });
+        showView(vEl, destroy);
+    });
+    router.on("/decisions/:key", (params) => {
+        disconnectAll();
+        reconnectCurrent = () => {
+            disconnectAll();
+            decStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Decision Definition");
+        nav.setActive("/decisions");
+        const { el: vEl, destroy, setTheme, } = createDecisionDetailView(params.key ?? "", decStore, { proxyUrl, profile, mock, theme: getTheme(), navigate: (path) => router.navigate(path) }, () => router.navigate("/decisions"));
+        showView(vEl, destroy, setTheme);
+    });
+    router.on("/instances", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            instStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Instances");
+        nav.setActive("/instances");
+        const { el: vEl, destroy } = createInstancesView(instStore, (inst) => router.navigate(`/instances/${inst.processInstanceKey}`), (state) => {
+            instStore.connect(proxyUrl, profile, pollInterval, mock, { state: state || undefined });
+        });
+        showView(vEl, destroy);
+    });
+    router.on("/instances/:key", (params) => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            instStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        const instanceKey = params.key ?? "";
+        header.setTitle(`Instance ${instanceKey}`);
+        nav.setActive("/instances");
+        const { el: vEl, destroy, setTheme, } = createInstanceDetailView(instanceKey, instStore, {
+            proxyUrl,
+            profile,
+            interval: pollInterval,
+            mock,
+            theme: getTheme(),
+            navigate: (path) => router.navigate(path),
+        }, () => router.navigate("/instances"));
+        showView(vEl, destroy, setTheme);
+    });
+    router.on("/incidents", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            incStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Incidents");
+        nav.setActive("/incidents");
+        const { el: vEl, destroy } = createIncidentsView(incStore, (inc) => {
+            router.navigate(`/incidents/${inc.incidentKey ?? ""}`);
+        });
+        showView(vEl, destroy);
+    });
+    router.on("/incidents/:key", (params) => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            incStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        const incidentKey = params.key ?? "";
+        header.setTitle(`Incident ${incidentKey}`);
+        nav.setActive("/incidents");
+        const { el: vEl, destroy } = createIncidentDetailView(incidentKey, incStore, { proxyUrl, profile, mock, theme: getTheme(), navigate: (path) => router.navigate(path) }, () => router.navigate("/incidents"));
+        showView(vEl, destroy);
+    });
+    router.on("/jobs", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            jobStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Jobs");
+        nav.setActive("/jobs");
+        const { el: vEl, destroy } = createJobsView(jobStore);
+        showView(vEl, destroy);
+    });
+    router.on("/tasks", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            taskStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        header.setTitle("Tasks");
+        nav.setActive("/tasks");
+        const { el: vEl, destroy } = createTasksView(taskStore, (task) => {
+            router.navigate(`/tasks/${task.userTaskKey}`);
+        });
+        showView(vEl, destroy);
+    });
+    router.on("/tasks/:key", (params) => {
+        reconnectCurrent = () => {
+            disconnectAll();
+            taskStore.connect(proxyUrl, profile, pollInterval, mock);
+        };
+        reconnectCurrent();
+        const taskKey = params.key ?? "";
+        header.setTitle(`Task ${taskKey}`);
+        nav.setActive("/tasks");
+        const { el: vEl, destroy } = createTaskDetailView(taskKey, taskStore, { proxyUrl, profile, mock, theme: getTheme() }, () => router.navigate("/tasks"));
+        showView(vEl, destroy);
+    });
+    router.on("/messages", () => {
+        reconnectCurrent = () => {
+            disconnectAll();
+        };
+        reconnectCurrent();
+        header.setTitle("Messages & Signals");
+        nav.setActive("/messages");
+        const { el: vEl, destroy } = createMessagesView({ proxyUrl, profile, mock });
+        showView(vEl, destroy);
+    });
+    const stopRouter = router.start();
+    // ── Public API ────────────────────────────────────────────────────────────
+    return {
+        el,
+        setProfile(name) {
+            profile = name;
+            connectAll();
+            header.setProfiles(profiles, profile);
+        },
+        setTheme(t) {
+            currentTheme = t;
+            applyTheme(el, t);
+            header.setTheme(t);
+        },
+        navigate(path) {
+            router.navigate(path);
+        },
+        destroy() {
+            stopRouter();
+            destroyView?.();
+            dashStore.destroy();
+            defStore.destroy();
+            decStore.destroy();
+            instStore.destroy();
+            incStore.destroy();
+            jobStore.destroy();
+            taskStore.destroy();
+            el.remove();
+        },
+    };
+}
+//# sourceMappingURL=operate.js.map

package/dist/router.d.ts

@@ -0,0 +1,9 @@
+type RouteHandler = (params: Record<string, string>) => void;
+export declare function createRouter(): {
+    on(path: string, handler: RouteHandler): void;
+    navigate(path: string): void;
+    start(): () => void;
+    currentPath(): string;
+};
+export {};
+//# sourceMappingURL=router.d.ts.map

package/dist/router.js

@@ -0,0 +1,49 @@
+export function createRouter() {
+    const routes = [];
+    let _current = "/";
+    function patternFor(path) {
+        const keys = [];
+        const src = path.replace(/:([^/]+)/g, (_, key) => {
+            keys.push(key);
+            return "([^/]+)";
+        });
+        return { pattern: new RegExp(`^${src}$`), keys };
+    }
+    function dispatch(path) {
+        _current = path;
+        for (const route of routes) {
+            const m = route.pattern.exec(path);
+            if (m) {
+                const params = {};
+                for (let i = 0; i < route.keys.length; i++) {
+                    const key = route.keys[i];
+                    if (key)
+                        params[key] = m[i + 1] ?? "";
+                }
+                route.handler(params);
+                return;
+            }
+        }
+    }
+    function on(path, handler) {
+        const { pattern, keys } = patternFor(path);
+        routes.push({ pattern, keys, handler });
+    }
+    function navigate(path) {
+        window.location.hash = path;
+    }
+    function onHashChange() {
+        const hash = window.location.hash.slice(1) || "/";
+        dispatch(hash);
+    }
+    function start() {
+        window.addEventListener("hashchange", onHashChange);
+        onHashChange();
+        return () => window.removeEventListener("hashchange", onHashChange);
+    }
+    function currentPath() {
+        return _current;
+    }
+    return { on, navigate, start, currentPath };
+}
+//# sourceMappingURL=router.js.map

package/dist/stores/base.d.ts

@@ -0,0 +1,20 @@
+export interface StoreState<T> {
+    data: T | null;
+    loading: boolean;
+    error: string | null;
+}
+type Listener = () => void;
+export declare class Store<T> {
+    private _state;
+    private _listeners;
+    private _unsub;
+    get state(): StoreState<T>;
+    subscribe(fn: Listener): () => void;
+    protected set(patch: Partial<StoreState<T>>): void;
+    protected setUnsub(unsub: () => void): void;
+    /** Stop polling without clearing data or listeners. Safe to reconnect later. */
+    disconnect(): void;
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=base.d.ts.map

package/dist/stores/base.js

@@ -0,0 +1,32 @@
+export class Store {
+    _state = { data: null, loading: false, error: null };
+    _listeners = new Set();
+    _unsub = null;
+    get state() {
+        return this._state;
+    }
+    subscribe(fn) {
+        this._listeners.add(fn);
+        return () => this._listeners.delete(fn);
+    }
+    set(patch) {
+        this._state = { ...this._state, ...patch };
+        for (const fn of this._listeners)
+            fn();
+    }
+    setUnsub(unsub) {
+        this._unsub?.();
+        this._unsub = unsub;
+    }
+    /** Stop polling without clearing data or listeners. Safe to reconnect later. */
+    disconnect() {
+        this._unsub?.();
+        this._unsub = null;
+    }
+    destroy() {
+        this._unsub?.();
+        this._unsub = null;
+        this._listeners.clear();
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/stores/dashboard.d.ts

@@ -0,0 +1,6 @@
+import type { DashboardData } from "../types.js";
+import { Store } from "./base.js";
+export declare class DashboardStore extends Store<DashboardData> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean): void;
+}
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/stores/dashboard.js

@@ -0,0 +1,19 @@
+import { getMockDashboard } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class DashboardStore extends Store {
+    connect(proxyUrl, profile, interval, mock) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            this.setUnsub(createMockStream(getMockDashboard, (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "dashboard" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/stores/decisions.d.ts

@@ -0,0 +1,9 @@
+import type { DecisionDefinitionResult } from "../types.js";
+import { Store } from "./base.js";
+export interface DecisionsPayload {
+    items: DecisionDefinitionResult[];
+}
+export declare class DecisionsStore extends Store<DecisionsPayload> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean): void;
+}
+//# sourceMappingURL=decisions.d.ts.map

package/dist/stores/decisions.js

@@ -0,0 +1,19 @@
+import { MOCK_DECISIONS } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class DecisionsStore extends Store {
+    connect(proxyUrl, profile, interval, mock) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            this.setUnsub(createMockStream(() => ({ items: MOCK_DECISIONS }), (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "decisions" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=decisions.js.map

package/dist/stores/definitions.d.ts

@@ -0,0 +1,9 @@
+import type { ProcessDefinitionResult } from "../types.js";
+import { Store } from "./base.js";
+export interface DefinitionsPayload {
+    items: ProcessDefinitionResult[];
+}
+export declare class DefinitionsStore extends Store<DefinitionsPayload> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean): void;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/stores/definitions.js

@@ -0,0 +1,19 @@
+import { MOCK_DEFINITIONS } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class DefinitionsStore extends Store {
+    connect(proxyUrl, profile, interval, mock) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            this.setUnsub(createMockStream(() => ({ items: MOCK_DEFINITIONS }), (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "definitions" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=definitions.js.map

package/dist/stores/incidents.d.ts

@@ -0,0 +1,10 @@
+import type { IncidentResult } from "../types.js";
+import { Store } from "./base.js";
+export interface IncidentsPayload {
+    items: IncidentResult[];
+    total: number;
+}
+export declare class IncidentsStore extends Store<IncidentsPayload> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean, processInstanceKey?: string): void;
+}
+//# sourceMappingURL=incidents.d.ts.map

package/dist/stores/incidents.js

@@ -0,0 +1,27 @@
+import { MOCK_INCIDENTS } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class IncidentsStore extends Store {
+    connect(proxyUrl, profile, interval, mock, processInstanceKey) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            const getFiltered = () => {
+                const items = processInstanceKey
+                    ? MOCK_INCIDENTS.filter((i) => i.processInstanceKey === processInstanceKey)
+                    : MOCK_INCIDENTS;
+                return { items, total: items.length };
+            };
+            this.setUnsub(createMockStream(getFiltered, (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "incidents" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        if (processInstanceKey)
+            params.set("processInstanceKey", processInstanceKey);
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=incidents.js.map

package/dist/stores/instances.d.ts

@@ -0,0 +1,15 @@
+import type { ProcessInstanceResult } from "../types.js";
+import { Store } from "./base.js";
+export interface InstancesPayload {
+    items: ProcessInstanceResult[];
+    total: number;
+}
+export interface InstancesFilter {
+    state?: string;
+    processDefinitionKey?: string;
+    page?: number;
+}
+export declare class InstancesStore extends Store<InstancesPayload> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean, filter?: InstancesFilter): void;
+}
+//# sourceMappingURL=instances.d.ts.map

package/dist/stores/instances.js

@@ -0,0 +1,33 @@
+import { MOCK_INSTANCES } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class InstancesStore extends Store {
+    connect(proxyUrl, profile, interval, mock, filter = {}) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            const getFiltered = () => {
+                let items = MOCK_INSTANCES;
+                if (filter.state)
+                    items = items.filter((i) => i.state === filter.state);
+                if (filter.processDefinitionKey)
+                    items = items.filter((i) => i.processDefinitionKey === filter.processDefinitionKey);
+                return { items, total: items.length };
+            };
+            this.setUnsub(createMockStream(getFiltered, (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "instances" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        if (filter.state)
+            params.set("state", filter.state);
+        if (filter.processDefinitionKey)
+            params.set("processDefinitionKey", filter.processDefinitionKey);
+        if (filter.page)
+            params.set("page", String(filter.page));
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=instances.js.map

package/dist/stores/jobs.d.ts

@@ -0,0 +1,10 @@
+import type { JobSearchResult } from "../types.js";
+import { Store } from "./base.js";
+export interface JobsPayload {
+    items: JobSearchResult[];
+    total: number;
+}
+export declare class JobsStore extends Store<JobsPayload> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean): void;
+}
+//# sourceMappingURL=jobs.d.ts.map

package/dist/stores/jobs.js

@@ -0,0 +1,19 @@
+import { MOCK_JOBS } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class JobsStore extends Store {
+    connect(proxyUrl, profile, interval, mock) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            this.setUnsub(createMockStream(() => ({ items: MOCK_JOBS, total: MOCK_JOBS.length }), (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "jobs" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=jobs.js.map

package/dist/stores/tasks.d.ts

@@ -0,0 +1,10 @@
+import type { UserTaskResult } from "../types.js";
+import { Store } from "./base.js";
+export interface TasksPayload {
+    items: UserTaskResult[];
+    total: number;
+}
+export declare class TasksStore extends Store<TasksPayload> {
+    connect(proxyUrl: string, profile: string | null, interval: number, mock: boolean): void;
+}
+//# sourceMappingURL=tasks.d.ts.map

package/dist/stores/tasks.js

@@ -0,0 +1,19 @@
+import { MOCK_TASKS } from "../mock-data.js";
+import { createMockStream, createStream } from "../stream.js";
+import { Store } from "./base.js";
+export class TasksStore extends Store {
+    connect(proxyUrl, profile, interval, mock) {
+        this.set({ loading: true, error: null });
+        if (mock) {
+            this.setUnsub(createMockStream(() => ({ items: MOCK_TASKS, total: MOCK_TASKS.length }), (payload) => this.set({ data: payload, loading: false }), interval));
+            return;
+        }
+        const params = new URLSearchParams({ topic: "tasks" });
+        if (profile)
+            params.set("profile", profile);
+        if (interval > 0)
+            params.set("interval", String(interval));
+        this.setUnsub(createStream(`${proxyUrl}/operate/stream?${params}`, (payload) => this.set({ data: payload, loading: false }), (msg) => this.set({ error: msg, loading: false })));
+    }
+}
+//# sourceMappingURL=tasks.js.map