@ximatai/muyun-web-app 0.26.17 → 0.26.19

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

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    moduleAlias?: string;
+    moduleTitle?: string;
+    embedded?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,17 @@
+import { type CodeRule, type CodeSource, type CodeTrigger } from './codeConfiguration';
+type __VLS_Props = {
+    sources: CodeSource[];
+    editable: boolean;
+    trigger?: CodeTrigger;
+};
+type __VLS_ModelProps = {
+    'rule': CodeRule;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:rule": (value: CodeRule) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:rule"?: ((value: CodeRule) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,6 +1,7 @@
 type __VLS_Props = {
     moduleAlias: string;
     moduleTitle?: string;
+    definitionId: string;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

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/codeConfiguration.d.ts

@@ -0,0 +1,127 @@
+import { type LanguageContext, type HttpClient } from '../web-core/index';
+import type { TextPresentation } from '../web-contracts/index';
+export type CodeMode = 'AUTO' | 'MANUAL' | 'AUTO_WITH_MANUAL_EDIT';
+export type CodeRole = 'PRIMARY' | 'NORMAL';
+export type CodeTrigger = 'SAVE' | 'EXPLICIT';
+export declare const codeSegmentTypes: readonly ["CONSTANT", "FIELD_VALUE", "CONTEXT_VAR", "SYSTEM_TIME", "SEQUENCE", "VALUE_MAPPING", "FORMULA"];
+export type CodeSegmentType = (typeof codeSegmentTypes)[number];
+export interface CodeSource {
+    fieldName: string;
+    title: string;
+    titleText?: TextPresentation;
+    ownerTitle?: string | null;
+    type: string;
+    length?: number | null;
+}
+export declare function codeSourceTitle(source: CodeSource, language?: LanguageContext): string;
+export interface CodeField {
+    fieldName: string;
+    title: string;
+    length?: number | null;
+    metadataFieldId?: string | null;
+    bindingId?: string | null;
+    bindingVersion?: number | null;
+    role?: CodeRole | null;
+    trigger?: CodeTrigger | null;
+}
+export interface CodeTarget {
+    moduleAlias: string;
+    moduleTitle?: string;
+    moduleTitleText?: TextPresentation;
+    entityAlias: string;
+    title: string;
+    source: 'STATIC' | 'DYNAMIC';
+    relationId?: string | null;
+    fields: CodeField[];
+    sources: CodeSource[];
+}
+export interface CodeConfigurationAvailability {
+    configurable: boolean;
+    reason?: 'no-model' | 'no-fields' | 'not-declared' | 'unavailable' | null;
+}
+export declare function readCodeConfigurationAvailability(http: HttpClient, moduleAlias: string): Promise<CodeConfigurationAvailability>;
+export interface CodeMapping {
+    id?: string;
+    version?: number;
+    sourceValue: string;
+    targetValue: string;
+    defaultMapping: boolean;
+    enabled: boolean;
+}
+export interface CodeSegment {
+    id?: string;
+    version?: number;
+    segmentType: CodeSegmentType;
+    sourceRef?: string | null;
+    fixedValue?: string | null;
+    formulaExpr?: string | null;
+    dateFormat?: string | null;
+    length?: number | null;
+    padMode?: string;
+    padChar?: string | null;
+    separator?: string | null;
+    sequenceBasis?: boolean;
+    nullPolicy?: string;
+    truncatePolicy?: string;
+    sortOrder: number;
+    mappings: CodeMapping[];
+}
+export interface CodeSequencePolicy {
+    id?: string;
+    version?: number;
+    startValue: number | null;
+    stepValue: number | null;
+    sequenceLength: number | null;
+    maxValue?: number | null;
+    resetPolicy: string;
+    overflowPolicy: string;
+}
+export interface CodeRule {
+    id?: string;
+    version?: number;
+    title: string;
+    moduleAlias: string;
+    entityAlias: string;
+    fieldName: string;
+    moduleMetadataFieldId?: string | null;
+    metadataFieldId?: string | null;
+    fieldRole?: CodeRole;
+    fieldTrigger?: CodeTrigger;
+    mode: CodeMode;
+    enabled: boolean;
+    linkedUpdate: boolean;
+    allowRecycle: boolean;
+    orgScopeType: 'GLOBAL' | 'ORG';
+    orgScopeId?: string | null;
+    globalDefault: boolean;
+    effectiveFrom?: string | null;
+    effectiveTo?: string | null;
+    segments: CodeSegment[];
+    sequencePolicy: CodeSequencePolicy | null;
+}
+export interface CodePreview {
+    value: string;
+    segments: Array<{
+        value: string;
+        segmentType: CodeSegmentType;
+    }>;
+}
+export declare function newCodeSegment(type?: CodeSegmentType): CodeSegment;
+export declare function newCodeSequence(): CodeSequencePolicy;
+export declare function newCodeRule(target: CodeTarget, field: CodeField): CodeRule;
+/** Match the rule's supported dependency kinds without parsing formula expressions in the browser. */
+export declare function codeRuleSupportsRenumbering(rule: CodeRule): boolean;
+export declare function prepareCodeRule(rule: CodeRule, language?: LanguageContext): CodeRule;
+/** Direct inputs only; formula samples can be added from the source catalog without parsing formulas in the browser. */
+export declare function codeTrialSources(target: CodeTarget, rule?: CodeRule): CodeSource[];
+/** Source types are shared by static Java declarations and dynamic column metadata. */
+export declare function codeTrialSourceKind(source: CodeSource): 'boolean' | 'number' | 'date' | 'datetime' | 'text';
+/** No formula evaluation in the browser; only coerce explicitly entered trial values. */
+export declare function codeTrialContext(sources: readonly CodeSource[], values: Record<string, string>, language?: LanguageContext): Record<string, unknown>;
+export declare function createCodeConfigurationClient(http: HttpClient, language?: LanguageContext): {
+    targets: (moduleAlias?: string) => Promise<CodeTarget[]>;
+    rules: (target: CodeTarget) => Promise<CodeRule[]>;
+    bind(target: CodeTarget, field: CodeField, role: CodeRole | null, trigger: CodeTrigger): Promise<CodeTarget>;
+    save(rule: CodeRule): Promise<CodeRule>;
+    preview(rule: CodeRule, context: Record<string, unknown>, sequenceValue: number, signal?: AbortSignal): Promise<CodePreview>;
+};

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

@@ -0,0 +1,5 @@
+export interface CodeConfigurationWorkspaceInput {
+    moduleAlias?: string;
+    moduleTitle?: string;
+}
+export declare const codeConfigurationWorkspaceView: import("../platform-workbench/workspaceViewContract.ts").WorkspaceViewDefinition<CodeConfigurationWorkspaceInput>;

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

@@ -1,4 +1,4 @@
-export declare const moduleGovernanceTabs: readonly ["overview", "metadata", "actions", "rules", "ui", "menu", "preview"];
+export declare const moduleGovernanceTabs: readonly ["overview", "metadata", "actions", "rules", "codes", "ui", "menu", "preview"];
 export type ModuleGovernanceTab = (typeof moduleGovernanceTabs)[number];
 export interface ModuleGovernanceWorkspaceViewInput {
     moduleAlias: string;

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/UiDatePicker.vue.d.ts

@@ -0,0 +1,33 @@
+import { type UiDatePickerMode, type UiDatePickerPrecision } from '../datePickerValue';
+type __VLS_Props = {
+    value?: string | null;
+    mode?: UiDatePickerMode;
+    precision?: UiDatePickerPrecision;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    allowClear?: boolean;
+    autofocus?: boolean;
+    required?: boolean;
+    id?: string;
+    ariaLabel?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    focus: (event: FocusEvent) => any;
+    "update:value": (value: string) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    mode: UiDatePickerMode;
+    allowClear: boolean;
+    invalid: boolean;
+    precision: UiDatePickerPrecision;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    label: string;
+};
+declare var __VLS_17: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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' | '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/UiPopover.vue.d.ts

@@ -2,13 +2,21 @@ type __VLS_Props = {
     trigger?: 'click' | 'hover' | 'focus';
     placement?: 'top' | 'topLeft' | 'topRight' | 'right' | 'rightTop' | 'rightBottom' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom';
 };
-declare var __VLS_8: {}, __VLS_11: {};
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_10: {}, __VLS_13: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_10) => any;
 } & {
-    content?: (props: typeof __VLS_11) => any;
+    content?: (props: typeof __VLS_13) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean | undefined) => any) | undefined;
+}>, {
     trigger: "click" | "hover" | "focus";
     placement: "top" | "topLeft" | "topRight" | "right" | "rightTop" | "rightBottom" | "bottom" | "bottomLeft" | "bottomRight" | "left" | "leftTop" | "leftBottom";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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;