index.js

const express = require("express");
const app = express();
app.use(express.json());

const defaultFactor = 2.5
const defaultInterval = 2

const generateOutput = ({ factor, interval, due }) =>
	  `[[date:${due.toISOString().slice(0, 10)}]] ${factor}/${interval}`;

app.get("/calculate", (req, res) => {
	  const { srs, signal } = req.query;
	  const [_, factor, interval] = srs.split("/");

	  const [calculatedFactor, calculatedInterval, calculatedDue] = [
		      parseInt(factor, 10) || defaultFactor,
		      parseFloat(interval) || defaultInterval,
		      new Date(),
		    ];
	  const calculatedSignal = parseInt(signal, 10);

	  const newNode = ankiSchedulerGetNewMetadata(
		      {
			            interval: calculatedInterval,
			            factor: calculatedFactor,
			            due: calculatedDue,
			          },
		      calculatedSignal
		    );

	  res.write(generateOutput(newNode));
	  res.end();
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
	  console.log(`Server is running on port ${port}`);
});

function ankiSchedulerGetNewMetadata(meta, signal) {
	  var maxInterval = 50 * 365;
	  var minFactor = 1.3;
	  var hardFactor = 1.2;
	  var jitterPercentage = 0.05;

	  var randomFromInterval = function (min, max) {
		      return Math.random() * (max - min) + min;
		    };

	  var addJitter = function (node) {
		      var jitter = node.interval * jitterPercentage;
		      return {
			            interval: node.interval + randomFromInterval(-jitter, jitter),
			            factor: node.factor,
			            due: node.due,
			          };
		    };

	  var enforceLimits = function (node) {
		      return {
			            interval: Math.min(node.interval, maxInterval),
			            factor: Math.max(node.factor, minFactor),
			            due: node.due,
			          };
		    };

	  var factor = meta.factor;
	  var interval = meta.interval;
	  var newFactor = factor;
	  var newInterval = interval;
	  var factorModifier = 0.15;

	  switch (signal) {
		      case 1:
			        newFactor = factor - 0.2;
			        newInterval = 1;
			        break;
			      case 2:
			        newFactor = factor - factorModifier;
			        newInterval = interval * hardFactor;
			        break;
			      case 3:
			        newInterval = interval * factor;
			        break;
			      case 4:
			        newInterval = interval * factor;
			        newFactor = factor + factorModifier;
			        break;
			    }

	  var newMeta = enforceLimits(
		      addJitter({ interval: newInterval, factor: newFactor })
		    );

	  function addDays(date, days) {
		      var result = new Date(date);
		      result.setDate(result.getDate() + days);
		      return result;
		    }

	  return {
		      interval: newMeta.interval,
		      factor: newMeta.factor,
		      due: signal === 1 ? new Date() : addDays(new Date(), Math.ceil(newMeta.interval)),
		    };
}