You're Invited:Meet the Socket Team at RSAC and BSidesSF 2026, March 23–26.RSVP →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

interval-management

Package Overview
Dependencies
Maintainers
1
Versions
20
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

interval-management - npm Package Compare versions

Comparing version
2.2.0
 to
2.3.0
+1
-1
index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const interval_1 = require("./intervals/interval");
var interval_1 = require("./intervals/interval");
exports.default = interval_1.interval;
+2
-2
intervals/dateInterval.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dateInterval = void 0;
const generalInterval_1 = require("./generalInterval");
exports.dateInterval = generalInterval_1.createInterval((a, b) => a.getTime() === b.getTime(), (a, b) => a.getTime() < b.getTime(), null);
var generalInterval_1 = require("./generalInterval");
exports.dateInterval = generalInterval_1.createInterval(function (a, b) { return a.getTime() === b.getTime(); }, function (a, b) { return a.getTime() < b.getTime(); }, null);
+139
-94
intervals/generalInterval.js
"use strict";
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -7,12 +14,13 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

exports.createInterval = void 0;
const index_1 = __importDefault(require("../index"));
exports.createInterval = (equals, isLessThan, infinity) => {
const min = (a, b) => hasInfinity(a, b) ? getInfinity(a, b) : (isLessThan(a, b) ? a : b);
const max = (a, b) => hasInfinity(a, b) ? getNotInfinity(a, b) : isLessThan(a, b) ? b : a;
const less = (a, b) => hasInfinity(a, b) ? infinityIsMore(a, b, false) : isLessThan(a, b);
const lessOrEqual = (a, b) => hasInfinity(a, b) ? infinityIsMore(a, b, true) : (isLessThan(a, b) || equals(a, b));
const moreOrEqual = (a, b) => hasInfinity(a, b) ? infinityIsMore(b, a, true) : (isLessThan(b, a) || equals(a, b));
const getInfinity = (a, b) => a === infinity ? a : b;
const getNotInfinity = (a, b) => a === infinity ? b : a;
const infinityIsMore = (a, b, equal) => {
var index_1 = __importDefault(require("../index"));
exports.createInterval = function (equals, isLessThan, infinity) {
var min = function (a, b) { return hasInfinity(a, b) ? getInfinity(a, b) : (isLessThan(a, b) ? a : b); };
var max = function (a, b) { return hasInfinity(a, b) ? getNotInfinity(a, b) : isLessThan(a, b) ? b : a; };
var less = function (a, b) { return hasInfinity(a, b) ? infinityIsMore(a, b, false) : isLessThan(a, b); };
var lessOrEqual = function (a, b) { return hasInfinity(a, b) ? infinityIsMore(a, b, true) : (isLessThan(a, b) || equals(a, b)); };
var moreOrEqual = function (a, b) { return hasInfinity(a, b) ? infinityIsMore(b, a, true) : (isLessThan(b, a) || equals(a, b)); };
var safeEquals = function (a, b) { return a === infinity && b === infinity || (!hasInfinity(a, b) && equals(a, b)); };
var getInfinity = function (a, b) { return a === infinity ? a : b; };
var getNotInfinity = function (a, b) { return a === infinity ? b : a; };
var infinityIsMore = function (a, b, equal) {
if (a === b && equal) {

@@ -26,4 +34,4 @@ return true;

};
const hasInfinity = (a, b) => (a === infinity || b === infinity);
const concatNext = (a, b) => (current) => {
var hasInfinity = function (a, b) { return (a === infinity || b === infinity); };
var concatNext = function (a, b) { return function (current) {
if (b.has(current)) {

@@ -39,4 +47,4 @@ return b.usedNext(current);

return b.end;
};
const checkInterval = (start, end) => {
}; };
var checkInterval = function (start, end) {
if (end !== infinity && isLessThan(end, start)) {

@@ -49,5 +57,5 @@ throw new Error('End of interval cannot come before start');

};
const generalInterval = (start, end, next) => {
var generalInterval = function (start, end, next) {
checkInterval(start, end);
const interval = (start, end, next) => {
var interval = function (start, end, next) {
checkInterval(start, end || infinity);

@@ -66,3 +74,3 @@ interval.start = start;

interval.isDone = false;
interval.done = () => interval.isDone;
interval.done = function () { return interval.isDone; };
interval.usedNext = next;

@@ -72,3 +80,3 @@ interval.start = start;

interval.end = end;
interval.it = (iterator) => {
interval.it = function (iterator) {
if (iterator <= 0) {

@@ -78,3 +86,3 @@ return interval;

if (less(interval.current, interval.end)) {
const nextValue = interval.usedNext(interval.current);
var nextValue = interval.usedNext(interval.current);
if (less(nextValue, interval.end)) {

@@ -84,3 +92,3 @@ interval.current = nextValue;

}
if (equals(nextValue, interval.end)) {
if (safeEquals(nextValue, interval.end)) {
interval.current = nextValue;

@@ -94,3 +102,3 @@ return interval;

}
if (equals(interval.current, interval.end)) {
if (safeEquals(interval.current, interval.end)) {
interval.isDone = true;

@@ -101,9 +109,9 @@ return interval;

};
interval.next = () => interval.it(1);
interval.val = () => interval.current;
interval.concat = nextInterval => generalInterval(min(interval.start, nextInterval.start), max(interval.end, nextInterval.end), less(interval.end, nextInterval.end)
interval.next = function () { return interval.it(1); };
interval.val = function () { return interval.current; };
interval.concat = function (nextInterval) { return generalInterval(min(interval.start, nextInterval.start), max(interval.end, nextInterval.end), less(interval.end, nextInterval.end)
? concatNext(interval, nextInterval)
: concatNext(nextInterval, interval));
interval.has = value => moreOrEqual(value, interval.start) && lessOrEqual(value, interval.end);
interval.diff = nextInterval => {
: concatNext(nextInterval, interval)); };
interval.has = function (value) { return moreOrEqual(value, interval.start) && lessOrEqual(value, interval.end); };
interval.diff = function (nextInterval) {
if (!interval.overlap(nextInterval)) {

@@ -121,3 +129,3 @@ return interval;

}
return generalInterval(interval.start, interval.end, next => {
return generalInterval(interval.start, interval.end, function (next) {
if (less(next, nextInterval.start)) {

@@ -132,18 +140,18 @@ return interval.usedNext(next);

};
interval.overlap = nextInterval => interval.has(nextInterval.start) || interval.has(nextInterval.end);
interval.isInside = nextInterval => nextInterval.has(interval.start) && nextInterval.has(interval.end);
interval.compare = nextInterval => interval.overlap(nextInterval) ? 0 : (less(interval.start, nextInterval.start) ? -1 : 1);
interval.copy = () => {
const copied = generalInterval(interval.start, interval.end, interval.usedNext);
interval.overlap = function (nextInterval) { return interval.has(nextInterval.start) || interval.has(nextInterval.end); };
interval.isInside = function (nextInterval) { return nextInterval.has(interval.start) && nextInterval.has(interval.end); };
interval.compare = function (nextInterval) { return interval.overlap(nextInterval) ? 0 : (less(interval.start, nextInterval.start) ? -1 : 1); };
interval.copy = function () {
var copied = generalInterval(interval.start, interval.end, interval.usedNext);
copied.current = interval.current;
return copied;
};
interval.fillIn = intervals => {
interval.fillIn = function (intervals) {
if (!intervals || intervals.length === 0) {
return interval;
}
const sorted = interval.sort(intervals);
let filler = sorted[0];
for (let i = 0; i < sorted.length; i++) {
const at = sorted[i];
var sorted = interval.sort(intervals);
var filler = sorted[0];
for (var i = 0; i < sorted.length; i++) {
var at = sorted[i];
if (moreOrEqual(filler.end, at.start)) {

@@ -158,9 +166,9 @@ filler = filler.concat(at);

};
interval.sort = intervals => [...intervals].sort((a, b) => a.compare(b));
interval.array = () => {
interval.sort = function (intervals) { return __spreadArrays(intervals).sort(function (a, b) { return a.compare(b); }); };
interval.array = function () {
if (interval.end === infinity) {
throw Error('Cannot count to Infinity!');
}
const aggregate = [];
const copyInterval = interval.copy();
var aggregate = [];
var copyInterval = interval.copy();
while (!copyInterval.done()) {

@@ -172,12 +180,12 @@ aggregate.push(copyInterval.val());

};
interval.split = split => {
const intervals = [];
interval.split = function (split) {
var intervals = [];
if (interval.end === infinity) {
throw Error('Cannot split infinite interval');
}
const items = interval.array();
let start = items[0];
const end = items[items.length - 1];
items.forEach((item, i) => {
const next = items[i + 1];
var items = interval.array();
var start = items[0];
var end = items[items.length - 1];
items.forEach(function (item, i) {
var next = items[i + 1];
if (!split(item, next, i)) {

@@ -193,19 +201,19 @@ intervals.push(generalInterval(start, item, interval.usedNext));

};
const findHelper = (compare, end) => {
var findHelper = function (compare, end) {
if (!end && end !== 0 && interval.end === infinity) {
throw Error('Cannot seek inside infinite interval without boundary');
}
const trueEnd = (interval.end === infinity || end || end === 0) ? end : interval.end;
const trueCompare = typeof compare === 'function' ? compare : (item) => equals(item, compare);
const copyInterval = generalInterval(interval.start, trueEnd, interval.usedNext);
var trueEnd = (interval.end === infinity || end || end === 0) ? end : interval.end;
var trueCompare = typeof compare === 'function' ? compare : function (item) { return safeEquals(item, compare); };
var copyInterval = generalInterval(interval.start, trueEnd, interval.usedNext);
return {
trueCompare,
copyInterval,
trueCompare: trueCompare,
copyInterval: copyInterval,
};
};
interval.find = (compare, end) => {
interval.find = function (compare, end) {
if (typeof compare !== 'function' && !interval.has(compare)) {
return null;
}
const { trueCompare, copyInterval } = findHelper(compare, end);
var _a = findHelper(compare, end), trueCompare = _a.trueCompare, copyInterval = _a.copyInterval;
while (!copyInterval.done()) {

@@ -219,8 +227,8 @@ if (trueCompare(copyInterval.val())) {

};
interval.all = (compare, end) => {
interval.all = function (compare, end) {
if (typeof compare !== 'function' && !interval.has(compare)) {
return [];
}
const { trueCompare, copyInterval } = findHelper(compare, end);
const aggregate = [];
var _a = findHelper(compare, end), trueCompare = _a.trueCompare, copyInterval = _a.copyInterval;
var aggregate = [];
while (!copyInterval.done()) {

@@ -234,5 +242,5 @@ if (trueCompare(copyInterval.val())) {

};
interval.convert = (to, next) => {
let nextEnd;
const nextStart = to(interval.start);
interval.convert = function (to, next) {
var nextEnd;
var nextStart = to(interval.start);
if (interval.end === infinity) {

@@ -254,3 +262,3 @@ switch (typeof nextStart) {

if (!next) {
if (equals(nextEnd, infinity)) {
if (safeEquals(nextEnd, infinity)) {
throw Error('Cannot convert an infinite interval without next function');

@@ -260,15 +268,15 @@ }

}
const converted = index_1.default(nextStart, nextEnd, next);
var converted = index_1.default(nextStart, nextEnd, next);
converted.current = to(interval.current);
return converted;
};
const mapper = (inter, fn) => {
let stop = false;
const copied = inter.copy();
const escape = () => stop = true;
fn(copied, () => stop, escape);
var mapper = function (inter, fn) {
var stop = false;
var copied = inter.copy();
var escape = function () { return stop = true; };
fn(copied, function () { return stop; }, escape);
};
interval.map = (iterator) => {
const aggregate = [];
mapper(interval, (copied, stop, escape) => {
interval.map = function (iterator) {
var aggregate = [];
mapper(interval, function (copied, stop, escape) {
while (!stop()) {

@@ -284,3 +292,3 @@ aggregate.push(iterator(copied.val(), escape));

};
interval.forEach = iterator => mapper(interval, (copied, stop, escape) => {
interval.forEach = function (iterator) { return mapper(interval, function (copied, stop, escape) {
while (!copied.done() && !stop()) {

@@ -290,6 +298,6 @@ iterator(copied.val(), escape);

}
});
interval.reduce = (iterator, start) => {
let aggregate = start;
mapper(interval, (copied, stop, escape) => {
}); };
interval.reduce = function (iterator, start) {
var aggregate = start;
mapper(interval, function (copied, stop, escape) {
while (!copied.done() && !stop()) {

@@ -302,3 +310,3 @@ aggregate = iterator(aggregate, copied.val(), escape);

};
interval.closest = (item) => {
interval.closest = function (item) {
if (less(item, interval.start)) {

@@ -310,7 +318,7 @@ return [interval.start];

}
let last = interval.start;
let toReturn = [];
mapper(interval, (copied, stop, escape) => {
var last = interval.start;
var toReturn = [];
mapper(interval, function (copied, stop, escape) {
while (!copied.done() && !stop()) {
if (equals(copied.val(), item)) {
if (safeEquals(copied.val(), item)) {
escape();

@@ -332,12 +340,13 @@ toReturn = [copied.val()];

};
interval.reset = () => {
interval.reset = function () {
interval.current = interval.start;
interval.isDone = false;
return interval;
};
interval.deep = () => index_1.default(interval.array());
interval.classify = (classify) => {
const split = interval.split((current, next) => classify(current) === classify(next));
const map = {};
split.forEach(int => {
const index = classify(int.start);
interval.deep = function () { return index_1.default(interval.array()); };
interval.classify = function (classify) {
var split = interval.split(function (current, next) { return classify(current) === classify(next); });
var map = {};
split.forEach(function (int) {
var index = classify(int.start);
if (!map[index]) {

@@ -350,6 +359,42 @@ map[index] = [];

};
interval.merge = int => index_1.default([
...interval.array(),
...int.array(),
].sort((a, b) => equals(a, b) ? 0 : (less(a, b) ? -1 : 1)));
interval.merge = function (int) { return index_1.default(__spreadArrays(interval.array(), int.array()).sort(function (a, b) { return safeEquals(a, b) ? 0 : (less(a, b) ? -1 : 1); })); };
interval.pop = function () {
if (interval.isDone) {
return null;
}
var prevStart = interval.start;
interval.start = interval.usedNext(prevStart);
interval.current = interval.usedNext(prevStart);
return prevStart;
};
interval.push = function (item) {
if (safeEquals(item, infinity)) {
throw Error('Cannot push into infinite interval');
}
var prevEnd = interval.end;
var prevUsed = interval.usedNext;
interval.isDone = false;
interval.usedNext = function (current) {
if (safeEquals(current, prevEnd)) {
return item;
}
return prevUsed(current);
};
interval.end = item;
return interval;
};
interval.unshift = function (item) {
var prevStart = interval.start;
var prevUsed = interval.usedNext;
interval.isDone = false;
interval.start = item;
interval.current = item;
interval.usedNext = function (current) {
if (safeEquals(item, current)) {
return prevStart;
}
return prevUsed(current);
};
return interval;
};
return interval;

@@ -356,0 +401,0 @@ };

+16
-16
intervals/interval.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.interval = void 0;
const numberInterval_1 = require("./numberInterval");
const stringInterval_1 = require("./stringInterval");
const objectInterval_1 = require("./objectInterval");
const dateInterval_1 = require("./dateInterval");
exports.interval = (start, end, next) => {
var numberInterval_1 = require("./numberInterval");
var stringInterval_1 = require("./stringInterval");
var objectInterval_1 = require("./objectInterval");
var dateInterval_1 = require("./dateInterval");
exports.interval = function (start, end, next) {
if (!start && !end && !next) {
return numberInterval_1.numberInterval(0, Infinity, current => current + 1);
return numberInterval_1.numberInterval(0, Infinity, function (current) { return current + 1; });
}
if (Array.isArray(start) && start.length > 0 && !end && !next) {
const mappedIndex = {};
start.forEach((value, i) => {
if (mappedIndex[JSON.stringify(value)] !== undefined) {
var mappedIndex_1 = {};
start.forEach(function (value, i) {
if (mappedIndex_1[JSON.stringify(value)] !== undefined) {
throw Error('Cannot define array-like interval with two equal (as JSON.stringify) values!');
}
mappedIndex[JSON.stringify(value)] = i;
mappedIndex_1[JSON.stringify(value)] = i;
});
return exports.interval(start[0], start[start.length - 1], value => {
const currentIndex = mappedIndex[JSON.stringify(value)];
return exports.interval(start[0], start[start.length - 1], function (value) {
var currentIndex = mappedIndex_1[JSON.stringify(value)];
if ((!currentIndex && currentIndex !== 0) || currentIndex === start.length - 1) {

@@ -34,9 +34,9 @@ return start[start.length - 1];

case 'number':
return numberInterval_1.numberInterval(start, end || Infinity, next || (current => current + 1));
return numberInterval_1.numberInterval(start, end || Infinity, next || (function (current) { return current + 1; }));
case 'symbol':
case 'string':
return stringInterval_1.stringInterval(start.toString(), end || null, next || (current => `${current}${current}`));
return stringInterval_1.stringInterval(start.toString(), end || null, next || (function (current) { return "" + current + current; }));
case 'object':
if (start instanceof Date) {
return dateInterval_1.dateInterval(start, end || null, next || (current => new Date(current.getTime() + 1)));
return dateInterval_1.dateInterval(start, end || null, next || (function (current) { return new Date(current.getTime() + 1); }));
}

@@ -48,3 +48,3 @@ if (!next) {

case 'boolean':
return numberInterval_1.numberInterval(start, end || true, next || (_ => true));
return numberInterval_1.numberInterval(start, end || true, next || (function (_) { return true; }));
}

@@ -51,0 +51,0 @@ }

+2
-2
intervals/numberInterval.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.numberInterval = void 0;
const generalInterval_1 = require("./generalInterval");
exports.numberInterval = generalInterval_1.createInterval((a, b) => a === b, (a, b) => a < b, Infinity);
var generalInterval_1 = require("./generalInterval");
exports.numberInterval = generalInterval_1.createInterval(function (a, b) { return a === b; }, function (a, b) { return a < b; }, Infinity);
+2
-2
intervals/objectInterval.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.objectInterval = void 0;
const generalInterval_1 = require("./generalInterval");
exports.objectInterval = generalInterval_1.createInterval((a, b) => a.equals(b), (a, b) => a.isLessThan(b), null);
var generalInterval_1 = require("./generalInterval");
exports.objectInterval = generalInterval_1.createInterval(function (a, b) { return a.equals(b); }, function (a, b) { return a.isLessThan(b); }, null);
+2
-2
intervals/stringInterval.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.stringInterval = void 0;
const generalInterval_1 = require("./generalInterval");
exports.stringInterval = generalInterval_1.createInterval((a, b) => a === b, (a, b) => a < b, null);
var generalInterval_1 = require("./generalInterval");
exports.stringInterval = generalInterval_1.createInterval(function (a, b) { return a === b; }, function (a, b) { return a < b; }, null);
+1
-1
package.json
{
"name": "interval-management",
"version": "2.2.0",
"version": "2.3.0",
"description": "No dependency interval management library, able to work with numbers, string, Dates or special objects",

@@ -5,0 +5,0 @@ "main": "index.js",

+33
-0
README.md

@@ -162,2 +162,35 @@ # Intervals documentation

### Changes since 2.3.0:
Added unshift, pop and push functions. Push will not work on infinite intervals.
Also, changed the build to be targetted to ES5, fixed a bug in interval.reset() to reset done() function result
Examples:
```typescript
expect(interval([1, 2, 3, 4]).unshift(0).array()).toEqual([0, 1, 2, 3, 4]);
expect(interval(2, 8, n => n + 2).unshift(1).array()).toEqual([1, 2, 4, 6, 8]);
expect(interval(0, Infinity, c => c + 1).unshift(-1).unshift(-2).has(-1)).toBe(true);
expect(interval([1, 2, 3, 4]).push(5).array()).toEqual([1, 2, 3, 4, 5]);
expect(interval(2, 8, n => n + 2).push(9).array()).toEqual([2, 4, 6, 8, 9]);
expect(interval([1, 2, 3, 4]).pop()).toBe(1);
expect(interval(2, 8, n => n + 2).pop()).toBe(2);
const poppy = interval(1, 5, c => c + 2);
poppy.pop();
poppy.pop();
expect(poppy.array()).toEqual([5]);
const inf = interval(0, Infinity, c => c + 1);
inf.pop();
expect(inf.has(0)).toBe(false);
```
This library does NOT allow you to:

@@ -164,0 +197,0 @@ 

+12
-0
types.d.ts

@@ -148,2 +148,14 @@ export interface Interval<T = number> {

merge: (int: Interval<T>) => Interval<T>;
/**
* Remove and return first element of the interval. Will reset the current position inside the interval.
*/
pop: () => T | null;
/**
* Pushes an element to the end of interval. Will fail on infinite intervals.
*/
push: (item: T) => Interval<T>;
/**
* Pushes an element to the start of the interval. Will reset current position inside the interval.
*/
unshift: (item: T) => Interval<T>;
}

@@ -150,0 +162,0 @@ /**