@holoscript/std 2.1.0 → 3.1.1

package/dist/collections.d.ts

@@ -1,177 +0,0 @@
-/**
- * @holoscript/std - Collections Module
- *
- * Provides List, Map, and Set implementations with functional operations
- * for use in HoloScript Plus programs.
- */
-import type { Vec3 } from './types.js';
-/**
- * Immutable List with functional operations
- */
-export declare class List<T> {
-    private readonly items;
-    constructor(items?: Iterable<T>);
-    static of<T>(...items: T[]): List<T>;
-    static from<T>(iterable: Iterable<T>): List<T>;
-    static range(start: number, end: number, step?: number): List<number>;
-    static repeat<T>(value: T, count: number): List<T>;
-    get length(): number;
-    get isEmpty(): boolean;
-    get(index: number): T | undefined;
-    first(): T | undefined;
-    last(): T | undefined;
-    map<U>(fn: (item: T, index: number) => U): List<U>;
-    flatMap<U>(fn: (item: T, index: number) => List<U> | U[]): List<U>;
-    filter(predicate: (item: T, index: number) => boolean): List<T>;
-    reject(predicate: (item: T, index: number) => boolean): List<T>;
-    reduce<U>(fn: (acc: U, item: T, index: number) => U, initial: U): U;
-    fold<U>(initial: U, fn: (acc: U, item: T) => U): U;
-    find(predicate: (item: T, index: number) => boolean): T | undefined;
-    findIndex(predicate: (item: T, index: number) => boolean): number;
-    indexOf(item: T): number;
-    includes(item: T): boolean;
-    some(predicate: (item: T, index: number) => boolean): boolean;
-    every(predicate: (item: T, index: number) => boolean): boolean;
-    none(predicate: (item: T, index: number) => boolean): boolean;
-    count(predicate: (item: T, index: number) => boolean): number;
-    forEach(fn: (item: T, index: number) => void): void;
-    concat(...lists: (List<T> | T[])[]): List<T>;
-    append(item: T): List<T>;
-    prepend(item: T): List<T>;
-    insert(index: number, item: T): List<T>;
-    remove(index: number): List<T>;
-    update(index: number, item: T): List<T>;
-    slice(start?: number, end?: number): List<T>;
-    take(n: number): List<T>;
-    takeLast(n: number): List<T>;
-    takeWhile(predicate: (item: T, index: number) => boolean): List<T>;
-    drop(n: number): List<T>;
-    dropLast(n: number): List<T>;
-    dropWhile(predicate: (item: T, index: number) => boolean): List<T>;
-    reverse(): List<T>;
-    sort(compareFn?: (a: T, b: T) => number): List<T>;
-    sortBy<U>(fn: (item: T) => U): List<T>;
-    shuffle(): List<T>;
-    unique(): List<T>;
-    uniqueBy<U>(fn: (item: T) => U): List<T>;
-    groupBy<K>(fn: (item: T) => K): HoloMap<K, List<T>>;
-    partition(predicate: (item: T, index: number) => boolean): [List<T>, List<T>];
-    zip<U>(other: List<U>): List<[T, U]>;
-    zipWith<U, V>(other: List<U>, fn: (a: T, b: U) => V): List<V>;
-    flatten<U>(this: List<List<U> | U[]>): List<U>;
-    sum(this: List<number>): number;
-    min(this: List<number>): number | undefined;
-    max(this: List<number>): number | undefined;
-    average(this: List<number>): number | undefined;
-    join(separator?: string): string;
-    toArray(): T[];
-    toSet(): HoloSet<T>;
-    [Symbol.iterator](): Iterator<T>;
-    toString(): string;
-}
-/**
- * Immutable Map with functional operations
- */
-export declare class HoloMap<K, V> {
-    private readonly _map;
-    constructor(entries?: Iterable<[K, V]> | Map<K, V>);
-    static of<K, V>(...entries: [K, V][]): HoloMap<K, V>;
-    static from<K, V>(entries: Iterable<[K, V]>): HoloMap<K, V>;
-    static fromObject<V>(obj: Record<string, V>): HoloMap<string, V>;
-    get size(): number;
-    get isEmpty(): boolean;
-    get(key: K): V | undefined;
-    getOrDefault(key: K, defaultValue: V): V;
-    has(key: K): boolean;
-    set(key: K, value: V): HoloMap<K, V>;
-    delete(key: K): HoloMap<K, V>;
-    update(key: K, fn: (value: V | undefined) => V): HoloMap<K, V>;
-    merge(other: HoloMap<K, V>): HoloMap<K, V>;
-    keys(): List<K>;
-    values(): List<V>;
-    entries(): List<[K, V]>;
-    map<U>(fn: (value: V, key: K) => U): HoloMap<K, U>;
-    mapKeys<K2>(fn: (key: K, value: V) => K2): HoloMap<K2, V>;
-    filter(predicate: (value: V, key: K) => boolean): HoloMap<K, V>;
-    reduce<U>(fn: (acc: U, value: V, key: K) => U, initial: U): U;
-    forEach(fn: (value: V, key: K) => void): void;
-    find(predicate: (value: V, key: K) => boolean): [K, V] | undefined;
-    some(predicate: (value: V, key: K) => boolean): boolean;
-    every(predicate: (value: V, key: K) => boolean): boolean;
-    toObject(this: HoloMap<string, V>): Record<string, V>;
-    toNativeMap(): Map<K, V>;
-    [Symbol.iterator](): Iterator<[K, V]>;
-    toString(): string;
-}
-/**
- * Immutable Set with functional operations
- */
-export declare class HoloSet<T> {
-    private readonly set;
-    constructor(items?: Iterable<T>);
-    static of<T>(...items: T[]): HoloSet<T>;
-    static from<T>(iterable: Iterable<T>): HoloSet<T>;
-    get size(): number;
-    get isEmpty(): boolean;
-    has(item: T): boolean;
-    add(item: T): HoloSet<T>;
-    delete(item: T): HoloSet<T>;
-    addAll(items: Iterable<T>): HoloSet<T>;
-    union(other: HoloSet<T>): HoloSet<T>;
-    intersection(other: HoloSet<T>): HoloSet<T>;
-    difference(other: HoloSet<T>): HoloSet<T>;
-    symmetricDifference(other: HoloSet<T>): HoloSet<T>;
-    isSubsetOf(other: HoloSet<T>): boolean;
-    isSupersetOf(other: HoloSet<T>): boolean;
-    isDisjointFrom(other: HoloSet<T>): boolean;
-    map<U>(fn: (item: T) => U): HoloSet<U>;
-    filter(predicate: (item: T) => boolean): HoloSet<T>;
-    reduce<U>(fn: (acc: U, item: T) => U, initial: U): U;
-    forEach(fn: (item: T) => void): void;
-    find(predicate: (item: T) => boolean): T | undefined;
-    some(predicate: (item: T) => boolean): boolean;
-    every(predicate: (item: T) => boolean): boolean;
-    toArray(): T[];
-    toList(): List<T>;
-    toNativeSet(): Set<T>;
-    [Symbol.iterator](): Iterator<T>;
-    toString(): string;
-}
-/**
- * Spatial grid for efficient spatial queries (useful for game worlds)
- */
-export declare class SpatialGrid<T> {
-    private readonly cellSize;
-    private readonly cells;
-    constructor(cellSize: number);
-    private getCellKey;
-    insert(position: Vec3, item: T): void;
-    remove(position: Vec3, item: T): boolean;
-    query(center: Vec3, radius: number): T[];
-    queryBox(min: Vec3, max: Vec3): T[];
-    clear(): void;
-    get cellCount(): number;
-    get itemCount(): number;
-}
-/**
- * Priority queue (min-heap by default)
- */
-export declare class PriorityQueue<T> {
-    private compareFn;
-    private heap;
-    constructor(compareFn?: (a: number, b: number) => number);
-    static minHeap<T>(): PriorityQueue<T>;
-    static maxHeap<T>(): PriorityQueue<T>;
-    get size(): number;
-    get isEmpty(): boolean;
-    enqueue(item: T, priority: number): void;
-    dequeue(): T | undefined;
-    peek(): T | undefined;
-    peekPriority(): number | undefined;
-    clear(): void;
-    private bubbleUp;
-    private bubbleDown;
-}
-export { HoloMap as Map };
-export { HoloSet as Set };
-//# sourceMappingURL=collections.d.ts.map