@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/components/shared/persona/_internal/SPersonaRunConsole.vue

@@ -1,300 +0,0 @@
-<script setup lang="ts">
-import { computed } from 'vue'
-
-import SButton from '../../controls/SButton.vue'
-import SActionListItem from '../../data-display/SActionListItem.vue'
-import SCodeBlock from '../../data-display/SCodeBlock.vue'
-import SEmptyState from '../../data-display/SEmptyState.vue'
-import SMessage from '../../data-display/SMessage.vue'
-import SSectionHeader from '../../data-display/SSectionHeader.vue'
-import SVirtualList from '../../data-display/SVirtualList.vue'
-import SKeyValueGrid from '../../data-display/SKeyValueGrid.vue'
-import SAsyncState from '../../feedback/SAsyncState.vue'
-import {
-  assertPersonaInventory,
-  findExactPersonaInventoryItem,
-  resolvePersonaInventoryAsyncState,
-} from './inventory'
-import { personaDistinctMessage } from '../presentation'
-import { useUiKitLocale } from '../../../../composables/useUiKitLocale'
-import { getPersonaRunConsoleFactKey } from '../types'
-import type {
-  PersonaPaginatedInventoryState,
-  PersonaRunConsoleCapabilities,
-  PersonaRunConsoleDensity,
-  PersonaRunConsoleEvent,
-  PersonaRunConsoleItem,
-  PersonaRunConsoleLabels,
-  PersonaRunConsoleOperation,
-  PersonaRunConsoleRun,
-} from '../types'
-
-defineOptions({ inheritAttrs: false })
-
-const props = withDefaults(
-  defineProps<{
-    runsState: PersonaPaginatedInventoryState<PersonaRunConsoleRun>
-    itemsState: PersonaPaginatedInventoryState<PersonaRunConsoleItem>
-    eventsState: PersonaPaginatedInventoryState<PersonaRunConsoleEvent>
-    capabilities: PersonaRunConsoleCapabilities
-    operation: PersonaRunConsoleOperation
-    resolvedLabels: PersonaRunConsoleLabels
-    selectedRunId?: string | null
-    reportSummary?: string | null
-    density?: PersonaRunConsoleDensity
-    listHeight?: number
-    itemsHeight?: number
-    eventsHeight?: number
-  }>(),
-  {
-    selectedRunId: null,
-    reportSummary: null,
-    density: 'comfortable',
-    listHeight: 560,
-    itemsHeight: 250,
-    eventsHeight: 430,
-  },
-)
-
-const emit = defineEmits<{
-  'select-run': [runId: string]
-  'load-more-runs': []
-  'refresh-events': []
-  'cancel-run': []
-  'load-more-items': []
-  'append-events': []
-  'load-more-events': []
-}>()
-const { locale, t } = useUiKitLocale()
-const runs = computed(() => props.runsState.status === 'ready'
-  ? assertPersonaInventory('SPersonaRunConsole.runsState', props.runsState.items)
-  : [])
-const items = computed(() => props.itemsState.status === 'ready'
-  ? assertPersonaInventory('SPersonaRunConsole.itemsState', props.itemsState.items)
-  : [])
-const events = computed(() => props.eventsState.status === 'ready'
-  ? assertPersonaInventory('SPersonaRunConsole.eventsState', props.eventsState.items)
-  : [])
-const runsAsyncState = computed(() => resolvePersonaInventoryAsyncState(
-  'SPersonaRunConsole.runsState',
-  props.runsState,
-  {
-    loadingMessage: t('persona.loadingRuns'),
-    emptyMessage: props.resolvedLabels.noRuns,
-  },
-))
-const itemsAsyncState = computed(() => resolvePersonaInventoryAsyncState(
-  'SPersonaRunConsole.itemsState',
-  props.itemsState,
-  {
-    loadingMessage: t('persona.loadingItems'),
-    emptyMessage: props.resolvedLabels.noItems,
-  },
-))
-const eventsAsyncState = computed(() => resolvePersonaInventoryAsyncState(
-  'SPersonaRunConsole.eventsState',
-  props.eventsState,
-  {
-    loadingMessage: t('persona.loadingEvents'),
-    emptyMessage: props.resolvedLabels.noEvents,
-  },
-))
-const selectedRun = computed(() => findExactPersonaInventoryItem(
-  'SPersonaRunConsole.runsState',
-  runs.value,
-  props.selectedRunId,
-))
-const selectedFacts = computed(() => selectedRun.value?.facts ?? [])
-const virtualRowSize = 96
-const runsViewportHeight = computed(() => Math.min(props.listHeight, runs.value.length * virtualRowSize))
-const itemsViewportHeight = computed(() => Math.min(props.itemsHeight, items.value.length * virtualRowSize))
-const eventsViewportHeight = computed(() => Math.min(props.eventsHeight, events.value.length * virtualRowSize))
-
-function eventDetail(event: PersonaRunConsoleEvent): string | null {
-  return personaDistinctMessage(event.title, event.message, locale.value)
-}
-</script>
-
-<template>
-  <div class="s-persona-run-console-shell">
-    <div class="s-persona-run-console" :data-density="density">
-    <section class="s-persona-run-console__section">
-      <SSectionHeader :title="resolvedLabels.runListTitle" size="sm" />
-      <SAsyncState :state="runsAsyncState">
-        <SVirtualList
-          :items="runs"
-          :item-size="virtualRowSize"
-          :height="runsViewportHeight"
-          :item-key="(run) => run.id"
-          :accessible-label="resolvedLabels.runListTitle"
-          :item-label="(run) => run.title"
-        >
-          <template #default="{ item }">
-            <SActionListItem
-              role="presentation"
-              :title="item.title"
-              :description="item.meta"
-              :detail="item.detail"
-              :selected="selectedRunId === item.id"
-              :status-label="item.statusLabel"
-              :status-severity="item.statusSeverity"
-              trailing-layout="inline"
-              height-mode="fill"
-              :surface="{ mode: 'action', accessibleLabel: t('persona.openRun', { title: item.title }) }"
-              @activate="emit('select-run', item.id)"
-            />
-          </template>
-        </SVirtualList>
-      </SAsyncState>
-      <div
-        v-if="runsState.status === 'ready' && runsState.pagination !== 'complete'"
-        class="s-persona-run-console__actions-line"
-      >
-        <SButton
-          size="sm"
-          severity="secondary"
-          :loading="runsState.pagination === 'loading-more'"
-          @click="emit('load-more-runs')"
-        >
-          {{ resolvedLabels.loadMoreRuns }}
-        </SButton>
-      </div>
-    </section>
-
-    <section class="s-persona-run-console__section">
-      <SSectionHeader :title="resolvedLabels.selectedRunTitle" size="sm" />
-      <div v-if="selectedRun" class="s-persona-run-console__detail">
-        <SSectionHeader :title="selectedRun.title" :description="selectedRun.meta">
-          <template #actions>
-            <SButton
-              size="sm"
-              severity="secondary"
-              :loading="operation === 'refreshing-events'"
-              @click="emit('refresh-events')"
-            >
-              {{ resolvedLabels.refreshEvents }}
-            </SButton>
-            <SButton
-              v-if="capabilities.cancelRun === 'enabled'"
-              size="sm"
-              severity="danger"
-              :loading="operation === 'cancelling-run'"
-              @click="emit('cancel-run')"
-            >
-              {{ resolvedLabels.cancelRun }}
-            </SButton>
-          </template>
-        </SSectionHeader>
-
-        <SMessage v-if="selectedRun.artifactLabel" severity="info" :title="t('persona.artifacts')">
-          {{ selectedRun.artifactLabel }}
-        </SMessage>
-
-        <SKeyValueGrid
-          v-if="selectedFacts.length > 0"
-          :items="selectedFacts"
-          :get-item-key="getPersonaRunConsoleFactKey"
-          variant="inline"
-          :columns="1"
-        />
-
-        <SSectionHeader :title="resolvedLabels.itemsTitle" size="sm" />
-        <SAsyncState :state="itemsAsyncState">
-          <SVirtualList
-            :items="items"
-            :item-size="virtualRowSize"
-            :height="itemsViewportHeight"
-            :item-key="(workItem) => workItem.id"
-            :accessible-label="resolvedLabels.itemsTitle"
-            :item-label="(workItem) => workItem.title"
-          >
-            <template #default="{ item }">
-              <SActionListItem
-                role="presentation"
-                :title="item.title"
-                :description="item.meta"
-                :detail="item.detail"
-                :status-label="item.statusLabel"
-                :status-severity="item.statusSeverity"
-                :badges="item.badges"
-                :surface="{ mode: 'static' }"
-                trailing-layout="inline"
-                height-mode="fill"
-              />
-            </template>
-          </SVirtualList>
-        </SAsyncState>
-        <div
-          v-if="itemsState.status === 'ready' && itemsState.pagination !== 'complete'"
-          class="s-persona-run-console__actions-line"
-        >
-          <SButton
-            size="sm"
-            severity="secondary"
-            :loading="itemsState.pagination === 'loading-more'"
-            @click="emit('load-more-items')"
-          >
-            {{ resolvedLabels.loadMoreItems }}
-          </SButton>
-        </div>
-
-        <SCodeBlock
-          v-if="reportSummary"
-          :code="reportSummary"
-          :language="{ id: 'plaintext' }"
-          :show-header="false"
-          :show-line-numbers="false"
-          viewport="compact"
-          :aria-label="resolvedLabels.reportSummary"
-        />
-
-        <SSectionHeader :title="resolvedLabels.eventsTitle" size="sm" />
-        <SAsyncState :state="eventsAsyncState">
-          <SVirtualList
-            :items="events"
-            :item-size="virtualRowSize"
-            :height="eventsViewportHeight"
-            :item-key="(event) => event.id"
-            :accessible-label="resolvedLabels.eventsTitle"
-            :item-label="(event) => event.title"
-          >
-            <template #default="{ item }">
-              <SActionListItem
-                role="presentation"
-                :title="item.title"
-                :description="item.meta"
-                :detail="eventDetail(item)"
-                :badges="item.badges"
-                :surface="{ mode: 'static' }"
-                height-mode="fill"
-              />
-            </template>
-          </SVirtualList>
-        </SAsyncState>
-        <div v-if="eventsState.status === 'ready'" class="s-persona-run-console__actions-line">
-          <SButton
-            size="sm"
-            severity="secondary"
-            :loading="operation === 'appending-events'"
-            @click="emit('append-events')"
-          >
-            {{ resolvedLabels.appendEvents }}
-          </SButton>
-          <SButton
-            v-if="eventsState.status === 'ready' && eventsState.pagination !== 'complete'"
-            size="sm"
-            severity="secondary"
-            :loading="eventsState.pagination === 'loading-more'"
-            @click="emit('load-more-events')"
-          >
-            {{ resolvedLabels.loadMoreEvents }}
-          </SButton>
-        </div>
-      </div>
-      <SEmptyState v-else :title="resolvedLabels.emptyRun" size="sm" />
-    </section>
-    </div>
-  </div>
-</template>
-
-<style lang="postcss" src="./SPersonaRunConsole.css" scoped></style>

package/src/components/shared/persona/_internal/inventory.ts

@@ -1,110 +0,0 @@
-import type { SAsyncStateContract } from '../../feedback/SAsyncState.vue'
-import type {
-  PersonaInventoryState,
-  PersonaPaginatedInventoryState,
-  PersonaProjectPickerState,
-} from '../types'
-
-export interface PersonaStableInventoryItem {
-  readonly id: string
-}
-
-export interface PersonaAsyncPresentation {
-  readonly loadingMessage: string
-  readonly emptyMessage: string
-}
-
-export function assertPersonaInventory<Item extends PersonaStableInventoryItem>(
-  owner: string,
-  items: Item[],
-): Item[] {
-  if (!Array.isArray(items)) {
-    throw new TypeError(
-      `${owner}: inventory должен быть массивом. / ${owner}: inventory must be an array.`,
-    )
-  }
-
-  const identities = new Set<string>()
-  for (const [index, item] of items.entries()) {
-    const candidate: unknown = item
-    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
-      throw new TypeError(
-        `${owner}: inventory[${index}] должен быть объектом со стабильным id. `
-        + `/ ${owner}: inventory[${index}] must be an object with a stable id.`,
-      )
-    }
-    const id = (candidate as { id?: unknown }).id
-    if (typeof id !== 'string' || id.length === 0) {
-      throw new TypeError(
-        `${owner}: inventory[${index}].id должен быть непустой строкой. `
-        + `/ ${owner}: inventory[${index}].id must be a non-empty string.`,
-      )
-    }
-    if (identities.has(id)) {
-      throw new TypeError(
-        `${owner}: inventory содержит duplicate id ${JSON.stringify(id)}. `
-        + `/ ${owner}: inventory contains duplicate id ${JSON.stringify(id)}.`,
-      )
-    }
-    identities.add(id)
-  }
-  return items
-}
-
-export function findExactPersonaInventoryItem<Item extends PersonaStableInventoryItem>(
-  owner: string,
-  items: Item[],
-  selectedId: string | null,
-): Item | null {
-  const inventory = assertPersonaInventory(owner, items)
-  if (selectedId === null) return null
-  if (typeof selectedId !== 'string' || selectedId.length === 0) {
-    throw new TypeError(
-      `${owner}: selectedId должен быть непустой строкой или null. `
-      + `/ ${owner}: selectedId must be a non-empty string or null.`,
-    )
-  }
-  const selectedItem = inventory.find((item) => item.id === selectedId)
-  if (selectedItem !== undefined) return selectedItem
-  throw new Error(
-    `${owner}: selectedId ${JSON.stringify(selectedId)} отсутствует в inventory. `
-    + `/ ${owner}: selectedId ${JSON.stringify(selectedId)} is absent from the inventory.`,
-  )
-}
-
-/**
- * Проецирует доменный inventory contract в единственный canonical async-state contract.
- * Projects a domain inventory contract onto the sole canonical async-state contract.
- */
-export function resolvePersonaInventoryAsyncState<Item extends PersonaStableInventoryItem>(
-  owner: string,
-  state: PersonaInventoryState<Item> | PersonaPaginatedInventoryState<Item>,
-  presentation: PersonaAsyncPresentation,
-): SAsyncStateContract {
-  if (state.status === 'loading') {
-    return { status: 'loading', message: state.message ?? presentation.loadingMessage }
-  }
-  if (state.status === 'error') return state
-
-  const inventory = assertPersonaInventory(owner, state.items)
-  return inventory.length === 0
-    ? { status: 'empty', message: presentation.emptyMessage }
-    : { status: 'ready' }
-}
-
-/**
- * Проецирует picker state в canonical async-state, сохраняя ready listing как доменный payload.
- * Projects picker state onto canonical async-state while preserving the ready listing payload.
- */
-export function resolvePersonaProjectPickerAsyncState(
-  state: PersonaProjectPickerState,
-  presentation: PersonaAsyncPresentation,
-): SAsyncStateContract {
-  if (state.status === 'loading') {
-    return { status: 'loading', message: state.message ?? presentation.loadingMessage }
-  }
-  if (state.status === 'error') return state
-  return state.listing === null
-    ? { status: 'empty', message: presentation.emptyMessage }
-    : { status: 'ready' }
-}

package/src/components/shared/persona/_internal/labels.ts

@@ -1,88 +0,0 @@
-import { validateNonEmptyString } from '../../../../internal/runtimeContract'
-import type { UiKitTranslate } from '../../../../locales/locale'
-import { createUiKitTranslate, UI_KIT_MESSAGES } from '../../../../locales/messages'
-
-import type { PersonaRunWorkbenchLabels } from '../types'
-
-const defaultTranslate = createUiKitTranslate(() => UI_KIT_MESSAGES.ru)
-
-function defaultLabels(t: UiKitTranslate): PersonaRunWorkbenchLabels {
-  return {
-    projectTitle: t('persona.projectTitle'),
-    discoveryTitle: t('persona.discoveryTitle'),
-    catalogTitle: t('persona.catalogTitle'),
-    structureTitle: t('persona.structureTitle'),
-    selectedTestTitle: t('persona.selectedTestTitle'),
-    runSelected: t('persona.runSelected'),
-    runAll: t('persona.runAll'),
-    discover: t('persona.discover'),
-    watch: t('persona.watch'),
-    searchPlaceholder: t('persona.searchTests'),
-    noCatalogTests: t('persona.noCatalogTests'),
-    emptyStructure: t('persona.emptyStructure'),
-    runListTitle: t('persona.runListTitle'),
-    selectedRunTitle: t('persona.selectedRunTitle'),
-    itemsTitle: t('persona.itemsTitle'),
-    eventsTitle: t('persona.eventsTitle'),
-    loadMoreRuns: t('persona.loadMoreRuns'),
-    loadMoreItems: t('persona.loadMoreItems'),
-    appendEvents: t('persona.appendEvents'),
-    loadMoreEvents: t('persona.loadMoreEvents'),
-    refreshEvents: t('persona.refreshEvents'),
-    cancelRun: t('persona.cancelRun'),
-    reportSummary: t('persona.reportSummary'),
-    emptyRun: t('persona.emptyRun'),
-    noRuns: t('persona.noRuns'),
-    noItems: t('persona.noItems'),
-    noEvents: t('persona.noRunEvents'),
-  }
-}
-
-type PersonaRunWorkbenchLabelKey = keyof PersonaRunWorkbenchLabels
-
-function resolveLabel(
-  defaults: Readonly<PersonaRunWorkbenchLabels>,
-  overrides: Readonly<Partial<PersonaRunWorkbenchLabels>>,
-  key: PersonaRunWorkbenchLabelKey,
-): string {
-  const override = overrides[key]
-  return override === undefined
-    ? defaults[key]
-    : validateNonEmptyString('SPersonaRunWorkbench', `labels.${key}`, override)
-}
-
-export function resolvePersonaRunWorkbenchLabels(
-  overrides: Readonly<Partial<PersonaRunWorkbenchLabels>> = {},
-  t: UiKitTranslate = defaultTranslate,
-): PersonaRunWorkbenchLabels {
-  const defaults = defaultLabels(t)
-  return {
-    projectTitle: resolveLabel(defaults, overrides, 'projectTitle'),
-    discoveryTitle: resolveLabel(defaults, overrides, 'discoveryTitle'),
-    catalogTitle: resolveLabel(defaults, overrides, 'catalogTitle'),
-    structureTitle: resolveLabel(defaults, overrides, 'structureTitle'),
-    selectedTestTitle: resolveLabel(defaults, overrides, 'selectedTestTitle'),
-    runSelected: resolveLabel(defaults, overrides, 'runSelected'),
-    runAll: resolveLabel(defaults, overrides, 'runAll'),
-    discover: resolveLabel(defaults, overrides, 'discover'),
-    watch: resolveLabel(defaults, overrides, 'watch'),
-    searchPlaceholder: resolveLabel(defaults, overrides, 'searchPlaceholder'),
-    noCatalogTests: resolveLabel(defaults, overrides, 'noCatalogTests'),
-    emptyStructure: resolveLabel(defaults, overrides, 'emptyStructure'),
-    runListTitle: resolveLabel(defaults, overrides, 'runListTitle'),
-    selectedRunTitle: resolveLabel(defaults, overrides, 'selectedRunTitle'),
-    itemsTitle: resolveLabel(defaults, overrides, 'itemsTitle'),
-    eventsTitle: resolveLabel(defaults, overrides, 'eventsTitle'),
-    loadMoreRuns: resolveLabel(defaults, overrides, 'loadMoreRuns'),
-    loadMoreItems: resolveLabel(defaults, overrides, 'loadMoreItems'),
-    appendEvents: resolveLabel(defaults, overrides, 'appendEvents'),
-    loadMoreEvents: resolveLabel(defaults, overrides, 'loadMoreEvents'),
-    refreshEvents: resolveLabel(defaults, overrides, 'refreshEvents'),
-    cancelRun: resolveLabel(defaults, overrides, 'cancelRun'),
-    reportSummary: resolveLabel(defaults, overrides, 'reportSummary'),
-    emptyRun: resolveLabel(defaults, overrides, 'emptyRun'),
-    noRuns: resolveLabel(defaults, overrides, 'noRuns'),
-    noItems: resolveLabel(defaults, overrides, 'noItems'),
-    noEvents: resolveLabel(defaults, overrides, 'noEvents'),
-  }
-}