@ximatai/muyun-web-app 0.26.8 → 0.26.10

package/dist/types/dynamic-page-runtime/PageNavigatorExplorer.vue.d.ts

@@ -12,24 +12,36 @@ type __VLS_Props = {
     reloadKey: number;
     keyword: string;
     externalQueryValues?: Record<string, unknown>;
-    actionsOf?: () => RecordInlineAction[];
+    navigatorHostModuleAlias: string;
+    /** Whether this navigator's upstream selection scope is available. */
+    ready?: boolean;
+    /** The navigator's declared upstream query scope is not settled yet. */
+    createDisabled?: boolean;
+    createDisabledReason?: string;
+    /** Human-readable context supplied by an upstream navigator selection. */
+    scopeSubtitle?: string;
+    actionsOf?: (record: {
+        id?: string;
+    }) => RecordInlineAction[];
 };
-declare var __VLS_38: {};
+declare var __VLS_45: {};
 type __VLS_Slots = {} & {
-    editor?: (props: typeof __VLS_38) => any;
+    editor?: (props: typeof __VLS_45) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    select: (record: QueryListRecord) => any;
     action: (action: RecordInlineAction, record: QueryListRecord) => any;
+    select: (record: QueryListRecord) => any;
     create: () => any;
     refresh: () => any;
+    deselect: () => any;
     loaded: (records: QueryListRecord[]) => any;
     "update:keyword": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((record: QueryListRecord) => any) | undefined;
     onAction?: ((action: RecordInlineAction, record: QueryListRecord) => any) | undefined;
+    onSelect?: ((record: QueryListRecord) => any) | undefined;
     onCreate?: (() => any) | undefined;
     onRefresh?: (() => any) | undefined;
+    onDeselect?: (() => any) | undefined;
     onLoaded?: ((records: QueryListRecord[]) => any) | undefined;
     "onUpdate:keyword"?: ((value: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/dynamic-page-runtime/RecordFormSurface.vue.d.ts

@@ -0,0 +1,31 @@
+import { type RecordFormFieldDescriptor, type RecordFormFieldPickerConfig, type RecordFormRecord, type RecordFormFieldValue } from '../platform-components/index';
+import type { ModuleContext } from '../web-core/index';
+import type { QueryListRecord } from '../platform-components/index';
+import { type ModulePageFormContribution, type ModulePageFormFieldPolicy } from './modulePageEnhancements';
+type __VLS_Props = {
+    record: RecordFormRecord;
+    fields: Map<string, RecordFormFieldDescriptor>;
+    mode: 'create' | 'edit' | 'view';
+    formSessionKey: number;
+    validationRequestKey?: number;
+    optionContext: ModuleContext<QueryListRecord>;
+    fileTransferContext: ModuleContext<QueryListRecord>;
+    pickerConfigs: Record<string, RecordFormFieldPickerConfig>;
+    disabled: boolean;
+    excludeFieldNames?: string[];
+    contributions?: readonly ModulePageFormContribution[];
+    fieldPolicies?: readonly ModulePageFormFieldPolicy[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:field": (fieldName: string, value: RecordFormFieldValue) => any;
+    "validity-change": (validity: {
+        valid: boolean;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:field"?: ((fieldName: string, value: RecordFormFieldValue) => any) | undefined;
+    "onValidity-change"?: ((validity: {
+        valid: boolean;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/dynamic-page-runtime/composables/useManagedDetailRelationRuntime.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from 'vue';
+import type { ManagedDetailRelationClient } from '../../web-core/index';
+import type { ResolvedDetailRelationDescriptor, WebPageResponse, WebQueryRequest } from '../../web-contracts/index';
+export interface ManagedDetailRelationRuntimeOptions<TRecord extends Record<string, unknown>> {
+    relation: Ref<ResolvedDetailRelationDescriptor | undefined>;
+    parentId: Ref<string | undefined>;
+    parentPersisted: Ref<boolean>;
+    mutationEnabled: Ref<boolean>;
+    can?: (actionCode: string) => boolean;
+    clientOf(parentId: string, relationCode: string): ManagedDetailRelationClient<TRecord>;
+}
+/**
+ * Source-neutral association session. List rendering stays in RecordQueryListPanel; this
+ * collaborator owns fixed-gateway transport, mutation serialization and cross-parent isolation.
+ */
+export declare function useManagedDetailRelationRuntime<TRecord extends Record<string, unknown>>(options: ManagedDetailRelationRuntimeOptions<TRecord>): {
+    records: Ref<TRecord[], TRecord[]>;
+    loading: Ref<boolean, boolean>;
+    saving: Ref<boolean, boolean>;
+    busy: import("vue").ComputedRef<boolean>;
+    error: Ref<unknown, unknown>;
+    reloadKey: Ref<number, number>;
+    executable: import("vue").ComputedRef<ResolvedDetailRelationDescriptor | undefined>;
+    mutable: import("vue").ComputedRef<import("../../web-contracts/index").ResolvedDetailRelationMutationContract | undefined>;
+    query: (request?: WebQueryRequest) => Promise<WebPageResponse<TRecord>>;
+    refresh: () => void;
+    create: (record: TRecord) => Promise<boolean>;
+    update: (id: string, record: TRecord) => Promise<boolean>;
+    remove: (id: string, version: number) => Promise<boolean>;
+};

package/dist/types/dynamic-page-runtime/composables/useModulePageActions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Common action boundary for a descriptor-driven page session.
+ *
+ * Enhancements are extension code. They may open their own UI or issue a
+ * request, but an exception must never escape into the host render session.
+ */
+export declare function useModulePageActions(): {
+    presentActionSuccess: (result: unknown, fallbackMessage: string, source?: string) => Promise<import("../../platform-components/index").PlatformActionResult>;
+    runEnhancementAction: <TContext>(contribution: {
+        key: string;
+        run(context: TContext): void | Promise<void>;
+    }, actionContext: TContext) => Promise<void>;
+};

package/dist/types/dynamic-page-runtime/composables/useModulePageBootstrap.d.ts

@@ -0,0 +1,17 @@
+import type { PageBootstrap } from '../../web-contracts/index';
+import { type ModuleContext } from '../../web-core/index';
+import type { QueryListRecord } from '../../platform-components/index';
+/**
+ * Owns the menu-entry bootstrap session for a standard module page.
+ *
+ * A host may be rendered without a persisted menu entry (for example from a
+ * static route). In that case no request is issued and `ready` is immediately
+ * true. A failed entry lookup is intentionally stateful: it is rendered by the
+ * host instead of allowing the rest of the page session to start with an
+ * unverified module alias.
+ */
+export declare function useModulePageBootstrap(context: ModuleContext<QueryListRecord>, menuId: () => string | undefined): {
+    pageBootstrap: import("vue").Ref<PageBootstrap | undefined, PageBootstrap | undefined>;
+    pageBootstrapError: import("vue").Ref<string | undefined, string | undefined>;
+    loadPageBootstrap: () => Promise<void>;
+};

package/dist/types/dynamic-page-runtime/composables/useModulePageDetailActionRuntime.d.ts

@@ -0,0 +1,48 @@
+import { type Ref } from 'vue';
+import type { RecordActionItem, RecordFormFieldDescriptor, RecordFormRecord } from '../../platform-components/index';
+import type { PageBootstrap, PageBootstrapActionBlock } from '../../web-contracts/index';
+import type { ModuleContext } from '../../web-core/index';
+import type { QueryListRecord } from '../../platform-components/index';
+interface DetailLoader {
+    resolveLoad(record: QueryListRecord): void;
+}
+export interface ModulePageDetailActionRuntimeOptions {
+    context: ModuleContext<QueryListRecord>;
+    pageBootstrap: Ref<PageBootstrap | undefined>;
+    selectedRecord: Ref<QueryListRecord | undefined>;
+    editorMode: Ref<'create' | 'edit' | 'view'>;
+    detail: DetailLoader;
+    refreshList(): void;
+    /** Current local-edit form validity, owned by RecordFormFields at the host boundary. */
+    localEditValid?: Ref<boolean>;
+    presentSuccess(result: unknown, fallbackMessage: string, source: string): Promise<unknown> | unknown;
+    presentError(cause: unknown, source: string): void;
+}
+/**
+ * Runs server-issued detail action contracts and their typed local-edit forms.
+ *
+ * The host retains layout and action routing. This runtime owns the action
+ * payload, refresh policy and error/success lifecycle, so presentation
+ * templates never acquire request or authorization responsibilities.
+ */
+export declare function useModulePageDetailActionRuntime(options: ModulePageDetailActionRuntimeOptions): {
+    supportedDetailActions: import("vue").ComputedRef<RecordActionItem[]>;
+    localEditActionBlocks: import("vue").ComputedRef<(PageBootstrapActionBlock & {
+        localEditForm: NonNullable<PageBootstrapActionBlock["localEditForm"]>;
+    })[]>;
+    detailPageActions: import("vue").ComputedRef<RecordActionItem[]>;
+    localEditOpen: Ref<boolean, boolean>;
+    localEditSaving: Ref<boolean, boolean>;
+    localEditBlock: Ref<(PageBootstrapActionBlock & {
+        localEditForm: NonNullable<PageBootstrapActionBlock["localEditForm"]>;
+    }) | undefined, (PageBootstrapActionBlock & {
+        localEditForm: NonNullable<PageBootstrapActionBlock["localEditForm"]>;
+    }) | undefined>;
+    localEditDraft: Ref<RecordFormRecord | undefined, RecordFormRecord | undefined>;
+    localEditFields: import("vue").ComputedRef<Map<string, RecordFormFieldDescriptor>>;
+    handleConfiguredAction: (action: {
+        key?: string;
+    }) => boolean;
+    submitLocalEdit: () => Promise<void>;
+};
+export {};

package/dist/types/dynamic-page-runtime/composables/useModulePageDetailExtensionRuntime.d.ts

@@ -0,0 +1,28 @@
+import type { QueryListRecord } from '../../platform-components/index';
+import type { ModuleContext } from '../../web-core/index';
+import type { ModulePageDetailSectionContext, ModulePageDrawer, ModulePageDrawerAction, ModulePageDrawerContext, ModulePageRecordViewContext, ModulePageScopeContext } from '../modulePageEnhancements';
+export interface ModulePageEnhancementDrawerRuntime {
+    definition: ModulePageDrawer;
+    context: ModulePageDrawerContext;
+    titleActions: ModulePageDrawerAction[];
+    closeBlocked: boolean;
+}
+interface Options {
+    module: ModuleContext<QueryListRecord>;
+    scope(): ModulePageScopeContext | undefined;
+    refreshList(): void;
+    reload(): void;
+    closeDetail(): void;
+}
+/** Owns frontend-only detail extension invalidation and drawer lifecycle. */
+export declare function useModulePageDetailExtensionRuntime(options: Options): {
+    drawer: import("vue").Ref<ModulePageEnhancementDrawerRuntime | undefined, ModulePageEnhancementDrawerRuntime | undefined>;
+    drawerOpen: import("vue").Ref<boolean, boolean>;
+    refreshDetailExtensions: () => void;
+    sectionContext: (record: QueryListRecord) => ModulePageDetailSectionContext;
+    recordViewContext: (record: QueryListRecord) => ModulePageRecordViewContext;
+    openDrawer: (definition: ModulePageDrawer, record?: QueryListRecord) => void;
+    closeDrawer: () => void;
+    disposeDrawer: () => void;
+};
+export {};

package/dist/types/dynamic-page-runtime/composables/useModulePageFormContributionRuntime.d.ts

@@ -0,0 +1,22 @@
+import { type Ref } from 'vue';
+import { type RecordFormFieldDescriptor, type RecordFormFieldState, type RecordFormFieldValue, type RecordFormRecord } from '../../platform-components/index';
+import { type ModulePageFormContribution, type ModulePageFormContributionContext, type ModulePageFormContributionState } from '../modulePageEnhancements';
+interface UseModulePageFormContributionRuntimeOptions {
+    contributions: Ref<readonly ModulePageFormContribution[]>;
+    mode: Ref<'create' | 'edit' | 'view'>;
+    draft: Ref<RecordFormRecord | undefined>;
+    fields: Ref<Map<string, RecordFormFieldDescriptor>>;
+    formSessionKey: Ref<number>;
+    setField(fieldName: string, value: RecordFormFieldValue): void;
+}
+/**
+ * Keeps application contribution validity at the same save boundary as the
+ * descriptor-owned form, without giving contributed components access to the
+ * module HTTP client or mutable form state.
+ */
+export declare function useModulePageFormContributionRuntime(options: UseModulePageFormContributionRuntimeOptions): {
+    valid: import("vue").ComputedRef<boolean>;
+    contextFor: (contribution: ModulePageFormContribution, field?: Readonly<RecordFormFieldState>) => ModulePageFormContributionContext;
+    stateSnapshot: () => ModulePageFormContributionState;
+};
+export {};

package/dist/types/dynamic-page-runtime/composables/useModulePageListSession.d.ts

@@ -0,0 +1,41 @@
+import { type Ref } from 'vue';
+import type { QueryListRecord, RecordQueryListMode } from '../../platform-components/index';
+export interface ModulePageListSessionOptions {
+    selectedRecord: Ref<QueryListRecord | undefined>;
+    saving: Ref<boolean>;
+    resetDetail(): void;
+    invalidateDetailLoad(): void;
+    resetTreeSelection(): void;
+    openRecord(record: QueryListRecord): void;
+    openRecycleBinRecord(record: QueryListRecord): void;
+}
+/**
+ * Owns list-side state and record selection policy for one module-page session.
+ *
+ * This boundary deliberately has no HTTP, authorization, bootstrap or template
+ * dependencies. The host supplies the already-authorized detail transitions,
+ * keeping list/card/drawer selection behaviour reusable and directly testable.
+ */
+export declare function useModulePageListSession(options: ModulePageListSessionOptions): {
+    listMode: Ref<RecordQueryListMode, RecordQueryListMode>;
+    reloadKey: Ref<number, number>;
+    cardAssistantRecords: Ref<{
+        [x: string]: unknown;
+        id?: string | undefined;
+        enabled?: boolean | undefined;
+    }[], QueryListRecord[] | {
+        [x: string]: unknown;
+        id?: string | undefined;
+        enabled?: boolean | undefined;
+    }[]>;
+    handleLoaded: (records: QueryListRecord[]) => void;
+    handleFlatManagementLoaded: (records: QueryListRecord[], recycleBinActive: boolean) => void;
+    setCardAssistantRecords: (records: QueryListRecord[]) => void;
+    resetFlatManagementSelection: () => void;
+    handleListModeChange: (mode: RecordQueryListMode) => void;
+    handleRecycleBinRestore: () => void;
+    selectRecord: (record: QueryListRecord) => void;
+    selectListDetailRecord: (record: QueryListRecord, detailSurfaceUsesDrawer: boolean) => void;
+    selectStandaloneListRecord: (record: QueryListRecord) => void;
+    openListRecord: (record: QueryListRecord) => void;
+};