@ximatai/muyun-web-app 0.26.12 → 0.26.14

package/dist/types/platform-components/index.d.ts

@@ -1,10 +1,13 @@
 export {};
+export type { QuerySettlementController } from './querySettlementController';
 export { default as FormulaExpressionEditor } from './FormulaExpressionEditor.vue';
 export type { FormulaExpressionField, FormulaExpressionFunction } from './formulaExpressionTokens';
 export { default as ApplicationScopeSwitcher } from './ApplicationScopeSwitcher.vue';
 export { default as BusinessNotificationPanel } from './BusinessNotificationPanel.vue';
 export { confirmAction } from '../vue-ui-antdv/index';
 export { UiModal } from '../vue-ui-antdv/index';
+export { uiDrawerWidths as drawerWidths } from '../vue-ui-antdv/index';
+export type { UiDrawerWidth as DrawerWidth } from '../vue-ui-antdv/index';
 export { default as CrudRecordListExplorer } from './CrudRecordListExplorer.vue';
 export { default as DrawerOperationBar } from './DrawerOperationBar.vue';
 export { default as DrawerTitleActions } from './DrawerTitleActions.vue';
@@ -32,6 +35,10 @@ export type { HeaderActionItem } from './AdaptiveHeaderActionBar.vue';
 export type { HeaderActionLevel } from './adaptiveHeaderActionLayout';
 export { default as RecordContentSectionHeading } from './RecordContentSectionHeading.vue';
 export { default as RecordDetailDrawer } from './RecordDetailDrawer.vue';
+export { default as ReferenceRecordDetailBrowser } from './ReferenceRecordDetailBrowser.vue';
+export { default as ReadonlyReferenceValue } from './ReadonlyReferenceValue.vue';
+export { createReferenceRecordDetailBrowser, provideReferenceRecordDetailBrowser, } from './referenceRecordDetailBrowser';
+export type { ReferenceRecordDetailBrowser as ReferenceRecordDetailBrowserState, ReferenceRecordDetailMutation, } from './referenceRecordDetailBrowser';
 export type { DrawerPromotion } from './drawerPromotion';
 export { default as RecordExternalChangeNotice } from './RecordExternalChangeNotice.vue';
 export { default as RecordDetailFields } from './RecordDetailFields.vue';
@@ -50,6 +57,11 @@ export { default as RecordExplorerPanel } from './RecordExplorerPanel.vue';
 export { default as RecordExplorerCreateButton } from './RecordExplorerCreateButton.vue';
 export type { RecordExplorerItemDescriptor } from './recordExplorerItemModel';
 export { default as RecordFormFields } from './RecordFormFields.vue';
+export { default as DictionaryOptionDialog } from './DictionaryOptionDialog.vue';
+export { default as DictionaryPicker } from './DictionaryPicker.vue';
+export { default as DictionaryRadioGroup } from './DictionaryRadioGroup.vue';
+export type { DictionaryOptionValue, DictionarySelectionMode } from './dictionaryOptionDialogModel';
+export type { DictionaryPickerMode, DictionaryPickerValidity } from './DictionaryPicker.vue';
 export { default as RecordFieldLabel } from './RecordFieldLabel.vue';
 export { default as RecordFormGrid } from './RecordFormGrid.vue';
 export { default as RecordFileReferenceTransfer } from './RecordFileReferenceTransfer.vue';
@@ -58,6 +70,20 @@ export { default as RecordMetaSection } from './RecordMetaSection.vue';
 export { default as RecordModeDrawer } from './RecordModeDrawer.vue';
 export { default as RecordPicker } from './RecordPicker.vue';
 export { default as RecordMultiPicker } from './RecordMultiPicker.vue';
+export { default as ReferencePicker } from './ReferencePicker.vue';
+export { readonlyReferenceDisplay } from './readonlyReferenceDisplay';
+export { createQueryReferencePickerProvider } from './queryReferencePickerProvider';
+export { createSourceReferencePickerProvider, sourceReferencePickerReloadKey, } from './sourceReferencePickerProvider';
+export { createUserReferencePickerProvider, userReferencePickerColumns } from './userReferencePicker';
+export type { UserReferencePickerConfig } from './userReferencePicker';
+export type { ReferencePickerAxisSelection, ReferencePickerBrowseScope, ReferencePickerCandidate, ReferencePickerColumn, ReferencePickerConfig, ReferencePickerId, ReferencePickerNavigationAxis, ReferencePickerNavigationItem, ReferencePickerPage, ReferencePickerPageRequest, ReferencePickerProvider, ReferencePickerSelectionSummary, ReferencePickerSourceIdentity, ReferencePickerTreeNode, ReferencePickerValidity, } from './referencePickerModel';
+export { default as ObjectPickerInput } from './ObjectPickerInput.vue';
+export { default as UserPicker } from './UserPicker.vue';
+export { default as EmployeePicker } from './EmployeePicker.vue';
+export { default as ScopedTreePicker } from './ScopedTreePicker.vue';
+export type { UserAccountId, UserPickerCandidate, UserPickerPage, UserPickerPageRequest, UserPickerPageSearch, UserPickerResolver, UserPickerNavigation, UserPickerNavigationItem, UserPickerNavigationScope, } from './userPickerModel';
+export type { EmployeeId, EmployeePickerCandidate, EmployeePickerConfig, EmployeePickerPage, EmployeePickerPageRequest, EmployeePickerPageSearch, EmployeePickerResolver, } from './employeePickerModel';
+export type { ScopedTreePickerCandidate, ScopedTreePickerChildrenRequest, ScopedTreePickerConfig, ScopedTreePickerPage, ScopedTreePickerProvider, ScopedTreePickerRootRequest, } from './scopedTreePickerModel';
 export { default as RecordQueryListPanel } from './RecordQueryListPanel.vue';
 export { default as RecordQueryListCell } from './RecordQueryListCell.vue';
 export { default as RecycleBinModeButton } from './RecycleBinModeButton.vue';
@@ -82,6 +108,8 @@ export type { RecordDetailDisplayResolver, RecordDetailDisplayValue } from './re
 export type { RecordListExplorerRecord } from './RecordListExplorer.vue';
 export type { QueryListRecord, RecordQueryListCellComponent, RecordQueryListColumn, RecordQueryListMode, StandardCrudRowActionKey, } from './RecordQueryListPanel.vue';
 export { resolveRecordQueryListColumns } from './recordQueryListColumnModel';
+export type { RecordQueryListQueryController, RecordQueryListQueryField, RecordQueryListQuerySnapshot, RecordQueryListResultRow, } from './recordQueryListQueryController';
+export type { RecordTreeQueryController, RecordTreeQueryNode, RecordTreeQuerySnapshot, } from './recordTreeQueryController';
 export type { RecordFormFieldDescriptor, RecordFormFieldFallback, RecordFormFieldPickerConfig, RecordFormFieldState, RecordFieldRenderer, RecordFormFieldValue, RecordFormRecord, } from './recordFormFieldModel';
 export type { CrudRecordListBase } from './crudRecordListModel';
 export { defaultCrudRecordListMatches, defaultCrudRecordListSubtitle, defaultCrudRecordListTitle, } from './crudRecordListModel';
@@ -95,7 +123,7 @@ export { formatPlatformFileSize } from './platformFileSize';
 export type { PlatformFileSizeDisplay, PlatformFileSizeOptions } from './platformFileSize';
 export { providePlatformTimeZoneContext, usePlatformTimeZoneContext } from './platformTimeZoneContext';
 export type { PlatformDateTimeDisplay, PlatformDateTimeOptions, PlatformDateTimePrecision, } from './platformDateTime';
-export { applyReferenceDependencyClears, childResourceDefaultFormViewCode, resolveRecordDetailFields, resolveRecordFormFieldNames, resolveRecordBooleanStatusValue, resolveRecordFormFieldState, resolveRecordFormFields, evaluateUiFormula, recordFieldRendererRegistry, } from './recordFormFieldModel';
+export { applyReferenceDependencyClears, childResourceDefaultFormViewCode, decodeDateTimeLocalEditorValue, decodeNumberEditorValue, resolveRecordDetailFields, resolveRecordFormFieldNames, resolveRecordBooleanStatusValue, resolveRecordFormFieldState, resolveRecordFormFields, evaluateUiFormula, recordFieldRendererRegistry, } from './recordFormFieldModel';
 export { createQueryScopedTreeModuleContext, createScopedTreeClient, createScopedTreeModuleContext, } from './scopedTreeModuleContext';
 export { createEmptyStaticTreeClient, createStaticTreeResourceModuleContext, } from './staticTreeResourceModuleContext';
 export { presentPlatformError, presentPlatformMessage, presentPlatformSuccess, } from './platformErrorFeedback';
@@ -104,7 +132,7 @@ export { createPlatformActionResultReactionHandlers, mergePlatformActionResultRe
 export type { PlatformActionResult, PlatformActionResultReaction, PlatformActionResultReactionHandler, PlatformActionResultReactionPayload, PlatformActionResultReactionType, PlatformActionResultStandardReactionHandlers, } from './platformActionResultReactions';
 export type { PlatformActionResultFeedbackContext, PlatformActionResultHandlingContext, } from './platformActionResultFeedback';
 export { executeStaticFormSave, executeStaticRecordAction } from './staticFormActionFlow';
-export { applyRecordExternalChange, createRecordEditorSessionState } from './recordEditorSessionState';
+export { applyRecordExternalChange, createRecordEditorSessionState, recordDraftFingerprint, } from './recordEditorSessionState';
 export { useFlatCrudManagementState } from './staticCrudManagementState';
 export type { PlatformActionErrorHandler, PlatformErrorFeedbackContext } from './platformErrorFeedback';
 export type { StaticFormActionErrorContext, StaticFormActionErrorHandler, StaticFormSaveMode, StaticFormSaveOptions, StaticRecordActionOptions, } from './staticFormActionFlow';
@@ -116,3 +144,5 @@ export type { StaticTreeResourceModuleContextOptions } from './staticTreeResourc
 export { default as RecordRelationTable } from './RecordRelationTable.vue';
 export { default as RecordRelationValue } from './RecordRelationValue.vue';
 export { default as RecordPermissionDialog } from './RecordPermissionDialog.vue';
+export { ReferencePickerReadError } from './referencePickerReadError';
+export type { ReferencePickerReadErrorKind } from './referencePickerReadError';

package/dist/types/platform-components/optionFieldOptionCache.d.ts

@@ -1,3 +1,3 @@
 import type { OptionItemDescriptor } from '../web-contracts/index';
 import type { ModuleContext } from '../web-core/index';
-export declare function loadOptionFieldItems(context: ModuleContext<unknown>, fieldName: string, entityAlias?: string): Promise<OptionItemDescriptor[]>;
+export declare function loadOptionFieldItems(context: ModuleContext<unknown>, fieldName: string, entityAlias?: string, moduleAlias?: string, forceRefresh?: boolean): Promise<OptionItemDescriptor[]>;

package/dist/types/platform-components/queryCriteriaDraft.d.ts

@@ -0,0 +1,24 @@
+import type { QueryOperator } from '../web-contracts/index';
+export interface QueryCriteriaConditionDraft {
+    kind: 'CONDITION';
+    id: number;
+    fieldName?: string;
+    operator?: QueryOperator;
+    values: unknown[];
+}
+export interface QueryCriteriaGroupDraft {
+    kind: 'GROUP';
+    id: number;
+    operator: 'AND' | 'OR';
+    children: QueryCriteriaDraftNode[];
+}
+export type QueryCriteriaDraftNode = QueryCriteriaConditionDraft | QueryCriteriaGroupDraft;
+/**
+ * Mirrors the source-neutral execution limits in QueryCriteria.  The server
+ * remains authoritative; keeping the limits here lets the composer identify
+ * the affected draft row before it sends a request that must be rejected.
+ */
+export declare const QUERY_CRITERIA_MAXIMUM_DEPTH = 4;
+export declare const QUERY_CRITERIA_MAXIMUM_NODES = 50;
+export declare const QUERY_CRITERIA_MAXIMUM_COLLECTION_VALUES = 100;
+export declare function isValueLessQueryOperator(operator: QueryOperator | undefined): operator is "NULL" | "NOT_NULL" | "EMPTY" | "NOT_EMPTY";

package/dist/types/platform-components/queryReferencePickerProvider.d.ts

@@ -0,0 +1,19 @@
+import type { QuerySchemaReference } from '../web-contracts/index';
+import { type HttpClient } from '../web-core/index';
+import type { ReferencePickerProvider } from './referencePickerModel';
+export interface QueryReferencePickerProviderOptions {
+    /**
+     * The HTTP client from the target's REFERENCE module context. The provider constructs its own
+     * navigation-only client instead of accepting an arbitrary context CRUD client.
+     */
+    http: HttpClient;
+    reference: QuerySchemaReference;
+}
+/**
+ * Adapts a query schema's ordinary target reference to the shared picker contract.
+ *
+ * Query schemas deliberately have no source-field resolve contract or dependency semantics. The
+ * only permitted candidate transport here is the target module's REFERENCE navigator endpoint;
+ * this is intentionally different from both ordinary target CRUD and source-field resolution.
+ */
+export declare function createQueryReferencePickerProvider({ http, reference, }: QueryReferencePickerProviderOptions): ReferencePickerProvider;

package/dist/types/platform-components/querySettlementController.d.ts

@@ -0,0 +1,5 @@
+/** Shared settlement boundary for query-backed UI surfaces used by orchestration adapters. */
+export interface QuerySettlementController<T = void> {
+    revision(): number;
+    settle(signal?: AbortSignal): Promise<T>;
+}

package/dist/types/platform-components/readonlyReferenceDisplay.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
+export interface ReadonlyReferenceDisplayItem {
+    id: string;
+    label: string;
+    /** Only a delivered, usable projection may enter the target-detail browser. */
+    browseable: boolean;
+}
+/**
+ * Formats only record-projected reference facts. It never resolves candidates: an absent title
+ * remains the persisted ID, which distinguishes an unavailable projection from a deleted or
+ * unauthorized target.
+ */
+export declare function readonlyReferenceDisplay(reference: Pick<ResolvedReferenceFieldDescriptor, 'cardinality'>, value: unknown, summary: unknown): string | undefined;
+/**
+ * Keeps the persisted reference order while retaining enough projection identity for the shared
+ * read-only browser. A raw ID intentionally remains non-interactive: it may be absent, deleted,
+ * or hidden by a target data scope.
+ */
+export declare function readonlyReferenceDisplayItems(reference: Pick<ResolvedReferenceFieldDescriptor, 'cardinality'>, value: unknown, summary: unknown): ReadonlyReferenceDisplayItem[];

package/dist/types/platform-components/recordEditorSessionState.d.ts

@@ -1,4 +1,11 @@
+import { type Ref } from 'vue';
 import { type WebDataChange } from '../web-contracts/index';
+/**
+ * Produces a stable value snapshot for a record draft. Editor sessions use it
+ * as a local baseline: returning every edited field to its starting value is
+ * not an unsaved change.
+ */
+export declare function recordDraftFingerprint(value: unknown): string;
 export interface RecordEditorSessionOptions<TRecord, TMode extends string> {
     viewMode: TMode;
     createMode: TMode;
@@ -18,12 +25,12 @@ export interface RecordExternalChangeOptions {
     changeTypes?: string[];
 }
 export declare function createRecordEditorSessionState<TRecord, TMode extends string>(options: RecordEditorSessionOptions<TRecord, TMode>): {
-    selected: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
-    draft: [TRecord] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TRecord, import("vue").Ref<TRecord, TRecord>, TRecord> : import("vue").Ref<import("vue").UnwrapRef<TRecord>, TRecord | import("vue").UnwrapRef<TRecord>>;
-    mode: [TMode] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TMode, import("vue").Ref<TMode, TMode>, TMode> : import("vue").Ref<import("vue").UnwrapRef<TMode>, TMode | import("vue").UnwrapRef<TMode>>;
+    selected: Ref<TRecord | undefined, TRecord | undefined>;
+    draft: Ref<TRecord, TRecord>;
+    mode: Ref<TMode, TMode>;
     readonly: import("vue").ComputedRef<boolean>;
     externallyChanged: import("vue").ComputedRef<boolean>;
-    externalChangedRecordId: import("vue").Ref<string | undefined, string | undefined>;
+    externalChangedRecordId: Ref<string | undefined, string | undefined>;
     select: (record: TRecord) => void;
     replaceSelected: (record: TRecord | undefined) => void;
     clearSelection: () => void;

package/dist/types/platform-components/recordFormFieldModel.d.ts

@@ -3,6 +3,8 @@ import type { ModuleContext } from '../web-core/index';
 import type { PickerConstraint, RecordPickerRecord } from './recordPickerConstraints';
 import type { WebTreeNode } from '../web-contracts/index';
 import type { RecordPickerMode } from './recordPickerModel';
+import type { ScopedTreePickerProvider } from './scopedTreePickerModel';
+import type { ReferencePickerColumn, ReferencePickerProvider } from './referencePickerModel';
 export type RecordFormFieldDescriptor = (ViewFieldDefinition | ResolvedViewFieldDescriptor) & {
     /** Optional during the protocol migration; resolved descriptors take precedence over legacy uiType. */
     fieldControl?: ResolvedFieldControlDescriptor;
@@ -36,7 +38,9 @@ export type JsonValue = null | boolean | number | string | JsonValue[] | {
 };
 /** A business boolean does not inherit the lifecycle field's implicit enabled default. */
 export type RecordBooleanStatusValue = boolean | undefined;
-export type RecordFormFieldControlType = 'input' | 'numberInput' | 'dateInput' | 'dateTimeInput' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'fileTransfer' | 'imageFileTransfer' | 'unsupported';
+export type RecordFormFieldControlType = 'input' | 'numberInput' | 'dateInput' | 'dateTimeInput' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'dictionaryPicker' | 'dictionaryRadioGroup' | 'fileTransfer' | 'imageFileTransfer' | 'unsupported';
+/** The only source-field reference presentations implemented by the common picker. */
+export type RecordFormReferencePickerPresentation = 'dropdown' | 'dialog';
 export interface RecordFieldRenderer {
     rendererType: string;
     controlType: Exclude<RecordFormFieldControlType, 'unsupported'>;
@@ -60,10 +64,14 @@ export interface RecordFormFieldFallback {
 }
 export interface RecordFormFieldPickerConfig {
     context: ModuleContext<RecordPickerRecord>;
+    /** Source-authorized, paged reference delivery for the common picker. */
+    provider?: ReferencePickerProvider;
+    /** Candidate columns are presentation only; identity and authorization stay with the provider. */
+    columns?: readonly ReferencePickerColumn[];
     loadOptions?: (keyword: string) => Promise<RecordPickerRecord[]>;
     loadTree?: () => Promise<WebTreeNode<RecordPickerRecord>[]>;
     resolveOptions?: (values: string[]) => Promise<RecordPickerRecord[]>;
-    reloadKey?: number;
+    reloadKey?: string | number;
     mode?: RecordPickerMode;
     placeholder?: string;
     allowClear?: boolean;
@@ -71,6 +79,17 @@ export interface RecordFormFieldPickerConfig {
     titleOf?: (record: RecordPickerRecord) => string;
     descriptionOf?: (record: RecordPickerRecord) => string | undefined;
     filterOption?: (record: RecordPickerRecord, keyword: string) => boolean;
+    /**
+     * Optional expanded tree navigation for a reference that keeps its ordinary compact picker.
+     * The host owns whether its declared effective scope is ready; this generic form model does
+     * not infer tenant or organization rules from field names.
+     */
+    scopedTree?: {
+        title?: string;
+        disabled?: boolean;
+        unavailableMessage?: string;
+        provider: ScopedTreePickerProvider;
+    };
 }
 export interface RecordFormFieldState {
     fieldName: string;
@@ -93,6 +112,13 @@ export interface RecordFormFieldState {
     optionTitleField?: string;
     optionItems?: import('../web-contracts/index').OptionItemDescriptor[];
     referenceTitleField?: string;
+    /** The compiled reference contract remains available to read-only detail and list renderers. */
+    reference?: ResolvedReferenceFieldDescriptor;
+    /**
+     * Source-neutral presentation resolved from the field control. It is intentionally separate
+     * from the provider: the descriptor chooses presentation while the host owns transport.
+     */
+    referencePickerPresentation?: RecordFormReferencePickerPresentation;
     /** Title for the standard TreeAbility root sentinel when this field is a tree parent reference. */
     treeRootTitle?: string;
     fileReference?: ResolvedFileReferenceFieldDescriptor;

package/dist/types/platform-components/recordQueryListColumnModel.d.ts

@@ -1,4 +1,4 @@
-import type { OptionItemDescriptor, QuerySchemaField, ResolvedViewDescriptor, ResolvedViewFieldDescriptor } from '../web-contracts/index';
+import type { OptionItemDescriptor, QuerySchemaField, ResolvedViewDescriptor, ResolvedViewFieldDescriptor, ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
 import type { Component } from 'vue';
 export type QueryListRecord = Record<string, unknown> & {
     id?: string;
@@ -18,6 +18,8 @@ export interface RecordQueryListColumn {
     width?: string;
     align?: 'left' | 'center' | 'right';
     titleField?: string;
+    /** Compiled reference facts for pure read-side title/summary rendering. */
+    reference?: ResolvedReferenceFieldDescriptor;
     /** Only descriptor-declared option fields load a runtime option catalog. */
     optionBinding?: boolean;
     /** Dynamic child entity whose declared option binding owns this field. */
@@ -27,11 +29,16 @@ export interface RecordQueryListColumn {
     /** Maximum visible lines for text cells. Defaults to one line. */
     maxDisplayLines?: number;
     render?: (record: QueryListRecord) => string;
+    /** Explicit list-presentation policy for excluding a visible column from assistant projection. */
+    assistantReadable?: boolean;
 }
 export interface RecordQueryListCellComponent {
     key: string;
     component: Component;
 }
+export interface RecordQueryListDisplayContext {
+    timeZone?: string;
+}
 /**
  * Compiles the source-neutral resolved list descriptor into the standard table's presentation model.
  *
@@ -40,3 +47,5 @@ export interface RecordQueryListCellComponent {
  * query schema for timestamp and option-title information.
  */
 export declare function resolveRecordQueryListColumns(view: ResolvedViewDescriptor | undefined, queryFields?: readonly QuerySchemaField[]): RecordQueryListColumn[];
+/** Pure standard-cell projection shared by the rendered list and assistant-visible result summary. */
+export declare function resolveRecordQueryListDisplayValue(record: QueryListRecord, column: RecordQueryListColumn, cellRenderers?: Record<string, (record: QueryListRecord) => string>, context?: RecordQueryListDisplayContext): string;

package/dist/types/platform-components/recordQueryListQueryController.d.ts

@@ -0,0 +1,36 @@
+import type { QueryValueType } from '../web-contracts/index';
+import type { QuerySettlementController } from './querySettlementController';
+export interface RecordQueryListQueryField {
+    name: string;
+    title: string;
+    valueType: QueryValueType;
+}
+export interface RecordQueryListResultRow {
+    id?: string;
+    cells: Array<{
+        fieldName: string;
+        title: string;
+        value: unknown;
+    }>;
+}
+export interface RecordQueryListQuerySnapshot {
+    mode: 'normal' | 'recycleBin';
+    status: 'waiting' | 'loading' | 'ready' | 'error';
+    quickSearchEnabled: boolean;
+    quickSearchFields: RecordQueryListQueryField[];
+    appliedQuickSearch?: string;
+    pageNum: number;
+    pageSize: number;
+    total: number;
+    totalKnown: boolean;
+    rows: RecordQueryListResultRow[];
+    truncated: boolean;
+}
+/** Public list-query port used by orchestration adapters without owning list state. */
+export interface RecordQueryListQueryController extends QuerySettlementController<RecordQueryListQuerySnapshot> {
+    /** Stable signature of user-controlled scope, filters, sorting and pagination. */
+    interactionRevision?(): string;
+    snapshot(): RecordQueryListQuerySnapshot;
+    /** Waits until the current reactive query transition and any active load have settled. */
+    applyQuickSearch(keyword: string): Promise<RecordQueryListQuerySnapshot>;
+}

package/dist/types/platform-components/recordTreeQueryController.d.ts

@@ -0,0 +1,18 @@
+import type { QuerySettlementController } from './querySettlementController';
+export interface RecordTreeQueryNode {
+    selectionKey: string;
+    title: string;
+    secondary?: string;
+}
+export interface RecordTreeQuerySnapshot {
+    status: 'loading' | 'ready' | 'error';
+    selectedTitle?: string;
+    nodes: RecordTreeQueryNode[];
+    truncated: boolean;
+}
+/** Public tree-query port used by orchestration adapters without owning tree state. */
+export interface RecordTreeQueryController extends QuerySettlementController<void> {
+    snapshot(): RecordTreeQuerySnapshot;
+    /** Selects one node through an opaque key from the current snapshot. */
+    select(selectionKey: string): RecordTreeQueryNode;
+}

package/dist/types/platform-components/referencePickerModel.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Source-neutral candidate contract for records selected through an authorized
+ * reference source. IDs are the only persisted value; projections are display
+ * data and affectPatch remains an explicit, host-owned extension.
+ */
+export type ReferencePickerId = string;
+/** Whether the compact entry still represents the persisted reference selection. */
+export interface ReferencePickerValidity {
+    valid: boolean;
+    status: 'ready' | 'editing' | 'resolving' | 'unmatched' | 'error';
+    message?: string;
+}
+export interface ReferencePickerSourceIdentity {
+    targetModuleAlias: string;
+    source: {
+        kind: 'sourceField' | 'businessPurpose' | 'targetReference';
+        id: string;
+    };
+    /** A source-controlled authorization/range revision when it is available. */
+    authorizationScope?: string;
+}
+export interface ReferencePickerCandidate {
+    id: ReferencePickerId;
+    title: string;
+    /** The UI is displaying the persisted identifier because no business title was available. */
+    identifierFallback?: boolean;
+    subtitle?: string;
+    disabled?: boolean;
+    unavailable?: boolean;
+    projections?: Readonly<Record<string, unknown>>;
+    affectPatch?: Readonly<Record<string, unknown>>;
+}
+export interface ReferencePickerAxisSelection {
+    axisId: string;
+    itemId: string;
+}
+export interface ReferencePickerBrowseScope {
+    selections: readonly ReferencePickerAxisSelection[];
+}
+export interface ReferencePickerNavigationItem {
+    id: string;
+    title: string;
+    disabled?: boolean;
+}
+/** A declared browse axis. The picker clears dependent selections on an upstream change. */
+export interface ReferencePickerNavigationAxis {
+    id: string;
+    title: string;
+    dependsOn?: readonly string[];
+    items: readonly ReferencePickerNavigationItem[];
+}
+export interface ReferencePickerPageRequest {
+    keyword: string;
+    pageNum: number;
+    pageSize: number;
+    scope: ReferencePickerBrowseScope;
+}
+export interface ReferencePickerPage<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    records: TCandidate[];
+    total: number;
+    navigation?: readonly ReferencePickerNavigationAxis[];
+}
+/** A complete, source-authorized browse tree. It is never synthesized from paged query results. */
+export interface ReferencePickerTreeNode<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    record: TCandidate;
+    children?: ReferencePickerTreeNode<TCandidate>[];
+}
+export interface ReferencePickerProvider<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    identity: ReferencePickerSourceIdentity;
+    searchPage(request: ReferencePickerPageRequest): Promise<ReferencePickerPage<TCandidate>>;
+    /**
+     * Reads the complete tree under the source's authorization scope. Dialog browse uses this only
+     * without a keyword; keyword search remains server-paged through searchPage.
+     */
+    loadTree?: (request: {
+        scope: ReferencePickerBrowseScope;
+    }) => Promise<ReferencePickerTreeNode<TCandidate>[]>;
+    /** Resolves persisted IDs under the source's authorized historical-display scope. */
+    resolve(ids: ReferencePickerId[]): Promise<TCandidate[]>;
+}
+export interface ReferencePickerColumn {
+    key: string;
+    title: string;
+    width?: number;
+}
+/** Compiled page/query configuration for a standard reference interaction. */
+export interface ReferencePickerConfig {
+    provider: ReferencePickerProvider;
+    mode?: 'dialog' | 'dropdown';
+    columns?: readonly ReferencePickerColumn[];
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    maxSelection?: number;
+    reloadKey?: string | number;
+}
+export interface ReferencePickerSelectionSummary {
+    id: ReferencePickerId;
+    title: string;
+    subtitle?: string;
+    unavailable?: boolean;
+}
+export declare function normalizeReferencePickerIds(value: ReferencePickerId | readonly ReferencePickerId[] | undefined, multiple: boolean): ReferencePickerId[];
+export declare function referencePickerValue(ids: readonly ReferencePickerId[], multiple: boolean): ReferencePickerId | ReferencePickerId[] | undefined;
+export declare function referencePickerSummary(candidate: ReferencePickerCandidate): ReferencePickerSelectionSummary;

package/dist/types/platform-components/referencePickerReadError.d.ts

@@ -0,0 +1,24 @@
+import { AppError } from '../web-core/index';
+export type ReferencePickerReadErrorKind = 'accessDenied' | 'missingDependencies' | 'unsupportedConfiguration' | 'temporaryFailure';
+/**
+ * The picker only classifies facts carried by AppError or facts its source can
+ * prove locally. It deliberately never derives a category from an error message.
+ */
+export declare class ReferencePickerReadError extends AppError {
+    readonly kind: ReferencePickerReadErrorKind;
+    readonly retryable: boolean;
+    readonly missingDependencyFields: readonly string[];
+    readonly original: AppError;
+    constructor(kind: ReferencePickerReadErrorKind, message: string, options: {
+        retryable: boolean;
+        missingDependencyFields?: readonly string[];
+        original?: AppError;
+    });
+}
+/**
+ * Returns undefined for 401 so the request client's authentication lifecycle
+ * remains the sole owner of login recovery and redirect behavior.
+ */
+export declare function referencePickerReadErrorOf(cause: unknown, fallbackMessage: string): ReferencePickerReadError | undefined;
+export declare function missingReferencePickerDependencies(sourceFields: readonly string[]): ReferencePickerReadError;
+export declare function unsupportedReferencePickerConfiguration(message: string): ReferencePickerReadError;

package/dist/types/platform-components/referenceRecordDetailBrowser.d.ts

@@ -0,0 +1,48 @@
+import { type InjectionKey } from 'vue';
+import { type HttpClient, type ModuleContext } from '../web-core/index';
+import type { QueryListRecord } from './recordQueryListColumnModel';
+import { type RecordFormFieldDescriptor } from './recordFormFieldModel';
+export type ActiveReferenceRecord = {
+    targetModuleAlias: string;
+    recordId: string;
+    record?: QueryListRecord;
+    loading: boolean;
+    /** A record-only editor owns an in-flight target mutation. */
+    busy?: boolean;
+    failed: boolean;
+    failureKind?: 'notFound' | 'temporary';
+};
+export type ReferenceRecordDetailMutation = {
+    targetModuleAlias: string;
+    recordId: string;
+    type: 'saved' | 'deleted' | 'unavailable';
+    record?: QueryListRecord;
+};
+export interface ReferenceRecordDetailBrowser {
+    revision: {
+        value: number;
+    };
+    active: {
+        value: ActiveReferenceRecord | undefined;
+    };
+    activeContext: {
+        value: ModuleContext<QueryListRecord> | undefined;
+    };
+    fields: {
+        value: Map<string, RecordFormFieldDescriptor>;
+    };
+    title: {
+        value: string;
+    };
+    canBrowse(targetModuleAlias: string, recordId: string): boolean;
+    open(targetModuleAlias: string, recordId: string): void;
+    setBusy(targetModuleAlias: string, recordId: string, busy: boolean): void;
+    reportMutation(mutation: ReferenceRecordDetailMutation): void;
+    close(): void;
+    /** Component teardown bypasses the user-facing busy close gate. */
+    dispose(): void;
+}
+export declare const referenceRecordDetailBrowserKey: InjectionKey<ReferenceRecordDetailBrowser | undefined>;
+export declare function createReferenceRecordDetailBrowser(http: HttpClient): ReferenceRecordDetailBrowser;
+export declare function provideReferenceRecordDetailBrowser(browser: ReferenceRecordDetailBrowser): void;
+export declare function useReferenceRecordDetailBrowser(): ReferenceRecordDetailBrowser | undefined;

package/dist/types/platform-components/scopedTreePickerModel.d.ts

@@ -0,0 +1,46 @@
+/**
+ * An authorized, source-owned record projection for a lazily loaded tree selector.
+ * The component deliberately does not infer a parent, tenant, or module from this shape.
+ */
+export interface ScopedTreePickerCandidate {
+    id: string;
+    title: string;
+    /** A provider may return a path, code, or scope summary to disambiguate equal titles. */
+    subtitle?: string;
+    /** False keeps the item expandable and asks the provider for children when it is expanded. */
+    isLeaf?: boolean;
+    disabled?: boolean;
+    unavailable?: boolean;
+}
+export interface ScopedTreePickerRootRequest {
+    /** Provider-defined search text. An empty string requests the current scope roots. */
+    keyword: string;
+    signal: AbortSignal;
+}
+export interface ScopedTreePickerChildrenRequest extends ScopedTreePickerRootRequest {
+    parent: ScopedTreePickerCandidate;
+    /** Opaque continuation supplied by an earlier child response when the provider supports paging. */
+    cursor?: string;
+}
+export interface ScopedTreePickerPage {
+    records: ScopedTreePickerCandidate[];
+    hasMore?: boolean;
+    nextCursor?: string;
+}
+/**
+ * A source-owned delivery boundary. The caller may use a static reference resolver, a dedicated
+ * candidate endpoint, or another authorized source; this component has no module-path knowledge.
+ */
+export interface ScopedTreePickerProvider {
+    loadRoot: (request: ScopedTreePickerRootRequest) => Promise<ScopedTreePickerPage>;
+    loadChildren: (request: ScopedTreePickerChildrenRequest) => Promise<ScopedTreePickerPage>;
+    /** Resolves persisted IDs through the same authorization and effective-scope rule. */
+    resolve: (ids: string[]) => Promise<ScopedTreePickerCandidate[]>;
+}
+export interface ScopedTreePickerConfig {
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    provider: ScopedTreePickerProvider;
+}
+export declare function scopedTreePickerValue(value: string | undefined): string | undefined;

package/dist/types/platform-components/sourceReferencePickerProvider.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
+import type { ReferenceResolveClient } from '../web-core/index';
+import type { ReferencePickerProvider } from './referencePickerModel';
+export interface SourceReferencePickerProviderOptions {
+    sourceModuleAlias: string;
+    fieldName: string;
+    reference: ResolvedReferenceFieldDescriptor;
+    /** Obtained at request time so a retained provider does not capture a replaced module context. */
+    resolver: () => ReferenceResolveClient;
+    /** Read at request time so a stable provider always uses the current draft. */
+    formValues: () => Record<string, unknown>;
+    source: () => {
+        recordId: string;
+    } | undefined;
+}
+/**
+ * Adapts the source-field resolver to the neutral picker contract.  It deliberately carries no
+ * target-module query fallback: the declaring source field remains the authority for candidate
+ * eligibility, projections and patches.
+ */
+export declare function createSourceReferencePickerProvider({ sourceModuleAlias, fieldName, reference, resolver, formValues, source, }: SourceReferencePickerProviderOptions): ReferencePickerProvider;
+/**
+ * Only source identity, persisted record scope and declared candidate dependencies invalidate a
+ * picker.  This avoids resetting pagination or re-querying for unrelated form edits.
+ */
+export declare function sourceReferencePickerReloadKey(sourceModuleAlias: string, fieldName: string, reference: ResolvedReferenceFieldDescriptor, record: Record<string, unknown> | undefined): string;

package/dist/types/platform-components/staticCrudManagementState.d.ts

@@ -1,3 +1,4 @@
+import { type Ref } from 'vue';
 import { type ModuleContext } from '../web-core/index';
 import type { UiConfirmOptions } from '../vue-ui-antdv/index';
 import { type PlatformActionResultReactionHandler } from './platformActionResultFeedback';
@@ -41,12 +42,12 @@ export interface StaticCrudManagementOptions<TRecord extends StaticCrudRecord> {
     actionResultReactionHandlers?: Record<string, PlatformActionResultReactionHandler | undefined>;
 }
 export declare function useFlatCrudManagementState<TRecord extends StaticCrudRecord>(options: StaticCrudManagementOptions<TRecord>): {
-    selected: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
-    draft: [TRecord] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TRecord, import("vue").Ref<TRecord, TRecord>, TRecord> : import("vue").Ref<import("vue").UnwrapRef<TRecord>, TRecord | import("vue").UnwrapRef<TRecord>>;
-    mode: import("vue").Ref<StaticCrudCardMode, StaticCrudCardMode>;
-    reloadKey: import("vue").Ref<number, number>;
-    saving: import("vue").Ref<boolean, boolean>;
-    actionError: import("vue").Ref<string | undefined, string | undefined>;
+    selected: Ref<TRecord | undefined, TRecord | undefined>;
+    draft: Ref<TRecord, TRecord>;
+    mode: Ref<StaticCrudCardMode, StaticCrudCardMode>;
+    reloadKey: Ref<number, number>;
+    saving: Ref<boolean, boolean>;
+    actionError: Ref<string | undefined, string | undefined>;
     cardTitle: import("vue").ComputedRef<string>;
     readonly: import("vue").ComputedRef<boolean>;
     canCreate: import("vue").ComputedRef<boolean>;