Socket
Socket
Sign inDemoInstall

@jsplumb/community

Package Overview
Dependencies
0
Maintainers
1
Versions
47
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 4.0.0-RC37 to 4.0.0-RC38

2

package.json
{
"name": "@jsplumb/community",
"version": "4.0.0-RC37",
"version": "4.0.0-RC38",
"description": "Visual connectivity for webapps. This package contains `community-core` and `browser-ui`, and is equivalent to the way that previous versions of the Community edition were packaged. Note that this package is effectively deprecated, and will not always be available. Try importing `@jsplumb/browser-ui` instead.",

@@ -5,0 +5,0 @@ "main": "js/jsplumb.community.cjs.js",

109

types/browser-ui/browser-jsplumb-instance.d.ts

@@ -1,2 +0,2 @@

import { jsPlumbDefaults, jsPlumbHelperFunctions, Dictionary, SourceDefinition, TargetDefinition, Offset, PointArray, Size, jsPlumbElement, TypeDescriptor, JsPlumbInstance, UIGroup, AbstractConnector, Endpoint, Overlay, RedrawResult, PaintStyle, OverlayCapableComponent, Segment, LabelOverlay, Connection, Component, DeleteConnectionOptions } from '@jsplumb/community-core';
import { jsPlumbDefaults, jsPlumbHelperFunctions, Dictionary, Offset, PointArray, Size, jsPlumbElement, TypeDescriptor, JsPlumbInstance, AbstractConnector, Endpoint, Overlay, RedrawResult, PaintStyle, OverlayCapableComponent, Segment, LabelOverlay, Connection, Component, DeleteConnectionOptions } from '@jsplumb/community-core';
import { ElementAttributes } from './svg-util';

@@ -22,3 +22,3 @@ import { DragManager } from "./drag-manager";

_size: [number, number];
getDragElement: () => jsPlumbDOMElement;
getDragElement: () => Element;
};

@@ -32,3 +32,3 @@ /**

*/
el: jsPlumbDOMElement;
el: Element;
/**

@@ -62,17 +62,15 @@ * x,y location of the element. provided on the `drag` event only.

}
export interface jsPlumbDOMElement extends HTMLElement, jsPlumbElement {
_jsPlumbGroup: UIGroup;
_jsPlumbParentGroup: UIGroup;
export declare type ElementType = {
E: Element;
};
export interface jsPlumbDOMElement extends HTMLElement, jsPlumbElement<Element> {
_isJsPlumbGroup: boolean;
_jsPlumbOrphanedEndpoints: Array<Endpoint>;
offsetParent: HTMLElement;
getAttribute: (name: string) => string;
offsetParent: jsPlumbDOMElement;
parentNode: jsPlumbDOMElement;
jtk: jsPlumbDOMInformation;
_jsPlumbTargetDefinitions: Array<TargetDefinition>;
_jsPlumbSourceDefinitions: Array<SourceDefinition>;
_jsPlumbList: any;
_jsPlumbScrollHandler?: Function;
_katavorioDrag?: Drag;
_jspContext?: any;
cloneNode: (deep?: boolean) => jsPlumbDOMElement;
}

@@ -87,3 +85,3 @@ export declare type DragGroupSpec = string | {

*/
export declare class BrowserJsPlumbInstance extends JsPlumbInstance {
export declare class BrowserJsPlumbInstance extends JsPlumbInstance<ElementType> {
_instanceIndex: number;

@@ -126,42 +124,42 @@ dragManager: DragManager;

removeDragFilter(filter: Function | string): void;
getElement(el: HTMLElement | string): jsPlumbDOMElement;
getElementById(elId: string): jsPlumbDOMElement;
getElement(el: Element | string): Element;
getElementById(elId: string): Element;
removeElement(element: any): void;
appendElement(el: HTMLElement, parent: HTMLElement): void;
getChildElements(el: jsPlumbElement): Array<jsPlumbElement>;
_getAssociatedElements(el: jsPlumbDOMElement): Array<jsPlumbElement>;
appendElement(el: Element, parent: Element): void;
getChildElements(el: Element): Array<Element>;
_getAssociatedElements(el: Element): Array<Element>;
shouldFireEvent(event: string, value: any, originalEvent?: Event): boolean;
getClass(el: jsPlumbDOMElement): string;
addClass(el: jsPlumbDOMElement, clazz: string): void;
hasClass(el: jsPlumbDOMElement, clazz: string): boolean;
removeClass(el: jsPlumbDOMElement, clazz: string): void;
toggleClass(el: jsPlumbDOMElement, clazz: string): void;
setAttribute(el: jsPlumbDOMElement, name: string, value: string): void;
getAttribute(el: jsPlumbDOMElement, name: string): string;
setAttributes(el: jsPlumbDOMElement, atts: Dictionary<string>): void;
removeAttribute(el: jsPlumbDOMElement, attName: string): void;
on(el: jsPlumbDOMElement, event: string, callbackOrSelector: Function | string, callback?: Function): this;
off(el: jsPlumbDOMElement, event: string, callback: Function): this;
trigger(el: jsPlumbDOMElement, event: string, originalEvent?: Event, payload?: any): void;
_getOffsetRelativeToRoot(el: jsPlumbDOMElement): Offset;
_getOffset(el: HTMLElement): Offset;
_getSize(el: HTMLElement): Size;
getStyle(el: HTMLElement, prop: string): any;
getSelector(ctx: string | jsPlumbDOMElement, spec: string): NodeListOf<jsPlumbDOMElement>;
getClass(el: Element): string;
addClass(el: Element, clazz: string): void;
hasClass(el: Element, clazz: string): boolean;
removeClass(el: Element, clazz: string): void;
toggleClass(el: Element, clazz: string): void;
setAttribute(el: Element, name: string, value: string): void;
getAttribute(el: Element, name: string): string;
setAttributes(el: Element, atts: Dictionary<string>): void;
removeAttribute(el: Element, attName: string): void;
on(el: Element, event: string, callbackOrSelector: Function | string, callback?: Function): this;
off(el: Element, event: string, callback: Function): this;
trigger(el: Element, event: string, originalEvent?: Event, payload?: any): void;
_getOffsetRelativeToRoot(el: Element): Offset;
_getOffset(el: Element): Offset;
_getSize(el: Element): Size;
getStyle(el: Element, prop: string): any;
getSelector(ctx: string | Element, spec: string): NodeListOf<jsPlumbDOMElement>;
setPosition(el: HTMLElement, p: Offset): void;
static getPositionOnElement(evt: Event, el: HTMLElement, zoom: number): PointArray;
setDraggable(element: jsPlumbDOMElement, draggable: boolean): void;
isDraggable(el: jsPlumbDOMElement): boolean;
toggleDraggable(el: jsPlumbDOMElement): boolean;
setDraggable(element: Element, draggable: boolean): void;
isDraggable(el: Element): boolean;
toggleDraggable(el: Element): boolean;
private _attachEventDelegates;
private _detachEventDelegates;
setContainer(c: string | jsPlumbDOMElement): void;
setContainer(c: string | Element): void;
reset(silently?: boolean): void;
destroy(): void;
unmanage(el: jsPlumbDOMElement, removeElement?: boolean): void;
addToDragSelection(...el: Array<string | jsPlumbDOMElement>): void;
unmanage(el: Element, removeElement?: boolean): void;
addToDragSelection(...el: Array<Element>): void;
clearDragSelection(): void;
removeFromDragSelection(...el: Array<jsPlumbDOMElement>): void;
toggleDragSelection(...el: Array<string | jsPlumbDOMElement>): void;
getDragSelection(): Array<jsPlumbDOMElement>;
removeFromDragSelection(...el: Array<Element>): void;
toggleDragSelection(...el: Array<Element>): void;
getDragSelection(): Array<Element>;
/**

@@ -175,3 +173,3 @@ * Adds the given element(s) to the given drag group.

*/
addToDragGroup(spec: DragGroupSpec, ...els: Array<jsPlumbDOMElement>): void;
addToDragGroup(spec: DragGroupSpec, ...els: Array<Element>): void;
/**

@@ -182,3 +180,3 @@ * Removes the given element(s) from any drag group they may be in. You don't need to supply the drag group id, as elements

*/
removeFromDragGroup(...els: Array<jsPlumbDOMElement>): void;
removeFromDragGroup(...els: Array<Element>): void;
/**

@@ -190,3 +188,3 @@ * Sets the active/passive state for the given element(s).You don't need to supply the drag group id, as elements

*/
setDragGroupState(state: boolean, ...els: Array<jsPlumbDOMElement>): void;
setDragGroupState(state: boolean, ...els: Array<Element>): void;
/**

@@ -198,5 +196,14 @@ * Consumes the given event.

consume(e: Event, doNotPreventDefault?: boolean): void;
addList(el: jsPlumbDOMElement, options?: jsPlumbListOptions): jsPlumbList;
removeList(el: jsPlumbDOMElement): void;
/**
* Adds a managed list to the instance.
* @param el Element containing the list.
* @param options
*/
addList(el: Element, options?: jsPlumbListOptions): jsPlumbList;
/**
* Removes a managed list from the instance
* @param el Element containing the list.
*/
removeList(el: Element): void;
/**
* Helper method for other libs/code to get a DragManager.

@@ -206,3 +213,3 @@ * @param options

createDragManager(options: CollicatOptions): Collicat;
rotate(element: jsPlumbElement, rotation: number, doNotRepaint?: boolean): RedrawResult;
rotate(element: Element, rotation: number, doNotRepaint?: boolean): RedrawResult;
svg: {

@@ -236,4 +243,4 @@ node: (name: string, attributes?: ElementAttributes) => jsPlumbDOMElement;

destroyEndpoint(ep: Endpoint): void;
paintEndpoint<C>(ep: Endpoint, paintStyle: PaintStyle): void;
removeEndpointClass<C>(ep: Endpoint, c: string): void;
paintEndpoint(ep: Endpoint, paintStyle: PaintStyle): void;
removeEndpointClass(ep: Endpoint, c: string): void;
getEndpointClass(ep: Endpoint): string;

@@ -240,0 +247,0 @@ refreshEndpoint(endpoint: Endpoint): void;

10

types/browser-ui/browser-util.d.ts

@@ -8,9 +8,9 @@ import { jsPlumbDOMElement } from "./browser-jsplumb-instance";

export declare function getEventSource(e: Event): jsPlumbDOMElement;
export declare function getClass(el: jsPlumbDOMElement): string;
export declare function addClass(el: jsPlumbDOMElement, clazz: string): void;
export declare function hasClass(el: jsPlumbDOMElement, clazz: string): boolean;
export declare function removeClass(el: jsPlumbDOMElement, clazz: string): void;
export declare function toggleClass(el: jsPlumbDOMElement, clazz: string): void;
export declare function getClass(el: Element): string;
export declare function addClass(el: Element, clazz: string): void;
export declare function hasClass(el: Element, clazz: string): boolean;
export declare function removeClass(el: Element, clazz: string): void;
export declare function toggleClass(el: Element, clazz: string): void;
export declare function createElement(tag: string, style?: Dictionary<any>, clazz?: string, atts?: Dictionary<string>): jsPlumbDOMElement;
export declare function createElementNS(ns: string, tag: string, style?: Dictionary<any>, clazz?: string, atts?: Dictionary<string | number>): jsPlumbDOMElement;
export declare function offsetRelativeToRoot(el: any): Offset;

8

types/browser-ui/collicat.d.ts

@@ -28,3 +28,3 @@ /**

}
export declare type GhostProxyGenerator = (el: jsPlumbDOMElement) => jsPlumbDOMElement;
export declare type GhostProxyGenerator = (el: Element) => Element;
export interface DragHandlerOptions {

@@ -36,8 +36,8 @@ selector?: string;

beforeStart?: (beforeStartParams: any) => void;
dragInit?: (el: jsPlumbDOMElement) => any;
dragAbort?: (el: jsPlumbDOMElement) => any;
dragInit?: (el: Element) => any;
dragAbort?: (el: Element) => any;
ghostProxy?: GhostProxyGenerator | boolean;
makeGhostProxy?: GhostProxyGenerator;
useGhostProxy?: (container: any, dragEl: any) => boolean;
ghostProxyParent?: jsPlumbDOMElement;
ghostProxyParent?: Element;
constrain?: ConstrainFunction | boolean;

@@ -44,0 +44,0 @@ revert?: RevertFunction;

10

types/browser-ui/drag-manager.d.ts

@@ -1,2 +0,2 @@

import { BrowserJsPlumbInstance, jsPlumbDOMElement } from "./browser-jsplumb-instance";
import { BrowserJsPlumbInstance } from "./browser-jsplumb-instance";
import { Dictionary, PointArray } from '@jsplumb/community-core';

@@ -24,4 +24,4 @@ import { Drag, DragHandlerOptions, GhostProxyGenerator } from "./collicat";

onStop: (params: DragStopEventParams) => void;
onDragInit: (el: jsPlumbDOMElement) => jsPlumbDOMElement;
onDragAbort: (el: jsPlumbDOMElement) => void;
onDragInit: (el: Element) => Element;
onDragAbort: (el: Element) => void;
reset: () => void;

@@ -32,3 +32,3 @@ init: (drag: Drag) => void;

export interface GhostProxyingDragHandler extends DragHandler {
useGhostProxy: (container: any, dragEl: jsPlumbDOMElement) => boolean;
useGhostProxy: (container: any, dragEl: Element) => boolean;
makeGhostProxy?: GhostProxyGenerator;

@@ -38,3 +38,3 @@ }

e: MouseEvent;
el: jsPlumbDOMElement;
el: Element;
finalPos?: PointArray;

@@ -41,0 +41,0 @@ drag: Drag;

20

types/browser-ui/element-drag-handler.d.ts

@@ -6,3 +6,3 @@ import { DragEventParams, DragHandler, DragStopEventParams } from "./drag-manager";

export interface DragStopPayload {
el: jsPlumbDOMElement;
el: Element;
e: MouseEvent;

@@ -29,4 +29,4 @@ pos: Offset;

constructor(instance: BrowserJsPlumbInstance);
onDragInit(el: jsPlumbDOMElement): jsPlumbDOMElement;
onDragAbort(el: jsPlumbDOMElement): void;
onDragInit(el: Element): Element;
onDragAbort(el: Element): void;
onStop(params: DragStopEventParams): void;

@@ -43,12 +43,12 @@ private _cleanup;

}): boolean;
addToDragSelection(el: string | jsPlumbDOMElement): void;
addToDragSelection(el: Element): void;
clearDragSelection(): void;
removeFromDragSelection(el: string | HTMLElement): void;
toggleDragSelection(el: string | jsPlumbDOMElement): void;
getDragSelection(): Array<jsPlumbDOMElement>;
removeFromDragSelection(el: Element): void;
toggleDragSelection(el: Element): void;
getDragSelection(): Array<Element>;
private static decodeDragGroupSpec;
addToDragGroup(spec: DragGroupSpec, ...els: Array<jsPlumbDOMElement>): void;
removeFromDragGroup(...els: Array<jsPlumbDOMElement>): void;
setDragGroupState(state: boolean, ...els: Array<jsPlumbDOMElement>): void;
addToDragGroup(spec: DragGroupSpec, ...els: Array<Element>): void;
removeFromDragGroup(...els: Array<Element>): void;
setDragGroupState(state: boolean, ...els: Array<Element>): void;
private isActiveDragGroupMember;
}

6

types/browser-ui/endpoint-drag-handler.d.ts

@@ -9,3 +9,3 @@ import { DragEventParams, DragHandler, DragStartEventParams, DragStopEventParams } from "./drag-manager";

existingJpc: boolean;
ep: Endpoint;
ep: Endpoint<Element>;
endpointRepresentation: EndpointRepresentation<any>;

@@ -42,4 +42,4 @@ private _activeDefinition;

*/
onDragInit(el: jsPlumbDOMElement): jsPlumbDOMElement;
onDragAbort(el: jsPlumbDOMElement): void;
onDragInit(el: Element): Element;
onDragAbort(el: Element): void;
/**

@@ -46,0 +46,0 @@ * Makes the element that is the placeholder for dragging. this element gets `managed` by the instance, and `unmanaged` when dragging

4

types/browser-ui/group-drag-handler.d.ts

@@ -13,4 +13,4 @@ import { ElementDragHandler } from "./element-drag-handler";

init(drag: Drag): void;
useGhostProxy(container: any, dragEl: jsPlumbDOMElement): boolean;
makeGhostProxy(el: jsPlumbDOMElement): jsPlumbDOMElement;
useGhostProxy(container: any, dragEl: Element): boolean;
makeGhostProxy(el: Element): Element;
onDrag(params: DragEventParams): void;

@@ -17,0 +17,0 @@ onDragAbort(el: jsPlumbDOMElement): void;

4

types/browser-ui/html-element-overlay.d.ts

@@ -12,4 +12,4 @@ import { jsPlumbDOMElement } from "./browser-jsplumb-instance";

constructor(instance: JsPlumbInstance, overlay: Overlay);
static createElement(o: HTMLElementOverlayHolder): jsPlumbDOMElement;
static getElement(o: HTMLElementOverlayHolder, component?: Component, elementCreator?: (c: Component) => jsPlumbDOMElement): jsPlumbDOMElement;
static createElement(o: HTMLElementOverlayHolder): Element;
static getElement(o: HTMLElementOverlayHolder, component?: Component, elementCreator?: (c: Component) => Element): Element;
static destroy(o: HTMLElementOverlayHolder): void;

@@ -16,0 +16,0 @@ static _getDimensions(o: HTMLElementOverlayHolder, forceRefresh?: boolean): PointArray;

13

types/browser-ui/lists.d.ts

@@ -1,2 +0,2 @@

import { BrowserJsPlumbInstance, jsPlumbDOMElement } from "./browser-jsplumb-instance";
import { BrowserJsPlumbInstance } from "./browser-jsplumb-instance";
import { EndpointSpec, Endpoint, Connection, AnchorSpec, Anchor, Dictionary } from '@jsplumb/community-core';

@@ -17,5 +17,5 @@ export interface ListManagerOptions {

constructor(instance: BrowserJsPlumbInstance, params?: ListManagerOptions);
addList(el: jsPlumbDOMElement, options?: jsPlumbListOptions): jsPlumbList;
removeList(el: jsPlumbDOMElement): void;
_maybeUpdateParentList(el: jsPlumbDOMElement): void;
addList(el: Element, options?: jsPlumbListOptions): jsPlumbList;
removeList(el: Element): void;
private _maybeUpdateParentList;
}

@@ -27,7 +27,8 @@ export declare class jsPlumbList {

_scrollHandler: Function;
constructor(instance: BrowserJsPlumbInstance, el: jsPlumbDOMElement, options: jsPlumbListOptions, id: string);
private readonly domElement;
constructor(instance: BrowserJsPlumbInstance, el: Element, options: jsPlumbListOptions, id: string);
private deriveAnchor;
deriveEndpoint(edge: string, index: number, ep: Endpoint, conn: Connection): string | Endpoint | [string, any];
deriveEndpoint(edge: string, index: number, ep: Endpoint, conn: Connection): string | Endpoint<any> | [string, any];
scrollHandler(): void;
destroy(): void;
}

6

types/core/anchor-manager.d.ts

@@ -13,3 +13,5 @@ import { Endpoint } from "./endpoint/endpoint-impl";

}
export declare class AnchorManager {
export declare class AnchorManager<T extends {
E: unknown;
} = any> {
private instance;

@@ -19,3 +21,3 @@ continuousAnchorLocations: Dictionary<[number, number, number, number]>;

private anchorLists;
constructor(instance: JsPlumbInstance);
constructor(instance: JsPlumbInstance<T>);
reset(): void;

@@ -22,0 +24,0 @@ private placeAnchors;

35

types/core/common.d.ts

@@ -10,10 +10,8 @@ import { UIGroup } from "./group/group";

export declare type UUID = string;
export declare type ElementId = string;
export declare type ElementRef = ElementId | any;
export interface jsPlumbElement {
export interface jsPlumbElement<E> {
_jsPlumbTargetDefinitions: Array<TargetDefinition>;
_jsPlumbSourceDefinitions: Array<SourceDefinition>;
_jsplumbid: string;
_jsPlumbGroup: UIGroup;
_jsPlumbParentGroup: UIGroup;
_jsPlumbGroup: UIGroup<E>;
_jsPlumbParentGroup: UIGroup<E>;
_jspContext?: any;

@@ -25,4 +23,4 @@ _jsPlumbConnections: Dictionary<boolean>;

uuids?: [UUID, UUID];
source?: jsPlumbElement | Endpoint;
target?: jsPlumbElement | Endpoint;
source?: Element | Endpoint;
target?: Element | Endpoint;
detachable?: boolean;

@@ -43,5 +41,5 @@ deleteEndpointsOnDetach?: boolean;

}
export interface InternalConnectParams extends ConnectParams {
sourceEndpoint?: Endpoint;
targetEndpoint?: Endpoint;
export interface InternalConnectParams<E> extends ConnectParams {
sourceEndpoint?: Endpoint<E>;
targetEndpoint?: Endpoint<E>;
scope?: string;

@@ -51,12 +49,12 @@ type?: string;

}
export interface ConnectionEstablishedParams {
export interface ConnectionEstablishedParams<E> {
connection: Connection;
source: jsPlumbElement;
source: E;
sourceEndpoint: Endpoint;
sourceId: string;
target: jsPlumbElement;
target: E;
targetEndpoint: Endpoint;
targetId: string;
}
export interface ConnectionDetachedParams extends ConnectionEstablishedParams {
export interface ConnectionDetachedParams<E> extends ConnectionEstablishedParams<E> {
}

@@ -119,6 +117,2 @@ export interface ConnectionMovedParams {

export declare type Rotation = number;
export interface OffsetAndSize {
o: Offset;
s: Size;
}
export declare type PointArray = [number, number];

@@ -145,7 +139,2 @@ export interface PointXY {

}
export declare type UpdateOffsetResult = {
o: ExtendedOffset;
s: Size;
r: Rotation;
};
export interface ExtendedOffset extends Offset {

@@ -152,0 +141,0 @@ width?: number;

16

types/core/connector/connection-impl.d.ts

@@ -12,6 +12,6 @@ import { JsPlumbInstance } from "../core";

import { EndpointSpec } from "../endpoint/endpoint";
export interface ConnectionParams {
export interface ConnectionParams<E> {
id?: string;
source?: jsPlumbElement;
target?: jsPlumbElement;
source?: E;
target?: E;
sourceEndpoint?: Endpoint;

@@ -45,3 +45,3 @@ targetEndpoint?: Endpoint;

}
export declare class Connection extends OverlayCapableComponent {
export declare class Connection<E = any> extends OverlayCapableComponent {
instance: JsPlumbInstance;

@@ -69,3 +69,3 @@ id: string;

directed: boolean;
endpoints: [Endpoint, Endpoint];
endpoints: [Endpoint<E>, Endpoint<E>];
endpointStyles: [PaintStyle, PaintStyle];

@@ -96,4 +96,4 @@ _endpointSpec: EndpointSpec;

floatingElement: any;
static updateConnectedClass<E>(instance: JsPlumbInstance, conn: Connection, element: jsPlumbElement, isRemoval: boolean): void;
constructor(instance: JsPlumbInstance, params: ConnectionParams);
static updateConnectedClass<E>(instance: JsPlumbInstance, conn: Connection, element: jsPlumbElement<E>, isRemoval: boolean): void;
constructor(instance: JsPlumbInstance, params: ConnectionParams<E>);
makeEndpoint(isSource: boolean, el: any, elId: string, ep?: Endpoint): Endpoint;

@@ -122,5 +122,5 @@ getTypeDescriptor(): string;

paint(params?: any): void;
prepareEndpoint(existing: Endpoint, index: number, element?: any, elementId?: string, params?: ConnectionParams): Endpoint;
prepareEndpoint(existing: Endpoint, index: number, element?: any, elementId?: string, params?: ConnectionParams<E>): Endpoint;
private _makeAnchor;
replaceEndpoint(idx: number, endpointDef: EndpointSpec): void;
}

2

types/core/connector/connectors.d.ts

@@ -6,4 +6,4 @@ import { AbstractConnector } from "./abstract-connector";

export declare const Connectors: {
get: (instance: JsPlumbInstance, connection: Connection, name: string, params: any) => AbstractConnector;
get: (instance: JsPlumbInstance<any>, connection: Connection<any>, name: string, params: any) => AbstractConnector;
register: (name: string, conn: Constructable<AbstractConnector>) => void;
};

208

types/core/core.d.ts

@@ -24,14 +24,14 @@ import { jsPlumbDefaults, jsPlumbHelperFunctions } from "./defaults";

import { PaintStyle } from './styles';
export declare type ElementSelectionSpecifier = jsPlumbElement | Array<jsPlumbElement> | '*';
export declare type ElementSelectionSpecifier<E> = E | Array<E> | '*';
export declare type SelectionList = '*' | Array<string>;
export interface AbstractSelectOptions {
export interface AbstractSelectOptions<E> {
scope?: SelectionList;
source?: ElementSelectionSpecifier;
target?: ElementSelectionSpecifier;
source?: ElementSelectionSpecifier<E>;
target?: ElementSelectionSpecifier<E>;
}
export interface SelectOptions extends AbstractSelectOptions {
export interface SelectOptions<E> extends AbstractSelectOptions<E> {
connections?: Array<Connection>;
}
export interface SelectEndpointOptions extends AbstractSelectOptions {
element?: ElementSelectionSpecifier;
export interface SelectEndpointOptions<E> extends AbstractSelectOptions<E> {
element?: ElementSelectionSpecifier<E>;
}

@@ -60,4 +60,4 @@ /**

};
export declare type ManagedElement = {
el: jsPlumbElement;
export declare type ManagedElement<E> = {
el: jsPlumbElement<E>;
info?: ViewportElement;

@@ -68,3 +68,5 @@ endpoints?: Array<Endpoint>;

};
export declare abstract class JsPlumbInstance extends EventGenerator {
export declare abstract class JsPlumbInstance<T extends {
E: unknown;
} = any> extends EventGenerator {
readonly _instanceIndex: number;

@@ -96,7 +98,7 @@ Defaults: jsPlumbDefaults;

readonly router: Router;
readonly groupManager: GroupManager;
readonly groupManager: GroupManager<T["E"]>;
private _connectionTypes;
private _endpointTypes;
private _container;
protected _managedElements: Dictionary<ManagedElement>;
protected _managedElements: Dictionary<ManagedElement<T["E"]>>;
private DEFAULT_SCOPE;

@@ -109,4 +111,4 @@ get defaultScope(): string;

constructor(_instanceIndex: number, defaults?: jsPlumbDefaults, helpers?: jsPlumbHelperFunctions);
getSize(el: any): Size;
getOffset(el: any | string, relativeToRoot?: boolean): Offset;
getSize(el: T["E"]): Size;
getOffset(el: T["E"], relativeToRoot?: boolean): Offset;
getContainer(): any;

@@ -117,11 +119,11 @@ setZoom(z: number, repaintEverything?: boolean): boolean;

checkCondition(conditionName: string, args?: any): boolean;
getId(element: jsPlumbElement, uuid?: string): string;
getId(element: T["E"], uuid?: string): string;
getCachedData(elId: string): ViewportElement;
getConnections(options?: SelectOptions, flat?: boolean): Dictionary<Connection> | Array<Connection>;
select(params?: SelectOptions): ConnectionSelection;
selectEndpoints(params?: SelectEndpointOptions): EndpointSelection;
setContainer(c: string | jsPlumbElement): void;
getConnections(options?: SelectOptions<T["E"]>, flat?: boolean): Dictionary<Connection> | Array<Connection>;
select(params?: SelectOptions<T["E"]>): ConnectionSelection;
selectEndpoints(params?: SelectEndpointOptions<T["E"]>): EndpointSelection;
setContainer(c: string | T["E"]): void;
private _set;
setSource(connection: Connection, el: jsPlumbElement | Endpoint, doNotRepaint?: boolean): void;
setTarget(connection: Connection, el: jsPlumbElement | Endpoint, doNotRepaint?: boolean): void;
setSource(connection: Connection, el: T["E"] | Endpoint, doNotRepaint?: boolean): void;
setTarget(connection: Connection, el: T["E"] | Endpoint, doNotRepaint?: boolean): void;
/**

@@ -137,3 +139,3 @@ * Returns whether or not hover is currently suspended.

setSuspendDrawing(val?: boolean, repaintAfterwards?: boolean): boolean;
computeAnchorLoc(endpoint: Endpoint, timestamp?: string): AnchorPlacement;
computeAnchorLoc(endpoint: Endpoint<T>, timestamp?: string): AnchorPlacement;
getSuspendedAt(): string;

@@ -151,3 +153,3 @@ /**

*/
each(spec: jsPlumbElement | Array<jsPlumbElement>, fn: (e: jsPlumbElement) => any): JsPlumbInstance;
each(spec: T["E"] | Array<T["E"]>, fn: (e: T["E"]) => any): JsPlumbInstance;
/**

@@ -166,3 +168,3 @@ * Update the cached offset information for some element.

deleteEveryConnection(params?: DeleteConnectionOptions): number;
deleteConnectionsForElement(el: jsPlumbElement, params?: DeleteConnectionOptions): JsPlumbInstance;
deleteConnectionsForElement(el: T["E"], params?: DeleteConnectionOptions): JsPlumbInstance;
private fireDetachEvent;

@@ -175,3 +177,3 @@ fireMoveEvent(params?: any, evt?: Event): void;

*/
manageAll(elements: Array<jsPlumbElement>, recalc?: boolean): void;
manageAll(elements: Array<Element>, recalc?: boolean): void;
/**

@@ -183,3 +185,3 @@ * Manage an element.

*/
manage(element: jsPlumbElement, internalId?: string, recalc?: boolean): ManagedElement;
manage(element: T["E"], internalId?: string, recalc?: boolean): ManagedElement<T["E"]>;
/**

@@ -190,4 +192,4 @@ * Stops managing the given element.

*/
unmanage(el: jsPlumbElement, removeElement?: boolean): void;
rotate(element: jsPlumbElement, rotation: number, doNotRepaint?: boolean): RedrawResult;
unmanage(el: T["E"], removeElement?: boolean): void;
rotate(element: T["E"], rotation: number, doNotRepaint?: boolean): RedrawResult;
getRotation(elementId: string): number;

@@ -200,6 +202,6 @@ /**

*/
newEndpoint(params: EndpointOptions, id?: string): Endpoint;
newEndpoint(params: EndpointOptions<T["E"]>, id?: string): Endpoint;
deriveEndpointAndAnchorSpec(type: string, dontPrependDefault?: boolean): any;
repaint(el: jsPlumbElement, ui?: any, timestamp?: string): RedrawResult;
revalidate(el: jsPlumbElement, timestamp?: string): RedrawResult;
repaint(el: T["E"], ui?: any, timestamp?: string): RedrawResult;
revalidate(el: T["E"], timestamp?: string): RedrawResult;
repaintEverything(): JsPlumbInstance;

@@ -212,9 +214,9 @@ /**

*/
abstract _getAssociatedElements(el: jsPlumbElement): Array<any>;
_draw(el: jsPlumbElement, ui?: any, timestamp?: string, offsetsWereJustCalculated?: boolean): RedrawResult;
abstract _getAssociatedElements(el: T["E"]): Array<T["E"]>;
_draw(el: T["E"], ui?: any, timestamp?: string, offsetsWereJustCalculated?: boolean): RedrawResult;
unregisterEndpoint(endpoint: Endpoint): void;
maybePruneEndpoint(endpoint: Endpoint): boolean;
deleteEndpoint(object: string | Endpoint): JsPlumbInstance;
addEndpoint(el: jsPlumbElement, params?: EndpointOptions, referenceParams?: EndpointOptions): Endpoint;
addEndpoints(el: jsPlumbElement, endpoints: Array<EndpointOptions>, referenceParams?: any): Array<Endpoint>;
addEndpoint(el: T["E"], params?: EndpointOptions<T["E"]>, referenceParams?: EndpointOptions<T["E"]>): Endpoint;
addEndpoints(el: T["E"], endpoints: Array<EndpointOptions<T["E"]>>, referenceParams?: any): Array<Endpoint>;
reset(silently?: boolean): void;

@@ -225,3 +227,3 @@ uuid(): string;

destroy(): void;
getEndpoints(el: jsPlumbElement): Array<Endpoint>;
getEndpoints(el: T["E"]): Array<Endpoint>;
getEndpoint(id: string): Endpoint;

@@ -232,34 +234,34 @@ connect(params: ConnectParams, referenceParams?: ConnectParams): Connection;

_finaliseConnection(jpc: Connection, params?: any, originalEvent?: Event): void;
removeAllEndpoints(el: jsPlumbElement, recurse?: boolean, affectedElements?: Array<jsPlumbElement>): JsPlumbInstance;
removeAllEndpoints(el: T["E"], recurse?: boolean, affectedElements?: Array<T["E"]>): JsPlumbInstance;
private _setEnabled;
toggleSourceEnabled(el: jsPlumbElement, connectionType?: string): any;
setSourceEnabled(el: jsPlumbElement, state: boolean, connectionType?: string): any;
findFirstSourceDefinition(el: jsPlumbElement, connectionType?: string): SourceDefinition;
findFirstTargetDefinition(el: jsPlumbElement, connectionType?: string): TargetDefinition;
toggleSourceEnabled(el: T["E"], connectionType?: string): any;
setSourceEnabled(el: T["E"], state: boolean, connectionType?: string): any;
findFirstSourceDefinition(el: T["E"], connectionType?: string): SourceDefinition;
findFirstTargetDefinition(el: T["E"], connectionType?: string): TargetDefinition;
private findFirstDefinition;
isSource(el: jsPlumbElement, connectionType?: string): any;
isSourceEnabled(el: jsPlumbElement, connectionType?: string): boolean;
toggleTargetEnabled(el: jsPlumbElement, connectionType?: string): any;
isTarget(el: jsPlumbElement, connectionType?: string): boolean;
isTargetEnabled(el: jsPlumbElement, connectionType?: string): boolean;
setTargetEnabled(el: jsPlumbElement, state: boolean, connectionType?: string): any;
isSource(el: T["E"], connectionType?: string): any;
isSourceEnabled(el: T["E"], connectionType?: string): boolean;
toggleTargetEnabled(el: T["E"], connectionType?: string): any;
isTarget(el: T["E"], connectionType?: string): boolean;
isTargetEnabled(el: T["E"], connectionType?: string): boolean;
setTargetEnabled(el: T["E"], state: boolean, connectionType?: string): any;
private _unmake;
private _unmakeEvery;
unmakeTarget(el: jsPlumbElement, connectionType?: string): void;
unmakeSource(el: jsPlumbElement, connectionType?: string): void;
unmakeTarget(el: T["E"], connectionType?: string): void;
unmakeSource(el: T["E"], connectionType?: string): void;
unmakeEverySource(connectionType?: string): void;
unmakeEveryTarget(connectionType?: string): void;
private _writeScopeAttribute;
makeSource(el: jsPlumbElement, params?: BehaviouralTypeDescriptor, referenceParams?: any): JsPlumbInstance;
makeSource(el: jsPlumbElement<T["E"]>, params?: BehaviouralTypeDescriptor, referenceParams?: any): JsPlumbInstance;
private _getScope;
getSourceScope(el: jsPlumbElement): string;
getTargetScope(el: jsPlumbElement): string;
getScope(el: jsPlumbElement): string;
getSourceScope(el: T["E"]): string;
getTargetScope(el: T["E"]): string;
getScope(el: T["E"]): string;
private _setScope;
setSourceScope(el: jsPlumbElement, scope: string): void;
setTargetScope(el: jsPlumbElement, scope: string): void;
setScope(el: jsPlumbElement, scope: string): void;
makeTarget(el: jsPlumbElement, params: BehaviouralTypeDescriptor, referenceParams?: any): JsPlumbInstance;
show(el: jsPlumbElement, changeEndpoints?: boolean): JsPlumbInstance;
hide(el: jsPlumbElement, changeEndpoints?: boolean): JsPlumbInstance;
setSourceScope(el: T["E"], scope: string): void;
setTargetScope(el: T["E"], scope: string): void;
setScope(el: T["E"], scope: string): void;
makeTarget(el: T["E"], params: BehaviouralTypeDescriptor, referenceParams?: any): JsPlumbInstance;
show(el: T["E"], changeEndpoints?: boolean): JsPlumbInstance;
hide(el: T["E"], changeEndpoints?: boolean): JsPlumbInstance;
private _setVisible;

@@ -269,3 +271,3 @@ /**

*/
toggleVisible(el: jsPlumbElement, changeEndpoints?: boolean): void;
toggleVisible(el: T["E"], changeEndpoints?: boolean): void;
private _operation;

@@ -279,39 +281,39 @@ registerConnectionType(id: string, type: TypeDescriptor): void;

restoreDefaults(): JsPlumbInstance;
getManagedElements(): Dictionary<ManagedElement>;
proxyConnection(connection: Connection, index: number, proxyEl: jsPlumbElement, proxyElId: string, endpointGenerator: any, anchorGenerator: any): void;
getManagedElements(): Dictionary<ManagedElement<T["E"]>>;
proxyConnection(connection: Connection, index: number, proxyEl: T["E"], proxyElId: string, endpointGenerator: any, anchorGenerator: any): void;
unproxyConnection(connection: Connection, index: number, proxyElId: string): void;
sourceOrTargetChanged(originalId: string, newId: string, connection: any, newElement: any, index: number): void;
getGroup(groupId: string): UIGroup;
getGroupFor(el: jsPlumbElement): UIGroup;
addGroup(params: AddGroupOptions): UIGroup;
addToGroup(group: string | UIGroup, ...el: Array<jsPlumbElement>): void;
collapseGroup(group: string | UIGroup): void;
expandGroup(group: string | UIGroup): void;
toggleGroup(group: string | UIGroup): void;
removeGroup(group: string | UIGroup, deleteMembers?: boolean, manipulateView?: boolean, doNotFireEvent?: boolean): void;
getGroup(groupId: string): UIGroup<T["E"]>;
getGroupFor(el: T["E"]): UIGroup<T["E"]>;
addGroup(params: AddGroupOptions): UIGroup<T["E"]>;
addToGroup(group: string | UIGroup<T["E"]>, ...el: Array<T["E"]>): void;
collapseGroup(group: string | UIGroup<T["E"]>): void;
expandGroup(group: string | UIGroup<T["E"]>): void;
toggleGroup(group: string | UIGroup<T["E"]>): void;
removeGroup(group: string | UIGroup<T["E"]>, deleteMembers?: boolean, manipulateView?: boolean, doNotFireEvent?: boolean): void;
removeAllGroups(deleteMembers?: boolean, manipulateView?: boolean): void;
removeFromGroup(group: string | UIGroup, ...el: Array<jsPlumbElement>): void;
abstract getElement(el: any | string): any;
abstract getElementById(el: string): any;
abstract removeElement(el: any): void;
abstract appendElement(el: any, parent: any): void;
abstract getChildElements(el: jsPlumbElement): Array<jsPlumbElement>;
abstract removeClass(el: any, clazz: string): void;
abstract addClass(el: any, clazz: string): void;
abstract toggleClass(el: any, clazz: string): void;
abstract getClass(el: any): string;
abstract hasClass(el: any, clazz: string): boolean;
abstract setAttribute(el: any, name: string, value: string): void;
abstract getAttribute(el: any, name: string): string;
abstract setAttributes(el: any, atts: Dictionary<string>): void;
abstract removeAttribute(el: any, attName: string): void;
abstract getSelector(ctx: string | any, spec?: string): NodeListOf<any>;
abstract getStyle(el: any, prop: string): any;
abstract _getSize(el: any): Size;
abstract _getOffset(el: any | string): Offset;
abstract _getOffsetRelativeToRoot(el: any | string): Offset;
abstract setPosition(el: any, p: Offset): void;
abstract on(el: any, event: string, callbackOrSelector: Function | string, callback?: Function): void;
abstract off(el: any, event: string, callback: Function): void;
abstract trigger(el: any, event: string, originalEvent?: Event, payload?: any): void;
removeFromGroup(group: string | UIGroup<T["E"]>, ...el: Array<T["E"]>): void;
abstract getElement(el: T["E"] | string): T["E"];
abstract getElementById(id: string): T["E"];
abstract removeElement(el: T["E"]): void;
abstract appendElement(el: T["E"], parent: T["E"]): void;
abstract getChildElements(el: T["E"]): Array<T["E"]>;
abstract removeClass(el: T["E"], clazz: string): void;
abstract addClass(el: T["E"], clazz: string): void;
abstract toggleClass(el: T["E"], clazz: string): void;
abstract getClass(el: T["E"]): string;
abstract hasClass(el: T["E"], clazz: string): boolean;
abstract setAttribute(el: T["E"], name: string, value: string): void;
abstract getAttribute(el: T["E"], name: string): string;
abstract setAttributes(el: T["E"], atts: Dictionary<string>): void;
abstract removeAttribute(el: T["E"], attName: string): void;
abstract getSelector(ctx: string | T["E"], spec?: string): NodeListOf<any>;
abstract getStyle(el: T["E"], prop: string): any;
abstract _getSize(el: T["E"]): Size;
abstract _getOffset(el: T["E"]): Offset;
abstract _getOffsetRelativeToRoot(el: T["E"] | string): Offset;
abstract setPosition(el: T["E"], p: Offset): void;
abstract on(el: T["E"], event: string, callbackOrSelector: Function | string, callback?: Function): void;
abstract off(el: T["E"], event: string, callback: Function): void;
abstract trigger(el: T["E"], event: string, originalEvent?: Event, payload?: any): void;
abstract getPath(segment: Segment, isFirstSegment: boolean): string;

@@ -337,11 +339,11 @@ abstract paintOverlay(o: Overlay, params: any, extents: any): void;

abstract applyConnectorType(connector: AbstractConnector, t: TypeDescriptor): void;
abstract applyEndpointType(ep: Endpoint, t: TypeDescriptor): void;
abstract setEndpointVisible(ep: Endpoint, v: boolean): void;
abstract destroyEndpoint(ep: Endpoint): void;
abstract paintEndpoint(ep: Endpoint, paintStyle: PaintStyle): void;
abstract addEndpointClass(ep: Endpoint, c: string): void;
abstract removeEndpointClass(ep: Endpoint, c: string): void;
abstract getEndpointClass(ep: Endpoint): string;
abstract setEndpointHover(endpoint: Endpoint, h: boolean, doNotCascade?: boolean): void;
abstract refreshEndpoint(endpoint: Endpoint): void;
abstract applyEndpointType(ep: Endpoint<T>, t: TypeDescriptor): void;
abstract setEndpointVisible(ep: Endpoint<T>, v: boolean): void;
abstract destroyEndpoint(ep: Endpoint<T>): void;
abstract paintEndpoint(ep: Endpoint<T>, paintStyle: PaintStyle): void;
abstract addEndpointClass(ep: Endpoint<T>, c: string): void;
abstract removeEndpointClass(ep: Endpoint<T>, c: string): void;
abstract getEndpointClass(ep: Endpoint<T>): string;
abstract setEndpointHover(endpoint: Endpoint<T>, h: boolean, doNotCascade?: boolean): void;
abstract refreshEndpoint(endpoint: Endpoint<T>): void;
}

9

types/core/endpoint/endpoint-impl.d.ts
import { EndpointSpec, InternalEndpointOptions } from "../endpoint/endpoint";
import { jsPlumbElement } from '../common';
import { JsPlumbInstance } from "../core";

@@ -13,3 +12,3 @@ import { Anchor } from "../anchor/anchor";

import { ViewportElement } from "../viewport";
export declare class Endpoint extends OverlayCapableComponent {
export declare class Endpoint<E = any> extends OverlayCapableComponent {
instance: JsPlumbInstance;

@@ -25,6 +24,5 @@ getIdPrefix(): string;

endpoint: EndpointRepresentation<any>;
element: jsPlumbElement;
element: E;
elementId: string;
dragAllowedWhenFull: boolean;
scope: string;
timestamp: string;

@@ -57,5 +55,6 @@ portId: string;

private uuid;
scope: string;
defaultLabelLocation: [number, number];
getDefaultOverlayKey(): string;
constructor(instance: JsPlumbInstance, params: InternalEndpointOptions);
constructor(instance: JsPlumbInstance, params: InternalEndpointOptions<E>);
private _updateAnchorClass;

@@ -62,0 +61,0 @@ private prepareAnchor;

9

types/core/endpoint/endpoint.d.ts

@@ -8,3 +8,2 @@ import { AnchorSpec } from "../factory/anchor-factory";

import { Connection } from "../connector/connection-impl";
import { jsPlumbElement } from "../common";
import { Endpoint } from "./endpoint-impl";

@@ -15,9 +14,9 @@ export declare type EndpointId = "Rectangle" | "Dot" | "Blank" | UserDefinedEndpointId;

export declare type EndpointSpec = EndpointId | [EndpointId, EndpointParams];
export interface InternalEndpointOptions extends EndpointOptions {
export interface InternalEndpointOptions<E> extends EndpointOptions<E> {
isTemporarySource?: boolean;
}
export interface EndpointOptions extends ComponentOptions {
export interface EndpointOptions<E> extends ComponentOptions {
anchor?: AnchorSpec | Anchor;
anchors?: [AnchorSpec, AnchorSpec];
endpoint?: EndpointSpec | Endpoint;
endpoint?: EndpointSpec | Endpoint<E>;
enabled?: boolean;

@@ -51,3 +50,3 @@ paintStyle?: PaintStyle;

uuid?: string;
source?: jsPlumbElement;
source?: E;
connections?: Array<Connection>;

@@ -54,0 +53,0 @@ detachable?: boolean;

2

types/core/factory/anchor-factory.d.ts

@@ -33,5 +33,5 @@ import { Connection } from "../connector/connection-impl";

export declare const Anchors: {
get: (instance: JsPlumbInstance, name: string, args: any) => Anchor;
get: (instance: JsPlumbInstance<any>, name: string, args: any) => Anchor;
};
export declare function makeAnchorFromSpec(instance: JsPlumbInstance, spec: AnchorSpec, elementId?: string): Anchor;
export declare type ShapeFunction = (anchorCount: number, p?: any) => Array<any>;

2

types/core/factory/endpoint-factory.d.ts

@@ -5,4 +5,4 @@ import { EndpointRepresentation } from "../endpoint/endpoints";

export declare const EndpointFactory: {
get: (ep: Endpoint, name: string, params: any) => EndpointRepresentation<any>;
get: (ep: Endpoint<any>, name: string, params: any) => EndpointRepresentation<any>;
register: (name: string, ep: Constructable<EndpointRepresentation<any>>) => void;
};

2

types/core/factory/overlay-factory.d.ts

@@ -6,4 +6,4 @@ import { Overlay } from '../overlay/overlay';

export declare const OverlayFactory: {
get: (instance: JsPlumbInstance, name: string, component: Component, params: any) => Overlay;
get: (instance: JsPlumbInstance<any>, name: string, component: Component, params: any) => Overlay;
register: (name: string, overlay: Constructable<Overlay>) => void;
};

50

types/core/group/group-manager.d.ts

@@ -1,2 +0,2 @@

import { Dictionary, jsPlumbElement, Offset } from '../common';
import { Dictionary, Offset } from '../common';
import { JsPlumbInstance } from "../core";

@@ -9,23 +9,23 @@ import { UIGroup } from "./group";

}
export declare class GroupManager {
export declare class GroupManager<E> {
instance: JsPlumbInstance;
groupMap: Dictionary<UIGroup>;
_connectionSourceMap: Dictionary<UIGroup>;
_connectionTargetMap: Dictionary<UIGroup>;
groupMap: Dictionary<UIGroup<E>>;
_connectionSourceMap: Dictionary<UIGroup<E>>;
_connectionTargetMap: Dictionary<UIGroup<E>>;
constructor(instance: JsPlumbInstance);
private _cleanupDetachedConnection;
addGroup(params: AddGroupOptions): UIGroup;
getGroup(groupId: string | UIGroup): UIGroup;
getGroupFor(el: jsPlumbElement): UIGroup;
getGroups(): Array<UIGroup>;
removeGroup(group: string | UIGroup, deleteMembers?: boolean, manipulateView?: boolean, doNotFireEvent?: boolean): Dictionary<Offset>;
addGroup(params: AddGroupOptions): UIGroup<E>;
getGroup(groupId: string | UIGroup<E>): UIGroup<E>;
getGroupFor(el: E): UIGroup<E>;
getGroups(): Array<UIGroup<E>>;
removeGroup(group: string | UIGroup<E>, deleteMembers?: boolean, manipulateView?: boolean, doNotFireEvent?: boolean): Dictionary<Offset>;
removeAllGroups(deleteMembers?: boolean, manipulateView?: boolean, doNotFireEvent?: boolean): void;
forEach(f: (g: UIGroup) => any): void;
orphan(_el: any): [string, Offset];
forEach(f: (g: UIGroup<E>) => any): void;
orphan(el: E): [string, Offset];
private _setGroupVisible;
_updateConnectionsForGroup(group: UIGroup): void;
_updateConnectionsForGroup(group: UIGroup<E>): void;
private _collapseConnection;
private _expandConnection;
private isElementDescendant;
collapseGroup(group: string | UIGroup): void;
collapseGroup(group: string | UIGroup<E>): void;
/**

@@ -37,4 +37,4 @@ * Cascade a collapse from the given `collapsedGroup` into the given `targetGroup`.

*/
cascadeCollapse(collapsedGroup: UIGroup, targetGroup: UIGroup, collapsedIds: Set<string>): void;
expandGroup(group: string | UIGroup, doNotFireEvent?: boolean): void;
cascadeCollapse(collapsedGroup: UIGroup<E>, targetGroup: UIGroup<E>, collapsedIds: Set<string>): void;
expandGroup(group: string | UIGroup<E>, doNotFireEvent?: boolean): void;
/**

@@ -45,12 +45,12 @@ * Cascade an expand from the given `collapsedGroup` into the given `targetGroup`.

*/
cascadeExpand(expandedGroup: UIGroup, targetGroup: UIGroup): void;
toggleGroup(group: string | UIGroup): void;
repaintGroup(group: string | UIGroup): void;
addToGroup(group: string | UIGroup, doNotFireEvent: boolean, ...el: Array<jsPlumbElement>): void;
removeFromGroup(group: string | UIGroup, doNotFireEvent: boolean, ...el: Array<jsPlumbElement>): void;
getAncestors(group: UIGroup): Array<UIGroup>;
isAncestor(group: UIGroup, possibleAncestor: UIGroup): boolean;
getDescendants(group: UIGroup): Array<UIGroup>;
isDescendant(possibleDescendant: UIGroup, ancestor: UIGroup): boolean;
cascadeExpand(expandedGroup: UIGroup<E>, targetGroup: UIGroup<E>): void;
toggleGroup(group: string | UIGroup<E>): void;
repaintGroup(group: string | UIGroup<E>): void;
addToGroup(group: string | UIGroup<E>, doNotFireEvent: boolean, ...el: Array<E>): void;
removeFromGroup(group: string | UIGroup<E>, doNotFireEvent: boolean, ...el: Array<E>): void;
getAncestors(group: UIGroup<E>): Array<UIGroup<E>>;
isAncestor(group: UIGroup<E>, possibleAncestor: UIGroup<E>): boolean;
getDescendants(group: UIGroup<E>): Array<UIGroup<E>>;
isDescendant(possibleDescendant: UIGroup<E>, ancestor: UIGroup<E>): boolean;
reset(): void;
}

24

types/core/group/group.d.ts

@@ -21,12 +21,12 @@ import { Dictionary, Offset } from '../common';

}
export declare class UINode {
export declare class UINode<E> {
instance: JsPlumbInstance;
el: any;
group: UIGroup;
group: UIGroup<E>;
constructor(instance: JsPlumbInstance, el: any);
}
export declare class UIGroup extends UINode {
export declare class UIGroup<E = any> extends UINode<E> {
instance: JsPlumbInstance;
children: Array<any>;
childGroups: Array<UIGroup>;
childGroups: Array<UIGroup<E>>;
collapsed: boolean;

@@ -49,7 +49,7 @@ droppable: boolean;

};
groups: Array<UIGroup>;
manager: GroupManager;
groups: Array<UIGroup<E>>;
manager: GroupManager<E>;
id: string;
constructor(instance: JsPlumbInstance, el: any, options: GroupOptions);
overrideDrop(el: any, targetGroup: UIGroup): boolean;
overrideDrop(el: any, targetGroup: UIGroup<E>): boolean;
getContentArea(): any;

@@ -59,9 +59,9 @@ getAnchor(conn: Connection, endpointIndex: number): AnchorSpec;

add(_el: any, doNotFireEvent?: boolean): void;
remove(el: any | Array<any>, manipulateDOM?: boolean, doNotFireEvent?: boolean, doNotUpdateConnections?: boolean, targetGroup?: UIGroup): void;
remove(el: E | Array<E>, manipulateDOM?: boolean, doNotFireEvent?: boolean, doNotUpdateConnections?: boolean, targetGroup?: UIGroup<E>): void;
removeAll(manipulateDOM?: boolean, doNotFireEvent?: boolean): void;
orphanAll(): Dictionary<Offset>;
addGroup(group: UIGroup): boolean;
removeGroup(group: UIGroup): void;
getGroups(): Array<UIGroup>;
get collapseParent(): UIGroup;
addGroup(group: UIGroup<E>): boolean;
removeGroup(group: UIGroup<E>): void;
getGroups(): Array<UIGroup<E>>;
get collapseParent(): UIGroup<E>;
}
js/jsplumb.community.cjs.js

Sorry, the diff of this file is too big to display

js/jsplumb.community.es.js

Sorry, the diff of this file is too big to display

js/jsplumb.community.umd.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc