@ximatai/muyun-web-app 0.26.13 → 0.26.15

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

@@ -2,6 +2,9 @@ import { type CompositionSkeleton, type PageCompositionActionPlacement } from '.
 import { type PageComposerFormItem, type PageComposerField, type PageComposerGroup, type PageComposerRelation, type PageQuerySummary } from './pageCompositionDraftState';
 import { type PageCompositionDragPayload } from './pageCompositionDragPayload';
 type __VLS_Props = {
+    layoutTitle?: string;
+    hideList?: boolean;
+    separateDetail?: boolean;
     skeleton?: CompositionSkeleton;
     explorerTitle?: string;
     searchableFieldIds?: string[];
@@ -32,7 +35,7 @@ type __VLS_Props = {
     selectedKey?: string;
     disabled?: boolean;
 };
-type ComposerNodeAction = 'configure' | 'remove' | 'add-group' | 'toggle-visibility';
+type ComposerNodeAction = 'configure' | 'remove' | 'add-group' | 'toggle-visibility' | 'split-layout' | 'merge-layout';
 export type ComposerDropTarget = ({
     kind: 'explorer-title' | 'explorer-secondary' | 'quick-search';
 } | {
@@ -54,13 +57,6 @@ export type ComposerDropTarget = ({
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (key: string) => any;
     "double-click": (key: string) => any;
-    "action-drop": (source: {
-        actionCode: string;
-        sourceAnchor?: PageCompositionActionPlacement["anchor"];
-    }, target: {
-        anchor: PageCompositionActionPlacement["anchor"];
-        index: number;
-    }) => any;
     "node-action": (action: ComposerNodeAction, key: string) => any;
     "reorder-list-field": (fieldId: string, targetIndex: number) => any;
     "reorder-form-field": (fieldId: string, targetIndex: number) => any;
@@ -72,16 +68,16 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "reorder-relation-field": (relationId: string, fieldId: string, targetIndex: number) => any;
     "reorder-query-summary": (summaryKey: string, targetIndex: number) => any;
     "source-drop": (target: ComposerDropTarget, payload: PageCompositionDragPayload) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((key: string) => any) | undefined;
-    "onDouble-click"?: ((key: string) => any) | undefined;
-    "onAction-drop"?: ((source: {
+    "action-drop": (source: {
         actionCode: string;
         sourceAnchor?: PageCompositionActionPlacement["anchor"];
     }, target: {
         anchor: PageCompositionActionPlacement["anchor"];
         index: number;
-    }) => any) | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((key: string) => any) | undefined;
+    "onDouble-click"?: ((key: string) => any) | undefined;
     "onNode-action"?: ((action: ComposerNodeAction, key: string) => any) | undefined;
     "onReorder-list-field"?: ((fieldId: string, targetIndex: number) => any) | undefined;
     "onReorder-form-field"?: ((fieldId: string, targetIndex: number) => any) | undefined;
@@ -93,10 +89,20 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onReorder-relation-field"?: ((relationId: string, fieldId: string, targetIndex: number) => any) | undefined;
     "onReorder-query-summary"?: ((summaryKey: string, targetIndex: number) => any) | undefined;
     "onSource-drop"?: ((target: ComposerDropTarget, payload: PageCompositionDragPayload) => any) | undefined;
+    "onAction-drop"?: ((source: {
+        actionCode: string;
+        sourceAnchor?: PageCompositionActionPlacement["anchor"];
+    }, target: {
+        anchor: PageCompositionActionPlacement["anchor"];
+        index: number;
+    }) => any) | undefined;
 }>, {
     disabled: boolean;
     selectedKey: string;
     editorMode: "fields" | "actions";
+    layoutTitle: string;
+    hideList: boolean;
+    separateDetail: boolean;
     formOrder: PageComposerFormItem[];
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

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

@@ -21,6 +21,9 @@ export interface BusinessLogEventView {
     operatorIdentity?: BusinessLogOperatorIdentity;
     moduleAlias?: string;
     actionCode?: string;
+    entityAlias?: string;
+    recordId?: string;
+    mutationSource?: string;
     outcome?: string;
     /** The authentication account, independent from the event's authenticated operator identity. */
     loginAccount?: string;

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

@@ -0,0 +1,25 @@
+import type { HttpClient } from '../web-core/index';
+export type BusinessLogEventType = 'LOGIN' | 'ACTION' | 'REQUEST_ERROR' | 'PAGE_ACCESS';
+export interface BusinessLogRetentionPolicy {
+    eventType: BusinessLogEventType;
+    automaticCleanupEnabled: boolean;
+    retentionDays: number;
+    version: number;
+    updatedAt?: string;
+    updatedBy?: string;
+}
+export interface BusinessLogRetentionRunResult {
+    eventType: BusinessLogEventType;
+    retentionDays: number;
+    result: {
+        occurredBefore: string;
+        deletedCount: number;
+        executedBatches: number;
+        status: 'COMPLETE' | 'BATCH_LIMIT_REACHED' | 'ALREADY_RUNNING';
+    };
+}
+export declare function createBusinessLogRetentionClient(http: HttpClient): {
+    policies(): Promise<BusinessLogRetentionPolicy[]>;
+    update(policy: BusinessLogRetentionPolicy): Promise<BusinessLogRetentionPolicy>;
+    purge(eventType: BusinessLogEventType, retentionDays: number): Promise<BusinessLogRetentionRunResult>;
+};

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

@@ -0,0 +1,7 @@
+import { type AssistantCapability, type AssistantSurface, type AssistantTurnRequester } from '../web-core/index';
+import type { BusinessRuleProposal } from './businessRuleGovernance';
+import type { BusinessRuleTrialInput, BusinessRuleEditor as BusinessRuleAssistantAdapter } from './businessRuleEditor';
+export type { BusinessRuleTrialInput, BusinessRuleEditor as BusinessRuleAssistantAdapter, } from './businessRuleEditor';
+export declare function parseBusinessRuleProposal(input: unknown): BusinessRuleProposal;
+export declare function parseBusinessRuleTrial(input: unknown): BusinessRuleTrialInput;
+export declare function createBusinessRuleAssistantSurface(adapter: BusinessRuleAssistantAdapter, requestTurn: AssistantTurnRequester, contributed?: () => AssistantCapability[]): AssistantSurface;

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

@@ -0,0 +1,22 @@
+import type { OperationProposal } from '../web-core/index';
+import type { BusinessRuleProposal, BusinessRulePreview, BusinessRuleTrialResult } from './businessRuleGovernance';
+export interface BusinessRuleTrialInput {
+    sampleValues: Record<string, unknown>;
+    sampleChildren: Record<string, Record<string, unknown>[]>;
+}
+export interface BusinessRuleEditor {
+    summary(): {
+        moduleAlias: string;
+        title?: string;
+        editable: boolean;
+        factsAvailable?: boolean;
+        hasUnappliedChanges?: boolean;
+        submissionStatus?: 'idle' | 'unknown' | 'current-read';
+    };
+    readCurrent?(signal?: AbortSignal, commit?: (accept: () => void) => void): Promise<void>;
+    catalog(section: string): unknown[];
+    revise(rule: BusinessRuleProposal): void;
+    preview(signal: AbortSignal): Promise<BusinessRulePreview>;
+    trial(input: BusinessRuleTrialInput, signal: AbortSignal): Promise<BusinessRuleTrialResult>;
+    prepareConfirmation(signal: AbortSignal): Promise<OperationProposal>;
+}

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

@@ -1,4 +1,6 @@
 export type BusinessRuleKind = 'CALCULATION' | 'VALIDATION' | 'UI_CONTROL';
+/** Save-validation behavior shared by manual editing and assistant rule inputs. */
+export declare const businessRuleValidationHelp = "\u516C\u5F0F\u4E3A\u771F\u65F6\u5141\u8BB8\u4FDD\u5B58\uFF0C\u4E3A\u5047\u65F6\u963B\u6B62\u4FDD\u5B58\u5E76\u663E\u793A\u5931\u8D25\u63D0\u793A\uFF1B\u5F53\u524D\u7F16\u8F91\u5668\u4E0D\u652F\u6301\u53EA\u63D0\u9192\u800C\u4ECD\u5141\u8BB8\u4FDD\u5B58\u7684\u89C4\u5219\u3002";
 export interface BusinessRuleEditableField {
     fieldName: string;
     title: string;
@@ -70,7 +72,7 @@ export declare function formulaFieldUnusableReason(field: BusinessRuleReferenceF
  * cannot consume it. The server remains authoritative; this only keeps authoring feedback close
  * to the attempted insertion.
  */
-export declare function aggregateFieldInsertionReason(field: BusinessRuleReferenceField, expression: string, selectionStart: number): string | undefined;
+export declare function aggregateFieldInsertionReason(field: BusinessRuleReferenceField, expression: string, selectionStart: number, childTargets?: readonly string[]): string | undefined;
 export interface UiControlTarget {
     elementKey: string;
     hide: boolean;
@@ -122,6 +124,8 @@ export interface BusinessRuleSnapshot {
     }>;
     /** Direct child fields, which may only appear within a child aggregation function. */
     aggregateFields?: BusinessRuleEditableField[];
+    /** Writable direct-child targets; never reference target fields. */
+    childFields?: BusinessRuleEditableField[];
     /** Additive portable function directory emitted by the server. */
     functions?: BusinessRuleFormulaCatalogEntry[];
     rules: BusinessRuleSnapshotRule[];
@@ -152,8 +156,10 @@ export interface BusinessRuleTrialResult {
     preview: BusinessRulePreview;
     values: Record<string, unknown>;
     changedFields: string[];
+    children?: Record<string, Record<string, unknown>[]>;
     errors: BusinessRuleIssue[];
 }
+export declare function businessRuleTrialValue(result: Pick<BusinessRuleTrialResult, 'values' | 'children'>, field: string): unknown;
 export interface BusinessRuleApplyResult {
     snapshot: BusinessRuleSnapshot;
     preview: BusinessRulePreview;

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

@@ -0,0 +1,63 @@
+import { OperationUsageError, type HttpClient } from '../web-core/index';
+import { type BusinessRuleSnapshot, type UiControlSnapshot, type BusinessRuleProposal, type BusinessRuleTrialResult, type BusinessRuleIssue } from './businessRuleGovernance';
+import type { BusinessRuleEditor, BusinessRuleTrialInput } from './businessRuleEditor';
+export declare class BusinessRulePrecheckError extends OperationUsageError {
+    readonly issues: BusinessRuleIssue[];
+    constructor(issues: BusinessRuleIssue[]);
+}
+/** One in-memory candidate shared by manual editing and conversation; server baselines remain authoritative. */
+export declare function createBusinessRuleSession(http: HttpClient, moduleAlias: string, ownerValid?: () => boolean, confirmationScope?: () => boolean): {
+    moduleAlias: string;
+    dispose(): void;
+    invalidateConfirmations: () => number;
+    snapshot: import("vue").Ref<BusinessRuleSnapshot | undefined, BusinessRuleSnapshot | undefined>;
+    ready: import("vue").ComputedRef<boolean>;
+    ui: import("vue").Ref<UiControlSnapshot | undefined, UiControlSnapshot | undefined>;
+    rules: import("vue").Ref<{
+        formKey?: string | undefined;
+        targets?: {
+            elementKey: string;
+            hide: boolean;
+            readOnly: boolean;
+        }[] | undefined;
+        code: string;
+        kind: import("./businessRuleGovernance").BusinessRuleKind;
+        targetField?: string | undefined;
+        expression: string;
+        enabled: boolean;
+        messageTemplate?: string | undefined;
+    }[], BusinessRuleProposal[] | {
+        formKey?: string | undefined;
+        targets?: {
+            elementKey: string;
+            hide: boolean;
+            readOnly: boolean;
+        }[] | undefined;
+        code: string;
+        kind: import("./businessRuleGovernance").BusinessRuleKind;
+        targetField?: string | undefined;
+        expression: string;
+        enabled: boolean;
+        messageTemplate?: string | undefined;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    loadFailed: import("vue").Ref<boolean, boolean>;
+    committedNeedsReload: import("vue").Ref<boolean, boolean>;
+    submissionStatus: import("vue").Ref<"unknown" | "idle" | "current-read", "unknown" | "idle" | "current-read">;
+    applying: import("vue").Ref<boolean, boolean>;
+    tenantId: import("vue").Ref<string, string>;
+    revision: import("vue").Ref<number, number>;
+    dirty: import("vue").ComputedRef<boolean>;
+    editing: import("vue").Ref<boolean, boolean>;
+    adapter: BusinessRuleEditor;
+    load: (force?: boolean, commit?: (accept: () => void) => void) => Promise<void>;
+    replace: (next: BusinessRuleProposal[]) => void;
+    discard: () => void;
+    apply: (stillCurrent?: () => boolean) => Promise<{
+        synchronized: boolean;
+    } | undefined>;
+    readCurrent: (signal?: AbortSignal, commit?: (accept: () => void) => void) => Promise<void>;
+    trial: (input: BusinessRuleTrialInput, signal?: AbortSignal) => Promise<BusinessRuleTrialResult>;
+    setEditing(owner: symbol, value: boolean): void;
+};
+export type BusinessRuleSession = ReturnType<typeof createBusinessRuleSession>;

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

@@ -0,0 +1,144 @@
+import { type AssistantInvocationToken, type AssistantCapability, type AssistantConfigurationEditor, type HttpClient } from '../web-core/index';
+import { type BusinessRuleSession } from './businessRuleSession';
+export declare function createBusinessRuleWorkspace(http: HttpClient, identity: () => string, enabled: () => boolean, openRules?: (moduleAlias: string) => void, onFocus?: () => void): {
+    session: (moduleAlias: string) => {
+        moduleAlias: string;
+        dispose(): void;
+        invalidateConfirmations: () => number;
+        snapshot: import("vue").Ref<import("./businessRuleGovernance").BusinessRuleSnapshot | undefined, import("./businessRuleGovernance").BusinessRuleSnapshot | undefined>;
+        ready: import("vue").ComputedRef<boolean>;
+        ui: import("vue").Ref<import("./businessRuleGovernance").UiControlSnapshot | undefined, import("./businessRuleGovernance").UiControlSnapshot | undefined>;
+        rules: import("vue").Ref<{
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[], import("./businessRuleGovernance").BusinessRuleProposal[] | {
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[]>;
+        loading: import("vue").Ref<boolean, boolean>;
+        loadFailed: import("vue").Ref<boolean, boolean>;
+        committedNeedsReload: import("vue").Ref<boolean, boolean>;
+        submissionStatus: import("vue").Ref<"unknown" | "idle" | "current-read", "unknown" | "idle" | "current-read">;
+        applying: import("vue").Ref<boolean, boolean>;
+        tenantId: import("vue").Ref<string, string>;
+        revision: import("vue").Ref<number, number>;
+        dirty: import("vue").ComputedRef<boolean>;
+        editing: import("vue").Ref<boolean, boolean>;
+        adapter: import("./businessRuleEditor").BusinessRuleEditor;
+        load: (force?: boolean, commit?: (accept: () => void) => void) => Promise<void>;
+        replace: (next: import("./businessRuleGovernance").BusinessRuleProposal[]) => void;
+        discard: () => void;
+        apply: (stillCurrent?: () => boolean) => Promise<{
+            synchronized: boolean;
+        } | undefined>;
+        readCurrent: (signal?: AbortSignal, commit?: (accept: () => void) => void) => Promise<void>;
+        trial: (input: import("./businessRuleEditor").BusinessRuleTrialInput, signal?: AbortSignal) => Promise<import("./businessRuleGovernance").BusinessRuleTrialResult>;
+        setEditing(owner: symbol, value: boolean): void;
+    };
+    focus: (value: BusinessRuleSession) => void;
+    dispose(): void;
+    showEditor(value: BusinessRuleSession): void;
+    hideEditor(value: BusinessRuleSession): void;
+    editor(): AssistantConfigurationEditor | undefined;
+    clearFocus(): void;
+    current(): {
+        revision: string;
+        facts: {
+            ruleConfiguration: import("../web-contracts").AssistantSurfaceContext | undefined;
+            draftLifetime: string;
+        };
+    };
+    capabilities(settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+};
+export type BusinessRuleWorkspace = ReturnType<typeof createBusinessRuleWorkspace>;
+export declare function provideBusinessRuleWorkspace(workspace: BusinessRuleWorkspace): void;
+export declare function useBusinessRuleWorkspace(): {
+    session: (moduleAlias: string) => {
+        moduleAlias: string;
+        dispose(): void;
+        invalidateConfirmations: () => number;
+        snapshot: import("vue").Ref<import("./businessRuleGovernance").BusinessRuleSnapshot | undefined, import("./businessRuleGovernance").BusinessRuleSnapshot | undefined>;
+        ready: import("vue").ComputedRef<boolean>;
+        ui: import("vue").Ref<import("./businessRuleGovernance").UiControlSnapshot | undefined, import("./businessRuleGovernance").UiControlSnapshot | undefined>;
+        rules: import("vue").Ref<{
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[], import("./businessRuleGovernance").BusinessRuleProposal[] | {
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[]>;
+        loading: import("vue").Ref<boolean, boolean>;
+        loadFailed: import("vue").Ref<boolean, boolean>;
+        committedNeedsReload: import("vue").Ref<boolean, boolean>;
+        submissionStatus: import("vue").Ref<"unknown" | "idle" | "current-read", "unknown" | "idle" | "current-read">;
+        applying: import("vue").Ref<boolean, boolean>;
+        tenantId: import("vue").Ref<string, string>;
+        revision: import("vue").Ref<number, number>;
+        dirty: import("vue").ComputedRef<boolean>;
+        editing: import("vue").Ref<boolean, boolean>;
+        adapter: import("./businessRuleEditor").BusinessRuleEditor;
+        load: (force?: boolean, commit?: (accept: () => void) => void) => Promise<void>;
+        replace: (next: import("./businessRuleGovernance").BusinessRuleProposal[]) => void;
+        discard: () => void;
+        apply: (stillCurrent?: () => boolean) => Promise<{
+            synchronized: boolean;
+        } | undefined>;
+        readCurrent: (signal?: AbortSignal, commit?: (accept: () => void) => void) => Promise<void>;
+        trial: (input: import("./businessRuleEditor").BusinessRuleTrialInput, signal?: AbortSignal) => Promise<import("./businessRuleGovernance").BusinessRuleTrialResult>;
+        setEditing(owner: symbol, value: boolean): void;
+    };
+    focus: (value: BusinessRuleSession) => void;
+    dispose(): void;
+    showEditor(value: BusinessRuleSession): void;
+    hideEditor(value: BusinessRuleSession): void;
+    editor(): AssistantConfigurationEditor | undefined;
+    clearFocus(): void;
+    current(): {
+        revision: string;
+        facts: {
+            ruleConfiguration: import("../web-contracts").AssistantSurfaceContext | undefined;
+            draftLifetime: string;
+        };
+    };
+    capabilities(settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+} | undefined;

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

@@ -0,0 +1,2 @@
+/** Lazy page loading may finish after the router commits; resume only once the shared editor is mounted. */
+export declare function waitForConfigurationEditor(visible: () => boolean, signal?: AbortSignal): Promise<void>;

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

@@ -0,0 +1,10 @@
+import { type HttpClient } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+export declare class MetadataChangeSetPrecheckError extends Error {
+}
+/** Both page and conversation confirm the same immutable, server-validated change set. */
+export declare function prepareMetadataChangeSetSubmission(http: HttpClient, moduleAlias: string, candidate: MetadataModelChangeSetProposal, isCurrent: () => boolean, signal?: AbortSignal, fieldSpecTitles?: Readonly<Record<string, string>>, capabilityTitles?: Readonly<Record<string, string>>): Promise<{
+    lines: string[];
+    details: string[];
+    apply(): Promise<void>;
+}>;