@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/components/shared/persona/presentation.ts

@@ -1,401 +0,0 @@
-import { validateExactString } from '../../../internal/runtimeContract'
-import type { UiKitLocale, UiKitStaticMessageKey, UiKitTranslate } from '../../../locales/locale'
-import { createUiKitTranslate, UI_KIT_MESSAGES } from '../../../locales/messages'
-
-const defaultTranslate = createUiKitTranslate(() => UI_KIT_MESSAGES.ru)
-type PersonaStaticMessageKey = Extract<UiKitStaticMessageKey, `persona.${string}`>
-
-export type PersonaStatusSeverity = 'secondary' | 'success' | 'info' | 'warn' | 'danger'
-
-export type PersonaParameterPresentation = {
-  name: string
-  type?: string | null
-  required?: boolean
-  default?: unknown
-}
-
-export type PersonaDiagnosticPresentationInput = {
-  context?: string | null
-  reason?: string | null
-  severity: string
-}
-
-export type PersonaDiagnosticPresentation = {
-  category: 'scenario_import' | 'component_analysis' | 'support_quality' | 'unclassified'
-  title: string
-  ownerLabel: string
-  impactLabel: string
-  remediation: string
-  statusLabel: string
-  statusSeverity: PersonaStatusSeverity
-}
-
-type PersonaDiagnosticOverviewItem = {
-  category: PersonaDiagnosticPresentation['category']
-}
-
-export function personaDiagnosticPresentation(
-  input: PersonaDiagnosticPresentationInput,
-  t: UiKitTranslate = defaultTranslate,
-): PersonaDiagnosticPresentation {
-  const isError = input.severity === 'error' || input.severity === 'blocking'
-  const statusLabel = isError
-    ? t('persona.diagnosticError')
-    : input.severity === 'warning'
-      ? t('persona.diagnosticWarning')
-      : t('persona.diagnosticInformation')
-  const statusSeverity: PersonaStatusSeverity = isError ? 'danger' : input.severity === 'warning' ? 'warn' : 'info'
-
-  if (input.context === 'native_scenarios') {
-    return {
-      category: 'scenario_import',
-      title: t('persona.scenarioNotImported'),
-      ownerLabel: t('persona.fixInTestProject'),
-      impactLabel: t('persona.scenarioUnavailable'),
-      remediation: t('persona.restoreScenarioImport'),
-      statusLabel,
-      statusSeverity,
-    }
-  }
-  if (input.context === 'components') {
-    return {
-      category: 'component_analysis',
-      title: t('persona.componentNotAnalyzed'),
-      ownerLabel: t('persona.fixInTestProject'),
-      impactLabel: t('persona.relatedStructureIncomplete'),
-      remediation: t('persona.restoreComponentImport'),
-      statusLabel,
-      statusSeverity,
-    }
-  }
-  if (input.context === 'support_quality') {
-    const remediation = input.reason === 'page_support_import_non_maintained'
-      ? t('persona.movePageObject')
-      : t('persona.giveStableName')
-    return {
-      category: 'support_quality',
-      title: t('persona.pageObjectQuality'),
-      ownerLabel: t('persona.fixInTestProject'),
-      impactLabel: t('persona.doesNotBlockScenarios'),
-      remediation,
-      statusLabel,
-      statusSeverity,
-    }
-  }
-  return {
-    category: 'unclassified',
-    title: t('persona.unclassifiedPersonaMessage'),
-    ownerLabel: t('persona.personaClassificationRequired'),
-    impactLabel: t('persona.impactUnspecified'),
-    remediation: t('persona.personaMustClassify'),
-    statusLabel,
-    statusSeverity,
-  }
-}
-
-export function personaDiagnosticOverviewMessage(
-  availableTests: number,
-  unavailableTests: number,
-  diagnostics: readonly PersonaDiagnosticOverviewItem[],
-  t: UiKitTranslate = defaultTranslate,
-): string {
-  const count = (category: PersonaDiagnosticOverviewItem['category']) => (
-    diagnostics.filter((diagnostic) => diagnostic.category === category).length
-  )
-  const totalTests = availableTests + unavailableTests
-  const scenarioImports = count('scenario_import')
-  const componentAnalysis = count('component_analysis')
-  const supportQuality = count('support_quality')
-  const parts = [
-    t('persona.overviewAvailable', { available: availableTests, total: totalTests }),
-    scenarioImports > 0 ? t('persona.overviewScenarioImports', { count: scenarioImports }) : null,
-    componentAnalysis > 0
-      ? t('persona.overviewComponentAnalysis', { count: componentAnalysis })
-      : null,
-    supportQuality > 0 ? t('persona.overviewSupportQuality', { count: supportQuality }) : null,
-  ]
-  return parts.filter((part): part is string => Boolean(part)).join(' ')
-}
-
-const PERSONA_RUN_STATUSES = [
-  'cancelled',
-  'cancelling',
-  'completed',
-  'degraded',
-  'error',
-  'failed',
-  'passed',
-  'paused',
-  'queued',
-  'running',
-  'skipped',
-  'timed_out',
-  'timeout',
-  'info',
-  'warn',
-  'warning',
-] as const
-type PersonaRunStatus = typeof PERSONA_RUN_STATUSES[number]
-const PERSONA_RUN_STATUS_PRESENTATIONS = {
-  cancelled: { labelKey: 'persona.statusCancelled', severity: 'secondary' },
-  cancelling: { labelKey: 'persona.statusCancelling', severity: 'warn' },
-  completed: { labelKey: 'persona.statusCompleted', severity: 'success' },
-  degraded: { labelKey: 'persona.statusDegraded', severity: 'warn' },
-  error: { labelKey: 'persona.statusError', severity: 'danger' },
-  failed: { labelKey: 'persona.statusError', severity: 'danger' },
-  passed: { labelKey: 'persona.statusPassed', severity: 'success' },
-  paused: { labelKey: 'persona.statusPaused', severity: 'info' },
-  queued: { labelKey: 'persona.statusQueued', severity: 'warn' },
-  running: { labelKey: 'persona.statusRunning', severity: 'info' },
-  skipped: { labelKey: 'persona.statusSkipped', severity: 'warn' },
-  timed_out: { labelKey: 'persona.statusTimedOut', severity: 'danger' },
-  timeout: { labelKey: 'persona.statusTimedOut', severity: 'danger' },
-  info: { labelKey: 'persona.diagnosticInformation', severity: 'info' },
-  warn: { labelKey: 'persona.diagnosticWarning', severity: 'warn' },
-  warning: { labelKey: 'persona.diagnosticWarning', severity: 'warn' },
-} as const satisfies Record<PersonaRunStatus, {
-  labelKey: PersonaStaticMessageKey
-  severity: PersonaStatusSeverity
-}>
-
-function resolvePersonaRunStatus(status: unknown): PersonaRunStatus {
-  return validateExactString('Persona presentation', 'run status', status, PERSONA_RUN_STATUSES)
-}
-
-export function personaRunStatusLabel(status: unknown, t: UiKitTranslate = defaultTranslate): string {
-  return t(PERSONA_RUN_STATUS_PRESENTATIONS[resolvePersonaRunStatus(status)].labelKey)
-}
-
-export function personaStatusSeverity(status: unknown): PersonaStatusSeverity {
-  return PERSONA_RUN_STATUS_PRESENTATIONS[resolvePersonaRunStatus(status)].severity
-}
-
-const PERSONA_SEMANTIC_KINDS = [
-  'Action',
-  'CombinedStep',
-  'Expectation',
-  'Fact',
-  'Goal',
-  'Ops',
-  'Step',
-  'action',
-  'check',
-  'combined_step',
-  'expectation',
-  'fact',
-  'get',
-  'goal',
-  'make',
-  'persona_call',
-  'step',
-] as const
-type PersonaSemanticKind = typeof PERSONA_SEMANTIC_KINDS[number]
-const PERSONA_SEMANTIC_KIND_LABELS = {
-  Action: 'persona.semanticAction',
-  CombinedStep: 'persona.semanticCombinedStep',
-  Expectation: 'persona.semanticExpectation',
-  Fact: 'persona.semanticFact',
-  Goal: 'persona.semanticGoal',
-  Ops: 'persona.semanticOps',
-  Step: 'persona.semanticStep',
-  action: 'persona.semanticAction',
-  check: 'persona.semanticExpectation',
-  combined_step: 'persona.semanticCombinedStep',
-  expectation: 'persona.semanticExpectation',
-  fact: 'persona.semanticFact',
-  get: 'persona.semanticGet',
-  goal: 'persona.semanticGoal',
-  make: 'persona.semanticAction',
-  persona_call: 'persona.semanticPersonaCall',
-  step: 'persona.semanticStep',
-} as const satisfies Record<PersonaSemanticKind, PersonaStaticMessageKey>
-
-export function personaSemanticKindLabel(kind: unknown, t: UiKitTranslate = defaultTranslate): string {
-  if (kind === null || kind === undefined) return ''
-  const resolvedKind = validateExactString(
-    'Persona presentation',
-    'semantic kind',
-    kind,
-    PERSONA_SEMANTIC_KINDS,
-  )
-  return t(PERSONA_SEMANTIC_KIND_LABELS[resolvedKind])
-}
-
-export function personaParameterSummary(
-  parameters: readonly PersonaParameterPresentation[],
-  t: UiKitTranslate = defaultTranslate,
-): string {
-  return parameters.map((parameter) => {
-    const type = parameter.type ? `: ${parameter.type}` : ''
-    const hasPrimitiveDefault = typeof parameter.default === 'string'
-      || typeof parameter.default === 'number'
-      || typeof parameter.default === 'boolean'
-    const defaultValue = hasPrimitiveDefault ? ` = ${String(parameter.default)}` : ''
-    return `${parameter.name}${type}${defaultValue}${parameter.required ? ` (${t('persona.requiredParameter')})` : ''}`
-  }).join(', ')
-}
-
-const PERSONA_SEVERITIES = ['blocker', 'critical', 'minor', 'normal', 'trivial'] as const
-type PersonaSeverity = typeof PERSONA_SEVERITIES[number]
-const PERSONA_SEVERITY_PRESENTATIONS = {
-  blocker: { labelKey: 'persona.severityBlocker', severity: 'danger' },
-  critical: { labelKey: 'persona.severityCritical', severity: 'danger' },
-  minor: { labelKey: 'persona.severityMinor', severity: 'secondary' },
-  normal: { labelKey: 'persona.severityNormal', severity: 'info' },
-  trivial: { labelKey: 'persona.severityTrivial', severity: 'secondary' },
-} as const satisfies Record<PersonaSeverity, {
-  labelKey: PersonaStaticMessageKey
-  severity: PersonaStatusSeverity
-}>
-
-function resolvePersonaSeverity(value: unknown): PersonaSeverity {
-  return validateExactString('Persona presentation', 'severity', value, PERSONA_SEVERITIES)
-}
-
-export function personaSeverityLabel(value: unknown, t: UiKitTranslate = defaultTranslate): string {
-  return t(PERSONA_SEVERITY_PRESENTATIONS[resolvePersonaSeverity(value)].labelKey)
-}
-
-export function personaSeverityBadge(value: unknown): PersonaStatusSeverity {
-  return PERSONA_SEVERITY_PRESENTATIONS[resolvePersonaSeverity(value)].severity
-}
-
-const PERSONA_REPORT_STATUSES = ['broken', 'failed', 'passed', 'skipped'] as const
-type PersonaReportStatus = typeof PERSONA_REPORT_STATUSES[number]
-const PERSONA_REPORT_STATUS_LABELS = {
-  broken: 'persona.reportBroken',
-  failed: 'persona.statusError',
-  passed: 'persona.statusPassed',
-  skipped: 'persona.statusSkipped',
-} as const satisfies Record<PersonaReportStatus, PersonaStaticMessageKey>
-
-export function personaReportStatusLabel(status: unknown, t: UiKitTranslate = defaultTranslate): string {
-  const resolvedStatus = validateExactString(
-    'Persona presentation',
-    'report status',
-    status,
-    PERSONA_REPORT_STATUSES,
-  )
-  return t(PERSONA_REPORT_STATUS_LABELS[resolvedStatus])
-}
-
-const PERSONA_LIFECYCLE_STAGES = [
-  'run_after_scenario',
-  'run_after_test',
-  'run_before_scenario',
-  'run_before_test',
-] as const
-type PersonaLifecycleStage = typeof PERSONA_LIFECYCLE_STAGES[number]
-const PERSONA_LIFECYCLE_STAGE_LABELS = {
-  run_after_scenario: 'persona.lifecycleAfterScenario',
-  run_after_test: 'persona.lifecycleAfterTest',
-  run_before_scenario: 'persona.lifecycleBeforeScenario',
-  run_before_test: 'persona.lifecycleBeforeTest',
-} as const satisfies Record<PersonaLifecycleStage, PersonaStaticMessageKey>
-
-export function personaLifecycleStageLabel(stage: unknown, t: UiKitTranslate = defaultTranslate): string {
-  const resolvedStage = validateExactString(
-    'Persona presentation',
-    'lifecycle stage',
-    stage,
-    PERSONA_LIFECYCLE_STAGES,
-  )
-  return t(PERSONA_LIFECYCLE_STAGE_LABELS[resolvedStage])
-}
-
-const PERSONA_EVENT_TYPES = [
-  'cancelled',
-  'completed',
-  'failed',
-  'log',
-  'queued',
-  'running',
-  'started',
-  'timeout',
-  'report.runtime_log',
-  'scenario.accepted',
-  'scenario.cancelled',
-  'scenario.finished',
-  'scenario.started',
-  'worker.started',
-  'worker.stopped',
-] as const
-type PersonaEventType = typeof PERSONA_EVENT_TYPES[number]
-const PERSONA_EVENT_TYPE_LABELS = {
-  cancelled: 'persona.eventRunCancelled',
-  completed: 'persona.eventRunCompleted',
-  failed: 'persona.eventRunFailed',
-  log: 'persona.eventRuntimeMessage',
-  queued: 'persona.eventRunQueued',
-  running: 'persona.eventRunStarted',
-  started: 'persona.eventRunStarted',
-  timeout: 'persona.eventRunTimedOut',
-  'report.runtime_log': 'persona.eventRuntimeMessage',
-  'scenario.accepted': 'persona.eventTestQueued',
-  'scenario.cancelled': 'persona.eventTestCancelled',
-  'scenario.finished': 'persona.eventTestFinished',
-  'scenario.started': 'persona.eventTestStarted',
-  'worker.started': 'persona.eventWorkerStarted',
-  'worker.stopped': 'persona.eventWorkerStopped',
-} as const satisfies Record<PersonaEventType, PersonaStaticMessageKey>
-
-export function personaEventTypeLabel(eventType: unknown, t: UiKitTranslate = defaultTranslate): string {
-  const resolvedEventType = validateExactString(
-    'Persona presentation',
-    'event type',
-    eventType,
-    PERSONA_EVENT_TYPES,
-  )
-  return t(PERSONA_EVENT_TYPE_LABELS[resolvedEventType])
-}
-
-export function personaPayloadMessage(payload: Record<string, unknown> | null): string {
-  if (!payload) return ''
-  for (const key of ['message', 'error_message', 'error', 'reason', 'detail', 'stderr', 'stdout']) {
-    const value = payload[key]
-    if (typeof value === 'string' && value.trim()) return value.trim()
-  }
-  return ''
-}
-
-export function personaDistinctMessage(
-  title: string,
-  message: string | null | undefined,
-  locale: UiKitLocale = 'ru',
-): string | null {
-  const normalizedMessage = message?.trim()
-  if (!normalizedMessage) return null
-  const comparable = (value: string) => value.toLocaleLowerCase(locale).replace(/[.!?]+$/u, '').trim()
-  return comparable(title) === comparable(normalizedMessage) ? null : normalizedMessage
-}
-
-export function personaDurationLabel(
-  durationMs: number | null | undefined,
-  t: UiKitTranslate = defaultTranslate,
-  locale: UiKitLocale = 'ru',
-): string {
-  if (durationMs === null || durationMs === undefined) return t('persona.durationUnknown')
-  if (durationMs < 1000) return t('persona.durationMilliseconds', { value: durationMs })
-  return t('persona.durationSeconds', {
-    value: (durationMs / 1000).toLocaleString(locale, { maximumFractionDigits: 2 }),
-  })
-}
-
-export function personaCountLabel(
-  count: number,
-  forms: [string, string, string],
-  locale: UiKitLocale = 'ru',
-): string {
-  if (locale === 'en') return `${count} ${count === 1 ? forms[0] : forms[2]}`
-  if (locale === 'zh-CN' || locale === 'zh-TW') return `${count} ${forms[2]}`
-  const remainder100 = count % 100
-  const remainder10 = count % 10
-  const form = remainder100 >= 11 && remainder100 <= 14
-    ? forms[2]
-    : remainder10 === 1
-      ? forms[0]
-      : remainder10 >= 2 && remainder10 <= 4
-        ? forms[1]
-        : forms[2]
-  return `${count} ${form}`
-}

package/src/components/shared/persona/types.ts

@@ -1,256 +0,0 @@
-import type { BadgeSeverity } from '../data-display/SBadge.vue'
-import type { ActionListItemBadge } from '../data-display/SActionListItem.vue'
-import type { Severity as MessageSeverity } from '../data-display/SMessage.vue'
-import type { SAsyncStateContract } from '../feedback/SAsyncState.vue'
-
-export type PersonaRunConsoleDensity = 'compact' | 'comfortable'
-
-/** Состояние точного инвентаря без одновременных loading/error/ready веток. / Exact inventory state without concurrent loading/error/ready branches. */
-export type PersonaInventoryPendingState = Extract<
-  SAsyncStateContract,
-  { status: 'loading' | 'error' }
->
-
-export type PersonaInventoryState<Item> =
-  | PersonaInventoryPendingState
-  | { status: 'ready'; items: Item[] }
-
-/** Состояние точного paginated inventory с явной фазой страницы. / Exact paginated inventory state with an explicit page phase. */
-export type PersonaPaginatedInventoryState<Item> =
-  | PersonaInventoryPendingState
-  | { status: 'ready'; items: Item[]; pagination: 'complete' | 'has-more' }
-  | { status: 'ready'; items: [Item, ...Item[]]; pagination: 'loading-more' }
-
-/** Явная доступность действия без boolean capability fallback. / Explicit action availability without a boolean capability fallback. */
-export type PersonaActionAvailability = 'enabled' | 'disabled'
-
-/** Единственная активная операция private run console. / The single active private run-console operation. */
-export type PersonaRunConsoleOperation =
-  | 'idle'
-  | 'refreshing-events'
-  | 'cancelling-run'
-  | 'appending-events'
-
-/** Capability inventory private run console. / Private run-console capability inventory. */
-export type PersonaRunConsoleCapabilities = {
-  cancelRun: PersonaActionAvailability
-}
-
-/** Стабильный badge-контракт canonical action-list owner. / Stable badge contract shared with the canonical action-list owner. */
-export type PersonaRunConsoleBadge = ActionListItemBadge
-
-export type PersonaRunConsoleFact = {
-  /** Стабильный доменный id, независимый от presentation label и позиции. / Stable domain id independent of presentation label and position. */
-  id: string
-  label: string
-  value: string | number
-}
-
-/** Возвращает стабильный доменный id факта. / Returns the stable domain id of a fact. */
-export function getPersonaRunConsoleFactKey(fact: PersonaRunConsoleFact): string {
-  return fact.id
-}
-
-export type PersonaRunConsoleRun = {
-  id: string
-  title: string
-  meta: string
-  detail?: string | null
-  statusLabel: string
-  statusSeverity: BadgeSeverity
-  artifactLabel?: string | null
-  facts?: PersonaRunConsoleFact[]
-}
-
-export type PersonaRunConsoleItem = {
-  id: string
-  title: string
-  meta: string
-  detail?: string | null
-  statusLabel: string
-  statusSeverity: BadgeSeverity
-  badges?: PersonaRunConsoleBadge[]
-}
-
-export type PersonaRunConsoleEvent = {
-  id: string
-  title: string
-  meta: string
-  message?: string | null
-  badges?: PersonaRunConsoleBadge[]
-}
-
-export type PersonaRunConsoleLabels = {
-  runListTitle: string
-  selectedRunTitle: string
-  itemsTitle: string
-  eventsTitle: string
-  loadMoreRuns: string
-  loadMoreItems: string
-  appendEvents: string
-  loadMoreEvents: string
-  refreshEvents: string
-  cancelRun: string
-  reportSummary: string
-  emptyRun: string
-  noRuns: string
-  noItems: string
-  noEvents: string
-}
-
-export type PersonaCatalogStep = {
-  id: string
-  title: string
-  meta?: string | null
-  detail?: string | null
-  kind?: string | null
-  depth: number
-  badges?: PersonaRunConsoleBadge[]
-}
-
-export type PersonaCatalogLink = {
-  id: string
-  label: string
-  url: string
-}
-
-export type PersonaCatalogTest = {
-  id: string
-  title: string
-  meta: string
-  description?: string | null
-  detail?: string | null
-  workItemId: string
-  scenarioId: string
-  variantId?: string | null
-  sourcePath: string
-  tags?: string[]
-  badges?: PersonaRunConsoleBadge[]
-  facts?: PersonaRunConsoleFact[]
-  links?: PersonaCatalogLink[]
-  statusLabel?: string | null
-  statusSeverity?: BadgeSeverity
-  structureNotice?: PersonaRunWorkbenchNotice | null
-  steps: PersonaCatalogStep[]
-}
-
-export type PersonaRunWorkbenchBinding = {
-  id: string
-  title: string
-  root: string
-  statusLabel: string
-  statusSeverity: BadgeSeverity
-  meta?: string | null
-}
-
-export type PersonaRunWorkbenchWatcher = {
-  statusLabel: string
-  statusSeverity: BadgeSeverity
-  message?: string | null
-}
-
-export type PersonaRunWorkbenchCatalogOverview = {
-  unavailableTests?: number
-  components: number
-  pages: number
-  diagnosticErrors?: number
-  diagnosticWarnings?: number
-  environments?: string[]
-  executionModel?: string | null
-}
-
-export type PersonaRunWorkbenchDiagnostic = {
-  id: string
-  category: 'scenario_import' | 'component_analysis' | 'support_quality' | 'unclassified'
-  title: string
-  message: string
-  meta?: string | null
-  ownerLabel: string
-  impactLabel: string
-  remediation: string
-  statusLabel: string
-  statusSeverity: BadgeSeverity
-}
-
-export type PersonaRunWorkbenchNotice = {
-  title: string
-  message: string
-  severity: MessageSeverity
-}
-
-export type PersonaRunWorkbenchLabels = PersonaRunConsoleLabels & {
-  projectTitle: string
-  discoveryTitle: string
-  catalogTitle: string
-  structureTitle: string
-  runSelected: string
-  runAll: string
-  discover: string
-  watch: string
-  searchPlaceholder: string
-  noCatalogTests: string
-  emptyStructure: string
-  selectedTestTitle: string
-}
-
-/** Единственная активная операция workbench и его private console family. / The single active workbench/private-console-family operation. */
-export type PersonaRunWorkbenchOperation =
-  | PersonaRunConsoleOperation
-  | 'discovering'
-  | 'watching'
-  | 'starting-run'
-
-/** Полный capability inventory workbench. / Complete workbench capability inventory. */
-export type PersonaRunWorkbenchCapabilities = PersonaRunConsoleCapabilities & {
-  discover: PersonaActionAvailability
-  watch: PersonaActionAvailability
-  runSelected: PersonaActionAvailability
-  runAll: PersonaActionAvailability
-}
-
-export type PersonaProjectPickerRoot = {
-  id: string
-  label: string
-  path: string
-}
-
-export type PersonaProjectPickerEntry = {
-  /** Стабильный id проекта/директории в полном listing inventory. / Stable project/directory id in the complete listing inventory. */
-  id: string
-  rootId: string
-  name: string
-  projectName?: string | null
-  relativePath: string
-  requestedRoot: string
-  displayPath: string
-  readiness: 'ready' | 'not_persona' | 'invalid' | 'unreadable'
-  isSelectable: boolean
-  isHidden: boolean
-  diagnosticMessage?: string | null
-}
-
-export type PersonaProjectPickerListing = {
-  root: PersonaProjectPickerRoot
-  current: PersonaProjectPickerEntry
-  parentRelativePath: string | null
-  directories: PersonaProjectPickerEntry[]
-}
-
-export type PersonaProjectPickerConnected = {
-  id: string
-  /** Id соответствующей PersonaProjectPickerEntry. / Id of the matching PersonaProjectPickerEntry. */
-  projectId: string
-  title: string
-  path: string
-  active: boolean
-}
-
-/** Состояние каталога picker; pagination loading допустим только при существующем listing. / Picker directory state; pagination loading is valid only with an existing listing. */
-export type PersonaProjectPickerState =
-  | PersonaInventoryPendingState
-  | { status: 'ready'; listing: null; pagination: 'complete' }
-  | {
-    status: 'ready'
-    listing: PersonaProjectPickerListing
-    pagination: 'complete' | 'has-more' | 'loading-more'
-  }