@ximatai/muyun-web-app 0.26.18 → 0.26.20

package/dist/types/views/WorkflowDefinitionSettings.vue.d.ts

@@ -0,0 +1,35 @@
+import type { useWorkflowConfigurationContext } from './useWorkflowConfigurationContext';
+type __VLS_Props = {
+    configuration: ReturnType<typeof useWorkflowConfigurationContext>;
+    creating: boolean;
+    busy: boolean;
+    actionCodeLocked?: boolean;
+};
+type __VLS_ModelProps = {
+    'title': string;
+    'approvalEnabled': boolean;
+    'actionCode': string;
+    'organizationId': string;
+    'matchExpression': string;
+    'fallback': boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: () => any;
+    "update:organizationId": (value: string) => any;
+    "update:matchExpression": (value: string) => any;
+    "update:fallback": (value: boolean) => any;
+    "update:title": (value: string) => any;
+    "update:approvalEnabled": (value: boolean) => any;
+    "update:actionCode": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSubmit?: (() => any) | undefined;
+    "onUpdate:organizationId"?: ((value: string) => any) | undefined;
+    "onUpdate:matchExpression"?: ((value: string) => any) | undefined;
+    "onUpdate:fallback"?: ((value: boolean) => any) | undefined;
+    "onUpdate:title"?: ((value: string) => any) | undefined;
+    "onUpdate:approvalEnabled"?: ((value: boolean) => any) | undefined;
+    "onUpdate:actionCode"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/WorkflowSelectionFields.vue.d.ts

@@ -1,27 +1,25 @@
 import { type ModuleContext } from '../web-core/index';
+import type { FormulaExpressionTools } from '../platform-components/formulaExpressionTools';
 import type { FormulaExpressionField } from '../platform-components/formulaExpressionTokens';
 type __VLS_Props = {
     organizationContext?: ModuleContext<Record<string, unknown>>;
     fields: readonly FormulaExpressionField[];
     disabled: boolean;
-    invalidPriority: boolean;
+    conditionTools?: FormulaExpressionTools;
 };
 type __VLS_ModelProps = {
     'organizationId': string;
     'matchExpression': string;
-    'matchPriority': string;
     'fallback': boolean;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:organizationId": (value: string) => any;
     "update:matchExpression": (value: string) => any;
-    "update:matchPriority": (value: string) => any;
     "update:fallback": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:organizationId"?: ((value: string) => any) | undefined;
     "onUpdate:matchExpression"?: ((value: string) => any) | undefined;
-    "onUpdate:matchPriority"?: ((value: string) => any) | undefined;
     "onUpdate:fallback"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/types/views/useWorkflowConfigurationContext.d.ts

@@ -0,0 +1,49 @@
+/** Shared module facts and formula assistance for definition management and design. */
+export declare function useWorkflowConfigurationContext(moduleAlias: string): {
+    context: import("../web-core/index").ModuleContext<unknown>;
+    client: {
+        formulaFunctions: () => Promise<{
+            name: string;
+            title: string;
+            description: string;
+            example: string;
+            parameters: {
+                name: string;
+                description: string;
+            }[];
+        }[]>;
+        validateCondition: (expression: string) => Promise<void>;
+        sort: (id: string, targetId: string, position: -1 | 1) => Promise<unknown>;
+        catalog: (id: string) => Promise<import("../web-contracts").WorkflowConfigurationCatalog>;
+        query: () => Promise<import("../web-contracts").WorkflowDefinition[]>;
+        versions: (id: string) => Promise<import("../web-contracts").WorkflowVersion[]>;
+        create: (payload: import("../web-contracts").WorkflowDefinitionCreate) => Promise<import("../web-contracts").WorkflowDefinition>;
+        view: (id: string) => Promise<import("../web-contracts").WorkflowDefinition>;
+        upgrade: (id: string) => Promise<import("../web-contracts").WorkflowVersion>;
+        saveSelection: (id: string, payload: import("../web-contracts").WorkflowDefinitionSelection) => Promise<import("../web-contracts").WorkflowDefinition>;
+        design: (id: string, versionId: string) => Promise<import("../web-contracts").WorkflowDesign>;
+        saveDesign: (id: string, versionId: string, expectedVersion: number, design: import("../web-contracts").WorkflowDesign) => Promise<import("../web-contracts").WorkflowVersion>;
+        validate: (id: string, versionId: string) => Promise<unknown>;
+        publish: (id: string, versionId: string, definitionVersion: number, expectedVersion: number) => Promise<import("../web-contracts").WorkflowVersion>;
+        changeStatus: (id: string, action: "enable" | "disable" | "archive", expectedVersion: number) => Promise<import("../web-contracts").WorkflowDefinition>;
+    };
+    language: import("../web-core/index").LanguageContext;
+    businessRuntime: import("vue").ComputedRef<import("../web-core/index").ModuleRuntimeContext | undefined>;
+    fields: import("vue").ComputedRef<{
+        name: string;
+        label: string;
+        valueType: import("../web-contracts").ViewFieldValueType | undefined;
+        referenceModule: string | undefined;
+    }[]>;
+    organizationContext: import("vue").ComputedRef<import("../web-core/index").ModuleContext<Record<string, unknown>> | undefined>;
+    conditionTools: {
+        loadFunctions: () => Promise<{
+            name: string;
+            title: string;
+            description: string;
+            example: string;
+            signature: string;
+        }[]>;
+        validate: (expression: string) => Promise<void>;
+    };
+};

package/dist/types/views/workflowConfigurationWorkspaceView.d.ts

@@ -1,5 +1,7 @@
 export interface WorkflowConfigurationInput {
     moduleAlias: string;
     moduleTitle?: string;
+    definitionId: string;
+    definitionTitle?: string;
 }
 export declare const workflowConfigurationWorkspaceView: import("../platform-workbench/workspaceViewContract.ts").WorkspaceViewDefinition<WorkflowConfigurationInput>;

package/dist/types/vue-ui-antdv/components/UiIcon.vue.d.ts

@@ -1,4 +1,4 @@
-export type UiIconName = 'app' | 'language' | 'assistant' | 'check' | 'close' | 'delete' | 'download' | 'down' | 'up' | 'edit' | 'export' | 'eye' | 'eye-off' | 'filter' | 'help' | 'left' | 'lock' | 'menu-collapse' | 'menu-expand' | 'minus' | 'notification' | 'open-in-new' | 'plus' | 'pin-off' | 'pin' | 'power' | 'reload' | 'right' | 'save' | 'search' | 'skin' | 'settings' | 'swap' | 'swap-vertical' | 'user';
+export type UiIconName = 'app' | 'fit-screen' | 'locate-start' | 'locate-end' | 'zoom-in' | 'zoom-out' | 'locate' | 'layout' | 'fullscreen' | 'fullscreen-exit' | 'language' | 'assistant' | 'check' | 'close' | 'delete' | 'download' | 'down' | 'up' | 'edit' | 'export' | 'eye' | 'eye-off' | 'filter' | 'help' | 'left' | 'lock' | 'menu-collapse' | 'menu-expand' | 'minus' | 'notification' | 'open-in-new' | 'plus' | 'pin-off' | 'pin' | 'power' | 'reload' | 'right' | 'save' | 'search' | 'skin' | 'settings' | 'swap' | 'swap-vertical' | 'user';
 type __VLS_Props = {
     name: UiIconName;
 };

package/dist/types/vue-ui-antdv/components/UiRadioGroup.vue.d.ts

@@ -2,12 +2,16 @@ export interface UiRadioOption {
     value: string;
     label: string;
     disabled?: boolean;
+    description?: string;
+    /** Optional categorical accent for card borders; accepts a CSS color or theme variable. */
+    color?: string;
 }
 type __VLS_Props = {
     value?: string;
     options: readonly UiRadioOption[];
     disabled?: boolean;
     size?: 'small' | 'default' | 'large';
+    appearance?: 'buttons' | 'cards';
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:value": (value: string) => any;

package/dist/types/vue-ui-antdv/components/UiSidePanel.vue.d.ts

@@ -3,6 +3,9 @@ import { type UiDrawerCloseGuard, type UiDrawerDismissal } from '../drawerDismis
 import { type UiSidePanelScope } from './sidePanelHost';
 type __VLS_Props = {
     open: boolean;
+    /** Keep a transfer target mounted when an adaptive detail surface is docked. */
+    forceRender?: boolean;
+    autofocus?: boolean;
     /** Inline surfaces stay in their owning workspace. */
     renderMode?: 'inline' | 'portal';
     width?: UiDrawerWidth;
@@ -25,6 +28,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }>, {
     scope: UiSidePanelScope;
     width: UiDrawerWidth;
+    autofocus: boolean;
+    forceRender: boolean;
     renderMode: "inline" | "portal";
     dismissal: UiDrawerDismissal;
     closeOnOutside: boolean;

package/dist/types/vue-ui-antdv/index.d.ts

@@ -36,6 +36,7 @@ export { default as DictionarySelect } from './components/DictionarySelect.vue';
 export { default as ReferenceSelect } from './components/ReferenceSelect.vue';
 export { default as UiTable } from './components/UiTable.vue';
 export { confirmAction } from './confirm';
+export { uiOverlayLayers } from './overlayLayers';
 export { allowsUiDrawerOutsideDismissal, mayCloseUiDrawer, resolveUiDrawerDismissal, } from './drawerDismissal';
 export type { UiDrawerCloseGuard, UiDrawerCloseReason, UiDrawerDismissal, UiDrawerDismissalOptions, } from './drawerDismissal';
 export { showErrorMessage, showFeedback, showInfoMessage, showSuccessMessage, showWarningMessage, } from './feedback';

package/dist/types/vue-ui-antdv/overlayLayers.d.ts

@@ -0,0 +1,5 @@
+/** Notifications remain above page overlays; their own confirmations must remain actionable. */
+export declare const uiOverlayLayers: {
+    readonly notification: 1200;
+    readonly notificationConfirmation: 1210;
+};

package/dist/types/vue-ui-antdv/types.d.ts

@@ -123,6 +123,8 @@ export interface UiTreeDropEvent {
 }
 export type UiTreeChangeReason = 'interaction' | 'filter' | 'reset';
 export interface UiConfirmOptions {
+    /** Use the notification layer when the confirmation originates from a persistent notification. */
+    layer?: 'standard' | 'notification';
     title: string;
     content?: string;
     details?: {

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

@@ -126,6 +126,10 @@ export interface WebBusinessNotification {
     content: string;
     dismissible: boolean;
     actions: WebBusinessNotificationAction[];
+    /** Persistent cards remain above ordinary overlays and outside the collapsible queue. */
+    displayPolicy?: 'standard' | 'persistent';
+    /** Optional absolute action deadline, in ISO-8601 format. */
+    expiresAt?: string;
     /** Optional standard card accent. Omit it to use the neutral platform presentation. */
     tone?: WebBusinessNotificationTone;
     /** The business fact's occurrence time, displayed in the workbench time zone when supplied. */
@@ -546,6 +550,9 @@ export interface PageDescriptorBase<TPageType extends PageType, TOpenMode extend
     restoreState?: TabRestoreState;
 }
 export interface RoutePageTarget {
+    /** Preserved module-menu presentation defaults for a custom business page. */
+    defaultUiConfigId?: string;
+    defaultQueryTemplateId?: string;
     route?: string;
     routeName?: string;
     pageKey?: string;

package/dist/types/web-contracts/workflow.d.ts

@@ -3,14 +3,16 @@ import type { TextPresentation } from './index';
 export interface WorkflowDefinition {
     id: string;
     version: number;
-    alias: string;
+    alias?: string | null;
+    actionCode?: string | null;
     title?: string;
     definitionStatus: string;
     currentVersionNo?: number;
     approvalEnabled: boolean;
     organizationId?: string;
     matchExpression?: string;
-    matchPriority?: number;
+    sortOrder?: number;
+    tenantId?: string;
     defaultDefinition?: boolean;
 }
 export interface WorkflowVersion {
@@ -151,8 +153,9 @@ export interface WorkflowStatus {
     errorMessage?: string;
     errorMessageText?: TextPresentation;
     definition?: {
+        definitionId?: string;
         definitionTitle?: string;
-        definitionAlias?: string;
+        definitionAlias?: string | null;
     };
 }
 export interface WorkflowRenderBundle {
@@ -290,18 +293,23 @@ export interface WorkflowConfigurationCatalog {
     }[];
 }
 export interface WorkflowDefinitionSelection {
+    actionCode?: string;
     version: number;
     title: string;
     organizationId: string | null;
     matchExpression: string | null;
-    matchPriority: number;
     defaultDefinition: boolean;
 }
-export interface WorkflowDefinitionCreate extends Omit<WorkflowDefinitionSelection, 'version'> {
-    alias: string;
-    approvalEnabled: boolean;
+export type WorkflowDefinitionCreate = Omit<WorkflowDefinitionSelection, 'version' | 'actionCode'> & {
+    alias?: string | null;
     enabled: boolean;
-}
+} & ({
+    approvalEnabled: true;
+    actionCode?: string;
+} | {
+    approvalEnabled: false;
+    actionCode: string;
+});
 export interface WorkflowAdminInstance {
     instanceId: string;
     moduleAlias: string;

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

@@ -1,4 +1,6 @@
-import type { WebBusinessNotificationRecordAction } from '../web-contracts/index';
+import type { WebBusinessNotification, WebBusinessNotificationRecordAction } from '../web-contracts/index';
 import type { HttpClient } from './http';
 /** Calls the standard record action declared by a notification. */
 export declare function invokeBusinessNotificationRecordAction(http: HttpClient, action: WebBusinessNotificationRecordAction): Promise<unknown>;
+/** Invalid supplied deadlines fail closed; an omitted deadline preserves legacy actions. */
+export declare function businessNotificationExpired(notification: Pick<WebBusinessNotification, 'expiresAt'>, now?: number): boolean;

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

@@ -33,3 +33,6 @@ export * from './useBusinessContentGenerationBatch';
 export * from './useBusinessContentReading';
 export * from './businessContentLanguage';
 export * from './recordReadRefreshGuard';
+export * from './recordReadView';
+export * from './useRecordReadSession';
+export * from './recordReadEntry';

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

@@ -0,0 +1,23 @@
+import type { PageDescriptor } from '../web-contracts/index';
+export interface RecordReadEntry {
+    moduleAlias: string;
+    viewCode: string;
+    menuId?: string;
+    /** Presentation/default-query hints only; the server resolves these again from a visible menu. */
+    params: Readonly<Record<string, unknown>>;
+    defaultUiConfigId?: string;
+    defaultQueryTemplateId?: string;
+}
+/**
+ * Resolves a business-owned named read view from the existing workbench descriptor.
+ * This is presentation selection, never authorization. Pass menuId to the ordinary authenticated
+ * transport as X-MuYun-Menu-Id; MenuEntryRequestContext validates the visible menu server-side.
+ * Direct links must explicitly declare their default view or be rejected by omitting it.
+ */
+export declare function resolveRecordReadEntry(options: {
+    moduleAlias: string;
+    viewCodes: readonly string[];
+    page?: PageDescriptor;
+    directViewCode?: string;
+    defaultViewCode?: string;
+}): RecordReadEntry;

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

@@ -0,0 +1,28 @@
+import type { QuerySchema, ResolvedModuleUiDescriptor, WebPageResponse, WebQueryRequest } from '../web-contracts/index';
+export interface RecordReadRequestOptions {
+    signal: AbortSignal;
+    contentLanguage?: string;
+}
+/**
+ * A business-owned, authorized read projection. It declares no write capability and needs no
+ * entity table or ModuleContext. Query merging, stable ordering and pagination belong to the server.
+ */
+export interface RecordReadView<TRecord extends Record<string, unknown> = Record<string, unknown>> {
+    sourceId: string;
+    viewCode: string;
+    /** Change on authentication, tenant or authorization/range changes; this key grants no access. */
+    scopeKey: string;
+    descriptor: ResolvedModuleUiDescriptor;
+    /** Authorized query capabilities; absent for legacy adapters that only support quick search. */
+    querySchema?: QuerySchema;
+    /** Stable within this source, including the origin when multiple sources share record IDs. */
+    recordKey(record: TRecord): string;
+    query(request: WebQueryRequest, options: RecordReadRequestOptions): Promise<WebPageResponse<TRecord>>;
+    /** Reauthorize detail reads on the server. Omit when this projection has no detail surface. */
+    detail?: {
+        load(record: TRecord, options: RecordReadRequestOptions): Promise<Record<string, unknown>>;
+        title(record: TRecord): string;
+    };
+}
+/** User-adjustable query input, never an authorization or mandatory business-scope declaration. */
+export type RecordReadQuery = Omit<WebQueryRequest, 'page' | 'quickSearch' | 'unpaged'>;

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

@@ -0,0 +1,27 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { WebPageResponse } from '../web-contracts/index';
+import type { RecordReadQuery, RecordReadView } from './recordReadView';
+/** One mounted view session; no cross-view or cross-principal cache of authorized results. */
+export declare function useRecordReadSession<TRecord extends Record<string, unknown>>(options: {
+    view: MaybeRefOrGetter<RecordReadView<TRecord>>;
+    query?: MaybeRefOrGetter<RecordReadQuery | undefined>;
+    pageSize?: number;
+    contentLanguage?: MaybeRefOrGetter<string | undefined>;
+}): {
+    result: import("vue").ShallowRef<WebPageResponse<TRecord> | undefined, WebPageResponse<TRecord> | undefined>;
+    loading: import("vue").Ref<boolean, boolean>;
+    error: import("vue").ShallowRef<unknown, unknown>;
+    pageNum: import("vue").Ref<number, number>;
+    pageSize: import("vue").Ref<number, number>;
+    quickSearch: import("vue").Ref<string, string>;
+    selected: import("vue").ShallowRef<TRecord | undefined, TRecord | undefined>;
+    detail: import("vue").ShallowRef<Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+    detailLoading: import("vue").Ref<boolean, boolean>;
+    detailError: import("vue").ShallowRef<unknown, unknown>;
+    refresh: () => Promise<void>;
+    search: (keyword: string) => Promise<void>;
+    goPage: (value: number) => Promise<void>;
+    resizePage: (value: number) => Promise<void>;
+    select: (record: TRecord) => Promise<void>;
+    closeDetail: () => void;
+};

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

@@ -47,6 +47,18 @@ export declare function createWorkflowClient(http: HttpClient): {
 };
 /** Definition commands are scoped to the owning business module. */
 export declare function createWorkflowDefinitionClient(http: HttpClient, moduleAlias: string): {
+    formulaFunctions: () => Promise<{
+        name: string;
+        title: string;
+        description: string;
+        example: string;
+        parameters: {
+            name: string;
+            description: string;
+        }[];
+    }[]>;
+    validateCondition: (expression: string) => Promise<void>;
+    sort: (id: string, targetId: string, position: -1 | 1) => Promise<unknown>;
     catalog: (id: string) => Promise<WorkflowConfigurationCatalog>;
     query: () => Promise<WorkflowDefinition[]>;
     versions: (id: string) => Promise<WorkflowVersion[]>;
@@ -58,7 +70,7 @@ export declare function createWorkflowDefinitionClient(http: HttpClient, moduleA
     saveDesign: (id: string, versionId: string, expectedVersion: number, design: WorkflowDesign) => Promise<WorkflowVersion>;
     validate: (id: string, versionId: string) => Promise<unknown>;
     publish: (id: string, versionId: string, definitionVersion: number, expectedVersion: number) => Promise<WorkflowVersion>;
-    changeStatus: (id: string, action: "disable" | "archive", expectedVersion: number) => Promise<WorkflowDefinition>;
+    changeStatus: (id: string, action: "enable" | "disable" | "archive", expectedVersion: number) => Promise<WorkflowDefinition>;
 };
 /** Management projections and commands keep their separate authorization boundary. */
 export declare function createWorkflowAdminClient(http: HttpClient): {

package/dist/useWorkflowConfigurationContext-B6Wdt26l.js

@@ -0,0 +1,66 @@
+import { E as e, y as t } from "./platform-workbench-D5w7Odpt.js";
+import { Pr as n, Wr as r, Xa as i, Xr as a, _n as o, qr as s, zt as c } from "./platform-components-DlKD3nyL.js";
+import { computed as l, onMounted as u } from "vue";
+//#region src/views/useWorkflowConfigurationContext.ts
+function d(d) {
+	let f = i(), p = s({ moduleAlias: "platform.workflow.definition" }), m = n(p.http, d), h = {
+		loadFunctions: async () => (await m.formulaFunctions()).map((e) => ({
+			name: e.name,
+			title: e.title,
+			description: e.description,
+			example: e.example,
+			signature: `${e.name}(${e.parameters.map((e) => e.name).join(", ")})`
+		})),
+		validate: (e) => m.validateCondition(e)
+	}, g = r({
+		http: p.http,
+		language: f,
+		moduleAlias: d,
+		runtimeAccess: "VIEW"
+	}), _ = t(), v = l(() => _?.value?.tenantId ? r({
+		http: p.http,
+		language: f,
+		moduleAlias: "iam.organization",
+		runtimeAccess: "REFERENCE"
+	}) : void 0);
+	e({
+		moduleAlias: d,
+		predicate: (e) => e.type === "configuration-translations-changed",
+		handler: async () => {
+			try {
+				await g.runtime.refreshTexts?.();
+			} catch (e) {
+				o(e, {
+					source: "workflow-design",
+					phase: "load"
+				});
+			}
+		}
+	});
+	let y = l(() => a(g.runtime)), b = l(() => [...c(y.value?.uiDescriptor)].map(([e, t]) => ({
+		name: e,
+		label: t.label ?? e,
+		valueType: t.valueType,
+		referenceModule: t.reference?.targetModuleAlias
+	})));
+	return u(async () => {
+		try {
+			await g.runtime.ready;
+		} catch (e) {
+			o(e, {
+				source: "workflow-design",
+				phase: "load"
+			});
+		}
+	}), {
+		context: p,
+		client: m,
+		language: f,
+		businessRuntime: y,
+		fields: b,
+		organizationContext: v,
+		conditionTools: h
+	};
+}
+//#endregion
+export { d as t };