@codexo/exojs-ldtk 0.15.3 → 0.16.0

package/README.md

@@ -6,23 +6,34 @@ Official ExoJS extension for loading [LDtk](https://ldtk.io) level files (`.ldtk
 ## Installation
 
 ```sh
-npm install @codexo/exojs @codexo/exojs-ldtk
+npm install @codexo/exojs @codexo/exojs-tilemap @codexo/exojs-ldtk
 ```
 
-`@codexo/exojs` is a peer dependency. `@codexo/exojs-tilemap` is a regular dependency and is
-installed transitively — 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.
 
 ## What this package provides
 
-- `LdtkMap` — parsed LDtk world; the result of `loader.load(LdtkMap, url)`. Exposes the raw `data`,
+- `LdtkMap` — parsed LDtk world; the result of `loader.load('world.ldtk')`. Exposes the raw `data`,
   the converted runtime `levels` (`readonly TileMap[]`, in document order), and
   `getLevelByName(identifier)`
+- `LdtkProject` — the streaming counterpart of `LdtkMap`: the result of
+  `loader.load(Asset.type('ldtkProject', 'world.ldtk'))`. Loads the document and every tileset
+  atlas, and **no** level payload. Exposes the world layout (`worlds` / `world`, one `MapWorld`
+  per LDtk world) and `createRuntime({ scope })` for loading levels one at a time
+- `ldtkToMapWorld` — build the format-neutral world model (level ids, bounds, neighbours) from a
+  raw document, without reading any layer payload
 - `ldtkToTileMap` — convert a single LDtk level to a `TileMap` (used internally; available for
   custom pipelines), plus its `LdtkToTileMapOptions`
+- `getLdtkIntGridValueAt` — the named/coloured IntGrid value at a tile coordinate
+- `createLdtkIntGridCellSource` — the layer's IntGrid as a `TileCellSource`, ready to hand to
+  `buildTileCollisionGeometry` or `TileColliderStreamer` for collision authored per cell
 - `ldtkExtension` — extension descriptor; depends on `tilemapExtension` automatically
-- `ldtkMapBinding` — the underlying `AssetBinding` (advanced/custom wiring)
+- `ldtkMapBinding` / `ldtkProjectBinding` — the underlying `AssetBinding`s (advanced/custom wiring)
 - The raw LDtk JSON types (`LdtkData`, `LdtkLevel`, `LdtkLayerInstance`, `LdtkEntityInstance`, …)
-  and the flip-bit constants (`ldtkFlipX`, `ldtkFlipY`, `ldtkFlipXy`, `ldtkFlipNone`)
+  and the flip-bit constants (`LDTK_FLIP_X`, `LDTK_FLIP_Y`, `LDTK_FLIP_XY`, `LDTK_FLIP_NONE`)
 - `TileMap`, `TileMapNode`, `TileMapView`, `TileLayer`, `TileSet`, `ObjectLayer`, … re-exported
   from `@codexo/exojs-tilemap` (same class identity — `instanceof TileMap` holds across both import
   paths)
@@ -39,33 +50,40 @@ import { LdtkMap, TileMapNode, ldtkExtension } from '@codexo/exojs-ldtk';
 
 const app = new Application({ extensions: [ldtkExtension] });
 
-const world = await app.loader.load(LdtkMap, 'levels/world.ldtk');
+const world = await app.loader.load('levels/world.ldtk');
 
 // Render the first level (each LDtk level is its own TileMap):
 const level = world.getLevelByName('Level_0') ?? world.levels[0];
-app.scene.root.addChild(new TileMapNode(level));
+app.scenes.root.addChild(new TileMapNode(level));
 ```
 
 `TileMapNode` is the same class exported by `@codexo/exojs-tilemap` (see its
 [README](https://www.npmjs.com/package/@codexo/exojs-tilemap) for the rendering/culling model and
 actor interleaving).
 
-## `/register` convenience entry
+### Streaming levels
 
-Importing `/register` registers `ldtkExtension` (and its `tilemapExtension` dependency) in the
-global `ExtensionRegistry`, so subsequently created Applications that use global defaults pick them
-up automatically:
+`ldtkMap` converts every level up front. For a project too large for that, load it as an
+`ldtkProject` and load levels individually — each gets its own `LoaderScope`, and external
+`.ldtkl` payloads are fetched only when their level is:
 
 ```ts
-// Side effect: registers ldtkExtension in the global ExtensionRegistry.
-import '@codexo/exojs-ldtk/register';
+import { Application, Asset } from '@codexo/exojs';
+import { ldtkExtension } from '@codexo/exojs-ldtk';
 
-// All named exports are also re-exported from /register:
-import { LdtkMap, ldtkExtension } from '@codexo/exojs-ldtk/register';
+const app = new Application({ extensions: [ldtkExtension] });
+
+const project = await app.loader.load(Asset.type('ldtkProject', 'levels/world.ldtk'));
+const runtime = project.createRuntime({ scope: app.loader });
+
+const forest = await runtime.loadLevel(project.world.getLevelByName('Forest')!.id);
+
+// ... later
+forest.destroy(); // map, spawned objects and the level's asset claims, in that order
 ```
 
-This is the only side-effectful entry — importing the package root (`@codexo/exojs-ldtk`) does
-**not** register anything.
+Which levels to load, and when, stays game policy — `project.world` carries the bounds and
+neighbour graph to decide with.
 
 ## Texture ownership
 
@@ -76,8 +94,8 @@ scene nodes — the application owns those.
 ## Core compatibility
 
 | `@codexo/exojs-ldtk` | `@codexo/exojs` |
-|---|---|
-| 0.14.x | 0.14.x |
+| -------------------- | --------------- |
+| 0.14.x               | 0.14.x          |
 
 ## Links
 

package/dist/esm/LdtkData.d.ts

@@ -9,10 +9,10 @@
  */
 import type { TilePropertyPoint, TilePropertyTileRef } from '@codexo/exojs-tilemap';
 /** Flip-bit constants for {@link LdtkTileData.f}. */
-export declare const ldtkFlipNone = 0;
-export declare const ldtkFlipX = 1;
-export declare const ldtkFlipY = 2;
-export declare const ldtkFlipXy = 3;
+export declare const LDTK_FLIP_NONE = 0;
+export declare const LDTK_FLIP_X = 1;
+export declare const LDTK_FLIP_Y = 2;
+export declare const LDTK_FLIP_XY = 3;
 /** A single tile placed in a Tiles or AutoLayer layer instance. */
 export interface LdtkTileData {
     /** Pixel position `[x, y]` of this tile within the layer. */
@@ -43,7 +43,7 @@ export type LdtkFieldPointValue = Omit<TilePropertyPoint, 'kind'>;
 /**
  * Raw `__value` shape for an `EntityRef`-typed field: the referenced
  * entity's own iid plus LDtk's navigation context (owning layer/level/world).
- * Maps to {@link import('@codexo/exojs-tilemap').TilePropertyObjectRef} —
+ * Maps to {@link import('@codexo/exojs-tilemap').TilePropertyObjectRef} -
  * `entityIid` becomes `id`.
  */
 export interface LdtkFieldEntityRefValue {
@@ -94,7 +94,7 @@ export interface LdtkEntityInstance {
     /** Alias of `__identifier`, mirrors the entity definition type. */
     readonly __type: string;
     /**
-     * Pixel position `[x, y]` of the entity's pivot-adjusted anchor — NOT the
+     * Pixel position `[x, y]` of the entity's pivot-adjusted anchor - NOT the
      * top-left corner. Combine with {@link __pivot} to recover the bounding
      * box's top-left corner: `topLeftX = px[0] - width * __pivot[0]`.
      */
@@ -135,10 +135,10 @@ export interface LdtkLayerInstance {
     /** Globally unique instance id (UUID string). */
     readonly iid: string;
     /**
-     * UID of the tileset used by this layer.
-     * Present for `Tiles`, `AutoLayer`, and `IntGrid` layers that use a tileset.
+     * UID of the tileset used by this layer, or `null` on a layer that draws no
+     * tiles - LDtk writes the key either way.
      */
-    readonly __tilesetDefUid?: number;
+    readonly __tilesetDefUid?: number | null;
     /** Placed tiles for `Tiles` layer type. */
     readonly gridTiles?: readonly LdtkTileData[];
     /** Auto-computed tiles for `AutoLayer` (and `IntGrid` + auto-rules) layer types. */
@@ -157,6 +157,22 @@ export interface LdtkLayerInstance {
     /** Layer opacity in `[0, 1]`. */
     readonly opacity?: number;
 }
+/**
+ * One entry of a level's `__neighbours` array: an adjacency to another level,
+ * plus the direction code LDtk assigned it.
+ */
+export interface LdtkLevelNeighbour {
+    /** `iid` of the neighbouring level. */
+    readonly levelIid: string;
+    /**
+     * Direction code: `"n"`, `"s"`, `"e"`, `"w"` for the cardinal sides, and
+     * `"<"`, `">"`, `"o"` for the depth relations LDtk 1.x adds (lower depth,
+     * greater depth, overlapping at the same depth). Mapped onto
+     * {@link import('@codexo/exojs-tilemap').MapLevelSide} by
+     * {@link import('./ldtkToMapWorld').ldtkToMapWorld}.
+     */
+    readonly dir: string;
+}
 /** A level in the LDtk world. */
 export interface LdtkLevel {
     /** Human-readable level identifier (unique within the world). */
@@ -180,8 +196,16 @@ export interface LdtkLevel {
      */
     readonly layerInstances: readonly LdtkLayerInstance[] | null;
     readonly fieldInstances?: readonly LdtkFieldInstance[];
-    /** Relative path to an external `.ldtkl` file for multi-world setups. */
-    readonly externalRelPath?: string;
+    /**
+     * Relative path to this level's external `.ldtkl` file, or `null` when the
+     * project does not save levels separately - LDtk writes the key either way.
+     */
+    readonly externalRelPath?: string | null;
+    /**
+     * Levels LDtk computed as adjacent to this one. Absent in documents written
+     * before LDtk emitted the field, and empty for an isolated level.
+     */
+    readonly __neighbours?: readonly LdtkLevelNeighbour[] | null;
 }
 /**
  * How a {@link LdtkWorldData}'s levels are spatially organised. `null` is a
@@ -194,7 +218,7 @@ export type LdtkWorldLayout = 'Free' | 'GridVania' | 'LinearHorizontal' | 'Linea
  * when the project has "Multi-Worlds" enabled in its advanced settings).
  * Each world owns its own {@link levels}; `defs` (tilesets/layers/entity
  * definitions) is declared once at the document root and shared by every
- * world rather than duplicated per-world — see {@link LdtkData.defs}.
+ * world rather than duplicated per-world - see {@link LdtkData.defs}.
  */
 export interface LdtkWorldData {
     /** Human-readable world identifier (unique within the project). */
@@ -246,6 +270,26 @@ export interface LdtkLayerDef {
     readonly tilesetDefUid?: number | null;
     readonly gridSize: number;
     readonly intGridValues?: readonly LdtkIntGridValueDef[];
+    /** Definition-level horizontal pixel offset, added to each layer instance offset. */
+    readonly pxOffsetX?: number;
+    /** Definition-level vertical pixel offset, added to each layer instance offset. */
+    readonly pxOffsetY?: number;
+    /**
+     * Parallax horizontal factor, in `[-1, 1]`. `0` (the default) means "no
+     * parallax" - the layer scrolls at normal camera speed, same as every
+     * other layer. See {@link import('./ldtkToTileMap').ldtkToTileMap} for how
+     * this is carried onto the runtime layer's `parallaxX`.
+     */
+    readonly parallaxFactorX?: number;
+    /** Parallax vertical factor, in `[-1, 1]`. `0` (the default) means "no parallax". */
+    readonly parallaxFactorY?: number;
+    /**
+     * Whether a non-zero parallax factor also scales this layer up/down to
+     * simulate depth. Defaults to `true` (LDtk's own default) when absent.
+     *
+     * Converted to the runtime layer's uniform `parallaxScale` multiplier.
+     */
+    readonly parallaxScaling?: boolean;
 }
 /** Top-level definitions block (`defs`). */
 export interface LdtkDefs {
@@ -264,7 +308,7 @@ export interface LdtkData {
     /**
      * Levels not organised into worlds. Always populated for pre-multi-world
      * documents; kept EMPTY (per the LDtk spec's backward-compatibility rule)
-     * when {@link worlds} is used instead — read levels via `worlds[].levels`
+     * when {@link worlds} is used instead - read levels via `worlds[].levels`
      * in that case, or use {@link import('./ldtkLevelEntries').getLdtkLevelEntries}
      * (or simply {@link import('./LdtkMap').LdtkMap.levels} /
      * {@link import('./LdtkMap').LdtkMap.getLevelByName}) to get "all levels,
@@ -275,8 +319,9 @@ export interface LdtkData {
      * Worlds, present and non-empty only when the project has "Multi-Worlds"
      * enabled in its advanced settings. Absent or empty for the (overwhelmingly
      * common) single-world case, in which levels live directly in the root
-     * {@link levels} array instead. `defs` is NOT duplicated per-world — it
+     * {@link levels} array instead. `defs` is NOT duplicated per-world - it
      * stays declared once at the document root regardless of this field.
      */
     readonly worlds?: readonly LdtkWorldData[];
 }
+//# sourceMappingURL=LdtkData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LdtkData.d.ts","sourceRoot":"","sources":["../../src/LdtkData.ts"],"names":[],"mappings":"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"}

package/dist/esm/LdtkData.js

@@ -1,18 +1,10 @@
-/**
- * TypeScript types for the LDtk JSON format (version 1.5.x).
- *
- * These interfaces model the root LDtk JSON document as produced by the LDtk
- * level editor. Only the fields consumed by the ExoJS runtime adapter are
- * declared here; unknown fields are not stripped at parse time.
- *
- * @see https://ldtk.io/json/
- */
-// ── Tile data ─────────────────────────────────────────────────────────────────
+//#region src/LdtkData.ts
 /** Flip-bit constants for {@link LdtkTileData.f}. */
-const ldtkFlipNone = 0;
-const ldtkFlipX = 1;
-const ldtkFlipY = 2;
-const ldtkFlipXy = 3;
+const LDTK_FLIP_NONE = 0;
+const LDTK_FLIP_X = 1;
+const LDTK_FLIP_Y = 2;
+const LDTK_FLIP_XY = 3;
 
-export { ldtkFlipNone, ldtkFlipX, ldtkFlipXy, ldtkFlipY };
-//# sourceMappingURL=LdtkData.js.map
+//#endregion
+export { LDTK_FLIP_NONE, LDTK_FLIP_X, LDTK_FLIP_XY, LDTK_FLIP_Y };
+//# sourceMappingURL=LdtkData.js.map

package/dist/esm/LdtkData.js.map

@@ -1 +1 @@
-{"version":3,"file":"LdtkData.js","sources":["../../../src/LdtkData.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;AAQG;AAMH;AAEA;AACO,MAAM,YAAY,GAAG;AACrB,MAAM,SAAS,GAAG;AAClB,MAAM,SAAS,GAAG;AAClB,MAAM,UAAU,GAAG;;;;"}
+{"version":3,"file":"LdtkData.js","names":[],"sources":["../../src/LdtkData.ts"],"sourcesContent":["/**\n * TypeScript types for the LDtk JSON format (version 1.5.x).\n *\n * These interfaces model the root LDtk JSON document as produced by the LDtk\n * level editor. Only the fields consumed by the ExoJS runtime adapter are\n * declared here; unknown fields are not stripped at parse time.\n *\n * @see https://ldtk.io/json/\n */\n\nimport type { TilePropertyPoint, TilePropertyTileRef } from '@codexo/exojs-tilemap';\n\n// ── Tile data ─────────────────────────────────────────────────────────────────\n\n/** Flip-bit constants for {@link LdtkTileData.f}. */\nexport const LDTK_FLIP_NONE = 0;\nexport const LDTK_FLIP_X = 1;\nexport const LDTK_FLIP_Y = 2;\nexport const LDTK_FLIP_XY = 3;\n\n/** A single tile placed in a Tiles or AutoLayer layer instance. */\nexport interface LdtkTileData {\n  /** Pixel position `[x, y]` of this tile within the layer. */\n  readonly px: readonly [number, number];\n  /** Source position `[x, y]` in the tileset image (top-left of the tile). */\n  readonly src: readonly [number, number];\n  /**\n   * Flip bits: `0` = none, `1` = flipX, `2` = flipY, `3` = flipX + flipY.\n   * Use {@link LDTK_FLIP_X} / {@link LDTK_FLIP_Y} constants for clarity.\n   */\n  readonly f: number;\n  /** Local tile index in the owning tileset. */\n  readonly t: number;\n  /** Per-tile opacity in `[0, 1]`. Defaults to `1` when absent. */\n  readonly a?: number;\n}\n\n// ── Entity data ───────────────────────────────────────────────────────────────\n\n/**\n * LDtk field types whose `__value` is a bare scalar (or `null`, when the\n * field has no value set).\n */\nexport type LdtkFieldScalarType = 'Int' | 'Float' | 'Bool' | 'String' | 'Multilines' | 'Color' | 'FilePath' | 'Enum';\n\n/**\n * Raw `__value` shape for a `Point`-typed field. Structurally identical to\n * {@link TilePropertyPoint} minus its `kind` tag, so the canonical shape is\n * reused directly rather than duplicated.\n */\nexport type LdtkFieldPointValue = Omit<TilePropertyPoint, 'kind'>;\n\n/**\n * Raw `__value` shape for an `EntityRef`-typed field: the referenced\n * entity's own iid plus LDtk's navigation context (owning layer/level/world).\n * Maps to {@link import('@codexo/exojs-tilemap').TilePropertyObjectRef} -\n * `entityIid` becomes `id`.\n */\nexport interface LdtkFieldEntityRefValue {\n  readonly entityIid: string;\n  readonly layerIid: string;\n  readonly levelIid: string;\n  readonly worldIid: string;\n}\n\n/**\n * Raw `__value` shape for a `Tile`-typed field. Structurally identical to\n * {@link TilePropertyTileRef} minus its `kind` tag, so the canonical shape is\n * reused directly rather than duplicated.\n */\nexport type LdtkFieldTileValue = Omit<TilePropertyTileRef, 'kind'>;\n\n/**\n * A field value on an entity or level instance, discriminated by `__type`.\n * `Array<T>` fields (e.g. `Array<Int>`, `Array<Point>`) carry a raw element\n * array whose per-element shape matches the corresponding non-array\n * `__value` shape above; see {@link import('./ldtkToTileMap').ldtkToTileMap}'s\n * field conversion for the exhaustive mapping into the canonical\n * {@link import('@codexo/exojs-tilemap').TilePropertyValue}.\n */\nexport type LdtkFieldInstance =\n  | {\n      readonly __identifier: string;\n      readonly __type: LdtkFieldScalarType;\n      readonly __value: string | number | boolean | null;\n    }\n  | {\n      readonly __identifier: string;\n      readonly __type: 'Point';\n      readonly __value: LdtkFieldPointValue | null;\n    }\n  | {\n      readonly __identifier: string;\n      readonly __type: 'EntityRef';\n      readonly __value: LdtkFieldEntityRefValue | null;\n    }\n  | {\n      readonly __identifier: string;\n      readonly __type: 'Tile';\n      readonly __value: LdtkFieldTileValue | null;\n    }\n  | {\n      readonly __identifier: string;\n      readonly __type: `Array<${string}>`;\n      readonly __value: readonly unknown[] | null;\n    };\n\n/** An entity instance placed in an Entities layer. */\nexport interface LdtkEntityInstance {\n  /** Entity definition identifier (class name). */\n  readonly __identifier: string;\n  /** Alias of `__identifier`, mirrors the entity definition type. */\n  readonly __type: string;\n  /**\n   * Pixel position `[x, y]` of the entity's pivot-adjusted anchor - NOT the\n   * top-left corner. Combine with {@link __pivot} to recover the bounding\n   * box's top-left corner: `topLeftX = px[0] - width * __pivot[0]`.\n   */\n  readonly px: readonly [number, number];\n  readonly width: number;\n  readonly height: number;\n  /**\n   * Normalised `[x, y]` anchor point within the entity's bounding box, each\n   * in `[0, 1]`. `[0, 0]` = top-left, `[0.5, 0.5]` = center, `[1, 1]` =\n   * bottom-right. Determines how {@link px} relates to the bounding box.\n   */\n  readonly __pivot: readonly [number, number];\n  readonly fieldInstances: readonly LdtkFieldInstance[];\n  /** Globally unique instance id (UUID string). */\n  readonly iid: string;\n  /** UID of the entity definition this instance was created from. */\n  readonly defUid: number;\n}\n\n// ── Layer instances ───────────────────────────────────────────────────────────\n\n/** Discriminant string for a layer instance type. */\nexport type LdtkLayerType = 'Tiles' | 'IntGrid' | 'Entities' | 'AutoLayer';\n\n/** A layer instance within a level. */\nexport interface LdtkLayerInstance {\n  /** Layer definition identifier. */\n  readonly __identifier: string;\n  /** Layer type discriminant. */\n  readonly __type: LdtkLayerType;\n  /** Layer width in grid cells. */\n  readonly __cWid: number;\n  /** Layer height in grid cells. */\n  readonly __cHei: number;\n  /** Grid / tile size in pixels. */\n  readonly __gridSize: number;\n  /** UID of the layer definition. */\n  readonly layerDefUid: number;\n  /** UID of the parent level. */\n  readonly levelId: number;\n  readonly visible: boolean;\n  /** Globally unique instance id (UUID string). */\n  readonly iid: string;\n  /**\n   * UID of the tileset used by this layer, or `null` on a layer that draws no\n   * tiles - LDtk writes the key either way.\n   */\n  readonly __tilesetDefUid?: number | null;\n  /** Placed tiles for `Tiles` layer type. */\n  readonly gridTiles?: readonly LdtkTileData[];\n  /** Auto-computed tiles for `AutoLayer` (and `IntGrid` + auto-rules) layer types. */\n  readonly autoLayerTiles?: readonly LdtkTileData[];\n  /** Entity instances for `Entities` layer type. */\n  readonly entityInstances?: readonly LdtkEntityInstance[];\n  /**\n   * Flat CSV array of IntGrid values for `IntGrid` layer type.\n   * Index = `y * __cWid + x`. `0` = empty cell.\n   */\n  readonly intGridCsv?: readonly number[];\n  /** Horizontal pixel offset applied to the layer. */\n  readonly pxOffsetX?: number;\n  /** Vertical pixel offset applied to the layer. */\n  readonly pxOffsetY?: number;\n  /** Layer opacity in `[0, 1]`. */\n  readonly opacity?: number;\n}\n\n// ── Levels ────────────────────────────────────────────────────────────────────\n\n/**\n * One entry of a level's `__neighbours` array: an adjacency to another level,\n * plus the direction code LDtk assigned it.\n */\nexport interface LdtkLevelNeighbour {\n  /** `iid` of the neighbouring level. */\n  readonly levelIid: string;\n  /**\n   * Direction code: `\"n\"`, `\"s\"`, `\"e\"`, `\"w\"` for the cardinal sides, and\n   * `\"<\"`, `\">\"`, `\"o\"` for the depth relations LDtk 1.x adds (lower depth,\n   * greater depth, overlapping at the same depth). Mapped onto\n   * {@link import('@codexo/exojs-tilemap').MapLevelSide} by\n   * {@link import('./ldtkToMapWorld').ldtkToMapWorld}.\n   */\n  readonly dir: string;\n}\n\n/** A level in the LDtk world. */\nexport interface LdtkLevel {\n  /** Human-readable level identifier (unique within the world). */\n  readonly identifier: string;\n  readonly uid: number;\n  /** Globally unique instance id (UUID string). */\n  readonly iid: string;\n  /** World-space X position of the level's top-left corner in pixels. */\n  readonly worldX: number;\n  /** World-space Y position of the level's top-left corner in pixels. */\n  readonly worldY: number;\n  /** Level width in pixels. */\n  readonly pxWid: number;\n  /** Level height in pixels. */\n  readonly pxHei: number;\n  readonly bgColor?: string;\n  /**\n   * Layer instances in this level (top-to-bottom render order).\n   * `null` when the level is stored in a separate `.ldtkl` file and has not\n   * been loaded yet.\n   */\n  readonly layerInstances: readonly LdtkLayerInstance[] | null;\n  readonly fieldInstances?: readonly LdtkFieldInstance[];\n  /**\n   * Relative path to this level's external `.ldtkl` file, or `null` when the\n   * project does not save levels separately - LDtk writes the key either way.\n   */\n  readonly externalRelPath?: string | null;\n  /**\n   * Levels LDtk computed as adjacent to this one. Absent in documents written\n   * before LDtk emitted the field, and empty for an isolated level.\n   */\n  readonly __neighbours?: readonly LdtkLevelNeighbour[] | null;\n}\n\n// ── Worlds ────────────────────────────────────────────────────────────────────\n\n/**\n * How a {@link LdtkWorldData}'s levels are spatially organised. `null` is a\n * valid LDtk value (unset), same as the other nullable enum-ish fields in\n * this file.\n */\nexport type LdtkWorldLayout = 'Free' | 'GridVania' | 'LinearHorizontal' | 'LinearVertical' | null;\n\n/**\n * A single world in a multi-world LDtk project (`root.worlds[]`, populated\n * when the project has \"Multi-Worlds\" enabled in its advanced settings).\n * Each world owns its own {@link levels}; `defs` (tilesets/layers/entity\n * definitions) is declared once at the document root and shared by every\n * world rather than duplicated per-world - see {@link LdtkData.defs}.\n */\nexport interface LdtkWorldData {\n  /** Human-readable world identifier (unique within the project). */\n  readonly identifier: string;\n  /** Globally unique instance id (UUID string). */\n  readonly iid: string;\n  /** Width of the world grid in pixels. */\n  readonly worldGridWidth: number;\n  /** Height of the world grid in pixels. */\n  readonly worldGridHeight: number;\n  /** How this world's levels are spatially organised. */\n  readonly worldLayout: LdtkWorldLayout;\n  /** Levels belonging to this world, in document order. */\n  readonly levels: readonly LdtkLevel[];\n}\n\n// ── Definitions ───────────────────────────────────────────────────────────────\n\n/** Tileset definition from `defs.tilesets`. */\nexport interface LdtkTilesetDef {\n  readonly uid: number;\n  /** Human-readable tileset identifier. */\n  readonly identifier: string;\n  /**\n   * Relative path to the tileset atlas image.\n   * `null` for internal / embedded tilesets with no image.\n   */\n  readonly relPath: string | null;\n  /** Tile grid size (both width and height) in pixels. */\n  readonly tileGridSize: number;\n  /** Tileset image width in pixels. */\n  readonly pxWid: number;\n  /** Tileset image height in pixels. */\n  readonly pxHei: number;\n  /** Pixel spacing between tiles in the atlas. */\n  readonly spacing?: number;\n  /** Pixel padding (margin) around the atlas edges. */\n  readonly padding?: number;\n}\n\n/** An IntGrid value definition (maps a raw int to a named, coloured entry). */\nexport interface LdtkIntGridValueDef {\n  readonly value: number;\n  readonly identifier: string | null;\n  readonly color: string;\n}\n\n/** Layer definition from `defs.layers`. */\nexport interface LdtkLayerDef {\n  readonly uid: number;\n  readonly identifier: string;\n  readonly type: LdtkLayerType;\n  /** UID of the default tileset for this layer. `null` or absent = none. */\n  readonly tilesetDefUid?: number | null;\n  readonly gridSize: number;\n  readonly intGridValues?: readonly LdtkIntGridValueDef[];\n  /** Definition-level horizontal pixel offset, added to each layer instance offset. */\n  readonly pxOffsetX?: number;\n  /** Definition-level vertical pixel offset, added to each layer instance offset. */\n  readonly pxOffsetY?: number;\n  /**\n   * Parallax horizontal factor, in `[-1, 1]`. `0` (the default) means \"no\n   * parallax\" - the layer scrolls at normal camera speed, same as every\n   * other layer. See {@link import('./ldtkToTileMap').ldtkToTileMap} for how\n   * this is carried onto the runtime layer's `parallaxX`.\n   */\n  readonly parallaxFactorX?: number;\n  /** Parallax vertical factor, in `[-1, 1]`. `0` (the default) means \"no parallax\". */\n  readonly parallaxFactorY?: number;\n  /**\n   * Whether a non-zero parallax factor also scales this layer up/down to\n   * simulate depth. Defaults to `true` (LDtk's own default) when absent.\n   *\n   * Converted to the runtime layer's uniform `parallaxScale` multiplier.\n   */\n  readonly parallaxScaling?: boolean;\n}\n\n/** Top-level definitions block (`defs`). */\nexport interface LdtkDefs {\n  readonly tilesets: readonly LdtkTilesetDef[];\n  readonly layers: readonly LdtkLayerDef[];\n}\n\n// ── Root document ─────────────────────────────────────────────────────────────\n\n/** Root LDtk JSON document (`*.ldtk`). */\nexport interface LdtkData {\n  /** LDtk JSON format version string (e.g. `\"1.5.3\"`). */\n  readonly jsonVersion: string;\n  readonly worldGridWidth?: number;\n  readonly worldGridHeight?: number;\n  readonly defaultGridSize?: number;\n  readonly bgColor?: string;\n  readonly defs: LdtkDefs;\n  /**\n   * Levels not organised into worlds. Always populated for pre-multi-world\n   * documents; kept EMPTY (per the LDtk spec's backward-compatibility rule)\n   * when {@link worlds} is used instead - read levels via `worlds[].levels`\n   * in that case, or use {@link import('./ldtkLevelEntries').getLdtkLevelEntries}\n   * (or simply {@link import('./LdtkMap').LdtkMap.levels} /\n   * {@link import('./LdtkMap').LdtkMap.getLevelByName}) to get \"all levels,\n   * in order\" regardless of which shape the document uses.\n   */\n  readonly levels: readonly LdtkLevel[];\n  /**\n   * Worlds, present and non-empty only when the project has \"Multi-Worlds\"\n   * enabled in its advanced settings. Absent or empty for the (overwhelmingly\n   * common) single-world case, in which levels live directly in the root\n   * {@link levels} array instead. `defs` is NOT duplicated per-world - it\n   * stays declared once at the document root regardless of this field.\n   */\n  readonly worlds?: readonly LdtkWorldData[];\n}\n"],"mappings":";;AAeA,MAAa,iBAAiB;AAC9B,MAAa,cAAc;AAC3B,MAAa,cAAc;AAC3B,MAAa,eAAe"}

package/dist/esm/LdtkMap.d.ts

@@ -1,4 +1,4 @@
-import type { TileMap } from '@codexo/exojs-tilemap';
+import type { MapWorld, TileMap } from '@codexo/exojs-tilemap';
 import type { LdtkData } from './LdtkData';
 /**
  * A parsed LDtk world document: holds the raw JSON data and the converted
@@ -8,7 +8,7 @@ import type { LdtkData } from './LdtkData';
  * convertible to a format-independent `TileMap`; access them via
  * {@link levels} (by document order) or by name via {@link getLevelByName}.
  *
- * Construction is cheap — the runtime `TileMap[]` is supplied externally
+ * Construction is cheap - the runtime `TileMap[]` is supplied externally
  * (built by {@link import('./ldtkToTileMap').ldtkToTileMap}). The map does
  * **not** own tileset textures; those remain in the Loader cache.
  */
@@ -18,24 +18,42 @@ export declare class LdtkMap {
     /** The raw parsed LDtk document. */
     readonly data: LdtkData;
     /**
-     * Runtime TileMaps — one per LDtk level, in document order.
+     * Runtime TileMaps - one per LDtk level, in document order.
      *
      * The index here corresponds to
      * {@link import('./ldtkLevelEntries').getLdtkLevelEntries}`(data)[i]`, not
-     * `data.levels[i]` — the latter is empty for multi-world documents, where
+     * `data.levels[i]` - the latter is empty for multi-world documents, where
      * levels live under `data.worlds[].levels` instead. `loadLdtkMap` fully
      * resolves external `.ldtkl` levels before conversion, so every entry here
      * is always a fully converted `TileMap`.
      */
     readonly levels: readonly TileMap[];
+    private _worlds?;
     constructor(source: string, data: LdtkData, levels: readonly TileMap[]);
+    /**
+     * The document's world layout: level placement, bounds and neighbour graph,
+     * one {@link MapWorld} per LDtk world (exactly one for a single-world
+     * project). Built on first access and cached.
+     *
+     * This is metadata about *where* levels are, independent of the runtime maps
+     * in {@link levels}. Use it to navigate; use
+     * {@link import('./LdtkWorld').LdtkWorld} instead when levels should be
+     * loaded on demand rather than all at once.
+     */
+    get worlds(): readonly MapWorld[];
+    /**
+     * The document's only world. Convenience for the single-world case; for a
+     * multi-world project this is the first world in document order and
+     * {@link worlds} is what to read instead.
+     */
+    get world(): MapWorld;
     /**
      * Find a level's runtime {@link TileMap} by the LDtk level `identifier`,
      * or `undefined` when no level with that name exists.
      *
      * Searches across {@link import('./ldtkLevelEntries').getLdtkLevelEntries}'s
      * flattened level set rather than `data.levels` directly, so this works for
-     * both single-world and multi-world documents — `data.levels` alone is
+     * both single-world and multi-world documents - `data.levels` alone is
      * empty for the latter.
      *
      * The lookup is O(n) in the number of levels.
@@ -45,7 +63,8 @@ export declare class LdtkMap {
      * Destroy all owned runtime TileMaps.
      *
      * Is idempotent. Does NOT destroy tileset textures (Loader-owned) or any
-     * SceneNodes — the application is responsible for those.
+     * SceneNodes - the application is responsible for those.
      */
     destroy(): void;
 }
+//# sourceMappingURL=LdtkMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LdtkMap.d.ts","sourceRoot":"","sources":["../../src/LdtkMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C;;;;;;;;;;;GAWG;AACH,qBAAa,OAAO;IAClB,6CAA6C;IAC7C,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,oCAAoC;IACpC,SAAgB,IAAI,EAAE,QAAQ,CAAC;IAC/B;;;;;;;;;OASG;IACH,SAAgB,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;IAE3C,OAAO,CAAC,OAAO,CAAC,CAAsB;gBAEnB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,OAAO,EAAE;IAM7E;;;;;;;;;OASG;IACH,IAAW,MAAM,IAAI,SAAS,QAAQ,EAAE,CAGvC;IAED;;;;OAIG;IACH,IAAW,KAAK,IAAI,QAAQ,CAQ3B;IAED;;;;;;;;;;OAUG;IACI,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAM9D;;;;;OAKG;IACI,OAAO,IAAI,IAAI;CAKvB"}

package/dist/esm/LdtkMap.js

@@ -1,67 +1,92 @@
-import { getLdtkLevelEntries } from './ldtkLevelEntries.js';
+import { getLdtkLevelEntries } from "./ldtkLevelEntries.js";
+import { ldtkToMapWorld } from "./ldtkToMapWorld.js";
 
+//#region src/LdtkMap.ts
 /**
- * A parsed LDtk world document: holds the raw JSON data and the converted
- * runtime {@link TileMap} for each level.
- *
- * `LdtkMap` is the parsed source model. Each LDtk level is independently
- * convertible to a format-independent `TileMap`; access them via
- * {@link levels} (by document order) or by name via {@link getLevelByName}.
- *
- * Construction is cheap — the runtime `TileMap[]` is supplied externally
- * (built by {@link import('./ldtkToTileMap').ldtkToTileMap}). The map does
- * **not** own tileset textures; those remain in the Loader cache.
- */
-class LdtkMap {
-    /** Resolved URL this map was loaded from. */
-    source;
-    /** The raw parsed LDtk document. */
-    data;
-    /**
-     * Runtime TileMaps — one per LDtk level, in document order.
-     *
-     * The index here corresponds to
-     * {@link import('./ldtkLevelEntries').getLdtkLevelEntries}`(data)[i]`, not
-     * `data.levels[i]` — the latter is empty for multi-world documents, where
-     * levels live under `data.worlds[].levels` instead. `loadLdtkMap` fully
-     * resolves external `.ldtkl` levels before conversion, so every entry here
-     * is always a fully converted `TileMap`.
-     */
-    levels;
-    constructor(source, data, levels) {
-        this.source = source;
-        this.data = data;
-        this.levels = levels;
-    }
-    /**
-     * Find a level's runtime {@link TileMap} by the LDtk level `identifier`,
-     * or `undefined` when no level with that name exists.
-     *
-     * Searches across {@link import('./ldtkLevelEntries').getLdtkLevelEntries}'s
-     * flattened level set rather than `data.levels` directly, so this works for
-     * both single-world and multi-world documents — `data.levels` alone is
-     * empty for the latter.
-     *
-     * The lookup is O(n) in the number of levels.
-     */
-    getLevelByName(identifier) {
-        const index = getLdtkLevelEntries(this.data).findIndex(entry => entry.level.identifier === identifier);
-        if (index === -1)
-            return undefined;
-        return this.levels[index];
-    }
-    /**
-     * Destroy all owned runtime TileMaps.
-     *
-     * Is idempotent. Does NOT destroy tileset textures (Loader-owned) or any
-     * SceneNodes — the application is responsible for those.
-     */
-    destroy() {
-        for (const level of this.levels) {
-            level.destroy();
-        }
-    }
-}
+* A parsed LDtk world document: holds the raw JSON data and the converted
+* runtime {@link TileMap} for each level.
+*
+* `LdtkMap` is the parsed source model. Each LDtk level is independently
+* convertible to a format-independent `TileMap`; access them via
+* {@link levels} (by document order) or by name via {@link getLevelByName}.
+*
+* Construction is cheap - the runtime `TileMap[]` is supplied externally
+* (built by {@link import('./ldtkToTileMap').ldtkToTileMap}). The map does
+* **not** own tileset textures; those remain in the Loader cache.
+*/
+var LdtkMap = class {
+	/** Resolved URL this map was loaded from. */
+	source;
+	/** The raw parsed LDtk document. */
+	data;
+	/**
+	* Runtime TileMaps - one per LDtk level, in document order.
+	*
+	* The index here corresponds to
+	* {@link import('./ldtkLevelEntries').getLdtkLevelEntries}`(data)[i]`, not
+	* `data.levels[i]` - the latter is empty for multi-world documents, where
+	* levels live under `data.worlds[].levels` instead. `loadLdtkMap` fully
+	* resolves external `.ldtkl` levels before conversion, so every entry here
+	* is always a fully converted `TileMap`.
+	*/
+	levels;
+	_worlds;
+	constructor(source, data, levels) {
+		this.source = source;
+		this.data = data;
+		this.levels = levels;
+	}
+	/**
+	* The document's world layout: level placement, bounds and neighbour graph,
+	* one {@link MapWorld} per LDtk world (exactly one for a single-world
+	* project). Built on first access and cached.
+	*
+	* This is metadata about *where* levels are, independent of the runtime maps
+	* in {@link levels}. Use it to navigate; use
+	* {@link import('./LdtkWorld').LdtkWorld} instead when levels should be
+	* loaded on demand rather than all at once.
+	*/
+	get worlds() {
+		this._worlds ??= ldtkToMapWorld(this.data);
+		return this._worlds;
+	}
+	/**
+	* The document's only world. Convenience for the single-world case; for a
+	* multi-world project this is the first world in document order and
+	* {@link worlds} is what to read instead.
+	*/
+	get world() {
+		const [first] = this.worlds;
+		if (first === void 0) throw new Error(`LdtkMap: "${this.source}" declares no world.`);
+		return first;
+	}
+	/**
+	* Find a level's runtime {@link TileMap} by the LDtk level `identifier`,
+	* or `undefined` when no level with that name exists.
+	*
+	* Searches across {@link import('./ldtkLevelEntries').getLdtkLevelEntries}'s
+	* flattened level set rather than `data.levels` directly, so this works for
+	* both single-world and multi-world documents - `data.levels` alone is
+	* empty for the latter.
+	*
+	* The lookup is O(n) in the number of levels.
+	*/
+	getLevelByName(identifier) {
+		const index = getLdtkLevelEntries(this.data).findIndex((entry) => entry.level.identifier === identifier);
+		if (index === -1) return void 0;
+		return this.levels[index];
+	}
+	/**
+	* Destroy all owned runtime TileMaps.
+	*
+	* Is idempotent. Does NOT destroy tileset textures (Loader-owned) or any
+	* SceneNodes - the application is responsible for those.
+	*/
+	destroy() {
+		for (const level of this.levels) level.destroy();
+	}
+};
 
+//#endregion
 export { LdtkMap };
-//# sourceMappingURL=LdtkMap.js.map
+//# sourceMappingURL=LdtkMap.js.map

package/dist/esm/LdtkMap.js.map

@@ -1 +1 @@
-{"version":3,"file":"LdtkMap.js","sources":["../../../src/LdtkMap.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;AAWG;MACU,OAAO,CAAA;;AAEF,IAAA,MAAM;;AAEN,IAAA,IAAI;AACpB;;;;;;;;;AASG;AACa,IAAA,MAAM;AAEtB,IAAA,WAAA,CAAmB,MAAc,EAAE,IAAc,EAAE,MAA0B,EAAA;AAC3E,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM;AACpB,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI;AAChB,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM;IACtB;AAEA;;;;;;;;;;AAUG;AACI,IAAA,cAAc,CAAC,UAAkB,EAAA;QACtC,MAAM,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,CACpD,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,UAAU,KAAK,UAAU,CAC/C;QACD,IAAI,KAAK,KAAK,EAAE;AAAE,YAAA,OAAO,SAAS;AAClC,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3B;AAEA;;;;;AAKG;IACI,OAAO,GAAA;AACZ,QAAA,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE;YAC/B,KAAK,CAAC,OAAO,EAAE;QACjB;IACF;AACD;;;;"}
+{"version":3,"file":"LdtkMap.js","names":[],"sources":["../../src/LdtkMap.ts"],"sourcesContent":["import type { MapWorld, TileMap } from '@codexo/exojs-tilemap';\n\nimport type { LdtkData } from './LdtkData';\nimport { getLdtkLevelEntries } from './ldtkLevelEntries';\nimport { ldtkToMapWorld } from './ldtkToMapWorld';\n\n/**\n * A parsed LDtk world document: holds the raw JSON data and the converted\n * runtime {@link TileMap} for each level.\n *\n * `LdtkMap` is the parsed source model. Each LDtk level is independently\n * convertible to a format-independent `TileMap`; access them via\n * {@link levels} (by document order) or by name via {@link getLevelByName}.\n *\n * Construction is cheap - the runtime `TileMap[]` is supplied externally\n * (built by {@link import('./ldtkToTileMap').ldtkToTileMap}). The map does\n * **not** own tileset textures; those remain in the Loader cache.\n */\nexport class LdtkMap {\n  /** Resolved URL this map was loaded from. */\n  public readonly source: string;\n  /** The raw parsed LDtk document. */\n  public readonly data: LdtkData;\n  /**\n   * Runtime TileMaps - one per LDtk level, in document order.\n   *\n   * The index here corresponds to\n   * {@link import('./ldtkLevelEntries').getLdtkLevelEntries}`(data)[i]`, not\n   * `data.levels[i]` - the latter is empty for multi-world documents, where\n   * levels live under `data.worlds[].levels` instead. `loadLdtkMap` fully\n   * resolves external `.ldtkl` levels before conversion, so every entry here\n   * is always a fully converted `TileMap`.\n   */\n  public readonly levels: readonly TileMap[];\n\n  private _worlds?: readonly MapWorld[];\n\n  public constructor(source: string, data: LdtkData, levels: readonly TileMap[]) {\n    this.source = source;\n    this.data = data;\n    this.levels = levels;\n  }\n\n  /**\n   * The document's world layout: level placement, bounds and neighbour graph,\n   * one {@link MapWorld} per LDtk world (exactly one for a single-world\n   * project). Built on first access and cached.\n   *\n   * This is metadata about *where* levels are, independent of the runtime maps\n   * in {@link levels}. Use it to navigate; use\n   * {@link import('./LdtkWorld').LdtkWorld} instead when levels should be\n   * loaded on demand rather than all at once.\n   */\n  public get worlds(): readonly MapWorld[] {\n    this._worlds ??= ldtkToMapWorld(this.data);\n    return this._worlds;\n  }\n\n  /**\n   * The document's only world. Convenience for the single-world case; for a\n   * multi-world project this is the first world in document order and\n   * {@link worlds} is what to read instead.\n   */\n  public get world(): MapWorld {\n    const [first] = this.worlds;\n\n    if (first === undefined) {\n      throw new Error(`LdtkMap: \"${this.source}\" declares no world.`);\n    }\n\n    return first;\n  }\n\n  /**\n   * Find a level's runtime {@link TileMap} by the LDtk level `identifier`,\n   * or `undefined` when no level with that name exists.\n   *\n   * Searches across {@link import('./ldtkLevelEntries').getLdtkLevelEntries}'s\n   * flattened level set rather than `data.levels` directly, so this works for\n   * both single-world and multi-world documents - `data.levels` alone is\n   * empty for the latter.\n   *\n   * The lookup is O(n) in the number of levels.\n   */\n  public getLevelByName(identifier: string): TileMap | undefined {\n    const index = getLdtkLevelEntries(this.data).findIndex(entry => entry.level.identifier === identifier);\n    if (index === -1) return undefined;\n    return this.levels[index];\n  }\n\n  /**\n   * Destroy all owned runtime TileMaps.\n   *\n   * Is idempotent. Does NOT destroy tileset textures (Loader-owned) or any\n   * SceneNodes - the application is responsible for those.\n   */\n  public destroy(): void {\n    for (const level of this.levels) {\n      level.destroy();\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,IAAa,UAAb,MAAqB;;CAEnB,AAAgB;;CAEhB,AAAgB;;;;;;;;;;;CAWhB,AAAgB;CAEhB,AAAQ;CAER,AAAO,YAAY,QAAgB,MAAgB,QAA4B;EAC7E,KAAK,SAAS;EACd,KAAK,OAAO;EACZ,KAAK,SAAS;CAChB;;;;;;;;;;;CAYA,IAAW,SAA8B;EACvC,KAAK,YAAY,eAAe,KAAK,IAAI;EACzC,OAAO,KAAK;CACd;;;;;;CAOA,IAAW,QAAkB;EAC3B,MAAM,CAAC,SAAS,KAAK;EAErB,IAAI,UAAU,QACZ,MAAM,IAAI,MAAM,aAAa,KAAK,OAAO,qBAAqB;EAGhE,OAAO;CACT;;;;;;;;;;;;CAaA,AAAO,eAAe,YAAyC;EAC7D,MAAM,QAAQ,oBAAoB,KAAK,IAAI,CAAC,CAAC,WAAU,UAAS,MAAM,MAAM,eAAe,UAAU;EACrG,IAAI,UAAU,IAAI,OAAO;EACzB,OAAO,KAAK,OAAO;CACrB;;;;;;;CAQA,AAAO,UAAgB;EACrB,KAAK,MAAM,SAAS,KAAK,QACvB,MAAM,QAAQ;CAElB;AACF"}