@types/collections - npm Package Compare versions

Comparing version 5.1.1 to 5.1.2

collections/package.json

 {
     "name": "@types/collections",
-    "version": "5.1.1",
+    "version": "5.1.2",
     "description": "TypeScript definitions for collections",
@@ -22,4 +22,4 @@ "license": "MIT",
     "dependencies": {},
-    "typesPublisherContentHash": "5c822413d3e6dcae24087c263a9477c54b4532b4c211a8d8423864bb01974727",
+    "typesPublisherContentHash": "11267cc5b0d7f1fdefc968a43bb025840081bea7e10275d922f1767b32fcfb0b",
     "typeScriptVersion": "3.5"
 }

collections/README.md

@@ -11,3 +11,3 @@ # Installation
 ### Additional Details
- * Last updated: Sat, 24 Apr 2021 14:01:18 GMT
+ * Last updated: Mon, 24 May 2021 12:32:36 GMT
  * Dependencies: none
@@ -14,0 +14,0 @@ * Global values: none

collections/sorted-set.d.ts

@@ -0,4 +1,26 @@
+declare const SortedSet: internal.SortedSetStatic;
+
+declare namespace SortedSet {
+    type Iterator<T> = internal.Iterator<T>;
+    type Node<T> = internal.Node<T>;
+    type SortedSet<T> = internal.SortedSet<T>;
+}
+
 declare namespace internal {
-    // TODO: These methods can be similar in others collection. One's should make some
-    // class model.
+    interface SortedSetStatic {
+        <T>(
+            values?: T[],
+            equals?: (a: T, b: T) => boolean,
+            compare?: (a: T, b: T) => number,
+            getDefault?: any,
+        ): SortedSet<T>;
+        new <T>(
+            values?: T[],
+            equals?: (a: T, b: T) => boolean,
+            compare?: (a: T, b: T) => number,
+            getDefault?: any,
+        ): SortedSet<T>;
+    }
+
+    // TODO: move somewhere else
     abstract class AbstractSet {
@@ -19,3 +41,2 @@ union(...plus: any[]): any;
         map(...plus: any[]): any;
-
         filter(...plus: any[]): any;
@@ -60,27 +81,56 @@ group(...plus: any[]): any;
 
+    class Iterator<T> {
+        constructor(set: SortedSet<T>, start?: T, end?: T);
+
+        next(): { done: boolean; value: T | undefined };
+    }
+
     class Node<T> {
-        value: T;
+        readonly value: T;
+        readonly left: Node<T> | null;
+        readonly right: Node<T> | null;
+        readonly length: number;
 
-        reduce(
-            cb: (result?: any, val?: any, key?: any, collection?: any) => any,
-            basis: any,
+        constructor(value: T);
+
+        checkIntegrity(): number;
+        getNext(): Node<T> | undefined;
+        getPrevious(): Node<T> | undefined;
+        log(
+            charmap: {
+                branchUp: string;
+                branchDown: string;
+                fromAbove: string;
+                fromBelow: string;
+                fromBoth: string;
+                intersection: string;
+                strafe: string;
+                through: string;
+            },
+            logNode: (n: Node<T>, innerWrite: (line: string) => void, innerWriteAbove: (line: string) => void) => void,
+            log: (line: string) => void,
+            logAbove: (line: string) => void,
+        ): void;
+        reduce<U>(
+            callback: (accumulator: U, currentValue: T, index: number, set: SortedSet<T>) => U,
+            initialValue: U,
             index: number,
-            thisp: any,
-            tree: any,
-            depth: number,
-        ): any;
-        touch(...plus: any[]): void;
-        checkIntegrity(...plus: any[]): number;
-        getNext(...plus: any[]): Node<T> | undefined;
-        getPrevious(...plus: any[]): Node<T> | undefined;
-        summary(...plus: any[]): string;
-        log(charmap: any, logNode: any, log: any, logAbove: any): any;
+            thisArg: any,
+            tree: SortedSet<T>,
+            depth?: number,
+        ): U;
+        reduceRight<U>(
+            callback: (accumulator: U, currentValue: T, index: number, set: SortedSet<T>) => U,
+            initialValue: U,
+            index: number,
+            thisArg: any,
+            tree: SortedSet<T>,
+            depth?: number,
+        ): U;
+        summary(): string;
+        touch(): void;
     }
 
-    class Iterator<T> {
-        next(): { done: true; value: T | null | undefined };
-    }
-
     class SortedSet<T> extends AbstractSet {
-        length: number;
+        readonly length: number;
 
@@ -92,14 +142,11 @@ constructor(values?: T[], equals?: (a: T, b: T) => boolean, compare?: (a: T, b: T) => number, getDefault?: any);
         clear(): void;
-        ["delete"](value: T): boolean;
+        delete(value: T): boolean;
 
         find(value: T): Node<T> | undefined;
-        findGreatest(n?: Node<T>): Node<T> | undefined;
+        findGreatest(): Node<T> | undefined;
         findGreatestLessThan(value: T): Node<T> | undefined;
         findGreatestLessThanOrEqual(value: T): Node<T> | undefined;
-        findLeast(n?: Node<T>): Node<T> | undefined;
+        findLeast(): Node<T> | undefined;
         findLeastGreaterThan(value: T): Node<T> | undefined;
         findLeastGreaterThanOrEqual(value: T): Node<T> | undefined;
-        max(n?: Node<T>): T | undefined;
-        min(n?: Node<T>): T | undefined;
-        one(): T | undefined;
 
@@ -110,11 +157,15 @@ get(elt: T): T | undefined;
 
+        max(): T | undefined;
+        min(): T | undefined;
+        one(): T | undefined;
+
         pop(): T | undefined;
-        push(...rest: T[]): void;
+        push(...values: T[]): void;
 
         shift(): T | undefined;
-        unshift(...rest: T[]): void;
+        unshift(...values: T[]): void;
 
         slice(start?: number, end?: number): T[];
-        splice(start: Node<T>, length: number, ...values: T[]): T[];
-        swap(start: number, length: number, values?: T[]): T[];
+        splice(start: number, length: number, ...values: T[]): T[];
+        swap(start: number, length: number, ...values: T[]): T[];
 
@@ -124,13 +175,17 @@ splay(value: T): void;
 
-        reduce(callback: (result?: any, val?: any, key?: any, collection?: any) => any, basis?: any, thisp?: any): any;
-        reduceRight(
-            callback: (result?: any, val?: any, key?: any, collection?: any) => any,
-            basis?: any,
-            thisp?: any,
-        ): any;
+        reduce<U>(
+            callback: (accumulator: U, currentValue: T, index: number, set: SortedSet<T>) => U,
+            initialValue?: U,
+            thisArg?: any,
+        ): U;
+        reduceRight<U>(
+            callback: (accumulator: U, currentValue: T, index: number, set: SortedSet<T>) => U,
+            initialValue?: U,
+            thisArg?: any,
+        ): U;
 
-        iterate(start: number, stop: number): Iterator<T>;
+        iterate(): Iterator<T>;
     }
 }
 
-export = internal.SortedSet;
+export = SortedSet;

No alert changes

Improved metrics

Total package byte prevSize

8899

increased by20.31%

Lines of code

170

increased by41.67%

No dependency changes