@visuallyjs/browser-ui 1.0.0

package/types/browser-ui/surface-renderer/plugins/resizing-tools/definitions.d.ts

@@ -0,0 +1,411 @@
+import { Group, Node, ObjectData, PointXY, Size, Vertex, VisuallyJsModel } from "../../../../core";
+import { Surface } from "../../surface";
+import { BrowserUIPluginOptions } from "../../../plugins";
+import { BrowserElement } from "../../../util";
+/**
+ * The default width/height of a resize handle when the container is an SVG element.
+ * @internal
+ */
+export declare const DEFAULT_SVG_HANDLE_SIZE = 12;
+/**
+ * The default length of the leader line to the resize handle when using the resizing tools in an SVG container.
+ * @internal
+ */
+export declare const DEFAULT_ROTATE_LEADER_LENGTH = 40;
+/**
+ * Default size of the rotate handle.
+ * @internal
+ */
+export declare const DEFAULT_ROTATE_HANDLE_SIZE = 16;
+/**
+ * Default size for border handles.
+ * @internal
+ */
+export declare const DEFAULT_BORDER_HANDLE_SIZE = 6;
+/**
+ * Options for the resizing tool plugin.
+ * @group Plugins
+ * @category Resizing Tools
+ */
+export interface ResizingToolsPluginOptions extends BrowserUIPluginOptions {
+    /**
+     * Attribute to use for vertex width - defaults to 'width'
+     */
+    widthAttribute?: string;
+    /**
+     * Attribute to use for vertex height - defaults to 'height'
+     */
+    heightAttribute?: string;
+    /**
+     * Attribute to use for vertex left position - defaults to 'left'
+     */
+    leftAttribute?: string;
+    /**
+     * Attribute to use for vertex top position - defaults to 'top'
+     */
+    topAttribute?: string;
+    /**
+     * Optional callback invoked after an edit has occurred
+     */
+    onEdit?: (o: Node | Group, surface: Surface, toolkit: VisuallyJsModel) => any;
+    /**
+     * Defaults to false, meaning the resizing tool plugin switches on whenever a new vertex is selected.
+     */
+    onDemand?: boolean;
+    /**
+     * Minimum height the user can shrink a vertex to. Defaults to 30.
+     */
+    minimumHeight?: number;
+    /**
+     * Minimum width the user can shrink a vertex to. Defaults to 30.
+     */
+    minimumWidth?: number;
+    /**
+     * Defaults to false, meaning size changes conform to an underlying grid, if present
+     */
+    ignoreGrid?: boolean;
+    /**
+     * Defaults to true, meaning groups will not be shrunk to the point that one or more of their child vertices is no longer visible.
+     */
+    constrainGroups?: boolean;
+    /**
+     * Whether or not to support rotation on all elements.. Defaults to false.
+     */
+    rotatable?: boolean;
+    /**
+     * Optional number of stops to use when rotating. If not provided vertices can be rotated to any angle. If provided, the value is divided into 360 and the result is the angle between each stop. For example, a value of 12 means each stop is 30 degrees.
+     */
+    rotationStops?: number;
+    /**
+     * Whether or not to support resize in the X axis. Defaults to true.
+     */
+    resizeX?: boolean;
+    /**
+     * Whether or not to support resize in the Y axis. Defaults to true.
+     */
+    resizeY?: boolean;
+    /**
+     * Method to use for resize - handles on the corners, or borders. Defaults to handles.
+     */
+    resizeMethod?: ResizingToolsResizeMethod;
+    /**
+     * When resizeMethod is "borders", set this to make the borders visible. Internally this just sets a CSS class on the draw skeleton's parent DOM element, and the appearance of the borders is then controlled via CSS.
+     */
+    bordersVisible?: boolean;
+    /**
+     * Optional function to invoke when a resize has occurred. The values the resizing plugin wants to write for the vertex are merged on top of the value returned from this function, and the combined payload is written as an update to the vertex in the data model. This exists for internal use mostly but there's no harm in it being exposed for your enjoyment.
+     * @param v
+     * @param p
+     */
+    payloadGenerator?: (v: Node, p: ObjectData) => ObjectData;
+    /**
+     * Width/height to use for handles. Defaults to 20 pixels.
+     */
+    handleSize?: number;
+    /**
+     * Shape of resize handles. Defaults to circle.
+     */
+    handleShape?: "rectangle" | "circle";
+    /**
+     * Length of the leader line to the resize handle when using the resizing tools in an SVG container. Defaults to 30 pixels.
+     */
+    rotateLeaderLength?: number;
+    /**
+     * Size of the rotate handle. Defaults to 16 pixels.
+     */
+    rotateHandleSize?: number;
+    /**
+     * Size of handles when using "border" resize. Defaults to 6 pixels.
+     */
+    borderHandleSize?: number;
+    /**
+     * Optional function that can decide on whether or not the given vertex should be resizable
+     * @param v
+     * @param el
+     */
+    canResizeFilter?: (v: Vertex, el: BrowserElement) => boolean;
+    /**
+     * Optional function that can decide on whether or not the given vertex should be rotatable
+     * @param v
+     * @param el
+     */
+    canRotateFilter?: (v: Vertex, el: BrowserElement) => boolean;
+    /**
+     * How much to offset the resize frame and handles from the bounds of the shape. Defaults to 5 pixels.
+     */
+    handleOffset?: number;
+    /**
+     * Optional function that can inject extra model updates each time a vertex is resized.
+     */
+    modelUpdater?: ResizingToolsModelUpdater;
+    /**
+     * Optional factory that can return a resize handler for some given vertex. You can use this to override the default behaviour for any vertex you choose
+     * @param vertex
+     */
+    handlerFactory?: ResizingToolsHandlerFactory;
+}
+/**
+ * @internal
+ */
+export declare const DEFAULT_MINIMUM_WIDTH = 30;
+/** @internal */
+export declare const DEFAULT_MINIMUM_HEIGHT = 30;
+/** @internal */
+export declare const DEFAULT_HANDLE_OFFSET = 5;
+/**
+ * Defines the resize method using element borders
+ * @group Plugins
+ * @category Resizing Tools
+ * @constant
+ */
+export declare const RESIZING_TOOLS_RESIZE_METHOD_BORDERS = "borders";
+/**
+ * Defines the resize method using handles at the corner of an element.
+ * @group Plugins
+ * @category Resizing Tools
+ * @constant
+ */
+export declare const RESIZING_TOOLS_RESIZE_METHOD_HANDLES = "handles";
+/**
+ * Defines the available resize methods.
+ * @group Plugins
+ * @category Resizing Tools
+ */
+export type ResizingToolsResizeMethod = typeof RESIZING_TOOLS_RESIZE_METHOD_BORDERS | typeof RESIZING_TOOLS_RESIZE_METHOD_HANDLES;
+/**
+ * Set on the element that is the parent of drag handles when in `handles` resize mode.
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_SKELETON = "vjs-resize-skeleton";
+/**
+ * Set on the element that is the parent of drag borders when in `borders` resize mode.
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_SKELETON_BORDERS = "vjs-resize-skeleton-borders";
+/**
+ * Set on the resize tool's main group element for some vertex when `bordersVisible` is set to true and the resize mode is {@link RESIZING_TOOLS_RESIZE_METHOD_BORDERS}
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_SKELETON_BORDERS_VISIBLE = "vjs-resize-skeleton-borders-visible";
+/**
+ * Set on the frame the resize tool draws around an object it is currently editing.
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_FRAME = "vjs-resize-frame";
+/**
+ * Set on the resize handles by the resizing/diagram tools
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE = "vjs-resize-handle";
+/**
+ * Set on a resize handle when it is being actively used
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_ACTIVE = "vjs-resize-handle-active";
+/**
+ * Set on the top left corner resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_TL = "vjs-resize-handle-tl";
+/**
+ * Set on the bottom left corner resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_BL = "vjs-resize-handle-bl";
+/**
+ * Set on the top right corner resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_TR = "vjs-resize-handle-tr";
+/**
+ * Set on the bottom right corner resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_BR = "vjs-resize-handle-br";
+/**
+ * Set on the top center resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_T = "vjs-resize-handle-t";
+/**
+ * Set on the bottom center resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_B = "vjs-resize-handle-b";
+/**
+ * Set on the left center resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_L = "vjs-resize-handle-l";
+/**
+ * Set on the right center resize handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_HANDLE_R = "vjs-resize-handle-r";
+/**
+ * Set on the border handles
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_BORDER = "vjs-resize-border";
+/**
+ * Set on the bottom border handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_BORDER_BOTTOM = "vjs-resize-border-b";
+/**
+ * Set on the top border handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_BORDER_TOP = "vjs-resize-border-t";
+/**
+ * Set on the left border handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_BORDER_LEFT = "vjs-resize-border-l";
+/**
+ * Set on the right border handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_RESIZE_BORDER_RIGHT = "vjs-resize-border-r";
+/**
+ * Set on the rotation handle
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_ROTATE_HANDLE = "vjs-rotate-handle";
+/**
+ * Set on the leader to the rotation handle.
+ * @group Plugins
+ * @category Resizing Tools
+ * @cssClass
+ * @context resizingTools
+ */
+export declare const CLASS_ROTATE_LEADER = "vjs-rotate-leader";
+/**
+ * When set to true on some element, disables resize in the X axis.
+ * @group Plugins
+ * @category Resizing Tools
+ * @dataAttribute
+ * @context resizingTools
+ */
+export declare const ATT_VJS_X_RESIZE = "data-vjs-x-resize";
+/**
+ * When set to true on some element, disables resize in the Y axis.
+ * @group Plugins
+ * @category Resizing Tools
+ * @dataAttribute
+ * @context resizingTools
+ */
+export declare const ATT_VJS_Y_RESIZE = "data-vjs-y-resize";
+/**
+ * When set to false on some element, disables resize.
+ * @group Plugins
+ * @category Resizing Tools
+ * @dataAttribute
+ * @context resizingTools
+ */
+export declare const ATT_VJS_RESIZABLE = "data-vjs-resizable";
+/**
+ * When set to false on some element, disables rotate.
+ * @group Plugins
+ * @category Resizing Tools
+ * @dataAttribute
+ * @context resizingTools
+ */
+export declare const ATT_VJS_ROTATABLE = "data-vjs-rotatable";
+/** @internal */
+export declare const ATT_DATA_DIR = "data-dir";
+/**
+ * Possible directions for resize - top/left/bottom/right/top left/top right/bottom right/bottom left
+ */
+export type ResizeDirection = "t" | "l" | "b" | "r" | "tl" | "tr" | "br" | "bl";
+/**
+ * Function invoked each time a resize event occurs that a {@link ResizingToolsHandlerFactory} is controlling. This function is expected to return an object containing a new x, y, width and height for the vertex being resized, as well as, optionally, an object containing required updates to other model objects, keyed by the other model object's IDs.
+ */
+export type ResizeFunction = (dx: number, dy: number) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    updates?: Record<string, ObjectData>;
+};
+/**
+ * @internal
+ */
+export type ResizeHandler = {
+    /**
+     * Resize returns new bounds for the element, and optional extra set of updates for other vertices.
+     * @param dx
+     * @param dy
+     */
+    resize: ResizeFunction;
+    id: string;
+    anchor: [0 | 1 | 0.5, 0 | 1 | 0.5];
+};
+/**
+ * A factory that can return handlers for resize, given a vertex to resize and a resize direction (as well as the default resize function for the given direction). When a resize begins, the factory is called with the ui, current vertex, resize direction, and default handler. It returns a {@link ResizeFunction} that is invoked each time a discrete resize event then occurs, until the mouse/pointer is released. Each time the resize function is invoked, it is expected to return an object containing a new x, y, width and height for the vertex being resized, as well as, optionally, an object containing required updates to other model objects. This object is keyed by vertex ID, and its values are individual updates to apply to the vertex with that ID.
+ */
+export type ResizingToolsHandlerFactory = (ui: Surface, vertex: Node | Group, resizeDirection: ResizeDirection, defaultHandler: ResizeFunction) => ResizeFunction;
+/**
+ * Defines a function that is invoked each time the resizing tools writes a size update to the model. The vertex that was resized, plus its new position and size, are passed to this function, and the function return a record of other updates it wishes to make to the model, keyed by object id. These updates are written and included as part of the transaction, and will be undone if the resize operation is subsequently undone.
+ */
+export type ResizingToolsModelUpdater = (v: Node, pos: PointXY, size: Size) => Record<string, ObjectData>;

package/types/browser-ui/surface-renderer/plugins/resizing-tools/drag-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ResizingToolsPlugin } from "./resizing-tools-plugin";
+import { ResizeHandler } from "./definitions";
+export declare function createHandleDragHandlers(p: ResizingToolsPlugin): Record<string, ResizeHandler>;

package/types/browser-ui/surface-renderer/plugins/resizing-tools/handle-gen.d.ts

@@ -0,0 +1,15 @@
+import { BrowserElement } from "../../../util";
+import { Size } from "../../../../core";
+/**
+ @internal
+*/
+export declare function $_createRectangularSvgHandles(handleSize: number, elSize: Size, obj: any, strokeWidth: number, parent: BrowserElement, offset: number, canResizeX: boolean, canResizeY: boolean): any;
+/**
+ * @internal
+ * @param handleSize
+ * @param elSize
+ * @param obj
+ * @param strokeWidth
+ * @param parent
+ */
+export declare function $_createCircularSvgHandles(handleSize: number, elSize: Size, obj: any, strokeWidth: number, parent: BrowserElement, offset: number, canResizeX: boolean, canResizeY: boolean): any;

package/types/browser-ui/surface-renderer/plugins/resizing-tools/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./definitions";
+export * from "./resizing-tools-plugin";
+export * from './handle-gen';
+export * from './util';

package/types/browser-ui/surface-renderer/plugins/resizing-tools/resizing-tools-plugin.d.ts

@@ -0,0 +1,185 @@
+import { ResizingToolsPluginOptions, ResizeHandler, ResizeDirection } from "./definitions";
+import { Grid, PointXY, Group, Node, ObjectData, VisuallyJsModel, Size, Vertex, VertexUpdatedReason } from "../../../../core";
+import { Surface } from "../../surface";
+import { BrowserElement } from "../../../util";
+import { ViewportElement, GroupMapping, ViewportGroupElement, GroupContentAreaInfo, GroupResizeResult } from "../../../../ui";
+import { BaseBrowserUIPlugin, BrowserUIPlugin } from "../../../plugins";
+import { ElasticGroupManager } from "../../elastic-group-manager";
+/**
+ * This plugin offers tools for users to resize/rotate elements using touch/mouse events.
+ * @group Plugins
+ * @category Resizing Tools
+ */
+export declare class ResizingToolsPlugin extends BaseBrowserUIPlugin implements BrowserUIPlugin<ResizingToolsPluginOptions> {
+    static type: string;
+    id: string;
+    surface: Surface;
+    instance: VisuallyJsModel;
+    widthAtt: string;
+    heightAtt: string;
+    leftAtt: string;
+    topAtt: string;
+    xAxis: boolean;
+    yAxis: boolean;
+    resizeX: boolean;
+    resizeY: boolean;
+    canResizeFilter: (v: Vertex, el: BrowserElement) => boolean;
+    canRotateFilter: (v: Vertex, el: BrowserElement) => boolean;
+    onEdit: (o: Node | Group, surface: Surface, toolkit: VisuallyJsModel) => any;
+    onDemand: boolean;
+    _currentDragDirection: ResizeDirection;
+    _currentRotation: number;
+    _currentPosition: PointXY;
+    _currentWidth: number;
+    _currentHeight: number;
+    _currentCenter: PointXY;
+    _currentSize: Size;
+    skeletons: Record<string, {
+        mel: ViewportElement<BrowserElement>;
+        el: BrowserElement;
+        canResizeX: boolean;
+        canResizeY: boolean;
+        handles: {
+            tl: BrowserElement;
+            bl: BrowserElement;
+            tr: BrowserElement;
+            br: BrowserElement;
+            t?: BrowserElement;
+            b?: BrowserElement;
+            r?: BrowserElement;
+            l?: BrowserElement;
+        };
+        borders: {
+            t: BrowserElement;
+            r: BrowserElement;
+            b: BrowserElement;
+            l: BrowserElement;
+        };
+        rh?: BrowserElement;
+        rl?: BrowserElement;
+        rotatable: boolean;
+        resizable: boolean;
+        frame: BrowserElement;
+    }>;
+    _groupParent: Group;
+    _groupViewportElement: ViewportGroupElement<BrowserElement>;
+    _isInsideElasticGroup: boolean;
+    _groupParentDef: GroupMapping<BrowserElement>;
+    _groupParentContentAreaInfo: GroupContentAreaInfo<BrowserElement>;
+    _currentElasticGroup: ElasticGroupManager;
+    _viewportElement: ViewportElement<any>;
+    private downAt;
+    private _downAtRotated;
+    private handler;
+    private toolkitDragObject;
+    private _currentHandle;
+    $x1: number;
+    $x2: number;
+    $y1: number;
+    $y2: number;
+    private _centerAtDown;
+    minimumHeight: number;
+    minimumWidth: number;
+    currentMinimumWidth: number;
+    currentMinimumHeight: number;
+    ignoreGrid: boolean;
+    grid: Grid;
+    _rotatable: boolean;
+    _constrainGroups: boolean;
+    _rotationStops: number;
+    _moving: boolean;
+    _rotating: boolean;
+    _hasUpdated: boolean;
+    protected $handleOffset: number;
+    private _modelUpdater;
+    private _handlerFactory;
+    private _setResizeActive;
+    set $moving(v: boolean);
+    set $rotating(v: boolean);
+    get $busy(): boolean;
+    _handleSize: number;
+    _handleShape: "rectangle" | "circle";
+    _rotateLeaderLength: number;
+    _rotateHandleSize: number;
+    _borderHandleSize: number;
+    _payloadGenerator: (v: Node, p: ObjectData) => ObjectData;
+    private resizeMethod;
+    private bordersVisible;
+    destroy(): void;
+    _handleDragHandlers: Record<string, ResizeHandler>;
+    _borderDragHandlers: Record<string, ResizeHandler>;
+    initialise(surface: Surface, options: ResizingToolsPluginOptions): boolean;
+    private _configureGroupParent;
+    private _handleMouseDown;
+    /**
+     * Gets the rotation for the current element, 0 if no current element or the current element declares no value.
+     * @internal
+     */
+    private _getCurrentRotation;
+    /**
+     * Rotates the given point around the center of the current element, by default in a clockwise direction, or counter clockwise if requested
+     * @param p
+     * @param anticlockwise
+     * @internal
+     */
+    private _rotatePointAroundCurrentCenter;
+    /**
+     * Gets the origin and size of an element that is being managed by the Surface.
+     * @param v Vertex Node/group to get position for.
+     * @returns A RectangleXY if element was found, otherwise null.
+     */
+    private _getViewportCoordinates;
+    reset(): void;
+    $minWidth(): number;
+    $minHeight(): number;
+    private _removeSkeleton;
+    private _deselect;
+    private _select;
+    protected _attachSvg(mel: ViewportElement<BrowserElement>, obj: any, canResizeX: boolean, canResizeY: boolean): BrowserElement;
+    /**
+     * Sets the position of the resize skeleton pertaining to the vertex with the given id, if one is present.
+     * Takes position and rotation into account.
+     * @internal
+     * @param id Vertex ID
+     */
+    protected $_setSkeletonPositionById(id: string): boolean;
+    /**
+     * Generates a payload for an update call, using the appropriate left/top/width/height attributes, and enforcing minWidth/minHeight where necessary.
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @private
+     */
+    private _generateUpdatePayload;
+    private _rotateHandler;
+    private _resizeHandler;
+    /**
+     * gets the current group offset, if any. When the current vertex is not a child of a group this will return [0,0]; otherwise it returns the group's origin plus any internal offset for the content area.
+     * @private
+     */
+    private _getGroupOffset;
+    /**
+     * Notification that the vertex was re-rendered. If we're attached to the previous element we do a reset, on the next tick.
+     * @param p
+     * @private
+     */
+    $vertexRerendered(p: {
+        el: BrowserElement;
+        id: string;
+        vertex: Vertex;
+        size: Size;
+    }): void;
+    $vertexRotated(element: ViewportElement<BrowserElement>, rotation: number): void;
+    $vertexUpdated(element: ViewportElement<BrowserElement>, reason: VertexUpdatedReason): void;
+    /**
+     * Redraws handles as appropriate, given the new size of the focus object.
+     * @param width
+     * @param height
+     * @private
+     */
+    private _repositionHandles;
+    $vertexSynced(element: ViewportElement<BrowserElement>): void;
+    $groupResized(params: GroupResizeResult<BrowserElement>): void;
+    $groupCollapsed(element: ViewportGroupElement<BrowserElement>): void;
+}

package/types/browser-ui/surface-renderer/plugins/resizing-tools/util.d.ts

@@ -0,0 +1,16 @@
+import { BrowserElement } from "../../../util";
+import { ViewportElement } from "../../../../ui";
+/**
+ * @internal
+ * @param t
+ * @param classes
+ * @param parent
+ * @param attributes
+ */
+export declare function $_createSvg(t: string, classes: Array<string>, parent?: BrowserElement, attributes?: Record<string, any>): BrowserElement;
+/**
+ * Sets the position of the given resize skeleton pertaining to the given managed element.
+ * Takes position and rotation into account.
+ * @internal
+ */
+export declare function $_setSkeletonPosition(s: BrowserElement, mel: ViewportElement<BrowserElement>): void;

package/types/browser-ui/surface-renderer/plugins/snaplines/index.d.ts

@@ -0,0 +1 @@
+export * from './snaplines-plugin';