@codexo/exojs-tilemap 0.15.3 → 0.16.0

package/dist/esm/chunkGeometry.js

@@ -1,99 +1,88 @@
-import { unpackTile } from './types.js';
+import { unpackTile } from "./types.js";
 
+//#region src/chunkGeometry.ts
 /** Pack a {@link TileTransform} into a 3-bit orientation code. @internal */
-function orientCode(transform) {
-    return (transform.flipX ? 1 : 0) | (transform.flipY ? 2 : 0) | (transform.diagonal ? 4 : 0);
-}
+const orientCode = (transform) => (transform.flipX ? 1 : 0) | (transform.flipY ? 2 : 0) | (transform.diagonal ? 4 : 0);
+let tileGeometryRebuildCount = 0;
 /**
- * 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
- * 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
- * {@link import('./TileChunkNode').TileChunkNode} keyed by `chunk.revision`, so
- * unchanged chunks never rebuild and the per-frame path stays allocation-free.
- *
- * @param chunk      The readonly chunk view to build from.
- * @param tilesets   The layer's tileset array (packed `tilesetIndex` selects one).
- * @param tileWidth  Map/layer tile cell width in pixels.
- * @param tileHeight Map/layer tile cell height in pixels.
- * @internal
- */
-function buildChunkPages(chunk, tilesets, tileWidth, tileHeight) {
-    if (chunk.empty) {
-        return [];
-    }
-    const buckets = new Map();
-    const width = chunk.width;
-    const height = chunk.height;
-    for (let ly = 0; ly < height; ly++) {
-        for (let lx = 0; lx < width; lx++) {
-            const packed = chunk.getRawAt(lx, ly);
-            if (packed === 0) {
-                continue;
-            }
-            const decoded = unpackTile(packed);
-            if (decoded === null) {
-                continue;
-            }
-            const tileset = tilesets[decoded.tilesetIndex];
-            // Out-of-range tileset or local id → treat as empty (G-GID). getTileRect
-            // throws on an out-of-range id, so the bounds check must precede it.
-            if (tileset === undefined || decoded.localTileId >= tileset.tileCount) {
-                continue;
-            }
-            const region = tileset.texture;
-            const texture = region.texture;
-            const textureWidth = texture.width;
-            const textureHeight = texture.height;
-            if (textureWidth <= 0 || textureHeight <= 0) {
-                continue;
-            }
-            const rect = tileset.getTileRect(decoded.localTileId);
-            // Absolute source pixel rect = tileset-region offset + in-atlas tile rect.
-            const sx = region.x + rect.x;
-            const sy = region.y + rect.y;
-            // Exact tile UVs, no half-texel inset. This assumes NEAREST filtering on
-            // the tileset atlas (the typical pixel-art case). Under LINEAR/mipmap
-            // filtering an atlas WITHOUT extrusion padding can bleed neighbouring
-            // tiles at the edges; author tilesets with extruded margins for linear
-            // sampling. (Extrusion-aware tilemap UV insetting — already done on the
-            // NineSlice/RepeatingSprite geometry paths — is a v0.14 follow-up.)
-            const u0 = sx / textureWidth;
-            const v0 = sy / textureHeight;
-            const u1 = (sx + rect.width) / textureWidth;
-            const v1 = (sy + rect.height) / textureHeight;
-            // Bottom-left aligned destination (Tiled orthogonal). Uniform tiles
-            // (rect.height === tileHeight) collapse to a plain cell rect. The
-            // tileset's visual draw offset (Tiled `tileoffset`) shifts every tile.
-            const x0 = lx * tileWidth + tileset.offsetX;
-            const y0 = ly * tileHeight + tileHeight - rect.height + tileset.offsetY;
-            const x1 = x0 + rect.width;
-            const y1 = y0 + rect.height;
-            let bucket = buckets.get(tileset);
-            if (bucket === undefined) {
-                bucket = [];
-                buckets.set(tileset, bucket);
-            }
-            bucket.push({ x0, y0, x1, y1, u0, v0, u1, v1, orient: orientCode(decoded.transform) });
-        }
-    }
-    // Emit pages in tileset-array order for deterministic, reproducible builds.
-    const pages = [];
-    for (const tileset of tilesets) {
-        const quads = buckets.get(tileset);
-        if (quads !== undefined && quads.length > 0) {
-            pages.push({ tileset, texture: tileset.texture.texture, quads });
-        }
-    }
-    return pages;
-}
+* 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
+* 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
+* {@link import('./TileChunkNode').TileChunkNode} keyed by `chunk.revision`, so
+* unchanged chunks never rebuild and the per-frame path stays allocation-free.
+*
+* @param chunk      The readonly chunk view to build from.
+* @param tilesets   The layer's tileset array (packed `tilesetIndex` selects one).
+* @param tileWidth  Map/layer tile cell width in pixels.
+* @param tileHeight Map/layer tile cell height in pixels.
+* @internal
+*/
+const buildChunkPages = (chunk, tilesets, tileWidth, tileHeight) => {
+	tileGeometryRebuildCount++;
+	if (chunk.empty) return [];
+	const buckets = /* @__PURE__ */ new Map();
+	const width = chunk.width;
+	const height = chunk.height;
+	for (let ly = 0; ly < height; ly++) for (let lx = 0; lx < width; lx++) {
+		const packed = chunk.getRawAt(lx, ly);
+		if (packed === 0) continue;
+		const decoded = unpackTile(packed);
+		if (decoded === null) continue;
+		const tileset = tilesets[decoded.tilesetIndex];
+		if (tileset === void 0 || decoded.localTileId >= tileset.tileCount) continue;
+		const region = tileset.texture;
+		const texture = region.texture;
+		const textureWidth = texture.width;
+		const textureHeight = texture.height;
+		if (textureWidth <= 0 || textureHeight <= 0) continue;
+		const rect = tileset.getTileRect(decoded.localTileId);
+		const sx = region.x + rect.x;
+		const sy = region.y + rect.y;
+		const u0 = sx / textureWidth;
+		const v0 = sy / textureHeight;
+		const u1 = (sx + rect.width) / textureWidth;
+		const v1 = (sy + rect.height) / textureHeight;
+		const x0 = lx * tileWidth + tileset.offsetX;
+		const y0 = ly * tileHeight + tileHeight - rect.height + tileset.offsetY;
+		const x1 = x0 + rect.width;
+		const y1 = y0 + rect.height;
+		let bucket = buckets.get(tileset);
+		if (bucket === void 0) {
+			bucket = [];
+			buckets.set(tileset, bucket);
+		}
+		bucket.push({
+			x0,
+			y0,
+			x1,
+			y1,
+			u0,
+			v0,
+			u1,
+			v1,
+			orient: orientCode(decoded.transform)
+		});
+	}
+	const pages = [];
+	for (const tileset of tilesets) {
+		const quads = buckets.get(tileset);
+		if (quads !== void 0 && quads.length > 0) pages.push({
+			tileset,
+			texture: tileset.texture.texture,
+			quads
+		});
+	}
+	return pages;
+};
 
+//#endregion
 export { buildChunkPages, orientCode };
-//# sourceMappingURL=chunkGeometry.js.map
+//# sourceMappingURL=chunkGeometry.js.map

package/dist/esm/chunkGeometry.js.map

@@ -1 +1 @@
-{"version":3,"file":"chunkGeometry.js","sources":["../../../src/chunkGeometry.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"chunkGeometry.js","names":[],"sources":["../../src/chunkGeometry.ts"],"sourcesContent":["import type { Texture } from '@codexo/exojs';\n\nimport type { ReadonlyTileChunk } from './TileChunk';\nimport type { TileSet } from './TileSet';\nimport type { TileTransform } from './types';\nimport { unpackTile } from './types';\n\n/**\n * One textured tile quad in chunk-local pixel space.\n *\n * `u0/v0/u1/v1` are the raw (min/max) source UV bounds of the tile within its\n * tileset texture - flip/orientation is **not** baked here; it travels in\n * {@link TileQuad.orient} and is applied by the per-backend renderer (flipX/Y\n * via UV-corner swap, diagonal via an axis swap in the shader). Keeping the\n * geometry orientation-neutral lets both backends share one CPU builder.\n * @internal\n */\nexport interface TileQuad {\n  /** Local destination rect, left/top (chunk-local pixels). */\n  readonly x0: number;\n  readonly y0: number;\n  /** Local destination rect, right/bottom (chunk-local pixels). */\n  readonly x1: number;\n  readonly y1: number;\n  /** Normalised source UV bounds (always min ≤ max). */\n  readonly u0: number;\n  readonly v0: number;\n  readonly u1: number;\n  readonly v1: number;\n  /** Orientation code: bit0 = flipX, bit1 = flipY, bit2 = diagonal. */\n  readonly orient: number;\n}\n\n/**\n * Geometry for one tileset \"page\" within a chunk: every tile in the chunk that\n * draws from a single tileset texture, grouped so the renderer can batch by\n * `(shader, texture)`.\n * @internal\n */\nexport interface ChunkPage {\n  /** The tileset all quads in this page draw from. */\n  readonly tileset: TileSet;\n  /** The underlying GPU texture (the tileset's atlas), bound once per page. */\n  readonly texture: Texture;\n  /** The tile quads for this page, in deterministic row-major order. */\n  readonly quads: readonly TileQuad[];\n}\n\n/** Pack a {@link TileTransform} into a 3-bit orientation code. @internal */\nexport const orientCode = (transform: TileTransform): number => (transform.flipX ? 1 : 0) | (transform.flipY ? 2 : 0) | (transform.diagonal ? 4 : 0);\n\n// Test/perf-only instrumentation: counts CPU chunk-geometry rebuilds. A rebuild\n// happens once per {@link buildChunkPages} call - i.e. when a chunk node sees a\n// changed `chunk.revision`. Lets benchmarks/regression tests assert that a camera\n// pan rebuilds nothing and a single tile mutation rebuilds exactly one chunk.\n// Near-zero cost (one integer increment on the already-expensive rebuild path).\nlet tileGeometryRebuildCount = 0;\n\n/** Read the cumulative chunk-geometry rebuild count. @internal */\nexport const getTileGeometryRebuildCount = (): number => tileGeometryRebuildCount;\n\n/** Reset the chunk-geometry rebuild counter (call before a measured frame). @internal */\nexport const resetTileGeometryRebuildCount = (): void => {\n  tileGeometryRebuildCount = 0;\n};\n\n/**\n * Build per-tileset page geometry for a single chunk.\n *\n * Iterates the chunk's packed cells in deterministic row-major order, skipping\n * empties, out-of-range tilesets, and out-of-range local tile ids (all treated\n * as empty - this is the renderer's half of the G-GID contract). Each surviving\n * cell is resolved to its source UV rect (from `tileset.getTileRect` + the\n * tileset `TextureRegion`) and a chunk-local destination rect (bottom-left\n * aligned per Tiled orthogonal semantics, so tilesets whose tiles are taller\n * than the map grid extend upward).\n *\n * Allocation happens here only - the result is cached on the owning\n * {@link import('./TileChunkNode').TileChunkNode} keyed by `chunk.revision`, so\n * unchanged chunks never rebuild and the per-frame path stays allocation-free.\n *\n * @param chunk      The readonly chunk view to build from.\n * @param tilesets   The layer's tileset array (packed `tilesetIndex` selects one).\n * @param tileWidth  Map/layer tile cell width in pixels.\n * @param tileHeight Map/layer tile cell height in pixels.\n * @internal\n */\nexport const buildChunkPages = (chunk: ReadonlyTileChunk, tilesets: readonly TileSet[], tileWidth: number, tileHeight: number): ChunkPage[] => {\n  tileGeometryRebuildCount++;\n\n  if (chunk.empty) {\n    return [];\n  }\n\n  const buckets = new Map<TileSet, TileQuad[]>();\n  const width = chunk.width;\n  const height = chunk.height;\n\n  for (let ly = 0; ly < height; ly++) {\n    for (let lx = 0; lx < width; lx++) {\n      const packed = chunk.getRawAt(lx, ly);\n\n      if (packed === 0) {\n        continue;\n      }\n\n      const decoded = unpackTile(packed);\n\n      if (decoded === null) {\n        continue;\n      }\n\n      const tileset = tilesets[decoded.tilesetIndex];\n\n      // Out-of-range tileset or local id → treat as empty (G-GID). getTileRect\n      // throws on an out-of-range id, so the bounds check must precede it.\n      if (tileset === undefined || decoded.localTileId >= tileset.tileCount) {\n        continue;\n      }\n\n      const region = tileset.texture;\n      const texture = region.texture;\n      const textureWidth = texture.width;\n      const textureHeight = texture.height;\n\n      if (textureWidth <= 0 || textureHeight <= 0) {\n        continue;\n      }\n\n      const rect = tileset.getTileRect(decoded.localTileId);\n\n      // Absolute source pixel rect = tileset-region offset + in-atlas tile rect.\n      const sx = region.x + rect.x;\n      const sy = region.y + rect.y;\n      // Exact tile UVs, no half-texel inset. This assumes NEAREST filtering on\n      // the tileset atlas (the typical pixel-art case). Under LINEAR/mipmap\n      // filtering an atlas WITHOUT extrusion padding can bleed neighbouring\n      // tiles at the edges; author tilesets with extruded margins for linear\n      // sampling. (Extrusion-aware tilemap UV insetting - already done on the\n      // NineSlice/RepeatingSprite geometry paths - is a v0.14 follow-up.)\n      const u0 = sx / textureWidth;\n      const v0 = sy / textureHeight;\n      const u1 = (sx + rect.width) / textureWidth;\n      const v1 = (sy + rect.height) / textureHeight;\n\n      // Bottom-left aligned destination (Tiled orthogonal). Uniform tiles\n      // (rect.height === tileHeight) collapse to a plain cell rect. The\n      // tileset's visual draw offset (Tiled `tileoffset`) shifts every tile.\n      const x0 = lx * tileWidth + tileset.offsetX;\n      const y0 = ly * tileHeight + tileHeight - rect.height + tileset.offsetY;\n      const x1 = x0 + rect.width;\n      const y1 = y0 + rect.height;\n\n      let bucket = buckets.get(tileset);\n\n      if (bucket === undefined) {\n        bucket = [];\n        buckets.set(tileset, bucket);\n      }\n\n      bucket.push({ x0, y0, x1, y1, u0, v0, u1, v1, orient: orientCode(decoded.transform) });\n    }\n  }\n\n  // Emit pages in tileset-array order for deterministic, reproducible builds.\n  const pages: ChunkPage[] = [];\n\n  for (const tileset of tilesets) {\n    const quads = buckets.get(tileset);\n\n    if (quads !== undefined && quads.length > 0) {\n      pages.push({ tileset, texture: tileset.texture.texture, quads });\n    }\n  }\n\n  return pages;\n};\n"],"mappings":";;;;AAiDA,MAAa,cAAc,eAAsC,UAAU,QAAQ,IAAI,MAAM,UAAU,QAAQ,IAAI,MAAM,UAAU,WAAW,IAAI;AAOlJ,IAAI,2BAA2B;;;;;;;;;;;;;;;;;;;;;;AA+B/B,MAAa,mBAAmB,OAA0B,UAA8B,WAAmB,eAAoC;CAC7I;CAEA,IAAI,MAAM,OACR,OAAO,CAAC;CAGV,MAAM,0BAAU,IAAI,IAAyB;CAC7C,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,MAAM;CAErB,KAAK,IAAI,KAAK,GAAG,KAAK,QAAQ,MAC5B,KAAK,IAAI,KAAK,GAAG,KAAK,OAAO,MAAM;EACjC,MAAM,SAAS,MAAM,SAAS,IAAI,EAAE;EAEpC,IAAI,WAAW,GACb;EAGF,MAAM,UAAU,WAAW,MAAM;EAEjC,IAAI,YAAY,MACd;EAGF,MAAM,UAAU,SAAS,QAAQ;EAIjC,IAAI,YAAY,UAAa,QAAQ,eAAe,QAAQ,WAC1D;EAGF,MAAM,SAAS,QAAQ;EACvB,MAAM,UAAU,OAAO;EACvB,MAAM,eAAe,QAAQ;EAC7B,MAAM,gBAAgB,QAAQ;EAE9B,IAAI,gBAAgB,KAAK,iBAAiB,GACxC;EAGF,MAAM,OAAO,QAAQ,YAAY,QAAQ,WAAW;EAGpD,MAAM,KAAK,OAAO,IAAI,KAAK;EAC3B,MAAM,KAAK,OAAO,IAAI,KAAK;EAO3B,MAAM,KAAK,KAAK;EAChB,MAAM,KAAK,KAAK;EAChB,MAAM,MAAM,KAAK,KAAK,SAAS;EAC/B,MAAM,MAAM,KAAK,KAAK,UAAU;EAKhC,MAAM,KAAK,KAAK,YAAY,QAAQ;EACpC,MAAM,KAAK,KAAK,aAAa,aAAa,KAAK,SAAS,QAAQ;EAChE,MAAM,KAAK,KAAK,KAAK;EACrB,MAAM,KAAK,KAAK,KAAK;EAErB,IAAI,SAAS,QAAQ,IAAI,OAAO;EAEhC,IAAI,WAAW,QAAW;GACxB,SAAS,CAAC;GACV,QAAQ,IAAI,SAAS,MAAM;EAC7B;EAEA,OAAO,KAAK;GAAE;GAAI;GAAI;GAAI;GAAI;GAAI;GAAI;GAAI;GAAI,QAAQ,WAAW,QAAQ,SAAS;EAAE,CAAC;CACvF;CAIF,MAAM,QAAqB,CAAC;CAE5B,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,QAAQ,QAAQ,IAAI,OAAO;EAEjC,IAAI,UAAU,UAAa,MAAM,SAAS,GACxC,MAAM,KAAK;GAAE;GAAS,SAAS,QAAQ,QAAQ;GAAS;EAAM,CAAC;CAEnE;CAEA,OAAO;AACT"}

package/dist/esm/index.d.ts

@@ -1 +1,2 @@
 export * from './public';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,UAAU,CAAC"}

package/dist/esm/index.js

@@ -1,15 +1,26 @@
-export { tilemapExtension } from './tilemapExtension.js';
-export { ImageLayer } from './ImageLayer.js';
-export { ObjectKind, ObjectLayer } from './ObjectLayer.js';
-export { TileLayer } from './TileLayer.js';
-export { TileMap } from './TileMap.js';
-export { TileSet } from './TileSet.js';
-export { TileLayerNode } from './TileLayerNode.js';
-export { TileMapNode } from './TileMapNode.js';
-export { TileMapBand } from './TileMapBand.js';
-export { TileMapView } from './TileMapView.js';
-export { TILE_TRANSFORM_IDENTITY, TilePropertyKind, tileToChunkCoord, tileToLocalInChunk } from './types.js';
-export { TileAnimator } from './TileAnimator.js';
-export { autoTile, refreshCell } from './autoTile.js';
-export { WangSet } from './WangSet.js';
-//# sourceMappingURL=index.js.map
+import { TILE_TRANSFORM_IDENTITY, TilePropertyKind, packTile, tileToChunkCoord, tileToLocalInChunk, unpackTile } from "./types.js";
+import { ImageLayer } from "./ImageLayer.js";
+import { ImageLayerNode } from "./ImageLayerNode.js";
+import { TileLayerNode } from "./TileLayerNode.js";
+import { TileMapNode } from "./TileMapNode.js";
+import { TileLayer } from "./TileLayer.js";
+import { TileMapBand } from "./TileMapBand.js";
+import { TileMapView } from "./TileMapView.js";
+import { TileSet } from "./TileSet.js";
+import { TileMap } from "./TileMap.js";
+import { tilemapExtension } from "./tilemapExtension.js";
+import { ObjectKind, ObjectLayer } from "./ObjectLayer.js";
+import { MapLevelSide, MapWorld } from "./MapWorld.js";
+import { MapLevelRuntime, MapWorldRuntime } from "./MapWorldRuntime.js";
+import { mapObjectDescriptor, mapObjectDescriptors } from "./MapObject.js";
+import { MapSpawnSession } from "./MapSpawnSession.js";
+import { MapObjectSpawner, MapSpawnError } from "./MapObjectSpawner.js";
+import { TileAnimator } from "./TileAnimator.js";
+import { buildTileCollisionGeometry } from "./tileCollision.js";
+import { ChunkStreamer } from "./ChunkStreamer.js";
+import { createSampledChunkSource } from "./SampledChunkSource.js";
+import { createWorkerSampledChunkSource } from "./WorkerSampledChunkSource.js";
+import { autoTile, refreshCell } from "./autoTile.js";
+import { WangSet } from "./WangSet.js";
+
+export { ChunkStreamer, ImageLayer, ImageLayerNode, MapLevelRuntime, MapLevelSide, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectKind, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileAnimator, TileLayer, TileLayerNode, TileMap, TileMapBand, TileMapNode, TileMapView, TilePropertyKind, TileSet, WangSet, autoTile, buildTileCollisionGeometry, createSampledChunkSource, createWorkerSampledChunkSource, mapObjectDescriptor, mapObjectDescriptors, packTile, refreshCell, tileToChunkCoord, tileToLocalInChunk, tilemapExtension, unpackTile };

package/dist/esm/nodeBounds.d.ts

@@ -0,0 +1,20 @@
+import type { SceneNode } from '@codexo/exojs';
+import { Rectangle } from '@codexo/exojs';
+/**
+ * Grow `out` to the union of `children`'s local bounds, each transformed by
+ * the child's own (translation-only, in practice) local transform - i.e. the
+ * children's combined extent expressed in the *parent's* local coordinate
+ * space, not the parent's own position/scale/rotation.
+ *
+ * Used as the unbounded-layer/-map fallback for `getLocalBounds()`: `Container`
+ * does not aggregate children into its own local bounds automatically (only
+ * `getBounds()` - global - does that), so nodes that want a children-derived
+ * local rect must compute it explicitly. Mirrors `Container.updateBounds()`'s
+ * own aggregation semantics, including skipping invisible children. Callers
+ * are expected to only invoke this when `children.length > 0`; `out` is left
+ * untouched otherwise (also guarded internally in case a future call site
+ * forgets to check).
+ * @internal
+ */
+export declare const aggregateChildLocalBounds: (children: readonly SceneNode[], out: Rectangle) => void;
+//# sourceMappingURL=nodeBounds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeBounds.d.ts","sourceRoot":"","sources":["../../src/nodeBounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,yBAAyB,GAAI,UAAU,SAAS,SAAS,EAAE,EAAE,KAAK,SAAS,KAAG,IA6B1F,CAAC"}

package/dist/esm/nodeBounds.js

@@ -0,0 +1,40 @@
+import { Rectangle } from "@codexo/exojs";
+
+//#region src/nodeBounds.ts
+/**
+* Grow `out` to the union of `children`'s local bounds, each transformed by
+* the child's own (translation-only, in practice) local transform - i.e. the
+* children's combined extent expressed in the *parent's* local coordinate
+* space, not the parent's own position/scale/rotation.
+*
+* Used as the unbounded-layer/-map fallback for `getLocalBounds()`: `Container`
+* does not aggregate children into its own local bounds automatically (only
+* `getBounds()` - global - does that), so nodes that want a children-derived
+* local rect must compute it explicitly. Mirrors `Container.updateBounds()`'s
+* own aggregation semantics, including skipping invisible children. Callers
+* are expected to only invoke this when `children.length > 0`; `out` is left
+* untouched otherwise (also guarded internally in case a future call site
+* forgets to check).
+* @internal
+*/
+const aggregateChildLocalBounds = (children, out) => {
+	if (children.length === 0) return;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const child of children) {
+		if (!child.visible) continue;
+		const rect = child.getLocalBounds().transform(child.getTransform(), Rectangle.temp);
+		minX = Math.min(minX, rect.left);
+		minY = Math.min(minY, rect.top);
+		maxX = Math.max(maxX, rect.right);
+		maxY = Math.max(maxY, rect.bottom);
+	}
+	if (minX === Infinity) return;
+	out.set(minX, minY, maxX - minX, maxY - minY);
+};
+
+//#endregion
+export { aggregateChildLocalBounds };
+//# sourceMappingURL=nodeBounds.js.map

package/dist/esm/nodeBounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeBounds.js","names":[],"sources":["../../src/nodeBounds.ts"],"sourcesContent":["import type { SceneNode } from '@codexo/exojs';\nimport { Rectangle } from '@codexo/exojs';\n\n/**\n * Grow `out` to the union of `children`'s local bounds, each transformed by\n * the child's own (translation-only, in practice) local transform - i.e. the\n * children's combined extent expressed in the *parent's* local coordinate\n * space, not the parent's own position/scale/rotation.\n *\n * Used as the unbounded-layer/-map fallback for `getLocalBounds()`: `Container`\n * does not aggregate children into its own local bounds automatically (only\n * `getBounds()` - global - does that), so nodes that want a children-derived\n * local rect must compute it explicitly. Mirrors `Container.updateBounds()`'s\n * own aggregation semantics, including skipping invisible children. Callers\n * are expected to only invoke this when `children.length > 0`; `out` is left\n * untouched otherwise (also guarded internally in case a future call site\n * forgets to check).\n * @internal\n */\nexport const aggregateChildLocalBounds = (children: readonly SceneNode[], out: Rectangle): void => {\n  if (children.length === 0) {\n    return;\n  }\n\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n\n  for (const child of children) {\n    if (!child.visible) {\n      continue;\n    }\n\n    const rect = child.getLocalBounds().transform(child.getTransform(), Rectangle.temp);\n\n    minX = Math.min(minX, rect.left);\n    minY = Math.min(minY, rect.top);\n    maxX = Math.max(maxX, rect.right);\n    maxY = Math.max(maxY, rect.bottom);\n  }\n\n  if (minX === Infinity) {\n    // Every child was invisible; nothing to aggregate.\n    return;\n  }\n\n  out.set(minX, minY, maxX - minX, maxY - minY);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAa,6BAA6B,UAAgC,QAAyB;CACjG,IAAI,SAAS,WAAW,GACtB;CAGF,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CAEX,KAAK,MAAM,SAAS,UAAU;EAC5B,IAAI,CAAC,MAAM,SACT;EAGF,MAAM,OAAO,MAAM,eAAe,CAAC,CAAC,UAAU,MAAM,aAAa,GAAG,UAAU,IAAI;EAElF,OAAO,KAAK,IAAI,MAAM,KAAK,IAAI;EAC/B,OAAO,KAAK,IAAI,MAAM,KAAK,GAAG;EAC9B,OAAO,KAAK,IAAI,MAAM,KAAK,KAAK;EAChC,OAAO,KAAK,IAAI,MAAM,KAAK,MAAM;CACnC;CAEA,IAAI,SAAS,UAEX;CAGF,IAAI,IAAI,MAAM,MAAM,OAAO,MAAM,OAAO,IAAI;AAC9C"}

package/dist/esm/pixelSnap.d.ts

@@ -1,12 +1,13 @@
-import type { PixelSnapMode } from '@codexo/exojs/renderer-sdk';
+import { PixelSnapMode } from '@codexo/exojs/renderer-sdk';
 /**
  * Throw a deterministic error when `mode` is not a valid {@link PixelSnapMode}.
  *
  * Mirrors the core `Drawable` setter's guard so the tilemap node passthroughs
  * (`TileMapView` / `TileMapNode` / `TileLayerNode`) reject JavaScript-invalid
- * values atomically — even for an empty layer that has no chunk drawable to
+ * values atomically - even for an empty layer that has no chunk drawable to
  * delegate the validation to. Kept local because the core guard is not part of
  * the public API surface.
  * @internal
  */
-export declare function assertPixelSnapMode(mode: PixelSnapMode): void;
+export declare const assertPixelSnapMode: (mode: PixelSnapMode) => void;
+//# sourceMappingURL=pixelSnap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pixelSnap.d.ts","sourceRoot":"","sources":["../../src/pixelSnap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,aAAa,KAAG,IASzD,CAAC"}

package/dist/esm/pixelSnap.js

@@ -1,19 +1,21 @@
-const validPixelSnapModes = new Set(['none', 'position', 'geometry']);
+import { PixelSnapMode } from "@codexo/exojs/renderer-sdk";
+
+//#region src/pixelSnap.ts
 /**
- * Throw a deterministic error when `mode` is not a valid {@link PixelSnapMode}.
- *
- * Mirrors the core `Drawable` setter's guard so the tilemap node passthroughs
- * (`TileMapView` / `TileMapNode` / `TileLayerNode`) reject JavaScript-invalid
- * values atomically — even for an empty layer that has no chunk drawable to
- * delegate the validation to. Kept local because the core guard is not part of
- * the public API surface.
- * @internal
- */
-function assertPixelSnapMode(mode) {
-    if (typeof mode !== 'string' || !validPixelSnapModes.has(mode)) {
-        throw new Error(`pixelSnapMode must be 'none', 'position', or 'geometry' (got ${String(mode)}).`);
-    }
-}
+* Throw a deterministic error when `mode` is not a valid {@link PixelSnapMode}.
+*
+* Mirrors the core `Drawable` setter's guard so the tilemap node passthroughs
+* (`TileMapView` / `TileMapNode` / `TileLayerNode`) reject JavaScript-invalid
+* values atomically - even for an empty layer that has no chunk drawable to
+* delegate the validation to. Kept local because the core guard is not part of
+* the public API surface.
+* @internal
+*/
+const assertPixelSnapMode = (mode) => {
+	const value = mode;
+	if (value !== PixelSnapMode.None && value !== PixelSnapMode.Position && value !== PixelSnapMode.Geometry) throw new Error(`pixelSnapMode must be a PixelSnapMode enum value (got ${String(mode)}).`);
+};
 
+//#endregion
 export { assertPixelSnapMode };
-//# sourceMappingURL=pixelSnap.js.map
+//# sourceMappingURL=pixelSnap.js.map

package/dist/esm/pixelSnap.js.map

@@ -1 +1 @@
-{"version":3,"file":"pixelSnap.js","sources":["../../../src/pixelSnap.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA,MAAM,mBAAmB,GAAwB,IAAI,GAAG,CAAS,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;AAElG;;;;;;;;;AASG;AACG,SAAU,mBAAmB,CAAC,IAAmB,EAAA;AACrD,IAAA,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;QAC9D,MAAM,IAAI,KAAK,CAAC,CAAA,6DAAA,EAAgE,MAAM,CAAC,IAAI,CAAC,CAAA,EAAA,CAAI,CAAC;IACnG;AACF;;;;"}
+{"version":3,"file":"pixelSnap.js","names":[],"sources":["../../src/pixelSnap.ts"],"sourcesContent":["import { PixelSnapMode } from '@codexo/exojs/renderer-sdk';\n\n/**\n * Throw a deterministic error when `mode` is not a valid {@link PixelSnapMode}.\n *\n * Mirrors the core `Drawable` setter's guard so the tilemap node passthroughs\n * (`TileMapView` / `TileMapNode` / `TileLayerNode`) reject JavaScript-invalid\n * values atomically - even for an empty layer that has no chunk drawable to\n * delegate the validation to. Kept local because the core guard is not part of\n * the public API surface.\n * @internal\n */\nexport const assertPixelSnapMode = (mode: PixelSnapMode): void => {\n  // Widen first: the parameter type would otherwise narrow the third\n  // comparison to a statically-false branch, but JavaScript callers can pass\n  // anything.\n  const value: unknown = mode;\n\n  if (value !== PixelSnapMode.None && value !== PixelSnapMode.Position && value !== PixelSnapMode.Geometry) {\n    throw new Error(`pixelSnapMode must be a PixelSnapMode enum value (got ${String(mode)}).`);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAa,uBAAuB,SAA8B;CAIhE,MAAM,QAAiB;CAEvB,IAAI,UAAU,cAAc,QAAQ,UAAU,cAAc,YAAY,UAAU,cAAc,UAC9F,MAAM,IAAI,MAAM,yDAAyD,OAAO,IAAI,EAAE,GAAG;AAE7F"}

package/dist/esm/public.d.ts

@@ -1,27 +1,47 @@
 export { tilemapExtension } from './tilemapExtension';
 export type { Extension } from '@codexo/exojs/extensions';
+export type { ChunkPayload, ChunkSource } from './ChunkSource';
 export type { ImageLayerOptions } from './ImageLayer';
 export { ImageLayer } from './ImageLayer';
 export type { EllipseObject, ObjectLayerOptions, ObjectPoint, ObjectQuery, ObjectSchema, PointObject, PolygonObject, PolylineObject, RectangleObject, TextObject, TextStyle, TileMapObject, TileMapObjectKind, TileObject, TypedObject, } from './ObjectLayer';
 export { ObjectKind, ObjectLayer } from './ObjectLayer';
+export type { MapBounds, MapLevel, MapLevelNeighbour, MapWorldOptions } from './MapWorld';
+export { MapLevelSide, MapWorld } from './MapWorld';
+export type { MapLevelCancelOptions, MapLevelLoadContext, MapLevelLoadOptions, MapLevelProvider, MapWorldRuntimeOptions } from './MapWorldRuntime';
+export { MapLevelRuntime, MapWorldRuntime } from './MapWorldRuntime';
+export type { MapObjectDescriptor } from './MapObject';
+export { mapObjectDescriptor, mapObjectDescriptors } from './MapObject';
+export type { MapObjectFactories, MapObjectFactory, MapObjectSpawnerOptions, MapSpawnErrorReason, MapSpawnOptions, UnknownMapObjectPolicy, } from './MapObjectSpawner';
+export { MapObjectSpawner, MapSpawnError } from './MapObjectSpawner';
+export { MapSpawnSession } from './MapSpawnSession';
 export type { ReadonlyTileChunk } from './TileChunk';
-export type { TileLayerOptions } from './TileLayer';
+export type { ChunkRange, TileLayerOptions } from './TileLayer';
 export { TileLayer } from './TileLayer';
 export type { TileMapOptions } from './TileMap';
 export { TileMap } from './TileMap';
 export type { TileSetOptions } from './TileSet';
 export { TileSet } from './TileSet';
+export { ImageLayerNode } from './ImageLayerNode';
 export type { TileLayerNodeOptions } from './TileLayerNode';
 export { TileLayerNode } from './TileLayerNode';
 export type { TileMapNodeOptions } from './TileMapNode';
 export { TileMapNode } from './TileMapNode';
 export { TileMapBand } from './TileMapBand';
-export type { TileLayerSelector, TileMapBandDefinition, TileMapViewOptions, } from './TileMapView';
+export type { TileLayerSelector, TileMapBandDefinition, TileMapViewOptions } from './TileMapView';
 export { TileMapView } from './TileMapView';
 export type { ChunkCoord, PackedTile, ResolvedTile, TileAnimationFrame, TileDefinition, TileProperties, TilePropertyObjectRef, TilePropertyPoint, TilePropertyTileRef, TilePropertyValue, TileTransform, } from './types';
-export { TILE_TRANSFORM_IDENTITY, TilePropertyKind, tileToChunkCoord, tileToLocalInChunk, } from './types';
+export { packTile, TILE_TRANSFORM_IDENTITY, TilePropertyKind, tileToChunkCoord, tileToLocalInChunk, unpackTile } from './types';
 export { TileAnimator } from './TileAnimator';
+export type { TileCellSource, TileCollisionGeometry, TileCollisionOptions, TileCollisionRect, TileCollisionShape, TileCollisionShapeKind, TileRegion, } from './tileCollision';
+export { buildTileCollisionGeometry } from './tileCollision';
+export type { ChunkStreamerOptions } from './ChunkStreamer';
+export { ChunkStreamer } from './ChunkStreamer';
+export type { SampledChunkSourceOptions } from './SampledChunkSource';
+export { createSampledChunkSource } from './SampledChunkSource';
+export type { WorkerSampledChunkSourceOptions } from './WorkerSampledChunkSource';
+export { createWorkerSampledChunkSource } from './WorkerSampledChunkSource';
 export type { AutoTileOptions } from './autoTile';
 export { autoTile, refreshCell } from './autoTile';
 export type { WangSetOptions } from './WangSet';
 export { WangSet } from './WangSet';
+//# sourceMappingURL=public.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/public.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/D,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,WAAW,EACX,aAAa,EACb,cAAc,EACd,eAAe,EACf,UAAU,EACV,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAExD,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1F,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEpD,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACnJ,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAErE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxE,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAClG,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EACV,UAAU,EACV,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,QAAQ,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEhI,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAE7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,YAAY,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACnD,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC"}