linked-list-typed 2.1.1 → 2.1.2

package/src/data-structures/heap/heap.ts

@@ -190,7 +190,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = Object.is;
 
   /**
@@ -255,7 +255,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new heap instance of this class.
    */
 
-  static from<T, R = never, S extends Heap<T, R> = Heap<T, R>>(
+  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(
     this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,
     elements?: Iterable<T | R>,
     options?: HeapOptions<T, R>
@@ -273,7 +273,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new Heap built from elements.
    */
 
-  static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
+  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
     return new Heap<EE, RR>(elements, options);
   }
 
@@ -788,7 +788,7 @@ export class FibonacciHeap<E> {
    */
 
   push(element: E): this {
-    const node = this._createNode(element);
+    const node = this.createNode(element);
     node.left = node;
     node.right = node;
     this.mergeWithRoot(node);
@@ -900,7 +900,7 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
-  _createNode(element: E): FibonacciHeapNode<E> {
+  createNode(element: E): FibonacciHeapNode<E> {
     return new FibonacciHeapNode<E>(element);
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -781,7 +781,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    * @returns A new SinglyLinkedListNode instance.
    */
 
-  protected _createNode(value: E): SinglyLinkedListNode<E> {
+  protected createNode(value: E): SinglyLinkedListNode<E> {
     return new SinglyLinkedListNode<E>(value);
   }
 
@@ -807,7 +807,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
 
   protected _ensureNode(elementOrNode: E | SinglyLinkedListNode<E>) {
     if (this.isNode(elementOrNode)) return elementOrNode;
-    return this._createNode(elementOrNode);
+    return this.createNode(elementOrNode);
   }
 
   /**

package/src/interfaces/binary-tree.ts

@@ -32,7 +32,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
   readonly isDuplicate: boolean;
 
   // ---- construction / mutation ----
-  _createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+  createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
 

package/tsconfig.base.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "./",
+    "declaration": true,
+    "esModuleInterop": true,
+    "inlineSourceMap": false,
+    "lib": ["esnext"],
+    "listEmittedFiles": false,
+    "listFiles": false,
+    "noFallthroughCasesInSwitch": true,
+    "pretty": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "traceResolution": false,
+    "noImplicitOverride": true,
+    "types": ["node"]
+  },
+  "compileOnSave": false,
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -1,38 +1,12 @@
 {
+  "extends": "./tsconfig.base.json",
   "compilerOptions": {
-    "declaration": true,
-    "outDir": "./dist",
-    "module": "commonjs",
-    "target": "es6",
-    "lib": [
-      //      "es2015",
-      "esnext"
-    ],
-    "strict": true,
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "declarationDir": "./dist",
-    "skipLibCheck": true,
-    "downlevelIteration": true,
-    "experimentalDecorators": true,
-    //    "allowJs": true,
-    //    "allowSyntheticDefaultImports": true,
-    //    "forceConsistentCasingInFileNames": true,
-    //    "noFallthroughCasesInSwitch": true,
-    //    "resolveJsonModule": true,
-    //    "isolatedModules": true,
-    //    "noEmit": true,
-    "typeRoots": [
-      "node_modules/@types"
-    ]
+    "rootDir": "./",
+    "outDir": "dist/dev",
+    "module": "NodeNext",
+    "target": "ESNext",
+    "moduleResolution": "NodeNext",
+    "sourceMap": true
   },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    //    "node_modules/data-structure-typed",
-    "node_modules",
-    "dist"
-  ]
+  "include": ["./src/**/*.ts"]
 }
-

package/tsconfig.test.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node", "jest"]
+  },
+  "include": ["./test/**/*.ts"]
+}

package/tsconfig.types.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "target": "ES2018",
+    "lib": ["ES2018", "DOM"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": false,
+    "outDir": "dist/types"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["dist", "node_modules", "test"]
+}

package/tsup.config.js

@@ -0,0 +1,28 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig([
+  {
+    entry: { "linked-list-typed": "src/index.ts" },
+    target: 'es2018',
+    format: ["iife"],
+    clean: true,
+    sourcemap: true,
+    minify: true,
+    outDir: "dist/umd",
+    globalName: "linkedListTyped",
+    platform: "browser",
+    outExtension: () => ({ js: '.min.js' }),
+  },
+  {
+    entry: { "linked-list-typed": "src/index.ts" },
+    target: 'es2018',
+    format: ["iife"],
+    clean: false,
+    sourcemap: true,
+    minify: false,
+    outDir: "dist/umd",
+    globalName: "linkedListTyped",
+    platform: "browser",
+    outExtension: () => ({ js: '.js' }),
+  }
+]);

package/tsup.node.config.js

@@ -0,0 +1,37 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig([
+  // ESM
+  {
+    entry: { index: "src/index.ts" },
+    format: ["esm"],
+    outDir: "dist/esm",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: true,
+    target: "es2018",
+    outExtension() {
+      return { js: ".mjs" }
+    },
+  },
+
+  // CJS
+  {
+    entry: { index: "src/index.ts" },
+    format: ["cjs"],
+    outDir: "dist/cjs",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: false,
+    target: "es2018",
+    outExtension() {
+      return { js: ".cjs" };
+    },
+  },
+]);

package/dist/common/index.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Range = exports.DFSOperation = void 0;
-const utils_1 = require("../utils");
-var DFSOperation;
-(function (DFSOperation) {
-    DFSOperation[DFSOperation["VISIT"] = 0] = "VISIT";
-    DFSOperation[DFSOperation["PROCESS"] = 1] = "PROCESS";
-})(DFSOperation = exports.DFSOperation || (exports.DFSOperation = {}));
-class Range {
-    constructor(low, high, includeLow = true, includeHigh = true) {
-        this.low = low;
-        this.high = high;
-        this.includeLow = includeLow;
-        this.includeHigh = includeHigh;
-        if (!((0, utils_1.isComparable)(low) && (0, utils_1.isComparable)(high)))
-            throw new RangeError('low or high is not comparable');
-        if (low > high)
-            throw new RangeError('low must be less than or equal to high');
-    }
-    // Determine whether a key is within the range
-    isInRange(key, comparator) {
-        const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-        const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-        return lowCheck && highCheck;
-    }
-}
-exports.Range = Range;

package/dist/constants/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DFSOperation = void 0;
-var DFSOperation;
-(function (DFSOperation) {
-    DFSOperation[DFSOperation["VISIT"] = 0] = "VISIT";
-    DFSOperation[DFSOperation["PROCESS"] = 1] = "PROCESS";
-})(DFSOperation = exports.DFSOperation || (exports.DFSOperation = {}));

package/dist/data-structures/base/index.d.ts

@@ -1,2 +0,0 @@
-export * from './iterable-entry-base';
-export * from './iterable-element-base';

package/dist/data-structures/base/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./iterable-entry-base"), exports);
-__exportStar(require("./iterable-element-base"), exports);

package/dist/data-structures/base/iterable-element-base.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableElementBase = void 0;
-/**
- * Base class that makes a data structure iterable and provides common
- * element-wise utilities (e.g., map/filter/reduce/find).
- *
- * @template E The public element type yielded by the structure.
- * @template R The underlying "raw" element type used internally or by converters.
- *
- * @remarks
- * This class implements the JavaScript iteration protocol (via `Symbol.iterator`)
- * and offers array-like helpers with predictable time/space complexity.
- */
-class IterableElementBase {
-    /**
-     * Create a new iterable base.
-     *
-     * @param options Optional behavior overrides. When provided, a `toElementFn`
-     * is used to convert a raw element (`R`) into a public element (`E`).
-     *
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    constructor(options) {
-        if (options) {
-            const { toElementFn } = options;
-            if (typeof toElementFn === 'function')
-                this._toElementFn = toElementFn;
-            else if (toElementFn)
-                throw new TypeError('toElementFn must be a function type');
-        }
-    }
-    /**
-     * Exposes the current `toElementFn`, if configured.
-     *
-     * @returns The converter function or `undefined` when not set.
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    get toElementFn() {
-        return this._toElementFn;
-    }
-    /**
-     * Returns an iterator over the structure's elements.
-     *
-     * @param args Optional iterator arguments forwarded to the internal iterator.
-     * @returns An `IterableIterator<E>` that yields the elements in traversal order.
-     *
-     * @remarks
-     * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
-     */
-    *[Symbol.iterator](...args) {
-        yield* this._getIterator(...args);
-    }
-    /**
-     * Returns an iterator over the values (alias of the default iterator).
-     *
-     * @returns An `IterableIterator<E>` over all elements.
-     * @remarks
-     * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
-     */
-    *values() {
-        for (const item of this)
-            yield item;
-    }
-    /**
-     * Tests whether all elements satisfy the predicate.
-     *
-     * @template TReturn
-     * @param predicate Function invoked for each element with signature `(value, index, self)`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns `true` if every element passes; otherwise `false`.
-     *
-     * @remarks
-     * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
-     */
-    every(predicate, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (thisArg === undefined) {
-                if (!predicate(item, index++, this))
-                    return false;
-            }
-            else {
-                const fn = predicate;
-                if (!fn.call(thisArg, item, index++, this))
-                    return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Tests whether at least one element satisfies the predicate.
-     *
-     * @param predicate Function invoked for each element with signature `(value, index, self)`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns `true` if any element passes; otherwise `false`.
-     *
-     * @remarks
-     * Time O(n) in the worst case; may exit early on first success. Space O(1).
-     */
-    some(predicate, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (thisArg === undefined) {
-                if (predicate(item, index++, this))
-                    return true;
-            }
-            else {
-                const fn = predicate;
-                if (fn.call(thisArg, item, index++, this))
-                    return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Invokes a callback for each element in iteration order.
-     *
-     * @param callbackfn Function invoked per element with signature `(value, index, self)`.
-     * @param thisArg Optional `this` binding for the callback.
-     * @returns `void`.
-     *
-     * @remarks
-     * Time O(n), Space O(1).
-     */
-    forEach(callbackfn, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (thisArg === undefined) {
-                callbackfn(item, index++, this);
-            }
-            else {
-                const fn = callbackfn;
-                fn.call(thisArg, item, index++, this);
-            }
-        }
-    }
-    // Implementation signature
-    find(predicate, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (thisArg === undefined) {
-                if (predicate(item, index++, this))
-                    return item;
-            }
-            else {
-                const fn = predicate;
-                if (fn.call(thisArg, item, index++, this))
-                    return item;
-            }
-        }
-        return;
-    }
-    /**
-     * Checks whether a strictly-equal element exists in the structure.
-     *
-     * @param element The element to test with `===` equality.
-     * @returns `true` if an equal element is found; otherwise `false`.
-     *
-     * @remarks
-     * Time O(n) in the worst case. Space O(1).
-     */
-    has(element) {
-        for (const ele of this)
-            if (ele === element)
-                return true;
-        return false;
-    }
-    /**
-     * Reduces all elements to a single accumulated value.
-     *
-     * @overload
-     * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`. The first element is used as the initial accumulator.
-     * @returns The final accumulated value typed as `E`.
-     *
-     * @overload
-     * @param callbackfn Reducer of signature `(acc, value, index, self) => nextAcc`.
-     * @param initialValue The initial accumulator value of type `E`.
-     * @returns The final accumulated value typed as `E`.
-     *
-     * @overload
-     * @template U The accumulator type when it differs from `E`.
-     * @param callbackfn Reducer of signature `(acc: U, value, index, self) => U`.
-     * @param initialValue The initial accumulator value of type `U`.
-     * @returns The final accumulated value typed as `U`.
-     *
-     * @remarks
-     * Time O(n), Space O(1). Throws if called on an empty structure without `initialValue`.
-     */
-    reduce(callbackfn, initialValue) {
-        let index = 0;
-        const iter = this[Symbol.iterator]();
-        let acc;
-        if (arguments.length >= 2) {
-            acc = initialValue;
-        }
-        else {
-            const first = iter.next();
-            if (first.done)
-                throw new TypeError('Reduce of empty structure with no initial value');
-            acc = first.value;
-            index = 1;
-        }
-        for (const value of iter) {
-            acc = callbackfn(acc, value, index++, this);
-        }
-        return acc;
-    }
-    /**
-     * Materializes the elements into a new array.
-     *
-     * @returns A shallow array copy of the iteration order.
-     * @remarks
-     * Time O(n), Space O(n).
-     */
-    toArray() {
-        return [...this];
-    }
-    /**
-     * Returns a representation of the structure suitable for quick visualization.
-     * Defaults to an array of elements; subclasses may override to provide richer visuals.
-     *
-     * @returns A visual representation (array by default).
-     * @remarks
-     * Time O(n), Space O(n).
-     */
-    toVisual() {
-        return [...this];
-    }
-    /**
-     * Prints `toVisual()` to the console. Intended for quick debugging.
-     *
-     * @returns `void`.
-     * @remarks
-     * Time O(n) due to materialization, Space O(n) for the intermediate representation.
-     */
-    print() {
-        console.log(this.toVisual());
-    }
-}
-exports.IterableElementBase = IterableElementBase;