udm-rules-vue 0.0.1

package/dist/connect/webviewHTMLContent.d.ts

@@ -0,0 +1,8 @@
+import { ExtensionContext, Webview } from 'vscode';
+/**
+ * 构建项目连接对应的webview html内容
+ * @param webview webview对象
+ * @param context 插件上下文对象
+ * @returns 返回项目连接对应的webview html内容
+ */
+export declare const buildRuleEditorWebviewHtml: (webview: Webview, context: ExtensionContext) => string;

package/dist/content.d.ts

@@ -0,0 +1,25 @@
+export declare const RULE_PROJECT_PROPERTIES_FILE_NAME = ".ruleproject";
+/**
+ * 规则包meta文件名
+ */
+export declare const RULE_PACKAGE_FILE_NAME = ".rulepackage";
+export declare const RULE_SYNC_ENTRIES_FILE_NAME = ".syncEntries";
+/**
+ * 规则项目类型
+ */
+export declare const TYPE_RULE_PROJECT = "ruleproject";
+/**
+ * 规则包类型
+ */
+export declare const TYPE_RULE_PACKAGE = "rulepackage";
+/**
+ * 绑定的文件类型
+ */
+export declare enum BINDING_FILE_TYPE {
+    RULE_FILE = "Rule",
+    RULE_PACKAGE = "Package"
+}
+/**
+ * XML头部
+ */
+export declare const XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";

package/dist/dispose.d.ts

@@ -0,0 +1,9 @@
+import * as vscode from "vscode";
+export declare function disposeAll(disposables: vscode.Disposable[]): void;
+export declare abstract class Disposable {
+    private _isDisposed;
+    protected _disposables: vscode.Disposable[];
+    dispose(): void;
+    protected _register<T extends vscode.Disposable>(value: T): T;
+    protected get isDisposed(): boolean;
+}

package/dist/dta/DecisionTableComponent.vue.d.ts

@@ -0,0 +1,37 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, Ref, GlobalComponents, GlobalDirectives } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    decisionTableEditorRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        loadFileCallback: () => Promise<any>;
+    }> & Readonly<{
+        "onDecision-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serialize: () => string;
+        setShowQuickTestButton: (value: boolean) => void;
+        showQuickTestButton: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+        "decision-table-editor-mounted": () => any;
+    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        readonlyMonacoEditor: HTMLDivElement;
+        preConditionCodeEditorContainer: HTMLDivElement;
+        contentCodeEditorContainer: HTMLDivElement;
+        tableEditorContainer: HTMLDivElement;
+    }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        loadFileCallback: () => Promise<any>;
+    }> & Readonly<{
+        "onDecision-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serialize: () => string;
+        setShowQuickTestButton: (value: boolean) => void;
+        showQuickTestButton: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;

package/dist/dta/DecisionTableDeserialize.d.ts

@@ -0,0 +1,3 @@
+import { Datatype } from '../model/Datatype';
+import { DecisionTableModel } from './model/DecisionTableModel';
+export declare const deserializeDecisionTable: (xml: string, decisionTableModel: DecisionTableModel) => Map<string, Datatype>;

package/dist/dta/DecisionTableEditor.vue.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, Ref, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    loadFileCallback: () => Promise<any>;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    serialize: () => string;
+    setShowQuickTestButton: (value: boolean) => void;
+    showQuickTestButton: Ref<boolean, boolean>;
+    showQuickTestDialog: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    "decision-table-editor-mounted": () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onDecision-table-editor-mounted"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    readonlyMonacoEditor: HTMLDivElement;
+    preConditionCodeEditorContainer: HTMLDivElement;
+    contentCodeEditorContainer: HTMLDivElement;
+    tableEditorContainer: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/dta/DecisionTableSerialize.d.ts

@@ -0,0 +1,2 @@
+import { DecisionTableModel } from './model/DecisionTableModel';
+export declare const serializeDecisionTable: (model: DecisionTableModel) => string;

package/dist/dta/DecisionTableUtils.d.ts

@@ -0,0 +1,19 @@
+import { ExpressionContext, Method1Context, Method2Context, Method3Context, PrimaryContext } from '../grammar/rule/RuleParser';
+import { Datatype } from '../model/Datatype';
+import { DefinitionType } from './model/Definition';
+import { PlaceholderExpression } from '../model/expression/PlaceholderExpression';
+/**
+ * 通过正则表达式解析出占位符
+ * @param expression 要解析的表达式
+ */
+export declare const parseConditionPlaceholders: (expression: string) => {
+    text: string;
+    start: number;
+    end: number;
+}[];
+/**
+ * 从给定的表达式中，取出不含有占位符表达式的第一个表达式
+ * @param expressionContext 表达式上下文对象
+ */
+export declare const buildWithoutPlaceholderExpression: (expressionContext: ExpressionContext | null) => PrimaryContext | Method1Context | Method2Context | Method3Context | undefined;
+export declare const parsePlaceholders: (expression: string, type: DefinitionType, avaliablePredefineVariablesMap: Map<string, Datatype>) => PlaceholderExpression[];

package/dist/dta/DecisionTableWebEditor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dta/DynamicEditableController.d.ts

@@ -0,0 +1,46 @@
+import { Datatype } from '../model/Datatype';
+import { default as monaco } from '../monaco/customMonaco';
+import { RulePart } from '../utils';
+import { ItemCell } from './model/ItemCell';
+/**
+ * 实现代码编辑器的动态可部分编辑区域
+ *
+ * 可编辑区域由多个可编辑范围组成，每个可编辑范围由起始行号、起始列号、结束行号、结束列号组成
+ */
+export declare class DynamicEditableController {
+    private readonly editPart;
+    private readonly editor;
+    private readonly loadAvaliablePredefineVariablesMapCallback;
+    private readonly CSS_EDITABLE;
+    private readonly CSS_READONLY;
+    private editableRanges;
+    private itemCell?;
+    constructor(editPart: {
+        part: RulePart;
+    }, editor: monaco.editor.IStandaloneCodeEditor, loadAvaliablePredefineVariablesMapCallback: () => Map<string, Datatype>);
+    getAvaliablePredefineVariablesMap(): Map<string, Datatype>;
+    getAvaliablePredefineVariablesMapCallback(): () => Map<string, Datatype>;
+    disableContentEditor(): void;
+    setContent(content: string, itemCell: ItemCell): void;
+    /**
+     * 当点击列头时，显示当前列头中配置的脚本内容
+     * @param script 要显示的脚本内容
+     */
+    showScript(script: string): void;
+    private initEventListeners;
+    private updateItemCellValue;
+    private updateDecorations;
+    private createEditableDecorations;
+    private createReadonlyDecorations;
+    private inEditableRange;
+    private adjustEditableRanges;
+    private findTargetEditableRangeIndex;
+    private isPositionEditable;
+    private findNearestEditablePos;
+    private toNewMonacoRange;
+    private rangeContains;
+    private getStartLineNumber;
+    private getEndLineNumber;
+    private getStartColumn;
+    private getEndColumn;
+}

package/dist/dta/PureWebDecisionTableEditor.vue.d.ts

@@ -0,0 +1,59 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, Ref, GlobalComponents, GlobalDirectives } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    loadFileCallback: () => Promise<any>;
+    loadBomFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+    loadVocFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+    loadVarFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+    loadProjectFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    serialize: () => any;
+    showQuickTestDialog: () => any;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    decisionTableEditor: CreateComponentPublicInstanceWithMixins<Readonly<{
+        loadFileCallback: () => Promise<any>;
+    }> & Readonly<{
+        "onDecision-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serialize: () => string;
+        setShowQuickTestButton: (value: boolean) => void;
+        showQuickTestButton: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+        "decision-table-editor-mounted": () => any;
+    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        readonlyMonacoEditor: HTMLDivElement;
+        preConditionCodeEditorContainer: HTMLDivElement;
+        contentCodeEditorContainer: HTMLDivElement;
+        tableEditorContainer: HTMLDivElement;
+    }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        loadFileCallback: () => Promise<any>;
+    }> & Readonly<{
+        "onDecision-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serialize: () => string;
+        setShowQuickTestButton: (value: boolean) => void;
+        showQuickTestButton: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;

package/dist/dta/component/ColumnNameBuilder.d.ts

@@ -0,0 +1,2 @@
+export declare const buildDefaultHeaderName: (columnIndex: number) => string;
+export declare const isDefaultHeaderName: (headerName: string) => boolean;

package/dist/dta/component/DecisionTable.d.ts

@@ -0,0 +1,136 @@
+import { Datatype } from '../../model/Datatype';
+import { DynamicEditableController } from '../DynamicEditableController';
+import { DecisionTableModel } from '../model/DecisionTableModel';
+import { Definition, DefinitionType } from '../model/Definition';
+import { ItemCell } from '../model/ItemCell';
+import { default as DecisionTableCrossHeader } from './DecisionTableCrossHeader';
+import { default as DecisionTableHeader } from './DecisionTableHeader';
+import { default as DecisionTableRowIndicate } from './DecisionTableRowIndicate';
+export declare const SELECTION_CELL = "selectionCell";
+export declare class DecisionTable {
+    private readonly container;
+    private readonly editorDynamicEditableController;
+    readonly loadPredefineConditionScriptCallback: () => string;
+    private model;
+    private headerFloatTable;
+    private indicateRowFloatTable;
+    private crossHeaderFloatTable;
+    /**
+     * 记录当前处于选中状态的所有单元格对象
+     */
+    private highlightCellsSet;
+    private selectionCells;
+    private readonly table;
+    private readonly headerSection;
+    private readonly bodySection;
+    private readonly redoUndoManager;
+    private readonly inputEditor;
+    /**
+     * 记录所有的列头对象
+     */
+    private readonly headerDefinitions;
+    /**
+     * 记录header的id和header对象的映射关系
+     */
+    private readonly headerIdMap;
+    /**
+     * 用一个WeakMap记录列头单元格与列头对象的映射关系，这里采用的是一个WeakMap对象，因为WeakMap对象的键是弱引用的，所以当键所引用的对象被垃圾回收时，WeakMap对象会自动删除对应的键值对
+     *
+     * 需要注意的是，这里关联的单元格key对象为浮动表头里的单元格对象，而不是内容单元格中列头单元格对象
+     */
+    private readonly headersMap;
+    /**
+     * 用于记录内容部分的单元格与内容对象的映射关系，这里采用的是一个WeakMap对象，因为WeakMap对象的键是弱引用的，所以当键所引用的对象被垃圾回收时，WeakMap对象会自动删除对应的键值对
+     */
+    private readonly contentCellWeakMap;
+    constructor(container: HTMLElement, editorDynamicEditableController: DynamicEditableController, loadPredefineConditionScriptCallback: () => string);
+    init(): void;
+    changeDarkMode(darkMode: boolean): void;
+    initFromModel(avaliablePredefineVariablesMap: Map<string, Datatype>): void;
+    deleteHeader(columnIndex: number): void;
+    /**
+     * 创建决策表需要的子列头行信息，这是在当前决策表中没有子列头行的时候需要创建的。
+     *
+     * 创建的子列头行信息包括：主表格的子列头行，浮动表头的子列头行，以及浮动交叉表头的子列头行。
+     */
+    createSubHeaderRow(): void;
+    copySelectionCells(): void;
+    pasteCopyCellsValue(): void;
+    getAvaliablePredefineVariablesMap(): Map<string, Datatype>;
+    getAvaliablePredefineVariablesMapCallback(): () => Map<string, Datatype>;
+    showScript(script: string): void;
+    /**
+     * 删除决策表需要的子列头行信息，这是在当前决策表中存在子列头行的时候需要删除的。
+     *
+     * 删除的子列头行信息包括：主表格的子列头行，浮动表头的子列头行，以及浮动交叉表头的子列头行。
+     */
+    deleteSubHeaderRow(): void;
+    /**
+     * 根据插入行的参考单元格，插入新行
+     * @param refCell 插入行的参考单元格，用于确定新行的插入位置
+     * @param before 是否在参考单元格之前插入新行，默认为false，表示在参考单元格之后插入新行
+     * @param otherwise 是否是否则行，默认为false，表示不是否则行
+     */
+    insertRow(refCell: ItemCell, before: boolean, otherwise?: boolean): void;
+    cleanSelectionCells(): void;
+    cleanCell(refCell: ItemCell): void;
+    splitMergeCells(): void;
+    getSelectedCells(): HTMLTableCellElement[];
+    mergeSelectedCells(): void;
+    splitSelectedCell(): void;
+    deleteRow(rowIndex: number, refCell: HTMLTableCellElement): void;
+    createIndicateRow(newRowIndex: number): HTMLTableRowElement;
+    /**
+     * 根据当前列头信息的变化，判断是否还需要子表头，如果需要表头就需要重新构建子表头，包含子表头所在行以及单元格信息等
+     * @param oldDefinition 旧表头对象
+     * @param newDefinition 新表头对象
+     */
+    rebuildSubHeader(oldDefinition: Definition, newDefinition: Definition): void;
+    changeHeader(oldDefinition: Definition, newDefinition: Definition): void;
+    insertHeader(columnIndex: number, type: DefinitionType): void;
+    insertContentCell(row: HTMLTableRowElement, itemCell: ItemCell, cellIndex?: number): HTMLTableCellElement;
+    private bindingEditor;
+    private bindingCellEvents;
+    private checkCellContentError;
+    private cleanCellError;
+    private setCellError;
+    buildResizeRowCallback(): (rowIndex: number, newHeight: number) => void;
+    getTargetBodyRow(rowIndex: number): HTMLTableRowElement;
+    buildHighlightRowCallback(): (rowIndex: number, add: boolean) => void;
+    buildHeaderResizeCallback(): (rowIndex: number, columnIndex: number, newWidth: number) => void;
+    buildHeaderHighlightCallback(): (cellIndex: number, add: boolean) => void;
+    rowResize(rowIndex: number, newHeight: string): void;
+    private intDragSelectionCellEvent;
+    private doDragSelecCells;
+    highlightCellEventBinding(itemCell: ItemCell): void;
+    highlightItemCells(itemCell: ItemCell): void;
+    private resetCellStyle;
+    private doHighlightTargetRowCells;
+    doHighlightTargetColumnCells(columnIndex: number, add: boolean): void;
+    private triggerSelectionCellEvent;
+    private findTargetPartition;
+    addHeaderDefinition(definition: Definition, index?: number): void;
+    resetDefaultHeaderName(index?: number): void;
+    buildNewColumnId(type: DefinitionType): string;
+    doHighlightCell(td: HTMLTableCellElement, add: boolean): void;
+    doCancelHighlight(): void;
+    isRowColumnHighlight(): boolean;
+    getHighlightCells(): Set<HTMLTableCellElement>;
+    removeHeaderDefinition(columnIndex: number): void;
+    applyHeaderDefinitionStyle(headerDefinition: Definition): void;
+    private resetTableCellStyle;
+    getModel(): DecisionTableModel;
+    getHeaderSection(): HTMLTableSectionElement;
+    getBodySection(): HTMLTableSectionElement;
+    getHeaderFloatTable(): DecisionTableHeader;
+    getIndicateRowFloatTable(): DecisionTableRowIndicate;
+    getCrossHeaderFloatTable(): DecisionTableCrossHeader;
+    getHeaderIdMap(): Map<string, Definition>;
+    getHeadersMap(): WeakMap<HTMLTableCellElement, Definition>;
+    getHeaderDefinitions(): Definition[];
+    getItemCellByContentCell(contentCell: HTMLTableCellElement): ItemCell | undefined;
+}
+export declare enum HeaderPosition {
+    before = 0,
+    after = 1
+}

package/dist/dta/component/DecisionTableCrossHeader.d.ts

@@ -0,0 +1,11 @@
+export default class DecisionTableCrossHeader {
+    readonly table: HTMLTableElement;
+    private readonly headerSection;
+    constructor(container: HTMLElement);
+    changeDarkMode(darkMode: boolean): void;
+    private bindingContainerScrollEvent;
+    initHeaderRowIndicate(): HTMLTableRowElement;
+    initSubHeaderRow(): HTMLTableRowElement;
+    deleteSubHeaderRow(): void;
+    getHeaderSection(): HTMLTableSectionElement;
+}

package/dist/dta/component/DecisionTableHeader.d.ts

@@ -0,0 +1,30 @@
+import { Definition } from '../model/Definition';
+import { DecisionTable } from './DecisionTable';
+export default class DecisionTableHeader {
+    private decitionTable;
+    readonly table: HTMLTableElement;
+    private readonly headerSection;
+    /**
+     * 记录当前处于选中状态的列单元格对象
+     */
+    private highlightColumnCell;
+    constructor(container: HTMLElement, decitionTable: DecisionTable);
+    changeDarkMode(darkMode: boolean): void;
+    /**
+     * 修改浮动表头内容，以及将新表头对象与当前单元格进行绑定
+     * @param newDefinition 新的表头对象
+     */
+    changeHeader(newDefinition: Definition): void;
+    private bindingContainerScrollEvent;
+    initHeaderRowAndIndicateCell(): void;
+    initSubHeaderRow(): void;
+    deleteSubHeaderRow(): void;
+    getHeaderRow(): HTMLTableRowElement;
+    getSubHeaderRow(): HTMLTableRowElement;
+    cancelHighlightColumn(): void;
+    getHightlightColumnCell(): HTMLTableCellElement | null;
+    insertHeaderCell(headerDefinitionIndex: number, resizeColumnCallback: (rowIndex: number, columnIndex: number, newWidth: number) => void, highlightColumnCallback: (cellIndex: number, add: boolean) => void, actionHeader: boolean): HTMLTableCellElement;
+    private bindingHighlightColumnEvent;
+    private bindingColumnResizer;
+    getHeaderSection(): HTMLTableSectionElement;
+}

package/dist/dta/component/DecisionTableRowIndicate.d.ts

@@ -0,0 +1,27 @@
+import { DecisionTable } from './DecisionTable';
+export default class DecisionTableIndicateRow {
+    readonly table: HTMLTableElement;
+    private decisionTable;
+    private readonly headerSection;
+    private readonly bodySection;
+    /**
+     * 记录当行处于选中状态的行对象
+     */
+    private highlightIndicateRowCell;
+    constructor(container: HTMLElement, decisionTable: DecisionTable);
+    changeDarkMode(darkMode: boolean): void;
+    private bindingContainerScrollEvent;
+    initHeaderIndicateRow(): HTMLTableRowElement;
+    initSubHeaderRow(): HTMLTableRowElement;
+    deleteSubHeaderRow(): void;
+    deleteIndicateRow(rowIndex: number, rowCount: number): void;
+    rowResize(rowIndex: number, newHeight: string): void;
+    createBodyIndicateRow(text: string, resizeRowCallback: (rowIndex: number, newHeight: number) => void, highlightRowCallback: (rowIndex: number, add: boolean) => void, newRowIndex?: number): HTMLTableRowElement;
+    cancelHighlight(): void;
+    getHightlightIndicateRowCell(): HTMLTableCellElement | null;
+    private highlightRowEventBinding;
+    private bindingRowResizer;
+    private findFirstActionItemCellByRow;
+    getBodySection(): HTMLTableSectionElement;
+    getHeaderSection(): HTMLTableSectionElement;
+}

package/dist/dta/component/contentContextMenuEvent.d.ts

@@ -0,0 +1,3 @@
+import { ItemCell } from '../model/ItemCell';
+import { DecisionTable } from './DecisionTable';
+export declare const doBindingContentContextMenu: (itemCell: ItemCell, table: DecisionTable) => void;

package/dist/dta/component/edit/ContentChangeEdit.d.ts

@@ -0,0 +1,11 @@
+import { ViewEdit } from '../../../view&document';
+export declare class ContentChangeEdit implements ViewEdit {
+    private readonly cellPath;
+    private readonly oldContent;
+    private readonly newContent;
+    readonly type = "contentChange";
+    constructor(cellPath: string, oldContent: string, newContent: string);
+    getCellPath(): string;
+    getOldContent(): string;
+    getNewContent(): string;
+}

package/dist/dta/component/edit/DeleteHeaderEdit.d.ts

@@ -0,0 +1,7 @@
+import { ViewEdit } from '../../../view&document';
+export declare class DeleteHeaderEdit implements ViewEdit {
+    private readonly _headerIndex;
+    readonly type = "deleteHeader";
+    constructor(_headerIndex: number);
+    get headerIndex(): number;
+}

package/dist/dta/component/edit/DeleteRowEdit.d.ts

@@ -0,0 +1,7 @@
+import { ViewEdit } from '../../../view&document';
+export declare class DeleteRowEdit implements ViewEdit {
+    private readonly _rowIndex;
+    readonly type = "deleteRow";
+    constructor(_rowIndex: number);
+    get rowIndex(): number;
+}

package/dist/dta/component/edit/HeaderChangeEdit.d.ts

@@ -0,0 +1,7 @@
+import { ViewEdit } from '../../../view&document';
+export declare class HeaderChangeEdit implements ViewEdit {
+    private readonly _headerIndex;
+    readonly type = "headerChange";
+    constructor(_headerIndex: number);
+    get headerIndex(): number;
+}

package/dist/dta/component/edit/HeaderWidthChangeEdit.d.ts

@@ -0,0 +1,9 @@
+import { ViewEdit } from '../../../view&document';
+export declare class HeaderWidthChangeEdit implements ViewEdit {
+    private readonly _columnIndex;
+    private readonly _width;
+    readonly type = "headerWidthChange";
+    constructor(_columnIndex: number, _width: number);
+    get columnIndex(): number;
+    get width(): number;
+}

package/dist/dta/component/edit/InsertHeaderEdit.d.ts

@@ -0,0 +1,7 @@
+import { ViewEdit } from '../../../view&document';
+export declare class InsertHeaderEdit implements ViewEdit {
+    private readonly _headerIndex;
+    readonly type = "insertHeader";
+    constructor(_headerIndex: number);
+    get headerIndex(): number;
+}

package/dist/dta/component/edit/InsertRowEdit.d.ts

@@ -0,0 +1,7 @@
+import { ViewEdit } from '../../../view&document';
+export declare class InsertRowEdit implements ViewEdit {
+    private readonly _rowIndex;
+    readonly type = "insertRow";
+    constructor(_rowIndex: number);
+    get rowIndex(): number;
+}

package/dist/dta/component/edit/RowHeightChangeEdit.d.ts

@@ -0,0 +1,9 @@
+import { ViewEdit } from '../../../view&document';
+export declare class RowHeightChangeEdit implements ViewEdit {
+    private readonly _rowIndex;
+    private readonly _height;
+    readonly type = "rowHeightChange";
+    constructor(_rowIndex: number, _height: number);
+    get rowIndex(): number;
+    get height(): number;
+}

package/dist/dta/component/edit/RowMoveEdit.d.ts

@@ -0,0 +1,7 @@
+import { ViewEdit } from '../../../view&document';
+export declare class RowMoveEdit implements ViewEdit {
+    rowIndex: number;
+    moveDirection: "up" | "down";
+    type: string;
+    constructor(rowIndex: number, moveDirection: "up" | "down");
+}

package/dist/dta/component/edit/StyleChangeEdit.d.ts

@@ -0,0 +1,16 @@
+import { ViewEdit } from '../../../view&document';
+import { Cell } from '../../model/Cell';
+export declare class StyleChangeEdit implements ViewEdit {
+    readonly type = "styleChange";
+    target: "header" | "cell";
+    style: string;
+    format?: string;
+    align?: string;
+    valign?: string;
+    foreColor?: string;
+    backColor?: string;
+    width?: string;
+    height?: string;
+    comment?: string;
+    constructor(cell: Cell);
+}

package/dist/dta/component/headerContextMenuEvent.d.ts

@@ -0,0 +1,2 @@
+import { DecisionTable } from './DecisionTable';
+export declare const doBindingHeaderContextMenu: (td: HTMLTableCellElement, table: DecisionTable) => void;

package/dist/dta/component/operationContextMenuBuilder.d.ts

@@ -0,0 +1,4 @@
+import { MenuItem } from '../../components/menu/types';
+import { Datatype } from '../../model/Datatype';
+import { ConditionItem } from '../model/ConditionItem';
+export declare const buildOperationMenuByDatatype: (menuItem: MenuItem<string>, datatype: Datatype, item: ConditionItem, callback?: () => void) => void;

package/dist/dta/component/operator/ColumnDelete.d.ts

@@ -0,0 +1,10 @@
+import { DecisionTable } from '../DecisionTable';
+export declare class ColumnDelete {
+    private table;
+    private model;
+    constructor(table: DecisionTable);
+    deleteColumn(columnIndex: number): void;
+    private deleteContentCells;
+    private deleteConditionHeader;
+    private deleteActionHeader;
+}

package/dist/dta/component/operator/ColumnInsert.d.ts

@@ -0,0 +1,14 @@
+import { DefinitionType } from '../../model/Definition';
+import { DecisionTable } from '../DecisionTable';
+export declare class ColumnInsert {
+    private readonly table;
+    private readonly model;
+    constructor(table: DecisionTable);
+    /**
+     * 在表格中插入一列，并将其插入到指定的列索引位置
+     * @param columnIndex 列对象索引，是不包含第一行中的标识单元格的索引
+     * @param type 列类型，是动作列还是条件列
+     */
+    insertColumn(columnIndex: number, type: DefinitionType): void;
+    private insertContentCells;
+}

package/dist/dta/component/operator/HeaderChange.d.ts

@@ -0,0 +1,15 @@
+import { Definition } from '../../model/Definition';
+import { DecisionTable } from '../DecisionTable';
+/**
+ * 如果列头绑定表达式发生变化，那么就调用这个类实现。
+ *
+ * 变化的内容主要是表达式的占位符发生变化，包含数量以及类型。
+ */
+export declare class HeaderChange {
+    private readonly table;
+    private readonly model;
+    constructor(table: DecisionTable);
+    changeHeader(oldDefinition: Definition, newDefinition: Definition): void;
+    private changeContentCell;
+    private buildTargetHeaderContentCells;
+}

package/dist/dta/component/operator/MergeSelectedCells.d.ts

@@ -0,0 +1,8 @@
+import { DecisionTable } from '../DecisionTable';
+export declare class MergeSelectedCells {
+    private readonly table;
+    private readonly model;
+    constructor(table: DecisionTable);
+    doMerge(): void;
+    private removeNonFirstCellConditions;
+}

package/dist/dta/component/operator/ModelInitializer.d.ts

@@ -0,0 +1,18 @@
+import { Datatype } from '../../../model/Datatype';
+import { DecisionTable } from '../DecisionTable';
+export declare class ModelInitializer {
+    private table;
+    private model;
+    private avaliablePredefineVariablesMap;
+    constructor(table: DecisionTable, avaliablePredefineVariablesMap: Map<string, Datatype>);
+    initialize(): void;
+    /**
+     * 初始化指定位置的列头对象
+     * @param index 列头的位置
+     * @returns 返回新插入的列头单元格对象
+     */
+    initHeader(index: number): HTMLTableCellElement;
+    private initSubHeader;
+    private initPartition;
+    private initActions;
+}