D3.js Dynamic Axis Extension

package.json

@@ -50,5 +50,8 @@
   },
   "engines": {
     "node": ">=12"
+  },
+  "dependencies": {
+    "d3-time": "^3.1.0"
   }
 }

src/axis.js

@@ -1,4 +1,5 @@
 import identity from "./identity.js";
+import * as d3 from "d3-time";
 
 var top = 1,
     right = 2,
@@ -114,6 +115,152 @@ function axis(orient, scale) {
         .each(function() { this.__axis = position; });
   }
 
+  axis.extend = function(extension,ticksLimit) {
+
+    // Get the current ticks
+    let ticks = axis.tickValues() || scale.ticks();
+    let newTicks;
+
+    if(orient === top || orient === bottom){
+	    console.warn("X ORIENTATION")
+	    // Calculate the interval (difference between the first two ticks)
+	    let tickDiff = ticks[1] - ticks[0];
+	    let interval = d3.timeMinute; // Default to minute interval
+
+	    // Adjust the interval based on the tickDiff
+	    if (tickDiff >= 365 * 24 * 60 * 60 * 1000) { // If ticks are yearly or larger
+	        interval = d3.timeYear;
+	        tickDiff = tickDiff / (365 * 24 * 60 * 60 * 1000); // Convert to years
+	    } 
+	    else if (tickDiff >= 30 * 24 * 60 * 60 * 1000) { // If ticks are monthly or larger
+	        interval = d3.timeMonth;
+	        tickDiff = tickDiff / (30 * 24 * 60 * 60 * 1000); // Convert to months
+	    }
+	    else if (tickDiff >= 24 * 60 * 60 * 1000) { // If ticks are daily or larger
+	        interval = d3.timeDay;
+	        tickDiff = tickDiff / (24 * 60 * 60 * 1000); // Convert to days
+	    }
+	    else if (tickDiff >= 60 * 60 * 1000) { // If ticks are hourly or larger
+	        interval = d3.timeHour;
+	        tickDiff = tickDiff / (60 * 60 * 1000); // Convert to hours
+	    }
+	    else if (tickDiff >= 60 * 1000) { // If ticks are minute or larger
+	        interval = d3.timeMinute;
+	        tickDiff = tickDiff / (60 * 1000); // Convert to minutes
+	    }
+	    else if (tickDiff >= 1000) { // If ticks are second or larger
+	        interval = d3.timeSecond;
+	        tickDiff = tickDiff / 1000; // Convert to seconds
+	    }
+
+	    newTicks = [...ticks];
+
+      //Extend BOTH ends of axis
+      if(extension.length>0){
+
+        let lastTick = ticks[ticks.length - 1];
+
+        let firstTick = ticks[0];
+
+        for (let i = 0; i < Math.abs(extension[0]); i++) {
+            firstTick = interval.offset(firstTick, -1*tickDiff); // Subtract a tick
+            newTicks.unshift(firstTick);
+	       }
+
+
+        for (let i = 0; i < extension[1]; i++) {
+	            lastTick = interval.offset(lastTick, tickDiff); // Add a new tick
+	            newTicks.push(lastTick);
+	      }
+
+      }
+	    // If extension > 0, extend to the right, else extend to the left
+	    else if (extension > 0) {
+	        let lastTick = ticks[ticks.length - 1];
+	        for (let i = 0; i < extension; i++) {
+	            lastTick = interval.offset(lastTick, tickDiff); // Add a new tick
+	            newTicks.push(lastTick);
+	        }
+	    } else if (extension < 0) {
+	        let firstTick = ticks[0];
+	        for (let i = 0; i < Math.abs(extension); i++) {
+	            firstTick = interval.offset(firstTick, -1*tickDiff); // Subtract a tick
+	            newTicks.unshift(firstTick);
+	        }
+	    }
+    }
+    else{
+
+	let tickDiff = Math.abs(ticks[1]-ticks[0]);	
+
+	newTicks = [...ticks];
+
+	// If extension > 0, extend to t, else extend to the left
+	     //Extend BOTH ends of axis
+      if(extension.length>0){
+
+        let lastTick = ticks[ticks.length - 1];
+
+        let firstTick = ticks[0];
+
+        for (let i = 0; i < Math.abs(extension[1]); i++) {
+            firstTick-=tickDiff;
+	          newTicks.unshift(firstTick);
+        }
+
+        for (let i = 0; i < extension[0]; i++) {
+	            lastTick+=tickDiff;
+	            newTicks.push(lastTick);
+	       }
+
+      } else if (extension > 0) {
+	        let lastTick = ticks[ticks.length - 1];
+	        for (let i = 0; i < extension; i++) {
+	            lastTick+=tickDiff;
+	            newTicks.push(lastTick);
+	        }
+	    } else if (extension < 0) {
+	        let firstTick = ticks[0];
+	        for (let i = 0; i < Math.abs(extension); i++) {
+	            firstTick-=tickDiff;
+		          newTicks.unshift(firstTick);
+	        }
+	    }
+
+      if(newTicks.length>ticksLimit){
+
+        let newTicks2 = [];
+        for(var i=0;i<newTicks.length;i+=(newTicks.length/ticksLimit)){
+          if(newTicks[Math.floor(i)])
+            newTicks2.push(newTicks[Math.floor(i)])
+        }
+
+        newTicks = newTicks2;
+
+      }
+      else if(newTicks.length<ticksLimit && newTicks.length>=2){
+
+        let newTicks2 = [];
+
+        let step = (newTicks[newTicks.length-1] - newTicks[0]) / ticksLimit;
+
+        let value = newTicks[0];
+
+        for(var i=0;i<ticksLimit;i++,value+=step){
+          newTicks2.push(value)
+        }
+
+        newTicks = newTicks2;
+
+      }
+    }
+
+    if(newTicks)
+    	axis.tickValues(Array.from(newTicks));
+
+    return axis;
+  };
+
   axis.scale = function(_) {
     return arguments.length ? (scale = _, axis) : scale;
   };