@krainovsd/graph 0.12.0-beta.6 → 0.13.0-beta1

package/lib/cjs/index.cjs

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const jsHelpers = require('@krainovsd/js-helpers');
 const d3Force = require('d3-force');
 const d3Zoom = require('d3-zoom');
-const jsHelpers = require('@krainovsd/js-helpers');
 const d3Array = require('d3-array');
 const d3Selection = require('d3-selection');
 const d3Drag = require('d3-drag');
@@ -41,158 +41,6 @@ const FORCE_SETTINGS = {
     collideRadius: null,
 };
 
-const GRAPH_SETTINGS = {
-    zoomExtent: [0.3, 10],
-    translateExtent: [[], []],
-    translateExtentEnable: true,
-    translateExtentCoefficient: [3, 3],
-    dragPlaceCoefficient: dragPlaceCoefficientGetter,
-    zoomInitial: null,
-    showDrawTime: true,
-    showDrawTimeEveryTick: false,
-};
-
-const HIGHLIGHT_SETTINGS = {
-    highlightByHoverNode: true,
-    highlightByHoverLink: true,
-    highlightUpFrames: 5,
-    highlightDownFrames: 5,
-    linkHoverExtraZone: 2,
-    /** Node */
-    highlightByNodeOnlyRoot: true,
-    highlightByNodeForNodeColorFading: false,
-    highlightByNodeForNodeColor: null,
-    highlightByNodeForNodeSizingAdditional: 0.5,
-    highlightByNodeForNodeSizingAdditionalCoefficient: 0.35,
-    highlightByNodeForNodeFadingMin: 0.21,
-    highlightByNodeForNodeBorderColor: null,
-    highlightByNodeForNodeBorderSizingAdditional: 0,
-    highlightByLinkForNodeColorFading: false,
-    highlightByLinkForNodeColor: null,
-    highlightByLinkForNodeSizingAdditional: 0.5,
-    highlightByLinkForNodeSizingAdditionalCoefficient: 0.35,
-    highlightByLinkForNodeFadingMin: 0.21,
-    highlightByLinkForNodeBorderColor: null,
-    highlightByLinkForNodeBorderSizingAdditional: 0,
-    /** Text */
-    highlightByNodeForTextShiftXAdditional: 0,
-    highlightByNodeForTextShiftYAdditional: 2,
-    highlightByNodeForTextSizingAdditional: 1,
-    highlightByNodeForTextWeightAdditional: 0,
-    highlightByNodeForTextFadingMin: 0.21,
-    highlightByLinkForTextShiftXAdditional: 0,
-    highlightByLinkForTextShiftYAdditional: 2,
-    highlightByLinkForTextSizingAdditional: 1,
-    highlightByLinkForTextWeightAdditional: 0,
-    highlightByLinkForTextFadingMin: 0.21,
-    /** Label */
-    highlightByNodeForLabelFadingMin: 0.21,
-    highlightByNodeForLabelSizingAdditional: 1,
-    highlightByNodeForLabelWeightAdditional: 0,
-    highlightByLinkForLabelFadingMin: 0.21,
-    highlightByLinkForLabelSizingAdditional: 1,
-    highlightByLinkForLabelWeightAdditional: 0,
-    /** Link */
-    highlightByNodeForLinkFadingMin: 0.21,
-    highlightByNodeForLinkSizeAdditional: 0,
-    highlightByNodeForLinkColor: null,
-    highlightByLinkForLinkFadingMin: 0.21,
-    highlightByLinkForLinkSizeAdditional: 0,
-    highlightByLinkForLinkColor: null,
-    /** Arrow */
-    highlightByNodeForArrowFadingMin: 0.21,
-    highlightByNodeForArrowSizeAdditional: 0,
-    highlightByNodeForArrowColor: null,
-    highlightByNodeForArrowBorderColor: null,
-    highlightByNodeForArrowBorderSizingAdditional: 0,
-    highlightByLinkForArrowFadingMin: 0.21,
-    highlightByLinkForArrowSizeAdditional: 0,
-    highlightByLinkForArrowColor: null,
-    highlightByLinkForArrowBorderColor: null,
-    highlightByLinkForArrowBorderSizingAdditional: 0,
-};
-
-const LINK_SETTINGS = {
-    prettyDraw: true,
-    linkScaleSwitch: 1,
-    linkColorAfterScaleSwitch: "#000000FF",
-    linkColorBeforeScaleSwitch: "#999",
-    linkWidthAfterScaleSwitch: 0.1,
-    linkWidthBeforeScaleSwitch: 1,
-    arrow: true,
-    arrowByHighlight: true,
-    particles: true,
-    particleFlexSpeed: true,
-    particleFlexSpeedCoefficient: 4,
-};
-const LINK_OPTIONS = {
-    alpha: 1,
-    arrowAlpha: 1,
-    arrowSize: 2,
-    arrowBorderColor: "#000000FF",
-    arrowBorderWidth: 0.1,
-    particleAlpha: 1,
-    particleColor: "#000000FF",
-    particleBorderColor: "#000000FF",
-    particleBorderWidth: 0.1,
-    particleCount: 2,
-    particleRadius: 0.5,
-    particleSteps: 60,
-};
-
-const NODE_SETTINGS = {
-    nodeRadiusFlexible: true,
-    nodeRadiusLinkCountForStep: 5,
-    nodeRadiusIncrementByStep: 1,
-    nodeRadiusMaxLinearSteps: 5,
-    nodeRadiusLinkCountDividerForLog: 25,
-    nodeRadiusLogFactor: 2.5,
-    nodeSizeFlexible: true,
-    nodeSizeLinkCountForStep: 5,
-    nodeSizeIncrementByStep: 0.1,
-    nodeSizeMaxLinearSteps: 5,
-    nodeSizeLinkCountDividerForLog: 25,
-    nodeSizeLogFactor: 2.5,
-    textScaleMin: 1.5,
-    textScaleMax: 18,
-    textSizeMin: 3.5,
-    textSizeMax: 1.5,
-    textShiftYMin: 4,
-    textShiftYMax: 2.5,
-    textNodeDebug: false,
-};
-const NODE_OPTIONS = {
-    shape: "circle",
-    height: 10,
-    width: 15,
-    borderRadius: 0,
-    radius: 4,
-    alpha: 1,
-    labelXPadding: 1,
-    labelYPadding: 1,
-    borderWidth: 0.1,
-    borderColor: "#000000FF",
-    textAlpha: 1,
-    textWidth: 20,
-    textShiftX: 0,
-    textFont: "Arial",
-    textAlign: "center",
-    textColor: "#333",
-    textStyle: "normal",
-    textWeight: 500,
-    textGap: 0,
-    label: null,
-    labelAlpha: 1,
-    labelAlign: "center",
-    labelColor: "#333",
-    labelFont: "Arial",
-    labelGap: 0,
-    labelSize: 3.5,
-    labelStyle: "normal",
-    labelWeight: 500,
-    labelWidth: 20,
-};
-
 function forceSettingsGetter(settings, prevSettings) {
     return {
         ...(prevSettings ?? FORCE_SETTINGS),
@@ -1146,6 +994,165 @@ function extractLinkPointIds(link) {
     return { sourceId, targetId };
 }
 
+const GRAPH_SETTINGS = {
+    zoomExtent: [0.3, 10],
+    translateExtent: [[], []],
+    translateExtentEnable: true,
+    translateExtentCoefficient: [3, 3],
+    dragPlaceCoefficient: dragPlaceCoefficientGetter,
+    zoomInitial: null,
+    showDrawTime: true,
+    showDrawTimeEveryTick: false,
+};
+
+const HIGHLIGHT_SETTINGS = {
+    highlightByHoverNode: true,
+    highlightByHoverLink: true,
+    highlightUpFrames: 5,
+    highlightDownFrames: 5,
+    linkHoverExtraZone: 2,
+    /** Node */
+    highlightByNodeOnlyRoot: true,
+    highlightByNodeForNodeColorFading: false,
+    highlightByNodeForNodeColor: null,
+    highlightByNodeForNodeSizingAdditional: 0.5,
+    highlightByNodeForNodeSizingAdditionalCoefficient: 0.35,
+    highlightByNodeForNodeFadingMin: 0.21,
+    highlightByNodeForNodeBorderColor: null,
+    highlightByNodeForNodeBorderSizingAdditional: 0,
+    highlightByLinkForNodeColorFading: false,
+    highlightByLinkForNodeColor: null,
+    highlightByLinkForNodeSizingAdditional: 0.5,
+    highlightByLinkForNodeSizingAdditionalCoefficient: 0.35,
+    highlightByLinkForNodeFadingMin: 0.21,
+    highlightByLinkForNodeBorderColor: null,
+    highlightByLinkForNodeBorderSizingAdditional: 0,
+    /** Text */
+    highlightByNodeForTextShiftXAdditional: 0,
+    highlightByNodeForTextShiftYAdditional: 2,
+    highlightByNodeForTextSizingAdditional: 1,
+    highlightByNodeForTextWeightAdditional: 0,
+    highlightByNodeForTextFadingMin: 0.21,
+    highlightByLinkForTextShiftXAdditional: 0,
+    highlightByLinkForTextShiftYAdditional: 2,
+    highlightByLinkForTextSizingAdditional: 1,
+    highlightByLinkForTextWeightAdditional: 0,
+    highlightByLinkForTextFadingMin: 0.21,
+    /** Label */
+    highlightByNodeForLabelFadingMin: 0.21,
+    highlightByNodeForLabelSizingAdditional: 1,
+    highlightByNodeForLabelWeightAdditional: 0,
+    highlightByLinkForLabelFadingMin: 0.21,
+    highlightByLinkForLabelSizingAdditional: 1,
+    highlightByLinkForLabelWeightAdditional: 0,
+    /** Link */
+    highlightByNodeForLinkFadingMin: 0.21,
+    highlightByNodeForLinkSizeAdditional: 0,
+    highlightByNodeForLinkColor: null,
+    highlightByLinkForLinkFadingMin: 0.21,
+    highlightByLinkForLinkSizeAdditional: 0,
+    highlightByLinkForLinkColor: null,
+    /** Arrow */
+    highlightByNodeForArrowFadingMin: 0.21,
+    highlightByNodeForArrowSizeAdditional: 0,
+    highlightByNodeForArrowColor: null,
+    highlightByNodeForArrowBorderColor: null,
+    highlightByNodeForArrowBorderSizingAdditional: 0,
+    highlightByLinkForArrowFadingMin: 0.21,
+    highlightByLinkForArrowSizeAdditional: 0,
+    highlightByLinkForArrowColor: null,
+    highlightByLinkForArrowBorderColor: null,
+    highlightByLinkForArrowBorderSizingAdditional: 0,
+};
+
+const LINK_SETTINGS = {
+    prettyDraw: true,
+    linkScaleSwitch: 1,
+    linkColorAfterScaleSwitch: "#000000FF",
+    linkColorBeforeScaleSwitch: "#999",
+    linkWidthAfterScaleSwitch: 0.1,
+    linkWidthBeforeScaleSwitch: 1,
+    arrow: true,
+    arrowByHighlight: true,
+    particles: true,
+    particleFlexSpeed: true,
+    particleFlexSpeedCoefficient: 4,
+};
+const LINK_OPTIONS = {
+    alpha: 1,
+    arrowAlpha: 1,
+    arrowSize: 2,
+    arrowBorderColor: "#000000FF",
+    arrowBorderWidth: 0.1,
+    particleAlpha: 1,
+    particleColor: "#000000FF",
+    particleBorderColor: "#000000FF",
+    particleBorderWidth: 0.1,
+    particleCount: 2,
+    particleRadius: 0.5,
+    particleSteps: 60,
+};
+
+const NODE_SETTINGS = {
+    nodeRadiusFlexible: true,
+    nodeRadiusLinkCountForStep: 5,
+    nodeRadiusIncrementByStep: 1,
+    nodeRadiusMaxLinearSteps: 5,
+    nodeRadiusLinkCountDividerForLog: 25,
+    nodeRadiusLogFactor: 2.5,
+    nodeSizeFlexible: true,
+    nodeSizeLinkCountForStep: 5,
+    nodeSizeIncrementByStep: 0.1,
+    nodeSizeMaxLinearSteps: 5,
+    nodeSizeLinkCountDividerForLog: 25,
+    nodeSizeLogFactor: 2.5,
+    textScaleMin: 1.5,
+    textScaleMax: 18,
+    textSizeMin: 3.5,
+    textSizeMax: 1.5,
+    textShiftYMin: 4,
+    textShiftYMax: 2.5,
+    textNodeDebug: false,
+};
+const NODE_OPTIONS = {
+    shape: "circle",
+    height: 10,
+    width: 15,
+    borderRadius: 0,
+    radius: 4,
+    alpha: 1,
+    labelXPadding: 1,
+    labelYPadding: 1,
+    borderWidth: 0.1,
+    borderColor: "#000000FF",
+    textAlpha: 1,
+    textWidth: 20,
+    textShiftX: 0,
+    textFont: "Arial",
+    textAlign: "center",
+    textColor: "#333",
+    textStyle: "normal",
+    textWeight: 500,
+    textGap: 0,
+    label: null,
+    labelAlpha: 1,
+    labelAlign: "center",
+    labelColor: "#333",
+    labelFont: "Arial",
+    labelGap: 0,
+    labelSize: 3.5,
+    labelStyle: "normal",
+    labelWeight: 500,
+    labelWidth: 20,
+};
+
+const GRAPH_CACHE_TYPE = {
+    NodeOptions: "nodeOptions",
+    LinkOptions: "linkOptions",
+    NodeText: "nodeText",
+    NodeLabel: "nodeLabel",
+};
+
 function initArea() {
     if (!this.area || !this.context || !this.container) {
         this.container = d3Selection.create("div")
@@ -2286,110 +2293,117 @@ function updateLinkCache() {
     }
 }
 
-function updateNodeCache() {
+function updateNodeCache(types) {
     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];
+        if (types === true || (jsHelpers.isObject(types) && types.options)) {
+            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;
+            }
+            nodeOptions.width = node.visible === false ? 0 : width;
+            nodeOptions.height = node.visible === false ? 0 : height;
+            nodeOptions.radius = node.visible === false ? 0 : radius;
+            nodeOptions.labelSize = labelSize;
+            this.nodeOptionsCache[node.id] = nodeOptions;
+        }
+        const nodeOptions = this.nodeOptionsCache[node.id];
+        /** label */
+        if (types === true || (jsHelpers.isObject(types) && types.label)) {
+            /** 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 */
+            }
+            else 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: nodeOptions.labelSize,
+                    maxWidth: nodeOptions.labelWidth,
+                    textStyle: nodeOptions.labelStyle,
+                    textWeight: nodeOptions.textWeight,
+                });
+                const textNodeParameters = [textInfo.currentMaxSize, nodeOptions.labelSize];
+                const lines = textInfo.lines;
+                const textSizeCoefficient = nodeOptions.labelSize / textNodeParameters[1];
+                const maxSize = textNodeParameters[0] * textSizeCoefficient;
+                nodeOptions.height =
+                    lines.length * nodeOptions.labelSize +
+                        (lines.length - 1) * nodeOptions.labelGap +
+                        nodeOptions.labelYPadding;
+                nodeOptions.width = maxSize + nodeOptions.labelXPadding;
+                this.cachedNodeLabel[node.id] = lines;
             }
-            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) {
+        if (nodeOptions.text && (types === true || (jsHelpers.isObject(types) && types.text))) {
             this.context.font = `${nodeOptions.textStyle} normal ${nodeOptions.textWeight} ${nodeOptions.textSize}px ${nodeOptions.textFont}`;
             this.context.fillStyle = nodeOptions.textColor;
             this.context.textAlign = nodeOptions.textAlign;
@@ -2410,7 +2424,6 @@ function updateNodeCache() {
             });
             this.cachedNodeText[node.id] = lines;
         }
-        this.nodeOptionsCache[node.id] = nodeOptions;
     }
 }
 
@@ -2421,9 +2434,12 @@ function initZoom(currentZoom) {
         .scaleExtent(this.graphSettings.zoomExtent)
         .on("zoom", (event) => {
         this.listeners.onZoom?.call?.(this, event);
+        const oldTransform = this.areaTransform;
         this.areaTransform = event.transform;
-        updateLinkCache.call(this);
-        updateNodeCache.call(this);
+        if (this.areaTransform.k !== oldTransform.k) {
+            updateLinkCache.call(this);
+            updateNodeCache.call(this, true);
+        }
         if (!this.simulationWorking && !this.highlightWorking)
             requestAnimationFrame(() => this.draw());
     });
@@ -2531,20 +2547,38 @@ class GraphCanvas {
         }
         if (options.highlightSettings) {
             this.highlightSettings = highlightSettingsGetter(options.highlightSettings, this.highlightSettings);
-            if (clearCache) {
-                this.clearCache(["nodeOptionsCache", "linkOptionsCache"]);
+            if (clearCache === true) {
+                this.clearCache([
+                    GRAPH_CACHE_TYPE.NodeOptions,
+                    GRAPH_CACHE_TYPE.NodeText,
+                    GRAPH_CACHE_TYPE.NodeLabel,
+                    GRAPH_CACHE_TYPE.LinkOptions,
+                ]);
+            }
+            else {
+                this.clearCache(clearCache);
             }
         }
         if (options.linkSettings) {
             this.linkSettings = linkSettingsGetter(options.linkSettings, this.linkSettings);
             if (clearCache) {
-                this.clearCache(["linkOptionsCache"]);
+                this.clearCache([GRAPH_CACHE_TYPE.LinkOptions]);
+            }
+            else {
+                this.clearCache(clearCache);
             }
         }
         if (options.nodeSettings) {
             this.nodeSettings = nodeSettingsGetter(options.nodeSettings, this.nodeSettings);
             if (clearCache) {
-                this.clearCache(["nodeOptionsCache"]);
+                this.clearCache([
+                    GRAPH_CACHE_TYPE.NodeOptions,
+                    GRAPH_CACHE_TYPE.NodeText,
+                    GRAPH_CACHE_TYPE.NodeLabel,
+                ]);
+            }
+            else {
+                this.clearCache(clearCache);
             }
             initCollideForce.call(this, true);
         }
@@ -2572,48 +2606,24 @@ class GraphCanvas {
             throw new Error("couldn't create canvas context");
         this.context.scale(this.dpi, this.dpi);
         this.draw();
-        // this.clearHTMLElements();
-        // initArea.call<
-        //   GraphCanvas<NodeData, LinkData>,
-        //   Parameters<typeof initArea>,
-        //   ReturnType<typeof initArea>
-        // >(this);
-        // initDnd.call<
-        //   GraphCanvas<NodeData, LinkData>,
-        //   Parameters<typeof initDnd>,
-        //   ReturnType<typeof initDnd>
-        // >(this);
-        // initZoom.call<
-        //   GraphCanvas<NodeData, LinkData>,
-        //   Parameters<typeof initZoom>,
-        //   ReturnType<typeof initZoom>
-        // >(this);
-        // initResize.call<
-        //   GraphCanvas<NodeData, LinkData>,
-        //   Parameters<typeof initResize>,
-        //   ReturnType<typeof initResize>
-        // >(this);
-        // initPointer.call<
-        //   GraphCanvas<NodeData, LinkData>,
-        //   Parameters<typeof initPointer>,
-        //   ReturnType<typeof initPointer>
-        // >(this);
-        // this.draw();
     }
     clearCache(keys) {
-        if (!keys) {
-            updateNodeCache.call(this);
+        if (keys === true) {
+            updateNodeCache.call(this, true);
             updateLinkCache.call(this);
         }
-        else {
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                if (key === "nodeOptionsCache") {
-                    updateNodeCache.call(this);
-                }
-                else {
-                    updateLinkCache.call(this);
-                }
+        else if (jsHelpers.isArray(keys)) {
+            if (keys.some((k) => k === GRAPH_CACHE_TYPE.NodeText ||
+                k === GRAPH_CACHE_TYPE.NodeLabel ||
+                k === GRAPH_CACHE_TYPE.NodeOptions)) {
+                updateNodeCache.call(this, {
+                    label: keys.includes(GRAPH_CACHE_TYPE.NodeLabel),
+                    options: keys.includes(GRAPH_CACHE_TYPE.NodeOptions),
+                    text: keys.includes(GRAPH_CACHE_TYPE.NodeOptions),
+                });
+            }
+            if (keys.includes(GRAPH_CACHE_TYPE.LinkOptions)) {
+                updateLinkCache.call(this);
             }
         }
     }
@@ -2647,7 +2657,7 @@ class GraphCanvas {
         }
         this.clearHTMLElements();
         this.clearState();
-        this.clearCache();
+        this.clearCache(true);
     }
     clearHTMLElements() {
         this.root.replaceChildren();
@@ -2674,7 +2684,7 @@ class GraphCanvas {
     }
     updateData(alpha = 0.5, clearCache = true) {
         if (clearCache) {
-            this.clearCache();
+            this.clearCache(clearCache);
         }
         if (this.simulation) {
             initCollideForce.call(this, false);
@@ -2697,7 +2707,7 @@ class GraphCanvas {
     }
     init() {
         initArea.call(this);
-        updateNodeCache.call(this);
+        updateNodeCache.call(this, true);
         updateLinkCache.call(this);
         initSimulation.call(this);
         initDnd.call(this);
@@ -3884,6 +3894,7 @@ const NODE_OPTIONS_LABEL_CONTROLS = [
 exports.COMMON_SETTINGS = COMMON_SETTINGS;
 exports.FORCE_CONTROLS = FORCE_CONTROLS;
 exports.FORCE_SETTINGS = FORCE_SETTINGS;
+exports.GRAPH_CACHE_TYPE = GRAPH_CACHE_TYPE;
 exports.GRAPH_SETTINGS = GRAPH_SETTINGS;
 exports.GraphCanvas = GraphCanvas;
 exports.HIGHLIGHT_BY_LINK_FOR_ARROW_CONTROLS = HIGHLIGHT_BY_LINK_FOR_ARROW_CONTROLS;