@codexo/exojs-ldtk 0.15.2 → 0.16.0

package/dist/esm/LdtkProject.d.ts

@@ -0,0 +1,107 @@
+import type { LoaderScope } from '@codexo/exojs';
+import type { MapWorld, TileSet } from '@codexo/exojs-tilemap';
+import { MapWorldRuntime } from '@codexo/exojs-tilemap';
+import type { LdtkData } from './LdtkData';
+/** Options for {@link LdtkProject.createRuntime}. */
+export interface LdtkRuntimeOptions {
+    /**
+     * Parent scope for everything the runtime loads. The runtime creates its own
+     * child scope under it and never destroys this one.
+     */
+    readonly scope: LoaderScope;
+    /**
+     * Which world of a multi-world project to stream, by identifier. Defaults to
+     * the first world in document order, which is the only one a single-world
+     * project has.
+     */
+    readonly world?: string;
+}
+/**
+ * A loaded LDtk project, prepared for streaming: world layout and tileset
+ * atlases are resident, level payloads are not.
+ *
+ * This is the entry point for a game that loads levels as it needs them. Read
+ * {@link worlds} to decide what to load, then drive a
+ * {@link MapWorldRuntime} from {@link createRuntime} to load and unload
+ * individual levels, each with its own asset scope.
+ *
+ * What is eager, and why:
+ *
+ * - the `.ldtk` document itself, because the world layout is what the game
+ *   navigates by;
+ * - every tileset atlas. This is a prefetch policy, not a technical
+ *   requirement, and it is bounded: LDtk declares tilesets once per project
+ *   (`defs.tilesets`), never per level, so the count does not grow with the
+ *   number of levels. Paying for them once keeps a level load off the network
+ *   entirely for a non-externalized project, and off the *image* network for an
+ *   externalized one.
+ *
+ * The atlases are claimed by this asset's own scope, so their residency is tied
+ * to how long the `ldtkProject` asset is held - not to a
+ * {@link MapWorldRuntime}. Releasing the asset releases them; destroying a
+ * runtime does not.
+ *
+ * What is lazy:
+ *
+ * - external `.ldtkl` level payloads - fetched when the level loads, claimed
+ *   by that level's scope, released when it unloads;
+ * - the conversion of a level into a runtime `TileMap`;
+ * - anything the level's {@link import('@codexo/exojs-tilemap').MapObjectSpawner} creates.
+ *
+ * Load the whole project at once with the `ldtkMap` asset type instead
+ * ({@link import('./LdtkMap').LdtkMap}) when a game is small enough not to
+ * need any of this.
+ *
+ * @example
+ * ```ts
+ * const project = await scene.loader.load(Asset.type('ldtkProject', 'world.ldtk'));
+ * const runtime = project.createRuntime({ scope: scene.loader });
+ *
+ * const forest = await runtime.loadLevel(project.world.getLevelByName('Forest')!.id, {
+ *   spawner,
+ *   context: { services, save },
+ * });
+ *
+ * scene.addChild(forest.map.createView().root);
+ * runtime.unloadLevel(forest.id);
+ * ```
+ */
+export declare class LdtkProject {
+    /** Resolved URL this project was loaded from. */
+    readonly source: string;
+    /** The raw parsed LDtk document. Externalized levels still carry `layerInstances: null`. */
+    readonly data: LdtkData;
+    /** Runtime tilesets keyed by LDtk tileset uid, shared by every level of the project. */
+    readonly tilesets: ReadonlyMap<number, TileSet>;
+    /** World layout, one entry per LDtk world. See {@link import('./ldtkToMapWorld').ldtkToMapWorld}. */
+    readonly worlds: readonly MapWorld[];
+    private readonly _entries;
+    /** Projects are produced by the `ldtkProject` asset binding. @internal */
+    constructor(source: string, data: LdtkData, tilesets: ReadonlyMap<number, TileSet>);
+    /**
+     * The project's only world. For a multi-world project this is the first in
+     * document order; read {@link worlds} to reach the others.
+     */
+    get world(): MapWorld;
+    /** The world with this identifier, or `undefined`. */
+    getWorld(name: string): MapWorld | undefined;
+    /**
+     * Create the live runtime that loads and unloads this project's levels.
+     *
+     * The runtime is a separate lifetime from the project: destroying it unloads
+     * every level it holds and leaves the project - document, world layout and
+     * tilesets - intact, ready for a new runtime.
+     *
+     * @throws {Error} when `options.world` names no world of this project.
+     */
+    createRuntime(options: LdtkRuntimeOptions): MapWorldRuntime;
+    private _loadLevel;
+    /**
+     * Fetch an externalized level's `.ldtkl` payload and merge it into the level
+     * record. The fetch is claimed by the level's own scope, so it is released
+     * when the level unloads and re-fetched (or served from the loader's cache)
+     * on a later load.
+     */
+    private _resolveLevel;
+}
+//# sourceMappingURL=LdtkProject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LdtkProject.d.ts","sourceRoot":"","sources":["../../src/LdtkProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAuB,QAAQ,EAAW,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,YAAY,CAAC;AAQtD,qDAAqD;AACrD,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,WAAW;IACtB,iDAAiD;IACjD,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,4FAA4F;IAC5F,SAAgB,IAAI,EAAE,QAAQ,CAAC;IAC/B,wFAAwF;IACxF,SAAgB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvD,qGAAqG;IACrG,SAAgB,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IAE5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IAErD,0EAA0E;gBACvD,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC;IAQzF;;;OAGG;IACH,IAAW,KAAK,IAAI,QAAQ,CAQ3B;IAED,sDAAsD;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAInD;;;;;;;;OAQG;IACI,aAAa,CAAC,OAAO,EAAE,kBAAkB,GAAG,eAAe;YAcpD,UAAU;IAYxB;;;;;OAKG;YACW,aAAa;CAiB5B"}

package/dist/esm/LdtkProject.js

@@ -0,0 +1,136 @@
+import { getLdtkLevelEntries } from "./ldtkLevelEntries.js";
+import { ldtkLevelToTileMap } from "./ldtkToTileMap.js";
+import { ldtkToMapWorld } from "./ldtkToMapWorld.js";
+import { resolveLdtkUrl } from "./url.js";
+import { validateLdtkLevelData } from "./validate.js";
+import { MapWorldRuntime } from "@codexo/exojs-tilemap";
+import { Asset } from "@codexo/exojs";
+
+//#region src/LdtkProject.ts
+/**
+* A loaded LDtk project, prepared for streaming: world layout and tileset
+* atlases are resident, level payloads are not.
+*
+* This is the entry point for a game that loads levels as it needs them. Read
+* {@link worlds} to decide what to load, then drive a
+* {@link MapWorldRuntime} from {@link createRuntime} to load and unload
+* individual levels, each with its own asset scope.
+*
+* What is eager, and why:
+*
+* - the `.ldtk` document itself, because the world layout is what the game
+*   navigates by;
+* - every tileset atlas. This is a prefetch policy, not a technical
+*   requirement, and it is bounded: LDtk declares tilesets once per project
+*   (`defs.tilesets`), never per level, so the count does not grow with the
+*   number of levels. Paying for them once keeps a level load off the network
+*   entirely for a non-externalized project, and off the *image* network for an
+*   externalized one.
+*
+* The atlases are claimed by this asset's own scope, so their residency is tied
+* to how long the `ldtkProject` asset is held - not to a
+* {@link MapWorldRuntime}. Releasing the asset releases them; destroying a
+* runtime does not.
+*
+* What is lazy:
+*
+* - external `.ldtkl` level payloads - fetched when the level loads, claimed
+*   by that level's scope, released when it unloads;
+* - the conversion of a level into a runtime `TileMap`;
+* - anything the level's {@link import('@codexo/exojs-tilemap').MapObjectSpawner} creates.
+*
+* Load the whole project at once with the `ldtkMap` asset type instead
+* ({@link import('./LdtkMap').LdtkMap}) when a game is small enough not to
+* need any of this.
+*
+* @example
+* ```ts
+* const project = await scene.loader.load(Asset.type('ldtkProject', 'world.ldtk'));
+* const runtime = project.createRuntime({ scope: scene.loader });
+*
+* const forest = await runtime.loadLevel(project.world.getLevelByName('Forest')!.id, {
+*   spawner,
+*   context: { services, save },
+* });
+*
+* scene.addChild(forest.map.createView().root);
+* runtime.unloadLevel(forest.id);
+* ```
+*/
+var LdtkProject = class {
+	/** Resolved URL this project was loaded from. */
+	source;
+	/** The raw parsed LDtk document. Externalized levels still carry `layerInstances: null`. */
+	data;
+	/** Runtime tilesets keyed by LDtk tileset uid, shared by every level of the project. */
+	tilesets;
+	/** World layout, one entry per LDtk world. See {@link import('./ldtkToMapWorld').ldtkToMapWorld}. */
+	worlds;
+	_entries;
+	/** Projects are produced by the `ldtkProject` asset binding. @internal */
+	constructor(source, data, tilesets) {
+		this.source = source;
+		this.data = data;
+		this.tilesets = tilesets;
+		this.worlds = ldtkToMapWorld(data);
+		this._entries = getLdtkLevelEntries(data);
+	}
+	/**
+	* The project's only world. For a multi-world project this is the first in
+	* document order; read {@link worlds} to reach the others.
+	*/
+	get world() {
+		const [first] = this.worlds;
+		if (first === void 0) throw new Error(`LdtkProject: "${this.source}" declares no world.`);
+		return first;
+	}
+	/** The world with this identifier, or `undefined`. */
+	getWorld(name) {
+		return this.worlds.find((world) => world.name === name);
+	}
+	/**
+	* Create the live runtime that loads and unloads this project's levels.
+	*
+	* The runtime is a separate lifetime from the project: destroying it unloads
+	* every level it holds and leaves the project - document, world layout and
+	* tilesets - intact, ready for a new runtime.
+	*
+	* @throws {Error} when `options.world` names no world of this project.
+	*/
+	createRuntime(options) {
+		const world = options.world === void 0 ? this.world : this.getWorld(options.world);
+		if (world === void 0) throw new Error(`LdtkProject: "${this.source}" has no world named "${options.world ?? ""}".`);
+		return new MapWorldRuntime({
+			world,
+			scope: options.scope,
+			load: (context) => this._loadLevel(context)
+		});
+	}
+	async _loadLevel(context) {
+		const entry = this._entries[context.level.index];
+		if (entry === void 0) throw new Error(`LdtkProject: level "${context.level.id}" has index ${context.level.index}, which is outside "${this.source}".`);
+		const level = await this._resolveLevel(entry.level, context.scope);
+		return ldtkLevelToTileMap(level, entry.worldIid, context.level.index, this.data, this.tilesets);
+	}
+	/**
+	* Fetch an externalized level's `.ldtkl` payload and merge it into the level
+	* record. The fetch is claimed by the level's own scope, so it is released
+	* when the level unloads and re-fetched (or served from the loader's cache)
+	* on a later load.
+	*/
+	async _resolveLevel(level, scope) {
+		if (level.layerInstances !== null || level.externalRelPath === void 0 || level.externalRelPath === null || level.externalRelPath === "") return level;
+		const url = resolveLdtkUrl(level.externalRelPath, this.source);
+		const external = validateLdtkLevelData(await scope.load(Asset.type("json", url)), url);
+		const fieldInstances = external.fieldInstances ?? level.fieldInstances;
+		return {
+			...level,
+			layerInstances: external.layerInstances,
+			...fieldInstances !== void 0 && { fieldInstances }
+		};
+	}
+};
+
+//#endregion
+export { LdtkProject };
+//# sourceMappingURL=LdtkProject.js.map

package/dist/esm/LdtkProject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LdtkProject.js","names":[],"sources":["../../src/LdtkProject.ts"],"sourcesContent":["import type { LoaderScope } from '@codexo/exojs';\nimport { Asset } from '@codexo/exojs';\nimport type { MapLevelLoadContext, MapWorld, TileMap, TileSet } from '@codexo/exojs-tilemap';\nimport { MapWorldRuntime } from '@codexo/exojs-tilemap';\n\nimport type { LdtkData, LdtkLevel } from './LdtkData';\nimport type { LdtkLevelEntry } from './ldtkLevelEntries';\nimport { getLdtkLevelEntries } from './ldtkLevelEntries';\nimport { ldtkToMapWorld } from './ldtkToMapWorld';\nimport { ldtkLevelToTileMap } from './ldtkToTileMap';\nimport { resolveLdtkUrl } from './url';\nimport { validateLdtkLevelData } from './validate';\n\n/** Options for {@link LdtkProject.createRuntime}. */\nexport interface LdtkRuntimeOptions {\n  /**\n   * Parent scope for everything the runtime loads. The runtime creates its own\n   * child scope under it and never destroys this one.\n   */\n  readonly scope: LoaderScope;\n  /**\n   * Which world of a multi-world project to stream, by identifier. Defaults to\n   * the first world in document order, which is the only one a single-world\n   * project has.\n   */\n  readonly world?: string;\n}\n\n/**\n * A loaded LDtk project, prepared for streaming: world layout and tileset\n * atlases are resident, level payloads are not.\n *\n * This is the entry point for a game that loads levels as it needs them. Read\n * {@link worlds} to decide what to load, then drive a\n * {@link MapWorldRuntime} from {@link createRuntime} to load and unload\n * individual levels, each with its own asset scope.\n *\n * What is eager, and why:\n *\n * - the `.ldtk` document itself, because the world layout is what the game\n *   navigates by;\n * - every tileset atlas. This is a prefetch policy, not a technical\n *   requirement, and it is bounded: LDtk declares tilesets once per project\n *   (`defs.tilesets`), never per level, so the count does not grow with the\n *   number of levels. Paying for them once keeps a level load off the network\n *   entirely for a non-externalized project, and off the *image* network for an\n *   externalized one.\n *\n * The atlases are claimed by this asset's own scope, so their residency is tied\n * to how long the `ldtkProject` asset is held - not to a\n * {@link MapWorldRuntime}. Releasing the asset releases them; destroying a\n * runtime does not.\n *\n * What is lazy:\n *\n * - external `.ldtkl` level payloads - fetched when the level loads, claimed\n *   by that level's scope, released when it unloads;\n * - the conversion of a level into a runtime `TileMap`;\n * - anything the level's {@link import('@codexo/exojs-tilemap').MapObjectSpawner} creates.\n *\n * Load the whole project at once with the `ldtkMap` asset type instead\n * ({@link import('./LdtkMap').LdtkMap}) when a game is small enough not to\n * need any of this.\n *\n * @example\n * ```ts\n * const project = await scene.loader.load(Asset.type('ldtkProject', 'world.ldtk'));\n * const runtime = project.createRuntime({ scope: scene.loader });\n *\n * const forest = await runtime.loadLevel(project.world.getLevelByName('Forest')!.id, {\n *   spawner,\n *   context: { services, save },\n * });\n *\n * scene.addChild(forest.map.createView().root);\n * runtime.unloadLevel(forest.id);\n * ```\n */\nexport class LdtkProject {\n  /** Resolved URL this project was loaded from. */\n  public readonly source: string;\n  /** The raw parsed LDtk document. Externalized levels still carry `layerInstances: null`. */\n  public readonly data: LdtkData;\n  /** Runtime tilesets keyed by LDtk tileset uid, shared by every level of the project. */\n  public readonly tilesets: ReadonlyMap<number, TileSet>;\n  /** World layout, one entry per LDtk world. See {@link import('./ldtkToMapWorld').ldtkToMapWorld}. */\n  public readonly worlds: readonly MapWorld[];\n\n  private readonly _entries: readonly LdtkLevelEntry[];\n\n  /** Projects are produced by the `ldtkProject` asset binding. @internal */\n  public constructor(source: string, data: LdtkData, tilesets: ReadonlyMap<number, TileSet>) {\n    this.source = source;\n    this.data = data;\n    this.tilesets = tilesets;\n    this.worlds = ldtkToMapWorld(data);\n    this._entries = getLdtkLevelEntries(data);\n  }\n\n  /**\n   * The project's only world. For a multi-world project this is the first in\n   * document order; read {@link worlds} to reach the others.\n   */\n  public get world(): MapWorld {\n    const [first] = this.worlds;\n\n    if (first === undefined) {\n      throw new Error(`LdtkProject: \"${this.source}\" declares no world.`);\n    }\n\n    return first;\n  }\n\n  /** The world with this identifier, or `undefined`. */\n  public getWorld(name: string): MapWorld | undefined {\n    return this.worlds.find(world => world.name === name);\n  }\n\n  /**\n   * Create the live runtime that loads and unloads this project's levels.\n   *\n   * The runtime is a separate lifetime from the project: destroying it unloads\n   * every level it holds and leaves the project - document, world layout and\n   * tilesets - intact, ready for a new runtime.\n   *\n   * @throws {Error} when `options.world` names no world of this project.\n   */\n  public createRuntime(options: LdtkRuntimeOptions): MapWorldRuntime {\n    const world = options.world === undefined ? this.world : this.getWorld(options.world);\n\n    if (world === undefined) {\n      throw new Error(`LdtkProject: \"${this.source}\" has no world named \"${options.world ?? ''}\".`);\n    }\n\n    return new MapWorldRuntime({\n      world,\n      scope: options.scope,\n      load: context => this._loadLevel(context),\n    });\n  }\n\n  private async _loadLevel(context: MapLevelLoadContext): Promise<TileMap> {\n    const entry = this._entries[context.level.index];\n\n    if (entry === undefined) {\n      throw new Error(`LdtkProject: level \"${context.level.id}\" has index ${context.level.index}, which is outside \"${this.source}\".`);\n    }\n\n    const level = await this._resolveLevel(entry.level, context.scope);\n\n    return ldtkLevelToTileMap(level, entry.worldIid, context.level.index, this.data, this.tilesets);\n  }\n\n  /**\n   * Fetch an externalized level's `.ldtkl` payload and merge it into the level\n   * record. The fetch is claimed by the level's own scope, so it is released\n   * when the level unloads and re-fetched (or served from the loader's cache)\n   * on a later load.\n   */\n  private async _resolveLevel(level: LdtkLevel, scope: LoaderScope): Promise<LdtkLevel> {\n    if (level.layerInstances !== null || level.externalRelPath === undefined || level.externalRelPath === null || level.externalRelPath === '') {\n      return level;\n    }\n\n    const url = resolveLdtkUrl(level.externalRelPath, this.source);\n    // Validated as strictly as an inlined level, with the `.ldtkl` file as the\n    // error source - a malformed external payload must fail as loudly.\n    const external = validateLdtkLevelData(await scope.load(Asset.type('json', url)), url);\n    const fieldInstances = external.fieldInstances ?? level.fieldInstances;\n\n    return {\n      ...level,\n      layerInstances: external.layerInstances,\n      ...(fieldInstances !== undefined && { fieldInstances }),\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,IAAa,cAAb,MAAyB;;CAEvB,AAAgB;;CAEhB,AAAgB;;CAEhB,AAAgB;;CAEhB,AAAgB;CAEhB,AAAiB;;CAGjB,AAAO,YAAY,QAAgB,MAAgB,UAAwC;EACzF,KAAK,SAAS;EACd,KAAK,OAAO;EACZ,KAAK,WAAW;EAChB,KAAK,SAAS,eAAe,IAAI;EACjC,KAAK,WAAW,oBAAoB,IAAI;CAC1C;;;;;CAMA,IAAW,QAAkB;EAC3B,MAAM,CAAC,SAAS,KAAK;EAErB,IAAI,UAAU,QACZ,MAAM,IAAI,MAAM,iBAAiB,KAAK,OAAO,qBAAqB;EAGpE,OAAO;CACT;;CAGA,AAAO,SAAS,MAAoC;EAClD,OAAO,KAAK,OAAO,MAAK,UAAS,MAAM,SAAS,IAAI;CACtD;;;;;;;;;;CAWA,AAAO,cAAc,SAA8C;EACjE,MAAM,QAAQ,QAAQ,UAAU,SAAY,KAAK,QAAQ,KAAK,SAAS,QAAQ,KAAK;EAEpF,IAAI,UAAU,QACZ,MAAM,IAAI,MAAM,iBAAiB,KAAK,OAAO,wBAAwB,QAAQ,SAAS,GAAG,GAAG;EAG9F,OAAO,IAAI,gBAAgB;GACzB;GACA,OAAO,QAAQ;GACf,OAAM,YAAW,KAAK,WAAW,OAAO;EAC1C,CAAC;CACH;CAEA,MAAc,WAAW,SAAgD;EACvE,MAAM,QAAQ,KAAK,SAAS,QAAQ,MAAM;EAE1C,IAAI,UAAU,QACZ,MAAM,IAAI,MAAM,uBAAuB,QAAQ,MAAM,GAAG,cAAc,QAAQ,MAAM,MAAM,sBAAsB,KAAK,OAAO,GAAG;EAGjI,MAAM,QAAQ,MAAM,KAAK,cAAc,MAAM,OAAO,QAAQ,KAAK;EAEjE,OAAO,mBAAmB,OAAO,MAAM,UAAU,QAAQ,MAAM,OAAO,KAAK,MAAM,KAAK,QAAQ;CAChG;;;;;;;CAQA,MAAc,cAAc,OAAkB,OAAwC;EACpF,IAAI,MAAM,mBAAmB,QAAQ,MAAM,oBAAoB,UAAa,MAAM,oBAAoB,QAAQ,MAAM,oBAAoB,IACtI,OAAO;EAGT,MAAM,MAAM,eAAe,MAAM,iBAAiB,KAAK,MAAM;EAG7D,MAAM,WAAW,sBAAsB,MAAM,MAAM,KAAK,MAAM,KAAK,QAAQ,GAAG,CAAC,GAAG,GAAG;EACrF,MAAM,iBAAiB,SAAS,kBAAkB,MAAM;EAExD,OAAO;GACL,GAAG;GACH,gBAAgB,SAAS;GACzB,GAAI,mBAAmB,UAAa,EAAE,eAAe;EACvD;CACF;AACF"}

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,7 +1,11 @@
-export { ldtkMapBinding } from './ldtkBinding.js';
-export { ldtkExtension } from './ldtkExtension.js';
-export { LdtkMap } from './LdtkMap.js';
-export { getLdtkIntGridValueAt, ldtkIntGridCsvProperty, ldtkIntGridValuesProperty, ldtkToTileMap } from './ldtkToTileMap.js';
-export { ldtkFlipNone, ldtkFlipX, ldtkFlipXy, ldtkFlipY } from './LdtkData.js';
-export { ObjectKind, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileMap, TileMapView, TilePropertyKind, TileSet, tilemapExtension } from '@codexo/exojs-tilemap';
-//# sourceMappingURL=index.js.map
+import { LDTK_FLIP_NONE, LDTK_FLIP_X, LDTK_FLIP_XY, LDTK_FLIP_Y } from "./LdtkData.js";
+import { createLdtkIntGridCellSource, getLdtkIntGridValueAt, ldtkIntGridCsvProperty, ldtkIntGridValuesProperty, ldtkToTileMap } from "./ldtkToTileMap.js";
+import { ldtkToMapWorld } from "./ldtkToMapWorld.js";
+import { LdtkMap } from "./LdtkMap.js";
+import { LdtkFormatError } from "./validate.js";
+import { LdtkProject } from "./LdtkProject.js";
+import { LdtkMapAssetType, LdtkProjectAssetType, ldtkMapType, ldtkProjectType } from "./ldtkTypes.js";
+import { ldtkExtension } from "./ldtkExtension.js";
+import { MapLevelRuntime, MapLevelSide, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectKind, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileMap, TileMapView, TilePropertyKind, TileSet, mapObjectDescriptor, mapObjectDescriptors, tilemapExtension } from "./public.js";
+
+export { LDTK_FLIP_NONE, LDTK_FLIP_X, LDTK_FLIP_XY, LDTK_FLIP_Y, LdtkFormatError, LdtkMap, LdtkMapAssetType, LdtkProject, LdtkProjectAssetType, MapLevelRuntime, MapLevelSide, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectKind, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileMap, TileMapView, TilePropertyKind, TileSet, createLdtkIntGridCellSource, getLdtkIntGridValueAt, ldtkExtension, ldtkIntGridCsvProperty, ldtkIntGridValuesProperty, ldtkMapType, ldtkProjectType, ldtkToMapWorld, ldtkToTileMap, mapObjectDescriptor, mapObjectDescriptors, tilemapExtension };

package/dist/esm/ldtkExtension.d.ts

@@ -2,16 +2,20 @@ import type { Extension } from '@codexo/exojs/extensions';
 /**
  * Default immutable LDtk extension descriptor.
  *
- * Registers one asset binding:
- * - {@link ldtkMapBinding} — `loader.load(LdtkMap, 'world.ldtk')` → fetches
- *   the `.ldtk` JSON, loads all referenced tileset images, and returns a
+ * Installs two asset types:
+ * - {@link ldtkMapType} - `loader.load(ldtkMapType.asset('world.ldtk'))` reads
+ *   the `.ldtk` document, loads all referenced tileset images, and returns a
  *   fully assembled {@link LdtkMap} with one runtime
  *   {@link import('@codexo/exojs-tilemap').TileMap} per level.
+ * - {@link ldtkProjectType} - `loader.load(ldtkProjectType.asset('world.ldtk'))`
+ *   returns the world layout and tileset atlases only, for games that load
+ *   levels on demand.
  *
  * Depends on {@link tilemapExtension} so that snapshot construction always
  * materialises the generic tilemap runtime before the LDtk adapter.
  *
- * Use with `ApplicationOptions.extensions` or call
- * `import '@codexo/exojs-ldtk/register'` for global auto-registration.
+ * Pass it to the application that should have it via
+ * `ApplicationOptions.extensions`.
  */
 export declare const ldtkExtension: Extension;
+//# sourceMappingURL=ldtkExtension.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ldtkExtension.d.ts","sourceRoot":"","sources":["../../src/ldtkExtension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAK1D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,EAAE,SAI1B,CAAC"}

package/dist/esm/ldtkExtension.js

@@ -1,28 +1,31 @@
-import { tilemapExtension } from '@codexo/exojs-tilemap';
-import { ldtkMapBinding } from './ldtkBinding.js';
+import { ldtkMapType, ldtkProjectType } from "./ldtkTypes.js";
+import { tilemapExtension } from "@codexo/exojs-tilemap";
 
+//#region src/ldtkExtension.ts
 /**
- * Default immutable LDtk extension descriptor.
- *
- * Registers one asset binding:
- * - {@link ldtkMapBinding} — `loader.load(LdtkMap, 'world.ldtk')` → fetches
- *   the `.ldtk` JSON, loads all referenced tileset images, and returns a
- *   fully assembled {@link LdtkMap} with one runtime
- *   {@link import('@codexo/exojs-tilemap').TileMap} per level.
- *
- * Depends on {@link tilemapExtension} so that snapshot construction always
- * materialises the generic tilemap runtime before the LDtk adapter.
- *
- * Use with `ApplicationOptions.extensions` or call
- * `import '@codexo/exojs-ldtk/register'` for global auto-registration.
- */
+* Default immutable LDtk extension descriptor.
+*
+* Installs two asset types:
+* - {@link ldtkMapType} - `loader.load(ldtkMapType.asset('world.ldtk'))` reads
+*   the `.ldtk` document, loads all referenced tileset images, and returns a
+*   fully assembled {@link LdtkMap} with one runtime
+*   {@link import('@codexo/exojs-tilemap').TileMap} per level.
+* - {@link ldtkProjectType} - `loader.load(ldtkProjectType.asset('world.ldtk'))`
+*   returns the world layout and tileset atlases only, for games that load
+*   levels on demand.
+*
+* Depends on {@link tilemapExtension} so that snapshot construction always
+* materialises the generic tilemap runtime before the LDtk adapter.
+*
+* Pass it to the application that should have it via
+* `ApplicationOptions.extensions`.
+*/
 const ldtkExtension = Object.freeze({
-    id: '@codexo/exojs-ldtk',
-    dependencies: [tilemapExtension],
-    // Localized erasure cast: typed binding meets the untyped Extension.assets
-    // contract here. Runtime behaviour is unaffected.
-    assets: [ldtkMapBinding],
+	id: "@codexo/exojs-ldtk",
+	dependencies: [tilemapExtension],
+	assets: [ldtkMapType, ldtkProjectType]
 });
 
+//#endregion
 export { ldtkExtension };
-//# sourceMappingURL=ldtkExtension.js.map
+//# sourceMappingURL=ldtkExtension.js.map

package/dist/esm/ldtkExtension.js.map

@@ -1 +1 @@
-{"version":3,"file":"ldtkExtension.js","sources":["../../../src/ldtkExtension.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;AAcG;AACI,MAAM,aAAa,GAAc,MAAM,CAAC,MAAM,CAAC;AACpD,IAAA,EAAE,EAAE,oBAAoB;IACxB,YAAY,EAAE,CAAC,gBAAgB,CAAC;;;IAGhC,MAAM,EAAE,CAAC,cAAc,CAA8B;AACtD,CAAA;;;;"}
+{"version":3,"file":"ldtkExtension.js","names":[],"sources":["../../src/ldtkExtension.ts"],"sourcesContent":["import type { Extension } from '@codexo/exojs/extensions';\nimport { tilemapExtension } from '@codexo/exojs-tilemap';\n\nimport { ldtkMapType, ldtkProjectType } from './ldtkTypes';\n\n/**\n * Default immutable LDtk extension descriptor.\n *\n * Installs two asset types:\n * - {@link ldtkMapType} - `loader.load(ldtkMapType.asset('world.ldtk'))` reads\n *   the `.ldtk` document, loads all referenced tileset images, and returns a\n *   fully assembled {@link LdtkMap} with one runtime\n *   {@link import('@codexo/exojs-tilemap').TileMap} per level.\n * - {@link ldtkProjectType} - `loader.load(ldtkProjectType.asset('world.ldtk'))`\n *   returns the world layout and tileset atlases only, for games that load\n *   levels on demand.\n *\n * Depends on {@link tilemapExtension} so that snapshot construction always\n * materialises the generic tilemap runtime before the LDtk adapter.\n *\n * Pass it to the application that should have it via\n * `ApplicationOptions.extensions`.\n */\nexport const ldtkExtension: Extension = Object.freeze({\n  id: '@codexo/exojs-ldtk',\n  dependencies: [tilemapExtension],\n  assets: [ldtkMapType, ldtkProjectType],\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,gBAA2B,OAAO,OAAO;CACpD,IAAI;CACJ,cAAc,CAAC,gBAAgB;CAC/B,QAAQ,CAAC,aAAa,eAAe;AACvC,CAAC"}

package/dist/esm/ldtkLevelEntries.d.ts

@@ -3,7 +3,7 @@ import type { LdtkData, LdtkLevel } from './LdtkData';
  * One level from a (possibly multi-world) {@link LdtkData} document, paired
  * with the {@link import('./LdtkData').LdtkWorldData.iid} of the world it
  * belongs to. `worldIid` is `undefined` when the document uses the legacy
- * single-world shape (`data.levels`, no `worlds[]`) — the overwhelmingly
+ * single-world shape (`data.levels`, no `worlds[]`) - the overwhelmingly
  * common case.
  */
 export interface LdtkLevelEntry {
@@ -17,11 +17,12 @@ export interface LdtkLevelEntry {
  * `data.worlds[].levels`, each tagged here with its owning world's `iid`;
  * per the LDtk spec the root `levels` array is kept but EMPTY in this shape).
  *
- * This is the single place that decides which shape a document uses — every
+ * This is the single place that decides which shape a document uses - every
  * consumer that needs "all levels, in document order" ({@link import('./loadLdtkMap').loadLdtkMap}'s
  * external `.ldtkl` resolution, {@link import('./ldtkToTileMap').ldtkToTileMap}'s
  * conversion, and {@link import('./LdtkMap').LdtkMap.getLevelByName}'s lookup)
  * goes through this function rather than re-deriving the single/multi-world
  * detection independently.
  */
-export declare function getLdtkLevelEntries(data: LdtkData): readonly LdtkLevelEntry[];
+export declare const getLdtkLevelEntries: (data: LdtkData) => readonly LdtkLevelEntry[];
+//# sourceMappingURL=ldtkLevelEntries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ldtkLevelEntries.d.ts","sourceRoot":"","sources":["../../src/ldtkLevelEntries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,QAAQ,KAAG,SAAS,cAAc,EAY3E,CAAC"}

package/dist/esm/ldtkLevelEntries.js

@@ -1,29 +1,33 @@
+//#region src/ldtkLevelEntries.ts
 /**
- * Flatten a {@link LdtkData} document's levels into one ordered list,
- * abstracting over LDtk's two root shapes: single-world (levels live in the
- * root {@link LdtkData.levels}) and multi-world (levels live in
- * `data.worlds[].levels`, each tagged here with its owning world's `iid`;
- * per the LDtk spec the root `levels` array is kept but EMPTY in this shape).
- *
- * This is the single place that decides which shape a document uses — every
- * consumer that needs "all levels, in document order" ({@link import('./loadLdtkMap').loadLdtkMap}'s
- * external `.ldtkl` resolution, {@link import('./ldtkToTileMap').ldtkToTileMap}'s
- * conversion, and {@link import('./LdtkMap').LdtkMap.getLevelByName}'s lookup)
- * goes through this function rather than re-deriving the single/multi-world
- * detection independently.
- */
-function getLdtkLevelEntries(data) {
-    if (data.worlds && data.worlds.length > 0) {
-        const entries = [];
-        for (const world of data.worlds) {
-            for (const level of world.levels) {
-                entries.push({ level, worldIid: world.iid });
-            }
-        }
-        return entries;
-    }
-    return data.levels.map(level => ({ level, worldIid: undefined }));
-}
+* Flatten a {@link LdtkData} document's levels into one ordered list,
+* abstracting over LDtk's two root shapes: single-world (levels live in the
+* root {@link LdtkData.levels}) and multi-world (levels live in
+* `data.worlds[].levels`, each tagged here with its owning world's `iid`;
+* per the LDtk spec the root `levels` array is kept but EMPTY in this shape).
+*
+* This is the single place that decides which shape a document uses - every
+* consumer that needs "all levels, in document order" ({@link import('./loadLdtkMap').loadLdtkMap}'s
+* external `.ldtkl` resolution, {@link import('./ldtkToTileMap').ldtkToTileMap}'s
+* conversion, and {@link import('./LdtkMap').LdtkMap.getLevelByName}'s lookup)
+* goes through this function rather than re-deriving the single/multi-world
+* detection independently.
+*/
+const getLdtkLevelEntries = (data) => {
+	if (data.worlds && data.worlds.length > 0) {
+		const entries = [];
+		for (const world of data.worlds) for (const level of world.levels) entries.push({
+			level,
+			worldIid: world.iid
+		});
+		return entries;
+	}
+	return data.levels.map((level) => ({
+		level,
+		worldIid: void 0
+	}));
+};
 
+//#endregion
 export { getLdtkLevelEntries };
-//# sourceMappingURL=ldtkLevelEntries.js.map
+//# sourceMappingURL=ldtkLevelEntries.js.map

package/dist/esm/ldtkLevelEntries.js.map

@@ -1 +1 @@
-{"version":3,"file":"ldtkLevelEntries.js","sources":["../../../src/ldtkLevelEntries.ts"],"sourcesContent":[null],"names":[],"mappings":"AAcA;;;;;;;;;;;;;AAaG;AACG,SAAU,mBAAmB,CAAC,IAAc,EAAA;AAChD,IAAA,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;QACzC,MAAM,OAAO,GAAqB,EAAE;AACpC,QAAA,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE;AAC/B,YAAA,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE;AAChC,gBAAA,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC;YAC9C;QACF;AACA,QAAA,OAAO,OAAO;IAChB;IAEA,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;AACnE;;;;"}
+{"version":3,"file":"ldtkLevelEntries.js","names":[],"sources":["../../src/ldtkLevelEntries.ts"],"sourcesContent":["import type { LdtkData, LdtkLevel } from './LdtkData';\n\n/**\n * One level from a (possibly multi-world) {@link LdtkData} document, paired\n * with the {@link import('./LdtkData').LdtkWorldData.iid} of the world it\n * belongs to. `worldIid` is `undefined` when the document uses the legacy\n * single-world shape (`data.levels`, no `worlds[]`) - the overwhelmingly\n * common case.\n */\nexport interface LdtkLevelEntry {\n  readonly level: LdtkLevel;\n  readonly worldIid: string | undefined;\n}\n\n/**\n * Flatten a {@link LdtkData} document's levels into one ordered list,\n * abstracting over LDtk's two root shapes: single-world (levels live in the\n * root {@link LdtkData.levels}) and multi-world (levels live in\n * `data.worlds[].levels`, each tagged here with its owning world's `iid`;\n * per the LDtk spec the root `levels` array is kept but EMPTY in this shape).\n *\n * This is the single place that decides which shape a document uses - every\n * consumer that needs \"all levels, in document order\" ({@link import('./loadLdtkMap').loadLdtkMap}'s\n * external `.ldtkl` resolution, {@link import('./ldtkToTileMap').ldtkToTileMap}'s\n * conversion, and {@link import('./LdtkMap').LdtkMap.getLevelByName}'s lookup)\n * goes through this function rather than re-deriving the single/multi-world\n * detection independently.\n */\nexport const getLdtkLevelEntries = (data: LdtkData): readonly LdtkLevelEntry[] => {\n  if (data.worlds && data.worlds.length > 0) {\n    const entries: LdtkLevelEntry[] = [];\n    for (const world of data.worlds) {\n      for (const level of world.levels) {\n        entries.push({ level, worldIid: world.iid });\n      }\n    }\n    return entries;\n  }\n\n  return data.levels.map(level => ({ level, worldIid: undefined }));\n};\n"],"mappings":";;;;;;;;;;;;;;;AA4BA,MAAa,uBAAuB,SAA8C;CAChF,IAAI,KAAK,UAAU,KAAK,OAAO,SAAS,GAAG;EACzC,MAAM,UAA4B,CAAC;EACnC,KAAK,MAAM,SAAS,KAAK,QACvB,KAAK,MAAM,SAAS,MAAM,QACxB,QAAQ,KAAK;GAAE;GAAO,UAAU,MAAM;EAAI,CAAC;EAG/C,OAAO;CACT;CAEA,OAAO,KAAK,OAAO,KAAI,WAAU;EAAE;EAAO,UAAU;CAAU,EAAE;AAClE"}

package/dist/esm/ldtkParallax.d.ts

@@ -0,0 +1,22 @@
+import type { LdtkData } from './LdtkData';
+/** Resolved runtime parallax transform for one LDtk layer instance. */
+export interface LdtkLayerParallax {
+    readonly parallaxX: number;
+    readonly parallaxY: number;
+    readonly parallaxScale: number;
+    /** Definition offset plus LDtk's unscaled-parallax centre compensation. */
+    readonly offsetX: number;
+    /** Definition offset plus LDtk's unscaled-parallax centre compensation. */
+    readonly offsetY: number;
+}
+/**
+ * Resolve the runtime parallax transform for a layer instance. Missing
+ * definitions and factors use LDtk's defaults: no shift and scale `1`.
+ */
+export declare const resolveLdtkLayerParallax: (data: LdtkData, layer: {
+    readonly layerDefUid: number;
+    readonly __cWid: number;
+    readonly __cHei: number;
+    readonly __gridSize: number;
+}) => LdtkLayerParallax;
+//# sourceMappingURL=ldtkParallax.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ldtkParallax.d.ts","sourceRoot":"","sources":["../../src/ldtkParallax.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,uEAAuE;AACvE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,QAAQ,EACd,OAAO;IACL,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,KACA,iBAaF,CAAC"}

package/dist/esm/ldtkParallax.js

@@ -0,0 +1,22 @@
+//#region src/ldtkParallax.ts
+/**
+* Resolve the runtime parallax transform for a layer instance. Missing
+* definitions and factors use LDtk's defaults: no shift and scale `1`.
+*/
+const resolveLdtkLayerParallax = (data, layer) => {
+	const layerDef = data.defs.layers.find((def) => def.uid === layer.layerDefUid);
+	const factorX = layerDef?.parallaxFactorX ?? 0;
+	const factorY = layerDef?.parallaxFactorY ?? 0;
+	const scaling = layerDef?.parallaxScaling ?? true;
+	return {
+		parallaxX: 1 - factorX,
+		parallaxY: 1 - factorY,
+		parallaxScale: scaling && factorX !== 0 ? Math.max(.01, 1 - factorX) : 1,
+		offsetX: (layerDef?.pxOffsetX ?? 0) + (scaling ? 0 : -layer.__cWid * layer.__gridSize * .5 * factorX),
+		offsetY: (layerDef?.pxOffsetY ?? 0) + (scaling ? 0 : -layer.__cHei * layer.__gridSize * .5 * factorY)
+	};
+};
+
+//#endregion
+export { resolveLdtkLayerParallax };
+//# sourceMappingURL=ldtkParallax.js.map

package/dist/esm/ldtkParallax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ldtkParallax.js","names":[],"sources":["../../src/ldtkParallax.ts"],"sourcesContent":["// LDtk → runtime parallax conversion.\n//\n// LDtk's `parallaxFactorX`/`parallaxFactorY` (declared on `defs.layers[]`,\n// range `[-1, 1]`) use `0` for normal camera speed. The runtime tilemap model\n// uses the opposite convention: `1` is normal speed, and render code derives\n// the camera-relative shift as `camCenter * (1 - parallaxX)`. Therefore the\n// scroll conversion is `runtimeFactor = 1 - ldtkFactor`.\n//\n// LDtk's editor applies one uniform scale derived from the horizontal factor:\n// `max(0.01, 1 - parallaxFactorX)`. Scaling happens around the layer origin.\n// When scaling is disabled, the editor offsets the unscaled layer by half its\n// dimensions times the factor so its centre follows the same parallax path.\n\nimport type { LdtkData } from './LdtkData';\n\n/** Resolved runtime parallax transform for one LDtk layer instance. */\nexport interface LdtkLayerParallax {\n  readonly parallaxX: number;\n  readonly parallaxY: number;\n  readonly parallaxScale: number;\n  /** Definition offset plus LDtk's unscaled-parallax centre compensation. */\n  readonly offsetX: number;\n  /** Definition offset plus LDtk's unscaled-parallax centre compensation. */\n  readonly offsetY: number;\n}\n\n/**\n * Resolve the runtime parallax transform for a layer instance. Missing\n * definitions and factors use LDtk's defaults: no shift and scale `1`.\n */\nexport const resolveLdtkLayerParallax = (\n  data: LdtkData,\n  layer: {\n    readonly layerDefUid: number;\n    readonly __cWid: number;\n    readonly __cHei: number;\n    readonly __gridSize: number;\n  },\n): LdtkLayerParallax => {\n  const layerDef = data.defs.layers.find(def => def.uid === layer.layerDefUid);\n  const factorX = layerDef?.parallaxFactorX ?? 0;\n  const factorY = layerDef?.parallaxFactorY ?? 0;\n  const scaling = layerDef?.parallaxScaling ?? true;\n\n  return {\n    parallaxX: 1 - factorX,\n    parallaxY: 1 - factorY,\n    parallaxScale: scaling && factorX !== 0 ? Math.max(0.01, 1 - factorX) : 1,\n    offsetX: (layerDef?.pxOffsetX ?? 0) + (scaling ? 0 : -layer.__cWid * layer.__gridSize * 0.5 * factorX),\n    offsetY: (layerDef?.pxOffsetY ?? 0) + (scaling ? 0 : -layer.__cHei * layer.__gridSize * 0.5 * factorY),\n  };\n};\n"],"mappings":";;;;;AA8BA,MAAa,4BACX,MACA,UAMsB;CACtB,MAAM,WAAW,KAAK,KAAK,OAAO,MAAK,QAAO,IAAI,QAAQ,MAAM,WAAW;CAC3E,MAAM,UAAU,UAAU,mBAAmB;CAC7C,MAAM,UAAU,UAAU,mBAAmB;CAC7C,MAAM,UAAU,UAAU,mBAAmB;CAE7C,OAAO;EACL,WAAW,IAAI;EACf,WAAW,IAAI;EACf,eAAe,WAAW,YAAY,IAAI,KAAK,IAAI,KAAM,IAAI,OAAO,IAAI;EACxE,UAAU,UAAU,aAAa,MAAM,UAAU,IAAI,CAAC,MAAM,SAAS,MAAM,aAAa,KAAM;EAC9F,UAAU,UAAU,aAAa,MAAM,UAAU,IAAI,CAAC,MAAM,SAAS,MAAM,aAAa,KAAM;CAChG;AACF"}

package/dist/esm/ldtkToMapWorld.d.ts

@@ -0,0 +1,20 @@
+import { MapWorld } from '@codexo/exojs-tilemap';
+import type { LdtkData } from './LdtkData';
+/**
+ * Build the format-neutral world model for an LDtk document: one
+ * {@link MapWorld} per LDtk world, in document order.
+ *
+ * A single-world project - the overwhelmingly common shape - yields exactly one
+ * unnamed world. A multi-world project yields one per entry of `worlds[]`, each
+ * named by its identifier, and they stay separate on purpose: LDtk worlds have independent coordinate spaces, so merging them
+ * would make {@link MapWorld.bounds} and {@link MapWorld.getLevelsInBounds}
+ * report overlaps that do not exist.
+ *
+ * {@link MapLevel.index} counts across the whole document, matching the
+ * flattened order {@link import('./LdtkMap').LdtkMap.levels} uses.
+ *
+ * Level metadata only: no layer payload is read, so this is safe to call on a
+ * document whose external levels have not been fetched.
+ */
+export declare const ldtkToMapWorld: (data: LdtkData) => readonly MapWorld[];
+//# sourceMappingURL=ldtkToMapWorld.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ldtkToMapWorld.d.ts","sourceRoot":"","sources":["../../src/ldtkToMapWorld.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,YAAY,CAAC;AAyCtD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,QAAQ,KAAG,SAAS,QAAQ,EAgBhE,CAAC"}