interval-management - npm Package Compare versions

Comparing version 2.4.0 to 3.0.0

index.d.ts

 import { interval } from './intervals/interval';
-export { Comparable, Interval } from './types';
+export { Interval } from './types';
 export default interval;

intervals/generalInterval.js

@@ -180,9 +180,9 @@ "use strict";
                 var next = items[i + 1];
-                if (!split(item, next, i)) {
+                if (i === items.length - 1) {
+                    intervals.push(generalInterval(start, end, interval.usedNext));
+                }
+                else if (!split(item, next, i)) {
                     intervals.push(generalInterval(start, item, interval.usedNext));
                     start = next;
                 }
-                if (i === items.length - 1) {
-                    intervals.push(generalInterval(start, end, interval.usedNext));
-                }
             });
@@ -230,3 +230,3 @@ return intervals;
         };
-        interval.convert = function (to, next) {
+        interval.convert = function (to, next, compare) {
             var nextEnd;
@@ -255,3 +255,3 @@ var nextStart = to(interval.start);
             }
-            var converted = index_1.default(nextStart, nextEnd, next);
+            var converted = index_1.default(nextStart, nextEnd, next, compare);
             converted.current = to(interval.current);
@@ -258,0 +258,0 @@ return converted;

intervals/interval.d.ts

@@ -1,2 +0,2 @@
-import { IntervalType } from "../types";
-export declare const interval: <T extends unknown = number>(start?: T | undefined, end?: T | undefined, next?: ((current: T) => T) | undefined) => IntervalType<T>;
+import { AllowedTypes, IntervalType, Simplify, IsComparableByDefault, EndParam } from "../types";
+export declare const interval: <T extends AllowedTypes = number>(start?: T | undefined, end?: EndParam<T> | undefined, next?: (T extends any[] ? never : (current: Simplify<T>) => Simplify<T>) | undefined, compare?: (IsComparableByDefault<T> extends false ? (a: Simplify<T>, b: Simplify<T>) => number : never) | undefined) => IntervalType<T>;

intervals/interval.js

@@ -8,3 +8,3 @@ "use strict";
 var dateInterval_1 = require("./dateInterval");
-exports.interval = function (start, end, next) {
+exports.interval = function (start, end, next, compare) {
     if (!start && !end && !next) {
@@ -43,6 +43,6 @@ return numberInterval_1.numberInterval(0, Infinity, function (current) { return current + 1; });
                 }
-                if (!next) {
+                if (!next || !compare) {
                     throw Error('Cannot create non-date object interval without knowing how to generate next item');
                 }
-                return objectInterval_1.objectInterval(start, end || null, next);
+                return objectInterval_1.objectInterval(compare)(start, end || null, next);
             case 'boolean':
@@ -49,0 +49,0 @@ return numberInterval_1.numberInterval(start, end || true, next || (function (_) { return true; }));

intervals/objectInterval.d.ts

@@ -1,2 +0,1 @@
-import { InnerComparable } from "../types";
-export declare const objectInterval: <T extends InnerComparable>(start: T, end: T, next: (current: T) => T) => import("../types").Interval<T>;
+export declare const objectInterval: <T>(compare: (a: T, b: T) => number) => (start: T, end: T, next: (current: T) => T) => import("..").Interval<T>;

intervals/objectInterval.js

@@ -5,2 +5,2 @@ "use strict";
 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);
+exports.objectInterval = function (compare) { return generalInterval_1.createInterval(function (a, b) { return !compare(a, b); }, function (a, b) { return compare(a, b) < 0; }, null); };

package.json

 {
   "name": "interval-management",
-  "version": "2.4.0",
+  "version": "3.0.0",
   "description": "No dependency interval management library, able to work with numbers, string, Dates or special objects",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

@@ -200,3 +200,7 @@ # Intervals documentation
 
+### Changes since 3.0.0
 
+You don't need to define complicated classes implementing Comparable interface. Instead, there is now a fourth parameter on interval function,
+which lets you define how do you want objects to be compared. This parameter is only accessible when needed - e.g. when comparing objects.
+
 Fixed a bug in .array() function where it returns a value even after .done() evaluates as true.
@@ -203,0 +207,0 @@

types.d.ts

@@ -118,4 +118,5 @@ export interface Interval<T = number> {
      * @param next How to get next element in line
+     * @param compare Use this function to redefine how the elements are compared. Only necessary when using object interval with defined next function
      */
-    convert: <E extends AllowedTypes>(to: (value: T) => E, next?: (item: E) => E) => Interval<E>;
+    convert: <E extends AllowedTypes>(to: (value: T) => E, next?: (item: E) => E, compare?: (a: E, b: E) => number) => Interval<E>;
     /**
@@ -175,16 +176,6 @@ * Map function which can deal with infinite intervals. This function does not mutate interval.
 }
-/**
- * Comparison interface, needs to be implemented in order for object intervals to work
- */
-interface IComparable<T> {
-    equals: (item: T) => boolean;
-    isLessThan: (item: T) => boolean;
-}
-export declare type AllowedTypes = string | number | symbol | Comparable<any> | Date | boolean;
-export declare type IntervalType<T> = T extends number ? Interval<number> : (T extends string ? Interval<string> : (T extends Date ? Interval<Date> : (T extends Comparable<T> ? Interval<Comparable<T>> : (T extends (infer U)[] ? Interval<U> : never))));
-export interface InnerComparable {
-    equals: <T extends InnerComparable>(item: T) => boolean;
-    isLessThan: <T extends InnerComparable>(item: T) => boolean;
-}
-export declare type Comparable<T> = T & IComparable<T>;
-export {};
+export declare type AllowedTypes = string | number | symbol | object | Date | boolean;
+export declare type IntervalType<T> = T extends number ? Interval<number> : (T extends string ? Interval<string> : (T extends Date ? Interval<Date> : (T extends (infer U)[] ? Interval<U> : (T extends object ? Interval<T> : never))));
+export declare type Simplify<T> = T extends number ? number : (T extends string ? string : (T extends Date ? Date : (T extends (infer U)[] ? U : (T extends object ? T : never))));
+export declare type EndParam<T> = T extends number ? number : (T extends string ? string | null : (T extends Date ? Date | null : (T extends [] ? never : (T extends object ? T | null : never))));
+export declare type IsComparableByDefault<T> = T extends number ? true : (T extends string ? true : (T extends Date ? true : (T extends [] ? true : (T extends object ? false : never))));

No alert changes

Improved metrics

Total package byte prevSize

37791

2.38%

Number of lines in readme file

219

1.86%

Worsened metrics

Lines of code

678

-1.31%

No dependency changes