Extracted interfaces from core classes (v0.3.0).

Author: T99

.d.ts/doubly-linked-list-node.d.ts

@@ -1,5 +1,6 @@
 import { DoublyLinkedList } from "./doubly-linked-list";
-export declare class DoublyLinkedListNode<E> {
+import { IDoublyLinkedListNode } from "./i-doubly-linked-list-node";
+export declare class DoublyLinkedListNode<E> implements IDoublyLinkedListNode<E> {
     private previous;
     private next;
     private parentList;

.d.ts/doubly-linked-list.d.ts

@@ -1,7 +1,8 @@
 import { AbstractList } from "@jsdsl/abstract-list";
 import { DoublyLinkedListNode } from "./doubly-linked-list-node";
 import { AbstractIterator } from "iter-over";
-export declare class DoublyLinkedList<E = any> extends AbstractList<E> {
+import { IDoublyLinkedList } from "./i-doubly-linked-list";
+export declare class DoublyLinkedList<E = any> extends AbstractList<E> implements IDoublyLinkedList<E> {
     private prologue;
     private epilogue;
     constructor(...elements: E[]);

.d.ts/i-doubly-linked-list-node.d.ts

@@ -0,0 +1,11 @@
+import { IDoublyLinkedList } from "./i-doubly-linked-list";
+export interface IDoublyLinkedListNode<E> {
+    getElement(): E;
+    getParentList(): IDoublyLinkedList<E>;
+    hasPreviousNode(): boolean;
+    getPreviousNode(): IDoublyLinkedListNode<E> | undefined;
+    setPreviousNode(previousNode: IDoublyLinkedListNode<E> | undefined): IDoublyLinkedListNode<E> | undefined;
+    hasNextNode(): boolean;
+    getNextNode(): IDoublyLinkedListNode<E> | undefined;
+    setNextNode(nextNode: IDoublyLinkedListNode<E> | undefined): IDoublyLinkedListNode<E> | undefined;
+}

.d.ts/i-doubly-linked-list.d.ts

@@ -0,0 +1,26 @@
+import { AbstractIterator } from "iter-over";
+import { IDoublyLinkedListNode } from "./i-doubly-linked-list-node";
+export interface IDoublyLinkedList<E> {
+    getFirst(): E | undefined;
+    getFirstNode(): IDoublyLinkedListNode<E> | undefined;
+    getLast(): E | undefined;
+    getLastNode(): IDoublyLinkedListNode<E> | undefined;
+    hasNextNode(node: IDoublyLinkedListNode<E>): boolean;
+    getNextNode(node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E> | undefined;
+    hasPreviousNode(node: IDoublyLinkedListNode<E>): boolean;
+    getPreviousNode(node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E> | undefined;
+    insertAfter(element: E, node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    insertNodeAfter(node: IDoublyLinkedListNode<E>, afterNode: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    insertBefore(element: E, node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    insertNodeBefore(node: IDoublyLinkedListNode<E>, beforeNode: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    insertFirst(element: E): IDoublyLinkedListNode<E>;
+    insertNodeFirst(node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    insertLast(element: E): IDoublyLinkedListNode<E>;
+    insertNodeLast(node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    removeFirst(): E | undefined;
+    removeFirstNode(): IDoublyLinkedListNode<E> | undefined;
+    removeLast(): E | undefined;
+    removeLastNode(): IDoublyLinkedListNode<E> | undefined;
+    removeNode(node: IDoublyLinkedListNode<E>): IDoublyLinkedListNode<E>;
+    nodeIterator(): AbstractIterator<IDoublyLinkedListNode<E>>;
+}

.d.ts/main.d.ts

@@ -1,2 +1,4 @@
 export { DoublyLinkedList } from "./doubly-linked-list";
 export { DoublyLinkedListNode } from "./doubly-linked-list-node";
+export { IDoublyLinkedList } from "./i-doubly-linked-list";
+export { IDoublyLinkedListNode } from "./i-doubly-linked-list-node";

js/doubly-linked-list-node.js.map

@@ -1,6 +1,6 @@
 {
 	"name": "@jsdsl/doubly-linked-list",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "A full-featured doubly-linked list implementation.",
 	"publishConfig": {
 		"access": "public"

js/doubly-linked-list.js.map

@@ -5,6 +5,7 @@
  */
 
 import { DoublyLinkedList } from "./doubly-linked-list";
+import { IDoublyLinkedListNode } from "./i-doubly-linked-list-node";
 
 /**
  * A doubly-linked node within a {@link DoublyLinkedList}.
@@ -13,7 +14,7 @@ import { DoublyLinkedList } from "./doubly-linked-list";
  * @version v0.2.0
  * @since v0.1.0
  */
-export class DoublyLinkedListNode<E> {
+export class DoublyLinkedListNode<E> implements IDoublyLinkedListNode<E> {
 
 	/**
 	 * A reference to the node preceding this node, or undefined if this node has no preceding sibling.
@@ -56,11 +57,6 @@ export class DoublyLinkedListNode<E> {
 
 	}
 
-	/**
-	 * Returns the element contained in this node.
-	 * 
-	 * @return The element contained in this node.
-	 */
 	public getElement(): E {
 
 		if (this.content !== null) return this.content;
@@ -75,48 +71,25 @@ export class DoublyLinkedListNode<E> {
 
 	}
 
-	/**
-	 * Returns the {@link DoublyLinkedList} that contains this node.
-	 * 
-	 * @return The DoublyLinkedList that contains this node.
-	 */
 	public getParentList(): DoublyLinkedList<E> {
 
 		return this.parentList;
 
 	}
 
-	/**
-	 * Returns true if this node has a preceding node.
-	 * 
-	 * @return true if this node has a preceding node.
-	 */
 	public hasPreviousNode(): boolean {
 
 		return (this.previous !== undefined);
 
 	}
 
-	/**
-	 * Returns this node's preceding node, or undefined if this node has no preceding sibling.
-	 * 
-	 * @return This node's preceding node, or undefined if this node has no preceding sibling.
-	 * @see DoublyLinkedListNode#hasPreviousNode
-	 */
 	public getPreviousNode(): DoublyLinkedListNode<E> | undefined {
 
 		if (!this.hasPreviousNode()) return undefined;
 		else return this.previous as DoublyLinkedListNode<E>;
 
 	}
 
-	/**
-	 * Sets the preceding node for this node, returning the node displaced as this node's preceding sibling, or
-	 * undefined if this node had no preceding sibling.
-	 * 
-	 * @param previousNode The node to set as this node's preceding sibling.
-	 * @return DOC-ME
-	 */
 	public setPreviousNode(previousNode: DoublyLinkedListNode<E> | undefined): DoublyLinkedListNode<E> | undefined {
 
 		let displaced: DoublyLinkedListNode<E> | undefined = this.previous;
@@ -125,36 +98,19 @@ export class DoublyLinkedListNode<E> {
 
 	}
 
-	/**
-	 * Returns true if this node has a successive node.
-	 *
-	 * @return true if this node has a successive node.
-	 */
 	public hasNextNode(): boolean {
 
 		return (this.next !== undefined);
 
 	}
 
-	/**
-	 * Returns this node's succeeding node, or undefined if this node has no successive sibling.
-	 *
-	 * @return This node's succeeding node, or undefined if this node has no successive sibling.
-	 * @see DoublyLinkedListNode#hasNextNode
-	 */
 	public getNextNode(): DoublyLinkedListNode<E> | undefined {
 
 		if (!this.hasNextNode()) return undefined;
 		else return this.next as DoublyLinkedListNode<E>;
 
 	}
 
-	/**
-	 * Sets the succeeding node for this node, returning the node displaced as this node's succeeding sibling, or
-	 * undefined if this node had no successive sibling.
-	 * 
-	 * @param nextNode The node to set as this node's successive sibling.
-	 */
 	public setNextNode(nextNode: DoublyLinkedListNode<E> | undefined): DoublyLinkedListNode<E> | undefined {
 
 		let displaced: DoublyLinkedListNode<E> | undefined = this.next;