update 移除无用类型

This commit is contained in:
LiuHao 2024-02-01 18:01:03 +08:00
parent bd1ddf7691
commit 8fd8341b36
12 changed files with 0 additions and 1556 deletions

View File

@ -1,29 +0,0 @@
// @Description:扩展
declare interface ScriptForm extends BpmnScript {
scriptType?: string;
}
declare interface ExecutionListenerForm extends BpmnExecutionListener {
type: string;
script?: ScriptForm;
}
declare interface FormItemVisible {
listenerType: string;
scriptType: string;
}
declare interface ConditionalForm {
conditionType?: string;
expression?: string;
scriptType?: string;
language?: string;
body?: string;
resource?: string;
}
// 任务监听器声明
declare interface TaskListenerForm extends BpmnTaskListener {
type: string;
script?: ScriptForm;
}

View File

@ -1,62 +0,0 @@
// @Description:扩展
declare interface BpmnScript {
scriptFormat?: string;
resource?: string;
value?: string;
}
declare interface BpmnField {
name: string;
expression?: string;
stringValue?: string;
string?: string;
htmlVar?: string;
}
declare interface BpmnExtensionElements {
values: any[];
}
declare interface BpmnExecutionListener {
event: string;
expression?: string;
class?: string;
delegateExpression?: string;
script?: BpmnScript;
fields?: BpmnField[];
}
declare interface BpmnExtensionProperty {
id?: string;
name?: string;
value?: string;
}
declare interface BpmnExtensionProperties {
values: BpmnExtensionProperty[];
}
// 任务监听器相关
declare interface BpmnTaskElements {
values: any[];
}
declare interface BpmnTaskListener {
event: string;
expression?: string;
class?: string;
delegateExpression?: string;
script?: BpmnScript;
fields?: BpmnField[];
}
declare interface BpmnTaskProperty {
id?: string;
name?: string;
value?: string;
}
declare interface BpmnTaskProperties {
values: BpmnTaskProperty[];
}

View File

@ -1,106 +0,0 @@
declare module 'bpmn-js-bpmnlint' {
import { Injector, ModuleDefinition } from 'didi';
import Modeler from 'bpmn-js/lib/Modeler';
import Canvas from 'diagram-js/lib/core/Canvas';
import ElementRegistry from 'diagram-js/lib/core/ElementRegistry';
import EventBus from 'diagram-js/lib/core/EventBus';
import Overlays from 'diagram-js/lib/features/overlays/Overlays';
import EditorActions from 'diagram-js/lib/features/editor-actions/EditorActions';
type EmptyConfig = {
resolver: {
resolveRule: () => unknown;
};
config: Record<string, any>;
};
type State = 'error' | 'warning';
type ButtonState = State | 'inactive' | 'success';
type Entry = {
rule: string;
message: string;
actualElementId: string;
};
type Issue = {
id: string;
category: string;
message: string;
rule: string;
};
type Issues = Record<string, Issue[]>[];
class Linting {
protected _bpmnjs: Modeler;
protected _canvas: Canvas;
protected _config: any;
protected _elementRegistry: ElementRegistry;
protected _eventBus: EventBus;
protected _overlays: Overlays;
protected _translate: Translate;
protected _issues: Record<string, any>;
protected _active: boolean;
protected _linterConfig: EmptyConfig;
protected _overlayIds: Record<string, string>;
constructor(
bpmnjs: Modeler,
canvas: Canvas,
config: any,
elementRegistry: ElementRegistry,
eventBus: EventBus,
overlays: Overlays,
translate: Translate
);
_init(): void;
_fireComplete(issues: Issues[]): void;
_createIssues(issues: Issues[]): void;
_createElementIssues(elementId: string, elementIssues: Issues[]): void;
_formatIssues(issues: Record<string, Issue>): Issues[];
_setActive(active: boolean): void;
_addErrors($ul: Element, errors: Entry[]): void;
_addWarnings($ul: Element, warnings: Entry[]): void;
_addEntry($ul: Element, state: State, entry: Entry): void;
_clearOverlays(): void;
_clearIssues(): void;
_setButtonState(state: ButtonState, errors: object, warnings: object): void;
_updateButton(): void;
_createButton(): void;
setLinterConfig(linterConfig: EmptyConfig): void;
getLinterConfig(): EmptyConfig;
isActive(): boolean;
toggle(newActive: boolean): boolean;
lint(): any;
update(): void;
}
class LintEditorActions extends EditorActions {
constructor(injector: Injector, linting: Linting);
}
const bpmnlint: ModuleDefinition;
export default bpmnlint;
}

View File

@ -1,207 +0,0 @@
declare module 'bpmn-js-token-simulation' {
import ContextPads from 'bpmn-js-token-simulation/lib/features/context-pads/ContextPads';
import ElementNotifications from 'bpmn-js-token-simulation/lib/features/element-notifications/ElementNotifications';
import ElementSupport from 'bpmn-js-token-simulation/lib/features/element-support/ElementSupport';
import Notifications from 'bpmn-js-token-simulation/lib/features/notifications/Notifications';
import ExclusiveGatewaySettings from 'bpmn-js-token-simulation/lib/features/exclusive-gateway-settings/ExclusiveGatewaySettings';
import PauseSimulation from 'bpmn-js-token-simulation/lib/features/pause-simulation/PauseSimulation';
import PreserveElementColors from 'bpmn-js-token-simulation/lib/features/preserve-element-colors/PreserveElementColors';
import ProcessInstanceIds from 'bpmn-js-token-simulation/lib/features/process-instance-ids/ProcessInstanceIds';
import ProcessInstanceSettings from 'bpmn-js-token-simulation/lib/features/process-instance-settings/ProcessInstanceSettings';
import Log from 'bpmn-js-token-simulation/lib/features/log/Log';
import ToggleMode from 'bpmn-js-token-simulation/lib/features/toggle-mode/modeler/ToggleMode';
import ProcessInstances from 'bpmn-js-token-simulation/lib/features/process-instances/ProcessInstances';
import ResetSimulation from 'bpmn-js-token-simulation/lib/features/reset-simulation/ResetSimulation';
import SetAnimationSpeed from 'bpmn-js-token-simulation/lib/features/set-animation-speed/SetAnimationSpeed';
import ShowProcessInstance from 'bpmn-js-token-simulation/lib/features/show-process-instance/ShowProcessInstance';
import SimulationState from 'bpmn-js-token-simulation/lib/features/simulation-state/SimulationState';
import Palette from 'bpmn-js-token-simulation/lib/features/palette/Palette';
import TokenCount from 'bpmn-js-token-simulation/lib/features/token-count/TokenCount';
import TokenSimulationBehavior from 'bpmn-js-token-simulation/lib/features/token-simulation-behavior/TokenSimulationBehavior';
import DisableModeling from 'bpmn-js-token-simulation/lib/features/disable-modeling/DisableModeling';
import KeyboardBindings from 'bpmn-js-token-simulation/lib/features/keyboard-bindings/KeyboardBindings';
import EditorActions from 'bpmn-js-token-simulation/lib/features/editor-actions/EditorActions';
import { ModuleDefinition } from 'didi';
const SimulationModeler: ModuleDefinition & {
animation: ['type', Animation];
contextPads: ['type', ContextPads];
disableModeling: ['type', DisableModeling];
elementNotifications: ['type', ElementNotifications];
elementSupport: ['type', ElementSupport];
exclusiveGatewaySettings: ['type', ExclusiveGatewaySettings];
log: ['type', Log];
notifications: ['type', Notifications];
pauseSimulation: ['type', PauseSimulation];
preserveElementColors: ['type', PreserveElementColors];
processInstanceIds: ['type', ProcessInstanceIds];
processInstanceSettings: ['type', ProcessInstanceSettings];
processInstances: ['type', ProcessInstances];
resetSimulation: ['type', ResetSimulation];
setAnimationSpeed: ['type', SetAnimationSpeed];
showProcessInstance: ['type', ShowProcessInstance];
simulationState: ['type', SimulationState];
toggleMode: ['type', ToggleMode];
tokenCount: ['type', TokenCount];
tokenSimulationBehavior: ['type', TokenSimulationBehavior];
tokenSimulationEditorActions: ['type', EditorActions];
tokenSimulationKeyboardBindings: ['type', KeyboardBindings];
tokenSimulationPalette: ['type', Palette];
};
export default SimulationModeler;
}
declare module 'bpmn-js-token-simulation/lib/viewer' {
import { ModuleDefinition } from 'didi';
import ContextPads from 'bpmn-js-token-simulation/lib/features/context-pads/ContextPads';
import ElementNotifications from 'bpmn-js-token-simulation/lib/features/element-notifications/ElementNotifications';
import ElementSupport from 'bpmn-js-token-simulation/lib/features/element-support/ElementSupport';
import Notifications from 'bpmn-js-token-simulation/lib/features/notifications/Notifications';
import ExclusiveGatewaySettings from 'bpmn-js-token-simulation/lib/features/exclusive-gateway-settings/ExclusiveGatewaySettings';
import PauseSimulation from 'bpmn-js-token-simulation/lib/features/pause-simulation/PauseSimulation';
import PreserveElementColors from 'bpmn-js-token-simulation/lib/features/preserve-element-colors/PreserveElementColors';
import ProcessInstanceIds from 'bpmn-js-token-simulation/lib/features/process-instance-ids/ProcessInstanceIds';
import ProcessInstanceSettings from 'bpmn-js-token-simulation/lib/features/process-instance-settings/ProcessInstanceSettings';
import Log from 'bpmn-js-token-simulation/lib/features/log/Log';
import ToggleMode from 'bpmn-js-token-simulation/lib/features/toggle-mode/viewer/ToggleMode';
import ProcessInstances from 'bpmn-js-token-simulation/lib/features/process-instances/ProcessInstances';
import ResetSimulation from 'bpmn-js-token-simulation/lib/features/reset-simulation/ResetSimulation';
import SetAnimationSpeed from 'bpmn-js-token-simulation/lib/features/set-animation-speed/SetAnimationSpeed';
import ShowProcessInstance from 'bpmn-js-token-simulation/lib/features/show-process-instance/ShowProcessInstance';
import SimulationState from 'bpmn-js-token-simulation/lib/features/simulation-state/SimulationState';
import Palette from 'bpmn-js-token-simulation/lib/features/palette/Palette';
import TokenCount from 'bpmn-js-token-simulation/lib/features/token-count/TokenCount';
import TokenSimulationBehavior from 'bpmn-js-token-simulation/lib/features/token-simulation-behavior/TokenSimulationBehavior';
const SimulationViewer: ModuleDefinition & {
animation: ['type', Animation];
contextPads: ['type', ContextPads];
elementNotifications: ['type', ElementNotifications];
elementSupport: ['type', ElementSupport];
exclusiveGatewaySettings: ['type', ExclusiveGatewaySettings];
log: ['type', Log];
notifications: ['type', Notifications];
pauseSimulation: ['type', PauseSimulation];
preserveElementColors: ['type', PreserveElementColors];
processInstanceIds: ['type', ProcessInstanceIds];
processInstanceSettings: ['type', ProcessInstanceSettings];
processInstances: ['type', ProcessInstances];
resetSimulation: ['type', ResetSimulation];
setAnimationSpeed: ['type', SetAnimationSpeed];
showProcessInstance: ['type', ShowProcessInstance];
simulationState: ['type', SimulationState];
toggleMode: ['type', ToggleMode];
tokenCount: ['type', TokenCount];
tokenSimulationBehavior: ['type', TokenSimulationBehavior];
tokenSimulationPalette: ['type', Palette];
};
export default SimulationViewer;
}
declare module 'bpmn-js-token-simulation/lib/animation/Animation' {
import Canvas from 'diagram-js/lib/core/Canvas';
import EventBus from 'diagram-js/lib/core/EventBus';
export default class Animation {
constructor(canvas: Canvas, eventBus: EventBus);
}
}
declare module 'bpmn-js-token-simulation/lib/features/context-pads/ContextPads' {
import Canvas from 'diagram-js/lib/core/Canvas';
import EventBus from 'diagram-js/lib/core/EventBus';
import ElementRegistry from 'diagram-js/lib/core/ElementRegistry';
import Overlays from 'diagram-js/lib/features/overlays/Overlays';
import { Injector } from 'didi';
import ProcessInstances from 'bpmn-js-token-simulation/lib/features/process-instances/ProcessInstances';
export default class ContextPads {
constructor(
eventBus: EventBus,
elementRegistry: ElementRegistry,
overlays: Overlays,
injector: Injector,
canvas: Canvas,
processInstances: ProcessInstances
);
registerHandler(type: string, handler: object): void;
openContextPads(element: any): void;
openElementContextPads(parent: any): void;
closeContextPads(parent: any): void;
closeElementContextPads(element: any): void;
}
}
declare module 'bpmn-js-token-simulation/lib/features/disable-modeling/DisableModeling' {
export default class DisableModeling {}
}
declare module 'bpmn-js-token-simulation/lib/features/editor-actions/EditorActions' {
export default class EditorActions {}
}
declare module 'bpmn-js-token-simulation/lib/features/element-notifications/ElementNotifications' {
export default class ElementNotifications {}
}
declare module 'bpmn-js-token-simulation/lib/features/element-support/ElementSupport' {
export default class ElementSupport {}
}
declare module 'bpmn-js-token-simulation/lib/features/exclusive-gateway-settings/ExclusiveGatewaySettings' {
export default class ExclusiveGatewaySettings {}
}
declare module 'bpmn-js-token-simulation/lib/features/keyboard-bindings/KeyboardBindings' {
export default class KeyboardBindings {}
}
declare module 'bpmn-js-token-simulation/lib/features/log/Log' {
export default class Log {}
}
declare module 'bpmn-js-token-simulation/lib/features/notifications/Notifications' {
export default class Notifications {}
}
declare module 'bpmn-js-token-simulation/lib/features/palette/Palette' {
export default class Palette {}
}
declare module 'bpmn-js-token-simulation/lib/features/pause-simulation/PauseSimulation' {
export default class PauseSimulation {}
}
declare module 'bpmn-js-token-simulation/lib/features/preserve-element-colors/PreserveElementColors' {
export default class PreserveElementColors {}
}
declare module 'bpmn-js-token-simulation/lib/features/process-instance-ids/ProcessInstanceIds' {
export default class ProcessInstanceIds {}
}
declare module 'bpmn-js-token-simulation/lib/features/process-instances/ProcessInstances' {
export default class ProcessInstances {}
}
declare module 'bpmn-js-token-simulation/lib/features/process-instance-settings/ProcessInstanceSettings' {
export default class ProcessInstanceSettings {}
}
declare module 'bpmn-js-token-simulation/lib/features/reset-simulation/ResetSimulation' {
export default class ResetSimulation {}
}
declare module 'bpmn-js-token-simulation/lib/features/set-animation-speed/SetAnimationSpeed' {
export default class SetAnimationSpeed {}
}
declare module 'bpmn-js-token-simulation/lib/features/show-process-instance/ShowProcessInstance' {
export default class ShowProcessInstance {}
}
declare module 'bpmn-js-token-simulation/lib/features/simulation-state/SimulationState' {
export default class SimulationState {}
}
declare module 'bpmn-js-token-simulation/lib/features/toggle-mode/viewer/ToggleMode' {
export default class ToggleMode {}
}
declare module 'bpmn-js-token-simulation/lib/features/toggle-mode/modeler/ToggleMode' {
export default class ToggleMode {
constructor();
toggleMode(): void;
}
}
declare module 'bpmn-js-token-simulation/lib/features/token-count/TokenCount' {
export default class TokenCount {}
}
declare module 'bpmn-js-token-simulation/lib/features/token-simulation-behavior/TokenSimulationBehavior' {
export default class TokenSimulationBehavior {}
}

View File

@ -1,42 +0,0 @@
declare module 'bpmn-js/lib/util/ModelUtil' {
/**
* Is an element of the given BPMN type?
*
* @param element
* @param type
*
* @return
*/
export function is(element: Element | ModdleElement, type: string): boolean;
/**
* Return true if element has any of the given types.
*
* @param element
* @param types
*
* @return
*/
export function isAny(element: Element | ModdleElement, types: string[]): boolean;
/**
* Return the business object for a given element.
*
* @param element
*
* @return
*/
export function getBusinessObject(element: Element | ModdleElement): ModdleElement;
/**
* Return the di object for a given element.
*
* @param element
*
* @return
*/
export function getDi(element: Element): ModdleElement;
type Element = import('../model/Types').Element;
type ModdleElement = import('../model/Types').ModdleElement;
}

View File

@ -1,808 +0,0 @@
declare module 'bpmn-moddle' {
import { Moddle, ModdleElement, Package } from 'moddle';
export { Moddle, Package, ModdleElement };
type ParseResult = {
rootElement: ModdleElement;
references: object[];
warnings: Error[];
elementsById: { [key: string]: ModdleElement };
};
type ParseError = {
warnings: Error[];
};
type SerializationResult = {
xml: string;
};
// bpmn.json 原始类型
export interface RootElement extends BaseElement {}
export interface BaseElement extends ModdleElement {
id?: string;
documentation?: Documentation;
extensionDefinitions?: ExtensionDefinition[];
extensionElements?: ExtensionElements;
}
export interface Interface extends RootElement {
name?: string;
operations?: Operation[];
implementationRef?: string;
}
export interface Operation extends BaseElement {
name?: string;
inMessageRef?: Message;
outMessageRef?: Message;
errorRef?: Error[];
implementationRef?: string;
}
export interface EndPoint extends RootElement {}
export interface Auditing extends BaseElement {}
export interface GlobalTask extends CallableElement {
resources?: ResourceRole[];
}
export interface Monitoring extends BaseElement {}
export interface Performer extends ResourceRole {}
export interface Process extends FlowElementsContainer, CallableElement {
processType?: ProcessType;
isClosed?: boolean;
auditing?: Auditing;
monitoring?: Monitoring;
properties?: Property[];
laneSets?: LaneSet[];
flowElements?: FlowElement[];
artifacts?: Artifact[];
resources?: ResourceRole[];
correlationSubscriptions?: CorrelationSubscription[];
supports?: Process[];
definitionalCollaborationRef?: Collaboration[];
isExecutable?: boolean;
}
export interface Lane extends BaseElement {
name?: string;
partitionElementRef?: BaseElement[];
partitionElement?: BaseElement;
flowNodeRef?: FlowNode[];
childLaneSet?: LaneSet[];
}
export interface LaneSet extends BaseElement {
lanes?: Lane[];
name?: string;
}
export interface GlobalManualTask extends GlobalTask {}
export interface ManualTask extends Task {}
export interface UserTask extends Task {
renderings?: Rendering[];
implementation?: string;
}
export interface Rendering extends BaseElement {}
export interface HumanPerformer extends Performer {}
export interface PotentialOwner extends HumanPerformer {}
export interface GlobalUserTask extends GlobalTask {
implementation?: string;
renderings?: Rendering[];
}
export interface Gateway extends FlowNode {
gatewayDirection?: GatewayDirection;
}
export interface EventBasedGateway extends Gateway {
instantiate: boolean;
eventGatewayType?: EventBasedGatewayType;
}
export interface ComplexGateway extends Gateway {
activationCondition?: Expression;
default?: SequenceFlow;
}
export interface ExclusiveGateway extends Gateway {
default?: SequenceFlow;
}
export interface InclusiveGateway extends Gateway {
default?: SequenceFlow;
}
export interface ParallelGateway extends Gateway {}
export interface Relationship extends BaseElement {
type?: string;
direction?: RelationshipDirection;
source?: Element[];
target?: Element[];
}
export interface Extension {
mustUnderstand: boolean; //"default": false
definition?: ExtensionDefinition;
}
export interface ExtensionDefinition {
name?: string; //"default": false
extensionAttributeDefinitions?: ExtensionAttributeDefinition[];
}
export interface ExtensionAttributeDefinition {
name?: string;
type?: string;
isReference: boolean;
extensionAttributeDefinitions?: ExtensionAttributeDefinition[];
extensionDefinition?: ExtensionDefinition;
}
export interface ExtensionElements {
valueRef?: Element;
values?: Element[];
extensionAttributeDefinition?: ExtensionAttributeDefinition;
}
export interface Documentation extends BaseElement {
text?: string;
textFormat: string;
}
export interface Event extends FlowNode, InteractionNode {
properties?: Property[];
}
export interface IntermediateCatchEvent extends CatchEvent {}
export interface IntermediateThrowEvent extends ThrowEvent {}
export interface EndEvent extends ThrowEvent {}
export interface StartEvent extends CatchEvent {
isInterrupting: boolean;
}
export interface ThrowEvent extends Event {
dataInputs?: DataInput[];
dataInputAssociations?: DataInputAssociation[];
inputSet?: InputSet;
eventDefinitions?: EventDefinition[];
eventDefinitionRef?: EventDefinition[];
}
export interface CatchEvent extends Event {
parallelMultiple: boolean;
dataOutputs?: DataOutput[];
dataOutputAssociations?: DataOutputAssociation[];
outputSet?: OutputSet;
eventDefinitions?: EventDefinition[];
eventDefinitionRef?: EventDefinition[];
}
export interface BoundaryEvent extends CatchEvent {
cancelActivity: boolean;
attachedToRef?: Activity;
}
export interface EventDefinition extends RootElement {}
export interface CancelEventDefinition extends EventDefinition {}
export interface ErrorEventDefinition extends EventDefinition {
errorRef?: Error;
}
export interface TerminateEventDefinition extends EventDefinition {}
export interface EscalationEventDefinition extends EventDefinition {
escalationRef?: Escalation;
}
export interface Escalation extends RootElement {
structureRef?: ItemDefinition;
name?: string;
escalationCode?: string;
}
export interface CompensateEventDefinition extends EventDefinition {
waitForCompletion: boolean;
activityRef?: Activity;
}
export interface TimerEventDefinition extends EventDefinition {
timeDate?: Expression;
timeCycle?: Expression;
timeDuration?: Expression;
}
export interface LinkEventDefinition extends EventDefinition {
name?: string;
target?: LinkEventDefinition;
source?: LinkEventDefinition;
}
export interface MessageEventDefinition extends EventDefinition {
messageRef?: Message;
operationRef?: Operation;
}
export interface ConditionalEventDefinition extends EventDefinition {
condition?: Expression;
}
export interface SignalEventDefinition extends EventDefinition {
signalRef?: Signal;
}
export interface Signal extends RootElement {
name?: string;
structureRef?: ItemDefinition;
}
export interface ImplicitThrowEvent extends ThrowEvent {}
export interface DataState extends BaseElement {
name?: string;
}
export interface ItemAwareElement extends BaseElement {
itemSubjectRef?: ItemDefinition;
dataState?: DataState;
}
export interface DataAssociation extends BaseElement {
sourceRef?: ItemAwareElement;
targetRef?: ItemAwareElement;
transformation?: FormalExpression;
assignment?: Assignment;
}
export interface DataInput extends ItemAwareElement {
name?: string;
isCollection: boolean;
inputSetRef?: InputSet[];
inputSetWithOptional?: InputSet[];
inputSetWithWhileExecuting?: InputSet[];
}
export interface DataOutput extends ItemAwareElement {
name?: string;
isCollection: boolean;
outputSetRef?: OutputSet[];
outputSetWithOptional?: OutputSet[];
outputSetWithWhileExecuting?: OutputSet[];
}
export interface InputSet extends BaseElement {
name?: string;
dataInputRefs?: DataInput[];
optionalInputRefs?: DataInput[];
whileExecutingInputRefs?: DataInput[];
outputSetRefs?: OutputSet[];
}
export interface OutputSet extends BaseElement {
name?: string;
dataOutputRefs?: DataOutput[];
inputSetRefs?: InputSet[];
optionalOutputRefs?: DataOutput[];
whileExecutingOutputRefs?: DataOutput[];
}
export interface Property extends ItemAwareElement {
name?: string;
}
export interface DataInputAssociation extends DataAssociation {}
export interface DataOutputAssociation extends DataAssociation {}
export interface InputOutputSpecification extends BaseElement {
dataInputs?: DataInput[];
dataOutputs?: DataOutput[];
inputSets?: InputSet[];
outputSets?: OutputSet[];
}
export interface DataObject extends FlowElement, ItemAwareElement {
isCollection: boolean;
}
export interface isCollection {
inputDataRef?: InputSet;
outputDataRef?: OutputSet;
operationRef?: Operation;
}
export interface Assignment extends BaseElement {
from?: Expression;
to?: Expression;
}
export interface DataStore extends RootElement, ItemAwareElement {
name?: string;
capacity?: number;
isUnlimited: boolean;
}
export interface Category extends RootElement, ItemAwareElement {
name?: string;
capacity?: number;
isUnlimited: boolean;
}
export interface DataStoreReference extends ItemAwareElement, FlowElement {
dataStoreRef?: DataStore;
}
export interface DataObjectReference extends ItemAwareElement, FlowElement {
dataObjectRef?: DataObject;
}
export interface ConversationNode extends BaseElement, InteractionNode {
name?: string;
messageFlows?: MessageFlow[];
CorrelationKeys?: CorrelationKey[];
participants?: Participant[];
}
export interface ConversationLink extends BaseElement {
sourceRef?: InteractionNode;
targetRef?: InteractionNode;
name?: string;
}
export interface ConversationAssociation extends BaseElement {
innerConversationNodeRef?: ConversationNode;
outerConversationNodeRef?: ConversationNode;
}
export interface CallConversation extends ConversationNode {
calledCollaborationRef?: Collaboration;
participantAssociations?: ParticipantAssociation[];
}
export interface Conversation extends ConversationNode {}
export interface SubConversation extends ConversationNode {
conversationNodes?: ConversationNode[];
}
export interface conversationNodes extends BaseElement, InteractionNode {
name?: string;
participantRef?: Participant[];
messageFlowRefs?: MessageFlow[];
correlationKeys?: CorrelationKey[];
}
export interface GlobalConversation extends Collaboration {}
export interface PartnerEntity extends RootElement {
name?: string;
participantRef?: Participant[];
}
export interface PartnerRole extends RootElement {
name?: string;
participantRef?: Participant[];
}
export interface CorrelationProperty extends RootElement {
name?: string;
correlationPropertyRetrievalExpression?: CorrelationPropertyRetrievalExpression[];
type?: ItemDefinition;
}
export interface Error extends RootElement {
name?: string;
errorCode?: string;
structureRef?: ItemDefinition;
}
export interface CorrelationKey extends BaseElement {
correlationPropertyRef?: CorrelationProperty[];
name?: string;
}
export interface Expression extends BaseElement {
body?: string;
}
export interface FormalExpression extends Expression {
language?: string;
evaluatesToTypeRef?: ItemDefinition;
}
export interface Message extends RootElement {
language?: string;
itemRef?: ItemDefinition;
}
export interface ItemDefinition extends RootElement {
itemKind?: ItemKind;
structureRef?: string;
isCollection: boolean;
import?: Import;
}
export interface FlowElement extends BaseElement {
name?: string;
auditing?: Auditing;
monitoring?: Monitoring;
categoryValueRef?: CategoryValue[];
}
export interface SequenceFlow extends FlowElement {
conditionExpression?: Expression;
isImmediate?: boolean;
sourceRef?: FlowNode;
targetRef?: FlowNode;
}
export interface FlowElementsContainer extends BaseElement {
laneSets?: LaneSet[];
flowElements?: FlowElement[];
}
export interface CallableElement extends RootElement {
name?: string;
ioSpecification?: InputOutputSpecification;
supportedInterfaceRefs?: Interface[];
ioBinding?: InputOutputBinding[];
}
export interface FlowNode extends FlowElement {
incoming?: SequenceFlow[];
outgoing?: SequenceFlow[];
lanes?: Lane[];
}
export interface CorrelationPropertyRetrievalExpression extends BaseElement {
messagePath?: FormalExpression;
messageRef?: Message;
}
export interface CorrelationPropertyBinding extends BaseElement {
dataPath?: FormalExpression;
correlationPropertyRef?: CorrelationProperty;
}
export interface Resource extends RootElement {
name?: string;
resourceParameters?: ResourceParameter[];
}
export interface ResourceParameter extends RootElement {
name?: string;
isRequired?: boolean;
type?: ItemDefinition;
}
export interface CorrelationSubscription extends BaseElement {
correlationKeyRef?: CorrelationKey[];
correlationPropertyBinding?: CorrelationPropertyBinding[];
}
export interface MessageFlow extends BaseElement {
name?: string;
sourceRef?: InteractionNode;
targetRef?: InteractionNode;
messageRef?: Message;
}
export interface MessageFlowAssociation extends BaseElement {
innerMessageFlowRef?: MessageFlow;
outerMessageFlowRef?: MessageFlow;
}
export interface InteractionNode {
incomingConversationLinks?: ConversationLink[];
outgoingConversationLinks?: ConversationLink[];
}
export interface Participant extends BaseElement, InteractionNode {
name?: string;
interfaceRef?: Interface[];
participantMultiplicity?: ParticipantMultiplicity;
endPointRefs?: EndPoint[];
processRef?: Process;
}
export interface ParticipantAssociation extends BaseElement {
innerParticipantRef?: Participant;
outerParticipantRef?: Participant;
}
export interface ParticipantMultiplicity extends BaseElement {
minimum: number;
maximum: number;
}
export interface Collaboration extends RootElement {
name?: string;
isClosed?: boolean;
participants?: Participant[];
messageFlows?: MessageFlow[];
artifacts?: Artifact[];
conversations?: ConversationNode[];
conversationAssociations?: ConversationAssociation[];
participantAssociations?: ParticipantAssociation[];
messageFlowAssociations?: MessageFlowAssociation[];
correlationKeys?: CorrelationKey[];
choreographyRef?: Choreography[];
conversationLinks?: ConversationLink[];
}
export interface ChoreographyActivity extends FlowNode {
initiatingParticipantRef?: Participant;
participantRefs?: Participant[];
correlationKeys?: CorrelationKey[];
loopType: ChoreographyLoopType;
}
export interface CallChoreography extends ChoreographyActivity {
calledChoreographyRef?: Choreography;
participantAssociations?: ParticipantAssociation[];
}
export interface ChoreographyTask extends ChoreographyActivity {
messageFlowRef?: MessageFlow[];
}
export interface Choreography extends Collaboration, FlowElementsContainer {}
export interface GlobalChoreographyTask extends Choreography {
initiatingParticipantRef?: Participant;
}
export interface TextAnnotation extends Artifact {
text?: string;
textFormat?: string;
}
export interface Group extends Artifact {
categoryValueRef?: CategoryValue[];
}
export interface Association extends Artifact {
associationDirection?: AssociationDirection[];
sourceRef?: BaseElement[];
targetRef?: BaseElement[];
}
export interface Category extends RootElement {
categoryValue?: CategoryValue[];
name?: string;
}
export interface Artifact extends BaseElement {}
export interface CategoryValue extends BaseElement {
categorizedFlowElements?: FlowElement[];
value?: string;
}
export interface Activity extends FlowNode {
isForCompensation: boolean;
default?: SequenceFlow;
ioSpecification?: InputOutputSpecification;
boundaryEventRefs?: BoundaryEvent[];
properties?: Property[];
dataInputAssociations?: DataInputAssociation[];
dataOutputAssociations?: DataOutputAssociation[];
startQuantity: number;
resources?: ResourceRole[];
completionQuantity: number;
loopCharacteristics?: LoopCharacteristics;
}
export interface ServiceTask extends Task {
implementation?: string;
operationRef?: Operation;
}
export interface SubProcess extends Activity, FlowElementsContainer, InteractionNode {
triggeredByEvent: boolean;
artifacts?: Artifact[];
}
export interface LoopCharacteristics extends BaseElement {}
export interface MultiInstanceLoopCharacteristics extends LoopCharacteristics {
isSequential: boolean;
behavior?: MultiInstanceBehavior;
loopCardinality?: Expression;
loopDataInputRef?: ItemAwareElement;
loopDataOutputRef?: ItemAwareElement;
inputDataItem?: DataInput;
outputDataItem?: DataOutput;
complexBehaviorDefinition?: ComplexBehaviorDefinition;
completionCondition?: Expression;
oneBehaviorEventRef?: EventDefinition[];
noneBehaviorEventRef?: EventDefinition[];
}
export interface StandardLoopCharacteristics extends LoopCharacteristics {
testBefore: boolean;
loopCondition?: Expression;
loopMaximum?: number;
}
export interface CallActivity extends Activity, InteractionNode {
calledElement?: string;
}
export interface Task extends Activity, InteractionNode {}
export interface SendTask extends Task {
implementation?: string;
operationRef?: Operation;
messageRef?: Message;
}
export interface ReceiveTask extends Task {
implementation?: string;
instantiate: boolean;
operationRef?: Operation;
messageRef?: Message;
}
export interface ScriptTask extends Task {
scriptFormat?: string;
script?: string;
}
export interface BusinessRuleTask extends Task {
implementation?: string;
}
export interface AdHocSubProcess extends SubProcess {
completionCondition?: Expression;
ordering?: AdHocOrdering;
cancelRemainingInstances: boolean;
}
export interface Transaction extends SubProcess {
protocal?: string;
method?: string;
}
export interface GlobalScriptTask extends GlobalTask {
scriptLanguage?: string;
script?: string;
}
export interface GlobalBusinessRuleTask extends GlobalTask {
implementation?: string;
}
export interface CompletionCondition extends BaseElement {
condition?: FormalExpression;
event?: ImplicitThrowEvent;
}
export interface ResourceRole extends BaseElement {
name?: string;
resourceRef?: Resource;
resourceParameterBindings?: ResourceParameterBinding[];
resourceAssignmentExpression?: ResourceAssignmentExpression;
}
export interface ResourceParameterBinding extends BaseElement {
expression?: Expression;
parameterRef?: ResourceParameter;
}
export interface ResourceAssignmentExpression extends BaseElement {
expression?: Expression;
}
export interface Import {
importType?: string;
location?: string;
namespace?: string;
}
export interface Definitions extends BaseElement {
name?: string;
targetNamespace?: string;
expressionLanguage: string;
typeLanguage: string;
imports?: Import[];
extensions?: Extension[];
rootElements?: RootElement[];
diagrams?: any[]; // bpmndi:BPMNDiagram
exporters?: string;
relationships?: Relationship[];
exporterVersion?: string;
}
export interface InputOutputBinding {
inputDataRef?: InputSet;
outputDataRef?: OutputSet;
operationRef?: Operation;
}
export interface ComplexBehaviorDefinition extends BaseElement {
condition?: FormalExpression;
event?: ImplicitThrowEvent[];
}
export enum ProcessType {
None,
Public,
Private
}
export enum GatewayDirection {
Unspecified,
Convergent,
Diverging,
Mixed
}
export enum EventBasedGatewayType {
Parallel,
Exclusive
}
export enum RelationshipDirection {
None,
Forward,
Backward,
Both
}
export enum ItemKind {
Physical,
Information
}
export enum ChoreographyLoopType {
None,
Standard,
MultiInstanceSequential,
MultiInstanceParallel
}
export enum AssociationDirection {
None,
One,
Both
}
export enum MultiInstanceBehavior {
None,
One,
All,
Complex
}
export enum AdHocOrdering {
Parallel,
Sequential
}
// 默认导出
export default class BpmnModdle extends Moddle {
constructor(packages?: Package[], options?: object);
fromXML(xmlStr: string, typeName?: string | object, options?: object): Promise<ParseResult | ParseError>;
toXML(element: string, options?: object): Promise<SerializationResult | Error>;
}
}

View File

@ -1,63 +0,0 @@
// 复制粘贴的行为校验
declare module 'camunda-bpmn-moddle/lib/CopyPasteBehavior' {
import EventBus from 'diagram-js/lib/core/EventBus';
import { Element } from 'bpmn-js/lib/model/Types';
// 注册一个 moddleCopy.canCopyProperty 监听事件
export default class CopyPasteBehavior {
constructor(eventBus: EventBus);
/**
*
* @param property
* @param parent
*/
canCopyProperty(property: object | string, parent: Element): boolean;
canHostInputOutput(parent: Element): boolean;
canHostConnector(parent: Element): boolean;
canHostIn(parent: Element): boolean;
}
}
//
declare module 'camunda-bpmn-moddle/lib/CopyPasteRootElementBehavior' {
import Modeler from 'bpmn-js/lib/Modeler';
import EventBus from 'diagram-js/lib/core/EventBus';
import { Injector } from 'didi';
import ModdleCopy from 'bpmn-js/lib/features/copy-paste/ModdleCopy';
import BpmnFactory from 'bpmn-js/lib/features/modeling/BpmnFactory';
/**
* (bpmn: Error)
* CommandInterceptor
* copyPaste.copyElement, copyPaste.pasteElement
*/
export default class CopyPasteRootElementBehavior {
constructor(bpmnjs: Modeler, eventBus: EventBus, injector: Injector, moddleCopy: ModdleCopy, bpmnFactory: BpmnFactory);
}
}
//
declare module 'camunda-bpmn-moddle/lib/RemoveInitiatorBehaviour' {
import Modeling from 'bpmn-js/lib/features/modeling/Modeling.js';
import { Injector } from 'didi';
/**
* `camunda:initiator` startEvent移动到子进程或在子进程中创建时的属性
* CommandInterceptor
*/
export default class RemoveInitiatorBehaviour {
constructor(modeling: Modeling, injector: Injector);
}
}
//
declare module 'camunda-bpmn-moddle/lib/RemoveVariableEventBehaviour' {
import Modeling from 'bpmn-js/lib/features/modeling/Modeling.js';
import { Injector } from 'didi';
import BpmnFactory from 'bpmn-js/lib/features/modeling/BpmnFactory';
import ModdleCopy from 'bpmn-js/lib/features/copy-paste/ModdleCopy';
export default class RemoveVariableEventBehaviour {
constructor(modeling: Modeling, injector: Injector, bpmnFactory: BpmnFactory, moddleCopy: ModdleCopy);
}
}

View File

@ -1,122 +0,0 @@
//
declare module 'diagram-js-direct-editing' {
import { ModuleDefinition } from 'didi';
const directEditingModule: ModuleDefinition;
export default directEditingModule;
}
//
declare module 'diagram-js-direct-editing/lib/DirectEditing' {
import EventBus from 'diagram-js/lib/core/EventBus';
import Canvas from 'diagram-js/lib/core/Canvas';
import TextBox from 'diagram-js-direct-editing/lib/TextBox';
type DirectEditingProvider = {};
type ElementDescriptor = {};
export default class DirectEditing {
protected _textbox: TextBox;
protected _eventBus: EventBus;
protected _providers: DirectEditingProvider[];
constructor(eventBus: EventBus, canvas: Canvas);
registerProvider(provider: DirectEditingProvider): void;
isActive(): boolean;
/**
* directEditing. + event
* @param event
* @param args
*/
_fire(event: string, ...args: any[]): void;
/**
* directEditing.deactivate
*/
close(): void;
/**
* directEditing.complete close
*/
complete(): void;
getValue(): string;
/**
* Activate direct editing on the given element
*
* @param {HTMLElement} element the descriptor for a shape or connection
* @return {Boolean} true if the activation was possible
*/
activate(element: HTMLElement): boolean;
}
}
//
declare module 'diagram-js-direct-editing/lib/TextBox' {
type TextBoxOptions = {
container: HTMLElement;
keyHandler: Function;
resizeHandler: Function;
};
type TextBoxBounds = {
x: number;
y: number;
width?: number;
height?: number;
maxWidth?: number;
minWidth?: number;
maxHeight?: number;
minHeight?: number;
};
type Style = {
fontSize?: number;
maxWidth?: number;
minWidth?: number;
maxHeight?: number;
minHeight?: number;
};
export default class TextBox {
protected container: HTMLElement;
protected parent: HTMLElement;
protected content: HTMLElement;
protected keyHandler: Function;
protected resizeHandler: Function;
constructor(options: TextBoxOptions);
// protected autoResize: Function
// protected handlePaste: Function
/**
*
* @param bounds {TextBoxBounds}
* @param style {Style | string}
* @param [value] {string | Object}
* @param [options] {Object}
*/
create(bounds: TextBoxBounds, style: Style | string, value?: string | object, options?: object): HTMLElement;
handlePaste(e: Event): void;
insertText(text: string): void;
_insertTextIE(text: string): void;
autoResize(): void;
resizable(): void;
destroy(): void;
getValue(): string;
getSelection(): Range;
setSelection(container: HTMLElement | number, offset?: number): void;
}
}

View File

@ -1,58 +0,0 @@
declare module 'object-refs' {
// 要使用的属性描述符在 Refs 实例中指定属性
type AttributeDescriptor = {
name: string;
collection: boolean;
enumerable: boolean;
inverse?: AttributeDescriptor;
};
type RefsCollection = Array<object> & {
remove(element: unknown): unknown;
contains(element: unknown): boolean;
add(element: unknown, idx?: number): unknown;
__refs_collection: true;
};
/**
* @example
*
* var refs = Refs({ name: 'wheels', collection: true, enumerable: true }, { name: 'car' });
*
* var car = { name: 'toyota' };
* var wheels = [{ pos: 'front-left' }, { pos: 'front-right' }];
*
* refs.bind(car, 'wheels');
*
* car.wheels // []
* car.wheels.add(wheels[0]);
* car.wheels.add(wheels[1]);
*
* car.wheels // [{ pos: 'front-left' }, { pos: 'front-right' }]
*
* wheels[0].car // { name: 'toyota' };
* car.wheels.remove(wheels[0]);
*
* wheels[0].car // undefined
*/
export class Refs {
private props: Record<string, AttributeDescriptor>;
constructor(a: AttributeDescriptor, b: AttributeDescriptor);
//将双向引用的一侧绑定到目标对象。
bind(target: object, property: string | AttributeDescriptor): void;
ensureRefsCollection(target: object, property: AttributeDescriptor): RefsCollection;
ensureBound(target: object, property: AttributeDescriptor): void;
unset(target, property, value): void;
set(target, property, value): void;
}
export type Collection = {
extend(collection: object[], refs: Refs, property: object, target: object): RefsCollection;
isExtended(collection: object[] | RefsCollection): boolean;
};
}

View File

@ -1,5 +1,4 @@
import { MessageApiInjection } from 'naive-ui/lib/message/src/MessageProvider';
import { ElementLike } from 'diagram-js/lib/core';
declare global {
interface Window {
@ -7,8 +6,6 @@ declare global {
__messageBox: MessageApiInjection;
URL: any;
}
type BpmnElement = ElementLike & { type: string };
}
declare interface Window {

View File

@ -1,33 +0,0 @@
import { ViewerOptions } from 'diagram-js/lib/model/Types';
import { ModuleDeclaration } from 'didi';
export interface EditorSettings {
processName: string;
procDefId: string;
processEngine: 'camunda';
paletteMode: 'default' | 'custom' | 'rewrite' | 'enhancement';
penalMode: 'default' | 'custom' | 'rewrite';
contextPadMode: 'default' | 'rewrite' | 'enhancement';
rendererMode: 'default' | 'rewrite' | 'enhancement';
bg: string;
toolbar: boolean;
miniMap: boolean;
contextmenu: boolean;
customContextmenu: boolean;
otherModule: boolean;
templateChooser: boolean;
useLint: boolean;
customTheme: Record<string, string | number>;
}
export type ModelerOptions<E extends Element> = ViewerOptions<E> & {
additionalModules: ModuleDeclaration[];
moddleExtensions: object;
};
// bpmn.js 事件参数
// 1. canvas 事件
type CanvasEventParams = {
svg: SVGElement;
viewport: SVGElement;
};

View File

@ -1,23 +0,0 @@
declare module '@/utils/Logger' {
export class Logger {
constructor();
static print(type: string, text: any, back?: boolean): void;
static printBack(type: string, text: any): void;
static pretty(type: any, title: string, ...text: any[]): void;
static prettyPrimary(title: string, ...text: any[]): void;
static prettySuccess(title: string, ...text: any[]): void;
static prettyWarn(title: string, ...text: any[]): void;
static prettyError(title: string, ...text: any[]): void;
static prettyInfo(title: string, ...text: any[]): void;
}
export default Logger;
}