@holoscript/std 2.1.0 → 3.1.1

package/dist/collections.js

@@ -1,720 +0,0 @@
-/**
- * @holoscript/std - Collections Module
- *
- * Provides List, Map, and Set implementations with functional operations
- * for use in HoloScript Plus programs.
- */
-/**
- * Immutable List with functional operations
- */
-export 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 = 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 = 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 = 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 undefined;
-        return Math.min(...this.items);
-    }
-    max() {
-        if (this.isEmpty)
-            return undefined;
-        return Math.max(...this.items);
-    }
-    average() {
-        if (this.isEmpty)
-            return undefined;
-        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(', ')})`;
-    }
-}
-/**
- * Immutable Map with functional operations
- */
-export 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 undefined;
-    }
-    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} }`;
-    }
-}
-/**
- * Immutable Set with functional operations
- */
-export 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 = new Set();
-        for (const item of this.set) {
-            if (other.has(item)) {
-                result.add(item);
-            }
-        }
-        return new HoloSet(result);
-    }
-    difference(other) {
-        const result = 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 = new Set();
-        for (const item of this.set) {
-            result.add(fn(item));
-        }
-        return new HoloSet(result);
-    }
-    filter(predicate) {
-        const result = 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 undefined;
-    }
-    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(', ')} }`;
-    }
-}
-/**
- * Spatial grid for efficient spatial queries (useful for game worlds)
- */
-export class SpatialGrid {
-    cellSize;
-    cells = 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;
-    }
-}
-/**
- * Priority queue (min-heap by default)
- */
-export class PriorityQueue {
-    compareFn;
-    heap = [];
-    constructor(compareFn = (a, b) => a - b) {
-        this.compareFn = compareFn;
-    }
-    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 undefined;
-        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;
-        }
-    }
-}
-// Convenience aliases
-export { HoloMap as Map };
-export { HoloSet as Set };
-//# sourceMappingURL=collections.js.map