@krainovsd/graph 0.12.0-beta.3 → 0.12.0-beta.5

package/lib/cjs/index.cjs

@@ -113,7 +113,6 @@ const HIGHLIGHT_SETTINGS = {
 };
 
 const LINK_SETTINGS = {
-    cacheOptions: true,
     prettyDraw: true,
     linkScaleSwitch: 1,
     linkColorAfterScaleSwitch: "#000000FF",
@@ -142,13 +141,18 @@ const LINK_OPTIONS = {
 };
 
 const NODE_SETTINGS = {
-    cacheOptions: true,
     nodeRadiusFlexible: true,
-    nodeRadiusCoefficient: 5,
-    nodeRadiusFactor: 1,
+    nodeRadiusLinkCountForStep: 5,
+    nodeRadiusIncrementByStep: 1,
+    nodeRadiusMaxLinearSteps: 5,
+    nodeRadiusLinkCountDividerForLog: 25,
+    nodeRadiusLogFactor: 2.5,
     nodeSizeFlexible: true,
-    nodeSizeCoefficient: 5,
-    nodeSizeFactor: 0.1,
+    nodeSizeLinkCountForStep: 5,
+    nodeSizeIncrementByStep: 0.1,
+    nodeSizeMaxLinearSteps: 5,
+    nodeSizeLinkCountDividerForLog: 25,
+    nodeSizeLogFactor: 2.5,
     textScaleMin: 1.5,
     textScaleMax: 18,
     textSizeMin: 3.5,
@@ -378,13 +382,29 @@ function nodeTextSizeGetter(transform, nodeSettings) {
     }
     return { textSize, textShiftY };
 }
-function nodeRadiusGetter({ radiusFlexible, radiusInitial, linkCount, radiusCoefficient, radiusFactor, }) {
-    return ((radiusFlexible && linkCount ? linkCount / radiusCoefficient : 0) * radiusFactor + radiusInitial);
+function nodeRadiusGetter({ radiusFlexible, linkCount, radiusInitial, radiusIncrementByStep, radiusLinkCountDividerForLog, radiusLinkCountForStep, radiusLogFactor, radiusMaxLinearSteps, }) {
+    if (!radiusFlexible || !linkCount)
+        return radiusInitial;
+    const steps = linkCount / radiusLinkCountForStep;
+    if (steps < radiusMaxLinearSteps) {
+        return steps * radiusIncrementByStep + radiusInitial;
+    }
+    return (radiusInitial +
+        radiusMaxLinearSteps * radiusIncrementByStep +
+        radiusLogFactor * Math.log10(linkCount / radiusLinkCountDividerForLog));
 }
-function nodeSizeGetter({ heightInitial, linkCount, sizeCoefficient, sizeFactor, sizeFlexible, widthInitial, }) {
+function nodeSizeGetter({ heightInitial, linkCount, sizeFlexible, widthInitial, sizeIncrementByStep, sizeLinkCountDividerForLog, sizeLinkCountForStep, sizeLogFactor, sizeMaxLinearSteps, }) {
     let additionalSizeCoefficient = 1;
     if (sizeFlexible && linkCount != undefined) {
-        additionalSizeCoefficient += (linkCount / sizeCoefficient) * sizeFactor;
+        const steps = linkCount / sizeLinkCountForStep;
+        if (steps < sizeMaxLinearSteps) {
+            additionalSizeCoefficient += steps * sizeIncrementByStep;
+        }
+        else {
+            additionalSizeCoefficient +=
+                sizeMaxLinearSteps * sizeIncrementByStep +
+                    sizeLogFactor * Math.log10(linkCount / sizeLinkCountDividerForLog);
+        }
     }
     return {
         width: widthInitial * additionalSizeCoefficient,
@@ -416,7 +436,7 @@ function pointerGetter(mouseEvent, areaRect, areaTransform) {
 }
 
 function isOverlapsNode(node, pointerX, pointerY, radius) {
-    if (node.x == undefined || node.y == undefined)
+    if (node.x == undefined || node.y == undefined || node.visible === false)
         return false;
     switch (node._shape) {
         case "circle": {
@@ -912,7 +932,10 @@ function linkByPointerGetter({ areaRect, areaTransform, mouseEvent, links, linkH
     });
 }
 function isNearLink(mouseX, mouseY, link, threshold = 2) {
-    if (!jsHelpers.isObject(link.source) || !jsHelpers.isObject(link.target))
+    if (!jsHelpers.isObject(link.source) ||
+        !jsHelpers.isObject(link.target) ||
+        link.source.visible === false ||
+        link.target.visible === false)
         return false;
     const x1 = link.source.x;
     const y1 = link.source.y;
@@ -1205,7 +1228,7 @@ function initDnd() {
 }
 
 function getDrawLink() {
-    return function drawLink(link, index) {
+    return function drawLink(link) {
         if (!this.context ||
             typeof link.source !== "object" ||
             typeof link.target !== "object" ||
@@ -1221,16 +1244,9 @@ function getDrawLink() {
         if (!link.source._visible && !link.target._visible)
             return;
         const id = `${link.target.id}${link.source.id}`;
-        let linkOptions;
-        if (this.linkSettings.cacheOptions && this.linkOptionsCache[id]) {
-            linkOptions = this.linkOptionsCache[id];
-        }
-        else {
-            linkOptions = linkIterationExtractor(link, index, this.links, this, this.linkSettings.options ?? {}, linkOptionsGetter);
-            if (this.linkSettings.cacheOptions) {
-                this.linkOptionsCache[id] = linkOptions;
-            }
-        }
+        const linkOptions = this.linkOptionsCache[id];
+        if (!linkOptions)
+            return;
         if (linkOptions.drawLink) {
             linkOptions.drawLink.call(this, link, linkOptions);
             return;
@@ -1327,7 +1343,9 @@ function getDrawLink() {
         let xEnd = link.target.x;
         let yEnd = link.target.y;
         let linkDistance = 0;
-        if (this.linkSettings.prettyDraw || this.linkSettings.particleFlexSpeed) {
+        if (this.linkSettings.prettyDraw ||
+            this.linkSettings.particleFlexSpeed ||
+            (this.linkSettings.arrow && arrowAlpha > 0)) {
             const isHasArrow = this.linkSettings.arrow && arrowAlpha > 0;
             const position = calculateLinkPositionByNode(link, isHasArrow ? arrowSize : 0);
             if (position) {
@@ -1408,12 +1426,6 @@ function getDrawLink() {
         }
         /** Arrow */
         if (this.linkSettings.arrow && arrowAlpha > 0) {
-            const { x1: xStart, x2: xEnd, y1: yStart, y2: yEnd, } = calculateLinkPositionByNode(link) ?? {
-                x1: 0,
-                x2: 0,
-                y1: 0,
-                y2: 0,
-            };
             this.context.beginPath();
             this.context.globalAlpha = arrowAlpha;
             this.context.strokeStyle = arrowBorderColor;
@@ -1436,33 +1448,10 @@ function getDrawLink() {
 }
 
 const SPACE = " ";
-function drawText({ context, id, textAlign, textColor, textFont, textStyle, textGap, textWeight, textSize, text, x, y, cachedNodeText, maxWidth, }) {
+function drawText({ context, textAlign, textColor, textFont, textStyle, textGap, textWeight, textSize, x, y, lines, }) {
     context.font = `${textStyle} normal ${textWeight} ${textSize}px ${textFont}`;
     context.fillStyle = textColor;
     context.textAlign = textAlign;
-    if (cachedNodeText[id] != undefined) {
-        cachedNodeText[id].forEach((line, index) => {
-            context.fillText(line, x, y + index * textSize + index * textGap);
-        });
-        return;
-    }
-    if (maxWidth == undefined || context.measureText(text).width <= maxWidth) {
-        cachedNodeText[id] = [text];
-        context.fillText(text, x, y);
-        return;
-    }
-    const { lines } = getTextLines({
-        context,
-        maxWidth,
-        text,
-        textAlign,
-        textColor,
-        textFont,
-        textSize,
-        textStyle,
-        textWeight,
-    });
-    cachedNodeText[id] = lines;
     lines.forEach((line, index) => {
         context.fillText(line, x, y + index * textSize + index * textGap);
     });
@@ -1504,21 +1493,18 @@ function getTextLines({ context, textAlign, textColor, textFont, textStyle, text
 }
 
 function getDrawNode(nodeRenders, textRenders) {
-    return function drawNode(node, index) {
+    return function drawNode(node) {
         if (!this.context || !node.x || !node.y)
             return;
-        if (node.visible != undefined && !node.visible)
+        if (node.visible != undefined && !node.visible) {
+            node._radius = 0;
+            node._width = 0;
+            node._height = 0;
             return;
-        let nodeOptions;
-        if (this.nodeSettings.cacheOptions && this.nodeOptionsCache[node.id]) {
-            nodeOptions = this.nodeOptionsCache[node.id];
-        }
-        else {
-            nodeOptions = nodeIterationExtractor(node, index, this.nodes, this, this.nodeSettings.options ?? {}, nodeOptionsGetter);
-            if (this.nodeSettings.cacheOptions) {
-                this.nodeOptionsCache[node.id] = nodeOptions;
-            }
         }
+        const nodeOptions = this.nodeOptionsCache[node.id];
+        if (!nodeOptions)
+            return;
         if (nodeOptions.nodeDraw && nodeOptions.textDraw) {
             nodeRenders.push(() => {
                 if (nodeOptions.nodeDraw) {
@@ -1532,13 +1518,13 @@ function getDrawNode(nodeRenders, textRenders) {
             });
             return;
         }
+        let radius = nodeOptions.radius;
+        let width = nodeOptions.width;
+        let height = nodeOptions.height;
         let alpha = nodeOptions.alpha;
         let color = nodeOptions.color;
         let borderColor = nodeOptions.borderColor;
         let borderWidth = nodeOptions.borderWidth;
-        let radiusInitial = nodeOptions.radius;
-        let widthInitial = nodeOptions.width;
-        let heightInitial = nodeOptions.height;
         let textAlpha = nodeOptions.textAlpha;
         let textSize = nodeOptions.textSize;
         let textShiftX = nodeOptions.textShiftX;
@@ -1585,9 +1571,9 @@ function getDrawNode(nodeRenders, textRenders) {
                 color = highlightOptions.color;
                 borderColor = highlightOptions.borderColor;
                 borderWidth = highlightOptions.borderWidth;
-                radiusInitial = highlightOptions.radiusInitial;
-                widthInitial = highlightOptions.widthInitial;
-                heightInitial = highlightOptions.heightInitial;
+                radius = highlightOptions.radiusInitial;
+                width = highlightOptions.widthInitial;
+                height = highlightOptions.heightInitial;
                 textSize = highlightOptions.textSize;
                 textShiftX = highlightOptions.textShiftX;
                 textShiftY = highlightOptions.textShiftY;
@@ -1634,9 +1620,9 @@ function getDrawNode(nodeRenders, textRenders) {
                 color = highlightOptions.color;
                 borderColor = highlightOptions.borderColor;
                 borderWidth = highlightOptions.borderWidth;
-                radiusInitial = highlightOptions.radiusInitial;
-                widthInitial = highlightOptions.widthInitial;
-                heightInitial = highlightOptions.heightInitial;
+                radius = highlightOptions.radiusInitial;
+                width = highlightOptions.widthInitial;
+                height = highlightOptions.heightInitial;
                 textSize = highlightOptions.textSize;
                 textShiftX = highlightOptions.textShiftX;
                 textShiftY = highlightOptions.textShiftY;
@@ -1645,78 +1631,6 @@ function getDrawNode(nodeRenders, textRenders) {
                 labelWeight = highlightOptions.labelWeight;
             }
         }
-        /** Flex radius */
-        const radius = nodeOptions.shape === "circle"
-            ? nodeRadiusGetter({
-                radiusFlexible: this.nodeSettings.nodeRadiusFlexible,
-                radiusInitial,
-                radiusCoefficient: this.nodeSettings.nodeRadiusCoefficient,
-                radiusFactor: this.nodeSettings.nodeRadiusFactor,
-                linkCount: node.linkCount,
-            })
-            : radiusInitial;
-        /** Flex size */
-        let height = heightInitial;
-        let width = widthInitial;
-        if (nodeOptions.shape === "square") {
-            const size = nodeSizeGetter({
-                heightInitial,
-                widthInitial,
-                linkCount: node.linkCount,
-                sizeCoefficient: this.nodeSettings.nodeSizeCoefficient,
-                sizeFactor: this.nodeSettings.nodeSizeFactor,
-                sizeFlexible: this.nodeSettings.nodeSizeFlexible,
-            });
-            width = size.width;
-            height = size.height;
-        }
-        if (nodeOptions.shape === "text") {
-            width = nodeOptions.width;
-            const size = nodeSizeGetter({
-                heightInitial,
-                widthInitial: width,
-                linkCount: node.linkCount,
-                sizeCoefficient: this.nodeSettings.nodeSizeCoefficient,
-                sizeFactor: this.nodeSettings.nodeSizeFactor,
-                sizeFlexible: this.nodeSettings.nodeSizeFlexible,
-            });
-            labelSize *= size.additionalSizeCoefficient;
-        }
-        /** Size by text in textNode */
-        if (nodeOptions.shape === "text" && nodeOptions.label) {
-            let lines;
-            let textNodeParameters;
-            const cachedLines = this.cachedNodeLabel[node.id];
-            const cachedTextNodeParameters = this.cachedTextNodeParameters[node.id];
-            if (cachedLines != undefined && cachedTextNodeParameters != undefined) {
-                lines = cachedLines;
-                textNodeParameters = cachedTextNodeParameters;
-            }
-            else {
-                const textInfo = getTextLines({
-                    context: this.context,
-                    text: nodeOptions.label,
-                    textAlign: nodeOptions.labelAlign,
-                    textColor: nodeOptions.labelColor,
-                    textFont: nodeOptions.labelFont,
-                    textSize: labelSize,
-                    maxWidth: nodeOptions.labelWidth,
-                    textStyle: nodeOptions.labelStyle,
-                    textWeight,
-                });
-                textNodeParameters = [textInfo.currentMaxSize, labelSize];
-                lines = textInfo.lines;
-                this.cachedNodeLabel[node.id] = lines;
-                this.cachedTextNodeParameters[node.id] = textNodeParameters;
-            }
-            const textSizeCoefficient = labelSize / textNodeParameters[1];
-            const maxSize = textNodeParameters[0] * textSizeCoefficient;
-            height =
-                lines.length * labelSize +
-                    (lines.length - 1) * nodeOptions.labelGap +
-                    nodeOptions.labelYPadding;
-            width = maxSize + nodeOptions.labelXPadding;
-        }
         /** Node parameters */
         node._radius = radius;
         node._borderWidth = borderWidth;
@@ -1747,6 +1661,7 @@ function getDrawNode(nodeRenders, textRenders) {
             this.context.lineWidth = borderWidth;
             this.context.strokeStyle = borderColor;
             this.context.fillStyle = color;
+            const labelLines = this.cachedNodeLabel[node.id];
             switch (nodeOptions.shape) {
                 case "circle": {
                     if (!node.image) {
@@ -1767,13 +1682,11 @@ function getDrawNode(nodeRenders, textRenders) {
                             this.context.stroke();
                         }
                     }
-                    if (node.label) {
+                    if (node.label && labelLines) {
                         this.context.globalAlpha = labelAlpha;
                         drawText({
                             context: this.context,
-                            cachedNodeText: this.cachedNodeLabel,
-                            id: node.id,
-                            text: node.label,
+                            lines: labelLines,
                             textAlign: nodeOptions.labelAlign,
                             textColor: nodeOptions.labelColor,
                             textFont: nodeOptions.labelFont,
@@ -1781,7 +1694,6 @@ function getDrawNode(nodeRenders, textRenders) {
                             textSize: labelSize,
                             textStyle: nodeOptions.labelStyle,
                             textWeight: labelWeight,
-                            maxWidth: nodeOptions.labelWidth,
                             x: node.x,
                             y: node.y + labelSize / 3,
                         });
@@ -1807,13 +1719,11 @@ function getDrawNode(nodeRenders, textRenders) {
                             this.context.stroke();
                         }
                     }
-                    if (node.label) {
+                    if (node.label && labelLines) {
                         this.context.globalAlpha = labelAlpha;
                         drawText({
                             context: this.context,
-                            cachedNodeText: this.cachedNodeLabel,
-                            id: node.id,
-                            text: node.label,
+                            lines: labelLines,
                             textAlign: nodeOptions.labelAlign,
                             textColor: nodeOptions.labelColor,
                             textFont: nodeOptions.labelFont,
@@ -1821,7 +1731,6 @@ function getDrawNode(nodeRenders, textRenders) {
                             textSize: labelSize,
                             textStyle: nodeOptions.labelStyle,
                             textWeight: labelWeight,
-                            maxWidth: nodeOptions.labelWidth,
                             x: node.x,
                             y: node.y + labelSize / 3,
                         });
@@ -1832,20 +1741,16 @@ function getDrawNode(nodeRenders, textRenders) {
                     if (this.nodeSettings.textNodeDebug) {
                         this.context.strokeRect(node.x - width / 2, node.y - height / 2, width, height);
                     }
-                    const lines = this.cachedNodeLabel[node.id];
-                    if (nodeOptions.label && lines)
+                    if (nodeOptions.label && labelLines)
                         drawText({
-                            id: node.id,
-                            cachedNodeText: this.cachedNodeLabel,
+                            lines: labelLines,
                             context: this.context,
-                            text: nodeOptions.label,
                             textAlign: nodeOptions.labelAlign,
                             textColor: nodeOptions.labelColor,
                             textFont: nodeOptions.labelFont,
                             textSize: labelSize,
                             x: node.x,
-                            y: node.y + textSize / 4 - (lines.length - 1) * (textSize / 2),
-                            maxWidth: nodeOptions.labelWidth,
+                            y: node.y + textSize / 4 - (labelLines.length - 1) * (textSize / 2),
                             textStyle: nodeOptions.labelStyle,
                             textWeight,
                             textGap: nodeOptions.labelGap,
@@ -1882,7 +1787,8 @@ function getDrawNode(nodeRenders, textRenders) {
             });
         }
         /** Text draw */
-        if (nodeOptions.textVisible && nodeOptions.text) {
+        const textLines = this.cachedNodeText[node.id];
+        if (nodeOptions.textVisible && nodeOptions.text && textLines) {
             textRenders.push(() => {
                 if (nodeOptions.textDraw) {
                     nodeOptions.textDraw.bind(this)(node, {
@@ -1910,17 +1816,14 @@ function getDrawNode(nodeRenders, textRenders) {
                     y += height / 2;
                 }
                 drawText({
-                    id: node.id,
-                    cachedNodeText: this.cachedNodeText,
+                    lines: textLines,
                     context: this.context,
-                    text: nodeOptions.text,
                     textAlign: nodeOptions.textAlign,
                     textColor: nodeOptions.textColor,
                     textFont: nodeOptions.textFont,
                     textSize,
                     x: node.x + textShiftX,
                     y,
-                    maxWidth: nodeOptions.textWidth,
                     textStyle: nodeOptions.textStyle,
                     textWeight,
                     textGap: nodeOptions.textGap,
@@ -2340,75 +2243,29 @@ function initCollideForce(forceUpdate) {
         else if (!this.simulation.force("collide") || forceUpdate) {
             this.simulation.force("collide", d3Force.forceCollide()
                 .radius((node, index) => {
-                const nodeOptions = nodeIterationExtractor(node, index, this.nodes, this, this.nodeSettings.options ?? {}, nodeOptionsGetter);
+                const nodeOptions = this.nodeOptionsCache[node.id];
+                if (!nodeOptions)
+                    return 0;
                 switch (nodeOptions.shape) {
                     case "circle": {
                         if (this.forceSettings.collideRadius) {
                             return nodeIterationExtractor(node, index, this.nodes, this, this.forceSettings.collideRadius, undefined);
                         }
-                        const radius = nodeRadiusGetter({
-                            radiusFlexible: this.nodeSettings.nodeRadiusFlexible,
-                            radiusInitial: nodeOptions.radius,
-                            radiusCoefficient: this.nodeSettings.nodeRadiusCoefficient,
-                            radiusFactor: this.nodeSettings.nodeRadiusFactor,
-                            linkCount: node.linkCount,
-                        });
-                        return radius + this.forceSettings.collideAdditionalRadius;
+                        return nodeOptions.radius + this.forceSettings.collideAdditionalRadius;
                     }
                     case "square": {
-                        const { height, width } = nodeSizeGetter({
-                            heightInitial: nodeOptions.width,
-                            widthInitial: nodeOptions.height,
-                            linkCount: node.linkCount,
-                            sizeCoefficient: this.nodeSettings.nodeSizeCoefficient,
-                            sizeFactor: this.nodeSettings.nodeSizeFactor,
-                            sizeFlexible: this.nodeSettings.nodeSizeFlexible,
-                        });
-                        return (Math.sqrt(width ** 2 + height ** 2) / 2 +
+                        return (Math.sqrt(nodeOptions.width ** 2 + nodeOptions.height ** 2) / 2 +
                             this.forceSettings.collideAdditionalRadius);
                     }
                     case "text": {
-                        let { height, width } = nodeSizeGetter({
-                            heightInitial: nodeOptions.width,
-                            widthInitial: nodeOptions.height,
-                            linkCount: node.linkCount,
-                            sizeCoefficient: this.nodeSettings.nodeSizeCoefficient,
-                            sizeFactor: this.nodeSettings.nodeSizeFactor,
-                            sizeFlexible: this.nodeSettings.nodeSizeFlexible,
-                        });
-                        if (this.context && nodeOptions.text) {
-                            const textInfo = getTextLines({
-                                context: this.context,
-                                text: nodeOptions.text,
-                                textAlign: nodeOptions.textAlign,
-                                textColor: nodeOptions.textColor,
-                                textFont: nodeOptions.textFont,
-                                textSize: nodeOptions.textSize,
-                                maxWidth: width,
-                                textStyle: nodeOptions.textStyle,
-                                textWeight: nodeOptions.textWeight,
-                            });
-                            height =
-                                textInfo.lines.length * nodeOptions.textSize +
-                                    (textInfo.lines.length - 1) * nodeOptions.textGap +
-                                    nodeOptions.labelYPadding;
-                            width = textInfo.currentMaxSize + nodeOptions.labelXPadding;
-                        }
-                        return (Math.sqrt(width ** 2 + height ** 2) / 2 +
+                        return (Math.sqrt(nodeOptions.width ** 2 + nodeOptions.height ** 2) / 2 +
                             this.forceSettings.collideAdditionalRadius);
                     }
                     default: {
                         if (this.forceSettings.collideRadius) {
                             return nodeIterationExtractor(node, index, this.nodes, this, this.forceSettings.collideRadius, undefined);
                         }
-                        const radius = nodeRadiusGetter({
-                            radiusFlexible: this.nodeSettings.nodeRadiusFlexible,
-                            radiusInitial: nodeOptions.radius,
-                            radiusCoefficient: this.nodeSettings.nodeRadiusCoefficient,
-                            radiusFactor: this.nodeSettings.nodeRadiusFactor,
-                            linkCount: node.linkCount,
-                        });
-                        return radius + this.forceSettings.collideAdditionalRadius;
+                        return nodeOptions.radius + this.forceSettings.collideAdditionalRadius;
                     }
                 }
             })
@@ -2418,6 +2275,145 @@ function initCollideForce(forceUpdate) {
     }
 }
 
+function updateLinkCache() {
+    this.linkOptionsCache = {};
+    for (let i = 0; i < this.links.length; i++) {
+        const link = this.links[i];
+        const { sourceId, targetId } = extractLinkPointIds(link);
+        const linkOptions = linkIterationExtractor(link, i, this.links, this, this.linkSettings.options ?? {}, linkOptionsGetter);
+        const id = `${targetId}${sourceId}`;
+        this.linkOptionsCache[id] = linkOptions;
+    }
+}
+
+function updateNodeCache() {
+    this.nodeOptionsCache = {};
+    if (!this.context)
+        return;
+    for (let i = 0; i < this.nodes.length; i++) {
+        const node = this.nodes[i];
+        const nodeOptions = nodeIterationExtractor(node, i, this.nodes, this, this.nodeSettings.options ?? {}, nodeOptionsGetter);
+        const radius = nodeOptions.shape === "circle"
+            ? nodeRadiusGetter({
+                radiusFlexible: this.nodeSettings.nodeRadiusFlexible,
+                radiusInitial: nodeOptions.radius,
+                radiusIncrementByStep: this.nodeSettings.nodeRadiusIncrementByStep,
+                radiusLinkCountForStep: this.nodeSettings.nodeRadiusLinkCountForStep,
+                radiusMaxLinearSteps: this.nodeSettings.nodeRadiusMaxLinearSteps,
+                radiusLogFactor: this.nodeSettings.nodeRadiusLogFactor,
+                radiusLinkCountDividerForLog: this.nodeSettings.nodeRadiusLinkCountDividerForLog,
+                linkCount: node.linkCount,
+            })
+            : nodeOptions.radius;
+        let width = nodeOptions.width;
+        let height = nodeOptions.height;
+        let labelSize = nodeOptions.labelSize;
+        if (nodeOptions.shape === "square") {
+            const size = nodeSizeGetter({
+                heightInitial: nodeOptions.height,
+                widthInitial: nodeOptions.width,
+                linkCount: node.linkCount,
+                sizeFlexible: this.nodeSettings.nodeSizeFlexible,
+                sizeIncrementByStep: this.nodeSettings.nodeSizeIncrementByStep,
+                sizeLinkCountForStep: this.nodeSettings.nodeSizeLinkCountForStep,
+                sizeMaxLinearSteps: this.nodeSettings.nodeSizeMaxLinearSteps,
+                sizeLogFactor: this.nodeSettings.nodeSizeLogFactor,
+                sizeLinkCountDividerForLog: this.nodeSettings.nodeSizeLinkCountDividerForLog,
+            });
+            width = size.width;
+            height = size.height;
+        }
+        if (nodeOptions.shape === "text") {
+            width = nodeOptions.width;
+            const size = nodeSizeGetter({
+                heightInitial: nodeOptions.height,
+                widthInitial: width,
+                linkCount: node.linkCount,
+                sizeFlexible: this.nodeSettings.nodeSizeFlexible,
+                sizeIncrementByStep: this.nodeSettings.nodeSizeIncrementByStep,
+                sizeLinkCountForStep: this.nodeSettings.nodeSizeLinkCountForStep,
+                sizeMaxLinearSteps: this.nodeSettings.nodeSizeMaxLinearSteps,
+                sizeLogFactor: this.nodeSettings.nodeSizeLogFactor,
+                sizeLinkCountDividerForLog: this.nodeSettings.nodeSizeLinkCountDividerForLog,
+            });
+            labelSize *= size.additionalSizeCoefficient;
+        }
+        /** label in not text shape */
+        if (nodeOptions.shape !== "text" && nodeOptions.label) {
+            this.context.font = `${nodeOptions.labelStyle} normal ${nodeOptions.labelWeight} ${nodeOptions.labelSize}px ${nodeOptions.labelFont}`;
+            this.context.fillStyle = nodeOptions.labelColor;
+            this.context.textAlign = nodeOptions.labelAlign;
+            if (nodeOptions.labelWidth == undefined ||
+                this.context.measureText(nodeOptions.label).width <= nodeOptions.labelWidth) {
+                this.cachedNodeLabel[node.id] = [nodeOptions.label];
+            }
+            const { lines } = getTextLines({
+                context: this.context,
+                maxWidth: nodeOptions.labelWidth,
+                text: nodeOptions.label,
+                textAlign: nodeOptions.labelAlign,
+                textColor: nodeOptions.labelColor,
+                textFont: nodeOptions.labelFont,
+                textSize: nodeOptions.labelSize,
+                textStyle: nodeOptions.labelStyle,
+                textWeight: nodeOptions.labelWeight,
+            });
+            this.cachedNodeLabel[node.id] = lines;
+        }
+        /** label in text shape */
+        if (nodeOptions.shape === "text" && nodeOptions.label) {
+            const textInfo = getTextLines({
+                context: this.context,
+                text: nodeOptions.label,
+                textAlign: nodeOptions.labelAlign,
+                textColor: nodeOptions.labelColor,
+                textFont: nodeOptions.labelFont,
+                textSize: labelSize,
+                maxWidth: nodeOptions.labelWidth,
+                textStyle: nodeOptions.labelStyle,
+                textWeight: nodeOptions.textWeight,
+            });
+            const textNodeParameters = [textInfo.currentMaxSize, labelSize];
+            const lines = textInfo.lines;
+            const textSizeCoefficient = labelSize / textNodeParameters[1];
+            const maxSize = textNodeParameters[0] * textSizeCoefficient;
+            height =
+                lines.length * labelSize +
+                    (lines.length - 1) * nodeOptions.labelGap +
+                    nodeOptions.labelYPadding;
+            width = maxSize + nodeOptions.labelXPadding;
+            this.cachedNodeLabel[node.id] = lines;
+        }
+        nodeOptions.width = node.visible === false ? 0 : width;
+        nodeOptions.height = node.visible === false ? 0 : height;
+        nodeOptions.radius = node.visible === false ? 0 : radius;
+        nodeOptions.labelSize = labelSize;
+        /** text */
+        if (nodeOptions.text) {
+            this.context.font = `${nodeOptions.textStyle} normal ${nodeOptions.textWeight} ${nodeOptions.textSize}px ${nodeOptions.textFont}`;
+            this.context.fillStyle = nodeOptions.textColor;
+            this.context.textAlign = nodeOptions.textAlign;
+            if (nodeOptions.textWidth == undefined ||
+                this.context.measureText(nodeOptions.text).width <= nodeOptions.textWidth) {
+                this.cachedNodeText[node.id] = [nodeOptions.text];
+            }
+            const { lines } = getTextLines({
+                context: this.context,
+                maxWidth: nodeOptions.textWidth,
+                text: nodeOptions.text,
+                textAlign: nodeOptions.textAlign,
+                textColor: nodeOptions.textColor,
+                textFont: nodeOptions.textFont,
+                textSize: nodeOptions.textSize,
+                textStyle: nodeOptions.textStyle,
+                textWeight: nodeOptions.textWeight,
+            });
+            this.cachedNodeText[node.id] = lines;
+        }
+        this.nodeOptionsCache[node.id] = nodeOptions;
+    }
+}
+
 function initZoom(currentZoom) {
     if (!this.area)
         throw new Error("bad init data");
@@ -2426,8 +2422,8 @@ function initZoom(currentZoom) {
         .on("zoom", (event) => {
         this.listeners.onZoom?.call?.(this, event);
         this.areaTransform = event.transform;
-        this.linkOptionsCache = {};
-        this.nodeOptionsCache = {};
+        updateLinkCache.call(this);
+        updateNodeCache.call(this);
         if (!this.simulationWorking && !this.highlightWorking)
             requestAnimationFrame(() => this.draw());
     });
@@ -2474,7 +2470,6 @@ class GraphCanvas {
     eventAbortController;
     cachedNodeText = {};
     cachedNodeLabel = {};
-    cachedTextNodeParameters = {};
     linkOptionsCache = {};
     nodeOptionsCache = {};
     isDragging = false;
@@ -2537,26 +2532,19 @@ class GraphCanvas {
         if (options.highlightSettings) {
             this.highlightSettings = highlightSettingsGetter(options.highlightSettings, this.highlightSettings);
             if (clearCache) {
-                this.linkOptionsCache = {};
-                this.cachedNodeText = {};
-                this.cachedNodeLabel = {};
-                this.cachedTextNodeParameters = {};
-                this.nodeOptionsCache = {};
+                this.clearCache(["nodeOptionsCache", "linkOptionsCache"]);
             }
         }
         if (options.linkSettings) {
             this.linkSettings = linkSettingsGetter(options.linkSettings, this.linkSettings);
             if (clearCache) {
-                this.linkOptionsCache = {};
+                this.clearCache(["linkOptionsCache"]);
             }
         }
         if (options.nodeSettings) {
             this.nodeSettings = nodeSettingsGetter(options.nodeSettings, this.nodeSettings);
             if (clearCache) {
-                this.cachedNodeText = {};
-                this.cachedNodeLabel = {};
-                this.cachedTextNodeParameters = {};
-                this.nodeOptionsCache = {};
+                this.clearCache(["nodeOptionsCache"]);
             }
             initCollideForce.call(this, true);
         }
@@ -2583,16 +2571,18 @@ class GraphCanvas {
     }
     clearCache(keys) {
         if (!keys) {
-            this.nodeOptionsCache = {};
-            this.linkOptionsCache = {};
-            this.cachedNodeText = {};
-            this.cachedNodeLabel = {};
-            this.cachedTextNodeParameters = {};
+            updateNodeCache.call(this);
+            updateLinkCache.call(this);
         }
         else {
             for (let i = 0; i < keys.length; i++) {
                 const key = keys[i];
-                this[key] = {};
+                if (key === "nodeOptionsCache") {
+                    updateNodeCache.call(this);
+                }
+                else {
+                    updateLinkCache.call(this);
+                }
             }
         }
     }
@@ -2676,6 +2666,8 @@ class GraphCanvas {
     }
     init() {
         initArea.call(this);
+        updateNodeCache.call(this);
+        updateLinkCache.call(this);
         initSimulation.call(this);
         initDnd.call(this);
         initZoom.call(this);
@@ -3266,12 +3258,6 @@ const HIGHLIGHT_BY_LINK_FOR_ARROW_CONTROLS = [
 ];
 
 const LINK_SETTINGS_CONTROLS = [
-    {
-        id: "cacheOptions",
-        type: "checkbox",
-        label: "Кеширование вычисляемых настроек",
-        initialValue: LINK_SETTINGS.cacheOptions,
-    },
     {
         id: "prettyDraw",
         type: "checkbox",
@@ -3479,12 +3465,6 @@ const LINK_OPTIONS_PARTICLE_CONTROLS = [
 ];
 
 const NODE_SETTINGS_CONTROLS = [
-    {
-        id: "cacheOptions",
-        type: "checkbox",
-        initialValue: NODE_SETTINGS.cacheOptions,
-        label: "Кеширование вычисляемых настроек",
-    },
     {
         id: "textNodeDebug",
         type: "checkbox",
@@ -3495,49 +3475,103 @@ const NODE_SETTINGS_CONTROLS = [
         id: "nodeRadiusFlexible",
         type: "checkbox",
         initialValue: NODE_SETTINGS.nodeRadiusFlexible,
-        label: "Гибкий радиус (только для круга)",
+        label: "Гибкий радиус",
     },
     {
-        id: "nodeRadiusCoefficient",
-        initialValue: NODE_SETTINGS.nodeRadiusCoefficient,
+        id: "nodeRadiusLinkCountForStep",
+        initialValue: NODE_SETTINGS.nodeRadiusLinkCountForStep,
         max: 100,
         min: 0.1,
         step: 0.1,
         type: "range",
-        label: "Количество связей для увеличения радиуса (только для круга)",
+        label: "Количество связей для увеличения линейного шага радиуса",
     },
     {
-        id: "nodeRadiusFactor",
-        initialValue: NODE_SETTINGS.nodeRadiusFactor,
+        id: "nodeRadiusIncrementByStep",
+        initialValue: NODE_SETTINGS.nodeRadiusIncrementByStep,
         max: 50,
         min: 0.1,
         step: 0.1,
         type: "range",
-        label: "Коэффициент увеличения радиуса (только для круга)",
+        label: "Размер шага линейного увеличения радиуса",
+    },
+    {
+        id: "nodeRadiusMaxLinearSteps",
+        initialValue: NODE_SETTINGS.nodeRadiusMaxLinearSteps,
+        max: 50,
+        min: 1,
+        step: 1,
+        type: "range",
+        label: "Максимальное число шагов линейного увеличения радиуса",
+    },
+    {
+        id: "nodeRadiusLogFactor",
+        initialValue: NODE_SETTINGS.nodeRadiusLogFactor,
+        max: 50,
+        min: 1,
+        step: 1,
+        type: "range",
+        label: "Число умножаемое на логарифм от количества связей для увеличения радиуса",
+    },
+    {
+        id: "nodeRadiusLinkCountDividerForLog",
+        initialValue: NODE_SETTINGS.nodeRadiusLinkCountDividerForLog,
+        max: 50,
+        min: 1,
+        step: 1,
+        type: "range",
+        label: "Делитель количества связей для вычисления логарифма увеличения радиуса.",
     },
     {
         id: "nodeSizeFlexible",
         type: "checkbox",
         initialValue: NODE_SETTINGS.nodeSizeFlexible,
-        label: "Гибкий размер (только не для круга)",
+        label: "Гибкий размер",
     },
     {
-        id: "nodeSizeCoefficient",
-        initialValue: NODE_SETTINGS.nodeSizeCoefficient,
+        id: "nodeSizeLinkCountForStep",
+        initialValue: NODE_SETTINGS.nodeSizeLinkCountForStep,
+        max: 100,
+        min: 0.1,
+        step: 0.1,
+        type: "range",
+        label: "Количество связей для увеличения линейного шага размера",
+    },
+    {
+        id: "nodeSizeIncrementByStep",
+        initialValue: NODE_SETTINGS.nodeSizeIncrementByStep,
         max: 50,
         min: 0.1,
         step: 0.1,
         type: "range",
-        label: "Количество связей для увеличения размера (только не для круга)",
+        label: "Размер шага линейного увеличения размера",
     },
     {
-        id: "nodeSizeFactor",
-        initialValue: NODE_SETTINGS.nodeSizeFactor,
-        max: 20,
-        min: 0.01,
-        step: 0.01,
+        id: "nodeSizeMaxLinearSteps",
+        initialValue: NODE_SETTINGS.nodeSizeMaxLinearSteps,
+        max: 50,
+        min: 1,
+        step: 1,
+        type: "range",
+        label: "Максимальное число шагов линейного увеличения размера",
+    },
+    {
+        id: "nodeSizeLogFactor",
+        initialValue: NODE_SETTINGS.nodeSizeLogFactor,
+        max: 50,
+        min: 1,
+        step: 1,
+        type: "range",
+        label: "Число умножаемое на логарифм от количества связей для увеличения размера",
+    },
+    {
+        id: "nodeSizeLinkCountDividerForLog",
+        initialValue: NODE_SETTINGS.nodeSizeLinkCountDividerForLog,
+        max: 50,
+        min: 1,
+        step: 1,
         type: "range",
-        label: "Коэффициент увеличения размера (только не для круга)",
+        label: "Делитель количества связей для вычисления логарифма увеличения размера.",
     },
     {
         id: "textScaleMin",
@@ -3601,7 +3635,6 @@ const NODE_OPTIONS_NODE_CONTROLS = [
         initialValue: NODE_OPTIONS.shape,
         label: "Форма",
         options: [
-            { label: "Картинки", value: "icon" },
             { label: "Круг", value: "circle" },
             { label: "Прямоугольник", value: "square" },
             { label: "Текст", value: "text" },