@happyvertical/smrt-reports 0.55.23 → 0.56.0

package/dist/svelte/RuntimeReportsRoute.svelte

@@ -0,0 +1,67 @@
+<script lang="ts">
+import { useI18n } from '@happyvertical/smrt-ui/i18n';
+import { onMount } from 'svelte';
+import { getRuntimeReportsBrowserClient } from './browser-client.js';
+import { M } from './messages.js';
+import SavedReports from './SavedReports.svelte';
+import type { RuntimeReportsClient } from './types.js';
+
+export interface Props {
+  client?: RuntimeReportsClient;
+  serverAvailable?: boolean;
+  /** Authenticated user id projected by the server route host. */
+  currentUserId?: string;
+  /** Opaque active tenant/session key used only to isolate browser hints. */
+  clientScope?: string;
+  /** Display label for the authenticated user; other ids stay opaque. */
+  currentUserLabel?: string;
+  /** Server-derived capability hint. Every mutation is still reauthorized. */
+  canArchive?: boolean;
+  reportHref?: (id: string) => string;
+  authorLabel?: (userId: string) => string | undefined;
+}
+let {
+  client,
+  serverAvailable = true,
+  currentUserId,
+  clientScope,
+  currentUserLabel,
+  canArchive = false,
+  reportHref,
+  authorLabel,
+}: Props = $props();
+let browserClient = $state<RuntimeReportsClient | undefined>();
+let mounted = $state(false);
+const { t } = useI18n();
+$effect(() => {
+  browserClient = client;
+  if (!client && mounted && serverAvailable) {
+    browserClient = getRuntimeReportsBrowserClient({
+      scopeKey: clientScope,
+      currentUserId,
+      canArchive,
+    });
+  }
+});
+onMount(() => {
+  mounted = true;
+  return () => {
+    mounted = false;
+  };
+});
+const resolveAuthor = (userId: string): string | undefined =>
+  authorLabel?.(userId) ??
+  (userId === currentUserId ? currentUserLabel : undefined);
+</script>
+
+<div data-smrt-component="RuntimeReportsRoute">
+  {#if serverAvailable && !browserClient}
+    <p role="status">{t(M['reports.loading'])}</p>
+  {:else}
+    <SavedReports
+      client={serverAvailable ? browserClient : undefined}
+      {reportHref}
+      authorLabel={resolveAuthor}
+    />
+  {/if}
+</div>

package/dist/svelte/RuntimeReportsRoute.svelte.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeReportsClient } from './types.js';
+export interface Props {
+    client?: RuntimeReportsClient;
+    serverAvailable?: boolean;
+    /** Authenticated user id projected by the server route host. */
+    currentUserId?: string;
+    /** Opaque active tenant/session key used only to isolate browser hints. */
+    clientScope?: string;
+    /** Display label for the authenticated user; other ids stay opaque. */
+    currentUserLabel?: string;
+    /** Server-derived capability hint. Every mutation is still reauthorized. */
+    canArchive?: boolean;
+    reportHref?: (id: string) => string;
+    authorLabel?: (userId: string) => string | undefined;
+}
+declare const RuntimeReportsRoute: import("svelte").Component<Props, {}, "">;
+type RuntimeReportsRoute = ReturnType<typeof RuntimeReportsRoute>;
+export default RuntimeReportsRoute;
+//# sourceMappingURL=RuntimeReportsRoute.svelte.d.ts.map

package/dist/svelte/RuntimeReportsRoute.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeReportsRoute.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/RuntimeReportsRoute.svelte.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4EAA4E;IAC5E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACtD;AAqDD,QAAA,MAAM,mBAAmB,2CAAwC,CAAC;AAClE,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAClE,eAAe,mBAAmB,CAAC"}

package/dist/svelte/SavedReports.svelte

@@ -0,0 +1,114 @@
+<script lang="ts">
+import { Checkbox } from '@happyvertical/smrt-ui/forms';
+import { useI18n } from '@happyvertical/smrt-ui/i18n';
+import { Button } from '@happyvertical/smrt-ui/ui';
+import { untrack } from 'svelte';
+import { M } from './messages.js';
+import { reportError } from './result.js';
+import type { RuntimeReportsClient, SavedRuntimeReport } from './types.js';
+
+export interface Props {
+  client?: RuntimeReportsClient;
+  reportHref?: (id: string) => string;
+  /** Host-owned identity projection; report transport never expands users. */
+  authorLabel?: (userId: string) => string | undefined;
+}
+let {
+  client,
+  reportHref = (id) => `/reports/${encodeURIComponent(id)}`,
+  authorLabel = (id) => id,
+}: Props = $props();
+const { t } = useI18n();
+let onlyMine = $state(false);
+let includeArchived = $state(false);
+let rows = $state<SavedRuntimeReport[]>([]);
+let loading = $state(false);
+let error = $state<ReturnType<typeof reportError> | null>(null);
+let refresh = $state(0);
+let pending = $state<string | null>(null);
+let epoch = 0;
+
+$effect(() => {
+  const transport = client;
+  const options = { onlyMine, includeArchived };
+  refresh;
+  const current = ++epoch;
+  rows = [];
+  error = null;
+  pending = null;
+  loading = !!transport;
+  if (transport) {
+    void transport
+      .list(options)
+      .then((value) => {
+        if (current === epoch) rows = value;
+      })
+      .catch((e) => {
+        if (current === epoch) error = reportError(e);
+      })
+      .finally(() => {
+        if (current === epoch) loading = false;
+      });
+  }
+  return () => {
+    ++epoch;
+  };
+});
+
+async function archive(report: SavedRuntimeReport) {
+  if (!client || pending || !report.canArchive) return;
+  const current = epoch;
+  pending = report.id;
+  error = null;
+  try {
+    await client.archive(report.id, report.status !== 'archived');
+    if (current === epoch) refresh = untrack(() => refresh) + 1;
+  } catch (e) {
+    if (current === epoch) error = reportError(e);
+  } finally {
+    if (current === epoch) pending = null;
+  }
+}
+</script>
+
+<section data-smrt-component="SavedReports" aria-label={t(M['reports.title'])}>
+  <h1>{t(M['reports.title'])}</h1>
+  {#if !client}
+    <p>{t(M['reports.unavailable'])}</p>
+  {:else}
+    <div data-smrt-part="filters">
+      <Checkbox bind:checked={onlyMine} label={t(M['reports.only_mine'])} />
+      <Checkbox bind:checked={includeArchived} label={t(M['reports.archived'])} />
+    </div>
+    {#if error}<p role="alert">{t(M[error])}</p><Button onclick={() => refresh++}>{t(M['reports.retry'])}</Button>{/if}
+    {#if loading}
+      <p role="status">{t(M['reports.loading'])}</p>
+    {:else if rows.length === 0 && !error}
+      <p>{t(M['reports.empty'])}</p>
+    {:else}
+      <ul>
+        {#each rows as report (report.id)}
+          <li>
+            <h2><a href={reportHref(report.id)}>{report.title}</a></h2>
+            <dl>
+              <dt>{t(M['reports.source'])}</dt><dd>{report.sourceId}</dd>
+              <dt>{t(M['reports.author'])}</dt><dd>{authorLabel(report.createdByUserId) ?? report.createdByUserId}</dd>
+            </dl>
+            <p>{report.lastRunAt ? t(M['reports.last_run'], { time: report.lastRunAt }) : t(M['reports.never_run'])}</p>
+            {#if report.canArchive}<Button disabled={pending !== null} onclick={() => archive(report)}>{t(M[report.status === 'archived' ? 'reports.unarchive' : 'reports.archive'])}</Button>{/if}
+          </li>
+        {/each}
+      </ul>
+    {/if}
+  {/if}
+</section>
+
+<style>
+@layer smrt.reset, smrt.structure, smrt.theme;
+@layer smrt.theme {
+  [data-smrt-part='filters'] { display: flex; flex-wrap: wrap; gap: var(--smrt-spacing-3); }
+  ul { display: grid; gap: var(--smrt-spacing-4); padding: 0; list-style: none; }
+  li { padding: var(--smrt-spacing-4); border: var(--smrt-hairline); border-radius: var(--smrt-radius-medium); }
+  dl { display: grid; grid-template-columns: auto 1fr; gap: var(--smrt-spacing-2); }
+}
+</style>

package/dist/svelte/SavedReports.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeReportsClient } from './types.js';
+export interface Props {
+    client?: RuntimeReportsClient;
+    reportHref?: (id: string) => string;
+    /** Host-owned identity projection; report transport never expands users. */
+    authorLabel?: (userId: string) => string | undefined;
+}
+declare const SavedReports: import("svelte").Component<Props, {}, "">;
+type SavedReports = ReturnType<typeof SavedReports>;
+export default SavedReports;
+//# sourceMappingURL=SavedReports.svelte.d.ts.map

package/dist/svelte/SavedReports.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SavedReports.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/SavedReports.svelte.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAsB,MAAM,YAAY,CAAC;AAG3E,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,4EAA4E;IAC5E,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACtD;AAwGD,QAAA,MAAM,YAAY,2CAAwC,CAAC;AAC3D,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACpD,eAAe,YAAY,CAAC"}

package/dist/svelte/browser-client.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeReportsClient } from './types.js';
+export interface RuntimeReportsBrowserClientOptions {
+    /** Opaque host key for the active tenant/session; carries no request authority. */
+    scopeKey?: string;
+    currentUserId?: string;
+    canArchive?: boolean;
+}
+/** One client per browser session so non-persistent last-run hints survive navigation. */
+export declare function getRuntimeReportsBrowserClient(options?: RuntimeReportsBrowserClientOptions): RuntimeReportsClient;
+//# sourceMappingURL=browser-client.d.ts.map

package/dist/svelte/browser-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-client.d.ts","sourceRoot":"","sources":["../../src/svelte/browser-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,MAAM,WAAW,kCAAkC;IACjD,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,0FAA0F;AAC1F,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,kCAAuC,GAC/C,oBAAoB,CAatB"}

package/dist/svelte/browser-client.js

@@ -0,0 +1,16 @@
+import { createRuntimeReportsHttpClient } from './client.js';
+let client;
+let identityKey = '';
+/** One client per browser session so non-persistent last-run hints survive navigation. */
+export function getRuntimeReportsBrowserClient(options = {}) {
+    if (typeof window === 'undefined')
+        throw new Error('The runtime reports browser client is unavailable during SSR');
+    // Route hosts pass server-derived identity and capability hints. Recreate the
+    // session client when that principal changes so hints never cross sessions.
+    const nextIdentityKey = `${options.scopeKey ?? ''}:${options.currentUserId ?? ''}:${options.canArchive === true}`;
+    if (!client || identityKey !== nextIdentityKey) {
+        client = createRuntimeReportsHttpClient(options);
+        identityKey = nextIdentityKey;
+    }
+    return client;
+}

package/dist/svelte/client.d.ts

@@ -0,0 +1,15 @@
+import type { RuntimeReportsClient, SavedRuntimeReport } from './types.js';
+export interface RuntimeReportsHttpClientOptions {
+    fetch?: typeof globalThis.fetch;
+    basePath?: string;
+    currentUserId?: string;
+    /** UI capability hint only. The server remains authoritative. */
+    canArchive?: boolean | ((report: Omit<SavedRuntimeReport, 'canArchive'>) => boolean);
+}
+export declare class RuntimeReportsHttpError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, code?: string | undefined);
+}
+export declare function createRuntimeReportsHttpClient(options?: RuntimeReportsHttpClientOptions): RuntimeReportsClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/svelte/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/svelte/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,+BAA+B;IAC9C,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,UAAU,CAAC,EACP,OAAO,GACP,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,KAAK,OAAO,CAAC,CAAC;CACnE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAE9C,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM;gBADb,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,YAAA;CAKzB;AA0CD,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,oBAAoB,CAoKtB"}

package/dist/svelte/client.js

@@ -0,0 +1,179 @@
+import { validReportResult } from './result.js';
+import { runtimeReportSpecFromWire } from './spec.js';
+export class RuntimeReportsHttpError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super('Runtime report request failed');
+        this.status = status;
+        this.code = code;
+        this.name = 'RuntimeReportsHttpError';
+    }
+}
+const REPORT_LIST_PAGE_LIMIT = 1_000;
+const MAX_REPORT_LIST_PAGES = 1_000;
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+async function responseJson(response) {
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        throw new RuntimeReportsHttpError(response.status);
+    }
+    if (!response.ok) {
+        const data = record(body);
+        throw new RuntimeReportsHttpError(response.status, typeof data?.code === 'string' ? data.code : undefined);
+    }
+    return body;
+}
+function safeId(value) {
+    return encodeURIComponent(value);
+}
+function confirmUrl(path) {
+    if (!path.startsWith('/') || path.startsWith('//'))
+        throw new RuntimeReportsHttpError(400, 'invalid_confirm_path');
+    if (typeof location === 'undefined')
+        return path;
+    const url = new URL(path, location.href);
+    if (url.origin !== location.origin)
+        throw new RuntimeReportsHttpError(400, 'invalid_confirm_path');
+    return `${url.pathname}${url.search}`;
+}
+export function createRuntimeReportsHttpClient(options = {}) {
+    const request = options.fetch ?? globalThis.fetch;
+    if (typeof request !== 'function')
+        throw new Error('Runtime reports require a fetch implementation');
+    const basePath = (options.basePath ?? '/api/runtimereports').replace(/\/$/, '');
+    const lastRuns = new Map();
+    const project = (value) => {
+        const row = record(value);
+        if (!row)
+            throw new RuntimeReportsHttpError(502, 'invalid_result');
+        const spec = runtimeReportSpecFromWire(row.spec);
+        if (!spec ||
+            typeof row.id !== 'string' ||
+            typeof row.title !== 'string' ||
+            typeof row.sourceId !== 'string' ||
+            typeof row.createdByUserId !== 'string' ||
+            (row.status !== 'active' && row.status !== 'archived')) {
+            throw new RuntimeReportsHttpError(502, 'invalid_result');
+        }
+        const projected = {
+            id: row.id,
+            title: row.title,
+            ...(typeof row.description === 'string' && row.description
+                ? { description: row.description }
+                : {}),
+            sourceId: row.sourceId,
+            createdByUserId: row.createdByUserId,
+            status: row.status,
+            spec,
+            ...(lastRuns.has(row.id) ? { lastRunAt: lastRuns.get(row.id) } : {}),
+        };
+        const canArchive = typeof options.canArchive === 'function'
+            ? options.canArchive(projected)
+            : options.canArchive === true;
+        return { ...projected, canArchive };
+    };
+    const get = async (id) => project(await responseJson(await request(`${basePath}/${safeId(id)}`, {
+        headers: { accept: 'application/json' },
+    })));
+    return {
+        async list({ onlyMine, includeArchived }) {
+            const filters = new URLSearchParams();
+            if (!includeArchived)
+                filters.set('status', 'active');
+            if (onlyMine) {
+                if (!options.currentUserId)
+                    throw new RuntimeReportsHttpError(400, 'missing_current_user');
+                filters.set('createdByUserId', options.currentUserId);
+            }
+            const reports = [];
+            const seenReportIds = new Set();
+            let offset = 0;
+            for (let page = 0; page < MAX_REPORT_LIST_PAGES; page++) {
+                const query = new URLSearchParams(filters);
+                query.set('limit', String(REPORT_LIST_PAGE_LIMIT));
+                query.set('offset', String(offset));
+                const body = record(await responseJson(await request(`${basePath}?${query}`, {
+                    headers: { accept: 'application/json' },
+                })));
+                if (!body ||
+                    !Array.isArray(body.items) ||
+                    typeof body.count !== 'number' ||
+                    !Number.isSafeInteger(body.count) ||
+                    body.count < 0 ||
+                    typeof body.limit !== 'number' ||
+                    !Number.isSafeInteger(body.limit) ||
+                    body.limit < 1 ||
+                    body.limit > REPORT_LIST_PAGE_LIMIT ||
+                    typeof body.offset !== 'number' ||
+                    !Number.isSafeInteger(body.offset) ||
+                    body.offset !== offset ||
+                    body.items.length > body.limit) {
+                    throw new RuntimeReportsHttpError(502, 'invalid_result');
+                }
+                const pageReports = body.items.map(project);
+                for (const report of pageReports) {
+                    if (seenReportIds.has(report.id))
+                        throw new RuntimeReportsHttpError(502, 'invalid_result');
+                    seenReportIds.add(report.id);
+                }
+                reports.push(...pageReports);
+                offset += body.items.length;
+                if (offset >= body.count)
+                    return reports;
+                if (body.items.length === 0)
+                    throw new RuntimeReportsHttpError(502, 'invalid_result');
+            }
+            throw new RuntimeReportsHttpError(502, 'invalid_result');
+        },
+        get,
+        async run(id) {
+            const body = record(await responseJson(await request(`${basePath}/${safeId(id)}/run`, {
+                method: 'POST',
+                headers: { accept: 'application/json' },
+            })));
+            if (body?.action !== 'run' || !validReportResult(body.result))
+                throw new RuntimeReportsHttpError(502, 'invalid_result');
+            lastRuns.set(id, body.result.ranAt);
+            return body.result;
+        },
+        async archive(id, archived) {
+            const body = record(await responseJson(await request(`${basePath}/${safeId(id)}/archive`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({ archived }),
+            })));
+            const result = record(body?.result);
+            if (body?.action !== 'archive' ||
+                result?.id !== id ||
+                result.status !== (archived ? 'archived' : 'active'))
+                throw new RuntimeReportsHttpError(502, 'invalid_result');
+        },
+        async confirm(proposal) {
+            const body = record(await responseJson(await request(confirmUrl(proposal.confirmPath), {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    spec: proposal.spec,
+                    specHash: proposal.specHash,
+                }),
+            })));
+            if (typeof body?.id !== 'string' || body.specHash !== proposal.specHash)
+                throw new RuntimeReportsHttpError(502, 'invalid_result');
+            return get(body.id);
+        },
+    };
+}

package/dist/svelte/index.d.ts

@@ -0,0 +1,15 @@
+export { getRuntimeReportsBrowserClient, type RuntimeReportsBrowserClientOptions, } from './browser-client.js';
+export { createRuntimeReportsHttpClient, type RuntimeReportsHttpClientOptions, RuntimeReportsHttpError, } from './client.js';
+export { default as ReportConfirmation } from './ReportConfirmation.svelte';
+export { default as ReportDetail } from './ReportDetail.svelte';
+export { default as ReportPicker } from './ReportPicker.svelte';
+export { default as ReportResult } from './ReportResult.svelte';
+export { default as RuntimeReportChartWidget } from './RuntimeReportChartWidget.svelte';
+export { default as RuntimeReportDetailRoute } from './RuntimeReportDetailRoute.svelte';
+export { default as RuntimeReportsRoute } from './RuntimeReportsRoute.svelte';
+export { default as RuntimeReportToolResult } from './RuntimeReportToolResult.svelte';
+export { default as RuntimeReportWidgetOptions } from './RuntimeReportWidgetOptions.svelte';
+export { default as SavedReports } from './SavedReports.svelte';
+export { runtimeReportProposalFromMessage, runtimeReportToolResultComponent, type ToolResultMessage, } from './tool-result.js';
+export type { RuntimeReportProposal, RuntimeReportResult, RuntimeReportSpec, RuntimeReportsClient, SavedRuntimeReport, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/svelte/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,KAAK,kCAAkC,GACxC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,8BAA8B,EAC9B,KAAK,+BAA+B,EACpC,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAC9E,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACtF,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAC5F,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EACL,gCAAgC,EAChC,gCAAgC,EAChC,KAAK,iBAAiB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/svelte/index.js

@@ -0,0 +1,13 @@
+export { getRuntimeReportsBrowserClient, } from './browser-client.js';
+export { createRuntimeReportsHttpClient, RuntimeReportsHttpError, } from './client.js';
+export { default as ReportConfirmation } from './ReportConfirmation.svelte';
+export { default as ReportDetail } from './ReportDetail.svelte';
+export { default as ReportPicker } from './ReportPicker.svelte';
+export { default as ReportResult } from './ReportResult.svelte';
+export { default as RuntimeReportChartWidget } from './RuntimeReportChartWidget.svelte';
+export { default as RuntimeReportDetailRoute } from './RuntimeReportDetailRoute.svelte';
+export { default as RuntimeReportsRoute } from './RuntimeReportsRoute.svelte';
+export { default as RuntimeReportToolResult } from './RuntimeReportToolResult.svelte';
+export { default as RuntimeReportWidgetOptions } from './RuntimeReportWidgetOptions.svelte';
+export { default as SavedReports } from './SavedReports.svelte';
+export { runtimeReportProposalFromMessage, runtimeReportToolResultComponent, } from './tool-result.js';

package/dist/svelte/messages.d.ts

@@ -0,0 +1,72 @@
+export declare const M: {
+    readonly 'reports.title': "reports.title";
+    readonly 'reports.only_mine': "reports.only_mine";
+    readonly 'reports.archived': "reports.archived";
+    readonly 'reports.archive': "reports.archive";
+    readonly 'reports.unarchive': "reports.unarchive";
+    readonly 'reports.loading': "reports.loading";
+    readonly 'reports.running': "reports.running";
+    readonly 'reports.empty': "reports.empty";
+    readonly 'reports.no_rows': "reports.no_rows";
+    readonly 'reports.unavailable': "reports.unavailable";
+    readonly 'reports.error': "reports.error";
+    readonly 'reports.denied': "reports.denied";
+    readonly 'reports.invalid': "reports.invalid";
+    readonly 'reports.retry': "reports.retry";
+    readonly 'reports.rerun': "reports.rerun";
+    readonly 'reports.table': "reports.table";
+    readonly 'reports.chart': "reports.chart";
+    readonly 'reports.source': "reports.source";
+    readonly 'reports.author': "reports.author";
+    readonly 'reports.last_run': "reports.last_run";
+    readonly 'reports.never_run': "reports.never_run";
+    readonly 'reports.truncated': "reports.truncated";
+    readonly 'reports.yes': "reports.yes";
+    readonly 'reports.no': "reports.no";
+    readonly 'reports.select_report': "reports.select_report";
+    readonly 'reports.select_measure': "reports.select_measure";
+    readonly 'reports.choose_report': "reports.choose_report";
+    readonly 'reports.choose_measure': "reports.choose_measure";
+    readonly 'reports.select_dimension': "reports.select_dimension";
+    readonly 'reports.choose_dimension': "reports.choose_dimension";
+    readonly 'reports.options_invalid': "reports.options_invalid";
+    readonly 'reports.cancel': "reports.cancel";
+    readonly 'reports.save': "reports.save";
+    readonly 'reports.confirm_title': "reports.confirm_title";
+    readonly 'reports.saved': "reports.saved";
+    readonly 'reports.declined': "reports.declined";
+    readonly 'reports.groupings': "reports.groupings";
+    readonly 'reports.measures': "reports.measures";
+    readonly 'reports.filters': "reports.filters";
+    readonly 'reports.having': "reports.having";
+    readonly 'reports.none': "reports.none";
+    readonly 'reports.rows': "reports.rows";
+    readonly 'reports.saving': "reports.saving";
+    readonly 'reports.approve': "reports.approve";
+    readonly 'reports.decline': "reports.decline";
+    readonly 'reports.aggregate.count': "reports.aggregate.count";
+    readonly 'reports.aggregate.countDistinct': "reports.aggregate.countDistinct";
+    readonly 'reports.aggregate.sum': "reports.aggregate.sum";
+    readonly 'reports.aggregate.avg': "reports.aggregate.avg";
+    readonly 'reports.aggregate.min': "reports.aggregate.min";
+    readonly 'reports.aggregate.max': "reports.aggregate.max";
+    readonly 'reports.operator.eq': "reports.operator.eq";
+    readonly 'reports.operator.ne': "reports.operator.ne";
+    readonly 'reports.operator.gt': "reports.operator.gt";
+    readonly 'reports.operator.gte': "reports.operator.gte";
+    readonly 'reports.operator.lt': "reports.operator.lt";
+    readonly 'reports.operator.lte': "reports.operator.lte";
+    readonly 'reports.operator.in': "reports.operator.in";
+    readonly 'reports.operator.notIn': "reports.operator.notIn";
+    readonly 'reports.operator.contains': "reports.operator.contains";
+    readonly 'reports.operator.isNull': "reports.operator.isNull";
+    readonly 'reports.operator.isNotNull': "reports.operator.isNotNull";
+    readonly 'reports.bucket.minute': "reports.bucket.minute";
+    readonly 'reports.bucket.hour': "reports.bucket.hour";
+    readonly 'reports.bucket.day': "reports.bucket.day";
+    readonly 'reports.bucket.week': "reports.bucket.week";
+    readonly 'reports.bucket.month': "reports.bucket.month";
+    readonly 'reports.bucket.quarter': "reports.bucket.quarter";
+    readonly 'reports.bucket.year': "reports.bucket.year";
+};
+//# sourceMappingURL=messages.d.ts.map

package/dist/svelte/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/svelte/messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEZ,CAAC"}

package/dist/svelte/messages.js

@@ -0,0 +1,72 @@
+import { defineMessages } from '@happyvertical/smrt-ui/i18n';
+export const M = defineMessages({
+    'reports.title': 'Reports',
+    'reports.only_mine': 'Only mine',
+    'reports.archived': 'Show archived reports',
+    'reports.archive': 'Archive',
+    'reports.unarchive': 'Unarchive',
+    'reports.loading': 'Loading reports…',
+    'reports.running': 'Running report…',
+    'reports.empty': 'No saved reports. Ask the assistant to create a report, then approve its proposal.',
+    'reports.no_rows': 'No results match this report.',
+    'reports.unavailable': 'Reports are unavailable because this host has no server.',
+    'reports.error': 'The report request failed. Please try again.',
+    'reports.denied': 'You do not have permission to read this report or one of its fields.',
+    'reports.invalid': 'The report returned an invalid result.',
+    'reports.retry': 'Try again',
+    'reports.rerun': 'Re-run',
+    'reports.table': 'Table view',
+    'reports.chart': 'Chart view',
+    'reports.source': 'Source',
+    'reports.author': 'Author',
+    'reports.last_run': 'Last run: {time}',
+    'reports.never_run': 'No recent run',
+    'reports.truncated': 'Showing a bounded sample; more rows are available.',
+    'reports.yes': 'Yes',
+    'reports.no': 'No',
+    'reports.select_report': 'Report',
+    'reports.select_measure': 'Measure',
+    'reports.choose_report': 'Choose a saved report',
+    'reports.choose_measure': 'Choose a measure',
+    'reports.select_dimension': 'Dimension',
+    'reports.choose_dimension': 'Choose a dimension',
+    'reports.options_invalid': 'Choose a report and measure before saving.',
+    'reports.cancel': 'Cancel',
+    'reports.save': 'Save',
+    'reports.confirm_title': 'Review report proposal',
+    'reports.saved': 'Report saved.',
+    'reports.declined': 'Report declined. Nothing was saved.',
+    'reports.groupings': 'Group by',
+    'reports.measures': 'Measures',
+    'reports.filters': 'Filters',
+    'reports.having': 'Measure filters',
+    'reports.none': 'None',
+    'reports.rows': 'rows',
+    'reports.saving': 'Saving…',
+    'reports.approve': 'Approve',
+    'reports.decline': 'Decline',
+    'reports.aggregate.count': 'Count of {field}',
+    'reports.aggregate.countDistinct': 'Distinct count of {field}',
+    'reports.aggregate.sum': 'Sum of {field}',
+    'reports.aggregate.avg': 'Average of {field}',
+    'reports.aggregate.min': 'Minimum of {field}',
+    'reports.aggregate.max': 'Maximum of {field}',
+    'reports.operator.eq': 'equals',
+    'reports.operator.ne': 'does not equal',
+    'reports.operator.gt': 'is greater than',
+    'reports.operator.gte': 'is at least',
+    'reports.operator.lt': 'is less than',
+    'reports.operator.lte': 'is at most',
+    'reports.operator.in': 'is one of',
+    'reports.operator.notIn': 'is not one of',
+    'reports.operator.contains': 'contains',
+    'reports.operator.isNull': 'is empty',
+    'reports.operator.isNotNull': 'is not empty',
+    'reports.bucket.minute': 'Minute',
+    'reports.bucket.hour': 'Hour',
+    'reports.bucket.day': 'Day',
+    'reports.bucket.week': 'Week',
+    'reports.bucket.month': 'Month',
+    'reports.bucket.quarter': 'Quarter',
+    'reports.bucket.year': 'Year',
+});