@ximatai/muyun-web-app 0.26.15 → 0.26.16

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

@@ -1,8 +1,22 @@
+import type { TextReference } from '../web-contracts/index';
+import { type LanguageContext } from './language';
+export interface OperationErrorMessage {
+    readonly message: string;
+    readonly source: TextReference;
+    readonly args: Readonly<Record<string, string | number | boolean | null>>;
+}
+/** Explicit CODE declaration; parameters are frozen display facts, never inferred from prose. */
+export declare function codeOperationErrorMessage(language: LanguageContext, key: string, original: string, args?: Record<string, unknown>): OperationErrorMessage;
 /** A rejected editor operation with safe, bounded feedback for callers. */
 export declare class OperationUsageError extends Error {
     readonly code: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED';
-    constructor(message: string, code?: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED');
+    readonly textMessage?: OperationErrorMessage;
+    constructor(message: string | OperationErrorMessage, code?: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED');
 }
+/** Resolves owned presentation facts without replaying validation or changing the error code. */
+export declare function resolveOperationErrorMessage(error: Error & {
+    readonly textMessage?: OperationErrorMessage;
+}, language?: LanguageContext): string;
 /** A staged draft was rejected before publication; no draft or display state was changed. */
 export declare class DraftUpdateRejectedError extends OperationUsageError {
     constructor(failure: OperationUsageError);

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

@@ -0,0 +1,16 @@
+import type { TextReference, TextPresentation, TextPresentationDocument } from '../web-contracts/index';
+import type { LanguageContext, TextResolution } from './language';
+/** Snapshot a producer's concrete CODE original; arguments format deployed resources, never business values in the fallback. */
+export declare function createCodeTextPresentation(key: string, originalText: string, context: LanguageContext, args?: Record<string, unknown>): TextPresentation;
+export declare function resolvePresentationText(text: TextPresentation, context: LanguageContext): TextResolution;
+/** Typed labels outside module descriptors use the same immutable presentation resource. */
+export declare function presentationLabel(original: string, text: TextPresentation | undefined, context: LanguageContext): string;
+/** Restore source facts for execution/dirty checks; projections remain separate and disposable. */
+export declare function originalPresentation<T extends TextPresentationDocument>(document: T): T;
+export declare function translatedPresentation<T extends TextPresentationDocument>(document: T, context: LanguageContext): T;
+export declare function isTextReference(value: unknown): value is TextReference;
+/** A label is valid only while its explicitly declared source still matches the raw record value. */
+export declare function recordPresentationText(record: object | undefined, field: string): TextPresentation | undefined;
+export declare function recordPresentationLabel(record: object, field: string, context: LanguageContext): string | undefined;
+/** Removes only the record's read metadata; arbitrary nested JSON business values are preserved. */
+export declare function withoutRecordPresentation<T>(record: T): T;

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

@@ -0,0 +1,2 @@
+/** UTF-8 digest shared with server source versions; works without WebCrypto on LAN HTTP. */
+export declare function sha256Hex(text: string): string;

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

@@ -0,0 +1,70 @@
+import type { WorkflowDefinition, WorkflowVersion, WorkflowTaskPreparation, WorkflowConfigurationCatalog, WorkflowDefinitionSelection, WorkflowDefinitionCreate, WorkflowAdminInstance, WorkflowAdminTask, WorkflowAdminInstanceQuery, WorkflowAdminHistoryQuery, WorkflowAction, WorkflowAddSignExplanation, WorkflowBranch, WorkflowDesign, WorkflowEvent, WorkflowHistoryInstance, WorkflowRenderBundle, WorkflowStatus, WorkflowTask, WorkflowWorkbenchCard, WorkflowWorkbenchFilters, WebPageResponse } from '../web-contracts/index';
+import type { HttpClient } from './http';
+import type { ModuleContext } from './module/moduleContext';
+/** Workflow mutations change ordinary record rights as well as the record itself. */
+export declare function refreshWorkflowRecordActions(context: Pick<ModuleContext<unknown>, 'invalidateRecordActions' | 'recordActions'>, recordId: string): Promise<void>;
+/** All operation rights remain server decisions. The client only carries typed intent. */
+export declare function createWorkflowClient(http: HttpClient): {
+    history: (moduleAlias: string, recordId: string) => Promise<WorkflowHistoryInstance[]>;
+    historyBundle: (id: string) => Promise<WorkflowRenderBundle>;
+    historyTasks: (id: string) => Promise<WorkflowTask[]>;
+    historyEvents: (id: string) => Promise<WorkflowEvent[]>;
+    status: (alias: string, id: string) => Promise<WorkflowStatus>;
+    submitBranches: (alias: string, id: string, payload?: unknown) => Promise<WorkflowBranch[]>;
+    executeGuide: (id: string, guideKey: string, payload: unknown) => Promise<unknown>;
+    preview: (alias: string, id: string, payload?: unknown) => Promise<{
+        semanticJson: string | undefined;
+        layoutJson: string | undefined;
+        definition?: WorkflowStatus["definition"];
+        tasks: WorkflowTask[];
+        taskViews?: WorkflowTask[];
+        instance: import("../web-contracts/index").WorkflowInstance;
+        nodes: import("../web-contracts/index").WorkflowNode[];
+        routes: import("../web-contracts/index").WorkflowRoute[];
+    }>;
+    submit: (alias: string, id: string, payload?: unknown) => Promise<unknown>;
+    bundle: (id: string) => Promise<WorkflowRenderBundle>;
+    addSignExplanations: (id: string) => Promise<WorkflowAddSignExplanation[]>;
+    actions: (id: string) => Promise<WorkflowAction[]>;
+    tasks: (id: string) => Promise<WorkflowTask[]>;
+    events: (id: string) => Promise<WorkflowEvent[]>;
+    branches: (id: string) => Promise<WorkflowBranch[]>;
+    branchChoices: (id: string, payload: unknown) => Promise<WorkflowBranch[]>;
+    taskAction: (id: string, code: string, payload: unknown) => Promise<unknown>;
+    instanceAction: (id: string, code: string, payload: unknown) => Promise<unknown>;
+    workbench: (board: string, pageNumber?: number, moduleAlias?: string) => Promise<WorkflowWorkbenchCard[]>;
+    workbenchModules: () => Promise<import("../web-contracts/index").ModuleTitleCatalog>;
+    workbenchPage: (board: string, pageNum?: number, filters?: WorkflowWorkbenchFilters, keyword?: string, pageSize?: number) => Promise<WebPageResponse<WorkflowWorkbenchCard> & {
+        navigation?: {
+            modules: Record<string, string>;
+            moduleTitles?: import("../web-contracts/index").ModuleTitleCatalog;
+        };
+    }>;
+    taskViews: (id: string) => Promise<WorkflowTask[]>;
+    eventViews: (id: string) => Promise<WorkflowEvent[]>;
+    prepareTask: (id: string) => Promise<WorkflowTaskPreparation>;
+};
+/** Definition commands are scoped to the owning business module. */
+export declare function createWorkflowDefinitionClient(http: HttpClient, moduleAlias: string): {
+    catalog: (id: string) => Promise<WorkflowConfigurationCatalog>;
+    query: () => Promise<WorkflowDefinition[]>;
+    versions: (id: string) => Promise<WorkflowVersion[]>;
+    create: (payload: WorkflowDefinitionCreate) => Promise<WorkflowDefinition>;
+    view: (id: string) => Promise<WorkflowDefinition>;
+    upgrade: (id: string) => Promise<WorkflowVersion>;
+    saveSelection: (id: string, payload: WorkflowDefinitionSelection) => Promise<WorkflowDefinition>;
+    design: (id: string, versionId: string) => Promise<WorkflowDesign>;
+    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>;
+};
+/** Management projections and commands keep their separate authorization boundary. */
+export declare function createWorkflowAdminClient(http: HttpClient): {
+    instances: (query: WorkflowAdminInstanceQuery) => Promise<WorkflowAdminInstance[]>;
+    history: (query: WorkflowAdminHistoryQuery) => Promise<WorkflowHistoryInstance[]>;
+    bundle: (id: string, history: boolean) => Promise<WorkflowRenderBundle>;
+    events: (id: string, history: boolean) => Promise<WorkflowEvent[]>;
+    activeTasks: (id: string) => Promise<WorkflowAdminTask[]>;
+    execute: (instanceId: string, code: string, reason: string, taskId?: string) => Promise<unknown>;
+};

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

@@ -0,0 +1,6 @@
+/** A UI host can protect drafts without coupling reusable record panels to the workbench implementation. */
+export interface WorkspaceUnsavedStateRegistrar {
+    registerUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean, sourceTitle?: () => string): () => void;
+}
+export declare function provideWorkspaceUnsavedStateRegistrar(registrar: WorkspaceUnsavedStateRegistrar | undefined): void;
+export declare function useWorkspaceViewUnsavedState(source: string | (() => string), isDirty: () => boolean, isBusy?: () => boolean): void;