@things-factory/ai-dashboard 0.0.0-stage → 10.1.213

package/client/pages/my-dashboard-page.ts

@@ -0,0 +1,371 @@
+/*
+ * 나의 대시보드 - the cards a person placed, drawn from the data as them (ADR-0160 decision 8).
+ *
+ * Cards are made in the AI conversation beside the page (its card tool is in front here) and saved by pressing the
+ * card there; the library holds one's own cards and those shared with one. The page asks no model: each card asks
+ * the server to run its definition, each on its own, so a slow card waits in its place.
+ */
+import '@material/web/icon/icon.js'
+import '../components/dashboard-card.js'
+import '../components/card-library.js'
+
+import { css, html, nothing } from 'lit'
+import { customElement, state } from 'lit/decorators.js'
+
+import { i18next, localize } from '@operato/i18n'
+import { notify, openPopup } from '@operato/layout'
+import { PageView } from '@operato/shell'
+import { DocumentPageStyles, ScrollbarStyles } from '@operato/styles'
+import { askAssistant } from '@things-factory/ai-assistant/dist-client/index.js'
+
+import { cardApi, DASHBOARD_CHANGED, dashboardChanged, type CardItem, type PlaceItem } from '../utils/card-api.js'
+import { movedPlaces } from '../utils/card-words.js'
+import { openCardAiPrompt, openCardRename, openCardShare, openCardVersions } from '../components/card-dialogs.js'
+import type { CardAction } from '../components/dashboard-card.js'
+
+const t = (key: string, options: Record<string, unknown> = {}) => String(i18next.t(key, options))
+
+/** The requests the empty dashboard offers - each sent to the conversation beside the page as it is. */
+const EXAMPLES = ['ai-dashboard.example.receivables', 'ai-dashboard.example.cash-trend', 'ai-dashboard.example.month-count']
+
+@customElement('my-dashboard-page')
+export class MyDashboardPage extends localize(i18next)(PageView) {
+  static styles = [
+    DocumentPageStyles,
+    ScrollbarStyles,
+    css`
+      .page {
+        gap: var(--spacing-large, 16px);
+      }
+
+      .lead {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 8px 16px;
+      }
+
+      .lead p {
+        flex: 1;
+        min-width: 240px;
+        margin: 0;
+        color: var(--ui-muted, var(--md-sys-color-on-surface-variant));
+      }
+
+      .chip {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        padding: 4px 10px;
+        border-radius: 999px;
+        background: var(--ui-accent-wash, color-mix(in srgb, var(--md-sys-color-primary) 12%, transparent));
+        color: var(--ui-accent, var(--md-sys-color-primary));
+        font-size: var(--ui-t-small, 12px);
+        font-weight: 600;
+        --md-icon-size: 16px;
+      }
+
+      .board {
+        container-type: inline-size;
+      }
+
+      .grid {
+        display: grid;
+        grid-template-columns: repeat(4, minmax(0, 1fr));
+        grid-auto-rows: minmax(250px, auto);
+        grid-auto-flow: dense;
+        gap: 16px;
+      }
+
+      .grid > * {
+        grid-column: span var(--w, 2);
+        grid-row: span var(--h, 1);
+      }
+
+      @container (max-width: 1100px) {
+        .grid {
+          grid-template-columns: repeat(2, minmax(0, 1fr));
+        }
+
+        .grid > .w3,
+        .grid > .w4 {
+          --w: 2;
+        }
+      }
+
+      @container (max-width: 640px) {
+        .grid {
+          grid-template-columns: minmax(0, 1fr);
+        }
+
+        .grid > * {
+          --w: 1 !important;
+        }
+      }
+
+      .empty {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 14px;
+        max-width: 640px;
+        margin: 6vh auto 0;
+        padding: 36px 28px;
+        border: 1px dashed var(--ui-line, var(--md-sys-color-outline-variant));
+        border-radius: 16px;
+        background: radial-gradient(120% 100% at 50% 0%, var(--ui-accent-wash, color-mix(in srgb, var(--md-sys-color-primary) 10%, transparent)) 0%, transparent 70%);
+        text-align: center;
+      }
+
+      .empty .mark {
+        display: grid;
+        place-items: center;
+        width: 56px;
+        height: 56px;
+        border-radius: 16px;
+        background: var(--ui-accent, var(--md-sys-color-primary));
+        color: var(--ui-on-accent, var(--md-sys-color-on-primary));
+        --md-icon-size: 30px;
+        box-shadow: 0 10px 24px -12px var(--ui-accent, var(--md-sys-color-primary));
+      }
+
+      .empty h2 {
+        margin: 4px 0 0;
+        font-size: var(--ui-t-page, 18px);
+        font-weight: 650;
+      }
+
+      .empty p {
+        margin: 0;
+        color: var(--ui-muted, var(--md-sys-color-on-surface-variant));
+      }
+
+      .examples {
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
+        width: 100%;
+        margin-top: 6px;
+      }
+
+      .examples button,
+      .empty .library {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 10px 14px;
+        border: 1px solid var(--ui-line, var(--md-sys-color-outline-variant));
+        border-radius: 10px;
+        background: var(--ui-panel, var(--md-sys-color-surface-container-lowest));
+        color: var(--ui-ink, var(--md-sys-color-on-surface));
+        font: inherit;
+        text-align: start;
+        cursor: pointer;
+        transition:
+          border-color 0.15s ease,
+          transform 0.15s ease;
+        --md-icon-size: 18px;
+      }
+
+      .examples button md-icon {
+        color: var(--ui-accent, var(--md-sys-color-primary));
+      }
+
+      .examples button:hover,
+      .examples button:focus-visible,
+      .empty .library:hover {
+        border-color: var(--ui-accent, var(--md-sys-color-primary));
+        transform: translateY(-1px);
+        outline: none;
+      }
+
+      .empty .library {
+        justify-content: center;
+        border-style: dashed;
+        background: transparent;
+      }
+
+      .notice {
+        margin: 0;
+        padding: 12px 14px;
+        border-radius: 10px;
+        background: color-mix(in srgb, var(--ui-crit, #c62828) 8%, transparent);
+      }
+
+      .note {
+        margin: 0;
+        font-size: var(--ui-t-small, 12px);
+        color: var(--ui-faint, var(--md-sys-color-on-surface-variant));
+      }
+    `
+  ]
+
+  @state() private places: PlaceItem[] = []
+  @state() private loaded = false
+  @state() private error?: string
+  @state() private editing = false
+
+  private onChanged = () => this.load()
+
+  get context() {
+    return {
+      title: t('ai-dashboard.title'),
+      frame: 'document',
+      actions: [
+        { title: t(this.editing ? 'ai-dashboard.button.done' : 'ai-dashboard.button.arrange'), action: () => (this.editing = !this.editing), icon: this.editing ? 'check' : 'dashboard_customize' },
+        { title: t('ai-dashboard.button.library'), action: () => this.openLibrary(), icon: 'collections_bookmark' },
+        { title: t('ai-dashboard.button.make'), action: () => this.make(), icon: 'auto_awesome', emphasis: { raised: true } }
+      ]
+    }
+  }
+
+  connectedCallback() {
+    super.connectedCallback()
+    window.addEventListener(DASHBOARD_CHANGED, this.onChanged)
+  }
+
+  disconnectedCallback() {
+    window.removeEventListener(DASHBOARD_CHANGED, this.onChanged)
+    super.disconnectedCallback()
+  }
+
+  updated(changes: Map<string, unknown>) {
+    /* The action bar follows the mode - its words say what pressing it does now. */
+    if (changes.has('editing')) this.updateContext()
+  }
+
+  /* Not awaited: the shell sets the tab's title only after this returns. */
+  async pageUpdated(changes: any) {
+    if ((this as any).active && changes.active) this.load()
+  }
+
+  private async load() {
+    try {
+      this.places = await cardApi.myDashboard()
+      this.error = undefined
+    } catch (error: any) {
+      this.error = error?.message ?? String(error)
+    } finally {
+      this.loaded = true
+    }
+  }
+
+  render() {
+    return html`<div class="page">
+      ${this.error
+        ? html`<p class="notice">${this.error}</p>`
+        : this.loaded && !this.places.length
+          ? this.renderEmpty()
+          : this.places.length
+            ? this.renderBoard()
+            : nothing}
+    </div>`
+  }
+
+  private renderBoard() {
+    const sorted = [...this.places].sort((a, b) => a.order - b.order)
+    return html`<div class="lead">
+        <p>${t('ai-dashboard.page.lead')}</p>
+        ${this.editing ? html`<span class="chip"><md-icon>dashboard_customize</md-icon>${t('ai-dashboard.page.arranging')}</span>` : nothing}
+      </div>
+      <div class="board">
+        <div class="grid" @card-action=${(event: CustomEvent) => this.onCardAction(event)}>
+          ${sorted.map(
+            (place, i) => html`<ai-dashboard-card
+              class="w${place.width} h${place.height}"
+              style="--w: ${place.width}; --h: ${place.height}"
+              data-place=${place.id}
+              .card=${place.card}
+              .width=${place.width}
+              .height=${place.height}
+              ?editing=${this.editing}
+              ?first=${i === 0}
+              ?last=${i === sorted.length - 1}
+            ></ai-dashboard-card>`
+          )}
+        </div>
+      </div>
+      <p class="note">${t('ai-dashboard.page.no-tokens')}</p>`
+  }
+
+  private renderEmpty() {
+    return html`<div class="empty">
+      <span class="mark"><md-icon>auto_awesome</md-icon></span>
+      <h2>${t('ai-dashboard.page.empty-title')}</h2>
+      <p>${t('ai-dashboard.page.empty-text')}</p>
+      <div class="examples">
+        ${EXAMPLES.map(key => html`<button @click=${() => this.askFor(t(key))}><md-icon>chat_bubble</md-icon><span>${t(key)}</span></button>`)}
+      </div>
+      <button class="library" @click=${() => this.openLibrary()}><md-icon>collections_bookmark</md-icon>${t('ai-dashboard.page.from-library')}</button>
+      <p class="note">${t('ai-dashboard.page.no-tokens')}</p>
+    </div>`
+  }
+
+  /** Sends a request to the conversation beside the page - this screen's, where the card tool is in front. */
+  private async askFor(ask: string) {
+    await askAssistant({ ask, continueCurrent: true })
+  }
+
+  private make() {
+    askAssistant({ draft: t('ai-dashboard.page.make-draft'), continueCurrent: true })
+  }
+
+  private openLibrary() {
+    openPopup(html`<ai-dashboard-card-library></ai-dashboard-card-library>`, { backdrop: true, size: 'large', title: t('ai-dashboard.library.title') })
+  }
+
+  private placeOf(card: CardItem) {
+    return this.places.find(one => one.card.id === card.id)
+  }
+
+  private async arrange(next: PlaceItem[]) {
+    const before = this.places
+    this.places = next
+    try {
+      await cardApi.arrange(next.map(({ id, order, width, height }) => ({ id, order, width, height })))
+    } catch (error: any) {
+      this.places = before
+      notify({ level: 'error', message: error?.message ?? String(error) })
+    }
+  }
+
+  private async onCardAction(event: CustomEvent) {
+    const { action, card } = event.detail as { action: CardAction; card: CardItem }
+    const place = this.placeOf(card)
+    try {
+      switch (action) {
+        case 'ai':
+          return openCardAiPrompt(card)
+        case 'rename':
+          return openCardRename(card)
+        case 'share':
+          return openCardShare(card)
+        case 'versions':
+          return openCardVersions(card)
+        case 'copy':
+          await cardApi.copy(card.id)
+          notify({ level: 'info', message: t('ai-dashboard.text.copied', { name: card.name }) })
+          return dashboardChanged()
+        case 'unplace':
+          if (!place) return
+          await cardApi.unplace(place.id)
+          notify({ level: 'info', message: t('ai-dashboard.text.unplaced', { name: card.name }) })
+          return this.load()
+        case 'left':
+        case 'right':
+          return place && this.arrange(movedPlaces(this.places, place.id, action === 'left' ? -1 : 1))
+        case 'wider':
+        case 'narrower':
+        case 'taller':
+        case 'shorter': {
+          if (!place) return
+          const width = Math.min(4, Math.max(1, place.width + (action === 'wider' ? 1 : action === 'narrower' ? -1 : 0)))
+          const height = Math.min(2, Math.max(1, place.height + (action === 'taller' ? 1 : action === 'shorter' ? -1 : 0)))
+          return this.arrange(this.places.map(one => (one.id === place.id ? { ...one, width, height } : one)))
+        }
+      }
+    } catch (error: any) {
+      notify({ level: 'error', message: error?.message ?? String(error) })
+    }
+  }
+}

package/client/route.ts

@@ -0,0 +1,8 @@
+/* The page this module brings to an application that puts it in its menu (ADR-0160 decision 10). */
+export default function route(page: string) {
+  switch (page) {
+    case 'my-dashboard':
+      import('./pages/my-dashboard-page.js')
+      return page
+  }
+}

package/client/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "declaration": true,
+    "module": "esnext",
+    "outDir": "../dist-client",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}

package/client/utils/card-api.ts

@@ -0,0 +1,110 @@
+/*
+ * The doors the dashboard screens call (server: card-resolver.ts). One place, so the page, the library and the
+ * conversation's card read the same fields.
+ */
+import gql from 'graphql-tag'
+
+import { client } from '@operato/graphql'
+
+export interface CardShare {
+  scope: 'USER' | 'DEPARTMENT' | 'DOMAIN'
+  targetId: string
+  targetName?: string | null
+}
+
+export interface CardItem {
+  id: string
+  name: string
+  description?: string | null
+  version: number
+  definition: any
+  access: 'owner' | 'shared'
+  ownerName?: string | null
+  copiedFromId?: string | null
+  placed: boolean
+  shares?: CardShare[] | null
+  updatedAt?: string | null
+}
+
+export interface PlaceItem {
+  id: string
+  order: number
+  width: number
+  height: number
+  card: CardItem
+}
+
+export interface CardCounts {
+  read: number
+  total: number
+  complete: boolean
+  shaped: number
+  shown: number
+}
+
+export interface CardRun {
+  block?: any
+  issue?: { code: string; params?: Record<string, unknown> }
+  counts?: CardCounts
+  asOf: string
+  source?: { key: string; labelKey?: string }
+}
+
+const CARD_FIELDS = `id name description version definition access ownerName copiedFromId placed shares { scope targetId targetName } updatedAt`
+
+async function ask<T>(document: string, variables: Record<string, unknown> = {}, mutate = false): Promise<T> {
+  const response: any = mutate
+    ? await client.mutate({ mutation: gql(document), variables })
+    : await client.query({ query: gql(document), variables, fetchPolicy: 'no-cache' })
+  if (response.errors?.length) throw new Error(response.errors[0].message)
+  return response.data
+}
+
+export const cardApi = {
+  myDashboard: async () => (await ask<any>(`query { myDashboard { id order width height card { ${CARD_FIELDS} } } }`)).myDashboard as PlaceItem[],
+  library: async (which: 'mine' | 'shared') => (await ask<any>(`query ($which: String!) { dashboardCards(which: $which) { ${CARD_FIELDS} } }`, { which })).dashboardCards as CardItem[],
+  run: async (id: string) => (await ask<any>(`query ($id: String!) { dashboardCardRun(id: $id) }`, { id })).dashboardCardRun as CardRun,
+  preview: async (sessionId: string, proposalKey: string) =>
+    (await ask<any>(`query ($s: String!, $k: String!) { dashboardCardProposalPreview(sessionId: $s, proposalKey: $k) }`, { s: sessionId, k: proposalKey })).dashboardCardProposalPreview as CardRun,
+  versions: async (id: string) =>
+    (await ask<any>(`query ($id: String!) { dashboardCardVersions(id: $id) { version name definition creatorName createdAt } }`, { id })).dashboardCardVersions as {
+      version: number
+      name: string
+      definition: any
+      creatorName?: string
+      createdAt?: string
+    }[],
+  shareOptions: async () =>
+    (await ask<any>(`query { dashboardShareOptions { domainId domainName departmentsAvailable departments { id name } peopleAvailable } }`)).dashboardShareOptions as {
+      domainId: string
+      domainName: string
+      departmentsAvailable: boolean
+      departments: { id: string; name: string }[]
+      peopleAvailable: boolean
+    },
+  people: async (text: string) => (await ask<any>(`query ($text: String!) { dashboardSharePeople(text: $text) { id name note } }`, { text })).dashboardSharePeople as { id: string; name: string; note?: string }[],
+  saveProposal: async (sessionId: string, proposalKey: string) =>
+    (await ask<any>(`mutation ($s: String!, $k: String!) { saveDashboardCardProposal(sessionId: $s, proposalKey: $k) }`, { s: sessionId, k: proposalKey }, true)).saveDashboardCardProposal as {
+      cardId: string
+      version: number
+      placeId: string
+      again?: boolean
+    },
+  rename: async (id: string, name: string) => (await ask<any>(`mutation ($id: String!, $name: String!) { renameDashboardCard(id: $id, name: $name) { id } }`, { id, name }, true)).renameDashboardCard,
+  restore: async (id: string, version: number) => (await ask<any>(`mutation ($id: String!, $v: Int!) { restoreDashboardCardVersion(id: $id, version: $v) { id } }`, { id, v: version }, true)).restoreDashboardCardVersion,
+  copy: async (id: string) => (await ask<any>(`mutation ($id: String!) { copyDashboardCard(id: $id) { id } }`, { id }, true)).copyDashboardCard,
+  remove: async (id: string) => (await ask<any>(`mutation ($id: String!) { deleteDashboardCard(id: $id) }`, { id }, true)).deleteDashboardCard,
+  share: async (id: string, shares: CardShare[]) =>
+    (await ask<any>(`mutation ($id: String!, $shares: [DashboardCardShareInput!]!) { shareDashboardCard(id: $id, shares: $shares) { ${CARD_FIELDS} } }`, { id, shares }, true)).shareDashboardCard as CardItem,
+  place: async (cardId: string) => (await ask<any>(`mutation ($id: String!) { placeDashboardCard(cardId: $id) { id } }`, { id: cardId }, true)).placeDashboardCard,
+  unplace: async (id: string) => (await ask<any>(`mutation ($id: String!) { removeDashboardPlace(id: $id) }`, { id }, true)).removeDashboardPlace,
+  arrange: async (places: { id: string; order: number; width: number; height: number }[]) =>
+    (await ask<any>(`mutation ($places: [DashboardPlaceInput!]!) { arrangeDashboard(places: $places) }`, { places }, true)).arrangeDashboard
+}
+
+/** Told when a card is saved, copied, placed or removed elsewhere - an open dashboard reads itself again. */
+export const DASHBOARD_CHANGED = 'ai-dashboard-changed'
+
+export function dashboardChanged(): void {
+  window.dispatchEvent(new CustomEvent(DASHBOARD_CHANGED))
+}

package/client/utils/card-words.ts

@@ -0,0 +1,80 @@
+/*
+ * What a card says besides its block - why it is not drawn, how much of its source it was drawn from, when it was
+ * read, what it reads (ADR-0160 decisions 4, 6). Pure - tested without a browser.
+ */
+import type { CardItem, CardRun } from './card-api.js'
+
+export type Translate = (key: string, options?: Record<string, unknown>) => string
+
+/** The refusals a card names in the reader's words - others are said by their code. */
+export const KNOWN_ISSUES = [
+  'door-closed',
+  'not-found',
+  'list-missing',
+  'query-failed',
+  'condition-unreadable',
+  'mixed-currency-order',
+  'too-many-series',
+  'too-many-figures',
+  'unknown-read',
+  'not-a-card-source',
+  'unknown-list',
+  'unknown-column',
+  'unknown-condition'
+] as const
+
+/** Why a card is not drawn - one sentence, and whether it is the reader's access (shown calmly, not as a fault). */
+export function issueLine(run: CardRun, t: Translate): { text: string; access: boolean } | undefined {
+  const issue = run.issue
+  if (!issue) return undefined
+  const code = issue.code
+  const known = (KNOWN_ISSUES as readonly string[]).includes(code)
+  const params = { ...(issue.params ?? {}), code } as Record<string, unknown>
+  if (Array.isArray(params.currencies)) params.currencies = (params.currencies as string[]).join(', ')
+  return {
+    text: t(known ? `ai-dashboard.issue.${code}` : 'ai-dashboard.issue.other', { ...params, defaultValue: known ? code : 'This card cannot be drawn ({code}).' }),
+    access: code === 'door-closed'
+  }
+}
+
+/** How much of its source a card was drawn from - said only when it was not all of it. */
+export function partialLine(run: CardRun, t: Translate): string | undefined {
+  const counts = run.counts
+  if (!counts || counts.complete) return undefined
+  return t('ai-dashboard.card.partial', { read: counts.read.toLocaleString(), total: counts.total.toLocaleString(), defaultValue: 'Drawn from {read} of {total} rows - sums and ranks are of those.' })
+}
+
+/** A table or chart with no row to draw - said in words, never an empty axis. A number of nothing is 0, and drawn. */
+export function drawsNothing(run: CardRun): boolean {
+  return !run.issue && !!run.block && run.block.kind !== 'metrics' && (run.counts?.shown ?? 0) === 0
+}
+
+/** The day relative periods were read for, and the time it was read. */
+export function readLine(run: CardRun, readAt: Date, t: Translate, locale?: string): string {
+  const time = readAt.toLocaleTimeString(locale || undefined, { hour: '2-digit', minute: '2-digit' })
+  return t('ai-dashboard.card.read-at', { day: run.asOf, time, defaultValue: 'as of {day} · read {time}' })
+}
+
+/** Who a card came from, for a card shared with the reader; whom it is shared with, for its owner. */
+export function ownershipLine(card: CardItem, t: Translate): string | undefined {
+  if (card.access === 'shared') return t('ai-dashboard.card.shared-by', { name: card.ownerName ?? '', defaultValue: 'shared by {name}' })
+  const shares = card.shares ?? []
+  if (!shares.length) return undefined
+  const names = shares.map(one => (one.scope === 'DOMAIN' ? t('ai-dashboard.share.everyone', { defaultValue: 'everyone' }) : one.targetName || one.targetId))
+  return t('ai-dashboard.card.shared-with', { names: names.slice(0, 3).join(', ') + (names.length > 3 ? ` +${names.length - 3}` : ''), defaultValue: 'shared with {names}' })
+}
+
+/** The kind of drawing a definition asks for - the icon a card and the library show. */
+export function viewIcon(definition: any): string {
+  return ({ number: 'pin', table: 'table_rows', bar: 'bar_chart', line: 'show_chart' } as Record<string, string>)[definition?.view?.kind] ?? 'dashboard'
+}
+
+/** Moves one place in a list of places and gives every place its order again - what arranging sends. */
+export function movedPlaces<P extends { id: string; order: number }>(places: readonly P[], id: string, step: -1 | 1): P[] {
+  const list = [...places].sort((a, b) => a.order - b.order)
+  const at = list.findIndex(one => one.id === id)
+  const to = at + step
+  if (at < 0 || to < 0 || to >= list.length) return list.map((one, order) => ({ ...one, order }))
+  ;[list[at], list[to]] = [list[to], list[at]]
+  return list.map((one, order) => ({ ...one, order }))
+}

package/dist-client/bootstrap.d.ts

@@ -0,0 +1,2 @@
+import './components/proposal-preview.js';
+export default function bootstrap(): void;

package/dist-client/bootstrap.js

@@ -0,0 +1,24 @@
+/*
+ * The conversation's dashboard card (ADR-0160 decision 9): its preview under the card, and pressing it saves the stored
+ * proposal to the person's dashboard. Registered here, by the package that declares the tool - the dock knows no kind.
+ */
+import { i18next } from '@operato/i18n';
+import { registerProposalHandler, registerProposalView } from '@things-factory/ai-assistant/dist-client/index.js';
+import './components/proposal-preview.js';
+import { cardApi, dashboardChanged } from './utils/card-api.js';
+const TOOL = 'proposeDashboardCard';
+export default function bootstrap() {
+    registerProposalView(TOOL, { previewTag: 'ai-dashboard-proposal-preview', runLabelKey: 'ai-dashboard.preview.save', runLabel: 'Save to my dashboard' });
+    registerProposalHandler(TOOL, async (proposal, context) => {
+        if (!context.sessionId || !proposal?.key)
+            return { verdict: 'unavailable', errorCode: 'no-conversation' };
+        const saved = await cardApi.saveProposal(context.sessionId, proposal.key);
+        dashboardChanged();
+        return {
+            verdict: 'accepted',
+            applied: 1,
+            note: String(i18next.t(saved.version > 1 ? 'ai-dashboard.preview.saved-version' : 'ai-dashboard.preview.saved', { name: proposal.card?.name ?? '', version: saved.version }))
+        };
+    });
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist-client/bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../client/bootstrap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAA;AAEjH,OAAO,kCAAkC,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,MAAM,IAAI,GAAG,sBAAsB,CAAA;AAEnC,MAAM,CAAC,OAAO,UAAU,SAAS;IAC/B,oBAAoB,CAAC,IAAI,EAAE,EAAE,UAAU,EAAE,+BAA+B,EAAE,WAAW,EAAE,2BAA2B,EAAE,QAAQ,EAAE,sBAAsB,EAAE,CAAC,CAAA;IACvJ,uBAAuB,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE;QACxD,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,QAAQ,EAAE,GAAG;YAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,iBAAiB,EAAE,CAAA;QACzG,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAA;QACzE,gBAAgB,EAAE,CAAA;QAClB,OAAO;YACL,OAAO,EAAE,UAAU;YACnB,OAAO,EAAE,CAAC;YACV,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,oCAAoC,CAAC,CAAC,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;SAC9K,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC","sourcesContent":["/*\n * The conversation's dashboard card (ADR-0160 decision 9): its preview under the card, and pressing it saves the stored\n * proposal to the person's dashboard. Registered here, by the package that declares the tool - the dock knows no kind.\n */\nimport { i18next } from '@operato/i18n'\nimport { registerProposalHandler, registerProposalView } from '@things-factory/ai-assistant/dist-client/index.js'\n\nimport './components/proposal-preview.js'\nimport { cardApi, dashboardChanged } from './utils/card-api.js'\n\nconst TOOL = 'proposeDashboardCard'\n\nexport default function bootstrap() {\n  registerProposalView(TOOL, { previewTag: 'ai-dashboard-proposal-preview', runLabelKey: 'ai-dashboard.preview.save', runLabel: 'Save to my dashboard' })\n  registerProposalHandler(TOOL, async (proposal, context) => {\n    if (!context.sessionId || !proposal?.key) return { verdict: 'unavailable', errorCode: 'no-conversation' }\n    const saved = await cardApi.saveProposal(context.sessionId, proposal.key)\n    dashboardChanged()\n    return {\n      verdict: 'accepted',\n      applied: 1,\n      note: String(i18next.t(saved.version > 1 ? 'ai-dashboard.preview.saved-version' : 'ai-dashboard.preview.saved', { name: proposal.card?.name ?? '', version: saved.version }))\n    }\n  })\n}\n"]}

package/dist-client/components/card-dialogs.d.ts

@@ -0,0 +1,59 @@
+import '@material/web/icon/icon.js';
+import '@material/web/button/filled-button.js';
+import '@material/web/button/text-button.js';
+import { LitElement } from 'lit';
+import { type CardItem } from '../utils/card-api.js';
+declare const CardAiForm_base: (new (...args: any[]) => LitElement) & typeof LitElement;
+/** What to change in a card - sent to the conversation beside the page with the card picked, as a screen request. */
+export declare class CardAiForm extends CardAiForm_base {
+    static styles: import("lit").CSSResult;
+    card: CardItem;
+    private text;
+    render(): import("lit-html").TemplateResult<1>;
+    private close;
+    private send;
+}
+declare const CardRenameForm_base: (new (...args: any[]) => LitElement) & typeof LitElement;
+/** A card's new name - a new version. */
+export declare class CardRenameForm extends CardRenameForm_base {
+    static styles: import("lit").CSSResult;
+    card: CardItem;
+    private name;
+    connectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    private close;
+    private save;
+}
+declare const CardShareForm_base: (new (...args: any[]) => LitElement) & typeof LitElement;
+/** Whom one's own card is shared with - the whole domain, one's own departments, people found by name. */
+export declare class CardShareForm extends CardShareForm_base {
+    static styles: import("lit").CSSResult;
+    card: CardItem;
+    private options?;
+    private shares;
+    private found;
+    private search;
+    private searching?;
+    connectedCallback(): Promise<void>;
+    private has;
+    private toggle;
+    private find;
+    render(): import("lit-html").TemplateResult<1>;
+    private close;
+    private save;
+}
+declare const CardVersions_base: (new (...args: any[]) => LitElement) & typeof LitElement;
+/** One's own card's versions, newest first - an earlier one comes back as a new version. */
+export declare class CardVersions extends CardVersions_base {
+    static styles: import("lit").CSSResult;
+    card: CardItem;
+    private versions?;
+    connectedCallback(): Promise<void>;
+    render(): import("lit-html").TemplateResult<1>;
+    private restore;
+}
+export declare const openCardAiPrompt: (card: CardItem) => any;
+export declare const openCardRename: (card: CardItem) => any;
+export declare const openCardShare: (card: CardItem) => any;
+export declare const openCardVersions: (card: CardItem) => any;
+export {};