udm-rules-vue 0.0.1

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

@@ -0,0 +1,14 @@
+import { DecisionTable } from '../DecisionTable';
+export declare class RowDelete {
+    private table;
+    private model;
+    constructor(table: DecisionTable);
+    /**
+     * 根据索引删除一内容行
+     * @param rowIndex 当前要删除的内容行在body中的索引
+     * @param refCell 参考单元格
+     */
+    deleteRow(rowIndex: number, refCell: HTMLTableCellElement): void;
+    private deleteTargetRowCondition;
+    private shrinkParentCellRowSpan;
+}

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

@@ -0,0 +1,32 @@
+import { ItemCell } from '../../model/ItemCell';
+import { DecisionTable } from '../DecisionTable';
+export declare class RowInsertOperator {
+    private table;
+    private model;
+    constructor(table: DecisionTable);
+    /**
+     * 根据插入行的参考单元格，插入新行
+     * @param refCell 插入行的参考单元格，用于确定新行的插入位置
+     * @param before 是否在参考单元格之前插入新行，默认为false，表示在参考单元格之后插入新行
+     * @param otherwise 是否是否则行，默认为false，表示不是否则行
+     */
+    insertRow(refCell: ItemCell, before: boolean, otherwise?: boolean): void;
+    /**
+     * 根据给出的分区对象，递归将父分区中的所有单元格的rowspan属性加1
+     *
+     * 在执行这些操作时，还需要判断父单元格对应行的位置，如果父单元格对应行位于当前新行之下，
+     * 那么就需要将父分区中对应的这些需要将rowspan属性加1的单元格移到新行当中，原行中需要删除这些单元格
+     * @param parentCondition 父条件对象
+     * @param newRow 新行对象
+     */
+    private increaseParentPartitionRowspan;
+    private insertNewPartitionCells;
+    /**
+     * 根据给出的动作列起始索引，插入新的动作列单元格
+     * @param nextHeaderIndex 动作列的开始索引
+     * @param newRow 新行对象
+     * @param conditionItem 条件项对象
+     * @param partition 对应的分区对象
+     */
+    private insertActionCells;
+}

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

@@ -0,0 +1,7 @@
+import { DecisionTable } from '../DecisionTable';
+export declare class SplitSelectedCell {
+    private readonly table;
+    private readonly model;
+    constructor(table: DecisionTable);
+    doSplit(): void;
+}

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

@@ -0,0 +1,18 @@
+import { Definition } from '../../model/Definition';
+import { DecisionTable } from '../DecisionTable';
+/**
+ * 子表头构建器，根据当前列头定义情况决定是否创建子表头或者删除已存在的子表头
+ */
+export declare class SubHeaderBuilder {
+    private readonly table;
+    private readonly model;
+    constructor(table: DecisionTable);
+    buildSubHeader(oldDefinition: Definition, newDefinition: Definition): void;
+    /**
+     * 在修改表头后，新表头中存在子表头，需要更新当前子表头
+     * @param oldDefinition 旧表头对象
+     * @param newDefinition 新表头对象
+     */
+    private buildNewSubHeaders;
+    private buildExistSubHeader;
+}

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

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

package/dist/dta/dialog/CellStyleDialog.vue.d.ts

@@ -0,0 +1,28 @@
+import { Cell } from '../model/Cell';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, GlobalComponents, GlobalDirectives } from '../../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    styleComponent: CreateComponentPublicInstanceWithMixins<Readonly<{
+        darkMode: boolean;
+        cell: Cell;
+    }> & Readonly<{}>, {
+        changeValue: () => void;
+        resetValue: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        darkMode: boolean;
+        cell: Cell;
+    }> & Readonly<{}>, {
+        changeValue: () => void;
+        resetValue: () => void;
+    }, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+export default _default;

package/dist/dta/dialog/EditColumnDialog.vue.d.ts

@@ -0,0 +1,8 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    codeEditorContainer: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/dta/dialog/Style.vue.d.ts

@@ -0,0 +1,11 @@
+import { Cell } from '../model/Cell';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+    cell: Cell;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    changeValue: () => void;
+    resetValue: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/dta/dialog/events.d.ts

@@ -0,0 +1,2 @@
+export declare const SHOW_EDIT_CONDITION_COLUMN_DIALOG = "SHOW_EDIT_CONDITION_COLUMN_DIALOG";
+export declare const SHOW_STYLE_DIALOG = "SHOW_STYLE_DIALOG";

package/dist/dta/model/ActionItem.d.ts

@@ -0,0 +1,12 @@
+import { ConditionItem } from './ConditionItem';
+import { Definition } from './Definition';
+import { Item } from './Item';
+export declare class ActionItem extends Item {
+    /**
+     * 当前动作项在哪个条件项下
+     */
+    private conditionItem;
+    constructor(conditionItem: ConditionItem, definition: Definition);
+    resetConditionItem(conditionItem: ConditionItem): void;
+    getConditionItem(): ConditionItem;
+}

package/dist/dta/model/Cell.d.ts

@@ -0,0 +1,59 @@
+import { Definition } from './Definition';
+import { Style } from './Style';
+export declare class Cell {
+    private format?;
+    private style?;
+    private align?;
+    private valign?;
+    private foreColor?;
+    private backColor?;
+    /**
+     * 内容变更回调函数,仅供决策树节点使用
+     */
+    private valueChangeCallback?;
+    private width?;
+    private height?;
+    /**
+     * 当前单元格显示的文本
+     */
+    private text?;
+    constructor(text?: string);
+    renderStyle(headerDefinition: Definition, tableCell: HTMLTableCellElement): void;
+    setAttribute(key: string, value: string, whole: boolean): void;
+    static parseAlignment(alignment: string): Alignment | undefined;
+    getWidth(): string | undefined;
+    setWidth(width: string): void;
+    getHeight(): string | undefined;
+    setHeight(height: string): void;
+    getFormat(): string | undefined;
+    setFormat(format: string): void;
+    getAlign(): AttributeValue<Alignment> | undefined;
+    setAlign(attributeValue: AttributeValue<Alignment> | undefined): void;
+    getValign(): AttributeValue<Alignment> | undefined;
+    setValign(attributeValue: AttributeValue<Alignment> | undefined): void;
+    getForeColor(): AttributeValue<string> | undefined;
+    setForeColor(attributeValue: AttributeValue<string> | undefined): void;
+    getBackColor(): AttributeValue<string> | undefined;
+    setBackColor(attributeValue: AttributeValue<string> | undefined): void;
+    getStyle(): Style | undefined;
+    setStyle(style: Style | undefined): void;
+    getText(): string | undefined;
+    getItem(): any;
+    setText(text: string): void;
+    registerValueChangeCallback(callback: (label: string) => void): void;
+}
+export declare enum Alignment {
+    Near = "Near",
+    Far = "Far",
+    Center = "Center",
+    Top = "Top",
+    Bottom = "Bottom",
+    Middle = "Middle"
+}
+export declare class AttributeValue<T> {
+    private value;
+    private whole;
+    constructor(value: T, whole: boolean);
+    getValue(): T;
+    isWhole(): boolean;
+}

package/dist/dta/model/ConditionItem.d.ts

@@ -0,0 +1,37 @@
+import { PreconditionContext } from '../../grammar/rule/RuleParser';
+import { ActionItem } from './ActionItem';
+import { Item } from './Item';
+import { Partition } from './Partition';
+export declare class ConditionItem extends Item {
+    /**
+     * 重定义脚本，在编辑器中通过右键菜单进行修改，如果为空则采用当前单元格对应的列定义的脚本。
+     */
+    private text?;
+    /**
+     * 当前条件下如果存在动作，那么这里就用来标识当前动作对应的规则名，这里仅用于决策树中，用来在决策树的动作节点中显示当前条件下动作对应的规则名。
+     * 这里仅用于显示，不会用在生成的规则脚本中。
+     */
+    private actionComment?;
+    private childPartition?;
+    private actions;
+    constructor(partition: Partition);
+    toScript(): string;
+    buildRuleScript(preconditionContext?: PreconditionContext): string | string[];
+    buildChildrenCount(): number;
+    /**
+     * 在设置了重定义脚本后，需要根本脚本内容中的参数占位符重新定义其下的ItemCell对象，如果占位符数量大于ItemCell数量，则需要创建新的ItemCell对象，
+     * 如果重定义脚本占位符数量小于ItemCell数量，那么就保持旧数据不动。
+     */
+    rebuildItems(): void;
+    setText(text?: string): void;
+    getText(): string | undefined;
+    setChildPartition(partition: Partition | undefined): void;
+    getChildPartition(): Partition | undefined;
+    getActions(): ActionItem[];
+    /**
+     * 设置当前条件下如果存在动作，那么这里就用来标识当前动作对应的规则名，这里仅用于决策树中，用来在决策树的动作节点中显示当前条件下动作对应的规则名。
+     * 这里仅用于显示，不会用在生成的规则脚本中。
+     */
+    setActionComment(comment?: string): void;
+    getActionComment(): string | undefined;
+}

package/dist/dta/model/DecisionTableModel.d.ts

@@ -0,0 +1,89 @@
+import { RuleProperty } from '../../model/expression/RuleExpression';
+import { ConditionItem } from './ConditionItem';
+import { Definition } from './Definition';
+import { Partition } from './Partition';
+import { ResourceData } from './ResourceData';
+export declare class DecisionTableModel {
+    private name;
+    private uuid;
+    private effectiveDate;
+    private quickTestData;
+    private expirationDate;
+    private priority;
+    private status;
+    private locale;
+    private documentation;
+    private preconditions;
+    /**
+     * 用于标识当前决策表中是否存在子列头
+     */
+    private existSubHeader;
+    private partiton;
+    private readonly properties;
+    private readonly resources;
+    /**
+     * 存储当前决策表的所有条件和动作列头定义
+     */
+    private readonly definitions;
+    private readonly conditionDefinitions;
+    private readonly actionDefinitions;
+    /**
+     * 将conditionDefinitions以及actionDefinitions中的Definition对象添加到headerMap中
+     */
+    private headerMap;
+    /**
+     * 根据行号，找到对应的最后一个条件项，以供规则脚本提示使用
+     * @param targetRowIndex 行号，从0开始
+     * @param targetPartition 目标分区
+     */
+    loadTargetLastCondition(targetRowIndex: number, parentConditionIndex: number, targetPartition?: Partition): ConditionItem | undefined;
+    changeDefinition(oldDefinition: Definition, newDefinition: Definition): void;
+    addResource(data: ResourceData): void;
+    /**
+     * 在决策表序列化时，会省略掉部分列头未定义表达式的条件项，所以在解析资源对应的格式信息时需要获取当前条件下最后一个条件对应的动作信息
+     * @param condition 条件对象
+     * @returns 返回当前条件项下最后一个条件项里的动作
+     */
+    private findLastConditionActions;
+    /**
+     * 当前idPart的内容可能是(C1)，也可能是(C1)[0],解析时使用正则，返回一个对象，里面包含两个元素
+     * @param idPart 要解析的内容
+     */
+    private parseHeaderDefinition;
+    private isNumber;
+    addDefinition(definition: Definition, index?: number): void;
+    removeDefinition(definition: Definition): void;
+    toXml(): string;
+    getTargetConditionDefinition(definitionId: string): Definition | undefined;
+    getTargetActionDefinition(definitionId: string): Definition | undefined;
+    setPartition(partition: Partition): void;
+    setName(name: string): void;
+    getName(): string;
+    setUuid(uuid: string): void;
+    getUuid(): string;
+    setStatus(status: string): void;
+    getStatus(): string;
+    setLocale(locale: string): void;
+    getLocale(): string;
+    setEffectiveDate(effectiveDate: string): void;
+    getEffectiveDate(): string;
+    setQuickTestData(quickTestData: string): void;
+    getQuickTestData(): string;
+    setExpirationDate(expirationDate: string): void;
+    getExpirationDate(): string;
+    setPriority(priority: string): void;
+    getPriority(): string;
+    setDocumentation(documentation: string): void;
+    getDocumentation(): string;
+    setPreconditions(preconditions: string): void;
+    getPreconditions(): string;
+    getHeaderMap(): Map<string, Definition>;
+    isExistSubHeader(): boolean;
+    setExistSubHeader(existSubHeader: boolean): void;
+    getProperties(): RuleProperty[];
+    getPartiton(): Partition;
+    getResources(): ResourceData[];
+    getDefinitions(): Definition[];
+    getConditionDefinitions(): Definition[];
+    getActionDefinitions(): Definition[];
+}

package/dist/dta/model/Definition.d.ts

@@ -0,0 +1,31 @@
+import { Datatype } from '../../model/Datatype';
+import { PlaceholderExpression } from '../../model/expression/PlaceholderExpression';
+import { HeaderCell } from './HeaderCell';
+export declare class Definition extends HeaderCell {
+    private id;
+    private expression;
+    private type;
+    private expressionChangeCallback?;
+    /**
+     * 用于存储expression中占位符所有占位符的名称
+     */
+    private placeholders;
+    constructor(id: string, expression: string, type: DefinitionType, avaliablePredefineVariablesMap: Map<string, Datatype>);
+    /**
+     * 返回当前列定义对象在具体表格列头中的列索引值，这个值在计算时要考虑当前所在列头前面单元格的colspan值
+     * @returns 列索引
+     */
+    getColumnIndex(): number;
+    clone(expression: string, avaliablePredefineVariablesMap: Map<string, Datatype>): Definition;
+    registerExpressionChangeCallback(callback: (expression: string) => void): void;
+    getId(): string;
+    getType(): DefinitionType;
+    getExpression(): string;
+    setExpression(expression: string): void;
+    getPlaceholders(): PlaceholderExpression[];
+    setPlaceholders(placeholders: PlaceholderExpression[]): void;
+}
+export declare enum DefinitionType {
+    Action = 0,
+    Condition = 1
+}

package/dist/dta/model/HeaderCell.d.ts

@@ -0,0 +1,16 @@
+import { Cell } from './Cell';
+import { SubHeader } from './SubHeader';
+export declare class HeaderCell extends Cell {
+    private targetTableHeaderCell?;
+    private targetFloatTableHeaderCell?;
+    /**
+     * 子列头，如果当前列对应的表达式中存在一个以上的点位符，那么就需要定义子列头，如果只有一个点位符，那么就不需要定义子列头
+     */
+    private subHeaders;
+    setTargetTableHeaderCell(cell: HTMLTableCellElement): void;
+    getTargetTableHeaderCell(): HTMLTableCellElement | undefined;
+    setTargetFloatTableHeaderCell(cell: HTMLTableCellElement): void;
+    getTargetFloatTableHeaderCell(): HTMLTableCellElement | undefined;
+    getSubHeaders(): SubHeader[];
+    setSubHeaders(subHeaders: SubHeader[]): void;
+}

package/dist/dta/model/Item.d.ts

@@ -0,0 +1,31 @@
+import { Definition } from './Definition';
+import { ItemCell } from './ItemCell';
+import { Partition } from './Partition';
+export declare abstract class Item {
+    private definition;
+    private partition;
+    /**
+     * 对应当前单元格列头的子列头数量，存储的就是列头表达式对应的具体参数值，如果当前条件项设置了重定义表达式，
+     * 那么这个的数量可能与子列头数量不一致，重定义表达式中可能存在多个参数，但当前列头可能只有一个参数，但这里为了能存储重定义表达式对应的参数值，
+     * 这里仍然会有两个ItemCell对象，分别对应重定义表达式中的两个占位符参数值，在这种情况下，尽管这里的参数数量与子列头数量不一致，但在创建单元格时，
+     * 还是以子列头数量为准，比如子列头数量为1，这里ItemCell数量为2，创建单元格时还是只创建一个，而不是两个。
+     */
+    private params;
+    /**
+     * 内容变更回调函数,仅供决策树节点使用
+     */
+    private valueChangeCallback?;
+    constructor(partition: Partition, definition: Definition);
+    removeItemCell(targetItemCell: ItemCell): void;
+    buildItemScript(): string;
+    /**
+     * 注册内容变更回调函数,仅供决策树节点使用
+     */
+    registerValueChangeCallback(callback: () => void): void;
+    getValueChangeCallback(): (() => void) | undefined;
+    getPartition(): Partition;
+    setPartition(partition: Partition): void;
+    getDefinition(): Definition;
+    setDefinition(definition: Definition): void;
+    getParams(): ItemCell[];
+}

package/dist/dta/model/ItemCell.d.ts

@@ -0,0 +1,46 @@
+import { PlaceholderExpression } from '../../model/expression/PlaceholderExpression';
+import { DecisionTable } from '../component/DecisionTable';
+import { Cell } from './Cell';
+import { Item } from './Item';
+import { Partition } from './Partition';
+export declare class ItemCell extends Cell {
+    private item;
+    private otherwise?;
+    private partition;
+    /**
+     * 当前单元格对应的表格单元格对象,这里的表格单元格对象可能为空，如在当前是条件单元格，且设置了重定义表表达式后，重定义表达式中参数数量大于当前列头参数数量时，
+     * 就需要创建额外的ItemCell来存在重定义表达式中对应的参数值，这里额外创建的单元格就不存在对应的表格单元格对象。
+     */
+    private tableCell?;
+    /**
+     * 当前单元格对应列头的占位符表达式，有可能对应的列头表达式存在问题，所以这里允许占位符表达式为空
+     */
+    private placeholder?;
+    private comment?;
+    /**
+     * 当前单元格如果存在重定义表达式时，就会在对应的表格单元格中添加一个名为redefine的class，通过这个class中的伪类实现重定义表达式内容展示，
+     * 但这里会有一个问题，那就是在列头被调整大小时，对应的表格单元格中的内容也会被调整，所以也需要调整对应的伪类的大小，
+     * 这里就在列头调整大小时，添加一个监听器，监听列头的调整大小事件，并实时调整对应的伪类的大小
+     */
+    private headerResizeObserver?;
+    constructor(item: Item, partition: Partition, text: string, placeholder?: PlaceholderExpression);
+    moveUp(): void;
+    moveDown(): void;
+    cleanCellContent(): void;
+    resetTdCellContent(): void;
+    listenHeadersResize(binding: boolean): void;
+    getHeaderResizeObserver(): ResizeObserver;
+    buildCellPath(): string;
+    isOtherwise(): boolean | undefined;
+    setOtherwise(otherwise: boolean): void;
+    getRowIndex(table: DecisionTable): number;
+    getTableCell(): HTMLTableCellElement | undefined;
+    setTableCell(tableCell: HTMLTableCellElement): void;
+    getItem(): Item;
+    getComment(): string | undefined;
+    setComment(comment: string): void;
+    getPartition(): Partition;
+    setPartition(partition: Partition): void;
+    getPlaceholder(): PlaceholderExpression | undefined;
+    setPlaceholder(placeholder?: PlaceholderExpression): void;
+}

package/dist/dta/model/Partition.d.ts

@@ -0,0 +1,20 @@
+import { PreconditionContext } from '../../grammar/rule/RuleParser';
+import { ConditionItem } from './ConditionItem';
+import { Definition } from './Definition';
+export declare class Partition {
+    /**
+     * 分区对应的列头定义对象
+     */
+    private definition;
+    private parentCondition?;
+    private conditions;
+    constructor(definition: Definition, parentCondition?: ConditionItem);
+    toScript(preconditionContext?: PreconditionContext): string;
+    buildRuleScripts(preconditionContext?: PreconditionContext): string[];
+    getConditions(): ConditionItem[];
+    getDefId(): string;
+    getDefinition(): Definition;
+    setDefinition(definition: Definition): void;
+    getParentCondition(): ConditionItem | undefined;
+    setParentCondition(parentCondition: ConditionItem | undefined): void;
+}

package/dist/dta/model/ResourceData.d.ts

@@ -0,0 +1,7 @@
+export declare class ResourceData {
+    private name;
+    private value;
+    constructor(name: string, value: string);
+    getName(): string;
+    getValue(): string;
+}

package/dist/dta/model/Style.d.ts

@@ -0,0 +1,19 @@
+export declare class Style {
+    private fontFamily?;
+    private fontSize?;
+    private bold?;
+    private italic?;
+    private whole;
+    constructor(fontStyle: string, whole: boolean);
+    renderTableCell(cell: HTMLTableCellElement, headerDefinitionStyle?: Style): void;
+    buildHTMLStyle(): string;
+    isWhole(): boolean;
+    getFontFamily(): string | undefined;
+    getFontSize(): string | undefined;
+    getBold(): boolean | undefined;
+    getItalic(): boolean | undefined;
+    setFontFamily(fontFamily: string | undefined): void;
+    setFontSize(fontSize: string | undefined): void;
+    setBold(bold: boolean | undefined): void;
+    setItalic(italic: boolean | undefined): void;
+}

package/dist/dta/model/SubHeader.d.ts

@@ -0,0 +1,15 @@
+import { PlaceholderExpression } from '../../model/expression/PlaceholderExpression';
+export declare class SubHeader {
+    private text;
+    private targetTableHeaderCell?;
+    private targetFloatTableHeaderCell?;
+    private placeholderExpression?;
+    constructor(text: string, placeholderExpression?: PlaceholderExpression);
+    getText(): string;
+    setText(text: string): void;
+    getPlaceholderExpression(): PlaceholderExpression | undefined;
+    setTargetTableHeaderCell(cell: HTMLTableCellElement): void;
+    getTargetTableHeaderCell(): HTMLTableCellElement | undefined;
+    setTargetFloatTableHeaderCell(cell: HTMLTableCellElement): void;
+    getTargetFloatTableHeaderCell(): HTMLTableCellElement | undefined;
+}

package/dist/dta/webview/DecisionTableDocument.d.ts

@@ -0,0 +1,68 @@
+import { CancellationToken, CustomDocument, CustomDocumentBackup, Uri, Event } from 'vscode';
+import { DocumentDelegate, ViewEdit } from '../../view&document';
+export declare class DecisionTableDocument implements CustomDocument {
+    static create(uri: Uri, backupId: string | undefined, delegate: DocumentDelegate): Promise<DecisionTableDocument | PromiseLike<DecisionTableDocument>>;
+    private static readFile;
+    private readonly _uri;
+    private _documentData;
+    private _edits;
+    private _savedEdits;
+    private fileWatcher;
+    private readonly _delegate;
+    private constructor();
+    get uri(): Uri;
+    get documentData(): string;
+    private readonly _onDidDispose;
+    /**
+     * Fired when the document is disposed of.
+     */
+    readonly onDidDispose: Event<void>;
+    private readonly _onDidChangeDocument;
+    /**
+     * Fired to notify webviews that the document has changed.
+     */
+    readonly onDidChangeContent: Event<{
+        readonly edit: ViewEdit;
+    }>;
+    private readonly _onDidChange;
+    /**
+     * Fired to tell VS Code that an edit has occurred in the document.
+     *
+     * This updates the document's dirty indicator.
+     */
+    readonly onDidChange: Event<{
+        readonly label: string;
+        undo(): void;
+        redo(): void;
+    }>;
+    /**
+     * Called by VS Code when there are no more references to the document.
+     *
+     * This happens when all editors for it have been closed.
+     */
+    dispose(): void;
+    /**
+     * Called when the user edits the document in a webview.
+     *
+     * This fires an event to notify VS Code that the document has been edited.
+     */
+    makeEdit(edit: ViewEdit): void;
+    /**
+     * Called by VS Code when the user saves the document.
+     */
+    save(cancellation: CancellationToken): Promise<void>;
+    /**
+     * Called by VS Code when the user saves the document to a new location.
+     */
+    saveAs(targetResource: Uri, cancellation: CancellationToken): Promise<void>;
+    /**
+     * Called by VS Code when the user calls `revert` on a document.
+     */
+    revert(_cancellation: CancellationToken): Promise<void>;
+    /**
+     * Called by VS Code to backup the edited document.
+     *
+     * These backups are used to implement hot exit.
+     */
+    backup(destination: Uri, cancellation: CancellationToken): Promise<CustomDocumentBackup>;
+}

package/dist/dta/webview/DecisionTableEditorProvider.d.ts

@@ -0,0 +1,31 @@
+import { CancellationToken, CustomDocumentBackup, CustomDocumentBackupContext, CustomDocumentEditEvent, CustomDocumentOpenContext, CustomEditorProvider, Disposable, ExtensionContext, Uri, WebviewPanel, Event } from 'vscode';
+import { WebviewCollection } from '../../WebviewCollection';
+import { DecisionTableDocument } from './DecisionTableDocument';
+export declare const NEW_RULE_TABLE_FILE_COMMAND_NAME = "udmp.createNewRuleTableFile";
+export declare class DecisionTableEditorProvider implements CustomEditorProvider<DecisionTableDocument> {
+    readonly context: ExtensionContext;
+    private readonly _onDidChangeCustomDocument;
+    readonly onDidChangeCustomDocument: Event<CustomDocumentEditEvent<DecisionTableDocument>>;
+    readonly webviews: WebviewCollection;
+    private static readonly viewType;
+    private _requestId;
+    private readonly _callbacks;
+    private sendBomFileData;
+    private allBomFileParsed;
+    private needSendFileData;
+    constructor(context: ExtensionContext);
+    static register(context: ExtensionContext): {
+        decisionTableDisposable: Disposable;
+        decisionTableProvider: DecisionTableEditorProvider;
+    };
+    closeTargetWebview(uri: Uri): void;
+    resolveCustomEditor(document: DecisionTableDocument, webviewPanel: WebviewPanel, token: CancellationToken): Thenable<void> | void;
+    openCustomDocument(uri: Uri, openContext: CustomDocumentOpenContext, token: CancellationToken): Promise<DecisionTableDocument>;
+    saveCustomDocument(document: DecisionTableDocument, cancellation: CancellationToken): Thenable<void>;
+    saveCustomDocumentAs(document: DecisionTableDocument, destination: Uri, cancellation: CancellationToken): Thenable<void>;
+    revertCustomDocument(document: DecisionTableDocument, cancellation: CancellationToken): Thenable<void>;
+    backupCustomDocument(document: DecisionTableDocument, context: CustomDocumentBackupContext, cancellation: CancellationToken): Thenable<CustomDocumentBackup>;
+    private postMessageWithResponse;
+    private postMessage;
+    private onMessage;
+}

package/dist/dta/webview/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 buildDecisionTableWebviewHtml: (webview: Webview, context: ExtensionContext) => string;