@xtia/grid 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aleta Lovelace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/grid.d.ts

@@ -0,0 +1,108 @@
+import { Pipe2D } from "@xtia/pipe2d";
+import { Angle, GetXYFunc, Source2D } from "./utils.js";
+type ChangeEvent<T> = {
+    changedCells: Set<Cell<T>>;
+};
+type EventMap<T> = {
+    change: ChangeEvent<T>;
+};
+type PathFindOptions<T> = {
+    maxCost?: number;
+    allowDiagonal?: boolean;
+    onVisit?: (info: {
+        cell: Cell<T>;
+        cost: number;
+    }) => void;
+    shortcutMap?: Source2D<Cell<T>[] | undefined>;
+};
+type CostMapOptions<T> = PathFindOptions<T> & {
+    stopAt?: [number, number] | Cell<T>;
+};
+export declare enum TraversalType {
+    cardinal = 0,
+    diagonal = 1,
+    shortcut = 2
+}
+type CostFunc<T> = (cell: Cell<T>, context: {
+    traversalType: TraversalType;
+    from: Cell<T>;
+}) => number;
+export declare enum Visibility {
+    visible = 0,
+    hidden = 1,
+    wall = 2
+}
+export declare class Cell<T> {
+    readonly x: number;
+    readonly y: number;
+    private gridView;
+    constructor(x: number, y: number, gridView: Grid<T>);
+    get value(): T;
+    set value(v: T);
+    getNeighbours(includeDiagonals?: boolean): Cell<T>[];
+    look(xDelta: number, yDelta: number): Cell<T> | undefined;
+    findPath(target: Cell<T> | [number, number], getCost: CostFunc<T>, options?: PathFindOptions<T>): Cell<T>[] | null;
+    getPathMap(getCost: CostFunc<T>, options?: PathFindOptions<T>): Pipe2D<Cell<T>[] | null>;
+    getCostMap(getCost: CostFunc<T>, options?: CostMapOptions<T>): Pipe2D<number>;
+    private calculateCosts;
+    getLineTo(target: {
+        x: number;
+        y: number;
+    } | [number, number]): IterableIterator<Cell<T>>;
+    createVisibilityMap(isWall: (cell: Cell<T>) => boolean, maxDistance?: number): Pipe2D<Visibility>;
+}
+export declare class Grid<T> {
+    readonly width: number;
+    readonly height: number;
+    private batch;
+    private parentGet;
+    private parentSet;
+    readonly cells: Pipe2D<Cell<T>>;
+    protected constructor(width: number, height: number, get: GetXYFunc<T>, set: (x: number, y: number, value: T) => void, batch: (cb: () => void) => void);
+    private writeMasks;
+    pipe: Pipe2D<T>;
+    private isWritable;
+    batchUpdate(fn: () => void): void;
+    get(x: number, y: number): T;
+    set(x: number, y: number, value: T): void;
+    trySet(x: number, y: number, value: T): boolean;
+    fill(value: T): void;
+    paste(x: number, y: number, source: Source2D<T>): void;
+    applyWriteMask(mask: Source2D<boolean>): () => void;
+    [Symbol.iterator](): IterableIterator<{
+        x: number;
+        y: number;
+        value: T;
+    }>;
+    forEach(callback: (value: T, x: number, y: number) => void): void;
+    getVisibilityMap(originX: number, originY: number, maxDistance: number, isWall: (value: T, x: number, y: number) => boolean, options?: {
+        startAngle?: Angle;
+        endAngle?: Angle;
+        includeWalls?: boolean;
+        angleStep?: Angle;
+    }): Pipe2D<boolean>;
+    getFloodMap(startX: number, startY: number, predicate: (value: T, x: number, y: number, initialValue: T) => boolean, options?: {
+        includeDiagonals?: boolean;
+        maxDistance?: number;
+    }): Pipe2D<boolean>;
+    combine<U, R>(aux: Source2D<U>, cb: (source: T, aux: U) => R): GridBase<R>;
+    map<U>(read: (initial: T, x: number, y: number) => U, write: (local: U, x: number, y: number) => T): Grid<U>;
+    region(x: number, y: number, width: number, height: number): Grid<T>;
+    static init<T>(width: number, height: number, initCell: () => T): GridBase<T>;
+    static from<T>(source: Source2D<T>): GridBase<T>;
+    static solid<T>(width: number, height: number, fillValue: T): GridBase<T>;
+}
+export declare class GridBase<T> extends Grid<T> {
+    private data;
+    private eventHandlers;
+    private triggerEvent;
+    private batchState;
+    batchUpdate(fn: () => void): void;
+    constructor(source: Source2D<T>);
+    constructor(width: number, height: number, cellInit: GetXYFunc<T>);
+    on<K extends keyof EventMap<T>>(eventName: K, handler: (data: EventMap<T>[K]) => void): () => void;
+    private xyToIndex;
+    private _set;
+    private triggerChange;
+}
+export {};

package/lib/grid.js

@@ -0,0 +1,470 @@
+import { Pipe2D } from "@xtia/pipe2d";
+import { angleToRadians, OrderedQueue } from "./utils.js";
+export var TraversalType;
+(function (TraversalType) {
+    TraversalType[TraversalType["cardinal"] = 0] = "cardinal";
+    TraversalType[TraversalType["diagonal"] = 1] = "diagonal";
+    TraversalType[TraversalType["shortcut"] = 2] = "shortcut";
+})(TraversalType || (TraversalType = {}));
+export var Visibility;
+(function (Visibility) {
+    Visibility[Visibility["visible"] = 0] = "visible";
+    Visibility[Visibility["hidden"] = 1] = "hidden";
+    Visibility[Visibility["wall"] = 2] = "wall";
+})(Visibility || (Visibility = {}));
+export class Cell {
+    constructor(x, y, gridView) {
+        this.x = x;
+        this.y = y;
+        this.gridView = gridView;
+    }
+    get value() {
+        return this.gridView.get(this.x, this.y);
+    }
+    set value(v) {
+        this.gridView.set(this.x, this.y, v);
+    }
+    getNeighbours(includeDiagonals = false) {
+        const offsets = includeDiagonals
+            ? [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]]
+            : [[-1, 0], [1, 0], [0, -1], [0, 1]];
+        return offsets
+            .map(([ox, oy]) => [ox + this.x, oy + this.y])
+            .filter(([tx, ty]) => tx >= 0 && tx < this.gridView.width && ty >= 0 && ty < this.gridView.height)
+            .map(([tx, ty]) => this.gridView.cells.get(tx, ty));
+    }
+    look(xDelta, yDelta) {
+        const [x, y] = [this.x + xDelta, this.y + yDelta];
+        if (x < 0 || x >= this.gridView.width || y < 0 || y >= this.gridView.height)
+            return undefined;
+        return this.gridView.cells.get(xDelta + this.x, yDelta + this.y);
+    }
+    findPath(target, getCost, options = {}) {
+        const targetXY = Array.isArray(target)
+            ? target
+            : [target.x, target.y];
+        const pathMap = this.calculateCosts(getCost, {
+            stopAt: targetXY,
+            allowDiagonal: options.allowDiagonal,
+            maxCost: options.maxCost,
+        }, true);
+        return pathMap === null || pathMap === void 0 ? void 0 : pathMap.get(...targetXY);
+    }
+    getPathMap(getCost, options = {}) {
+        return this.calculateCosts(getCost, options, true);
+    }
+    getCostMap(getCost, options = {}) {
+        return this.calculateCosts(getCost, options);
+    }
+    calculateCosts(getCost, options, asPathMap = false) {
+        var _a, _b;
+        var _c;
+        const visited = new Set();
+        const costs = new Map();
+        const maxCost = (_c = options.maxCost) !== null && _c !== void 0 ? _c : Infinity;
+        const pathInfo = asPathMap
+            ? new Map()
+            : null;
+        costs.set(this, 0);
+        const queue = new OrderedQueue(cell => { var _a; return (_a = costs.get(cell)) !== null && _a !== void 0 ? _a : Infinity; }, this);
+        const targetCell = Array.isArray(options.stopAt)
+            ? this.gridView.cells.get(options.stopAt[0], options.stopAt[1])
+            : options.stopAt;
+        if (targetCell && targetCell.gridView !== this.gridView) {
+            throw new Error("Target cell belongs to a different Grid");
+        }
+        while (queue.length > 0) {
+            const current = queue.take();
+            (_a = options.onVisit) === null || _a === void 0 ? void 0 : _a.call(options, { cell: current, cost: costs.get(current) });
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            if (targetCell && current === targetCell) {
+                break;
+            }
+            const currentCost = costs.get(current);
+            const neighbours = current.getNeighbours(options.allowDiagonal).map(cell => ({
+                traversalType: cell.x == current.x && cell.y == current.y ? TraversalType.cardinal : TraversalType.diagonal,
+                cell
+            }));
+            if (options.shortcutMap) {
+                const shortcuts = (_b = options.shortcutMap.get(current.x, current.y)) === null || _b === void 0 ? void 0 : _b.map(cell => ({
+                    traversalType: TraversalType.shortcut,
+                    cell
+                }));
+                if (shortcuts)
+                    neighbours.push(...shortcuts);
+            }
+            neighbours.forEach(n => {
+                var _a;
+                if (visited.has(n.cell))
+                    return;
+                const moveCost = getCost(n.cell, {
+                    traversalType: n.traversalType,
+                    from: current,
+                });
+                if (moveCost === Infinity)
+                    return;
+                const newCost = currentCost + moveCost;
+                const oldCost = (_a = costs.get(n.cell)) !== null && _a !== void 0 ? _a : Infinity;
+                if (newCost < oldCost && newCost <= maxCost) {
+                    costs.set(n.cell, newCost);
+                    pathInfo === null || pathInfo === void 0 ? void 0 : pathInfo.set(n.cell, current);
+                    queue.add(n.cell);
+                }
+            });
+        }
+        if (pathInfo) {
+            const cache = new Map();
+            return this.gridView.cells.map(targetCell => {
+                if (targetCell === this)
+                    return [];
+                if (cache.has(targetCell))
+                    return cache.get(targetCell);
+                if (!pathInfo.has(targetCell))
+                    return null;
+                let current = targetCell;
+                let path = [];
+                while (current !== this) {
+                    if (cache.has(current)) {
+                        path.unshift(...cache.get(current));
+                        cache.set(targetCell, path);
+                        return path;
+                    }
+                    path.unshift(current);
+                    current = pathInfo.get(current);
+                }
+                cache.set(targetCell, path);
+                return path;
+            });
+        }
+        return this.gridView.cells.map((c => { var _a; return (_a = costs.get(c)) !== null && _a !== void 0 ? _a : Infinity; }))
+            .strict();
+    }
+    *getLineTo(target) {
+        const [targetX, targetY] = Array.isArray(target)
+            ? target
+            : [target.x, target.y];
+        if (this.x === targetX && this.y === targetY) {
+            yield this;
+            return;
+        }
+        const dx = Math.abs(targetX - this.x);
+        const dy = Math.abs(targetY - this.y);
+        const sx = this.x < targetX ? 1 : -1;
+        const sy = this.y < targetY ? 1 : -1;
+        let err = dx - dy;
+        let x = this.x;
+        let y = this.y;
+        while (true) {
+            const cell = this.gridView.cells.get(x, y);
+            if (cell) {
+                yield cell;
+            }
+            if (x === targetX && y === targetY) {
+                break;
+            }
+            const e2 = 2 * err;
+            if (e2 > -dy) {
+                err -= dy;
+                x += sx;
+            }
+            if (e2 < dx) {
+                err += dx;
+                y += sy;
+            }
+        }
+    }
+    createVisibilityMap(isWall, maxDistance = Infinity) {
+        return new Pipe2D(this.gridView.width, this.gridView.height, (x, y) => {
+            const distance = getDistance(this, { x, y });
+            if (distance > maxDistance) {
+                return Visibility.hidden;
+            }
+            for (const cell of this.getLineTo({ x, y })) {
+                if (isWall(cell)) {
+                    if (cell.x === this.x && cell.y === this.y) {
+                        continue;
+                    }
+                    if (cell.x === x && cell.y === y) {
+                        return Visibility.wall;
+                    }
+                    return Visibility.hidden;
+                }
+            }
+            return Visibility.visible;
+        });
+    }
+}
+function getDistance(c1, c2) {
+    return Math.sqrt(Math.pow(c2.x - c1.x, 2) + Math.pow(c2.y - c1.y, 2));
+}
+export class Grid {
+    constructor(width, height, get, set, batch) {
+        this.width = width;
+        this.height = height;
+        this.batch = batch;
+        this.cells = new Pipe2D(this.width, this.height, (x, y) => {
+            return new Cell(x, y, this);
+        }).strict().withCache();
+        this.writeMasks = [];
+        this.pipe = new Pipe2D(this);
+        this.parentGet = get;
+        this.parentSet = set;
+    }
+    isWritable(x, y) {
+        return !this.writeMasks.some(mask => !mask.mask.get(x, y));
+    }
+    batchUpdate(fn) {
+        this.batch(fn);
+    }
+    get(x, y) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
+            throw new RangeError("Coordinates out of bounds");
+        }
+        return this.parentGet(x, y);
+    }
+    set(x, y, value) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
+            throw new RangeError("Coordinates out of bounds");
+        }
+        if (this.isWritable(x, y))
+            this.parentSet(x, y, value);
+    }
+    trySet(x, y, value) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+            return false;
+        this.set(x, y, value);
+        return true;
+    }
+    fill(value) {
+        this.batchUpdate(() => {
+            for (let y = 0; y < this.height; y++) {
+                for (let x = 0; x < this.width; x++) {
+                    const tx = x;
+                    const ty = y;
+                    this.trySet(tx, ty, value);
+                }
+            }
+        });
+    }
+    paste(x, y, source) {
+        const cachedSource = new GridBase(source);
+        this.batchUpdate(() => {
+            for (let oy = 0; oy < source.height; oy++) {
+                for (let ox = 0; ox < source.width; ox++) {
+                    const tx = ox + x;
+                    const ty = oy + y;
+                    this.trySet(tx, ty, cachedSource.get(ox, oy));
+                }
+            }
+        });
+    }
+    applyWriteMask(mask) {
+        const unique = { mask };
+        this.writeMasks.push(unique);
+        return () => {
+            const idx = this.writeMasks.indexOf(unique);
+            if (idx == -1)
+                throw new Error("Mask was not present");
+            this.writeMasks.splice(idx, 1);
+        };
+    }
+    *[Symbol.iterator]() {
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                yield { x, y, value: this.get(x, y) };
+            }
+        }
+    }
+    forEach(callback) {
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                callback(this.get(x, y), x, y);
+            }
+        }
+    }
+    getVisibilityMap(originX, originY, maxDistance, isWall, options) {
+        const { startAngle = { asTurns: 0 }, endAngle = { asTurns: 1 }, includeWalls = false, angleStep = { asDegrees: 1 } } = options || {};
+        const visibilityGrid = new GridBase(this.width, this.height, () => false);
+        const startRad = angleToRadians(startAngle);
+        const endRad = angleToRadians(endAngle);
+        const stepRad = angleToRadians(angleStep);
+        const totalAngle = endRad > startRad
+            ? endRad - startRad
+            : endRad + (2 * Math.PI) - startRad;
+        const effectiveStepRad = Math.max(0.001, Math.min(stepRad, totalAngle));
+        const steps = Math.ceil(totalAngle / effectiveStepRad);
+        for (let i = 0; i <= steps; i++) {
+            const angle = startRad + i * effectiveStepRad;
+            if (angle > endRad && i > 0)
+                break;
+            const endX = Math.round(originX + maxDistance * Math.cos(angle));
+            const endY = Math.round(originY + maxDistance * Math.sin(angle));
+            let x0 = originX;
+            let y0 = originY;
+            let x1 = endX;
+            let y1 = endY;
+            const dx = Math.abs(x1 - x0);
+            const dy = Math.abs(y1 - y0);
+            const sx = x0 < x1 ? 1 : -1;
+            const sy = y0 < y1 ? 1 : -1;
+            let err = dx - dy;
+            while (true) {
+                if (x0 < 0 || x0 >= this.width || y0 < 0 || y0 >= this.height) {
+                    break;
+                }
+                const isWallCell = isWall(this.get(x0, y0), x0, y0);
+                if (isWallCell) {
+                    if (includeWalls) {
+                        visibilityGrid.set(x0, y0, true);
+                    }
+                    break;
+                }
+                else {
+                    visibilityGrid.set(x0, y0, true);
+                }
+                if (x0 === x1 && y0 === y1)
+                    break;
+                const e2 = 2 * err;
+                if (e2 > -dy) {
+                    err -= dy;
+                    x0 += sx;
+                }
+                if (e2 < dx) {
+                    err += dx;
+                    y0 += sy;
+                }
+            }
+        }
+        return visibilityGrid.pipe;
+    }
+    getFloodMap(startX, startY, predicate, options) {
+        const { includeDiagonals = false, maxDistance = Infinity } = options || {};
+        const result = new GridBase(this.width, this.height, () => false);
+        const startValue = this.get(startX, startY);
+        if (!predicate(startValue, startX, startY, startValue)) {
+            return result.pipe;
+        }
+        const queue = [[startX, startY, 0]];
+        result.set(startX, startY, true);
+        while (queue.length > 0) {
+            const [x, y, distance] = queue.shift();
+            if (distance >= maxDistance)
+                continue;
+            this.cells.get(x, y).getNeighbours(includeDiagonals)
+                .forEach(neighbour => {
+                if (result.get(neighbour.x, neighbour.y))
+                    return;
+                if (predicate(neighbour.value, neighbour.x, neighbour.y, startValue)) {
+                    result.set(neighbour.x, neighbour.y, true);
+                    queue.push([neighbour.x, neighbour.y, distance + 1]);
+                }
+            });
+        }
+        return result.pipe;
+    }
+    combine(aux, cb) {
+        const width = Math.min(this.width, aux.width);
+        const height = Math.min(this.height, aux.height);
+        return new GridBase(width, height, (x, y) => {
+            return cb(this.get(x, y), aux.get(x, y));
+        });
+    }
+    map(read, write) {
+        return new Grid(this.width, this.height, (x, y) => read(this.parentGet(x, y), x, y), (x, y, value) => this.parentSet(x, y, write(value, x, y)), fn => this.batch(fn));
+    }
+    region(x, y, width, height) {
+        return new Grid(width, height, (tx, ty) => {
+            return this.parentGet(tx + x, ty + y);
+        }, (tx, ty, value) => {
+            if (tx < 0 || ty < 0 || tx >= width || ty >= height)
+                throw new Error("Out of bounds");
+            this.parentSet(tx + x, ty + y, value);
+        }, fn => this.batch(fn));
+    }
+    static init(width, height, initCell) {
+        return new GridBase(width, height, initCell);
+    }
+    static from(source) {
+        return new GridBase(source);
+    }
+    static solid(width, height, fillValue) {
+        return new GridBase(Pipe2D.solid(fillValue, width, height));
+    }
+}
+export class GridBase extends Grid {
+    triggerEvent(name, data) {
+        var _a;
+        (_a = this.eventHandlers[name]) === null || _a === void 0 ? void 0 : _a.forEach(obj => obj.fn(data));
+    }
+    batchUpdate(fn) {
+        if (this.batchState) {
+            this.batchState.level++;
+        }
+        else {
+            this.batchState = {
+                level: 1,
+                changedCells: new Set()
+            };
+        }
+        fn();
+        this.batchState.level--;
+        if (this.batchState.level == 0) {
+            const changed = this.batchState.changedCells;
+            this.batchState = null;
+            this.triggerChange(changed);
+        }
+    }
+    constructor(widthOrSource, height, cellInit) {
+        const source = typeof widthOrSource == "object"
+            ? widthOrSource
+            : {
+                width: widthOrSource,
+                height: height,
+                get: cellInit
+            };
+        super(source.width, source.height, (x, y) => this.data[this.xyToIndex(x, y)], (x, y, value) => this._set(x, y, value), fn => this.batchUpdate(fn));
+        this.eventHandlers = {};
+        this.batchState = null;
+        this.data = Array.from({ length: source.width * source.height }, (_, i) => {
+            const x = i % source.width;
+            const y = Math.floor(i / source.width);
+            return source.get(x, y);
+        });
+    }
+    on(eventName, handler) {
+        const unique = { fn: handler };
+        if (!this.eventHandlers[eventName])
+            this.eventHandlers[eventName] = [];
+        this.eventHandlers[eventName].push(unique);
+        return () => {
+            const idx = this.eventHandlers[eventName].indexOf(unique);
+            if (idx === -1)
+                throw new Error("Event handler was already retired");
+            this.eventHandlers[eventName].splice(idx, 1);
+        };
+    }
+    xyToIndex(x, y) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
+            throw new Error(`Coordinates out of bounds: (${x}, ${y})`);
+        }
+        return y * this.width + x;
+    }
+    _set(x, y, value) {
+        const idx = this.xyToIndex(x, y);
+        if (this.data[idx] === value)
+            return;
+        if (this.batchState) {
+            this.batchState.changedCells.add(this.cells.get(x, y));
+            return;
+        }
+        this.data[this.xyToIndex(x, y)] = value;
+        if (this.eventHandlers.change) {
+            this.triggerChange(new Set([this.cells.get(x, y)]));
+        }
+    }
+    triggerChange(changed) {
+        this.triggerEvent("change", { changedCells: changed });
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { Grid, type GridBase, type Cell, TraversalType, Visibility } from "./grid.js";

package/lib/index.js

@@ -0,0 +1 @@
+export { Grid, TraversalType, Visibility } from "./grid.js";

package/lib/utils.d.ts

@@ -0,0 +1,22 @@
+export type GetXYFunc<T> = (x: number, y: number) => T;
+export type Source2D<T> = {
+    width: number;
+    height: number;
+    get: GetXYFunc<T>;
+};
+export type Angle = {
+    asDegrees: number;
+} | {
+    asRadians: number;
+} | {
+    asTurns: number;
+};
+export declare function angleToRadians(angle: Angle): number;
+export declare class OrderedQueue<T> {
+    private getCost;
+    private queue;
+    constructor(getCost: (value: T) => number, ...values: T[]);
+    add(value: T): void;
+    get length(): number;
+    take(): T;
+}

package/lib/utils.js

@@ -0,0 +1,39 @@
+export function angleToRadians(angle) {
+    if ("asRadians" in angle)
+        return angle.asRadians;
+    if ("asDegrees" in angle)
+        return angle.asDegrees * (180 / Math.PI);
+    if ("asTurns" in angle)
+        return angle.asTurns * Math.PI * 2;
+    throw new Error("Invalid angle");
+}
+export class OrderedQueue {
+    constructor(getCost, ...values) {
+        this.getCost = getCost;
+        this.queue = [];
+        values.forEach(v => this.add(v));
+    }
+    add(value) {
+        const priority = this.getCost(value);
+        const item = { value, priority };
+        let low = 0, high = this.queue.length;
+        while (low < high) {
+            const mid = (low + high) >> 1;
+            if (this.queue[mid].priority > priority) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        this.queue.splice(low, 0, item);
+    }
+    get length() {
+        return this.queue.length;
+    }
+    take() {
+        if (this.queue.length == 0)
+            throw new Error("Queue is empty");
+        return this.queue.pop().value;
+    }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "version": "0.0.1",
+  "description": "2D store and utilities",
+  "name": "@xtia/grid",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./lib/*": null
+  },
+  "scripts": {
+    "build": "npx tsc",
+    "test": "npx jest"
+  },
+  "files": [
+    "lib/"
+  ],
+  "devDependencies": {
+    "@swc/jest": "^0.2.39",
+    "@types/jest": "^30.0.0",
+    "jest": "^30.4.2",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@xtia/pipe2d": "^2.1.0"
+  }
+}