ngx-rs-ant 1.3.2 → 1.3.5

package/esm2020/camunda-bpmn-editor/custom/service-task/ServiceTaskContextPadProvider.mjs

@@ -0,0 +1,46 @@
+export default class ServiceTaskContextPadProvider {
+    constructor(contextPad, translate, appendPreview, elementFactory, autoPlace, create) {
+        this.translate = translate;
+        this.appendPreview = appendPreview;
+        this.elementFactory = elementFactory;
+        this.autoPlace = autoPlace;
+        this.create = create;
+        contextPad.registerProvider(this);
+        this.appendServiceTaskPreview = this.appendServiceTaskPreview.bind(this);
+        this.appendServiceTask = this.appendServiceTask.bind(this);
+        this.appendServiceTaskStart = this.appendServiceTaskStart.bind(this);
+    }
+    getContextPadEntries() {
+        return {
+            'append.service-task': {
+                group: 'model',
+                className: 'bpmn-icon-service-task',
+                title: this.translate('Append ServiceTask'),
+                action: {
+                    hover: this.appendServiceTaskPreview,
+                    click: this.appendServiceTask,
+                    dragstart: this.appendServiceTaskStart
+                }
+            }
+        };
+    }
+    appendServiceTaskPreview(event, source) {
+        this.appendPreview.create(source, 'bpmn:ServiceTask');
+        return () => {
+            this.appendPreview.cleanUp();
+        };
+    }
+    appendServiceTask(event, source) {
+        const shape = this.elementFactory.createShape({ type: 'bpmn:ServiceTask' });
+        this.autoPlace.append(source, shape);
+        this.appendPreview.cleanUp();
+    }
+    appendServiceTaskStart(event, source) {
+        const shape = this.elementFactory.createShape({ type: 'bpmn:ServiceTask' });
+        this.create.start(event, shape, {
+            source: source
+        });
+        this.appendPreview.cleanUp();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/camunda-bpmn-editor/custom/service-task/ServiceTaskPaletteProvider.mjs

@@ -0,0 +1,27 @@
+export default class ServiceTaskPaletteProvider {
+    constructor(palette, translate, elementFactory, create) {
+        this.translate = translate;
+        this.elementFactory = elementFactory;
+        this.create = create;
+        palette.registerProvider(this);
+        this.createServiceTask = this.createServiceTask.bind(this);
+    }
+    getPaletteEntries() {
+        return {
+            'create.service-task': {
+                group: 'activity',
+                className: 'bpmn-icon-service-task',
+                title: this.translate('Create ServiceTask'),
+                action: {
+                    dragstart: this.createServiceTask,
+                    click: this.createServiceTask
+                }
+            }
+        };
+    }
+    createServiceTask(event) {
+        const shape = this.elementFactory.createShape({ type: 'bpmn:ServiceTask' });
+        this.create.start(event, shape);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/camunda-bpmn-editor/custom/service-task/index.mjs

@@ -0,0 +1,8 @@
+import ServiceTaskPaletteProvider from './ServiceTaskPaletteProvider';
+import ServiceTaskContextPadProvider from "./ServiceTaskContextPadProvider";
+export default {
+    __init__: ['serviceTaskPaletteProvider', 'serviceTaskContextPadProvider'],
+    serviceTaskPaletteProvider: ['type', ServiceTaskPaletteProvider],
+    serviceTaskContextPadProvider: ['type', ServiceTaskContextPadProvider],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcnMtYW50L3NyYy9jYW11bmRhLWJwbW4tZWRpdG9yL2N1c3RvbS9zZXJ2aWNlLXRhc2svaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywwQkFBMEIsTUFBTSw4QkFBOEIsQ0FBQztBQUN0RSxPQUFPLDZCQUE2QixNQUFNLGlDQUFpQyxDQUFDO0FBRTVFLGVBQWU7SUFDYixRQUFRLEVBQUUsQ0FBQyw0QkFBNEIsRUFBRSwrQkFBK0IsQ0FBQztJQUN6RSwwQkFBMEIsRUFBRSxDQUFDLE1BQU0sRUFBRSwwQkFBMEIsQ0FBQztJQUNoRSw2QkFBNkIsRUFBRSxDQUFDLE1BQU0sRUFBRSw2QkFBNkIsQ0FBQztDQUN2RSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFNlcnZpY2VUYXNrUGFsZXR0ZVByb3ZpZGVyIGZyb20gJy4vU2VydmljZVRhc2tQYWxldHRlUHJvdmlkZXInO1xyXG5pbXBvcnQgU2VydmljZVRhc2tDb250ZXh0UGFkUHJvdmlkZXIgZnJvbSBcIi4vU2VydmljZVRhc2tDb250ZXh0UGFkUHJvdmlkZXJcIjtcclxuXHJcbmV4cG9ydCBkZWZhdWx0IHtcclxuICBfX2luaXRfXzogWydzZXJ2aWNlVGFza1BhbGV0dGVQcm92aWRlcicsICdzZXJ2aWNlVGFza0NvbnRleHRQYWRQcm92aWRlciddLFxyXG4gIHNlcnZpY2VUYXNrUGFsZXR0ZVByb3ZpZGVyOiBbJ3R5cGUnLCBTZXJ2aWNlVGFza1BhbGV0dGVQcm92aWRlcl0sXHJcbiAgc2VydmljZVRhc2tDb250ZXh0UGFkUHJvdmlkZXI6IFsndHlwZScsIFNlcnZpY2VUYXNrQ29udGV4dFBhZFByb3ZpZGVyXSxcclxufTtcclxuIl19

package/esm2020/camunda-bpmn-editor/custom/translate/translations.mjs

@@ -1,14 +1,38 @@
 export const translations = {
+    // 调色板
     'Activate the hand tool': '激活拖拽工具',
     'Activate the lasso tool': '激活框选工具',
     'Activate the create/remove space tool': '激活空间移动工具',
     'Activate the global connect tool': '激活全局连接工具',
     'Create StartEvent': '创建开始节点',
     'Create EndEvent': '创建结束节点',
-    'Create Gateway': '创建网关节点',
     'Create UserTask': '创建用户任务',
+    'Create ServiceTask': '创建服务任务',
+    'Create Gateway': '创建网关节点',
+    // 面板
+    'Append EndEvent': '追加结束节点',
+    'Append UserTask': '追加用户任务',
+    'Append ServiceTask': '追加服务任务',
+    'Append Gateway': '追加网关节点',
+    'Connect using Sequence/MessageFlow or Association': '使用序列/消息流或关联连接',
+    'Remove': '删除',
+    'Set Color': '设置颜色',
+    'Change type': '改变节点类型',
+    'Exclusive Gateway': '互斥网关',
+    'Parallel Gateway': '并行网关',
+    'Default Flow': '默认流向',
+    'Sequence Flow': '顺序流向',
     'Open minimap': '打开缩略图',
     'Close minimap': '关闭缩略图',
+    // 配置
+    'General': '参数配置',
+    'Name': '名称',
+    'Task description': '任务描述',
+    'Set assignment rule': '设置用户规则',
+    'dynamic user': '动态用户',
+    'static user': '静态用户',
+    'dynamic role': '动态角色',
+    'static role': '静态角色',
     /*
       'Create {type}': '创建{type}',
       'Create Intermediate/Boundary Event': '创建中间/边界事件',
@@ -273,4 +297,4 @@ export const translations = {
       'Multi Instance Retry Time Cycle': '多实例重试时间',
       */
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translations.js","sourceRoot":"","sources":["../../../../../../projects/ngx-rs-ant/src/camunda-bpmn-editor/custom/translate/translations.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAErB;IACF,wBAAwB,EAAE,QAAQ;IAClC,yBAAyB,EAAE,QAAQ;IACnC,uCAAuC,EAAE,UAAU;IACnD,kCAAkC,EAAE,UAAU;IAC9C,mBAAmB,EAAE,QAAQ;IAC7B,iBAAiB,EAAE,QAAQ;IAC3B,gBAAgB,EAAE,QAAQ;IAC1B,iBAAiB,EAAE,QAAQ;IAC3B,cAAc,EAAE,OAAO;IACvB,eAAe,EAAE,OAAO;IAGxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsQI;CACL,CAAC","sourcesContent":["export const translations: {\r\n  [key: string]: string\r\n} = {\r\n  'Activate the hand tool': '激活拖拽工具',\r\n  'Activate the lasso tool': '激活框选工具',\r\n  'Activate the create/remove space tool': '激活空间移动工具',\r\n  'Activate the global connect tool': '激活全局连接工具',\r\n  'Create StartEvent': '创建开始节点',\r\n  'Create EndEvent': '创建结束节点',\r\n  'Create Gateway': '创建网关节点',\r\n  'Create UserTask': '创建用户任务',\r\n  'Open minimap': '打开缩略图',\r\n  'Close minimap': '关闭缩略图',\r\n\r\n\r\n  /*\r\n    'Create {type}': '创建{type}',\r\n    'Create Intermediate/Boundary Event': '创建中间/边界事件',\r\n    'Append {type}': '追加{type}', //'追加{type}',\r\n    'Add Lane above': '添加上面泳道',\r\n    'Divide into two Lanes': '拆分两个泳道',\r\n    'Divide into three Lanes': '拆分三个泳道',\r\n    'Add Lane below': '添下面泳道',\r\n    'Append compensation activity': '追加补偿活动',\r\n    'Change type': '改变节点类型', // 改变事情类型\r\n    'Connect using Association': '使用关联连接',\r\n    'Connect using Sequence/MessageFlow or Association': '使用序列/消息流或关联连接',\r\n    'Connect using DataInputAssociation': '使用数据输入关联连接',\r\n    'Remove': '删除',\r\n    'Create expanded SubProcess': '创建扩展子流程',\r\n    // 'Create Pool/Participant': '创建者或参与者',\r\n    'Create IntermediateThrowEvent/BoundaryEvent': '创建中间事件或边界事件',\r\n    'Parallel Multi Instance': '并行多实例',\r\n    'Sequential Multi Instance': '顺序多重实例',\r\n    'Loop': '循环',\r\n    'Ad-hoc': '特别指定',\r\n    'Task': '任务',\r\n    'Send Task': '发送任务', // 发送任务\r\n    'Receive Task': '接收任务',\r\n    'User Task': '用户任务',\r\n    'Manual Task': '手工任务',\r\n    'Business Rule Task': '作业规则任务',\r\n    'Service Task': '服务任务',\r\n    'Script Task': '脚本任务',\r\n    'Call Activity': '调用活动',\r\n    'Sub Process (collapsed)': '子过程（折叠）',\r\n    'Sub Process (expanded)': '子过程（展开）',\r\n    'Start Event': '开始事件',\r\n    'Intermediate Throw Event': '抛出事件',\r\n    'End Event': '结束事件',\r\n    'Message Start Event': '消息开始事件',\r\n    'Timer Start Event': '时间开始事件',\r\n    'Conditional Start Event': '条件开始事件',\r\n    'Signal Start Event': '信号开始事件',\r\n    'Error Start Event': '错误开始事件',\r\n    'Escalation Start Event': '升级开始事件',\r\n    'Compensation Start Event': '补偿开始事件',\r\n    'Message Start Event (non-interrupting)': '消息开始事件（不中断）',\r\n    'Timer Start Event (non-interrupting)': '定时开始事件（不中断）',\r\n    'Conditional Start Event (non-interrupting)': '条件开始事件（不中断）',\r\n    'Signal Start Event (non-interrupting)': '信号开始事件（不中断）',\r\n    'Escalation Start Event (non-interrupting)': '升级开始事件（不中断）',\r\n    'Message Intermediate Catch Event': '信息捕获事件',\r\n    'Message Intermediate Throw Event': '信息抛出事件',\r\n    'Timer Intermediate Catch Event': '定时器捕获事件',\r\n    'Escalation Intermediate Throw Event': '升级抛出事件',\r\n    'Conditional Intermediate Catch Event': '条件捕获事件',\r\n    'Link Intermediate Catch Event': '链接捕获事件',\r\n    'Link Intermediate Throw Event': '链接抛出事件',\r\n    'Compensation Intermediate Throw Event': '补偿抛出事件',\r\n    'Signal Intermediate Catch Event': '信号捕获事件',\r\n    'Signal Intermediate Throw Event': '信号抛出事件',\r\n    'Message End Event': '消息结束事件',\r\n    'Escalation End Event': '升级结束事件',\r\n    'Error End Event': '错误结束事件',\r\n    'Cancel End Event': '取消结束事件',\r\n    'Compensation End Event': '补偿结束事件',\r\n    'Signal End Event': '信号结束事件',\r\n    'Terminate End Event': '终止结束事件',\r\n    'Message Boundary Event': '消息边界事件',\r\n    'Message Boundary Event (non-interrupting)': '消息边界事件（非中断）',\r\n    'Timer Boundary Event': '定时边界事件',\r\n    'Timer Boundary Event (non-interrupting)': '定时边界事件（非中断）',\r\n    'Escalation Boundary Event': '升级边界事件',\r\n    'Escalation Boundary Event (non-interrupting)': '升级边界事件（非中断）',\r\n    'Conditional Boundary Event': '有条件的边界事件',\r\n    'Conditional Boundary Event (non-interrupting)': '条件边界事件（非中断）',\r\n    'Error Boundary Event': '错误边界事件',\r\n    'Cancel Boundary Event': '取消边界事件',\r\n    'Signal Boundary Event': '信号边界事件',\r\n    'Signal Boundary Event (non-interrupting)': '信号边界事件（非中断）',\r\n    'Compensation Boundary Event': '补偿边界事件',\r\n    'Exclusive': '排他',\r\n    'Exclusive Gateway': '互斥网关',\r\n    'Parallel Gateway': '并行网关',\r\n    'Inclusive Gateway': '相容网关',\r\n    'Complex Gateway': '复杂网关',\r\n    'Event based Gateway': '事件网关',\r\n    'Transaction': '交换',\r\n    'Sub Process': '子流程',\r\n    'Event Sub Process': '事件子流程',\r\n    'Empty Pool (removes content)': '清空泳池（删除内容）',\r\n    'Collapsed Pool': '合并泳池',\r\n    'Expanded Pool': '扩展泳池',\r\n\r\n    // flow\r\n    'Default Flow': '默认流向',\r\n    'Sequence Flow': '顺序流向',\r\n    'Conditional Flow': '条件流向',\r\n\r\n    // Errors\r\n    'no parent for {element} in {parent}': '在{parent}中的{element}没有父元素',\r\n    'no shape type specified': '没有指定的形状类型',\r\n    'flow elements must be children of pools/participants': '流动元素必须是游泳池/参与者',\r\n    'out of bounds release': '跨界界释放',\r\n    'more than {count} child lanes': '超出{count}分支',\r\n    'element required': '被请求元素',\r\n    'diagram not part of bpmn': '图在bpmn中',\r\n    'no diagram to display': '没有图表来显示',\r\n    'no process or collaboration to display': '没有流程或协作显示',\r\n    'element {element} referenced by {referenced}#{property} not yet drawn':\r\n      '元素{element}在{referenced}＃{property}的引用还没有绘制',\r\n    'already rendered {element}': '已经提供{element}',\r\n    'failed to import {element}': '元素导入失败{element}',\r\n    'ID must not be empty.': 'ID不能为空！',\r\n    'ID must be a valid QName.': '无效的ID输入！',\r\n\r\n    // message\r\n    'This maps to the process definition key.': '映射流程定义的Key。',\r\n    'This maps to the task definition key.': '映射任务定义的Key。',\r\n    'Specify more than one group as a comma separated list.': '多于一个组时为逗号分隔的列表。',\r\n    'Specify more than one user as a comma separated list.': '多于一个用户时为逗号分隔的列表。',\r\n    'Must provide either loop cardinality or collection': '必须提供循环基数或集合',\r\n    'Available process variables, identified in the diagram.': '可用的过程变量，如图中所示。',\r\n    'No variables found.': '未找到变量。',\r\n\r\n    'General': '基本属性',\r\n    'Documentation': '备注',\r\n    'Element documentation': '元素备注',\r\n    'Executable': '可执行',\r\n    'Process Documentation': '过程说明',\r\n    '': '无',\r\n    'Listeners': '监听器',\r\n    'Execution Listener': '扩展监听器',\r\n    'Extensions': '扩展',\r\n    'Properties': '属性',\r\n    'Add Property': '添加属性',\r\n    'Process Id': '流程标识',\r\n    'Process Name': '流程名称',\r\n    'Participant Id': '参与者标识',\r\n    'Participant Name': '参与者名称',\r\n    'Name': '名称',\r\n    'Id': '标识',\r\n    'ID': '标识',\r\n    'Value': '值',\r\n    'Version Tag': '版本标记',\r\n    'External Task Configuration': '外部任务配置',\r\n    'Task Priority': '任务优先级',\r\n    'Job Configuration': '作业配置',\r\n    'Job Priority': '作业优先级',\r\n    'History Configuration': '历史配置',\r\n    'History Time To Live': '历史生存时间',\r\n    'Details': '详情',\r\n    'Initiator': '初始化',\r\n    'Asynchronous Continuations': '异步连续',\r\n    'Asynchronous Before': '异步之前',\r\n    'Asynchronous After': '异步之后',\r\n    'Forms': '表单',\r\n    'Form Key': '表单名',\r\n    'Form Fields': '表单字段',\r\n    'Form Buttons': '表单按钮',\r\n    'Form Field': '表单字段',\r\n    'Form Button': '表单按钮',\r\n    'Button Name': '按钮名称',\r\n    'Business Key': '业务键',\r\n    'Type': '类型',\r\n    'Label': '标签',\r\n    'Default Value': '默认值',\r\n    'Validation': '校验',\r\n    'Add Constraint': '添加约束',\r\n    'Config': '配置',\r\n    'Must provide a value': '必须提供一个值',\r\n    'Event Type': '事件类型',\r\n    'Listener Type': '监听器类型',\r\n    'Java Class': 'Java 类',\r\n    'Field Injection': '字段注入',\r\n    'Fields': '字段',\r\n    'Condition Type': '条件类型',\r\n    'Script Format': '脚本格式',\r\n    'Script Type': '脚本类型',\r\n    'Inline Script': '内联脚本',\r\n    'External Resource': '外部资源',\r\n    'Expression': '表达式',\r\n    'Delegate Expression': '委托表达式',\r\n    'Script': '脚本',\r\n    'Parameter must have a name': '参数必须有一个名称',\r\n    'String': '字符串',\r\n    'Implementation': '实现',\r\n    'External': '外部',\r\n    'Connector': '连接器',\r\n    'Must configure Connector': '必须配置连接器',\r\n    'Connector Id': '连接器ID',\r\n    'Input/Output': '输入/输出',\r\n    'Input Parameters': '输入参数',\r\n    'Input Parameter': '输入参数',\r\n    'Output Parameters': '输出参数',\r\n    'Output Parameter': '输出参数',\r\n    'Text': '文本',\r\n    'List': '列表',\r\n    'Add Entry': '增加条目',\r\n    'Field Injections': '字段注入',\r\n    'TextAnnotation': '文本注释',\r\n    'Variables': '变量',\r\n    'In Mapping': '输入映射',\r\n    'Out Mapping': '输出映射',\r\n    'Target': '目标',\r\n    'Source': '来源',\r\n    'Local': '本地',\r\n    'Candidate Starter Configuration': '候选人起动器配置',\r\n    'Candidate Starter Groups': '候选人起动器组',\r\n    'Candidate Starter Users': '候选人起动器用户',\r\n    'Configure Connector': '配置连接器',\r\n    'Assignee Type': '受理人类型',\r\n    'Assignee': '受理人',\r\n    'Dynamic': '动态',\r\n    'Static': '静态',\r\n    'User': '用户',\r\n    'Role': '角色',\r\n    'Candidate Users': '候选用户',\r\n    'Candidate Groups': '候选组',\r\n    'Due Date': '到期',\r\n    'Follow Up Date': '跟踪日期',\r\n    'Priority': '优先级',\r\n    'The due date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)':\r\n      '可以使用EL表达式，（例如：${someDate} 或者ISO日期（例如：2015-06-26T09:54:00））',\r\n    'The follow up date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)':\r\n      '可以使用EL表达式，（例如：${someDate} 或者ISO日期（例如：2015-06-26T09:54:00））',\r\n\r\n    'Create Task': '创建任务',\r\n    'Create DataObjectReference': '创建数据对象引用',\r\n    'Create DataStoreReference': '创建数据存储引用',\r\n    'Create Group': '创建分组',\r\n    'Category Value': '类别值',\r\n\r\n    //custom\r\n    'Create CallActivity': '创建调用任务',\r\n    'Append Gateway': '追加网关节点',\r\n    'Append Intermediate/Boundary Event': '追加中间/边界事件',\r\n    'StartEvent': '开始节点',\r\n    'EndEvent': '结束节点',\r\n    'DataObjectReference': '数据对象引用',\r\n    'DataStoreReference': '数据存储引用',\r\n    'Element must have an unique id.': '节点元素必须用于唯一编号',\r\n    'Create ExclusiveGateway': '创建排他网关',\r\n    'Create Pool/Participant': '创建泳道或参与者',\r\n    'Append ExclusiveGateway': '追加排他网关',\r\n    'Append Task': '追加任务',\r\n    'Append UserTask': '追加用户任务',\r\n    'Append Sequence': '追加连线',\r\n    'Append EndEvent': '追加结束节点',\r\n    'UserTask': '用户任务',\r\n    'ExclusiveGateway': '条件', //排他网关\r\n    'Element is not set findUserType': '员工节点未设置节点人员',\r\n    'Token Simulation ': '流程模拟',\r\n    'Tasklist Configuration': '任务列表配置',\r\n    'Startable': '可启动',\r\n    'Element Documentation': '元素描述',\r\n\r\n    'Multi Instance': '多实例',\r\n    'Loop Cardinality': '循环基数',\r\n    'Collection': '集合',\r\n    'Element Variable': '元素变量',\r\n    'Completion Condition': '完成条件',\r\n    'Multi Instance Asynchronous Before': '多实例异步之前',\r\n    'Multi Instance Asynchronous After': '多实例异步之后',\r\n    'Multi Instance Exclusive': '多实例排他',\r\n    'Multi Instance Retry Time Cycle': '多实例重试时间',\r\n    */\r\n};\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translations.js","sourceRoot":"","sources":["../../../../../../projects/ngx-rs-ant/src/camunda-bpmn-editor/custom/translate/translations.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAErB;IACF,MAAM;IACN,wBAAwB,EAAE,QAAQ;IAClC,yBAAyB,EAAE,QAAQ;IACnC,uCAAuC,EAAE,UAAU;IACnD,kCAAkC,EAAE,UAAU;IAC9C,mBAAmB,EAAE,QAAQ;IAC7B,iBAAiB,EAAE,QAAQ;IAC3B,iBAAiB,EAAE,QAAQ;IAC3B,oBAAoB,EAAE,QAAQ;IAC9B,gBAAgB,EAAE,QAAQ;IAC1B,KAAK;IACL,iBAAiB,EAAE,QAAQ;IAC3B,iBAAiB,EAAE,QAAQ;IAC3B,oBAAoB,EAAE,QAAQ;IAC9B,gBAAgB,EAAE,QAAQ;IAC1B,mDAAmD,EAAE,eAAe;IACpE,QAAQ,EAAE,IAAI;IACd,WAAW,EAAE,MAAM;IACnB,aAAa,EAAE,QAAQ;IACvB,mBAAmB,EAAE,MAAM;IAC3B,kBAAkB,EAAE,MAAM;IAC1B,cAAc,EAAE,MAAM;IACtB,eAAe,EAAE,MAAM;IACvB,cAAc,EAAE,OAAO;IACvB,eAAe,EAAE,OAAO;IACxB,KAAK;IACL,SAAS,EAAE,MAAM;IACjB,MAAM,EAAE,IAAI;IACZ,kBAAkB,EAAE,MAAM;IAC1B,qBAAqB,EAAE,QAAQ;IAC/B,cAAc,EAAE,MAAM;IACtB,aAAa,EAAE,MAAM;IACrB,cAAc,EAAE,MAAM;IACtB,aAAa,EAAE,MAAM;IAGrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsQI;CACL,CAAC","sourcesContent":["export const translations: {\r\n  [key: string]: string\r\n} = {\r\n  // 调色板\r\n  'Activate the hand tool': '激活拖拽工具',\r\n  'Activate the lasso tool': '激活框选工具',\r\n  'Activate the create/remove space tool': '激活空间移动工具',\r\n  'Activate the global connect tool': '激活全局连接工具',\r\n  'Create StartEvent': '创建开始节点',\r\n  'Create EndEvent': '创建结束节点',\r\n  'Create UserTask': '创建用户任务',\r\n  'Create ServiceTask': '创建服务任务',\r\n  'Create Gateway': '创建网关节点',\r\n  // 面板\r\n  'Append EndEvent': '追加结束节点',\r\n  'Append UserTask': '追加用户任务',\r\n  'Append ServiceTask': '追加服务任务',\r\n  'Append Gateway': '追加网关节点',\r\n  'Connect using Sequence/MessageFlow or Association': '使用序列/消息流或关联连接',\r\n  'Remove': '删除',\r\n  'Set Color': '设置颜色',\r\n  'Change type': '改变节点类型',\r\n  'Exclusive Gateway': '互斥网关',\r\n  'Parallel Gateway': '并行网关',\r\n  'Default Flow': '默认流向',\r\n  'Sequence Flow': '顺序流向',\r\n  'Open minimap': '打开缩略图',\r\n  'Close minimap': '关闭缩略图',\r\n  // 配置\r\n  'General': '参数配置',\r\n  'Name': '名称',\r\n  'Task description': '任务描述',\r\n  'Set assignment rule': '设置用户规则',\r\n  'dynamic user': '动态用户',\r\n  'static user': '静态用户',\r\n  'dynamic role': '动态角色',\r\n  'static role': '静态角色',\r\n\r\n\r\n  /*\r\n    'Create {type}': '创建{type}',\r\n    'Create Intermediate/Boundary Event': '创建中间/边界事件',\r\n    'Append {type}': '追加{type}', //'追加{type}',\r\n    'Add Lane above': '添加上面泳道',\r\n    'Divide into two Lanes': '拆分两个泳道',\r\n    'Divide into three Lanes': '拆分三个泳道',\r\n    'Add Lane below': '添下面泳道',\r\n    'Append compensation activity': '追加补偿活动',\r\n    'Change type': '改变节点类型', // 改变事情类型\r\n    'Connect using Association': '使用关联连接',\r\n    'Connect using Sequence/MessageFlow or Association': '使用序列/消息流或关联连接',\r\n    'Connect using DataInputAssociation': '使用数据输入关联连接',\r\n    'Remove': '删除',\r\n    'Create expanded SubProcess': '创建扩展子流程',\r\n    // 'Create Pool/Participant': '创建者或参与者',\r\n    'Create IntermediateThrowEvent/BoundaryEvent': '创建中间事件或边界事件',\r\n    'Parallel Multi Instance': '并行多实例',\r\n    'Sequential Multi Instance': '顺序多重实例',\r\n    'Loop': '循环',\r\n    'Ad-hoc': '特别指定',\r\n    'Task': '任务',\r\n    'Send Task': '发送任务', // 发送任务\r\n    'Receive Task': '接收任务',\r\n    'User Task': '用户任务',\r\n    'Manual Task': '手工任务',\r\n    'Business Rule Task': '作业规则任务',\r\n    'Service Task': '服务任务',\r\n    'Script Task': '脚本任务',\r\n    'Call Activity': '调用活动',\r\n    'Sub Process (collapsed)': '子过程（折叠）',\r\n    'Sub Process (expanded)': '子过程（展开）',\r\n    'Start Event': '开始事件',\r\n    'Intermediate Throw Event': '抛出事件',\r\n    'End Event': '结束事件',\r\n    'Message Start Event': '消息开始事件',\r\n    'Timer Start Event': '时间开始事件',\r\n    'Conditional Start Event': '条件开始事件',\r\n    'Signal Start Event': '信号开始事件',\r\n    'Error Start Event': '错误开始事件',\r\n    'Escalation Start Event': '升级开始事件',\r\n    'Compensation Start Event': '补偿开始事件',\r\n    'Message Start Event (non-interrupting)': '消息开始事件（不中断）',\r\n    'Timer Start Event (non-interrupting)': '定时开始事件（不中断）',\r\n    'Conditional Start Event (non-interrupting)': '条件开始事件（不中断）',\r\n    'Signal Start Event (non-interrupting)': '信号开始事件（不中断）',\r\n    'Escalation Start Event (non-interrupting)': '升级开始事件（不中断）',\r\n    'Message Intermediate Catch Event': '信息捕获事件',\r\n    'Message Intermediate Throw Event': '信息抛出事件',\r\n    'Timer Intermediate Catch Event': '定时器捕获事件',\r\n    'Escalation Intermediate Throw Event': '升级抛出事件',\r\n    'Conditional Intermediate Catch Event': '条件捕获事件',\r\n    'Link Intermediate Catch Event': '链接捕获事件',\r\n    'Link Intermediate Throw Event': '链接抛出事件',\r\n    'Compensation Intermediate Throw Event': '补偿抛出事件',\r\n    'Signal Intermediate Catch Event': '信号捕获事件',\r\n    'Signal Intermediate Throw Event': '信号抛出事件',\r\n    'Message End Event': '消息结束事件',\r\n    'Escalation End Event': '升级结束事件',\r\n    'Error End Event': '错误结束事件',\r\n    'Cancel End Event': '取消结束事件',\r\n    'Compensation End Event': '补偿结束事件',\r\n    'Signal End Event': '信号结束事件',\r\n    'Terminate End Event': '终止结束事件',\r\n    'Message Boundary Event': '消息边界事件',\r\n    'Message Boundary Event (non-interrupting)': '消息边界事件（非中断）',\r\n    'Timer Boundary Event': '定时边界事件',\r\n    'Timer Boundary Event (non-interrupting)': '定时边界事件（非中断）',\r\n    'Escalation Boundary Event': '升级边界事件',\r\n    'Escalation Boundary Event (non-interrupting)': '升级边界事件（非中断）',\r\n    'Conditional Boundary Event': '有条件的边界事件',\r\n    'Conditional Boundary Event (non-interrupting)': '条件边界事件（非中断）',\r\n    'Error Boundary Event': '错误边界事件',\r\n    'Cancel Boundary Event': '取消边界事件',\r\n    'Signal Boundary Event': '信号边界事件',\r\n    'Signal Boundary Event (non-interrupting)': '信号边界事件（非中断）',\r\n    'Compensation Boundary Event': '补偿边界事件',\r\n    'Exclusive': '排他',\r\n    'Exclusive Gateway': '互斥网关',\r\n    'Parallel Gateway': '并行网关',\r\n    'Inclusive Gateway': '相容网关',\r\n    'Complex Gateway': '复杂网关',\r\n    'Event based Gateway': '事件网关',\r\n    'Transaction': '交换',\r\n    'Sub Process': '子流程',\r\n    'Event Sub Process': '事件子流程',\r\n    'Empty Pool (removes content)': '清空泳池（删除内容）',\r\n    'Collapsed Pool': '合并泳池',\r\n    'Expanded Pool': '扩展泳池',\r\n\r\n    // flow\r\n    'Default Flow': '默认流向',\r\n    'Sequence Flow': '顺序流向',\r\n    'Conditional Flow': '条件流向',\r\n\r\n    // Errors\r\n    'no parent for {element} in {parent}': '在{parent}中的{element}没有父元素',\r\n    'no shape type specified': '没有指定的形状类型',\r\n    'flow elements must be children of pools/participants': '流动元素必须是游泳池/参与者',\r\n    'out of bounds release': '跨界界释放',\r\n    'more than {count} child lanes': '超出{count}分支',\r\n    'element required': '被请求元素',\r\n    'diagram not part of bpmn': '图在bpmn中',\r\n    'no diagram to display': '没有图表来显示',\r\n    'no process or collaboration to display': '没有流程或协作显示',\r\n    'element {element} referenced by {referenced}#{property} not yet drawn':\r\n      '元素{element}在{referenced}＃{property}的引用还没有绘制',\r\n    'already rendered {element}': '已经提供{element}',\r\n    'failed to import {element}': '元素导入失败{element}',\r\n    'ID must not be empty.': 'ID不能为空！',\r\n    'ID must be a valid QName.': '无效的ID输入！',\r\n\r\n    // message\r\n    'This maps to the process definition key.': '映射流程定义的Key。',\r\n    'This maps to the task definition key.': '映射任务定义的Key。',\r\n    'Specify more than one group as a comma separated list.': '多于一个组时为逗号分隔的列表。',\r\n    'Specify more than one user as a comma separated list.': '多于一个用户时为逗号分隔的列表。',\r\n    'Must provide either loop cardinality or collection': '必须提供循环基数或集合',\r\n    'Available process variables, identified in the diagram.': '可用的过程变量，如图中所示。',\r\n    'No variables found.': '未找到变量。',\r\n\r\n    'General': '基本属性',\r\n    'Documentation': '备注',\r\n    'Element documentation': '元素备注',\r\n    'Executable': '可执行',\r\n    'Process Documentation': '过程说明',\r\n    '': '无',\r\n    'Listeners': '监听器',\r\n    'Execution Listener': '扩展监听器',\r\n    'Extensions': '扩展',\r\n    'Properties': '属性',\r\n    'Add Property': '添加属性',\r\n    'Process Id': '流程标识',\r\n    'Process Name': '流程名称',\r\n    'Participant Id': '参与者标识',\r\n    'Participant Name': '参与者名称',\r\n    'Name': '名称',\r\n    'Id': '标识',\r\n    'ID': '标识',\r\n    'Value': '值',\r\n    'Version Tag': '版本标记',\r\n    'External Task Configuration': '外部任务配置',\r\n    'Task Priority': '任务优先级',\r\n    'Job Configuration': '作业配置',\r\n    'Job Priority': '作业优先级',\r\n    'History Configuration': '历史配置',\r\n    'History Time To Live': '历史生存时间',\r\n    'Details': '详情',\r\n    'Initiator': '初始化',\r\n    'Asynchronous Continuations': '异步连续',\r\n    'Asynchronous Before': '异步之前',\r\n    'Asynchronous After': '异步之后',\r\n    'Forms': '表单',\r\n    'Form Key': '表单名',\r\n    'Form Fields': '表单字段',\r\n    'Form Buttons': '表单按钮',\r\n    'Form Field': '表单字段',\r\n    'Form Button': '表单按钮',\r\n    'Button Name': '按钮名称',\r\n    'Business Key': '业务键',\r\n    'Type': '类型',\r\n    'Label': '标签',\r\n    'Default Value': '默认值',\r\n    'Validation': '校验',\r\n    'Add Constraint': '添加约束',\r\n    'Config': '配置',\r\n    'Must provide a value': '必须提供一个值',\r\n    'Event Type': '事件类型',\r\n    'Listener Type': '监听器类型',\r\n    'Java Class': 'Java 类',\r\n    'Field Injection': '字段注入',\r\n    'Fields': '字段',\r\n    'Condition Type': '条件类型',\r\n    'Script Format': '脚本格式',\r\n    'Script Type': '脚本类型',\r\n    'Inline Script': '内联脚本',\r\n    'External Resource': '外部资源',\r\n    'Expression': '表达式',\r\n    'Delegate Expression': '委托表达式',\r\n    'Script': '脚本',\r\n    'Parameter must have a name': '参数必须有一个名称',\r\n    'String': '字符串',\r\n    'Implementation': '实现',\r\n    'External': '外部',\r\n    'Connector': '连接器',\r\n    'Must configure Connector': '必须配置连接器',\r\n    'Connector Id': '连接器ID',\r\n    'Input/Output': '输入/输出',\r\n    'Input Parameters': '输入参数',\r\n    'Input Parameter': '输入参数',\r\n    'Output Parameters': '输出参数',\r\n    'Output Parameter': '输出参数',\r\n    'Text': '文本',\r\n    'List': '列表',\r\n    'Add Entry': '增加条目',\r\n    'Field Injections': '字段注入',\r\n    'TextAnnotation': '文本注释',\r\n    'Variables': '变量',\r\n    'In Mapping': '输入映射',\r\n    'Out Mapping': '输出映射',\r\n    'Target': '目标',\r\n    'Source': '来源',\r\n    'Local': '本地',\r\n    'Candidate Starter Configuration': '候选人起动器配置',\r\n    'Candidate Starter Groups': '候选人起动器组',\r\n    'Candidate Starter Users': '候选人起动器用户',\r\n    'Configure Connector': '配置连接器',\r\n    'Assignee Type': '受理人类型',\r\n    'Assignee': '受理人',\r\n    'Dynamic': '动态',\r\n    'Static': '静态',\r\n    'User': '用户',\r\n    'Role': '角色',\r\n    'Candidate Users': '候选用户',\r\n    'Candidate Groups': '候选组',\r\n    'Due Date': '到期',\r\n    'Follow Up Date': '跟踪日期',\r\n    'Priority': '优先级',\r\n    'The due date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)':\r\n      '可以使用EL表达式，（例如：${someDate} 或者ISO日期（例如：2015-06-26T09:54:00））',\r\n    'The follow up date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)':\r\n      '可以使用EL表达式，（例如：${someDate} 或者ISO日期（例如：2015-06-26T09:54:00））',\r\n\r\n    'Create Task': '创建任务',\r\n    'Create DataObjectReference': '创建数据对象引用',\r\n    'Create DataStoreReference': '创建数据存储引用',\r\n    'Create Group': '创建分组',\r\n    'Category Value': '类别值',\r\n\r\n    //custom\r\n    'Create CallActivity': '创建调用任务',\r\n    'Append Gateway': '追加网关节点',\r\n    'Append Intermediate/Boundary Event': '追加中间/边界事件',\r\n    'StartEvent': '开始节点',\r\n    'EndEvent': '结束节点',\r\n    'DataObjectReference': '数据对象引用',\r\n    'DataStoreReference': '数据存储引用',\r\n    'Element must have an unique id.': '节点元素必须用于唯一编号',\r\n    'Create ExclusiveGateway': '创建排他网关',\r\n    'Create Pool/Participant': '创建泳道或参与者',\r\n    'Append ExclusiveGateway': '追加排他网关',\r\n    'Append Task': '追加任务',\r\n    'Append UserTask': '追加用户任务',\r\n    'Append Sequence': '追加连线',\r\n    'Append EndEvent': '追加结束节点',\r\n    'UserTask': '用户任务',\r\n    'ExclusiveGateway': '条件', //排他网关\r\n    'Element is not set findUserType': '员工节点未设置节点人员',\r\n    'Token Simulation ': '流程模拟',\r\n    'Tasklist Configuration': '任务列表配置',\r\n    'Startable': '可启动',\r\n    'Element Documentation': '元素描述',\r\n\r\n    'Multi Instance': '多实例',\r\n    'Loop Cardinality': '循环基数',\r\n    'Collection': '集合',\r\n    'Element Variable': '元素变量',\r\n    'Completion Condition': '完成条件',\r\n    'Multi Instance Asynchronous Before': '多实例异步之前',\r\n    'Multi Instance Asynchronous After': '多实例异步之后',\r\n    'Multi Instance Exclusive': '多实例排他',\r\n    'Multi Instance Retry Time Cycle': '多实例重试时间',\r\n    */\r\n};\r\n"]}

package/esm2020/data-detail/data-detail.component.mjs

@@ -1,4 +1,4 @@
-import { Component, Input } from '@angular/core';
+import { Component } from '@angular/core';
 import { DataDetailService } from "./data-detail.service";
 import * as i0 from "@angular/core";
 import * as i1 from "./data-detail.service";
@@ -24,17 +24,9 @@ export class DataDetailComponent {
     }
 }
 DataDetailComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DataDetailComponent, deps: [{ token: i0.ViewContainerRef }, { token: i1.DataDetailService }], target: i0.ɵɵFactoryTarget.Component });
-DataDetailComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: DataDetailComponent, selector: "coast-data-detail", inputs: { tenant: "tenant", className: "className", oid: "oid", params: "params" }, providers: [DataDetailService], ngImport: i0, template: "<dx-load-panel [container]=\"viewContainerRef.element.nativeElement\" [showPane]=\"false\"\n               [visible]=\"loading\">\n  <dxo-position [of]=\"viewContainerRef.element.nativeElement\"></dxo-position>\n</dx-load-panel>\n<div *ngIf=\"!loading && sections.length === 0\" class=\"empty\">\n  <span>\u60A8\u65E0\u6743\u67E5\u770B\u8BE5\u6570\u636E\u5B9E\u4F8B\u4EFB\u4F55\u4FE1\u606F</span>\n</div>\n<ng-container *ngIf=\"sections.length > 0\">\n  <dx-accordion [collapsible]=\"true\" [multiple]=\"true\" [deferRendering]=\"false\" [dataSource]=\"sections\"\n                [selectedItems]=\"sections\">\n    <div *dxTemplate=\"let section of 'title'\" class=\"section-title\">\n      <div class=\"section-title-name\">{{section.name}}</div>\n    </div>\n    <div *dxTemplate=\"let section of 'item'\">\n      <rs-form [tenant]=\"tenant\" [className]=\"className\" [oid]=\"oid\" [template]=\"section.formTemplate\"\n               [readonly]=\"true\"></rs-form>\n    </div>\n  </dx-accordion>\n</ng-container>\n", styles: [":host{flex:1;padding:24px;display:flex;flex-flow:column nowrap}:host div.empty{flex:1;padding:16px;display:flex;flex-flow:row nowrap;justify-content:center;align-items:center}:host div.empty span{text-align:center;-webkit-user-select:none;user-select:none}:host .section-title{border-bottom:1px solid var(--coast-border-color, #dddddd)}:host .section-title .section-title-name{height:24px;font-size:14px;font-weight:700;padding:4px 8px;display:flex;flex-flow:column nowrap;justify-content:center}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.DxAccordionComponent, selector: "dx-accordion", inputs: ["accessKey", "activeStateEnabled", "animationDuration", "collapsible", "dataSource", "deferRendering", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "itemHoldTimeout", "items", "itemTemplate", "itemTitleTemplate", "keyExpr", "multiple", "noDataText", "repaintChangesOnly", "rtlEnabled", "selectedIndex", "selectedItem", "selectedItemKeys", "selectedItems", "tabIndex", "visible", "width"], outputs: ["onContentReady", "onDisposing", "onInitialized", "onItemClick", "onItemContextMenu", "onItemHold", "onItemRendered", "onItemTitleClick", "onOptionChanged", "onSelectionChanged", "accessKeyChange", "activeStateEnabledChange", "animationDurationChange", "collapsibleChange", "dataSourceChange", "deferRenderingChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "itemHoldTimeoutChange", "itemsChange", "itemTemplateChange", "itemTitleTemplateChange", "keyExprChange", "multipleChange", "noDataTextChange", "repaintChangesOnlyChange", "rtlEnabledChange", "selectedIndexChange", "selectedItemChange", "selectedItemKeysChange", "selectedItemsChange", "tabIndexChange", "visibleChange", "widthChange"] }, { kind: "directive", type: i4.DxTemplateDirective, selector: "[dxTemplate]", inputs: ["dxTemplateOf"] }, { kind: "component", type: i5.DxoPositionComponent, selector: "dxo-position", inputs: ["at", "boundary", "boundaryOffset", "collision", "my", "of", "offset"] }, { kind: "component", type: i6.DxLoadPanelComponent, selector: "dx-load-panel", inputs: ["animation", "closeOnOutsideClick", "container", "copyRootClassesToWrapper", "deferRendering", "delay", "elementAttr", "focusStateEnabled", "height", "hideOnOutsideClick", "hideOnParentScroll", "hint", "hoverStateEnabled", "indicatorSrc", "maxHeight", "maxWidth", "message", "minHeight", "minWidth", "position", "rtlEnabled", "shading", "shadingColor", "showIndicator", "showPane", "visible", "width", "wrapperAttr"], outputs: ["onContentReady", "onDisposing", "onHidden", "onHiding", "onInitialized", "onOptionChanged", "onShowing", "onShown", "animationChange", "closeOnOutsideClickChange", "containerChange", "copyRootClassesToWrapperChange", "deferRenderingChange", "delayChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hideOnOutsideClickChange", "hideOnParentScrollChange", "hintChange", "hoverStateEnabledChange", "indicatorSrcChange", "maxHeightChange", "maxWidthChange", "messageChange", "minHeightChange", "minWidthChange", "positionChange", "rtlEnabledChange", "shadingChange", "shadingColorChange", "showIndicatorChange", "showPaneChange", "visibleChange", "widthChange", "wrapperAttrChange"] }, { kind: "component", type: i7.FormComponent, selector: "rs-form", inputs: ["tenant", "className", "oid", "copyOid", "template", "params", "tabViewContainerRef", "onlyFrontEnd", "model", "readonly"], outputs: ["submitCallback"] }] });
+DataDetailComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: DataDetailComponent, selector: "coast-data-detail", providers: [DataDetailService], ngImport: i0, template: "<dx-load-panel [container]=\"viewContainerRef.element.nativeElement\" [showPane]=\"false\"\n               [visible]=\"loading\">\n  <dxo-position [of]=\"viewContainerRef.element.nativeElement\"></dxo-position>\n</dx-load-panel>\n<div *ngIf=\"!loading && sections.length === 0\" class=\"empty\">\n  <span>\u60A8\u65E0\u6743\u67E5\u770B\u8BE5\u6570\u636E\u5B9E\u4F8B\u4EFB\u4F55\u4FE1\u606F</span>\n</div>\n<ng-container *ngIf=\"sections.length > 0\">\n  <dx-accordion [collapsible]=\"true\" [multiple]=\"true\" [deferRendering]=\"false\" [dataSource]=\"sections\"\n                [selectedItems]=\"sections\">\n    <div *dxTemplate=\"let section of 'title'\" class=\"section-title\">\n      <div class=\"section-title-name\">{{ section.name }}</div>\n    </div>\n    <div *dxTemplate=\"let section of 'item'\">\n      <rs-form [tenant]=\"tenant\" [className]=\"className\" [oid]=\"oid\" [template]=\"section.formTemplate\" [params]=\"params\"\n               [tabViewContainerRef]=\"tabViewContainerRef\" [readonly]=\"true\"></rs-form>\n    </div>\n  </dx-accordion>\n</ng-container>\n", styles: [":host{flex:1;padding:24px;display:flex;flex-flow:column nowrap}:host div.empty{flex:1;padding:16px;display:flex;flex-flow:row nowrap;justify-content:center;align-items:center}:host div.empty span{text-align:center;-webkit-user-select:none;user-select:none}:host .section-title{border-bottom:1px solid var(--coast-border-color, #dddddd)}:host .section-title .section-title-name{height:24px;font-size:14px;font-weight:700;padding:4px 8px;display:flex;flex-flow:column nowrap;justify-content:center}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.DxAccordionComponent, selector: "dx-accordion", inputs: ["accessKey", "activeStateEnabled", "animationDuration", "collapsible", "dataSource", "deferRendering", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "itemHoldTimeout", "items", "itemTemplate", "itemTitleTemplate", "keyExpr", "multiple", "noDataText", "repaintChangesOnly", "rtlEnabled", "selectedIndex", "selectedItem", "selectedItemKeys", "selectedItems", "tabIndex", "visible", "width"], outputs: ["onContentReady", "onDisposing", "onInitialized", "onItemClick", "onItemContextMenu", "onItemHold", "onItemRendered", "onItemTitleClick", "onOptionChanged", "onSelectionChanged", "accessKeyChange", "activeStateEnabledChange", "animationDurationChange", "collapsibleChange", "dataSourceChange", "deferRenderingChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "itemHoldTimeoutChange", "itemsChange", "itemTemplateChange", "itemTitleTemplateChange", "keyExprChange", "multipleChange", "noDataTextChange", "repaintChangesOnlyChange", "rtlEnabledChange", "selectedIndexChange", "selectedItemChange", "selectedItemKeysChange", "selectedItemsChange", "tabIndexChange", "visibleChange", "widthChange"] }, { kind: "directive", type: i4.DxTemplateDirective, selector: "[dxTemplate]", inputs: ["dxTemplateOf"] }, { kind: "component", type: i5.DxoPositionComponent, selector: "dxo-position", inputs: ["at", "boundary", "boundaryOffset", "collision", "my", "of", "offset"] }, { kind: "component", type: i6.DxLoadPanelComponent, selector: "dx-load-panel", inputs: ["animation", "closeOnOutsideClick", "container", "copyRootClassesToWrapper", "deferRendering", "delay", "elementAttr", "focusStateEnabled", "height", "hideOnOutsideClick", "hideOnParentScroll", "hint", "hoverStateEnabled", "indicatorSrc", "maxHeight", "maxWidth", "message", "minHeight", "minWidth", "position", "rtlEnabled", "shading", "shadingColor", "showIndicator", "showPane", "visible", "width", "wrapperAttr"], outputs: ["onContentReady", "onDisposing", "onHidden", "onHiding", "onInitialized", "onOptionChanged", "onShowing", "onShown", "animationChange", "closeOnOutsideClickChange", "containerChange", "copyRootClassesToWrapperChange", "deferRenderingChange", "delayChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hideOnOutsideClickChange", "hideOnParentScrollChange", "hintChange", "hoverStateEnabledChange", "indicatorSrcChange", "maxHeightChange", "maxWidthChange", "messageChange", "minHeightChange", "minWidthChange", "positionChange", "rtlEnabledChange", "shadingChange", "shadingColorChange", "showIndicatorChange", "showPaneChange", "visibleChange", "widthChange", "wrapperAttrChange"] }, { kind: "component", type: i7.FormComponent, selector: "rs-form", inputs: ["tenant", "className", "oid", "copyOid", "template", "extraAttrMap", "params", "tabViewContainerRef", "onlyFrontEnd", "model", "readonly"], outputs: ["submitCallback"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DataDetailComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'coast-data-detail', providers: [DataDetailService], template: "<dx-load-panel [container]=\"viewContainerRef.element.nativeElement\" [showPane]=\"false\"\n               [visible]=\"loading\">\n  <dxo-position [of]=\"viewContainerRef.element.nativeElement\"></dxo-position>\n</dx-load-panel>\n<div *ngIf=\"!loading && sections.length === 0\" class=\"empty\">\n  <span>\u60A8\u65E0\u6743\u67E5\u770B\u8BE5\u6570\u636E\u5B9E\u4F8B\u4EFB\u4F55\u4FE1\u606F</span>\n</div>\n<ng-container *ngIf=\"sections.length > 0\">\n  <dx-accordion [collapsible]=\"true\" [multiple]=\"true\" [deferRendering]=\"false\" [dataSource]=\"sections\"\n                [selectedItems]=\"sections\">\n    <div *dxTemplate=\"let section of 'title'\" class=\"section-title\">\n      <div class=\"section-title-name\">{{section.name}}</div>\n    </div>\n    <div *dxTemplate=\"let section of 'item'\">\n      <rs-form [tenant]=\"tenant\" [className]=\"className\" [oid]=\"oid\" [template]=\"section.formTemplate\"\n               [readonly]=\"true\"></rs-form>\n    </div>\n  </dx-accordion>\n</ng-container>\n", styles: [":host{flex:1;padding:24px;display:flex;flex-flow:column nowrap}:host div.empty{flex:1;padding:16px;display:flex;flex-flow:row nowrap;justify-content:center;align-items:center}:host div.empty span{text-align:center;-webkit-user-select:none;user-select:none}:host .section-title{border-bottom:1px solid var(--coast-border-color, #dddddd)}:host .section-title .section-title-name{height:24px;font-size:14px;font-weight:700;padding:4px 8px;display:flex;flex-flow:column nowrap;justify-content:center}\n"] }]
-        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i1.DataDetailService }]; }, propDecorators: { tenant: [{
-                type: Input
-            }], className: [{
-                type: Input
-            }], oid: [{
-                type: Input
-            }], params: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+            args: [{ selector: 'coast-data-detail', providers: [DataDetailService], template: "<dx-load-panel [container]=\"viewContainerRef.element.nativeElement\" [showPane]=\"false\"\n               [visible]=\"loading\">\n  <dxo-position [of]=\"viewContainerRef.element.nativeElement\"></dxo-position>\n</dx-load-panel>\n<div *ngIf=\"!loading && sections.length === 0\" class=\"empty\">\n  <span>\u60A8\u65E0\u6743\u67E5\u770B\u8BE5\u6570\u636E\u5B9E\u4F8B\u4EFB\u4F55\u4FE1\u606F</span>\n</div>\n<ng-container *ngIf=\"sections.length > 0\">\n  <dx-accordion [collapsible]=\"true\" [multiple]=\"true\" [deferRendering]=\"false\" [dataSource]=\"sections\"\n                [selectedItems]=\"sections\">\n    <div *dxTemplate=\"let section of 'title'\" class=\"section-title\">\n      <div class=\"section-title-name\">{{ section.name }}</div>\n    </div>\n    <div *dxTemplate=\"let section of 'item'\">\n      <rs-form [tenant]=\"tenant\" [className]=\"className\" [oid]=\"oid\" [template]=\"section.formTemplate\" [params]=\"params\"\n               [tabViewContainerRef]=\"tabViewContainerRef\" [readonly]=\"true\"></rs-form>\n    </div>\n  </dx-accordion>\n</ng-container>\n", styles: [":host{flex:1;padding:24px;display:flex;flex-flow:column nowrap}:host div.empty{flex:1;padding:16px;display:flex;flex-flow:row nowrap;justify-content:center;align-items:center}:host div.empty span{text-align:center;-webkit-user-select:none;user-select:none}:host .section-title{border-bottom:1px solid var(--coast-border-color, #dddddd)}:host .section-title .section-title-name{height:24px;font-size:14px;font-weight:700;padding:4px 8px;display:flex;flex-flow:column nowrap;justify-content:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i1.DataDetailService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic-params/dynamic-params.component.mjs

@@ -1,10 +1,18 @@
-import { Component, Input } from '@angular/core';
+import { Component, ContentChild, Input } from '@angular/core';
+import { TooltipContentTemplateDirective } from "./tooltip-content-template.directive";
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
-import * as i2 from "devextreme-angular/ui/button";
-import * as i3 from "devextreme-angular/ui/text-box";
+import * as i2 from "devextreme-angular/core";
+import * as i3 from "devextreme-angular/ui/button";
+import * as i4 from "devextreme-angular/ui/text-box";
+import * as i5 from "devextreme-angular/ui/tooltip";
 export class DynamicParamsComponent {
     constructor() {
+        this.label = '动态参数';
+        this.showHelp = false;
+        this.keyPlaceholder = '参数名';
+        this.valuePlaceholder = '参数值';
+        this.required = false;
         this.readonly = false;
     }
     add() {
@@ -15,15 +23,26 @@ export class DynamicParamsComponent {
     }
 }
 DynamicParamsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-DynamicParamsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: DynamicParamsComponent, selector: "rs-dynamic-params", inputs: { label: "label", params: "params", readonly: "readonly" }, ngImport: i0, template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>{{label || '\u52A8\u6001\u53C2\u6570'}}</span>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"\n               [disabled]=\"readonly\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box placeholder=\"\u53C2\u6570\u540D\" [(value)]=\"param.name\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-text-box placeholder=\"\u53C2\u6570\u503C\" [(value)]=\"param.value\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\" [disabled]=\"readonly\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i2.DxButtonComponent, selector: "dx-button", inputs: ["accessKey", "activeStateEnabled", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "icon", "rtlEnabled", "stylingMode", "tabIndex", "template", "text", "type", "useSubmitBehavior", "validationGroup", "visible", "width"], outputs: ["onClick", "onContentReady", "onDisposing", "onInitialized", "onOptionChanged", "accessKeyChange", "activeStateEnabledChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "iconChange", "rtlEnabledChange", "stylingModeChange", "tabIndexChange", "templateChange", "textChange", "typeChange", "useSubmitBehaviorChange", "validationGroupChange", "visibleChange", "widthChange"] }, { kind: "component", type: i3.DxTextBoxComponent, selector: "dx-text-box", inputs: ["accessKey", "activeStateEnabled", "buttons", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "inputAttr", "isValid", "label", "labelMode", "mask", "maskChar", "maskInvalidMessage", "maskRules", "maxLength", "mode", "name", "placeholder", "readOnly", "rtlEnabled", "showClearButton", "showMaskMode", "spellcheck", "stylingMode", "tabIndex", "text", "useMaskedValue", "validationError", "validationErrors", "validationMessageMode", "validationMessagePosition", "validationStatus", "value", "valueChangeEvent", "visible", "width"], outputs: ["onChange", "onContentReady", "onCopy", "onCut", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onKeyDown", "onKeyUp", "onOptionChanged", "onPaste", "onValueChanged", "accessKeyChange", "activeStateEnabledChange", "buttonsChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "labelChange", "labelModeChange", "maskChange", "maskCharChange", "maskInvalidMessageChange", "maskRulesChange", "maxLengthChange", "modeChange", "nameChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "showClearButtonChange", "showMaskModeChange", "spellcheckChange", "stylingModeChange", "tabIndexChange", "textChange", "useMaskedValueChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationMessagePositionChange", "validationStatusChange", "valueChange", "valueChangeEventChange", "visibleChange", "widthChange", "onBlur"] }] });
+DynamicParamsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: DynamicParamsComponent, selector: "rs-dynamic-params", inputs: { label: "label", showHelp: "showHelp", keyPlaceholder: "keyPlaceholder", valuePlaceholder: "valuePlaceholder", params: "params", required: "required", readonly: "readonly" }, queries: [{ propertyName: "tooltipContentTemplate", first: true, predicate: TooltipContentTemplateDirective, descendants: true }], ngImport: i0, template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>{{ label }}</span>\n    <span *ngIf=\"required\" class=\"required-mark\">&nbsp;*</span>\n    <i *ngIf=\"showHelp\" #dynamicParamsSpan class=\"coast-icon-help cursor-pointer\">\n      <dx-tooltip [target]=\"dynamicParamsSpan\"\n                  [position]=\"'top'\"\n                  [showEvent]=\"'mouseover'\"\n                  [hideEvent]=\"'mouseout'\">\n        <div *dxTemplate=\"let data of 'content'\"\n             style=\"display: flex; flex-flow: column nowrap;align-items: flex-start;\">\n          <ng-container [ngTemplateOutlet]=\"tooltipContentTemplate.templateRef\"></ng-container>\n        </div>\n      </dx-tooltip>\n    </i>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"\n               [disabled]=\"readonly\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box [placeholder]=\"keyPlaceholder\" [(value)]=\"param.name\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-text-box [placeholder]=\"valuePlaceholder\" [(value)]=\"param.value\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\" [disabled]=\"readonly\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.DxTemplateDirective, selector: "[dxTemplate]", inputs: ["dxTemplateOf"] }, { kind: "component", type: i3.DxButtonComponent, selector: "dx-button", inputs: ["accessKey", "activeStateEnabled", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "icon", "rtlEnabled", "stylingMode", "tabIndex", "template", "text", "type", "useSubmitBehavior", "validationGroup", "visible", "width"], outputs: ["onClick", "onContentReady", "onDisposing", "onInitialized", "onOptionChanged", "accessKeyChange", "activeStateEnabledChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "iconChange", "rtlEnabledChange", "stylingModeChange", "tabIndexChange", "templateChange", "textChange", "typeChange", "useSubmitBehaviorChange", "validationGroupChange", "visibleChange", "widthChange"] }, { kind: "component", type: i4.DxTextBoxComponent, selector: "dx-text-box", inputs: ["accessKey", "activeStateEnabled", "buttons", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "inputAttr", "isValid", "label", "labelMode", "mask", "maskChar", "maskInvalidMessage", "maskRules", "maxLength", "mode", "name", "placeholder", "readOnly", "rtlEnabled", "showClearButton", "showMaskMode", "spellcheck", "stylingMode", "tabIndex", "text", "useMaskedValue", "validationError", "validationErrors", "validationMessageMode", "validationMessagePosition", "validationStatus", "value", "valueChangeEvent", "visible", "width"], outputs: ["onChange", "onContentReady", "onCopy", "onCut", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onKeyDown", "onKeyUp", "onOptionChanged", "onPaste", "onValueChanged", "accessKeyChange", "activeStateEnabledChange", "buttonsChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "labelChange", "labelModeChange", "maskChange", "maskCharChange", "maskInvalidMessageChange", "maskRulesChange", "maxLengthChange", "modeChange", "nameChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "showClearButtonChange", "showMaskModeChange", "spellcheckChange", "stylingModeChange", "tabIndexChange", "textChange", "useMaskedValueChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationMessagePositionChange", "validationStatusChange", "valueChange", "valueChangeEventChange", "visibleChange", "widthChange", "onBlur"] }, { kind: "component", type: i5.DxTooltipComponent, selector: "dx-tooltip", inputs: ["animation", "closeOnOutsideClick", "container", "contentTemplate", "copyRootClassesToWrapper", "deferRendering", "disabled", "elementAttr", "height", "hideEvent", "hideOnOutsideClick", "hideOnParentScroll", "hint", "hoverStateEnabled", "maxHeight", "maxWidth", "minHeight", "minWidth", "position", "rtlEnabled", "shading", "shadingColor", "showEvent", "target", "visible", "width", "wrapperAttr"], outputs: ["onContentReady", "onDisposing", "onHidden", "onHiding", "onInitialized", "onOptionChanged", "onShowing", "onShown", "animationChange", "closeOnOutsideClickChange", "containerChange", "contentTemplateChange", "copyRootClassesToWrapperChange", "deferRenderingChange", "disabledChange", "elementAttrChange", "heightChange", "hideEventChange", "hideOnOutsideClickChange", "hideOnParentScrollChange", "hintChange", "hoverStateEnabledChange", "maxHeightChange", "maxWidthChange", "minHeightChange", "minWidthChange", "positionChange", "rtlEnabledChange", "shadingChange", "shadingColorChange", "showEventChange", "targetChange", "visibleChange", "widthChange", "wrapperAttrChange"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'rs-dynamic-params', template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>{{label || '\u52A8\u6001\u53C2\u6570'}}</span>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"\n               [disabled]=\"readonly\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box placeholder=\"\u53C2\u6570\u540D\" [(value)]=\"param.name\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-text-box placeholder=\"\u53C2\u6570\u503C\" [(value)]=\"param.value\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\" [disabled]=\"readonly\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"] }]
+            args: [{ selector: 'rs-dynamic-params', template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>{{ label }}</span>\n    <span *ngIf=\"required\" class=\"required-mark\">&nbsp;*</span>\n    <i *ngIf=\"showHelp\" #dynamicParamsSpan class=\"coast-icon-help cursor-pointer\">\n      <dx-tooltip [target]=\"dynamicParamsSpan\"\n                  [position]=\"'top'\"\n                  [showEvent]=\"'mouseover'\"\n                  [hideEvent]=\"'mouseout'\">\n        <div *dxTemplate=\"let data of 'content'\"\n             style=\"display: flex; flex-flow: column nowrap;align-items: flex-start;\">\n          <ng-container [ngTemplateOutlet]=\"tooltipContentTemplate.templateRef\"></ng-container>\n        </div>\n      </dx-tooltip>\n    </i>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"\n               [disabled]=\"readonly\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box [placeholder]=\"keyPlaceholder\" [(value)]=\"param.name\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-text-box [placeholder]=\"valuePlaceholder\" [(value)]=\"param.value\" [disabled]=\"readonly\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\" [disabled]=\"readonly\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"] }]
         }], propDecorators: { label: [{
                 type: Input
+            }], showHelp: [{
+                type: Input
+            }], keyPlaceholder: [{
+                type: Input
+            }], valuePlaceholder: [{
+                type: Input
             }], params: [{
                 type: Input
+            }], required: [{
+                type: Input
             }], readonly: [{
                 type: Input
+            }], tooltipContentTemplate: [{
+                type: ContentChild,
+                args: [TooltipContentTemplateDirective]
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1wYXJhbXMuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJzLWFudC9zcmMvZHluYW1pYy1wYXJhbXMvZHluYW1pYy1wYXJhbXMuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJzLWFudC9zcmMvZHluYW1pYy1wYXJhbXMvZHluYW1pYy1wYXJhbXMuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUMsTUFBTSxlQUFlLENBQUM7Ozs7O0FBTy9DLE1BQU0sT0FBTyxzQkFBc0I7SUFMbkM7UUFXRSxhQUFRLEdBQUcsS0FBSyxDQUFDO0tBU2xCO0lBUEMsR0FBRztRQUNELElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUMsSUFBSSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFDLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQWE7UUFDbEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQy9CLENBQUM7O21IQWRVLHNCQUFzQjt1R0FBdEIsc0JBQXNCLDZIQ1BuQywrekJBZUE7MkZEUmEsc0JBQXNCO2tCQUxsQyxTQUFTOytCQUNFLG1CQUFtQjs4QkFNN0IsS0FBSztzQkFESixLQUFLO2dCQUdOLE1BQU07c0JBREwsS0FBSztnQkFHTixRQUFRO3NCQURQLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbXBvbmVudCwgSW5wdXR9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdycy1keW5hbWljLXBhcmFtcycsXG4gIHRlbXBsYXRlVXJsOiAnLi9keW5hbWljLXBhcmFtcy5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2R5bmFtaWMtcGFyYW1zLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgRHluYW1pY1BhcmFtc0NvbXBvbmVudCB7XG4gIEBJbnB1dCgpXG4gIGxhYmVsOiBhbnk7XG4gIEBJbnB1dCgpXG4gIHBhcmFtcyE6IHsgbmFtZTogc3RyaW5nLCB2YWx1ZTogc3RyaW5nIH1bXTtcbiAgQElucHV0KClcbiAgcmVhZG9ubHkgPSBmYWxzZTtcblxuICBhZGQoKSB7XG4gICAgdGhpcy5wYXJhbXMucHVzaCh7bmFtZTogJycsIHZhbHVlOiAnJ30pO1xuICB9XG5cbiAgZGVsZXRlKGluZGV4OiBudW1iZXIpIHtcbiAgICB0aGlzLnBhcmFtcy5zcGxpY2UoaW5kZXgsIDEpO1xuICB9XG59XG4iLCI8ZGl2IGNsYXNzPVwiZHgtZmllbGRcIj5cbiAgPGRpdiBjbGFzcz1cImR4LWZpZWxkLWxhYmVsXCI+XG4gICAgPHNwYW4+e3tsYWJlbCB8fCAn5Yqo5oCB5Y+C5pWwJ319PC9zcGFuPlxuICAgIDxkeC1idXR0b24gdHlwZT1cImRlZmF1bHRcIiBzdHlsaW5nTW9kZT1cInRleHRcIiBpY29uPVwiY29hc3QtaWNvbiBjb2FzdC1pY29uLWFkZFwiIChvbkNsaWNrKT1cImFkZCgpXCJcbiAgICAgICAgICAgICAgIFtkaXNhYmxlZF09XCJyZWFkb25seVwiPjwvZHgtYnV0dG9uPlxuICA8L2Rpdj5cbiAgPGRpdiBjbGFzcz1cImR4LWZpZWxkLXZhbHVlXCI+XG4gICAgPGRpdiAqbmdGb3I9XCJsZXQgcGFyYW0gb2YgcGFyYW1zOyBsZXQgaW5kZXggPSBpbmRleFwiPlxuICAgICAgPGR4LXRleHQtYm94IHBsYWNlaG9sZGVyPVwi5Y+C5pWw5ZCNXCIgWyh2YWx1ZSldPVwicGFyYW0ubmFtZVwiIFtkaXNhYmxlZF09XCJyZWFkb25seVwiPjwvZHgtdGV4dC1ib3g+XG4gICAgICA8ZHgtdGV4dC1ib3ggcGxhY2Vob2xkZXI9XCLlj4LmlbDlgLxcIiBbKHZhbHVlKV09XCJwYXJhbS52YWx1ZVwiIFtkaXNhYmxlZF09XCJyZWFkb25seVwiPjwvZHgtdGV4dC1ib3g+XG4gICAgICA8ZHgtYnV0dG9uIHR5cGU9XCJkYW5nZXJcIiBzdHlsaW5nTW9kZT1cInRleHRcIiBpY29uPVwiY29hc3QtaWNvbiBjb2FzdC1pY29uLWNsb3NlXCJcbiAgICAgICAgICAgICAgICAgKG9uQ2xpY2spPVwiZGVsZXRlKGluZGV4KVwiIFtkaXNhYmxlZF09XCJyZWFkb25seVwiPjwvZHgtYnV0dG9uPlxuICAgIDwvZGl2PlxuICA8L2Rpdj5cbjwvZGl2PlxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic-params/dynamic-params.module.mjs

@@ -2,27 +2,32 @@ import { NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { DynamicParamsComponent } from './dynamic-params.component';
 import { DevExtremeModule } from "devextreme-angular";
+import { TooltipContentTemplateDirective } from './tooltip-content-template.directive';
 import * as i0 from "@angular/core";
 export class DynamicParamsModule {
 }
 DynamicParamsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-DynamicParamsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsModule, declarations: [DynamicParamsComponent], imports: [CommonModule,
-        DevExtremeModule], exports: [DynamicParamsComponent] });
+DynamicParamsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsModule, declarations: [DynamicParamsComponent,
+        TooltipContentTemplateDirective], imports: [CommonModule,
+        DevExtremeModule], exports: [DynamicParamsComponent,
+        TooltipContentTemplateDirective] });
 DynamicParamsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsModule, imports: [CommonModule,
         DevExtremeModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
-                        DynamicParamsComponent
+                        DynamicParamsComponent,
+                        TooltipContentTemplateDirective
                     ],
                     imports: [
                         CommonModule,
                         DevExtremeModule
                     ],
                     exports: [
-                        DynamicParamsComponent
+                        DynamicParamsComponent,
+                        TooltipContentTemplateDirective
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1wYXJhbXMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJzLWFudC9zcmMvZHluYW1pYy1wYXJhbXMvZHluYW1pYy1wYXJhbXMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBQ2xFLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLG9CQUFvQixDQUFDOztBQWNwRCxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsaUJBVjVCLHNCQUFzQixhQUd0QixZQUFZO1FBQ1osZ0JBQWdCLGFBR2hCLHNCQUFzQjtpSEFHYixtQkFBbUIsWUFQNUIsWUFBWTtRQUNaLGdCQUFnQjsyRkFNUCxtQkFBbUI7a0JBWi9CLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFO3dCQUNaLHNCQUFzQjtxQkFDdkI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osZ0JBQWdCO3FCQUNqQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1Asc0JBQXNCO3FCQUN2QjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge0R5bmFtaWNQYXJhbXNDb21wb25lbnR9IGZyb20gJy4vZHluYW1pYy1wYXJhbXMuY29tcG9uZW50JztcbmltcG9ydCB7RGV2RXh0cmVtZU1vZHVsZX0gZnJvbSBcImRldmV4dHJlbWUtYW5ndWxhclwiO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBEeW5hbWljUGFyYW1zQ29tcG9uZW50XG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgRGV2RXh0cmVtZU1vZHVsZVxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgRHluYW1pY1BhcmFtc0NvbXBvbmVudFxuICBdXG59KVxuZXhwb3J0IGNsYXNzIER5bmFtaWNQYXJhbXNNb2R1bGUge1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1wYXJhbXMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJzLWFudC9zcmMvZHluYW1pYy1wYXJhbXMvZHluYW1pYy1wYXJhbXMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBQ2xFLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLG9CQUFvQixDQUFDO0FBQ3BELE9BQU8sRUFBQywrQkFBK0IsRUFBQyxNQUFNLHNDQUFzQyxDQUFDOztBQWdCckYsTUFBTSxPQUFPLG1CQUFtQjs7Z0hBQW5CLG1CQUFtQjtpSEFBbkIsbUJBQW1CLGlCQVo1QixzQkFBc0I7UUFDdEIsK0JBQStCLGFBRy9CLFlBQVk7UUFDWixnQkFBZ0IsYUFHaEIsc0JBQXNCO1FBQ3RCLCtCQUErQjtpSEFHdEIsbUJBQW1CLFlBUjVCLFlBQVk7UUFDWixnQkFBZ0I7MkZBT1AsbUJBQW1CO2tCQWQvQixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRTt3QkFDWixzQkFBc0I7d0JBQ3RCLCtCQUErQjtxQkFDaEM7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osZ0JBQWdCO3FCQUNqQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1Asc0JBQXNCO3dCQUN0QiwrQkFBK0I7cUJBQ2hDO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7RHluYW1pY1BhcmFtc0NvbXBvbmVudH0gZnJvbSAnLi9keW5hbWljLXBhcmFtcy5jb21wb25lbnQnO1xuaW1wb3J0IHtEZXZFeHRyZW1lTW9kdWxlfSBmcm9tIFwiZGV2ZXh0cmVtZS1hbmd1bGFyXCI7XG5pbXBvcnQge1Rvb2x0aXBDb250ZW50VGVtcGxhdGVEaXJlY3RpdmV9IGZyb20gJy4vdG9vbHRpcC1jb250ZW50LXRlbXBsYXRlLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIER5bmFtaWNQYXJhbXNDb21wb25lbnQsXG4gICAgVG9vbHRpcENvbnRlbnRUZW1wbGF0ZURpcmVjdGl2ZVxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIERldkV4dHJlbWVNb2R1bGVcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIER5bmFtaWNQYXJhbXNDb21wb25lbnQsXG4gICAgVG9vbHRpcENvbnRlbnRUZW1wbGF0ZURpcmVjdGl2ZVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIER5bmFtaWNQYXJhbXNNb2R1bGUge1xufVxuIl19

package/esm2020/dynamic-params/tooltip-content-template.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TooltipContentTemplateDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+TooltipContentTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TooltipContentTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+TooltipContentTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.7", type: TooltipContentTemplateDirective, selector: "[rsTooltipContentTemplate]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TooltipContentTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rsTooltipContentTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1jb250ZW50LXRlbXBsYXRlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1ycy1hbnQvc3JjL2R5bmFtaWMtcGFyYW1zL3Rvb2x0aXAtY29udGVudC10ZW1wbGF0ZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBYyxNQUFNLGVBQWUsQ0FBQzs7QUFLckQsTUFBTSxPQUFPLCtCQUErQjtJQUMxQyxZQUFtQixXQUFpQztRQUFqQyxnQkFBVyxHQUFYLFdBQVcsQ0FBc0I7SUFDcEQsQ0FBQzs7NEhBRlUsK0JBQStCO2dIQUEvQiwrQkFBK0I7MkZBQS9CLCtCQUErQjtrQkFIM0MsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsNEJBQTRCO2lCQUN2QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBUZW1wbGF0ZVJlZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tyc1Rvb2x0aXBDb250ZW50VGVtcGxhdGVdJ1xufSlcbmV4cG9ydCBjbGFzcyBUb29sdGlwQ29udGVudFRlbXBsYXRlRGlyZWN0aXZlIHtcbiAgY29uc3RydWN0b3IocHVibGljIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjx1bmtub3duPikge1xuICB9XG59XG4iXX0=