windmill-components 1.87.0 → 1.89.1

package/package/components/graph/svelvet/nodes/views/Node.svelte

@@ -0,0 +1,84 @@
+<script>import { afterUpdate } from 'svelte';
+import { findStore } from '../../store/controllers/storeApi';
+import { forceCssHeightAndWidth } from '../../customCss/controllers/getCss';
+export let node;
+export let canvasId;
+export let isCustom = false;
+const store = findStore(canvasId);
+const { lockedOption } = store;
+// forceCssHeightAndWidth forces the size of the node to be defined by CSS
+afterUpdate(() => {
+    if (node.className)
+        forceCssHeightAndWidth(store, node);
+});
+const mousedown = (e) => {
+    if (node.clickCallback)
+        node.clickCallback(node);
+};
+</script>
+
+<!-- on:wheel prevents page scroll when using mousewheel in the Node -->
+<div
+	on:mousedown={mousedown}
+	on:touchstart={mousedown}
+	class="{isCustom ? 'CustomNode' : 'Node'} {node.className}"
+	style="left: {node.positionX}px;
+    top: {node.positionY}px;
+    width: {node.width}px;
+    height: {node.height}px;
+    {isCustom
+		? ''
+		: `
+    background-color: ${node.bgColor ?? 'white'};
+    border-color: ${node.borderColor};
+    border-radius: ${node.borderRadius}px;
+    color: ${node.textColor};
+    cursor: ${$lockedOption ? 'default' : 'grab'};`}"
+	id="svelvet-{node.id}"
+>
+	<!-- This executes if node.image is present without node.label -->
+	{#if node.image}
+		<img
+			src={node.src}
+			alt=""
+			style="width: {node.width * 0.75}px;
+			 height: {node.height * 0.75}px;
+       overflow: hidden;"
+		/>
+	{/if}
+	<slot />
+</div>
+
+<style>
+	.CustomNode {
+		position: absolute;
+		display: grid;
+		justify-content: center;
+		align-items: center;
+		font-size: 14px;
+		text-align: center;
+		pointer-events: auto;
+		box-shadow: 1px 1px 3px 1px rgba(0, 0, 0, 0.2);
+	}
+
+	.Node {
+		position: absolute;
+		display: grid;
+		-webkit-user-select: none;
+		   -moz-user-select: none;
+		        user-select: none;
+		justify-content: center;
+		overscroll-behavior: auto;
+		align-items: center;
+		font-size: 14px;
+		text-align: center;
+		border: solid 1px black;
+		border-radius: 5px;
+		box-shadow: 1px 1px 3px 1px rgba(0, 0, 0, 0.2);
+		pointer-events: auto; /* this is needed for pointer events to work since we disable them in graphview */
+	}
+	/* the default behavior when click/dragging an image is to move it. This interferes with node dragging. We disable pointer events on img to prevent this */
+	/* Alternatively, we could use e.preventDefault() on mouseDown. However, this interferes with embedded Svelvet forms */
+	img {
+		pointer-events: none;
+	}</style>

package/package/components/graph/svelvet/nodes/views/Node.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import type { NodeType } from '../../store/types/types';
+declare const __propDef: {
+    props: {
+        node: NodeType;
+        canvasId: string;
+        isCustom?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type NodeProps = typeof __propDef.props;
+export type NodeEvents = typeof __propDef.events;
+export type NodeSlots = typeof __propDef.slots;
+export default class Node extends SvelteComponentTyped<NodeProps, NodeEvents, NodeSlots> {
+}
+export {};

package/package/components/graph/svelvet/store/controllers/storeApi.d.ts

@@ -0,0 +1,32 @@
+import type { StoreType } from '../types/types';
+import type { UserNodeType, UserEdgeType } from '../../types/types';
+/**
+ * findStore is going to return the target Svelvet store with the canvasId provided as argument.
+ * There can be multiple Svelvet canvases on the same page, and each has their own store with a unique canvasId.
+ * @param canvasId The canvasId of a Svelvet component
+ * @returns The store of a Svelvet component that matches the canvasId
+ */
+export declare function findStore(canvasId: string): StoreType;
+/**
+ * createStoreEmpty will initialize a new Svelvet store with a unique canvasId.
+ * If you have multiple Svelvet components on the page, the stores object will look like the following example:
+ * const stores = \{
+ *                  canvasId-1: store of Svelvet component 1,
+ *                  canvasId-2: store of Svelvet component 2,
+ *                  canvasId-3: store of Svelvet component 3,
+ *                \}
+ * Notes: This should be called once every time you initialize a new Svelvet canvas, (ie, only in the Svelvet.svelte file).
+ * This function will initialize an empty store for the Svelvet component and should be followed by invoking populateSvelvetStoreFromUserInput to populate all the initial state from the user input.
+ *
+ * @param canvasId The canvasId of the newly created Svelvet component
+ * @returns An empty store for the newly created Svelvet component.
+ */
+export declare function createStoreEmpty(canvasId: string): StoreType;
+/**
+ * populateSvelvetStoreFromUserInput will populate all the states and set these states into the Svelvet store initialized by invoking createStoreEmpty
+ *
+ * @param canvasId The canvasId of the Svelvet component you are creating a store for
+ * @param nodes This is an array of objects containing node info that is defined by the user. NOTE THAT THE STRUCTURE DIFFERS FROM THE NODES CLASS. The whole point of populateSvelvetStoreFromUserInput is to convert nodes into proper Svelvet Node objects. An example of nodes is in $routes/testingplayground/index.svelte
+ * @param edges Same as nodes, this is an array of objects containing edge info THAT IS DIFFERENT FROM THE EDGE CLASS.
+ */
+export declare function populateSvelvetStoreFromUserInput(canvasId: string, nodes: UserNodeType[], edges: UserEdgeType[]): void;

package/package/components/graph/svelvet/store/controllers/storeApi.js

@@ -0,0 +1,106 @@
+/*
+
+
+Important functions (in order of how likely I think you are to use them):
+
+findStore(canvasId: string)
+- Input: canvasId. There can be multiple Svelvet canvases on the same page, and each has their own store
+- Returns: store
+- Notes: You will need to call this function on every component you make
+
+getNodes(store, filter)
+- Description: this function returns of list of Node objects
+- Input: store: the store where you get the list of Node objects from
+-        filter: an object where you can filter the array. For example, if you want to find nodes with an id of 'sdf-2d3fs' and positionX=35, then you
+                 would set filter = {id: 'sdf-2d3fs, positionX: 35}.
+                 Right now, you can only test for equality.
+- Notes: This is a very mongoose way of retrieving information. Given the relational nature of our stores, maybe it would be better to use an SQL-like syntax
+         This array is non-reactive (ie, you cannot use information from this array to force a re-render of a Svelte component)
+
+createStoreEmpty(canvasId: string)
+- Input: canvasId.
+- Returns: store
+- Notes. This should be called once every time you initialize a new Svelvet canvas, (ie, only in the Svelvet.svelte file)
+
+populateSvelvetStoreFromUserInput(canvasId, nodes, edges)
+- canvasId: this the the canvasId of the Svelvet component you are creating a store for
+- nodes: this is an array of objects containing node info that is defined by the user. NOTE THAT THE STRUCTURE DIFFERS FROM THE NODES CLASS
+         The whole point of populateSvelvetStoreFromUserInput is to convert nodes into proper Svelvet Node objects. An example of nodes is in
+         $routes/testingplayground/index.svelte
+- edges: same as nodes, this is an array of objects containing edge info THAT IS DIFFERENT FROM THE EDGE CLASS.
+- Returns: store
+*/
+import { stores } from '../models/store';
+import { writable, get } from 'svelte/store';
+import { populateAnchorsStore, populateNodesStore, populateEdgesStore } from './util';
+import { populateCollapsibleStore } from '../../collapsible/controllers/util';
+/**
+ * findStore is going to return the target Svelvet store with the canvasId provided as argument.
+ * There can be multiple Svelvet canvases on the same page, and each has their own store with a unique canvasId.
+ * @param canvasId The canvasId of a Svelvet component
+ * @returns The store of a Svelvet component that matches the canvasId
+ */
+export function findStore(canvasId) {
+    return stores[canvasId];
+}
+/**
+ * createStoreEmpty will initialize a new Svelvet store with a unique canvasId.
+ * If you have multiple Svelvet components on the page, the stores object will look like the following example:
+ * const stores = \{
+ *                  canvasId-1: store of Svelvet component 1,
+ *                  canvasId-2: store of Svelvet component 2,
+ *                  canvasId-3: store of Svelvet component 3,
+ *                \}
+ * Notes: This should be called once every time you initialize a new Svelvet canvas, (ie, only in the Svelvet.svelte file).
+ * This function will initialize an empty store for the Svelvet component and should be followed by invoking populateSvelvetStoreFromUserInput to populate all the initial state from the user input.
+ *
+ * @param canvasId The canvasId of the newly created Svelvet component
+ * @returns An empty store for the newly created Svelvet component.
+ */
+export function createStoreEmpty(canvasId) {
+    stores[canvasId] = {
+        nodesStore: writable({}),
+        edgesStore: writable({}),
+        anchorsStore: writable({}),
+        potentialAnchorsStore: writable({}),
+        widthStore: writable(600),
+        heightStore: writable(600),
+        backgroundStore: writable(false),
+        movementStore: writable(true),
+        nodeSelected: writable(false),
+        nodeIdSelected: writable(-1),
+        d3Scale: writable(1),
+        options: writable({}),
+        temporaryEdgeStore: writable([]),
+        nodeCreate: writable(false),
+        boundary: writable(false),
+        edgeEditModal: writable(null),
+        collapsibleStore: writable([]),
+        collapsibleOption: writable(false),
+        lockedOption: writable(false),
+        editableOption: writable(false),
+        d3ZoomParameters: writable({}),
+        highlightEdgesOption: writable(true) // option to turn on/off highlightable edges
+    };
+    return stores[canvasId];
+}
+/**
+ * populateSvelvetStoreFromUserInput will populate all the states and set these states into the Svelvet store initialized by invoking createStoreEmpty
+ *
+ * @param canvasId The canvasId of the Svelvet component you are creating a store for
+ * @param nodes This is an array of objects containing node info that is defined by the user. NOTE THAT THE STRUCTURE DIFFERS FROM THE NODES CLASS. The whole point of populateSvelvetStoreFromUserInput is to convert nodes into proper Svelvet Node objects. An example of nodes is in $routes/testingplayground/index.svelte
+ * @param edges Same as nodes, this is an array of objects containing edge info THAT IS DIFFERENT FROM THE EDGE CLASS.
+ */
+export function populateSvelvetStoreFromUserInput(canvasId, nodes, edges) {
+    // find the store
+    const store = findStore(canvasId);
+    // populate store.nodesStore with user nodes
+    populateNodesStore(store, nodes, canvasId);
+    // populate store.anchorsStore with anchors. Note the userdoes not explictly define anchors; anchors are calculated from the edges
+    populateAnchorsStore(store, nodes, edges, canvasId);
+    // populate edges
+    populateEdgesStore(store, edges, canvasId);
+    // populatate collapsible objects if "collapsible" feature is turned on
+    if (get(store.collapsibleOption))
+        populateCollapsibleStore(store, nodes, edges, canvasId);
+}

package/package/components/graph/svelvet/store/controllers/userApi.d.ts

@@ -0,0 +1,3 @@
+export declare function getD3PositionX(canvasId: any): number;
+export declare function getD3PositionY(canvasId: any): number;
+export declare function getD3Zoom(canvasId: any): number;

package/package/components/graph/svelvet/store/controllers/userApi.js

@@ -0,0 +1,18 @@
+import { findStore } from './storeApi';
+import { get } from 'svelte/store';
+export function getD3PositionX(canvasId) {
+    const store = findStore(canvasId);
+    const width = get(store.widthStore);
+    const x = width / 2 - get(store.d3ZoomParameters).x; // user input is shifted so that x=0, y=0 occurs in the center
+    return x;
+}
+export function getD3PositionY(canvasId) {
+    const store = findStore(canvasId);
+    const height = get(store.heightStore);
+    const y = height / 2 - get(store.d3ZoomParameters).y; // user input is shifted so that x=0, y=0 occurs in the center
+    return y;
+}
+export function getD3Zoom(canvasId) {
+    const store = findStore(canvasId);
+    return get(store.d3ZoomParameters).k;
+}

package/package/components/graph/svelvet/store/controllers/util.d.ts

@@ -0,0 +1,24 @@
+import type { UserEdgeType, UserNodeType } from '../../types/types';
+import type { StoreType } from '../types/types';
+/**
+ * Populates edgesStore of Edges. This function does not return the edgesStore. Instead it sets the nodesStore of Svelvet store.
+ * @param store An object containing the state of the Svelvet component. You can access the following through `store`: nodesStore, edgesStore, anchorsStore, etc.
+ * @param edges An edge that the user specifies. This is NOT the same as a Edge object.
+ * @param canvasId The canvasId of the Svelvet component that holds the Edges
+ */
+export declare function populateEdgesStore(store: StoreType, edges: UserEdgeType[], canvasId: string): void;
+/**
+ * Populates the anchorsStore. This will overwrite any data in the AnchorsStore.
+ * @param store The Svelvet store containing the state of the Svelvet component
+ * @param nodes An array of user specified nodes
+ * @param edges An array of user specified edges
+ * @param canvasId The canvasId of the Svelvet component that holds the nodes and edges
+ */
+export declare function populateAnchorsStore(store: StoreType, nodes: UserNodeType[], edges: UserEdgeType[], canvasId: string): void;
+/**
+ * Populates the nodesStore. This will overwrite any data in the nodesStore.
+ * @param store The Svelvet store containing the state of the Svelvet component
+ * @param nodes An array of user specifed nodes
+ * @param canvasId The canvasId of the Svelvet component that holds the nodes
+ */
+export declare function populateNodesStore(store: StoreType, nodes: UserNodeType[], canvasId: string): void;

package/package/components/graph/svelvet/store/controllers/util.js

@@ -0,0 +1,148 @@
+const pkStringGenerator = () => (Math.random() + 1).toString(36).substring(7); // these are callbacks used to calculate anchor position relative to node
+import { dynamicCbCreator, fixedCbCreator } from '../../edges/controllers/anchorCbDev';
+import { getAnchors } from '../../edges/controllers/util';
+import { Anchor } from '../../edges/models/Anchor';
+import { Edge } from '../../edges/models/Edge';
+import { Node } from '../../nodes/models/Node';
+/**
+ * Creates an Anchor on the targeted Node with infomation the userNode holds
+ * @param store An object containing the state of the Svelvet component. You can access the following through `store`: nodesStore, edgesStore, anchorsStore, etc.
+ * @param userNode A node that the user specifies. This is NOT the same as a Node object.
+ * @param sourceOrTarget User specified information of source or target
+ * @param canvasId The id of the canvas that holds the Anchor and its attached Node
+ * @param edge An edge that the user specifies. It should target the userNode as source or target. This is NOT the same as an Edge object
+ * @returns An Anchor object
+ */
+function createAnchor(store, userNode, sourceOrTarget, canvasId, edge) {
+    // edge case
+    if (userNode === null)
+        throw `you cannot create an anchor without a user node (for now)`;
+    const edgeId = edge.id;
+    const anchorId = pkStringGenerator();
+    // userCb is the appropriate source or taret callback from userEdge object. It is
+    // possible the user to NOT set userCb in which case userCb will be undefined
+    let userCb;
+    if (sourceOrTarget === 'target')
+        userCb = edge.targetAnchorCb;
+    else
+        userCb = edge.sourceAnchorCb;
+    // create anchor callbacks
+    let cb;
+    if (userCb === undefined)
+        cb = dynamicCbCreator(store, edgeId, anchorId);
+    else
+        cb = fixedCbCreator(store, edgeId, anchorId, userNode.id, userCb);
+    // Create a new anchor.
+    const anchor = new Anchor(anchorId, userNode.id, edgeId, sourceOrTarget, -1, // dummy variables for x,y,angle for now
+    -1, // dummy variables for x,y,angle for now
+    cb, canvasId, 0 // dummy variables for x,y,angle for now
+    );
+    // return
+    return anchor;
+}
+/**
+ * Populates edgesStore of Edges. This function does not return the edgesStore. Instead it sets the nodesStore of Svelvet store.
+ * @param store An object containing the state of the Svelvet component. You can access the following through `store`: nodesStore, edgesStore, anchorsStore, etc.
+ * @param edges An edge that the user specifies. This is NOT the same as a Edge object.
+ * @param canvasId The canvasId of the Svelvet component that holds the Edges
+ */
+export function populateEdgesStore(store, edges, canvasId) {
+    const edgesStore = {};
+    for (let i = 0; i < edges.length; i++) {
+        const userEdge = edges[i];
+        //  { id: 'e1-2', source: 1, type: 'straight', target: 2, label: 'e1-2' },
+        // source is node.id for the source node
+        // target is node.id for the target node
+        // We need to get the anchors
+        const { id: edgeId } = userEdge;
+        const anchors = getAnchors(store, { edgeId: edgeId });
+        // check that we have two anchors for every edge
+        if (anchors.length !== 2)
+            throw 'We should have two anchors for every node';
+        // check that we have 1 source anchor and 1 target anchor. Since sourceOrTarget is typed to be either 'source'
+        //   or 'target', it suffices to check whether there are two unique elements
+        if (new Set(anchors.map((e) => e.sourceOrTarget)).size !== 2)
+            throw 'we should have one source and one target anchor';
+        // get source and target anchor
+        let sourceAnchor, targetAnchor;
+        if (anchors[0].sourceOrTarget === 'source') {
+            sourceAnchor = anchors[0];
+            targetAnchor = anchors[1];
+        }
+        else {
+            sourceAnchor = anchors[1];
+            targetAnchor = anchors[0];
+        }
+        edgesStore[edgeId] = new Edge(edgeId, sourceAnchor.positionX, sourceAnchor.positionY, targetAnchor.positionX, targetAnchor.positionY, canvasId, userEdge.label === undefined ? '' : userEdge.label, userEdge.type === undefined ? 'bezier' : userEdge.type, userEdge.labelBgColor === undefined ? 'white' : userEdge.labelBgColor, userEdge.labelTextColor === undefined ? 'black' : userEdge.labelTextColor, userEdge.edgeColor === undefined ? 'black' : userEdge.edgeColor, userEdge.animate === undefined ? false : userEdge.animate, userEdge.noHandle === undefined ? false : userEdge.noHandle, userEdge.arrow === undefined ? false : userEdge.arrow, userEdge.clickCallback === undefined ? () => { } : userEdge.clickCallback, userEdge.className === undefined ? '' : userEdge.className);
+    }
+    store.edgesStore.set(edgesStore);
+}
+/**
+ * Finds userNode (with UserNodeType; Not the same as the Node) by the node id from nodesStore
+ * @param id The id of the Node in its nodesStore
+ * @param userNodes The array of userNodes (NOT the same as Node object)
+ * @returns The node that user specified or null if not found
+ */
+function findUserNodeById(id, userNodes) {
+    for (let i = 0; i < userNodes.length; i++) {
+        const userNode = userNodes[i];
+        if (userNode.id === id)
+            return userNode;
+    }
+    return null;
+}
+/**
+ * Populates the anchorsStore. This will overwrite any data in the AnchorsStore.
+ * @param store The Svelvet store containing the state of the Svelvet component
+ * @param nodes An array of user specified nodes
+ * @param edges An array of user specified edges
+ * @param canvasId The canvasId of the Svelvet component that holds the nodes and edges
+ */
+export function populateAnchorsStore(store, nodes, edges, canvasId) {
+    // anchorsStore will populated and eventaully synchronized to store.anchorsStore
+    const anchorsStore = {};
+    // iterate through user edges. Note the user never explicitly defines anchors; we calculate anchors
+    // from the user edge/node information
+    for (let i = 0; i < edges.length; i++) {
+        const userEdge = edges[i];
+        // find the source and target userNodes. These will be used to create the nodeId foreign key and
+        // determine placement of the anchor based on userNode.targetPosition, useNode.sourcePosition
+        const { source: sourceNodeId, target: targetNodeId } = userEdge;
+        const sourceUserNode = findUserNodeById(sourceNodeId, nodes);
+        const targetUserNode = findUserNodeById(targetNodeId, nodes);
+        // create source anchor
+        const sourceAnchor = createAnchor(store, sourceUserNode, 'source', canvasId, userEdge);
+        // create target anchor
+        const targetAnchor = createAnchor(store, targetUserNode, 'target', canvasId, userEdge);
+        // store source and target anchors
+        anchorsStore[sourceAnchor.id] = sourceAnchor;
+        anchorsStore[targetAnchor.id] = targetAnchor;
+    }
+    //populates the anchorsStore
+    store.anchorsStore.set(anchorsStore);
+    // set anchor positions. We can only set anchor positions after anchorsStore and nodesStore
+    // has been populated. TODO: maybe add a check to see that anchorsStore and NodesStore populated?
+    const anchors = getAnchors(store);
+    for (const anchor of anchors)
+        anchor.callback();
+}
+/**
+ * Populates the nodesStore. This will overwrite any data in the nodesStore.
+ * @param store The Svelvet store containing the state of the Svelvet component
+ * @param nodes An array of user specifed nodes
+ * @param canvasId The canvasId of the Svelvet component that holds the nodes
+ */
+export function populateNodesStore(store, nodes, canvasId) {
+    // this is the nodesStore object. THIS IS NOT THE SAME AS A NODESTORE
+    const nodesStore = {};
+    // iterate through user nodes and create node objects
+    for (let i = 0; i < nodes.length; i++) {
+        const userNode = nodes[i];
+        const nodeId = userNode.id;
+        // TODO: move sanitizing default values to middleware
+        const node = new Node(nodeId.toString(), userNode.position.x, userNode.position.y, userNode.width, userNode.height, userNode.bgColor ?? 'white', userNode.data, canvasId, userNode.borderColor === undefined ? 'black' : userNode.borderColor, userNode.image === undefined ? false : userNode.image, userNode.src === undefined ? '' : userNode.src, userNode.textColor === undefined ? '' : userNode.textColor, userNode.borderRadius === undefined ? 0 : userNode.borderRadius, userNode.childNodes === undefined ? [] : userNode.childNodes, userNode.className === undefined ? '' : userNode.className, userNode.clickCallback === undefined ? () => { } : userNode.clickCallback);
+        nodesStore[nodeId] = node;
+    }
+    // This is actually what sets the store
+    store.nodesStore.set(nodesStore);
+}

package/package/components/graph/svelvet/store/models/store.d.ts

@@ -0,0 +1,12 @@
+import type { StoreType } from '../types/types';
+/**
+  `store` is a dictionary of Svelvet stores.
+    * The reason why we have multiple Svelvet stores is to handle multiple canvases on the same page.
+    * A Svelvet store is the single source of truth for a canvas state.
+    * We discourage developers from interacting with stores directly; instead use the api methods in
+      `src/lib/controllers/storeApi.ts`. However, if need to direct access you can do so by importing:
+      `import { store } from 'src/lib/models/store';`
+*/
+export declare const stores: {
+    [key: string]: StoreType;
+};

package/package/components/graph/svelvet/store/models/store.js

@@ -0,0 +1,9 @@
+/**
+  `store` is a dictionary of Svelvet stores.
+    * The reason why we have multiple Svelvet stores is to handle multiple canvases on the same page.
+    * A Svelvet store is the single source of truth for a canvas state.
+    * We discourage developers from interacting with stores directly; instead use the api methods in
+      `src/lib/controllers/storeApi.ts`. However, if need to direct access you can do so by importing:
+      `import { store } from 'src/lib/models/store';`
+*/
+export const stores = {};

package/package/components/graph/svelvet/store/types/types.d.ts

@@ -0,0 +1,129 @@
+import type { CollapsibleType } from '../../collapsible/types/types';
+import type { Writable } from 'svelte/store';
+import type { AnchorType } from '../../edges/types/types';
+export interface ResizeNodeType {
+    id: string;
+    nodeId: string;
+    edgeId?: string;
+    canvasId: string;
+    anchorId?: string;
+    positionX: number;
+    positionY: number;
+    setPositionAndCascade: Function;
+    setPosition: Function;
+    delete: Function;
+}
+export interface StoreType {
+    nodesStore: Writable<{
+        [key: string]: NodeType;
+    }>;
+    edgesStore: Writable<{
+        [key: string]: EdgeType;
+    }>;
+    anchorsStore: Writable<{
+        [key: string]: AnchorType;
+    }>;
+    potentialAnchorsStore: Writable<{
+        [key: string]: PotentialAnchorType;
+    }>;
+    widthStore: Writable<number>;
+    heightStore: Writable<number>;
+    backgroundStore: Writable<boolean>;
+    movementStore: Writable<boolean>;
+    nodeIdSelected: Writable<number>;
+    nodeSelected: Writable<boolean>;
+    d3Scale: Writable<number>;
+    options: Writable<{
+        [key: string]: any;
+    }>;
+    temporaryEdgeStore: Writable<TemporaryEdgeType[]>;
+    nodeCreate: Writable<boolean>;
+    boundary: Writable<boolean | PositionType>;
+    edgeEditModal: Writable<null | string>;
+    collapsibleStore: Writable<CollapsibleType[]>;
+    collapsibleOption: Writable<boolean>;
+    lockedOption: Writable<boolean>;
+    editableOption: Writable<boolean>;
+    d3ZoomParameters: Writable<{
+        [key: string]: number;
+    }>;
+    highlightEdgesOption: Writable<boolean>;
+}
+export interface PositionType {
+    x: number;
+    y: number;
+}
+export interface NodeType {
+    id: string;
+    width: number;
+    height: number;
+    positionX: number;
+    positionY: number;
+    bgColor: string;
+    data: {
+        html?: any;
+        custom?: {
+            component: any;
+            props?: any;
+            cb?: (e: string, detail: any) => void;
+        };
+        img?: any;
+        label?: string;
+    };
+    canvasId: string;
+    setPositionFromMovement: Function;
+    setSizeFromMovement: Function;
+    setExportableData: Function;
+    borderColor: string;
+    image: boolean;
+    src: string;
+    textColor: string;
+    borderRadius: number;
+    childNodes: string[];
+    className: string;
+    clickCallback: Function;
+}
+export interface EdgeType {
+    id: string;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    canvasId: string;
+    label: string;
+    type: 'straight' | 'smoothstep' | 'step' | 'bezier';
+    labelBgColor: string;
+    labelTextColor: string;
+    edgeColor: string;
+    animate: boolean;
+    noHandle: boolean;
+    arrow: boolean;
+    clickCallback: Function;
+    className: string;
+    delete: Function;
+    setExportableData: Function;
+}
+export interface PotentialAnchorType {
+    id: string;
+    nodeId: string;
+    callback: Function;
+    positionX: number;
+    positionY: number;
+    angle: number;
+    canvasId: string;
+    delete: Function;
+}
+export interface TemporaryEdgeType {
+    id: string;
+    sourcePotentialAnchorId: string;
+    sourceX: number;
+    sourceY: number;
+    targetPotentialAnchorId: string | null;
+    targetX: number;
+    targetY: number;
+    canvasId: string;
+    type: string;
+    edgeColor: string;
+    createEdge: Function;
+    createNode: Function;
+}

package/package/components/graph/svelvet/store/types/types.js

@@ -0,0 +1 @@
+export {};

package/package/components/graph/svelvet/types/README.md

@@ -0,0 +1,3 @@
+# Types
+
+This folder contains types exported to the user, as decribed in feature: `https://www.svelvet.io/docs/typescript/`

package/package/components/graph/svelvet/types/index.d.ts

@@ -0,0 +1,2 @@
+import type { UserEdgeType, UserNodeType } from './types';
+export { UserEdgeType, UserNodeType };

package/package/components/graph/svelvet/types/index.js

@@ -0,0 +1 @@
+export {};

package/package/components/graph/svelvet/types/types.d.ts

@@ -0,0 +1,49 @@
+export interface UserNodeType {
+    id: string;
+    width: number;
+    height: number;
+    bgColor?: string;
+    data: {
+        html?: any;
+        custom?: {
+            component: any;
+            props?: any;
+            cb?: (e: string, detail: any) => void;
+        };
+        img?: any;
+    };
+    position: {
+        x: number;
+        y: number;
+    };
+    borderColor?: string | undefined;
+    image?: boolean;
+    src?: string;
+    textColor?: string;
+    targetPosition?: 'left' | 'right' | 'top' | 'bottom';
+    sourcePosition?: 'left' | 'right' | 'top' | 'bottom';
+    borderRadius?: number;
+    childNodes?: string[];
+    className?: string;
+    clickCallback?: Function;
+}
+export interface UserEdgeType {
+    id: string;
+    source: string;
+    target: string;
+    sourceAnchorCb?: Function;
+    targetAnchorCb?: Function;
+    label?: string;
+    labelBgColor?: string;
+    labelTextColor?: string;
+    edgeColor?: string;
+    type?: 'straight' | 'smoothstep' | 'step' | 'bezier' | undefined;
+    animate?: boolean;
+    noHandle?: boolean;
+    arrow?: boolean;
+    clickCallback?: Function;
+    className?: string;
+}
+export declare function getD3PositionX(canvasId: string): number;
+export declare function getD3PositionY(canvasId: string): number;
+export declare function getD3Zoom(canvasId: string): number;