@ximatai/muyun-web-app 0.26.3

package/dist/types/web-core/actionResult.d.ts

@@ -0,0 +1,28 @@
+import { webDataChangeTypes, type WebActionResultEnvelope, type WebDataChange, type WebDataChangeType } from '@muyun/web-contracts';
+export interface ResolvedWebActionResult {
+    message: string;
+    messageCode?: string;
+    messageType?: string;
+    resultType?: string;
+    changeSetId?: string;
+    changes: WebDataChange[];
+    raw: unknown;
+}
+export { webDataChangeTypes };
+export type { WebDataChange, WebDataChangeType };
+export declare const webDataChanges: {
+    recordCreated(moduleAlias: string, recordId: string, facts?: WebDataChangeFacts): WebDataChange;
+    recordUpdated(moduleAlias: string, recordId: string, facts?: WebDataChangeFacts): WebDataChange;
+    recordDeleted(moduleAlias: string, recordId: string, facts?: WebDataChangeFacts): WebDataChange;
+    collectionChanged(moduleAlias: string, facts?: WebDataChangeFacts): WebDataChange;
+};
+export type WebDataChangeFacts = Omit<WebDataChange, 'type' | 'moduleAlias'>;
+export declare function withWebActionResultChanges<T>(result: T, changes: WebDataChange[]): T & {
+    changes: WebDataChange[];
+};
+export declare function resolveWebActionResultMessage(result: unknown, fallbackMessage?: string): string;
+export declare function resolveWebActionResult(result: unknown, options?: {
+    fallbackMessage?: string;
+}): ResolvedWebActionResult;
+export declare function actionResultData<TData>(result: TData | WebActionResultEnvelope<TData>): TData;
+export declare function webDataChangeKey(change: WebDataChange): string;

package/dist/types/web-core/clients.d.ts

@@ -0,0 +1,23 @@
+import type { ChangeOwnPasswordRequest, CurrentUser, LoginRequest, LoginResult, MenuMineResponse } from '@muyun/web-contracts';
+import type { HttpClient } from './http';
+export interface SessionClient {
+    current(): Promise<CurrentUser>;
+}
+export interface MenuClient {
+    mine(): Promise<MenuMineResponse>;
+}
+export interface AuthClient {
+    login(request: LoginRequest): Promise<LoginResult>;
+    changeOwnPassword(request: ChangeOwnPasswordRequest, token: string): Promise<void>;
+    logout(token?: string): Promise<void>;
+}
+export declare function createSessionClient(http: HttpClient): SessionClient;
+export declare function createMenuClient(http: HttpClient): MenuClient;
+/**
+ * The backend serializes Java enum values as upper-case identifiers while the
+ * web contract deliberately uses lower-case literals.  Normalize once at the
+ * HTTP projection boundary so every workbench consumer sees the same menu
+ * contract instead of requiring application-level compatibility code.
+ */
+export declare function normalizeMenuMineResponse(response: unknown): MenuMineResponse;
+export declare function createAuthClient(http: HttpClient): AuthClient;

package/dist/types/web-core/dataChanges.d.ts

@@ -0,0 +1,15 @@
+import type { WebCommittedChangeSet } from '@muyun/web-contracts';
+export type DataChangeHandler = (changeSet: WebCommittedChangeSet) => void | Promise<void>;
+export interface DataChangeDispatcher {
+    dispatch(changeSet: WebCommittedChangeSet): Promise<boolean>;
+    subscribe(handler: DataChangeHandler): DataChangeSubscription;
+    markHandled(changeSetId: string | undefined): void;
+}
+export interface DataChangeDispatcherOptions {
+    maxHandledChangeSetIds?: number;
+}
+export interface DataChangeSubscription {
+    unsubscribe(): void;
+}
+export declare function createDataChangeDispatcher(options?: DataChangeDispatcherOptions): DataChangeDispatcher;
+export declare function normalizeChangeSet(changeSet: WebCommittedChangeSet | undefined): WebCommittedChangeSet | undefined;

package/dist/types/web-core/errors.d.ts

@@ -0,0 +1,65 @@
+import type { WebActionMessage } from '@muyun/web-contracts';
+export interface ErrorTarget {
+    kind?: string;
+    moduleAlias?: string;
+    entityAlias?: string;
+    relationAlias?: string;
+    fieldName?: string;
+    rowIndex?: number;
+    recordId?: string;
+    actionCode?: string;
+    attachmentId?: string;
+}
+export interface ErrorUiContext {
+    phase: 'page-load' | 'action' | 'background';
+    surface: 'workbench' | 'form' | 'table' | 'dialog' | 'unknown';
+}
+export type GlobalErrorSlot = 'redirect-login' | 'page-error' | 'global-toast' | 'global-modal' | 'silent';
+export interface GlobalErrorPresentation {
+    slot: GlobalErrorSlot;
+    message: string;
+    traceId?: string;
+}
+export declare const platformErrorCodes: {
+    readonly appError: "APP_ERROR";
+    readonly networkError: "NETWORK_ERROR";
+    readonly httpError: "HTTP_ERROR";
+    readonly authRequired: "AUTH_REQUIRED";
+    readonly authExpired: "AUTH_EXPIRED";
+    readonly passwordChangeRequired: "PASSWORD_CHANGE_REQUIRED";
+    readonly loginBadCredentials: "LOGIN_BAD_CREDENTIALS";
+    readonly accessDenied: "ACCESS_DENIED";
+    readonly validationFailed: "VALIDATION_FAILED";
+    readonly conflictVersion: "CONFLICT_VERSION";
+    readonly resourceInUse: "RESOURCE_IN_USE";
+    readonly resourceNotFound: "RESOURCE_NOT_FOUND";
+    readonly resourceSoftDeletedConflict: "RESOURCE_SOFT_DELETED_CONFLICT";
+    readonly configMissing: "CONFIG_MISSING";
+    readonly internalError: "INTERNAL_ERROR";
+};
+export type PlatformErrorCode = (typeof platformErrorCodes)[keyof typeof platformErrorCodes] | (string & {});
+export declare class AppError extends Error {
+    readonly code: PlatformErrorCode;
+    readonly status?: number;
+    readonly traceId?: string;
+    readonly scope?: Record<string, unknown>;
+    readonly targets: ErrorTarget[];
+    readonly details?: Record<string, unknown>;
+    readonly messageArgs?: Record<string, unknown>;
+    readonly actionMessage?: WebActionMessage;
+    globallyHandled: boolean;
+    constructor(message: string, options?: {
+        code?: PlatformErrorCode;
+        status?: number;
+        traceId?: string;
+        scope?: Record<string, unknown>;
+        targets?: ErrorTarget[];
+        details?: Record<string, unknown>;
+        messageArgs?: Record<string, unknown>;
+        actionMessage?: WebActionMessage;
+    });
+}
+export declare function normalizeError(error: unknown): AppError;
+export declare function resolveGlobalErrorPresentation(error: AppError, context?: ErrorUiContext): GlobalErrorPresentation;
+export declare function userFacingErrorMessage(error: AppError): string;
+export declare function isUnexpectedPlatformError(error: AppError): boolean;

package/dist/types/web-core/http.d.ts

@@ -0,0 +1,21 @@
+import type { RouteQueryValue } from '@muyun/web-contracts';
+import { AppError } from './errors';
+export interface RequestContext {
+    baseUrl?: string;
+    token?: string;
+    traceId?: string;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+    onAuthenticationRequired?: (error: AppError, token?: string) => boolean | void;
+}
+export interface HttpRequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    query?: Record<string, RouteQueryValue>;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+export interface HttpClient {
+    request<T>(options: HttpRequestOptions): Promise<T>;
+}
+export declare function createHttpClient(context?: RequestContext): HttpClient;

package/dist/types/web-core/index.d.ts

@@ -0,0 +1,8 @@
+export * from './errors';
+export * from './http';
+export * from './query';
+export * from './actionResult';
+export * from './dataChanges';
+export * from './realtime';
+export * from './clients';
+export * from './module/index';

package/dist/types/web-core/mock.d.ts

@@ -0,0 +1,6 @@
+import type { CurrentUser, MenuRecord, WebTreeNode } from '@muyun/web-contracts';
+import type { MenuClient, SessionClient } from './index';
+export declare function createMockSessionClient(currentUser?: CurrentUser): SessionClient;
+export declare function createMockMenuClient(records?: WebTreeNode<MenuRecord>[]): MenuClient;
+export declare const mockCurrentUser: CurrentUser;
+export declare const mockMenuTree: WebTreeNode<MenuRecord>[];

package/dist/types/web-core/module/abilities.d.ts

@@ -0,0 +1,21 @@
+import { type ModuleAbilityCode } from './abilityCodes';
+import { type ModuleRuntimeContextState } from './runtimeContext';
+import type { ModuleEnableClient, StaticModuleCrudClient, StaticModuleTreeClient } from './staticModuleClient';
+export interface ModuleAbilityClients<TRecord> {
+    crud: StaticModuleCrudClient<TRecord>;
+    tree: StaticModuleTreeClient<TRecord>;
+    enable: ModuleEnableClient;
+}
+export interface ModuleAbilities<TRecord> {
+    crud(): StaticModuleCrudClient<TRecord>;
+    tree(): StaticModuleTreeClient<TRecord>;
+    enable(): ModuleEnableClient;
+    tryCrud(): StaticModuleCrudClient<TRecord> | undefined;
+    tryTree(): StaticModuleTreeClient<TRecord> | undefined;
+    tryEnable(): ModuleEnableClient | undefined;
+    has(ability: ModuleAbilityCode | string): boolean | undefined;
+    hasCrud(): boolean | undefined;
+    hasTree(): boolean | undefined;
+    hasEnable(): boolean | undefined;
+}
+export declare function createModuleAbilities<TRecord>(moduleAlias: string, runtime: ModuleRuntimeContextState, clients: ModuleAbilityClients<TRecord>): ModuleAbilities<TRecord>;

package/dist/types/web-core/module/abilityCodes.d.ts

@@ -0,0 +1,18 @@
+export declare const moduleAbilityCodes: {
+    readonly crud: "crud";
+    readonly softDelete: "softDelete";
+    readonly lifecycle: "lifecycle";
+    readonly cache: "cache";
+    readonly tree: "tree";
+    readonly sort: "sort";
+    readonly reference: "reference";
+    readonly enable: "enable";
+    readonly dataScope: "dataScope";
+    readonly recycleBin: "recycleBin";
+    readonly workflow: "workflow";
+    readonly approval: "approval";
+    readonly childRelation: "childRelation";
+    readonly referenceDependency: "referenceDependency";
+    readonly exchange: "exchange";
+};
+export type ModuleAbilityCode = (typeof moduleAbilityCodes)[keyof typeof moduleAbilityCodes];

package/dist/types/web-core/module/index.d.ts

@@ -0,0 +1,6 @@
+export * from './abilityCodes';
+export * from './recycleBin';
+export * from './staticModuleClient';
+export type { ModuleActionState, ModuleRuntimeAction, ModuleRuntimeContext, ModuleRuntimeContextState, } from './runtimeContext';
+export type { ModuleAbilityClients, ModuleAbilities } from './abilities';
+export * from './moduleContext';

package/dist/types/web-core/module/moduleContext.d.ts

@@ -0,0 +1,49 @@
+import type { HttpClient } from '../http';
+import { type ModuleAbilities } from './abilities';
+import { type ModuleActionState, type ModuleRecordActionAvailability, type ModuleRuntimeAction, type ModuleRuntimeContextState } from './runtimeContext';
+import { type StaticModuleCrudClient, type StaticModuleTreeClient } from './staticModuleClient';
+export interface ModuleContext<TRecord> {
+    moduleAlias: string;
+    http: HttpClient;
+    crud: StaticModuleCrudClient<TRecord>;
+    runtime: ModuleRuntimeContextState;
+    abilities: ModuleAbilities<TRecord>;
+    action(actionCode: string, recordId?: string): ModuleActionState | undefined;
+    runtimeAction(actionCode: string): ModuleRuntimeAction | undefined;
+    can(actionCode: string, recordId?: string): boolean | undefined;
+    recordActions(recordId: string): Promise<ModuleRecordActionAvailability>;
+    recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
+}
+export interface ModuleTreeContext<TRecord> extends ModuleContext<TRecord> {
+    tree: StaticModuleTreeClient<TRecord>;
+}
+export interface ModuleContextConfig {
+    http?: HttpClient;
+    httpFactory?: () => HttpClient;
+}
+export interface ModuleContextOptions extends ModuleContextConfig {
+    moduleAlias: string;
+}
+export declare function configureModuleContext(config: ModuleContextConfig): void;
+export declare function provideModuleContextConfig(config: ModuleContextConfig): void;
+export declare function createModuleContext<TRecord>(options: ModuleContextOptions): ModuleContext<TRecord>;
+export declare function createModuleTreeContext<TRecord>(options: ModuleContextOptions): ModuleTreeContext<TRecord>;
+export declare function useModuleContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleContext<TRecord>;
+export declare function useModuleTreeContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleTreeContext<TRecord>;
+export declare const ModuleContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    moduleAlias: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    moduleAlias: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    moduleAlias: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/web-core/module/recycleBin.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleContext } from './moduleContext';
+/**
+ * 回收站是模块能力，查询权限只决定当前用户能否进入该能力。
+ */
+export declare function hasRecycleBinAbility<TRecord>(context: ModuleContext<TRecord>): boolean;
+export declare function canQueryRecycleBin<TRecord>(context: ModuleContext<TRecord>): boolean;

package/dist/types/web-core/module/runtimeContext.d.ts

@@ -0,0 +1,65 @@
+import type { ResolvedModuleUiDescriptor } from '@muyun/web-contracts';
+import { type AppError } from '../errors';
+import type { HttpClient } from '../http';
+import type { ModuleAbilityCode } from './abilityCodes';
+export interface ModuleRuntimeAction {
+    actionCode: string;
+    permissionActionCode?: string;
+    title?: string;
+    actionLevel?: 'DEFAULT' | 'LIST' | 'RECORD' | 'BATCH' | 'ANY';
+    category?: string;
+    accessMode?: 'AUTH_REQUIRED' | 'LOGIN_REQUIRED' | 'ANONYMOUS_ALLOWED';
+    actionAuth?: boolean;
+    dataAuth?: boolean;
+    defaultGrantPolicy?: string;
+    executorType?: string;
+    executorKey?: string;
+    authorized: boolean;
+    authorizationDecision?: string;
+}
+export interface ModuleActionState {
+    actionCode: string;
+    available: boolean;
+    reason?: string;
+    authorized?: boolean;
+    recordId?: string;
+    definition?: ModuleRuntimeAction;
+    actionLevel?: ModuleRuntimeAction['actionLevel'];
+    title?: string;
+}
+export interface ModuleRecordActionAvailability {
+    recordId: string;
+    actions: ModuleRecordActionDecision[];
+}
+export interface ModuleRecordActionDecision {
+    actionCode: string;
+    available: boolean;
+    reason?: string;
+}
+export interface ModuleRuntimeContext {
+    moduleAlias: string;
+    title?: string;
+    moduleKind?: 'STATIC' | 'DYNAMIC';
+    entryType?: 'module' | 'route' | 'link';
+    entryRoute?: string;
+    entryExternalUrl?: string;
+    mainEntityAlias?: string;
+    capabilities: string[];
+    abilities?: string[];
+    actions: ModuleRuntimeAction[];
+    uiDescriptor?: ResolvedModuleUiDescriptor;
+}
+export interface ModuleRuntimeContextState {
+    ready: Promise<ModuleRuntimeContext>;
+    load(): Promise<ModuleRuntimeContext>;
+    snapshot(): ModuleRuntimeContext | undefined;
+    error(): AppError | undefined;
+    hasAbility(ability: ModuleAbilityCode | string): boolean | undefined;
+    action(actionCode: string, recordId?: string): ModuleActionState | undefined;
+    runtimeAction(actionCode: string): ModuleRuntimeAction | undefined;
+    can(actionCode: string, recordId?: string): boolean | undefined;
+    recordActions(recordId: string): Promise<ModuleRecordActionAvailability>;
+    recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
+}
+export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string): ModuleRuntimeContextState;
+export declare function isRuntimeAbilityAvailable(context: ModuleRuntimeContext | undefined, ability: ModuleAbilityCode): boolean;

package/dist/types/web-core/module/staticModuleClient.d.ts

@@ -0,0 +1,45 @@
+import type { TreeSortRequest, WebActionResultFacts, WebActionResultEnvelope, QuerySchema, WebListResponse, WebPageResponse, WebQueryRequest, WebTreeNode } from '@muyun/web-contracts';
+import type { HttpClient } from '../http';
+export interface StaticRecordMutationResult<TRecord> extends WebActionResultFacts {
+    record: TRecord;
+}
+export type StaticCountMutationResult = number | WebActionResultEnvelope<number>;
+export interface RecordActionRequest {
+    version: number;
+}
+export interface QuerySchemaRequestOptions {
+    uiConfigId?: string;
+}
+export interface StaticModuleCrudClient<TRecord> {
+    querySchema(options?: QuerySchemaRequestOptions): Promise<QuerySchema>;
+    query(request?: WebQueryRequest): Promise<WebPageResponse<TRecord>>;
+    view(id: string): Promise<TRecord>;
+    insert(record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
+    update(id: string, record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
+    delete(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
+    enable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
+    disable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
+}
+export interface StaticModuleTreeClient<TRecord> extends StaticModuleCrudClient<TRecord> {
+    tree(): Promise<WebListResponse<WebTreeNode<TRecord>>>;
+    treeFlat(options?: {
+        rootId?: string;
+        includeSelf?: boolean;
+    }): Promise<WebListResponse<TRecord>>;
+    subtree(id: string, options?: {
+        includeSelf?: boolean;
+    }): Promise<WebListResponse<WebTreeNode<TRecord>>>;
+    sort(id: string, request: TreeSortRequest): Promise<StaticCountMutationResult>;
+}
+export interface ModuleEnableClient {
+    enable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
+    disable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
+}
+export declare function createStaticModuleCrudClient<TRecord>(http: HttpClient, options: {
+    moduleAlias: string;
+}): StaticModuleCrudClient<TRecord>;
+export declare function createStaticResourceCrudClient<TRecord>(http: HttpClient, resourcePath: string): StaticModuleCrudClient<TRecord>;
+export declare function createStaticModuleTreeClient<TRecord>(http: HttpClient, options: {
+    moduleAlias: string;
+}): StaticModuleTreeClient<TRecord>;
+export declare function createStaticResourceTreeClient<TRecord>(http: HttpClient, resourcePath: string): StaticModuleTreeClient<TRecord>;

package/dist/types/web-core/query.d.ts

@@ -0,0 +1,16 @@
+import { QueryClient, VueQueryPlugin } from '@tanstack/vue-query';
+export declare function createQueryClient(): QueryClient;
+export declare const queryKeys: {
+    session: {
+        current: readonly ["session", "current"];
+    };
+    menu: {
+        mine: readonly ["menu", "mine"];
+    };
+    staticModule: {
+        query: (moduleAlias: string, request?: unknown) => readonly ["static-module", string, "query", unknown];
+        tree: (moduleAlias: string, options?: unknown) => readonly ["static-module", string, "tree", unknown];
+        view: (moduleAlias: string, id: string) => readonly ["static-module", string, "view", string];
+    };
+};
+export { VueQueryPlugin };

package/dist/types/web-core/realtime.d.ts

@@ -0,0 +1,104 @@
+import { type IMessage } from '@stomp/stompjs';
+import type { WebBusinessRealtimeEvent, WebCommittedChangeSet, WebRealtimeEnvelope, WebUserNotification } from '@muyun/web-contracts';
+import type { DataChangeDispatcher } from './dataChanges';
+export type RealtimeConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'unauthorized' | 'failed';
+export interface RealtimeChannel<TPayload> {
+    destination: string;
+    type?: string;
+    readonly __payload?: TPayload;
+}
+export interface RealtimeCommand<TPayload> {
+    destination: string;
+    readonly __payload?: TPayload;
+}
+export type RealtimeHandler<TPayload> = (payload: TPayload, envelope: WebRealtimeEnvelope<TPayload> | undefined) => void | Promise<void>;
+export interface RealtimeSubscription {
+    unsubscribe(): void;
+}
+export interface RealtimeClient {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe<TPayload>(channel: RealtimeChannel<TPayload>, handler: RealtimeHandler<TPayload>): RealtimeSubscription;
+    publish<TPayload>(command: RealtimeCommand<TPayload>, payload: TPayload): void;
+    state(): RealtimeConnectionState;
+}
+export interface RealtimeClientOptions {
+    baseUrl?: string;
+    token?: string;
+    brokerPath?: string;
+    reconnectDelay?: number;
+    heartbeatIncoming?: number;
+    heartbeatOutgoing?: number;
+    clientFactory?: StompClientFactory;
+    onStateChange?: (state: RealtimeConnectionState) => void;
+}
+export interface StompClientFactory {
+    (options: StompClientFactoryOptions): StompClientAdapter;
+}
+export interface StompClientFactoryOptions {
+    brokerURL: string;
+    connectHeaders: Record<string, string>;
+    reconnectDelay: number;
+    heartbeatIncoming: number;
+    heartbeatOutgoing: number;
+    onConnect: () => void;
+    onDisconnect: () => void;
+    onWebSocketClose: () => void;
+    onStompError: (frame?: StompErrorFrame) => void;
+}
+export interface StompClientAdapter {
+    connected: boolean;
+    activate(): void;
+    deactivate(): Promise<void>;
+    subscribe(destination: string, handler: (message: IMessage) => void): StompSubscriptionLike;
+    publish(options: {
+        destination: string;
+        body: string;
+    }): void;
+}
+export interface StompSubscriptionLike {
+    unsubscribe(): void;
+}
+export interface StompErrorFrame {
+    headers?: Record<string, string | undefined>;
+    body?: string;
+}
+export declare const realtimeMessageTypes: {
+    readonly dataChange: "platform.data-change";
+    readonly securityNotification: "platform.security-notification";
+    readonly businessEvent: "platform.business-event";
+};
+export declare const realtimeDestinations: {
+    readonly userDataChanges: "/user/queue/platform/data-changes";
+    readonly userNotifications: "/user/queue/platform/notifications";
+    readonly userBusinessEvents: "/user/queue/platform/business-events";
+    readonly userImMessages: "/user/queue/platform/im/messages";
+    readonly platformPing: "/app/platform/ping";
+    readonly sessionActivity: "/app/platform/session/activity";
+    readonly imMessagesSend: "/app/platform/im/messages/send";
+};
+export declare const dataChangeChannel: RealtimeChannel<WebCommittedChangeSet>;
+export declare const userNotificationChannel: RealtimeChannel<WebUserNotification>;
+export declare const userBusinessEventChannel: RealtimeChannel<WebBusinessRealtimeEvent>;
+export declare const userImMessageChannel: RealtimeChannel<unknown>;
+export declare const platformPingCommand: RealtimeCommand<{
+    timestamp: string;
+}>;
+export declare const sessionActivityCommand: RealtimeCommand<{
+    timestamp: string;
+}>;
+export declare const imMessageSendCommand: RealtimeCommand<unknown>;
+export declare function tenantPublicDataChangeChannel(tenantId: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function tenantPublicNotificationChannel(tenantId: string): RealtimeChannel<unknown>;
+export declare function organizationPublicDataChangeChannel(organizationId: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function organizationPublicNotificationChannel(organizationId: string): RealtimeChannel<unknown>;
+export declare function moduleDataChangeChannel(moduleAlias: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function recordDataChangeChannel(moduleAlias: string, recordId: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function resourceDataChangeChannel(moduleAlias: string, resourceKey: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function resourceRecordDataChangeChannel(moduleAlias: string, resourceKey: string, recordId: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function contextDataChangeChannel(contextType: string, contextId: string): RealtimeChannel<WebCommittedChangeSet>;
+export declare function imConversationMessageChannel(conversationId: string): RealtimeChannel<unknown>;
+export declare function createRealtimeClient(options?: RealtimeClientOptions): RealtimeClient;
+export declare function connectRealtimeDataChanges(realtime: RealtimeClient, dispatcher: DataChangeDispatcher): RealtimeSubscription;
+export declare function connectRealtimeUserNotifications(realtime: RealtimeClient, handler: RealtimeHandler<WebUserNotification>): RealtimeSubscription;
+export declare function connectRealtimeBusinessEvents(realtime: RealtimeClient, handler: RealtimeHandler<WebBusinessRealtimeEvent>): RealtimeSubscription;

package/dist/useUserSessionRows-CLM0ZvAF.js

@@ -0,0 +1,128 @@
+import { Et as e } from "./platform-components-bC1gwhic.js";
+import { t } from "./pageRealtime-sRtDYlQP.js";
+import { ref as n } from "vue";
+//#region src/views/useUserSessionRows.ts
+function r(r) {
+	let i = n([]), a = n({}), o = n([]), s = n({}), c = t({ load: async (e) => {
+		await g(e.keys, e.isLatest);
+	} }), l = t({ load: async (e) => {
+		await Promise.all(e.keys.map((t) => d(t, e.isLatest)));
+	} });
+	function u(e) {
+		l.enqueue(e);
+	}
+	async function d(t, n = () => !0) {
+		if (!(!t || r.context.can("sessions", t) === !1)) {
+			y(t, {
+				...v(t),
+				loading: !0,
+				error: void 0
+			});
+			try {
+				await f(t);
+				let e = await r.context.http.request({
+					method: "GET",
+					path: `/iam.user/${encodeURIComponent(t)}/sessions`
+				});
+				if (!n(t)) return;
+				y(t, {
+					records: e,
+					loading: !1,
+					error: void 0
+				});
+			} catch (i) {
+				if (!n(t)) return;
+				let a = e(i, {
+					source: `${r.source}-sessions`,
+					phase: "load"
+				});
+				y(t, {
+					...v(t),
+					loading: !1,
+					error: a.message
+				});
+			}
+		}
+	}
+	async function f(t) {
+		try {
+			await r.context.recordActions(t);
+		} catch (t) {
+			e(t, {
+				source: `${r.source}-sessions`,
+				phase: "load"
+			});
+		}
+	}
+	function p(e, t) {
+		let n = String(e.id ?? "");
+		n && (i.value = t ? Array.from(new Set([...i.value, n])) : i.value.filter((e) => e !== n), t && v(n).records.length === 0 && l.enqueue(n));
+	}
+	function m(e) {
+		o.value = e.map((e) => String(e.id ?? "")).filter(Boolean), c.enqueue(o.value);
+	}
+	function h(e) {
+		if (e.type !== "iam.user.session.collectionChanged" || e.moduleAlias !== "iam.user") return;
+		let t = String(e.recordId ?? "");
+		t && (o.value.includes(t) && c.enqueue(t), i.value.includes(t) && l.enqueue(t));
+	}
+	async function g(t, n = () => !0) {
+		let i = Array.from(new Set(t.filter(Boolean)));
+		if (i.length !== 0) try {
+			let e = (await r.context.http.request({
+				method: "POST",
+				path: "/iam.user/sessions/status",
+				body: { userIds: i }
+			})).filter((e) => n(e.userId));
+			if (e.length === 0) return;
+			s.value = {
+				...s.value,
+				...Object.fromEntries(e.map((e) => [e.userId, e]))
+			};
+		} catch (t) {
+			e(t, {
+				source: `${r.source}-online-status`,
+				phase: "load"
+			});
+		}
+	}
+	function _(e) {
+		let t = String(e.id ?? ""), n = s.value[t];
+		if (!n) return "-";
+		if (n.present) {
+			let e = n.presentSessionCount ?? 0, t = n.idleSessionCount ?? 0;
+			return e > 0 && t >= e ? `闲置 (${e}/${n.activeSessionCount})` : `使用中 (${Math.max(0, e - t)}/${n.activeSessionCount})`;
+		}
+		return n.online ? `在线 (${n.activeSessionCount})` : "离线";
+	}
+	function v(e) {
+		return e ? a.value[e] ?? {
+			records: [],
+			loading: !1
+		} : {
+			records: [],
+			loading: !1
+		};
+	}
+	function y(e, t) {
+		a.value = {
+			...a.value,
+			[e]: t
+		};
+	}
+	function b() {
+		c.reset(), l.reset(), i.value = [], a.value = {}, o.value = [], s.value = {};
+	}
+	return {
+		expandedUserKeys: i,
+		handleUserListLoaded: m,
+		handleUserRowExpand: p,
+		handleUserSessionBusinessEvent: h,
+		loadUserSessions: u,
+		resetUserSessionRows: b,
+		userOnlineStatusTitle: _,
+		userSessionState: v
+	};
+}
+//#endregion
+export { r as t };