@codexo/exojs-tiled 0.15.3 → 0.16.0

package/README.md

@@ -6,11 +6,13 @@ into a generic runtime `TileMap` or a typed parsed source model.
 ## Installation
 
 ```sh
-npm install @codexo/exojs @codexo/exojs-tiled
+npm install @codexo/exojs @codexo/exojs-tilemap @codexo/exojs-tiled
 ```
 
-`@codexo/exojs` is a peer dependency. `@codexo/exojs-tilemap` is a regular dependency and is
-installed transitively by `@codexo/exojs-tiled` — you do not need to install it manually.
+Both `@codexo/exojs` and `@codexo/exojs-tilemap` are **peer** dependencies, so install them
+explicitly alongside the adapter. Nothing is pulled in transitively: strict package managers
+(pnpm, Yarn PnP) will not resolve an unlisted peer, and npm's auto-install of peers still leaves
+the versions outside your control. Keep the engine and every adapter on the same version.
 
 If you want the generic tilemap runtime without the Tiled adapter:
 
@@ -20,10 +22,10 @@ npm install @codexo/exojs @codexo/exojs-tilemap
 
 ## What this package provides
 
-- `TileMap` (re-exported from `@codexo/exojs-tilemap`) — generic runtime tilemap; the common-case result of `loader.load(TileMap, url)`
+- `TileMap` (re-exported from `@codexo/exojs-tilemap`) — generic runtime tilemap; the common-case result of `loader.load(Asset.type('tileMap', url))`
 - `TileMapNode` / `TileLayerNode` (re-exported from `@codexo/exojs-tilemap`) — scene nodes that render a loaded `TileMap` on WebGL2/WebGPU
 - `TileMapView` / `TileMapBand` (re-exported from `@codexo/exojs-tilemap`) — group a map's layers into independently placeable bands for interleaving actors between tile layers; same class identity, so `instanceof` holds across both import paths (the canonical view/band docs live in the [`@codexo/exojs-tilemap` README](https://www.npmjs.com/package/@codexo/exojs-tilemap))
-- `TiledMap` — parsed Tiled source model; advanced/diagnostic use via `loader.load(TiledMap, url)`
+- `TiledMap` — parsed Tiled source model; advanced/diagnostic use via `loader.load(Asset.type('tiledSource', url))`
 - `TiledTileset` — parsed tileset (atlas-image or collection-of-images); holds resolved textures
 - `TiledLayer` hierarchy — `TiledTileLayer`, `TiledObjectLayer`, `TiledImageLayer`, `TiledGroupLayer`
 - `TiledObject` — parsed object (point, ellipse, polygon, polyline, text, tile-ref, rectangle)
@@ -43,10 +45,10 @@ import { TileMap, TileMapNode, tiledExtension } from '@codexo/exojs-tiled';
 
 const app = new Application({ extensions: [tiledExtension] });
 
-const map = await app.loader.load(TileMap, 'maps/world.tmj');
+const map = await app.loader.load(Asset.type('tileMap', 'maps/world.tmj'));
 // map is a @codexo/exojs-tilemap TileMap
 
-app.scene.root.addChild(new TileMapNode(map));
+app.scenes.root.addChild(new TileMapNode(map));
 ```
 
 `TileMapNode` and `TileLayerNode` are the same classes exported by `@codexo/exojs-tilemap` (see its
@@ -60,41 +62,27 @@ Load the fully resolved Tiled source model and convert it manually:
 ```ts
 import { TiledMap } from '@codexo/exojs-tiled';
 
-const source = await app.loader.load(TiledMap, 'maps/world.tmj');
+const source = await app.loader.load(Asset.type('tiledSource', 'maps/world.tmj'));
 const map = source.toTileMap();
 ```
 
 Both paths are semantically equivalent. The runtime binding (`TileMap`) uses the Loader-managed
 source-model sub-load internally, so concurrent or duplicate loads are deduplicated.
 
-## `/register` convenience entry
-
-Importing `/register` registers `tiledExtension` (and its `tilemapExtension` dependency) in the
-global `ExtensionRegistry`. Subsequently created Applications that use global defaults will
-receive both extensions automatically.
-
-```ts
-// Side effect: registers tiledExtension in the global ExtensionRegistry.
-import '@codexo/exojs-tiled/register';
-
-// All named exports are also re-exported from /register:
-import { TileMap, TiledMap, tiledExtension } from '@codexo/exojs-tiled/register';
-```
-
 ## Extension dependency
 
 `tiledExtension.dependencies` includes `tilemapExtension` from `@codexo/exojs-tilemap`.
-Registering `tiledExtension` is sufficient — `buildSnapshot` and `ExtensionRegistry.register`
-traverse the dependency graph automatically.
+Passing `tiledExtension` to `ApplicationOptions.extensions` is sufficient — `buildSnapshot`
+traverses the dependency graph automatically.
 
 ## Asset loading
 
-`loader.load(TileMap, url)` (common path) and `loader.load(TiledMap, url)` (advanced path) both:
+`loader.load(Asset.type('tileMap', url))` (common path) and `loader.load(Asset.type('tiledSource', url))` (advanced path) both:
 
 1. Fetch and validate the `.tmj` file.
 2. Resolve each tileset entry (fetches external `.tsj` files via the Loader cache).
 3. Load atlas images (`tileset.image`) and per-tile images (collection-of-images tilesets)
-   via `loader.load(Texture, …)` — the Loader deduplicates identical URLs.
+   via `loader.load(imageUrl)` — the Loader deduplicates identical URLs.
 4. Validate GID ranges (no duplicates, no overlaps, all layer GIDs covered) — throws
    `TiledFormatError` on any inconsistency.
 
@@ -105,53 +93,53 @@ The runtime binding additionally calls `TiledMap.toTileMap()` to produce the gen
 ```ts
 // `.tmj`/`.tsj` are recognised by extension; a format hint is only needed for
 // Tiled data served from a generic `.json` path:
-await loader.load(TileMap, 'maps/world.json', { format: 'tiled' });
+await loader.load(Asset.type('tileMap', 'maps/world.json', { format: 'tiled' }));
 ```
 
-| Option | Type | Default | Description |
-|---|---|---|---|
+| Option   | Type      | Default   | Description                                                                                                                                                                                             |
+| -------- | --------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `format` | `'tiled'` | `'tiled'` | Format hint for ambiguous `.json` paths. `.tmj`/`.tsj` are recognised by extension. `'tiled'` is the only accepted value (a foreign format is a compile error). Participates in the asset identity key. |
 
-Options are optional. Parsing is always strict: `validateTiledMapData` throws a `TiledFormatError` on any malformed *known* field, and silently preserves *unknown* fields (so real-world Tiled files using features ExoJS does not model still load).
+Options are optional. Parsing is always strict: `validateTiledMapData` throws a `TiledFormatError` on any malformed _known_ field, and silently preserves _unknown_ fields (so real-world Tiled files using features ExoJS does not model still load).
 
 ## Parsed API overview
 
 ### `TiledMap`
 
 ```ts
-map.source            // resolved URL this map was loaded from
-map.width             // map width in tiles
-map.height            // map height in tiles
-map.tileWidth         // tile grid cell width in pixels
-map.tileHeight        // tile grid cell height in pixels
-map.orientation       // 'orthogonal' | 'isometric' | 'staggered' | 'hexagonal'
-map.renderOrder       // 'right-down' | 'right-up' | 'left-down' | 'left-up' | undefined
-map.infinite          // true for infinite maps (layers use chunks, not flat data)
-map.backgroundColor   // optional CSS color string
-map.layers            // TiledLayer[] — parsed layer hierarchy
-map.tilesets          // TiledTileset[] — sorted by firstGid ascending
-map.properties        // TiledPropertyData[] — custom properties
-map.findTilesetForGid(gid)  // → TiledTileset | undefined (masks flip bits automatically)
-map.getProperty(name)       // → TiledPropertyData | undefined
-map.toTileMap()             // → TileMap — synchronous runtime conversion
-map.destroy()               // no-op; textures are Loader-owned
+map.source; // resolved URL this map was loaded from
+map.width; // map width in tiles
+map.height; // map height in tiles
+map.tileWidth; // tile grid cell width in pixels
+map.tileHeight; // tile grid cell height in pixels
+map.orientation; // 'orthogonal' | 'isometric' | 'staggered' | 'hexagonal'
+map.renderOrder; // 'right-down' | 'right-up' | 'left-down' | 'left-up' | undefined
+map.infinite; // true for infinite maps (layers use chunks, not flat data)
+map.backgroundColor; // optional CSS color string
+map.layers; // TiledLayer[] — parsed layer hierarchy
+map.tilesets; // TiledTileset[] — sorted by firstGid ascending
+map.properties; // TiledPropertyData[] — custom properties
+map.findTilesetForGid(gid); // → TiledTileset | undefined (masks flip bits automatically)
+map.getProperty(name); // → TiledPropertyData | undefined
+map.toTileMap(); // → TileMap — synchronous runtime conversion
+map.destroy(); // no-op; textures are Loader-owned
 ```
 
 ### `TiledTileset`
 
 ```ts
-tileset.firstGid      // first GID in this tileset's range (inclusive)
-tileset.lastGid       // last GID in this tileset's range (inclusive)
-tileset.name
-tileset.tileWidth / tileHeight
-tileset.tileCount / columns / spacing / margin
-tileset.source        // resolved .tsj URL (undefined for embedded tilesets)
-tileset.imageUrl      // resolved atlas image URL (undefined for collection-of-images)
-tileset.texture       // Texture loaded for imageUrl (Loader-owned)
-tileset.tileTextures  // Map<localId, Texture> for collection-of-images tilesets (Loader-owned)
-tileset.tiles         // TiledTileData[] — per-tile animation/property/collision data
-tileset.getTile(localId)    // → TiledTileData | undefined
-tileset.getProperty(name)   // → TiledPropertyData | undefined
+tileset.firstGid; // first GID in this tileset's range (inclusive)
+tileset.lastGid; // last GID in this tileset's range (inclusive)
+tileset.name;
+tileset.tileWidth / tileHeight;
+tileset.tileCount / columns / spacing / margin;
+tileset.source; // resolved .tsj URL (undefined for embedded tilesets)
+tileset.imageUrl; // resolved atlas image URL (undefined for collection-of-images)
+tileset.texture; // Texture loaded for imageUrl (Loader-owned)
+tileset.tileTextures; // Map<localId, Texture> for collection-of-images tilesets (Loader-owned)
+tileset.tiles; // TiledTileData[] — per-tile animation/property/collision data
+tileset.getTile(localId); // → TiledTileData | undefined
+tileset.getProperty(name); // → TiledPropertyData | undefined
 ```
 
 ### `TiledLayer` subclasses
@@ -159,18 +147,23 @@ tileset.getProperty(name)   // → TiledPropertyData | undefined
 All layers extend `TiledLayer` (base: `id`, `name`, `class`, `visible`, `opacity`, `x`, `y`,
 `offsetX/Y`, `parallaxX/Y`, `tintColor`, `properties`, `getProperty(name)`).
 
-| Subclass | `type` | Extra fields |
-|---|---|---|
-| `TiledTileLayer` | `'tilelayer'` | `width`, `height`, `data?: number[]` (finite), `chunks?` (infinite) |
-| `TiledObjectLayer` | `'objectgroup'` | `drawOrder`, `objects: TiledObject[]` |
-| `TiledImageLayer` | `'imagelayer'` | `image`, `repeatX`, `repeatY` |
-| `TiledGroupLayer` | `'group'` | `layers: TiledLayer[]` |
+| Subclass           | `type`          | Extra fields                                                        |
+| ------------------ | --------------- | ------------------------------------------------------------------- |
+| `TiledTileLayer`   | `'tilelayer'`   | `width`, `height`, `data?: number[]` (finite), `chunks?` (infinite) |
+| `TiledObjectLayer` | `'objectgroup'` | `drawOrder`, `objects: TiledObject[]`                               |
+| `TiledImageLayer`  | `'imagelayer'`  | `image`, `repeatX`, `repeatY`                                       |
+| `TiledGroupLayer`  | `'group'`       | `layers: TiledLayer[]`                                              |
 
 ### `TiledObject`
 
 Shape discriminants: `point` (boolean), `ellipse` (boolean), `polygon`, `polyline`, `text`,
 `gid` (tile object). If none are set, the object is a plain rectangle.
 
+`TiledObject.type` is the object's **class**, normalised across Tiled versions: 1.9 wrote it as
+`class` in the JSON, every other version as `type`. A file carries one of the two, so `class` wins
+when present and non-empty. That string is also the dispatch key a
+[`MapObjectSpawner`](https://www.npmjs.com/package/@codexo/exojs-tilemap) sees.
+
 ## Texture ownership
 
 Textures for tileset images are loaded via the Loader and remain in the Loader cache.
@@ -180,8 +173,8 @@ The Loader handles texture lifecycle (including deduplication across maps that s
 ## Core compatibility
 
 | `@codexo/exojs-tiled` | `@codexo/exojs` |
-|---|---|
-| 0.13.x | 0.13.x |
+| --------------------- | --------------- |
+| 0.13.x                | 0.13.x          |
 
 ## Links
 

package/dist/esm/TiledLayer.d.ts

@@ -69,4 +69,5 @@ export declare class TiledGroupLayer extends TiledLayer {
     constructor(data: TiledGroupLayerData);
 }
 /** Constructs the appropriate {@link TiledLayer} subclass for `data.type`. */
-export declare function createTiledLayer(data: TiledLayerData): TiledLayer;
+export declare const createTiledLayer: (data: TiledLayerData) => TiledLayer;
+//# sourceMappingURL=TiledLayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TiledLayer.d.ts","sourceRoot":"","sources":["../../src/TiledLayer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,2GAA2G;AAC3G,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAEpD;;;;;;;GAOG;AACH,8BAAsB,UAAU;IAC9B,kBAAyB,IAAI,EAAE,cAAc,CAAC;IAE9C,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,SAAgB,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAEzD,SAAS,aAAa,IAAI,EAAE,kBAAkB;IAgB9C,0CAA0C;IACnC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;CAGhE;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAC5C,SAAyB,IAAI,EAAG,WAAW,CAAU;IAErD,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACrD,SAAgB,MAAM,CAAC,EAAE,SAAS,cAAc,EAAE,GAAG,SAAS,CAAC;gBAE5C,IAAI,EAAE,kBAAkB;CAO5C;AAED,4DAA4D;AAC5D,qBAAa,gBAAiB,SAAQ,UAAU;IAC9C,SAAyB,IAAI,EAAG,aAAa,CAAU;IAEvD,SAAgB,SAAS,EAAE,WAAW,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC;IAC1E,SAAgB,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;gBAE7B,IAAI,EAAE,oBAAoB;CAK9C;AAED;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,SAAyB,IAAI,EAAG,YAAY,CAAU;IAEtD,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,OAAO,EAAE,OAAO,CAAC;gBAEd,IAAI,EAAE,mBAAmB;CAM7C;AAED,mEAAmE;AACnE,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,SAAyB,IAAI,EAAG,OAAO,CAAU;IAEjD,SAAgB,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;gBAE3B,IAAI,EAAE,mBAAmB;CAI7C;AAED,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,GAAI,MAAM,cAAc,KAAG,UAWvD,CAAC"}

package/dist/esm/TiledLayer.js

@@ -1,117 +1,115 @@
-import { TiledObject } from './TiledObject.js';
+import { TiledObject } from "./TiledObject.js";
 
+//#region src/TiledLayer.ts
 /**
- * Base class for the four parsed Tiled layer types. Holds the fields shared
- * by every layer (`tilelayer`, `objectgroup`, `imagelayer`, `group`).
- *
- * Use {@link TiledLayer.type} (or `instanceof`) to discriminate between
- * {@link TiledTileLayer}, {@link TiledObjectLayer}, {@link TiledImageLayer},
- * and {@link TiledGroupLayer}.
- */
-class TiledLayer {
-    id;
-    name;
-    class;
-    visible;
-    opacity;
-    x;
-    y;
-    offsetX;
-    offsetY;
-    parallaxX;
-    parallaxY;
-    tintColor;
-    properties;
-    constructor(data) {
-        this.id = data.id;
-        this.name = data.name;
-        this.class = data.class ?? '';
-        this.visible = data.visible;
-        this.opacity = data.opacity;
-        this.x = data.x;
-        this.y = data.y;
-        this.offsetX = data.offsetx ?? 0;
-        this.offsetY = data.offsety ?? 0;
-        this.parallaxX = data.parallaxx ?? 1;
-        this.parallaxY = data.parallaxy ?? 1;
-        this.tintColor = data.tintcolor;
-        this.properties = data.properties ?? [];
-    }
-    /** Looks up a custom property by name. */
-    getProperty(name) {
-        return this.properties.find(property => property.name === name);
-    }
-}
+* Base class for the four parsed Tiled layer types. Holds the fields shared
+* by every layer (`tilelayer`, `objectgroup`, `imagelayer`, `group`).
+*
+* Use {@link TiledLayer.type} (or `instanceof`) to discriminate between
+* {@link TiledTileLayer}, {@link TiledObjectLayer}, {@link TiledImageLayer},
+* and {@link TiledGroupLayer}.
+*/
+var TiledLayer = class {
+	id;
+	name;
+	class;
+	visible;
+	opacity;
+	x;
+	y;
+	offsetX;
+	offsetY;
+	parallaxX;
+	parallaxY;
+	tintColor;
+	properties;
+	constructor(data) {
+		this.id = data.id;
+		this.name = data.name;
+		this.class = data.class ?? "";
+		this.visible = data.visible;
+		this.opacity = data.opacity;
+		this.x = data.x;
+		this.y = data.y;
+		this.offsetX = data.offsetx ?? 0;
+		this.offsetY = data.offsety ?? 0;
+		this.parallaxX = data.parallaxx ?? 1;
+		this.parallaxY = data.parallaxy ?? 1;
+		this.tintColor = data.tintcolor;
+		this.properties = data.properties ?? [];
+	}
+	/** Looks up a custom property by name. */
+	getProperty(name) {
+		return this.properties.find((property) => property.name === name);
+	}
+};
 /**
- * A tile layer. On a finite map, {@link data} holds the flat row-major array
- * of GIDs (`width * height` entries). On an infinite map, {@link chunks}
- * holds the sparse list of tile chunks instead; exactly one of the two is
- * defined, matching the owning {@link TiledMap}'s `infinite` flag.
- */
-class TiledTileLayer extends TiledLayer {
-    type = 'tilelayer';
-    width;
-    height;
-    data;
-    chunks;
-    constructor(data) {
-        super(data);
-        this.width = data.width;
-        this.height = data.height;
-        this.data = data.data;
-        this.chunks = data.chunks;
-    }
-}
+* A tile layer. On a finite map, {@link data} holds the flat row-major array
+* of GIDs (`width * height` entries). On an infinite map, {@link chunks}
+* holds the sparse list of tile chunks instead; exactly one of the two is
+* defined, matching the owning {@link TiledMap}'s `infinite` flag.
+*/
+var TiledTileLayer = class extends TiledLayer {
+	type = "tilelayer";
+	width;
+	height;
+	data;
+	chunks;
+	constructor(data) {
+		super(data);
+		this.width = data.width;
+		this.height = data.height;
+		this.data = data.data;
+		this.chunks = data.chunks;
+	}
+};
 /** An object layer: a flat list of {@link TiledObject}s. */
-class TiledObjectLayer extends TiledLayer {
-    type = 'objectgroup';
-    drawOrder;
-    objects;
-    constructor(data) {
-        super(data);
-        this.drawOrder = data.draworder ?? 'topdown';
-        this.objects = data.objects.map(object => new TiledObject(object));
-    }
-}
+var TiledObjectLayer = class extends TiledLayer {
+	type = "objectgroup";
+	drawOrder;
+	objects;
+	constructor(data) {
+		super(data);
+		this.drawOrder = data.draworder ?? "topdown";
+		this.objects = data.objects.map((object) => new TiledObject(object));
+	}
+};
 /**
- * An image layer. {@link image} is the path to the layer's image exactly as
- * written in the Tiled JSON (relative to the map's location); resolving it
- * against the owning {@link TiledMap}'s `source` is left to the consumer.
- */
-class TiledImageLayer extends TiledLayer {
-    type = 'imagelayer';
-    image;
-    repeatX;
-    repeatY;
-    constructor(data) {
-        super(data);
-        this.image = data.image;
-        this.repeatX = data.repeatx ?? false;
-        this.repeatY = data.repeaty ?? false;
-    }
-}
+* An image layer. {@link image} is the path to the layer's image exactly as
+* written in the Tiled JSON (relative to the map's location); resolving it
+* against the owning {@link TiledMap}'s `source` is left to the consumer.
+*/
+var TiledImageLayer = class extends TiledLayer {
+	type = "imagelayer";
+	image;
+	repeatX;
+	repeatY;
+	constructor(data) {
+		super(data);
+		this.image = data.image;
+		this.repeatX = data.repeatx ?? false;
+		this.repeatY = data.repeaty ?? false;
+	}
+};
 /** A group layer, recursively containing further parsed layers. */
-class TiledGroupLayer extends TiledLayer {
-    type = 'group';
-    layers;
-    constructor(data) {
-        super(data);
-        this.layers = data.layers.map(createTiledLayer);
-    }
-}
+var TiledGroupLayer = class extends TiledLayer {
+	type = "group";
+	layers;
+	constructor(data) {
+		super(data);
+		this.layers = data.layers.map(createTiledLayer);
+	}
+};
 /** Constructs the appropriate {@link TiledLayer} subclass for `data.type`. */
-function createTiledLayer(data) {
-    switch (data.type) {
-        case 'tilelayer':
-            return new TiledTileLayer(data);
-        case 'objectgroup':
-            return new TiledObjectLayer(data);
-        case 'imagelayer':
-            return new TiledImageLayer(data);
-        case 'group':
-            return new TiledGroupLayer(data);
-    }
-}
+const createTiledLayer = (data) => {
+	switch (data.type) {
+		case "tilelayer": return new TiledTileLayer(data);
+		case "objectgroup": return new TiledObjectLayer(data);
+		case "imagelayer": return new TiledImageLayer(data);
+		case "group": return new TiledGroupLayer(data);
+	}
+};
 
+//#endregion
 export { TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer, createTiledLayer };
-//# sourceMappingURL=TiledLayer.js.map
+//# sourceMappingURL=TiledLayer.js.map

package/dist/esm/TiledLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"TiledLayer.js","sources":["../../../src/TiledLayer.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAeA;;;;;;;AAOG;MACmB,UAAU,CAAA;AAGd,IAAA,EAAE;AACF,IAAA,IAAI;AACJ,IAAA,KAAK;AACL,IAAA,OAAO;AACP,IAAA,OAAO;AACP,IAAA,CAAC;AACD,IAAA,CAAC;AACD,IAAA,OAAO;AACP,IAAA,OAAO;AACP,IAAA,SAAS;AACT,IAAA,SAAS;AACT,IAAA,SAAS;AACT,IAAA,UAAU;AAE1B,IAAA,WAAA,CAAsB,IAAwB,EAAA;AAC5C,QAAA,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;AACjB,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI;QACrB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,EAAE;AAC7B,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO;AAC3B,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO;AAC3B,QAAA,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AACf,QAAA,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QACf,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,CAAC;QACpC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,CAAC;AACpC,QAAA,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS;QAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,EAAE;IACzC;;AAGO,IAAA,WAAW,CAAC,IAAY,EAAA;AAC7B,QAAA,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC;IACjE;AACD;AAED;;;;;AAKG;AACG,MAAO,cAAe,SAAQ,UAAU,CAAA;IACnB,IAAI,GAAG,WAAoB;AAEpC,IAAA,KAAK;AACL,IAAA,MAAM;AACN,IAAA,IAAI;AACJ,IAAA,MAAM;AAEtB,IAAA,WAAA,CAAmB,IAAwB,EAAA;QACzC,KAAK,CAAC,IAAI,CAAC;AACX,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;AACvB,QAAA,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM;AACzB,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI;AACrB,QAAA,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM;IAC3B;AACD;AAED;AACM,MAAO,gBAAiB,SAAQ,UAAU,CAAA;IACrB,IAAI,GAAG,aAAsB;AAEtC,IAAA,SAAS;AACT,IAAA,OAAO;AAEvB,IAAA,WAAA,CAAmB,IAA0B,EAAA;QAC3C,KAAK,CAAC,IAAI,CAAC;QACX,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,SAAS;AAC5C,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;IACpE;AACD;AAED;;;;AAIG;AACG,MAAO,eAAgB,SAAQ,UAAU,CAAA;IACpB,IAAI,GAAG,YAAqB;AAErC,IAAA,KAAK;AACL,IAAA,OAAO;AACP,IAAA,OAAO;AAEvB,IAAA,WAAA,CAAmB,IAAyB,EAAA;QAC1C,KAAK,CAAC,IAAI,CAAC;AACX,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,KAAK;QACpC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,KAAK;IACtC;AACD;AAED;AACM,MAAO,eAAgB,SAAQ,UAAU,CAAA;IACpB,IAAI,GAAG,OAAgB;AAEhC,IAAA,MAAM;AAEtB,IAAA,WAAA,CAAmB,IAAyB,EAAA;QAC1C,KAAK,CAAC,IAAI,CAAC;QACX,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC;IACjD;AACD;AAED;AACM,SAAU,gBAAgB,CAAC,IAAoB,EAAA;AACnD,IAAA,QAAQ,IAAI,CAAC,IAAI;AACf,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,IAAI,cAAc,CAAC,IAAI,CAAC;AACjC,QAAA,KAAK,aAAa;AAChB,YAAA,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC;AACnC,QAAA,KAAK,YAAY;AACf,YAAA,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC;AAClC,QAAA,KAAK,OAAO;AACV,YAAA,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC;;AAEtC;;;;"}
+{"version":3,"file":"TiledLayer.js","names":[],"sources":["../../src/TiledLayer.ts"],"sourcesContent":["import type {\n  TiledChunkData,\n  TiledGroupLayerData,\n  TiledImageLayerData,\n  TiledLayerData,\n  TiledLayerDataBase,\n  TiledObjectLayerData,\n  TiledPropertyData,\n  TiledTileLayerData,\n} from './data';\nimport { TiledObject } from './TiledObject';\n\n/** Discriminant shared by every {@link TiledLayer} subclass, mirroring {@link TiledLayerData}'s `type`. */\nexport type TiledLayerType = TiledLayerData['type'];\n\n/**\n * Base class for the four parsed Tiled layer types. Holds the fields shared\n * by every layer (`tilelayer`, `objectgroup`, `imagelayer`, `group`).\n *\n * Use {@link TiledLayer.type} (or `instanceof`) to discriminate between\n * {@link TiledTileLayer}, {@link TiledObjectLayer}, {@link TiledImageLayer},\n * and {@link TiledGroupLayer}.\n */\nexport abstract class TiledLayer {\n  public abstract readonly type: TiledLayerType;\n\n  public readonly id: number;\n  public readonly name: string;\n  public readonly class: string;\n  public readonly visible: boolean;\n  public readonly opacity: number;\n  public readonly x: number;\n  public readonly y: number;\n  public readonly offsetX: number;\n  public readonly offsetY: number;\n  public readonly parallaxX: number;\n  public readonly parallaxY: number;\n  public readonly tintColor?: string | undefined;\n  public readonly properties: readonly TiledPropertyData[];\n\n  protected constructor(data: TiledLayerDataBase) {\n    this.id = data.id;\n    this.name = data.name;\n    this.class = data.class ?? '';\n    this.visible = data.visible;\n    this.opacity = data.opacity;\n    this.x = data.x;\n    this.y = data.y;\n    this.offsetX = data.offsetx ?? 0;\n    this.offsetY = data.offsety ?? 0;\n    this.parallaxX = data.parallaxx ?? 1;\n    this.parallaxY = data.parallaxy ?? 1;\n    this.tintColor = data.tintcolor;\n    this.properties = data.properties ?? [];\n  }\n\n  /** Looks up a custom property by name. */\n  public getProperty(name: string): TiledPropertyData | undefined {\n    return this.properties.find(property => property.name === name);\n  }\n}\n\n/**\n * A tile layer. On a finite map, {@link data} holds the flat row-major array\n * of GIDs (`width * height` entries). On an infinite map, {@link chunks}\n * holds the sparse list of tile chunks instead; exactly one of the two is\n * defined, matching the owning {@link TiledMap}'s `infinite` flag.\n */\nexport class TiledTileLayer extends TiledLayer {\n  public override readonly type = 'tilelayer' as const;\n\n  public readonly width: number;\n  public readonly height: number;\n  public readonly data?: readonly number[] | undefined;\n  public readonly chunks?: readonly TiledChunkData[] | undefined;\n\n  public constructor(data: TiledTileLayerData) {\n    super(data);\n    this.width = data.width;\n    this.height = data.height;\n    this.data = data.data;\n    this.chunks = data.chunks;\n  }\n}\n\n/** An object layer: a flat list of {@link TiledObject}s. */\nexport class TiledObjectLayer extends TiledLayer {\n  public override readonly type = 'objectgroup' as const;\n\n  public readonly drawOrder: NonNullable<TiledObjectLayerData['draworder']>;\n  public readonly objects: readonly TiledObject[];\n\n  public constructor(data: TiledObjectLayerData) {\n    super(data);\n    this.drawOrder = data.draworder ?? 'topdown';\n    this.objects = data.objects.map(object => new TiledObject(object));\n  }\n}\n\n/**\n * An image layer. {@link image} is the path to the layer's image exactly as\n * written in the Tiled JSON (relative to the map's location); resolving it\n * against the owning {@link TiledMap}'s `source` is left to the consumer.\n */\nexport class TiledImageLayer extends TiledLayer {\n  public override readonly type = 'imagelayer' as const;\n\n  public readonly image: string;\n  public readonly repeatX: boolean;\n  public readonly repeatY: boolean;\n\n  public constructor(data: TiledImageLayerData) {\n    super(data);\n    this.image = data.image;\n    this.repeatX = data.repeatx ?? false;\n    this.repeatY = data.repeaty ?? false;\n  }\n}\n\n/** A group layer, recursively containing further parsed layers. */\nexport class TiledGroupLayer extends TiledLayer {\n  public override readonly type = 'group' as const;\n\n  public readonly layers: readonly TiledLayer[];\n\n  public constructor(data: TiledGroupLayerData) {\n    super(data);\n    this.layers = data.layers.map(createTiledLayer);\n  }\n}\n\n/** Constructs the appropriate {@link TiledLayer} subclass for `data.type`. */\nexport const createTiledLayer = (data: TiledLayerData): TiledLayer => {\n  switch (data.type) {\n    case 'tilelayer':\n      return new TiledTileLayer(data);\n    case 'objectgroup':\n      return new TiledObjectLayer(data);\n    case 'imagelayer':\n      return new TiledImageLayer(data);\n    case 'group':\n      return new TiledGroupLayer(data);\n  }\n};\n"],"mappings":";;;;;;;;;;;AAuBA,IAAsB,aAAtB,MAAiC;CAG/B,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,AAAU,YAAY,MAA0B;EAC9C,KAAK,KAAK,KAAK;EACf,KAAK,OAAO,KAAK;EACjB,KAAK,QAAQ,KAAK,SAAS;EAC3B,KAAK,UAAU,KAAK;EACpB,KAAK,UAAU,KAAK;EACpB,KAAK,IAAI,KAAK;EACd,KAAK,IAAI,KAAK;EACd,KAAK,UAAU,KAAK,WAAW;EAC/B,KAAK,UAAU,KAAK,WAAW;EAC/B,KAAK,YAAY,KAAK,aAAa;EACnC,KAAK,YAAY,KAAK,aAAa;EACnC,KAAK,YAAY,KAAK;EACtB,KAAK,aAAa,KAAK,cAAc,CAAC;CACxC;;CAGA,AAAO,YAAY,MAA6C;EAC9D,OAAO,KAAK,WAAW,MAAK,aAAY,SAAS,SAAS,IAAI;CAChE;AACF;;;;;;;AAQA,IAAa,iBAAb,cAAoC,WAAW;CAC7C,AAAyB,OAAO;CAEhC,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,AAAO,YAAY,MAA0B;EAC3C,MAAM,IAAI;EACV,KAAK,QAAQ,KAAK;EAClB,KAAK,SAAS,KAAK;EACnB,KAAK,OAAO,KAAK;EACjB,KAAK,SAAS,KAAK;CACrB;AACF;;AAGA,IAAa,mBAAb,cAAsC,WAAW;CAC/C,AAAyB,OAAO;CAEhC,AAAgB;CAChB,AAAgB;CAEhB,AAAO,YAAY,MAA4B;EAC7C,MAAM,IAAI;EACV,KAAK,YAAY,KAAK,aAAa;EACnC,KAAK,UAAU,KAAK,QAAQ,KAAI,WAAU,IAAI,YAAY,MAAM,CAAC;CACnE;AACF;;;;;;AAOA,IAAa,kBAAb,cAAqC,WAAW;CAC9C,AAAyB,OAAO;CAEhC,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,AAAO,YAAY,MAA2B;EAC5C,MAAM,IAAI;EACV,KAAK,QAAQ,KAAK;EAClB,KAAK,UAAU,KAAK,WAAW;EAC/B,KAAK,UAAU,KAAK,WAAW;CACjC;AACF;;AAGA,IAAa,kBAAb,cAAqC,WAAW;CAC9C,AAAyB,OAAO;CAEhC,AAAgB;CAEhB,AAAO,YAAY,MAA2B;EAC5C,MAAM,IAAI;EACV,KAAK,SAAS,KAAK,OAAO,IAAI,gBAAgB;CAChD;AACF;;AAGA,MAAa,oBAAoB,SAAqC;CACpE,QAAQ,KAAK,MAAb;EACE,KAAK,aACH,OAAO,IAAI,eAAe,IAAI;EAChC,KAAK,eACH,OAAO,IAAI,iBAAiB,IAAI;EAClC,KAAK,cACH,OAAO,IAAI,gBAAgB,IAAI;EACjC,KAAK,SACH,OAAO,IAAI,gBAAgB,IAAI;CACnC;AACF"}

package/dist/esm/TiledMap.d.ts

@@ -1,4 +1,5 @@
 import { type Texture } from '@codexo/exojs';
+import type { ChunkSource } from '@codexo/exojs-tilemap';
 import { TileMap } from '@codexo/exojs-tilemap';
 import type { TiledMapData, TiledOrientation, TiledPropertyData, TiledRenderOrder } from './data';
 import { type TiledLayer } from './TiledLayer';
@@ -39,6 +40,7 @@ export declare class TiledMap {
     readonly tilesets: readonly TiledTileset[];
     readonly properties: readonly TiledPropertyData[];
     private readonly _imageTextures;
+    private readonly _chunkSources;
     constructor(source: string, data: TiledMapData, tilesets: readonly TiledTileset[], imageTextures?: ReadonlyMap<number, Texture>);
     /**
      * Returns the tileset that owns `gid`, or `undefined` if `gid` is `0`
@@ -55,17 +57,42 @@ export declare class TiledMap {
      * Convert this parsed Tiled source model into a format-independent runtime
      * {@link TileMap} from `@codexo/exojs-tilemap`.
      *
-     * Only finite orthogonal maps with atlas tilesets are supported. A
-     * non-orthogonal or infinite map, or a collection-of-images tileset, throws
-     * {@link TiledFormatError} rather than silently producing wrong (misplaced)
-     * or empty geometry. Tile layers become renderable `TileLayer`s, object
-     * groups become data-only `ObjectLayer`s, and image layers become data-only
-     * `ImageLayer`s; group layer children are flattened in document order.
+     * Only orthogonal maps with atlas tilesets are supported. A non-orthogonal
+     * map, a collection-of-images tileset, or a tileset with no image at all
+     * throws {@link TiledFormatError} rather than silently producing wrong
+     * (misplaced) or empty geometry. Tile
+     * layers become renderable `TileLayer`s, object groups become data-only
+     * `ObjectLayer`s, and image layers become data-only `ImageLayer`s; group
+     * layer children are flattened in document order.
      *
-     * The returned `TileMap` does **not** own the tileset textures — they remain
+     * The runtime map has no group node, so each group's own style is baked into
+     * its children as Tiled composes it: `visible` ANDs, `opacity` and the
+     * parallax factors multiply, the offsets add, and tint colours multiply per
+     * colour channel. Object layers take the visibility, opacity and offset the
+     * same way - `ObjectLayer` carries no parallax or tint of its own, so a
+     * group's contribution to those two is dropped for object layers only.
+     *
+     * An `infinite: true` (chunked) tile layer converts to an **unbounded**
+     * runtime `TileLayer` with no tiles populated eagerly - its data streams in
+     * on demand via the {@link ChunkSource} built for it, retrievable with
+     * {@link getChunkSource} after this call returns.
+     *
+     * The returned `TileMap` does **not** own the tileset textures - they remain
      * in the Loader cache. Destroying the returned map does not unload textures.
      */
     toTileMap(): TileMap;
+    /**
+     * The {@link ChunkSource} built for the chunked tile layer with the given
+     * Tiled layer `id`, as a side effect of the most recent {@link toTileMap}
+     * call. Returns `undefined` if `toTileMap()` hasn't been called yet, if
+     * `layerId` doesn't name a tile layer, or if that layer is finite
+     * (`data`-based) rather than chunked (`infinite`-map `chunks`-based).
+     *
+     * Call {@link toTileMap} before calling this - it is what builds the
+     * providers this method reads from.
+     * @advanced
+     */
+    getChunkSource(layerId: number): ChunkSource | undefined;
     /**
      * Releases this map's reference to its parsed source. Tileset textures are
      * Loader-owned and may be shared with other maps; this does NOT destroy
@@ -73,3 +100,4 @@ export declare class TiledMap {
      */
     destroy(): void;
 }
+//# sourceMappingURL=TiledMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TiledMap.d.ts","sourceRoot":"","sources":["../../src/TiledMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAEV,WAAW,EAUZ,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAgD,OAAO,EAA6B,MAAM,uBAAuB,CAAC;AAEzH,OAAO,KAAK,EAGV,YAAY,EAEZ,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAEjB,MAAM,QAAQ,CAAC;AAGhB,OAAO,EAAsD,KAAK,UAAU,EAAoC,MAAM,cAAc,CAAC;AAErI,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAInD;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ;IACnB,6CAA6C;IAC7C,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,+DAA+D;IAC/D,SAAgB,IAAI,EAAE,YAAY,CAAC;IAEnC,SAAgB,WAAW,EAAE,gBAAgB,CAAC;IAC9C,SAAgB,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC3D,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,0BAA0B;IAC1B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,2BAA2B;IAC3B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,sCAAsC;IACtC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,uCAAuC;IACvC,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,QAAQ,EAAE,OAAO,CAAC;IAClC,SAAgB,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrD,SAAgB,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IAC9C,oFAAoF;IACpF,SAAgB,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAClD,SAAgB,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAEzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA+B;IAC9D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;gBAE7C,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,YAAY,EAAE,EAAE,aAAa,GAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAa;IAoBjJ;;;;;;;OAOG;IACI,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAgB/D,0CAA0C;IACnC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,SAAS,IAAI,OAAO;IA6J3B;;;;;;;;;;OAUG;IACI,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI/D;;;;OAIG;IACI,OAAO,IAAI,IAAI;CAGvB"}