@holoscript/std 2.1.0 → 6.0.3

package/dist/collections.cjs

@@ -0,0 +1,715 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/collections.ts
+var collections_exports = {};
+__export(collections_exports, {
+  HoloMap: () => HoloMap,
+  HoloSet: () => HoloSet,
+  List: () => List,
+  Map: () => HoloMap,
+  PriorityQueue: () => PriorityQueue,
+  Set: () => HoloSet,
+  SpatialGrid: () => SpatialGrid
+});
+module.exports = __toCommonJS(collections_exports);
+var List = class _List {
+  items;
+  constructor(items = []) {
+    this.items = Array.from(items);
+  }
+  static of(...items) {
+    return new _List(items);
+  }
+  static from(iterable) {
+    return new _List(iterable);
+  }
+  static range(start, end, step = 1) {
+    const items = [];
+    for (let i = start; step > 0 ? i < end : i > end; i += step) {
+      items.push(i);
+    }
+    return new _List(items);
+  }
+  static repeat(value, count) {
+    return new _List(Array(count).fill(value));
+  }
+  get length() {
+    return this.items.length;
+  }
+  get isEmpty() {
+    return this.items.length === 0;
+  }
+  get(index) {
+    return index < 0 ? this.items[this.items.length + index] : this.items[index];
+  }
+  first() {
+    return this.items[0];
+  }
+  last() {
+    return this.items[this.items.length - 1];
+  }
+  map(fn) {
+    return new _List(this.items.map(fn));
+  }
+  flatMap(fn) {
+    const result = [];
+    this.items.forEach((item, index) => {
+      const mapped = fn(item, index);
+      if (mapped instanceof _List) {
+        result.push(...mapped.toArray());
+      } else {
+        result.push(...mapped);
+      }
+    });
+    return new _List(result);
+  }
+  filter(predicate) {
+    return new _List(this.items.filter(predicate));
+  }
+  reject(predicate) {
+    return this.filter((item, index) => !predicate(item, index));
+  }
+  reduce(fn, initial) {
+    return this.items.reduce(fn, initial);
+  }
+  fold(initial, fn) {
+    return this.items.reduce(fn, initial);
+  }
+  find(predicate) {
+    return this.items.find(predicate);
+  }
+  findIndex(predicate) {
+    return this.items.findIndex(predicate);
+  }
+  indexOf(item) {
+    return this.items.indexOf(item);
+  }
+  includes(item) {
+    return this.items.includes(item);
+  }
+  some(predicate) {
+    return this.items.some(predicate);
+  }
+  every(predicate) {
+    return this.items.every(predicate);
+  }
+  none(predicate) {
+    return !this.some(predicate);
+  }
+  count(predicate) {
+    return this.filter(predicate).length;
+  }
+  forEach(fn) {
+    this.items.forEach(fn);
+  }
+  concat(...lists) {
+    const arrays = lists.map((l) => l instanceof _List ? l.toArray() : l);
+    return new _List([...this.items, ...arrays.flat()]);
+  }
+  append(item) {
+    return new _List([...this.items, item]);
+  }
+  prepend(item) {
+    return new _List([item, ...this.items]);
+  }
+  insert(index, item) {
+    const arr = [...this.items];
+    arr.splice(index, 0, item);
+    return new _List(arr);
+  }
+  remove(index) {
+    const arr = [...this.items];
+    arr.splice(index, 1);
+    return new _List(arr);
+  }
+  update(index, item) {
+    const arr = [...this.items];
+    arr[index] = item;
+    return new _List(arr);
+  }
+  slice(start, end) {
+    return new _List(this.items.slice(start, end));
+  }
+  take(n) {
+    return this.slice(0, n);
+  }
+  takeLast(n) {
+    return this.slice(-n);
+  }
+  takeWhile(predicate) {
+    const result = [];
+    for (let i = 0; i < this.items.length; i++) {
+      if (!predicate(this.items[i], i)) break;
+      result.push(this.items[i]);
+    }
+    return new _List(result);
+  }
+  drop(n) {
+    return this.slice(n);
+  }
+  dropLast(n) {
+    return this.slice(0, -n);
+  }
+  dropWhile(predicate) {
+    let startIndex = 0;
+    for (let i = 0; i < this.items.length; i++) {
+      if (!predicate(this.items[i], i)) break;
+      startIndex = i + 1;
+    }
+    return this.slice(startIndex);
+  }
+  reverse() {
+    return new _List([...this.items].reverse());
+  }
+  sort(compareFn) {
+    return new _List([...this.items].sort(compareFn));
+  }
+  sortBy(fn) {
+    return this.sort((a, b) => {
+      const va = fn(a);
+      const vb = fn(b);
+      if (va < vb) return -1;
+      if (va > vb) return 1;
+      return 0;
+    });
+  }
+  shuffle() {
+    const arr = [...this.items];
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return new _List(arr);
+  }
+  unique() {
+    return new _List([...new Set(this.items)]);
+  }
+  uniqueBy(fn) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const item of this.items) {
+      const key = fn(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(item);
+      }
+    }
+    return new _List(result);
+  }
+  groupBy(fn) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of this.items) {
+      const key = fn(item);
+      const group = groups.get(key) || [];
+      group.push(item);
+      groups.set(key, group);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, items] of groups) {
+      result.set(key, new _List(items));
+    }
+    return new HoloMap(result);
+  }
+  partition(predicate) {
+    const pass = [];
+    const fail = [];
+    this.items.forEach((item, index) => {
+      if (predicate(item, index)) {
+        pass.push(item);
+      } else {
+        fail.push(item);
+      }
+    });
+    return [new _List(pass), new _List(fail)];
+  }
+  zip(other) {
+    const length = Math.min(this.length, other.length);
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push([this.items[i], other.get(i)]);
+    }
+    return new _List(result);
+  }
+  zipWith(other, fn) {
+    return this.zip(other).map(([a, b]) => fn(a, b));
+  }
+  flatten() {
+    const result = [];
+    for (const item of this.items) {
+      if (item instanceof _List) {
+        result.push(...item.toArray());
+      } else if (Array.isArray(item)) {
+        result.push(...item);
+      }
+    }
+    return new _List(result);
+  }
+  sum() {
+    return this.reduce((acc, n) => acc + n, 0);
+  }
+  min() {
+    if (this.isEmpty) return void 0;
+    return Math.min(...this.items);
+  }
+  max() {
+    if (this.isEmpty) return void 0;
+    return Math.max(...this.items);
+  }
+  average() {
+    if (this.isEmpty) return void 0;
+    return this.sum() / this.length;
+  }
+  join(separator = ",") {
+    return this.items.join(separator);
+  }
+  toArray() {
+    return [...this.items];
+  }
+  toSet() {
+    return new HoloSet(this.items);
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  toString() {
+    return `List(${this.items.join(", ")})`;
+  }
+};
+var HoloMap = class _HoloMap {
+  _map;
+  constructor(entries) {
+    this._map = entries instanceof Map ? entries : new Map(entries);
+  }
+  static of(...entries) {
+    return new _HoloMap(entries);
+  }
+  static from(entries) {
+    return new _HoloMap(entries);
+  }
+  static fromObject(obj) {
+    return new _HoloMap(Object.entries(obj));
+  }
+  get size() {
+    return this._map.size;
+  }
+  get isEmpty() {
+    return this._map.size === 0;
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  getOrDefault(key, defaultValue) {
+    return this._map.has(key) ? this._map.get(key) : defaultValue;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  set(key, value) {
+    const newMap = new Map(this._map);
+    newMap.set(key, value);
+    return new _HoloMap(newMap);
+  }
+  delete(key) {
+    const newMap = new Map(this._map);
+    newMap.delete(key);
+    return new _HoloMap(newMap);
+  }
+  update(key, fn) {
+    return this.set(key, fn(this.get(key)));
+  }
+  merge(other) {
+    const newMap = new Map(this._map);
+    for (const [key, value] of other) {
+      newMap.set(key, value);
+    }
+    return new _HoloMap(newMap);
+  }
+  keys() {
+    return new List(this._map.keys());
+  }
+  values() {
+    return new List(this._map.values());
+  }
+  entries() {
+    return new List(this._map.entries());
+  }
+  map(fn) {
+    const entries = [];
+    for (const [key, value] of this._map) {
+      entries.push([key, fn(value, key)]);
+    }
+    return new _HoloMap(entries);
+  }
+  mapKeys(fn) {
+    const entries = [];
+    for (const [key, value] of this._map) {
+      entries.push([fn(key, value), value]);
+    }
+    return new _HoloMap(entries);
+  }
+  filter(predicate) {
+    const entries = [];
+    for (const [key, value] of this._map) {
+      if (predicate(value, key)) {
+        entries.push([key, value]);
+      }
+    }
+    return new _HoloMap(entries);
+  }
+  reduce(fn, initial) {
+    let acc = initial;
+    for (const [key, value] of this._map) {
+      acc = fn(acc, value, key);
+    }
+    return acc;
+  }
+  forEach(fn) {
+    this._map.forEach(fn);
+  }
+  find(predicate) {
+    for (const [key, value] of this._map) {
+      if (predicate(value, key)) {
+        return [key, value];
+      }
+    }
+    return void 0;
+  }
+  some(predicate) {
+    for (const [key, value] of this._map) {
+      if (predicate(value, key)) return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const [key, value] of this._map) {
+      if (!predicate(value, key)) return false;
+    }
+    return true;
+  }
+  toObject() {
+    const obj = {};
+    for (const [key, value] of this._map) {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  toNativeMap() {
+    return new Map(this._map);
+  }
+  [Symbol.iterator]() {
+    return this._map[Symbol.iterator]();
+  }
+  toString() {
+    const entries = [...this._map].map(([k, v]) => `${k}: ${v}`).join(", ");
+    return `HoloMap { ${entries} }`;
+  }
+};
+var HoloSet = class _HoloSet {
+  set;
+  constructor(items) {
+    this.set = new Set(items);
+  }
+  static of(...items) {
+    return new _HoloSet(items);
+  }
+  static from(iterable) {
+    return new _HoloSet(iterable);
+  }
+  get size() {
+    return this.set.size;
+  }
+  get isEmpty() {
+    return this.set.size === 0;
+  }
+  has(item) {
+    return this.set.has(item);
+  }
+  add(item) {
+    const newSet = new Set(this.set);
+    newSet.add(item);
+    return new _HoloSet(newSet);
+  }
+  delete(item) {
+    const newSet = new Set(this.set);
+    newSet.delete(item);
+    return new _HoloSet(newSet);
+  }
+  addAll(items) {
+    const newSet = new Set(this.set);
+    for (const item of items) {
+      newSet.add(item);
+    }
+    return new _HoloSet(newSet);
+  }
+  union(other) {
+    return this.addAll(other);
+  }
+  intersection(other) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      if (other.has(item)) {
+        result.add(item);
+      }
+    }
+    return new _HoloSet(result);
+  }
+  difference(other) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      if (!other.has(item)) {
+        result.add(item);
+      }
+    }
+    return new _HoloSet(result);
+  }
+  symmetricDifference(other) {
+    return this.difference(other).union(other.difference(this));
+  }
+  isSubsetOf(other) {
+    for (const item of this.set) {
+      if (!other.has(item)) return false;
+    }
+    return true;
+  }
+  isSupersetOf(other) {
+    return other.isSubsetOf(this);
+  }
+  isDisjointFrom(other) {
+    return this.intersection(other).isEmpty;
+  }
+  map(fn) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      result.add(fn(item));
+    }
+    return new _HoloSet(result);
+  }
+  filter(predicate) {
+    const result = /* @__PURE__ */ new Set();
+    for (const item of this.set) {
+      if (predicate(item)) {
+        result.add(item);
+      }
+    }
+    return new _HoloSet(result);
+  }
+  reduce(fn, initial) {
+    let acc = initial;
+    for (const item of this.set) {
+      acc = fn(acc, item);
+    }
+    return acc;
+  }
+  forEach(fn) {
+    this.set.forEach(fn);
+  }
+  find(predicate) {
+    for (const item of this.set) {
+      if (predicate(item)) return item;
+    }
+    return void 0;
+  }
+  some(predicate) {
+    for (const item of this.set) {
+      if (predicate(item)) return true;
+    }
+    return false;
+  }
+  every(predicate) {
+    for (const item of this.set) {
+      if (!predicate(item)) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return [...this.set];
+  }
+  toList() {
+    return new List(this.set);
+  }
+  toNativeSet() {
+    return new Set(this.set);
+  }
+  [Symbol.iterator]() {
+    return this.set[Symbol.iterator]();
+  }
+  toString() {
+    return `HoloSet { ${[...this.set].join(", ")} }`;
+  }
+};
+var SpatialGrid = class {
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  constructor(cellSize) {
+    this.cellSize = cellSize;
+  }
+  getCellKey(x, y, z) {
+    const cx = Math.floor(x / this.cellSize);
+    const cy = Math.floor(y / this.cellSize);
+    const cz = Math.floor(z / this.cellSize);
+    return `${cx},${cy},${cz}`;
+  }
+  insert(position, item) {
+    const key = this.getCellKey(position.x, position.y, position.z);
+    if (!this.cells.has(key)) {
+      this.cells.set(key, []);
+    }
+    this.cells.get(key).push(item);
+  }
+  remove(position, item) {
+    const key = this.getCellKey(position.x, position.y, position.z);
+    const cell = this.cells.get(key);
+    if (!cell) return false;
+    const index = cell.indexOf(item);
+    if (index === -1) return false;
+    cell.splice(index, 1);
+    if (cell.length === 0) {
+      this.cells.delete(key);
+    }
+    return true;
+  }
+  query(center, radius) {
+    const results = [];
+    const cellRadius = Math.ceil(radius / this.cellSize);
+    const cx = Math.floor(center.x / this.cellSize);
+    const cy = Math.floor(center.y / this.cellSize);
+    const cz = Math.floor(center.z / this.cellSize);
+    for (let x = cx - cellRadius; x <= cx + cellRadius; x++) {
+      for (let y = cy - cellRadius; y <= cy + cellRadius; y++) {
+        for (let z = cz - cellRadius; z <= cz + cellRadius; z++) {
+          const cell = this.cells.get(`${x},${y},${z}`);
+          if (cell) {
+            results.push(...cell);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  queryBox(min, max) {
+    const results = [];
+    const minCx = Math.floor(min.x / this.cellSize);
+    const minCy = Math.floor(min.y / this.cellSize);
+    const minCz = Math.floor(min.z / this.cellSize);
+    const maxCx = Math.floor(max.x / this.cellSize);
+    const maxCy = Math.floor(max.y / this.cellSize);
+    const maxCz = Math.floor(max.z / this.cellSize);
+    for (let x = minCx; x <= maxCx; x++) {
+      for (let y = minCy; y <= maxCy; y++) {
+        for (let z = minCz; z <= maxCz; z++) {
+          const cell = this.cells.get(`${x},${y},${z}`);
+          if (cell) {
+            results.push(...cell);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  clear() {
+    this.cells.clear();
+  }
+  get cellCount() {
+    return this.cells.size;
+  }
+  get itemCount() {
+    let count = 0;
+    for (const cell of this.cells.values()) {
+      count += cell.length;
+    }
+    return count;
+  }
+};
+var PriorityQueue = class _PriorityQueue {
+  constructor(compareFn = (a, b) => a - b) {
+    this.compareFn = compareFn;
+  }
+  heap = [];
+  static minHeap() {
+    return new _PriorityQueue((a, b) => a - b);
+  }
+  static maxHeap() {
+    return new _PriorityQueue((a, b) => b - a);
+  }
+  get size() {
+    return this.heap.length;
+  }
+  get isEmpty() {
+    return this.heap.length === 0;
+  }
+  enqueue(item, priority) {
+    this.heap.push({ item, priority });
+    this.bubbleUp(this.heap.length - 1);
+  }
+  dequeue() {
+    if (this.isEmpty) return void 0;
+    const result = this.heap[0].item;
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.bubbleDown(0);
+    }
+    return result;
+  }
+  peek() {
+    return this.heap[0]?.item;
+  }
+  peekPriority() {
+    return this.heap[0]?.priority;
+  }
+  clear() {
+    this.heap = [];
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.compareFn(this.heap[index].priority, this.heap[parentIndex].priority) >= 0) break;
+      [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
+      index = parentIndex;
+    }
+  }
+  bubbleDown(index) {
+    while (true) {
+      const leftChild = 2 * index + 1;
+      const rightChild = 2 * index + 2;
+      let smallest = index;
+      if (leftChild < this.heap.length && this.compareFn(this.heap[leftChild].priority, this.heap[smallest].priority) < 0) {
+        smallest = leftChild;
+      }
+      if (rightChild < this.heap.length && this.compareFn(this.heap[rightChild].priority, this.heap[smallest].priority) < 0) {
+        smallest = rightChild;
+      }
+      if (smallest === index) break;
+      [this.heap[index], this.heap[smallest]] = [this.heap[smallest], this.heap[index]];
+      index = smallest;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HoloMap,
+  HoloSet,
+  List,
+  Map,
+  PriorityQueue,
+  Set,
+  SpatialGrid
+});
+//# sourceMappingURL=collections.cjs.map