@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/persona/presentation.js

@@ -0,0 +1,330 @@
+import { UI_KIT_MESSAGES as e, createUiKitTranslate as t } from "../../../locales/messages.js";
+import { validateExactString as n } from "../../../internal/runtimeContract.js";
+//#region src/components/shared/persona/presentation.ts
+var r = t(() => e.ru);
+function i(e, t = r) {
+	let n = e.severity === "error" || e.severity === "blocking", i = n ? t("persona.diagnosticError") : e.severity === "warning" ? t("persona.diagnosticWarning") : t("persona.diagnosticInformation"), a = n ? "danger" : e.severity === "warning" ? "warn" : "info";
+	if (e.context === "native_scenarios") return {
+		category: "scenario_import",
+		title: t("persona.scenarioNotImported"),
+		ownerLabel: t("persona.fixInTestProject"),
+		impactLabel: t("persona.scenarioUnavailable"),
+		remediation: t("persona.restoreScenarioImport"),
+		statusLabel: i,
+		statusSeverity: a
+	};
+	if (e.context === "components") return {
+		category: "component_analysis",
+		title: t("persona.componentNotAnalyzed"),
+		ownerLabel: t("persona.fixInTestProject"),
+		impactLabel: t("persona.relatedStructureIncomplete"),
+		remediation: t("persona.restoreComponentImport"),
+		statusLabel: i,
+		statusSeverity: a
+	};
+	if (e.context === "support_quality") {
+		let n = e.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: n,
+			statusLabel: i,
+			statusSeverity: a
+		};
+	}
+	return {
+		category: "unclassified",
+		title: t("persona.unclassifiedPersonaMessage"),
+		ownerLabel: t("persona.personaClassificationRequired"),
+		impactLabel: t("persona.impactUnspecified"),
+		remediation: t("persona.personaMustClassify"),
+		statusLabel: i,
+		statusSeverity: a
+	};
+}
+function a(e, t, n, i = r) {
+	let a = (e) => n.filter((t) => t.category === e).length, o = e + t, s = a("scenario_import"), c = a("component_analysis"), l = a("support_quality");
+	return [
+		i("persona.overviewAvailable", {
+			available: e,
+			total: o
+		}),
+		s > 0 ? i("persona.overviewScenarioImports", { count: s }) : null,
+		c > 0 ? i("persona.overviewComponentAnalysis", { count: c }) : null,
+		l > 0 ? i("persona.overviewSupportQuality", { count: l }) : null
+	].filter((e) => !!e).join(" ");
+}
+var o = [
+	"cancelled",
+	"cancelling",
+	"completed",
+	"degraded",
+	"error",
+	"failed",
+	"passed",
+	"paused",
+	"queued",
+	"running",
+	"skipped",
+	"timed_out",
+	"timeout",
+	"info",
+	"warn",
+	"warning"
+], s = {
+	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"
+	}
+};
+function c(e) {
+	return n("Persona presentation", "run status", e, o);
+}
+function l(e, t = r) {
+	return t(s[c(e)].labelKey);
+}
+function u(e) {
+	return s[c(e)].severity;
+}
+var d = [
+	"Action",
+	"CombinedStep",
+	"Expectation",
+	"Fact",
+	"Goal",
+	"Ops",
+	"Step",
+	"action",
+	"check",
+	"combined_step",
+	"expectation",
+	"fact",
+	"get",
+	"goal",
+	"make",
+	"persona_call",
+	"step"
+], f = {
+	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"
+};
+function p(e, t = r) {
+	return e == null ? "" : t(f[n("Persona presentation", "semantic kind", e, d)]);
+}
+function m(e, t = r) {
+	return e.map((e) => {
+		let n = e.type ? `: ${e.type}` : "", r = typeof e.default == "string" || typeof e.default == "number" || typeof e.default == "boolean" ? ` = ${String(e.default)}` : "";
+		return `${e.name}${n}${r}${e.required ? ` (${t("persona.requiredParameter")})` : ""}`;
+	}).join(", ");
+}
+var h = [
+	"blocker",
+	"critical",
+	"minor",
+	"normal",
+	"trivial"
+], g = {
+	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"
+	}
+};
+function _(e) {
+	return n("Persona presentation", "severity", e, h);
+}
+function v(e, t = r) {
+	return t(g[_(e)].labelKey);
+}
+function y(e) {
+	return g[_(e)].severity;
+}
+var b = [
+	"broken",
+	"failed",
+	"passed",
+	"skipped"
+], x = {
+	broken: "persona.reportBroken",
+	failed: "persona.statusError",
+	passed: "persona.statusPassed",
+	skipped: "persona.statusSkipped"
+};
+function S(e, t = r) {
+	return t(x[n("Persona presentation", "report status", e, b)]);
+}
+var C = [
+	"run_after_scenario",
+	"run_after_test",
+	"run_before_scenario",
+	"run_before_test"
+], w = {
+	run_after_scenario: "persona.lifecycleAfterScenario",
+	run_after_test: "persona.lifecycleAfterTest",
+	run_before_scenario: "persona.lifecycleBeforeScenario",
+	run_before_test: "persona.lifecycleBeforeTest"
+};
+function T(e, t = r) {
+	return t(w[n("Persona presentation", "lifecycle stage", e, C)]);
+}
+var E = [
+	"cancelled",
+	"completed",
+	"failed",
+	"log",
+	"queued",
+	"running",
+	"started",
+	"timeout",
+	"report.runtime_log",
+	"scenario.accepted",
+	"scenario.cancelled",
+	"scenario.finished",
+	"scenario.started",
+	"worker.started",
+	"worker.stopped"
+], D = {
+	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"
+};
+function O(e, t = r) {
+	return t(D[n("Persona presentation", "event type", e, E)]);
+}
+function k(e) {
+	if (!e) return "";
+	for (let t of [
+		"message",
+		"error_message",
+		"error",
+		"reason",
+		"detail",
+		"stderr",
+		"stdout"
+	]) {
+		let n = e[t];
+		if (typeof n == "string" && n.trim()) return n.trim();
+	}
+	return "";
+}
+function A(e, t, n = "ru") {
+	let r = t?.trim();
+	if (!r) return null;
+	let i = (e) => e.toLocaleLowerCase(n).replace(/[.!?]+$/u, "").trim();
+	return i(e) === i(r) ? null : r;
+}
+function j(e, t = r, n = "ru") {
+	return e == null ? t("persona.durationUnknown") : e < 1e3 ? t("persona.durationMilliseconds", { value: e }) : t("persona.durationSeconds", { value: (e / 1e3).toLocaleString(n, { maximumFractionDigits: 2 }) });
+}
+function M(e, t, n = "ru") {
+	if (n === "en") return `${e} ${e === 1 ? t[0] : t[2]}`;
+	if (n === "zh-CN" || n === "zh-TW") return `${e} ${t[2]}`;
+	let r = e % 100, i = e % 10;
+	return `${e} ${r >= 11 && r <= 14 ? t[2] : i === 1 ? t[0] : i >= 2 && i <= 4 ? t[1] : t[2]}`;
+}
+//#endregion
+export { M as personaCountLabel, a as personaDiagnosticOverviewMessage, i as personaDiagnosticPresentation, A as personaDistinctMessage, j as personaDurationLabel, O as personaEventTypeLabel, T as personaLifecycleStageLabel, m as personaParameterSummary, k as personaPayloadMessage, S as personaReportStatusLabel, l as personaRunStatusLabel, p as personaSemanticKindLabel, y as personaSeverityBadge, v as personaSeverityLabel, u as personaStatusSeverity };

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

@@ -0,0 +1,222 @@
+import { BadgeSeverity } from '../data-display/SBadge.vue';
+import { ActionListItemBadge } from '../data-display/SActionListItem.vue';
+import { Severity as MessageSeverity } from '../data-display/SMessage.vue';
+import { 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 declare function getPersonaRunConsoleFactKey(fact: PersonaRunConsoleFact): string;
+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';
+};

package/dist/src/components/shared/persona/types.js

@@ -0,0 +1,6 @@
+//#region src/components/shared/persona/types.ts
+function e(e) {
+	return e.id;
+}
+//#endregion
+export { e as getPersonaRunConsoleFactKey };

package/dist/src/composables/uiPreferencesReset.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Типизированный scoped-controller для сброса UI-предпочтений.
+ * Typed scoped controller for resetting UI preferences.
+ */
+export interface UiPreferencesResetController {
+    /**
+     * Подписывает owner на сброс и возвращает функцию отписки.
+     * Subscribes an owner to reset requests and returns an unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Синхронно уведомляет всех active owners о сбросе.
+     * Synchronously notifies every active owner about a reset.
+     */
+    requestReset(): void;
+}
+/**
+ * Создаёт isolated reset scope без document events и глобальных строковых каналов.
+ * Creates an isolated reset scope without document events or global string channels.
+ */
+export declare function createUiPreferencesResetController(): UiPreferencesResetController;

package/dist/src/composables/uiPreferencesReset.js

@@ -0,0 +1,24 @@
+import { createAggregateError as e } from "../internal/es2020.js";
+//#region src/composables/uiPreferencesReset.ts
+function t() {
+	let t = /* @__PURE__ */ new Set();
+	return {
+		subscribe(e) {
+			return t.add(e), () => {
+				t.delete(e);
+			};
+		},
+		requestReset() {
+			let n = [];
+			for (let e of [...t]) try {
+				e();
+			} catch (e) {
+				n.push(e);
+			}
+			if (n.length === 1) throw n[0];
+			if (n.length > 1) throw e(n, "Не все owners UI-предпочтений смогли обработать сброс.");
+		}
+	};
+}
+//#endregion
+export { t as createUiPreferencesResetController };

package/dist/src/composables/useClipboard.d.ts

@@ -0,0 +1,20 @@
+export type ClipboardCopyResult = {
+    status: 'copied';
+    method: 'clipboard-api';
+} | {
+    status: 'empty';
+} | {
+    status: 'unavailable';
+    reason: 'clipboard-api-missing';
+} | {
+    status: 'failed';
+    error: Error | DOMException;
+};
+export interface ClipboardService {
+    copyText: (value: string) => Promise<ClipboardCopyResult>;
+}
+/**
+ * Предоставляет единый типизированный контракт копирования текста.
+ * Provides the canonical typed text-copying contract.
+ */
+export declare function useClipboard(): ClipboardService;

package/dist/src/composables/useClipboard.js

@@ -0,0 +1,26 @@
+import { withErrorCause as e } from "../internal/es2020.js";
+//#region src/composables/useClipboard.ts
+function t() {
+	return { copyText: async (t) => {
+		if (!t) return { status: "empty" };
+		let n = typeof navigator > "u" ? void 0 : navigator.clipboard;
+		if (!n?.writeText) return {
+			status: "unavailable",
+			reason: "clipboard-api-missing"
+		};
+		try {
+			return await n.writeText(t), {
+				status: "copied",
+				method: "clipboard-api"
+			};
+		} catch (t) {
+			let n = typeof DOMException < "u" && t instanceof DOMException;
+			return {
+				status: "failed",
+				error: t instanceof Error || n ? t : e(/* @__PURE__ */ Error("Clipboard API rejected writeText without an Error object"), t)
+			};
+		}
+	} };
+}
+//#endregion
+export { t as useClipboard };

package/dist/src/composables/useDialogOverlay.d.ts

@@ -0,0 +1,19 @@
+import { ComponentPublicInstance, Ref } from 'vue';
+export interface DialogOverlayOptions {
+    open: Readonly<Ref<boolean>>;
+    closable: Readonly<Ref<boolean>>;
+    requestClose: () => void;
+    /** Runs after the mounted surface owns focus for the current open cycle. */
+    opened?: () => void;
+}
+export interface DialogOverlayController {
+    panelRef: Ref<HTMLElement | null>;
+    setPanelElement: (element: Element | ComponentPublicInstance | null) => void;
+    backdropStyle: Readonly<Ref<Record<string, string>>>;
+    surfaceStyle: Readonly<Ref<Record<string, string>>>;
+}
+/**
+ * Владеет modal-регистрацией, focus trap, body lock и восстановлением фокуса.
+ * Owns modal registration, focus trapping, body lock, and focus restoration.
+ */
+export declare function useDialogOverlay(options: DialogOverlayOptions): DialogOverlayController;