@limitlesspc/std 0.21.1 → 0.23.0

package/dist/structs/index.js

@@ -1,24 +1,238 @@
 import {
-  DoublyLinkedList,
-  LinkedList,
-  MaxHeap,
-  MinHeap,
-  Queue,
-  SortedArray,
-  UnorderedArray
-} from "../chunk-DYKZK6B5.js";
-import "../chunk-65SNM7MP.js";
-import "../chunk-WBSY6KRH.js";
-import "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
-import "../chunk-TMLWLR46.js";
+  swap
+} from "../chunk-4POIKW4G.js";
+import "../chunk-CCBSTDYA.js";
+import "../chunk-NXILTE26.js";
+import {
+  ascend
+} from "../chunk-TMLWLR46.js";
 import "../chunk-LJSF3QBT.js";
+
+// src/structs/heap.ts
+var Heap = class _Heap {
+  constructor(compare, data = [], heapify = true) {
+    this.compare = compare;
+    if (heapify) {
+      this.data = [];
+      this.push(...data);
+    } else {
+      this.data = data;
+    }
+  }
+  data;
+  get length() {
+    return this.data.length;
+  }
+  get height() {
+    return Math.floor(Math.log2(this.length)) + 1;
+  }
+  valueOf() {
+    return this.peek();
+  }
+  copy() {
+    return new _Heap(this.compare, [...this.data], false);
+  }
+  /**
+   * Returns the first value in the heap
+   */
+  peek() {
+    return this.data[0];
+  }
+  /**
+   * Removes the first value from the heap and returns it
+   */
+  pop() {
+    const first = this.data[0];
+    swap(this.data, 0, this.length - 1);
+    this.data.pop();
+    this.heapify();
+    return first;
+  }
+  /**
+   * Inserts values into the heap and makes sure the first value is the min/max
+   * @param values
+   * @returns The new length of the heap
+   */
+  push(...values) {
+    const { data, compare } = this;
+    for (const value of values) {
+      data.push(value);
+      let i = data.length - 1;
+      let parent = Math.floor((i - 1) / 2);
+      while (i > 0 && compare(data[i], data[parent]) < 0) {
+        swap(data, i, parent);
+        i = parent;
+        parent = Math.floor((i - 1) / 2);
+      }
+    }
+    return data.length;
+  }
+  *drain() {
+    while (this.length) {
+      yield this.pop();
+    }
+  }
+  [Symbol.iterator]() {
+    return this.data.values();
+  }
+  heapify(i = 0) {
+    const { length, compare, data } = this;
+    const left = 2 * i + 1;
+    const right = 2 * i + 2;
+    let largest = i;
+    if (left < length && compare(data[left], data[largest]) < 0) {
+      largest = left;
+    }
+    if (right < length && compare(data[right], data[largest]) < 0) {
+      largest = right;
+    }
+    if (largest !== i) {
+      swap(data, i, largest);
+      this.heapify(largest);
+    }
+  }
+};
+
+// src/structs/sorted-array.ts
+var SortedArray = class _SortedArray {
+  constructor(data = [], compare = ascend, sort = true) {
+    this.data = data;
+    this.compare = compare;
+    if (sort) {
+      this.data.sort(compare);
+    }
+  }
+  valueOf() {
+    return this.at(0);
+  }
+  keys() {
+    return this.data.keys();
+  }
+  values() {
+    return this.data.values();
+  }
+  entries() {
+    return this.data.entries();
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  length() {
+    return this.data.length;
+  }
+  at(index) {
+    return this.data[index];
+  }
+  copy() {
+    return new _SortedArray([...this.data], this.compare, false);
+  }
+  /**
+   * Returns the index of the value if it exists, otherwise -1
+   * @param value
+   */
+  indexOf(value) {
+    const { data } = this;
+    let low = 0;
+    let high = data.length - 1;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const cmp = this.compare(value, data[mid]);
+      if (cmp < 0) {
+        high = mid - 1;
+      } else if (cmp > 0) {
+        low = mid + 1;
+      } else {
+        return mid;
+      }
+    }
+    return -1;
+  }
+  /**
+   * Returns if the array has the value
+   * @param value
+   */
+  has(value) {
+    return this.indexOf(value) !== -1;
+  }
+  /**
+   * Binary inserts a value into the array while maintaining sorted order
+   * @param value
+   * @returns the index of where the value was inserted
+   */
+  push(value) {
+    const { data, compare } = this;
+    let low = 0;
+    let high = data.length - 1;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const cmp = compare(value, data[mid]);
+      if (cmp < 0) {
+        high = mid - 1;
+      } else if (cmp > 0) {
+        low = mid + 1;
+      } else {
+        data.splice(mid, 0, value);
+        return mid;
+      }
+    }
+    data.splice(low, 0, value);
+    return low;
+  }
+};
+
+// src/structs/unordered-array.ts
+var UnorderedArray = class _UnorderedArray extends Array {
+  copy() {
+    return new _UnorderedArray(...this);
+  }
+  /**
+   * Inserts new elements at the end of an unordered array, and returns the new length of the unordered array.
+   * @param items Elements to insert at the end of the array.
+   */
+  unshift(...items) {
+    return super.push(...items);
+  }
+  /**
+   * Removes the last element from an array and returns it.
+   * If the array is empty, undefined is returned and the array is not modified.
+   */
+  shift() {
+    return super.pop();
+  }
+  /**
+   * Removes an item by index
+   * @param index the index of the item to remove
+   * @returns the removed item, if it exists
+   */
+  removeIndex(index) {
+    swap(this, index, this.length - 1);
+    return this.pop();
+  }
+  splice(start, deleteCount = this.length - start, ...items) {
+    const spliced = [];
+    for (let i = 0; i < deleteCount; i++) {
+      const replacement = items[i];
+      let removed;
+      if (replacement) {
+        removed = this[start + i];
+        this[start + i] = replacement;
+      } else {
+        removed = this.removeIndex(start);
+      }
+      if (removed) {
+        spliced.push(removed);
+      }
+    }
+    return spliced;
+  }
+  toSpliced(start, deleteCount = this.length - start, ...items) {
+    const copy = this.copy();
+    copy.splice(start, deleteCount, ...items);
+    return copy;
+  }
+};
 export {
-  DoublyLinkedList,
-  LinkedList,
-  MaxHeap,
-  MinHeap,
-  Queue,
+  Heap,
   SortedArray,
   UnorderedArray
 };

package/dist/types.js

@@ -1 +0,0 @@
-import "./chunk-6F4PWJZI.js";

package/dist/{vec3-S_YuL-W1.d.ts → vec3-BQ6mZ-wg.d.ts}

@@ -1,25 +1,14 @@
-interface Vec extends Float32Array {
-    toString: () => string;
-    copy: () => Vec;
-    mag: () => number;
-    setMag: (n: number) => this;
-    magSq: () => number;
-    limit: (max: number) => this;
-    normalize: () => this;
+interface ReadonlyVec3Like {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
 }
-
-type Vec3Like = [x: number, y: number, z: number] | Float32Array;
-type ReadonlyVec3Like = Readonly<Vec3Like>;
 type First = ReadonlyVec3Like | number;
-declare class Vec3 extends Float32Array implements Vec {
-    static readonly BYTE_LENGTH: number;
+declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
     constructor(x?: First, y?: number, z?: number);
-    get x(): number;
-    set x(value: number);
-    get y(): number;
-    set y(value: number);
-    get z(): number;
-    set z(value: number);
     get r(): number;
     set r(value: number);
     get g(): number;
@@ -30,6 +19,7 @@ declare class Vec3 extends Float32Array implements Vec {
     copy(): Vec3;
     static random(mag?: number): Vec3;
     eq(x: First, y?: number, z?: number): boolean;
+    set(x: First, y?: number, z?: number): this;
     neg(): Vec3;
     add(x: First, y?: number, z?: number): this;
     static add(v1: Vec3, x: First, y?: number, z?: number): Vec3;
@@ -40,10 +30,10 @@ declare class Vec3 extends Float32Array implements Vec {
     div(x: First, y?: number, z?: number): this;
     static div(v1: Vec3, x: First, y?: number, z?: number): Vec3;
     static fma(a: ReadonlyVec3Like, b: ReadonlyVec3Like, c: ReadonlyVec3Like): Vec3;
-    lt(x: ReadonlyVec3Like): Vec3;
-    lte(x: ReadonlyVec3Like): Vec3;
-    gt(x: ReadonlyVec3Like): Vec3;
-    gte(x: ReadonlyVec3Like): Vec3;
+    lt(v: ReadonlyVec3Like): Vec3;
+    lte(v: ReadonlyVec3Like): Vec3;
+    gt(v: ReadonlyVec3Like): Vec3;
+    gte(v: ReadonlyVec3Like): Vec3;
     limit(max: number): this;
     normalize(): this;
     static normalize(v: Vec3): Vec3;
@@ -67,4 +57,4 @@ declare class Vec3 extends Float32Array implements Vec {
 }
 declare function vec3(x?: First, y?: number, z?: number): Vec3;
 
-export { type ReadonlyVec3Like as R, type Vec as V, type Vec3Like as a, Vec3 as b, vec3 as v };
+export { type ReadonlyVec3Like as R, Vec3 as V, vec3 as v };

package/package.json

@@ -1,85 +1,78 @@
 {
   "name": "@limitlesspc/std",
   "type": "module",
-  "version": "0.21.1",
+  "version": "0.23.0",
   "description": "A standard library for JavaScript",
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
   "exports": {
     "./package.json": "./package.json",
     "./async": {
-      "default": "./dist/async/index.js",
-      "types": "./dist/async/index.d.ts"
+      "types": "./dist/async/index.d.ts",
+      "default": "./dist/async/index.js"
     },
     "./cmath": {
-      "default": "./dist/cmath/index.js",
-      "types": "./dist/cmath/index.d.ts"
+      "types": "./dist/cmath/index.d.ts",
+      "default": "./dist/cmath/index.js"
     },
     "./fn": {
-      "default": "./dist/fn/index.js",
-      "types": "./dist/fn/index.d.ts"
+      "types": "./dist/fn/index.d.ts",
+      "default": "./dist/fn/index.js"
     },
     "./gfx": {
-      "default": "./dist/gfx/index.js",
-      "types": "./dist/gfx/index.d.ts"
+      "types": "./dist/gfx/index.d.ts",
+      "default": "./dist/gfx/index.js"
     },
     "./iter": {
-      "default": "./dist/iter/index.js",
-      "types": "./dist/iter/index.d.ts"
+      "types": "./dist/iter/index.d.ts",
+      "default": "./dist/iter/index.js"
     },
     "./math": {
-      "default": "./dist/math/index.js",
-      "types": "./dist/math/index.d.ts"
+      "types": "./dist/math/index.d.ts",
+      "default": "./dist/math/index.js"
     },
     "./string": {
-      "default": "./dist/string/index.js",
-      "types": "./dist/string/index.d.ts"
+      "types": "./dist/string/index.d.ts",
+      "default": "./dist/string/index.js"
     },
     "./structs": {
-      "default": "./dist/structs/index.js",
-      "types": "./dist/structs/index.d.ts"
+      "types": "./dist/structs/index.d.ts",
+      "default": "./dist/structs/index.js"
     },
     "./time": {
-      "default": "./dist/time/index.js",
-      "types": "./dist/time/index.d.ts"
+      "types": "./dist/time/index.d.ts",
+      "default": "./dist/time/index.js"
     },
     "./array": {
-      "default": "./dist/array.js",
-      "types": "./dist/array.d.ts"
+      "types": "./dist/array.d.ts",
+      "default": "./dist/array.js"
     },
     "./bytes": {
-      "default": "./dist/bytes.js",
-      "types": "./dist/bytes.d.ts"
+      "types": "./dist/bytes.d.ts",
+      "default": "./dist/bytes.js"
     },
     "./cmp": {
-      "default": "./dist/cmp.js",
-      "types": "./dist/cmp.d.ts"
+      "types": "./dist/cmp.d.ts",
+      "default": "./dist/cmp.js"
     },
     "./csv": {
-      "default": "./dist/csv.js",
-      "types": "./dist/csv.d.ts"
-    },
-    "./easing": {
-      "default": "./dist/easing.js",
-      "types": "./dist/easing.d.ts"
+      "types": "./dist/csv.d.ts",
+      "default": "./dist/csv.js"
     },
     "./events": {
-      "default": "./dist/events.js",
-      "types": "./dist/events.d.ts"
+      "types": "./dist/events.d.ts",
+      "default": "./dist/events.js"
     },
     "./object": {
-      "default": "./dist/object.js",
-      "types": "./dist/object.d.ts"
+      "types": "./dist/object.d.ts",
+      "default": "./dist/object.js"
     },
     "./random": {
-      "default": "./dist/random.js",
-      "types": "./dist/random.d.ts"
+      "types": "./dist/random.d.ts",
+      "default": "./dist/random.js"
     },
     "./types": {
-      "default": "./dist/types.js",
-      "types": "./dist/types.d.ts"
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
     }
   },
   "files": [
@@ -87,22 +80,25 @@
   ],
   "prettier": "@limitlesspc/prettier-config",
   "devDependencies": {
-    "@limitlesspc/eslint-config": "^0.16.2",
-    "@limitlesspc/prettier-config": "^1.1.1",
-    "bumpp": "^9.8.1",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.6"
+    "@limitlesspc/eslint-config": "^0.18.4",
+    "@limitlesspc/prettier-config": "^1.2.1",
+    "@vitest/coverage-v8": "^4.0.16",
+    "bumpp": "^10.3.2",
+    "eslint": "^9.39.2",
+    "prettier": "^3.7.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
   },
   "scripts": {
     "build": "tsup",
-    "test": "vitest",
     "fmt": "prettier . --write --cache --ignore-unknown",
     "fmt:check": "prettier . --check --cache --ignore-unknown",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "lint:fix-dry": "eslint --fix-dry-run",
-    "check-exports": "attw --pack . --ignore-rules=cjs-resolves-to-esm",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
     "release": "bumpp && pnpm publish",
     "typecheck": "tsc --noEmit"
   }