@codexo/exojs-tilemap 0.15.3 → 0.16.0

package/dist/esm/autoTile.js

@@ -1,214 +1,173 @@
-import { unpackTile, TILE_TRANSFORM_IDENTITY } from './types.js';
+import { TILE_TRANSFORM_IDENTITY, unpackTile } from "./types.js";
 
-// ── Module-level mask helpers ─────────────────────────────────────────────
+//#region src/autoTile.ts
 /**
- * Compute a 4-bit edge bitmask for the cell at `(tx, ty)`.
- * Top=1, Right=2, Bottom=4, Left=8.
- */
-function computeEdgeMask(tx, ty, inGroup) {
-    let mask = 0;
-    if (inGroup(tx, ty - 1))
-        mask |= 1;
-    if (inGroup(tx + 1, ty))
-        mask |= 2;
-    if (inGroup(tx, ty + 1))
-        mask |= 4;
-    if (inGroup(tx - 1, ty))
-        mask |= 8;
-    return mask;
-}
+* Compute a 4-bit edge bitmask for the cell at `(tx, ty)`.
+* Top=1, Right=2, Bottom=4, Left=8.
+*/
+const computeEdgeMask = (tx, ty, inGroup) => {
+	let mask = 0;
+	if (inGroup(tx, ty - 1)) mask |= 1;
+	if (inGroup(tx + 1, ty)) mask |= 2;
+	if (inGroup(tx, ty + 1)) mask |= 4;
+	if (inGroup(tx - 1, ty)) mask |= 8;
+	return mask;
+};
 /**
- * Compute an 8-bit blob bitmask for the cell at `(tx, ty)` using the
- * corner-dependency rule: diagonal bits are only set when both adjacent
- * cardinal directions are also set.
- *
- * Bit layout:
- * ```
- * 1  | 2  | 4
- * 8  | -- | 16
- * 32 | 64 | 128
- * ```
- */
-function computeBlobMask(tx, ty, inGroup) {
-    const top = inGroup(tx, ty - 1);
-    const right = inGroup(tx + 1, ty);
-    const bottom = inGroup(tx, ty + 1);
-    const left = inGroup(tx - 1, ty);
-    let mask = 0;
-    if (top)
-        mask |= 2;
-    if (right)
-        mask |= 16;
-    if (bottom)
-        mask |= 64;
-    if (left)
-        mask |= 8;
-    // Corner bits: only when BOTH adjacent cardinals are set.
-    if (top && left && inGroup(tx - 1, ty - 1))
-        mask |= 1;
-    if (top && right && inGroup(tx + 1, ty - 1))
-        mask |= 4;
-    if (bottom && left && inGroup(tx - 1, ty + 1))
-        mask |= 32;
-    if (bottom && right && inGroup(tx + 1, ty + 1))
-        mask |= 128;
-    return mask;
-}
+* Compute an 8-bit blob bitmask for the cell at `(tx, ty)` using the
+* corner-dependency rule: diagonal bits are only set when both adjacent
+* cardinal directions are also set.
+*
+* Bit layout:
+* ```
+* 1  | 2  | 4
+* 8  | -- | 16
+* 32 | 64 | 128
+* ```
+*/
+const computeBlobMask = (tx, ty, inGroup) => {
+	const top = inGroup(tx, ty - 1);
+	const right = inGroup(tx + 1, ty);
+	const bottom = inGroup(tx, ty + 1);
+	const left = inGroup(tx - 1, ty);
+	let mask = 0;
+	if (top) mask |= 2;
+	if (right) mask |= 16;
+	if (bottom) mask |= 64;
+	if (left) mask |= 8;
+	if (top && left && inGroup(tx - 1, ty - 1)) mask |= 1;
+	if (top && right && inGroup(tx + 1, ty - 1)) mask |= 4;
+	if (bottom && left && inGroup(tx - 1, ty + 1)) mask |= 32;
+	if (bottom && right && inGroup(tx + 1, ty + 1)) mask |= 128;
+	return mask;
+};
 /** Compute the mask for a cell given the Wang mode and a membership predicate. */
-function computeMask(wangSet, tx, ty, inGroup) {
-    return wangSet.type === 'edge'
-        ? computeEdgeMask(tx, ty, inGroup)
-        : computeBlobMask(tx, ty, inGroup);
-}
+const computeMask = (wangSet, tx, ty, inGroup) => wangSet.type === "edge" ? computeEdgeMask(tx, ty, inGroup) : computeBlobMask(tx, ty, inGroup);
 /**
- * Apply the variant computed for cell `(tx, ty)` to `layer`, preserving the
- * cell's current orientation transform. No-op if the mask has no mapping or
- * the target tileset is missing.
- */
-function applyVariant(layer, wangSet, tx, ty, inGroup) {
-    const newLocalTileId = wangSet.getTileId(computeMask(wangSet, tx, ty, inGroup));
-    if (newLocalTileId === undefined)
-        return;
-    const tileset = layer.tilesets[wangSet.tilesetIndex];
-    if (!tileset)
-        return;
-    // Preserve the existing orientation transform if the cell already holds one.
-    const existing = layer.getTileAt(tx, ty);
-    layer.setTileAt(tx, ty, {
-        localTileId: newLocalTileId,
-        tileset,
-        transform: existing ? existing.transform : TILE_TRANSFORM_IDENTITY,
-    });
-}
-// ── Public API ────────────────────────────────────────────────────────────
+* Apply the variant computed for cell `(tx, ty)` to `layer`, preserving the
+* cell's current orientation transform. No-op if the mask has no mapping or
+* the target tileset is missing.
+*/
+const applyVariant = (layer, wangSet, tx, ty, inGroup) => {
+	const newLocalTileId = wangSet.getTileId(computeMask(wangSet, tx, ty, inGroup));
+	if (newLocalTileId === void 0) return;
+	const tileset = layer.tilesets[wangSet.tilesetIndex];
+	if (!tileset) return;
+	const existing = layer.getTileAt(tx, ty);
+	layer.setTileAt(tx, ty, {
+		localTileId: newLocalTileId,
+		tileset,
+		transform: existing ? existing.transform : TILE_TRANSFORM_IDENTITY
+	});
+};
 /**
- * Apply Wang autotiling to `layer` using `wangSet`.
- *
- * Iterates every cell in the layer. For each cell that belongs to the Wang
- * group, computes a neighbor bitmask and looks up the correct local tile ID
- * from {@link WangSet.blobMap}. The layer is mutated in place; cells whose
- * computed bitmask has no mapping in the blobMap are left unchanged.
- *
- * The function performs two passes (snapshot then write) so neighbor tests
- * always reflect the pre-call state regardless of processing order.
- *
- * **Group membership.** With no `matchFn`, a cell belongs to the group when its
- * `tilesetIndex` matches {@link WangSet.tilesetIndex} and its `localTileId` is a
- * {@link WangSet.isMember member} of the set. Membership covers every variant
- * the set can produce, so re-running `autoTile` (or {@link refreshCell}) on
- * already-autotiled data is stable. Paint with a tile ID that is a member (a
- * blobMap value, or one listed in {@link WangSetOptions.members}).
- *
- * **Blob mode bitmask (bit positions):**
- * ```
- * 1  | 2  | 4
- * 8  | -- | 16
- * 32 | 64 | 128
- * ```
- * Diagonal bits (1, 4, 32, 128) are only set when both adjacent cardinals
- * are also set (the "corner dependency" rule that reduces 256 raw
- * combinations to 47 valid blob states).
- *
- * **Edge mode bitmask (bit positions):** Top=1, Right=2, Bottom=4, Left=8.
- */
-function autoTile(layer, wangSet, options) {
-    const matchFn = options?.matchFn;
-    const wrapBorder = options?.wrapBorder ?? true;
-    const w = layer.width;
-    const h = layer.height;
-    const snapshot = new Map();
-    for (let ty = 0; ty < h; ty++) {
-        for (let tx = 0; tx < w; tx++) {
-            const packed = layer.getRawTileAt(tx, ty);
-            if (packed === 0)
-                continue;
-            const decoded = unpackTile(packed);
-            if (!decoded)
-                continue;
-            snapshot.set(ty * w + tx, decoded);
-        }
-    }
-    // ── Membership test (reads the snapshot) ─────────────────────────────
-    const isInGroup = (nx, ny) => {
-        if (nx < 0 || nx >= w || ny < 0 || ny >= h)
-            return wrapBorder;
-        const cell = snapshot.get(ny * w + nx);
-        if (!cell)
-            return false;
-        if (matchFn)
-            return matchFn(cell.localTileId, cell.tilesetIndex, nx, ny);
-        return cell.tilesetIndex === wangSet.tilesetIndex && wangSet.isMember(cell.localTileId);
-    };
-    // ── Pass 2: compute masks and write ──────────────────────────────────
-    for (let ty = 0; ty < h; ty++) {
-        for (let tx = 0; tx < w; tx++) {
-            const cellInfo = snapshot.get(ty * w + tx);
-            if (!cellInfo)
-                continue;
-            // Skip cells that are not part of the group.
-            const isMember = matchFn
-                ? matchFn(cellInfo.localTileId, cellInfo.tilesetIndex, tx, ty)
-                : cellInfo.tilesetIndex === wangSet.tilesetIndex && wangSet.isMember(cellInfo.localTileId);
-            if (!isMember)
-                continue;
-            applyVariant(layer, wangSet, tx, ty, isInGroup);
-        }
-    }
-}
+* Apply Wang autotiling to `layer` using `wangSet`.
+*
+* Iterates every cell in the layer. For each cell that belongs to the Wang
+* group, computes a neighbor bitmask and looks up the correct local tile ID
+* from {@link WangSet.blobMap}. The layer is mutated in place; cells whose
+* computed bitmask has no mapping in the blobMap are left unchanged.
+*
+* The function performs two passes (snapshot then write) so neighbor tests
+* always reflect the pre-call state regardless of processing order.
+*
+* **Group membership.** With no `matchFn`, a cell belongs to the group when its
+* `tilesetIndex` matches {@link WangSet.tilesetIndex} and its `localTileId` is a
+* {@link WangSet.isMember member} of the set. Membership covers every variant
+* the set can produce, so re-running `autoTile` (or {@link refreshCell}) on
+* already-autotiled data is stable. Paint with a tile ID that is a member (a
+* blobMap value, or one listed in {@link WangSetOptions.members}).
+*
+* **Blob mode bitmask (bit positions):**
+* ```
+* 1  | 2  | 4
+* 8  | -- | 16
+* 32 | 64 | 128
+* ```
+* Diagonal bits (1, 4, 32, 128) are only set when both adjacent cardinals
+* are also set (the "corner dependency" rule that reduces 256 raw
+* combinations to 47 valid blob states).
+*
+* **Edge mode bitmask (bit positions):** Top=1, Right=2, Bottom=4, Left=8.
+*
+* @throws If `layer` is unbounded (no fixed width/height) - there is no
+* "whole layer" to sweep. Use {@link refreshCell} to autotile an unbounded
+* layer incrementally, one edited cell at a time.
+*/
+const autoTile = (layer, wangSet, options) => {
+	const matchFn = options?.matchFn;
+	const wrapBorder = options?.wrapBorder ?? true;
+	const w = layer.width;
+	const h = layer.height;
+	if (w === void 0 || h === void 0) throw new Error("autoTile() requires a bounded layer (sweeps the whole layer) — use refreshCell() on an unbounded layer instead.");
+	const snapshot = /* @__PURE__ */ new Map();
+	for (let ty = 0; ty < h; ty++) for (let tx = 0; tx < w; tx++) {
+		const packed = layer.getRawTileAt(tx, ty);
+		if (packed === 0) continue;
+		const decoded = unpackTile(packed);
+		if (!decoded) continue;
+		snapshot.set(ty * w + tx, decoded);
+	}
+	const isInGroup = (nx, ny) => {
+		if (nx < 0 || nx >= w || ny < 0 || ny >= h) return wrapBorder;
+		const cell = snapshot.get(ny * w + nx);
+		if (!cell) return false;
+		if (matchFn) return matchFn(cell.localTileId, cell.tilesetIndex, nx, ny);
+		return cell.tilesetIndex === wangSet.tilesetIndex && wangSet.isMember(cell.localTileId);
+	};
+	for (let ty = 0; ty < h; ty++) for (let tx = 0; tx < w; tx++) {
+		const cellInfo = snapshot.get(ty * w + tx);
+		if (!cellInfo) continue;
+		if (!(matchFn ? matchFn(cellInfo.localTileId, cellInfo.tilesetIndex, tx, ty) : cellInfo.tilesetIndex === wangSet.tilesetIndex && wangSet.isMember(cellInfo.localTileId))) continue;
+		applyVariant(layer, wangSet, tx, ty, isInGroup);
+	}
+};
 /**
- * Incrementally re-autotile a single cell and its eight neighbours after an
- * edit, instead of re-running {@link autoTile} over the whole layer.
- *
- * A cell's blob/edge mask depends only on its immediate neighbours, so painting
- * or erasing cell `(x, y)` can change the variant of that cell and of the (up
- * to) eight cells that have it as a neighbour — but nothing further out. This
- * recomputes exactly that 3×3 neighbourhood, touching only the 1–4 chunks it
- * spans (and rebuilding geometry only for chunks whose tiles actually change).
- * For a paint operation this is O(1) work versus `autoTile`'s O(width·height).
- *
- * Membership is read live from the layer, so the membership test MUST be
- * variant-stable: the default ({@link WangSet.isMember}) is, and any custom
- * `matchFn` you pass must be too (see {@link AutoTileOptions.matchFn}).
- *
- * Typical editor use: write the painted tile with `layer.setTileAt(...)` using
- * a member tile ID, then call `refreshCell(layer, x, y, wangSet)`.
- *
- * @param layer   The layer to update in place.
- * @param x       Tile X of the edited cell.
- * @param y       Tile Y of the edited cell.
- * @param wangSet The Wang set to resolve variants from.
- * @param options Membership / border options (shared with {@link autoTile}).
- */
-function refreshCell(layer, x, y, wangSet, options) {
-    const matchFn = options?.matchFn;
-    const wrapBorder = options?.wrapBorder ?? true;
-    const w = layer.width;
-    const h = layer.height;
-    // Live membership test (reads the current layer; variant-stable by default).
-    const isInGroup = (nx, ny) => {
-        if (nx < 0 || nx >= w || ny < 0 || ny >= h)
-            return wrapBorder;
-        const tile = layer.getTileAt(nx, ny);
-        if (!tile)
-            return false;
-        const tsi = layer.tilesets.indexOf(tile.tileset);
-        if (matchFn)
-            return matchFn(tile.localTileId, tsi, nx, ny);
-        return tsi === wangSet.tilesetIndex && wangSet.isMember(tile.localTileId);
-    };
-    // Recompute the edited cell and its eight neighbours.
-    for (let dy = -1; dy <= 1; dy++) {
-        for (let dx = -1; dx <= 1; dx++) {
-            const tx = x + dx;
-            const ty = y + dy;
-            if (!layer.inBounds(tx, ty))
-                continue;
-            if (!isInGroup(tx, ty))
-                continue;
-            applyVariant(layer, wangSet, tx, ty, isInGroup);
-        }
-    }
-}
+* Incrementally re-autotile a single cell and its eight neighbours after an
+* edit, instead of re-running {@link autoTile} over the whole layer.
+*
+* A cell's blob/edge mask depends only on its immediate neighbours, so painting
+* or erasing cell `(x, y)` can change the variant of that cell and of the (up
+* to) eight cells that have it as a neighbour - but nothing further out. This
+* recomputes exactly that 3×3 neighbourhood, touching only the 1-4 chunks it
+* spans (and rebuilding geometry only for chunks whose tiles actually change).
+* For a paint operation this is O(1) work versus `autoTile`'s O(width·height).
+*
+* Membership is read live from the layer, so the membership test MUST be
+* variant-stable: the default ({@link WangSet.isMember}) is, and any custom
+* `matchFn` you pass must be too (see {@link AutoTileOptions.matchFn}).
+*
+* Typical editor use: write the painted tile with `layer.setTileAt(...)` using
+* a member tile ID, then call `refreshCell(layer, x, y, wangSet)`.
+*
+* @param layer   The layer to update in place.
+* @param x       Tile X of the edited cell.
+* @param y       Tile Y of the edited cell.
+* @param wangSet The Wang set to resolve variants from.
+* @param options Membership / border options (shared with {@link autoTile}).
+*/
+const refreshCell = (layer, x, y, wangSet, options) => {
+	const matchFn = options?.matchFn;
+	const wrapBorder = options?.wrapBorder ?? true;
+	const w = layer.width;
+	const h = layer.height;
+	const isInGroup = (nx, ny) => {
+		if (w !== void 0 && (nx < 0 || nx >= w) || h !== void 0 && (ny < 0 || ny >= h)) return wrapBorder;
+		const tile = layer.getTileAt(nx, ny);
+		if (!tile) return false;
+		const tsi = layer.tilesets.indexOf(tile.tileset);
+		if (matchFn) return matchFn(tile.localTileId, tsi, nx, ny);
+		return tsi === wangSet.tilesetIndex && wangSet.isMember(tile.localTileId);
+	};
+	for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+		const tx = x + dx;
+		const ty = y + dy;
+		if (!layer.inBounds(tx, ty)) continue;
+		if (!isInGroup(tx, ty)) continue;
+		applyVariant(layer, wangSet, tx, ty, isInGroup);
+	}
+};
 
+//#endregion
 export { autoTile, refreshCell };
-//# sourceMappingURL=autoTile.js.map
+//# sourceMappingURL=autoTile.js.map

package/dist/esm/autoTile.js.map

@@ -1 +1 @@
-{"version":3,"file":"autoTile.js","sources":["../../../src/autoTile.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"autoTile.js","names":[],"sources":["../../src/autoTile.ts"],"sourcesContent":["import type { TileLayer } from './TileLayer';\nimport { TILE_TRANSFORM_IDENTITY, unpackTile } from './types';\nimport type { WangSet } from './WangSet';\n\n/**\n * Options for {@link autoTile} and {@link refreshCell}.\n */\nexport interface AutoTileOptions {\n  /**\n   * When provided, only cells for which `matchFn` returns `true` are treated\n   * as part of the Wang group. The function receives the cell's `localTileId`,\n   * `tilesetIndex`, and tile coordinates `(x, y)`.\n   *\n   * If omitted, group membership defaults to {@link WangSet.isMember} on the\n   * cell's `localTileId` (and a matching `tilesetIndex`). That default is\n   * *variant-stable* - every autotiled variant counts as a member - which is\n   * what makes {@link refreshCell} correct. If you supply a `matchFn` for use\n   * with `refreshCell`, it MUST likewise be variant-stable (independent of the\n   * currently-rendered variant), e.g. keyed on a separate logical-terrain grid\n   * or a tile property.\n   */\n  matchFn?: (localTileId: number, tilesetIndex: number, x: number, y: number) => boolean;\n  /**\n   * When `true` (default), out-of-bounds neighbors are treated as though\n   * they belong to the Wang group, so border tiles fill correctly to the\n   * layer edge. Set to `false` to leave border tiles visually open.\n   */\n  wrapBorder?: boolean;\n}\n\n// ── Module-level mask helpers ─────────────────────────────────────────────\n\n/**\n * Compute a 4-bit edge bitmask for the cell at `(tx, ty)`.\n * Top=1, Right=2, Bottom=4, Left=8.\n */\nconst computeEdgeMask = (tx: number, ty: number, inGroup: (nx: number, ny: number) => boolean): number => {\n  let mask = 0;\n  if (inGroup(tx, ty - 1)) mask |= 1;\n  if (inGroup(tx + 1, ty)) mask |= 2;\n  if (inGroup(tx, ty + 1)) mask |= 4;\n  if (inGroup(tx - 1, ty)) mask |= 8;\n  return mask;\n};\n\n/**\n * Compute an 8-bit blob bitmask for the cell at `(tx, ty)` using the\n * corner-dependency rule: diagonal bits are only set when both adjacent\n * cardinal directions are also set.\n *\n * Bit layout:\n * ```\n * 1  | 2  | 4\n * 8  | -- | 16\n * 32 | 64 | 128\n * ```\n */\nconst computeBlobMask = (tx: number, ty: number, inGroup: (nx: number, ny: number) => boolean): number => {\n  const top = inGroup(tx, ty - 1);\n  const right = inGroup(tx + 1, ty);\n  const bottom = inGroup(tx, ty + 1);\n  const left = inGroup(tx - 1, ty);\n  let mask = 0;\n  if (top) mask |= 2;\n  if (right) mask |= 16;\n  if (bottom) mask |= 64;\n  if (left) mask |= 8;\n  // Corner bits: only when BOTH adjacent cardinals are set.\n  if (top && left && inGroup(tx - 1, ty - 1)) mask |= 1;\n  if (top && right && inGroup(tx + 1, ty - 1)) mask |= 4;\n  if (bottom && left && inGroup(tx - 1, ty + 1)) mask |= 32;\n  if (bottom && right && inGroup(tx + 1, ty + 1)) mask |= 128;\n  return mask;\n};\n\n/** Compute the mask for a cell given the Wang mode and a membership predicate. */\nconst computeMask = (wangSet: WangSet, tx: number, ty: number, inGroup: (nx: number, ny: number) => boolean): number =>\n  wangSet.type === 'edge' ? computeEdgeMask(tx, ty, inGroup) : computeBlobMask(tx, ty, inGroup);\n\n/**\n * Apply the variant computed for cell `(tx, ty)` to `layer`, preserving the\n * cell's current orientation transform. No-op if the mask has no mapping or\n * the target tileset is missing.\n */\nconst applyVariant = (layer: TileLayer, wangSet: WangSet, tx: number, ty: number, inGroup: (nx: number, ny: number) => boolean): void => {\n  const newLocalTileId = wangSet.getTileId(computeMask(wangSet, tx, ty, inGroup));\n  if (newLocalTileId === undefined) return;\n\n  const tileset = layer.tilesets[wangSet.tilesetIndex];\n  if (!tileset) return;\n\n  // Preserve the existing orientation transform if the cell already holds one.\n  const existing = layer.getTileAt(tx, ty);\n  layer.setTileAt(tx, ty, {\n    localTileId: newLocalTileId,\n    tileset,\n    transform: existing ? existing.transform : TILE_TRANSFORM_IDENTITY,\n  });\n};\n\n// ── Public API ────────────────────────────────────────────────────────────\n\n/**\n * Apply Wang autotiling to `layer` using `wangSet`.\n *\n * Iterates every cell in the layer. For each cell that belongs to the Wang\n * group, computes a neighbor bitmask and looks up the correct local tile ID\n * from {@link WangSet.blobMap}. The layer is mutated in place; cells whose\n * computed bitmask has no mapping in the blobMap are left unchanged.\n *\n * The function performs two passes (snapshot then write) so neighbor tests\n * always reflect the pre-call state regardless of processing order.\n *\n * **Group membership.** With no `matchFn`, a cell belongs to the group when its\n * `tilesetIndex` matches {@link WangSet.tilesetIndex} and its `localTileId` is a\n * {@link WangSet.isMember member} of the set. Membership covers every variant\n * the set can produce, so re-running `autoTile` (or {@link refreshCell}) on\n * already-autotiled data is stable. Paint with a tile ID that is a member (a\n * blobMap value, or one listed in {@link WangSetOptions.members}).\n *\n * **Blob mode bitmask (bit positions):**\n * ```\n * 1  | 2  | 4\n * 8  | -- | 16\n * 32 | 64 | 128\n * ```\n * Diagonal bits (1, 4, 32, 128) are only set when both adjacent cardinals\n * are also set (the \"corner dependency\" rule that reduces 256 raw\n * combinations to 47 valid blob states).\n *\n * **Edge mode bitmask (bit positions):** Top=1, Right=2, Bottom=4, Left=8.\n *\n * @throws If `layer` is unbounded (no fixed width/height) - there is no\n * \"whole layer\" to sweep. Use {@link refreshCell} to autotile an unbounded\n * layer incrementally, one edited cell at a time.\n */\nexport const autoTile = (layer: TileLayer, wangSet: WangSet, options?: AutoTileOptions): void => {\n  const matchFn = options?.matchFn;\n  const wrapBorder = options?.wrapBorder ?? true;\n  const w = layer.width;\n  const h = layer.height;\n  if (w === undefined || h === undefined) {\n    throw new Error('autoTile() requires a bounded layer (sweeps the whole layer) — use refreshCell() on an unbounded layer instead.');\n  }\n\n  // ── Pass 1: snapshot ─────────────────────────────────────────────────\n  // Capture each cell's (tilesetIndex, localTileId) before any writes so\n  // that neighbor membership tests always see pre-mutation state.\n\n  interface CellInfo {\n    tilesetIndex: number;\n    localTileId: number;\n  }\n  const snapshot = new Map<number, CellInfo>();\n\n  for (let ty = 0; ty < h; ty++) {\n    for (let tx = 0; tx < w; tx++) {\n      const packed = layer.getRawTileAt(tx, ty);\n      if (packed === 0) continue;\n      const decoded = unpackTile(packed);\n      if (!decoded) continue;\n      snapshot.set(ty * w + tx, decoded);\n    }\n  }\n\n  // ── Membership test (reads the snapshot) ─────────────────────────────\n\n  const isInGroup = (nx: number, ny: number): boolean => {\n    if (nx < 0 || nx >= w || ny < 0 || ny >= h) return wrapBorder;\n    const cell = snapshot.get(ny * w + nx);\n    if (!cell) return false;\n    if (matchFn) return matchFn(cell.localTileId, cell.tilesetIndex, nx, ny);\n    return cell.tilesetIndex === wangSet.tilesetIndex && wangSet.isMember(cell.localTileId);\n  };\n\n  // ── Pass 2: compute masks and write ──────────────────────────────────\n\n  for (let ty = 0; ty < h; ty++) {\n    for (let tx = 0; tx < w; tx++) {\n      const cellInfo = snapshot.get(ty * w + tx);\n      if (!cellInfo) continue;\n\n      // Skip cells that are not part of the group.\n      const isMember = matchFn\n        ? matchFn(cellInfo.localTileId, cellInfo.tilesetIndex, tx, ty)\n        : cellInfo.tilesetIndex === wangSet.tilesetIndex && wangSet.isMember(cellInfo.localTileId);\n      if (!isMember) continue;\n\n      applyVariant(layer, wangSet, tx, ty, isInGroup);\n    }\n  }\n};\n\n/**\n * Incrementally re-autotile a single cell and its eight neighbours after an\n * edit, instead of re-running {@link autoTile} over the whole layer.\n *\n * A cell's blob/edge mask depends only on its immediate neighbours, so painting\n * or erasing cell `(x, y)` can change the variant of that cell and of the (up\n * to) eight cells that have it as a neighbour - but nothing further out. This\n * recomputes exactly that 3×3 neighbourhood, touching only the 1-4 chunks it\n * spans (and rebuilding geometry only for chunks whose tiles actually change).\n * For a paint operation this is O(1) work versus `autoTile`'s O(width·height).\n *\n * Membership is read live from the layer, so the membership test MUST be\n * variant-stable: the default ({@link WangSet.isMember}) is, and any custom\n * `matchFn` you pass must be too (see {@link AutoTileOptions.matchFn}).\n *\n * Typical editor use: write the painted tile with `layer.setTileAt(...)` using\n * a member tile ID, then call `refreshCell(layer, x, y, wangSet)`.\n *\n * @param layer   The layer to update in place.\n * @param x       Tile X of the edited cell.\n * @param y       Tile Y of the edited cell.\n * @param wangSet The Wang set to resolve variants from.\n * @param options Membership / border options (shared with {@link autoTile}).\n */\nexport const refreshCell = (layer: TileLayer, x: number, y: number, wangSet: WangSet, options?: AutoTileOptions): void => {\n  const matchFn = options?.matchFn;\n  const wrapBorder = options?.wrapBorder ?? true;\n  const w = layer.width;\n  const h = layer.height;\n\n  // Live membership test (reads the current layer; variant-stable by default).\n  const isInGroup = (nx: number, ny: number): boolean => {\n    if ((w !== undefined && (nx < 0 || nx >= w)) || (h !== undefined && (ny < 0 || ny >= h))) return wrapBorder;\n    const tile = layer.getTileAt(nx, ny);\n    if (!tile) return false;\n    const tsi = layer.tilesets.indexOf(tile.tileset);\n    if (matchFn) return matchFn(tile.localTileId, tsi, nx, ny);\n    return tsi === wangSet.tilesetIndex && wangSet.isMember(tile.localTileId);\n  };\n\n  // Recompute the edited cell and its eight neighbours.\n  for (let dy = -1; dy <= 1; dy++) {\n    for (let dx = -1; dx <= 1; dx++) {\n      const tx = x + dx;\n      const ty = y + dy;\n      if (!layer.inBounds(tx, ty)) continue;\n      if (!isInGroup(tx, ty)) continue;\n      applyVariant(layer, wangSet, tx, ty, isInGroup);\n    }\n  }\n};\n"],"mappings":"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"}

package/dist/esm/chunkGeometry.d.ts

@@ -6,7 +6,7 @@ import type { TileTransform } from './types';
  * One textured tile quad in chunk-local pixel space.
  *
  * `u0/v0/u1/v1` are the raw (min/max) source UV bounds of the tile within its
- * tileset texture — flip/orientation is **not** baked here; it travels in
+ * tileset texture - flip/orientation is **not** baked here; it travels in
  * {@link TileQuad.orient} and is applied by the per-backend renderer (flipX/Y
  * via UV-corner swap, diagonal via an axis swap in the shader). Keeping the
  * geometry orientation-neutral lets both backends share one CPU builder.
@@ -42,23 +42,23 @@ export interface ChunkPage {
     readonly quads: readonly TileQuad[];
 }
 /** Pack a {@link TileTransform} into a 3-bit orientation code. @internal */
-export declare function orientCode(transform: TileTransform): number;
+export declare const orientCode: (transform: TileTransform) => number;
 /** Read the cumulative chunk-geometry rebuild count. @internal */
-export declare function getTileGeometryRebuildCount(): number;
+export declare const getTileGeometryRebuildCount: () => number;
 /** Reset the chunk-geometry rebuild counter (call before a measured frame). @internal */
-export declare function resetTileGeometryRebuildCount(): void;
+export declare const resetTileGeometryRebuildCount: () => void;
 /**
  * Build per-tileset page geometry for a single chunk.
  *
  * Iterates the chunk's packed cells in deterministic row-major order, skipping
  * empties, out-of-range tilesets, and out-of-range local tile ids (all treated
- * as empty — this is the renderer's half of the G-GID contract). Each surviving
+ * as empty - this is the renderer's half of the G-GID contract). Each surviving
  * cell is resolved to its source UV rect (from `tileset.getTileRect` + the
  * tileset `TextureRegion`) and a chunk-local destination rect (bottom-left
  * aligned per Tiled orthogonal semantics, so tilesets whose tiles are taller
  * than the map grid extend upward).
  *
- * Allocation happens here only — the result is cached on the owning
+ * Allocation happens here only - the result is cached on the owning
  * {@link import('./TileChunkNode').TileChunkNode} keyed by `chunk.revision`, so
  * unchanged chunks never rebuild and the per-frame path stays allocation-free.
  *
@@ -68,4 +68,5 @@ export declare function resetTileGeometryRebuildCount(): void;
  * @param tileHeight Map/layer tile cell height in pixels.
  * @internal
  */
-export declare function buildChunkPages(chunk: ReadonlyTileChunk, tilesets: readonly TileSet[], tileWidth: number, tileHeight: number): ChunkPage[];
+export declare const buildChunkPages: (chunk: ReadonlyTileChunk, tilesets: readonly TileSet[], tileWidth: number, tileHeight: number) => ChunkPage[];
+//# sourceMappingURL=chunkGeometry.d.ts.map

package/dist/esm/chunkGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkGeometry.d.ts","sourceRoot":"","sources":["../../src/chunkGeometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C;;;;;;;;;GASG;AACH,MAAM,WAAW,QAAQ;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AAED,4EAA4E;AAC5E,eAAO,MAAM,UAAU,GAAI,WAAW,aAAa,KAAG,MAA8F,CAAC;AASrJ,kEAAkE;AAClE,eAAO,MAAM,2BAA2B,QAAO,MAAkC,CAAC;AAElF,yFAAyF;AACzF,eAAO,MAAM,6BAA6B,QAAO,IAEhD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,iBAAiB,EAAE,UAAU,SAAS,OAAO,EAAE,EAAE,WAAW,MAAM,EAAE,YAAY,MAAM,KAAG,SAAS,EAyFxI,CAAC"}