@codexo/exojs-tiled 0.15.3 → 0.16.0

package/dist/esm/loadTiledMap.js

@@ -1,98 +1,89 @@
-import { Texture } from '@codexo/exojs';
-import { decodeTiledLayerData } from './decodeLayerData.js';
-import { TiledMap } from './TiledMap.js';
-import { TiledTileset } from './TiledTileset.js';
-import { resolveTiledUrl } from './url.js';
-import { validateTiledMapData, validateTiledTilesetFileData } from './validate.js';
+import { validateTiledTilesetFileData } from "./validate.js";
+import { resolveTiledUrl } from "./url.js";
+import { TiledMap } from "./TiledMap.js";
+import { TiledTileset } from "./TiledTileset.js";
+import { Asset } from "@codexo/exojs";
 
+//#region src/loadTiledMap.ts
 /**
- * Resolves and loads the image(s) referenced by a tileset: the atlas
- * `image` (if present) and any collection-of-images per-tile `image`
- * entries, relative to `baseUrl` (the resolved location of the file the
- * tileset data came from — the `.tmj` for an embedded tileset, the `.tsj`
- * for an external one).
- *
- * Textures are loaded via `context.loader`, which deduplicates concurrent
- * and repeated loads of the same normalized URL.
- */
-async function loadTiledTilesetResources(data, baseUrl, context, source) {
-    let imageUrl;
-    let texture;
-    if (data.image !== undefined) {
-        imageUrl = resolveTiledUrl(data.image, baseUrl);
-        texture = await context.loader.load(Texture, imageUrl);
-    }
-    let tileTextures;
-    if (data.tiles !== undefined) {
-        for (const tile of data.tiles) {
-            if (tile.image === undefined) {
-                continue;
-            }
-            const tileImageUrl = resolveTiledUrl(tile.image, baseUrl);
-            const tileTexture = await context.loader.load(Texture, tileImageUrl);
-            tileTextures ??= new Map();
-            tileTextures.set(tile.id, tileTexture);
-        }
-    }
-    return { source, imageUrl, texture, tileTextures };
-}
+* Resolves and loads the image(s) referenced by a tileset: the atlas
+* `image` (if present) and any collection-of-images per-tile `image`
+* entries, relative to `baseUrl` (the resolved location of the file the
+* tileset data came from - the `.tmj` for an embedded tileset, the `.tsj`
+* for an external one).
+*
+* Textures are claimed by this map's own dependency scope, which deduplicates
+* concurrent and repeated loads of the same normalized URL and releases them
+* with the map.
+*/
+const loadTiledTilesetResources = async (data, baseUrl, context, source) => {
+	let imageUrl;
+	let texture;
+	if (data.image !== void 0) {
+		imageUrl = resolveTiledUrl(data.image, baseUrl);
+		texture = await context.dependencies.load(Asset.type("texture", imageUrl));
+	}
+	let tileTextures;
+	if (data.tiles !== void 0) for (const tile of data.tiles) {
+		if (tile.image === void 0) continue;
+		const tileImageUrl = resolveTiledUrl(tile.image, baseUrl);
+		const tileTexture = await context.dependencies.load(Asset.type("texture", tileImageUrl));
+		tileTextures ??= /* @__PURE__ */ new Map();
+		tileTextures.set(tile.id, tileTexture);
+	}
+	return {
+		source,
+		imageUrl,
+		texture,
+		tileTextures
+	};
+};
 /**
- * Resolves one `tilesets[]` entry of a `.tmj` file to a {@link TiledTileset}:
- * fetches and validates the external `.tsj` if `ref.source` is set, or uses
- * the embedded tileset data directly, then resolves and loads its image(s).
- */
-async function loadTiledTileset(ref, mapSource, context) {
-    if ('source' in ref) {
-        const tsjUrl = resolveTiledUrl(ref.source, mapSource);
-        const raw = await context.fetchJson(tsjUrl);
-        const data = validateTiledTilesetFileData(raw, tsjUrl);
-        const resources = await loadTiledTilesetResources(data, tsjUrl, context, tsjUrl);
-        return new TiledTileset(data, ref.firstgid, resources);
-    }
-    const resources = await loadTiledTilesetResources(ref, mapSource, context);
-    return new TiledTileset(ref, ref.firstgid, resources);
-}
+* Resolves one `tilesets[]` entry of a `.tmj` file to a {@link TiledTileset}:
+* fetches and validates the external `.tsj` if `ref.source` is set, or uses
+* the embedded tileset data directly, then resolves and loads its image(s).
+*/
+const loadTiledTileset = async (ref, mapSource, context) => {
+	if ("source" in ref) {
+		const tsjUrl = resolveTiledUrl(ref.source, mapSource);
+		const raw = await context.dependencies.load(Asset.type("json", tsjUrl));
+		const data = validateTiledTilesetFileData(raw, tsjUrl);
+		const resources = await loadTiledTilesetResources(data, tsjUrl, context, tsjUrl);
+		return new TiledTileset(data, ref.firstgid, resources);
+	}
+	const resources = await loadTiledTilesetResources(ref, mapSource, context);
+	return new TiledTileset(ref, ref.firstgid, resources);
+};
 /**
- * Recursively walks the layer tree and loads the image for every
- * `imagelayer` encountered. Returns a `Map` keyed by layer `id` so that
- * {@link TiledMap.toTileMap} can attach the pre-loaded {@link Texture} to each
- * runtime image layer without performing additional I/O.
- */
-async function loadImageLayerTextures(layers, mapSource, context) {
-    const result = new Map();
-    for (const layer of layers) {
-        if (layer.type === 'imagelayer' && layer.image) {
-            const imageUrl = resolveTiledUrl(layer.image, mapSource);
-            const texture = await context.loader.load(Texture, imageUrl);
-            result.set(layer.id, texture);
-        }
-        else if (layer.type === 'group') {
-            const nested = await loadImageLayerTextures(layer.layers, mapSource, context);
-            for (const [id, tex] of nested) {
-                result.set(id, tex);
-            }
-        }
-    }
-    return result;
-}
+* Recursively walks the layer tree and loads the image for every
+* `imagelayer` encountered. Returns a `Map` keyed by layer `id` so that
+* {@link TiledMap.toTileMap} can attach the pre-loaded {@link Texture} to each
+* runtime image layer without performing additional I/O.
+*/
+const loadImageLayerTextures = async (layers, mapSource, context) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const layer of layers) if (layer.type === "imagelayer" && layer.image) {
+		const imageUrl = resolveTiledUrl(layer.image, mapSource);
+		const texture = await context.dependencies.load(Asset.type("texture", imageUrl));
+		result.set(layer.id, texture);
+	} else if (layer.type === "group") {
+		const nested = await loadImageLayerTextures(layer.layers, mapSource, context);
+		for (const [id, tex] of nested) result.set(id, tex);
+	}
+	return result;
+};
 /**
- * Loads and resolves a Tiled map: fetches and validates the `.tmj`, resolves
- * each tileset (external `.tsj` or embedded) and its image(s), and returns
- * the assembled, GID-validated {@link TiledMap}.
- * @internal
- */
-async function loadTiledMap(source, context) {
-    const raw = await context.fetchJson(source);
-    // Decode any base64/gzip/zlib tile-layer data into plain GID arrays before
-    // validation, so the rest of the pipeline stays CSV-shaped and synchronous.
-    await decodeTiledLayerData(raw, source);
-    const data = validateTiledMapData(raw, source);
-    const [tilesets, imageTextures] = await Promise.all([
-        Promise.all(data.tilesets.map(ref => loadTiledTileset(ref, source, context))),
-        loadImageLayerTextures(data.layers, source, context),
-    ]);
-    return new TiledMap(source, data, tilesets, imageTextures);
-}
+* Assembles a validated Tiled document into a {@link TiledMap}: resolves every
+* tileset (external `.tsj` or embedded) and its images, loads every image
+* layer's texture, and validates the GIDs against the assembled tilesets.
+* @internal
+*/
+const loadTiledMap = async (data, context) => {
+	const source = context.source;
+	const [tilesets, imageTextures] = await Promise.all([Promise.all(data.tilesets.map((ref) => loadTiledTileset(ref, source, context))), loadImageLayerTextures(data.layers, source, context)]);
+	return new TiledMap(source, data, tilesets, imageTextures);
+};
 
+//#endregion
 export { loadTiledMap };
-//# sourceMappingURL=loadTiledMap.js.map
+//# sourceMappingURL=loadTiledMap.js.map

package/dist/esm/loadTiledMap.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadTiledMap.js","sources":["../../../src/loadTiledMap.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"loadTiledMap.js","names":[],"sources":["../../src/loadTiledMap.ts"],"sourcesContent":["import type { AssetFactoryContext, Texture } from '@codexo/exojs';\nimport { Asset } from '@codexo/exojs';\n\nimport type { TiledLayerData, TiledMapData, TiledTilesetData, TiledTilesetRefData } from './data';\nimport { TiledMap } from './TiledMap';\nimport type { TiledLoadOptions } from './tiledOptions';\nimport { TiledTileset, type TiledTilesetResources } from './TiledTileset';\nimport { resolveTiledUrl } from './url';\nimport { validateTiledTilesetFileData } from './validate';\n\n/** What every step below needs from the load it belongs to. */\ntype TiledContext = AssetFactoryContext<TiledLoadOptions>;\n\n/**\n * Resolves and loads the image(s) referenced by a tileset: the atlas\n * `image` (if present) and any collection-of-images per-tile `image`\n * entries, relative to `baseUrl` (the resolved location of the file the\n * tileset data came from - the `.tmj` for an embedded tileset, the `.tsj`\n * for an external one).\n *\n * Textures are claimed by this map's own dependency scope, which deduplicates\n * concurrent and repeated loads of the same normalized URL and releases them\n * with the map.\n */\nconst loadTiledTilesetResources = async (data: TiledTilesetData, baseUrl: string, context: TiledContext, source?: string): Promise<TiledTilesetResources> => {\n  let imageUrl: string | undefined;\n  let texture: Texture | undefined;\n\n  if (data.image !== undefined) {\n    imageUrl = resolveTiledUrl(data.image, baseUrl);\n    texture = await context.dependencies.load(Asset.type('texture', imageUrl));\n  }\n\n  let tileTextures: Map<number, Texture> | undefined;\n\n  if (data.tiles !== undefined) {\n    for (const tile of data.tiles) {\n      if (tile.image === undefined) {\n        continue;\n      }\n\n      const tileImageUrl = resolveTiledUrl(tile.image, baseUrl);\n      const tileTexture: Texture = await context.dependencies.load(Asset.type('texture', tileImageUrl));\n\n      tileTextures ??= new Map();\n      tileTextures.set(tile.id, tileTexture);\n    }\n  }\n\n  return { source, imageUrl, texture, tileTextures };\n};\n\n/**\n * Resolves one `tilesets[]` entry of a `.tmj` file to a {@link TiledTileset}:\n * fetches and validates the external `.tsj` if `ref.source` is set, or uses\n * the embedded tileset data directly, then resolves and loads its image(s).\n */\nconst loadTiledTileset = async (ref: TiledTilesetRefData, mapSource: string, context: TiledContext): Promise<TiledTileset> => {\n  if ('source' in ref) {\n    const tsjUrl = resolveTiledUrl(ref.source, mapSource);\n    // An external tileset is an ordinary JSON asset: acquiring it through the\n    // dependency scope gives it its own identity and cache record, and shares\n    // one download between every map that references it.\n    const raw = await context.dependencies.load(Asset.type('json', tsjUrl));\n    const data = validateTiledTilesetFileData(raw, tsjUrl);\n    const resources = await loadTiledTilesetResources(data, tsjUrl, context, tsjUrl);\n\n    return new TiledTileset(data, ref.firstgid, resources);\n  }\n\n  const resources = await loadTiledTilesetResources(ref, mapSource, context);\n\n  return new TiledTileset(ref, ref.firstgid, resources);\n};\n\n/**\n * Recursively walks the layer tree and loads the image for every\n * `imagelayer` encountered. Returns a `Map` keyed by layer `id` so that\n * {@link TiledMap.toTileMap} can attach the pre-loaded {@link Texture} to each\n * runtime image layer without performing additional I/O.\n */\nconst loadImageLayerTextures = async (layers: readonly TiledLayerData[], mapSource: string, context: TiledContext): Promise<Map<number, Texture>> => {\n  const result = new Map<number, Texture>();\n\n  for (const layer of layers) {\n    if (layer.type === 'imagelayer' && layer.image) {\n      const imageUrl = resolveTiledUrl(layer.image, mapSource);\n      const texture: Texture = await context.dependencies.load(Asset.type('texture', imageUrl));\n      result.set(layer.id, texture);\n    } else if (layer.type === 'group') {\n      const nested = await loadImageLayerTextures(layer.layers, mapSource, context);\n      for (const [id, tex] of nested) {\n        result.set(id, tex);\n      }\n    }\n  }\n\n  return result;\n};\n\n/**\n * Assembles a validated Tiled document into a {@link TiledMap}: resolves every\n * tileset (external `.tsj` or embedded) and its images, loads every image\n * layer's texture, and validates the GIDs against the assembled tilesets.\n * @internal\n */\nexport const loadTiledMap = async (data: TiledMapData, context: TiledContext): Promise<TiledMap> => {\n  const source = context.source;\n  const [tilesets, imageTextures] = await Promise.all([\n    Promise.all(data.tilesets.map(ref => loadTiledTileset(ref, source, context))),\n    loadImageLayerTextures(data.layers, source, context),\n  ]);\n\n  return new TiledMap(source, data, tilesets, imageTextures);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,MAAM,4BAA4B,OAAO,MAAwB,SAAiB,SAAuB,WAAoD;CAC3J,IAAI;CACJ,IAAI;CAEJ,IAAI,KAAK,UAAU,QAAW;EAC5B,WAAW,gBAAgB,KAAK,OAAO,OAAO;EAC9C,UAAU,MAAM,QAAQ,aAAa,KAAK,MAAM,KAAK,WAAW,QAAQ,CAAC;CAC3E;CAEA,IAAI;CAEJ,IAAI,KAAK,UAAU,QACjB,KAAK,MAAM,QAAQ,KAAK,OAAO;EAC7B,IAAI,KAAK,UAAU,QACjB;EAGF,MAAM,eAAe,gBAAgB,KAAK,OAAO,OAAO;EACxD,MAAM,cAAuB,MAAM,QAAQ,aAAa,KAAK,MAAM,KAAK,WAAW,YAAY,CAAC;EAEhG,iCAAiB,IAAI,IAAI;EACzB,aAAa,IAAI,KAAK,IAAI,WAAW;CACvC;CAGF,OAAO;EAAE;EAAQ;EAAU;EAAS;CAAa;AACnD;;;;;;AAOA,MAAM,mBAAmB,OAAO,KAA0B,WAAmB,YAAiD;CAC5H,IAAI,YAAY,KAAK;EACnB,MAAM,SAAS,gBAAgB,IAAI,QAAQ,SAAS;EAIpD,MAAM,MAAM,MAAM,QAAQ,aAAa,KAAK,MAAM,KAAK,QAAQ,MAAM,CAAC;EACtE,MAAM,OAAO,6BAA6B,KAAK,MAAM;EACrD,MAAM,YAAY,MAAM,0BAA0B,MAAM,QAAQ,SAAS,MAAM;EAE/E,OAAO,IAAI,aAAa,MAAM,IAAI,UAAU,SAAS;CACvD;CAEA,MAAM,YAAY,MAAM,0BAA0B,KAAK,WAAW,OAAO;CAEzE,OAAO,IAAI,aAAa,KAAK,IAAI,UAAU,SAAS;AACtD;;;;;;;AAQA,MAAM,yBAAyB,OAAO,QAAmC,WAAmB,YAAyD;CACnJ,MAAM,yBAAS,IAAI,IAAqB;CAExC,KAAK,MAAM,SAAS,QAClB,IAAI,MAAM,SAAS,gBAAgB,MAAM,OAAO;EAC9C,MAAM,WAAW,gBAAgB,MAAM,OAAO,SAAS;EACvD,MAAM,UAAmB,MAAM,QAAQ,aAAa,KAAK,MAAM,KAAK,WAAW,QAAQ,CAAC;EACxF,OAAO,IAAI,MAAM,IAAI,OAAO;CAC9B,OAAO,IAAI,MAAM,SAAS,SAAS;EACjC,MAAM,SAAS,MAAM,uBAAuB,MAAM,QAAQ,WAAW,OAAO;EAC5E,KAAK,MAAM,CAAC,IAAI,QAAQ,QACtB,OAAO,IAAI,IAAI,GAAG;CAEtB;CAGF,OAAO;AACT;;;;;;;AAQA,MAAa,eAAe,OAAO,MAAoB,YAA6C;CAClG,MAAM,SAAS,QAAQ;CACvB,MAAM,CAAC,UAAU,iBAAiB,MAAM,QAAQ,IAAI,CAClD,QAAQ,IAAI,KAAK,SAAS,KAAI,QAAO,iBAAiB,KAAK,QAAQ,OAAO,CAAC,CAAC,GAC5E,uBAAuB,KAAK,QAAQ,QAAQ,OAAO,CACrD,CAAC;CAED,OAAO,IAAI,SAAS,QAAQ,MAAM,UAAU,aAAa;AAC3D"}

package/dist/esm/objectAlignment.d.ts

@@ -0,0 +1,28 @@
+import type { TiledObjectAlignment, TiledOrientation } from './data';
+/** A {@link TiledObjectAlignment} with Tiled's orientation-dependent default already applied. */
+export type TiledResolvedObjectAlignment = Exclude<TiledObjectAlignment, 'unspecified'>;
+/** Every value Tiled accepts for a tileset's `objectalignment`. */
+export declare const TILED_OBJECT_ALIGNMENTS: readonly TiledObjectAlignment[];
+/**
+ * Resolve a tileset's `objectalignment` into a concrete alignment for tile
+ * objects on a map of the given `orientation`.
+ *
+ * Tiled's default (`'unspecified'`, and an absent field) is orientation
+ * dependent: `'bottom'` on an isometric map and `'bottomleft'` on every other
+ * orientation, including staggered and hexagonal.
+ * @advanced
+ */
+export declare const resolveTiledObjectAlignment: (alignment: TiledObjectAlignment | undefined, orientation: TiledOrientation) => TiledResolvedObjectAlignment;
+/**
+ * Offset of a tile object's stored `x`/`y` anchor from the top-left corner of
+ * its `width` × `height` bounding box, for an already-resolved `alignment`.
+ *
+ * Subtract this from the stored position to obtain the corner:
+ * `cornerX = object.x - offset.x`.
+ * @advanced
+ */
+export declare const getTiledObjectAnchorOffset: (alignment: TiledResolvedObjectAlignment, width: number, height: number) => {
+    readonly x: number;
+    readonly y: number;
+};
+//# sourceMappingURL=objectAlignment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objectAlignment.d.ts","sourceRoot":"","sources":["../../src/objectAlignment.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAErE,iGAAiG;AACjG,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC;AAExF,mEAAmE;AACnE,eAAO,MAAM,uBAAuB,EAAE,SAAS,oBAAoB,EAWlE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,oBAAoB,GAAG,SAAS,EAAE,aAAa,gBAAgB,KAAG,4BAMxH,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GACrC,WAAW,4BAA4B,EACvC,OAAO,MAAM,EACb,QAAQ,MAAM,KACb;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAqB1C,CAAC"}

package/dist/esm/objectAlignment.js

@@ -0,0 +1,79 @@
+//#region src/objectAlignment.ts
+/** Every value Tiled accepts for a tileset's `objectalignment`. */
+const TILED_OBJECT_ALIGNMENTS = [
+	"unspecified",
+	"topleft",
+	"top",
+	"topright",
+	"left",
+	"center",
+	"right",
+	"bottomleft",
+	"bottom",
+	"bottomright"
+];
+/**
+* Resolve a tileset's `objectalignment` into a concrete alignment for tile
+* objects on a map of the given `orientation`.
+*
+* Tiled's default (`'unspecified'`, and an absent field) is orientation
+* dependent: `'bottom'` on an isometric map and `'bottomleft'` on every other
+* orientation, including staggered and hexagonal.
+* @advanced
+*/
+const resolveTiledObjectAlignment = (alignment, orientation) => {
+	if (alignment !== void 0 && alignment !== "unspecified") return alignment;
+	return orientation === "isometric" ? "bottom" : "bottomleft";
+};
+/**
+* Offset of a tile object's stored `x`/`y` anchor from the top-left corner of
+* its `width` × `height` bounding box, for an already-resolved `alignment`.
+*
+* Subtract this from the stored position to obtain the corner:
+* `cornerX = object.x - offset.x`.
+* @advanced
+*/
+const getTiledObjectAnchorOffset = (alignment, width, height) => {
+	switch (alignment) {
+		case "topleft": return {
+			x: 0,
+			y: 0
+		};
+		case "top": return {
+			x: width / 2,
+			y: 0
+		};
+		case "topright": return {
+			x: width,
+			y: 0
+		};
+		case "left": return {
+			x: 0,
+			y: height / 2
+		};
+		case "center": return {
+			x: width / 2,
+			y: height / 2
+		};
+		case "right": return {
+			x: width,
+			y: height / 2
+		};
+		case "bottomleft": return {
+			x: 0,
+			y: height
+		};
+		case "bottom": return {
+			x: width / 2,
+			y: height
+		};
+		case "bottomright": return {
+			x: width,
+			y: height
+		};
+	}
+};
+
+//#endregion
+export { TILED_OBJECT_ALIGNMENTS, getTiledObjectAnchorOffset, resolveTiledObjectAlignment };
+//# sourceMappingURL=objectAlignment.js.map

package/dist/esm/objectAlignment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectAlignment.js","names":[],"sources":["../../src/objectAlignment.ts"],"sourcesContent":["// Tile-object anchoring rules, mirroring Tiled's own `MapObject::alignment()`\n// and `alignmentOffset()` from libtiled.\n\nimport type { TiledObjectAlignment, TiledOrientation } from './data';\n\n/** A {@link TiledObjectAlignment} with Tiled's orientation-dependent default already applied. */\nexport type TiledResolvedObjectAlignment = Exclude<TiledObjectAlignment, 'unspecified'>;\n\n/** Every value Tiled accepts for a tileset's `objectalignment`. */\nexport const TILED_OBJECT_ALIGNMENTS: readonly TiledObjectAlignment[] = [\n  'unspecified',\n  'topleft',\n  'top',\n  'topright',\n  'left',\n  'center',\n  'right',\n  'bottomleft',\n  'bottom',\n  'bottomright',\n];\n\n/**\n * Resolve a tileset's `objectalignment` into a concrete alignment for tile\n * objects on a map of the given `orientation`.\n *\n * Tiled's default (`'unspecified'`, and an absent field) is orientation\n * dependent: `'bottom'` on an isometric map and `'bottomleft'` on every other\n * orientation, including staggered and hexagonal.\n * @advanced\n */\nexport const resolveTiledObjectAlignment = (alignment: TiledObjectAlignment | undefined, orientation: TiledOrientation): TiledResolvedObjectAlignment => {\n  if (alignment !== undefined && alignment !== 'unspecified') {\n    return alignment;\n  }\n\n  return orientation === 'isometric' ? 'bottom' : 'bottomleft';\n};\n\n/**\n * Offset of a tile object's stored `x`/`y` anchor from the top-left corner of\n * its `width` × `height` bounding box, for an already-resolved `alignment`.\n *\n * Subtract this from the stored position to obtain the corner:\n * `cornerX = object.x - offset.x`.\n * @advanced\n */\nexport const getTiledObjectAnchorOffset = (\n  alignment: TiledResolvedObjectAlignment,\n  width: number,\n  height: number,\n): { readonly x: number; readonly y: number } => {\n  switch (alignment) {\n    case 'topleft':\n      return { x: 0, y: 0 };\n    case 'top':\n      return { x: width / 2, y: 0 };\n    case 'topright':\n      return { x: width, y: 0 };\n    case 'left':\n      return { x: 0, y: height / 2 };\n    case 'center':\n      return { x: width / 2, y: height / 2 };\n    case 'right':\n      return { x: width, y: height / 2 };\n    case 'bottomleft':\n      return { x: 0, y: height };\n    case 'bottom':\n      return { x: width / 2, y: height };\n    case 'bottomright':\n      return { x: width, y: height };\n  }\n};\n"],"mappings":";;AASA,MAAa,0BAA2D;CACtE;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;AAWA,MAAa,+BAA+B,WAA6C,gBAAgE;CACvJ,IAAI,cAAc,UAAa,cAAc,eAC3C,OAAO;CAGT,OAAO,gBAAgB,cAAc,WAAW;AAClD;;;;;;;;;AAUA,MAAa,8BACX,WACA,OACA,WAC+C;CAC/C,QAAQ,WAAR;EACE,KAAK,WACH,OAAO;GAAE,GAAG;GAAG,GAAG;EAAE;EACtB,KAAK,OACH,OAAO;GAAE,GAAG,QAAQ;GAAG,GAAG;EAAE;EAC9B,KAAK,YACH,OAAO;GAAE,GAAG;GAAO,GAAG;EAAE;EAC1B,KAAK,QACH,OAAO;GAAE,GAAG;GAAG,GAAG,SAAS;EAAE;EAC/B,KAAK,UACH,OAAO;GAAE,GAAG,QAAQ;GAAG,GAAG,SAAS;EAAE;EACvC,KAAK,SACH,OAAO;GAAE,GAAG;GAAO,GAAG,SAAS;EAAE;EACnC,KAAK,cACH,OAAO;GAAE,GAAG;GAAG,GAAG;EAAO;EAC3B,KAAK,UACH,OAAO;GAAE,GAAG,QAAQ;GAAG,GAAG;EAAO;EACnC,KAAK,eACH,OAAO;GAAE,GAAG;GAAO,GAAG;EAAO;CACjC;AACF"}

package/dist/esm/public.d.ts

@@ -1,31 +1,29 @@
 export { type TiledLoadOptions } from './tiledOptions';
-export type { AssetBinding, AssetHandler, AssetLoadRequest, Extension } from '@codexo/exojs/extensions';
+export type { AssetEntry, Extension } from '@codexo/exojs/extensions';
 export type { TiledBuildInfo } from './tiledBuildInfo';
 export { tiledBuildInfo } from './tiledBuildInfo';
 export { tiledExtension } from './tiledExtension';
-export { tiledMapBinding } from './tiledMapBinding';
-export { tiledRuntimeMapBinding } from './tiledRuntimeMapBinding';
-export type { ChunkCoord, EllipseObject, ObjectLayerOptions, ObjectPoint, ObjectQuery, PackedTile, PointObject, PolygonObject, PolylineObject, ReadonlyTileChunk, RectangleObject, ResolvedTile, TileDefinition, TileLayerNodeOptions, TileLayerOptions, TileLayerSelector, TileMapBandDefinition, TileMapNodeOptions, TileMapObject, TileMapObjectKind, TileMapOptions, TileMapViewOptions, TileObject, TileProperties, TilePropertyValue, TileSetOptions, TileTransform, WangSetOptions, } from '@codexo/exojs-tilemap';
-export { ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileLayerNode, TileMap, TileMapBand, tilemapExtension, TileMapNode, TileMapView, TileSet, WangSet, } from '@codexo/exojs-tilemap';
-export type { TiledAnimationFrameData, TiledChunkData, TiledClassPropertyValueData, TiledEmbeddedTilesetRefData, TiledExternalTilesetRefData, TiledGroupLayerData, TiledImageLayerData, TiledLayerData, TiledLayerDataBase, TiledMapData, TiledObjectData, TiledObjectLayerData, TiledOrientation, TiledPointData, TiledPropertyData, TiledPropertyType, TiledRenderOrder, TiledTextData, TiledTileData, TiledTileLayerData, TiledTilesetData, TiledTilesetRefData, TiledWangColorData, TiledWangSetData, TiledWangTileData, } from './data';
+export { TiledSourceAssetType, tiledSourceType } from './tiledSourceType';
+export { TileMapAssetType, tileMapType } from './tileMapType';
+export type { ChunkCoord, EllipseObject, MapBounds, MapLevel, MapLevelCancelOptions, MapLevelLoadContext, MapLevelLoadOptions, MapLevelNeighbour, MapLevelProvider, MapObjectDescriptor, MapObjectFactories, MapObjectFactory, MapObjectSpawnerOptions, MapSpawnErrorReason, MapSpawnOptions, MapWorldOptions, MapWorldRuntimeOptions, ObjectLayerOptions, ObjectPoint, ObjectQuery, PackedTile, PointObject, PolygonObject, PolylineObject, ReadonlyTileChunk, RectangleObject, ResolvedTile, TileDefinition, TileLayerNodeOptions, TileLayerOptions, TileLayerSelector, TileMapBandDefinition, TileMapNodeOptions, TileMapObject, TileMapObjectKind, TileMapOptions, TileMapViewOptions, TileObject, TileProperties, TilePropertyValue, TileSetOptions, TileTransform, UnknownMapObjectPolicy, WangSetOptions, } from '@codexo/exojs-tilemap';
+export { MapLevelRuntime, MapLevelSide, mapObjectDescriptor, mapObjectDescriptors, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileLayerNode, TileMap, TileMapBand, tilemapExtension, TileMapNode, TileMapView, TileSet, WangSet, } from '@codexo/exojs-tilemap';
+export type { TiledAnimationFrameData, TiledChunkData, TiledClassPropertyValueData, TiledEmbeddedTilesetRefData, TiledExternalTilesetRefData, TiledGroupLayerData, TiledImageLayerData, TiledLayerData, TiledLayerDataBase, TiledMapData, TiledObjectAlignment, TiledObjectData, TiledObjectLayerData, TiledOrientation, TiledPointData, TiledPropertyData, TiledPropertyType, TiledRenderOrder, TiledTextData, TiledTileData, TiledTileLayerData, TiledTilesetData, TiledTilesetRefData, TiledWangColorData, TiledWangSetData, TiledWangTileData, } from './data';
 export type { TiledLayerType } from './TiledLayer';
-export { createTiledLayer, TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer, } from './TiledLayer';
+export { createTiledLayer, TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer } from './TiledLayer';
 export { TiledMap } from './TiledMap';
 export { TiledObject } from './TiledObject';
 export type { TiledTilesetResources } from './TiledTileset';
 export { TiledTileset } from './TiledTileset';
+export type { TiledResolvedObjectAlignment } from './objectAlignment';
+export { getTiledObjectAnchorOffset, resolveTiledObjectAlignment, TILED_OBJECT_ALIGNMENTS } from './objectAlignment';
 export { tiledWangSetToWangSet } from './wangSets';
 export { TiledFormatError } from './validate';
 import type { TileMap } from '@codexo/exojs-tilemap';
 import type { TiledMap } from './TiledMap';
 declare module '@codexo/exojs' {
-    interface ExtensionTypeMap {
-        /** `.tmj` path-only loads resolve to the generic runtime {@link TileMap}. */
-        tmj: TileMap;
-    }
-    interface ExtensionTokenTypeMap {
-        /** The advanced parsed-source token is also accepted for `.tmj`: `load(TiledMap, 'world.tmj')`. */
-        tmj: TiledMap;
+    interface ExtensionKindMap {
+        /** `.tmj` bare-path loads resolve to the generic runtime `tileMap` type ({@link TileMap}). */
+        tmj: 'tileMap';
     }
     interface AssetDefinitions {
         tileMap: {
@@ -34,13 +32,17 @@ declare module '@codexo/exojs' {
                 source: string;
                 format?: 'tiled';
             };
+            isValue: true;
         };
-        tiledMap: {
+        tiledSource: {
             resource: TiledMap;
             config: {
                 source: string;
                 format?: 'tiled';
             };
+            /** See `tileMap` - `tiledSourceType` keeps the default leaf too. */
+            isValue: true;
         };
     }
 }
+//# sourceMappingURL=public.d.ts.map

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

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

package/dist/esm/public.js

@@ -0,0 +1,14 @@
+import { tiledBuildInfo } from "./tiledBuildInfo.js";
+import { TILED_OBJECT_ALIGNMENTS, getTiledObjectAnchorOffset, resolveTiledObjectAlignment } from "./objectAlignment.js";
+import { TiledFormatError } from "./validate.js";
+import { TiledObject } from "./TiledObject.js";
+import { TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer, createTiledLayer } from "./TiledLayer.js";
+import { TiledMap } from "./TiledMap.js";
+import { TiledTileset } from "./TiledTileset.js";
+import { TiledSourceAssetType, tiledSourceType } from "./tiledSourceType.js";
+import { TileMapAssetType, tileMapType } from "./tileMapType.js";
+import { tiledExtension } from "./tiledExtension.js";
+import { tiledWangSetToWangSet } from "./wangSets.js";
+import { MapLevelRuntime, MapLevelSide, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectLayer as ObjectLayer$1, TILE_TRANSFORM_IDENTITY, TileLayer as TileLayer$1, TileLayerNode, TileMap as TileMap$1, TileMapBand, TileMapNode, TileMapView, TileSet as TileSet$1, WangSet as WangSet$1, mapObjectDescriptor, mapObjectDescriptors, tilemapExtension as tilemapExtension$1 } from "@codexo/exojs-tilemap";
+
+export { MapLevelRuntime, MapLevelSide, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectLayer$1 as ObjectLayer, TILED_OBJECT_ALIGNMENTS, TILE_TRANSFORM_IDENTITY, TileLayer$1 as TileLayer, TileLayerNode, TileMap$1 as TileMap, TileMapAssetType, TileMapBand, TileMapNode, TileMapView, TileSet$1 as TileSet, TiledFormatError, TiledGroupLayer, TiledImageLayer, TiledLayer, TiledMap, TiledObject, TiledObjectLayer, TiledSourceAssetType, TiledTileLayer, TiledTileset, WangSet$1 as WangSet, createTiledLayer, getTiledObjectAnchorOffset, mapObjectDescriptor, mapObjectDescriptors, resolveTiledObjectAlignment, tileMapType, tiledBuildInfo, tiledExtension, tiledSourceType, tiledWangSetToWangSet, tilemapExtension$1 as tilemapExtension };

package/dist/esm/tileMapType.d.ts

@@ -0,0 +1,31 @@
+import type { AssetFactory } from '@codexo/exojs';
+import { type AssetRequest, AssetType } from '@codexo/exojs';
+import { TileMap } from '@codexo/exojs-tilemap';
+import { type TiledLoadOptions } from './tiledOptions';
+/**
+ * The format-independent runtime {@link TileMap} produced from a `.tmj` file -
+ * the common case.
+ *
+ * The `.tmj` itself is acquired once as a `tiledSource` dependency, so loading
+ * both the runtime map and the source model for one URL shares a single
+ * download and a single parsed document.
+ */
+export declare class TileMapAssetType extends AssetType<void, TileMap, TiledLoadOptions> {
+    readonly id = "tileMap";
+    readonly extensions: string[];
+    readonly _token: typeof TileMap;
+    resourceIdentity({ options }: AssetRequest<TiledLoadOptions>): string;
+    /**
+     * The runtime map has no source data of its own: it is built from the
+     * `tiledSource` asset its factory loads. Acquiring the document here as well
+     * would download, parse and validate it a second time under a second
+     * identity.
+     */
+    unacquiredSource(): {
+        source: void;
+    };
+    createFactory(): AssetFactory<void, TileMap, TiledLoadOptions>;
+}
+/** The runtime tilemap asset type for Tiled maps. Install it through `tiledExtension`. */
+export declare const tileMapType: TileMapAssetType;
+//# sourceMappingURL=tileMapType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tileMapType.d.ts","sourceRoot":"","sources":["../../src/tileMapType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,KAAK,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAG5E;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC;IAC9E,SAAgB,EAAE,aAAa;IAC/B,SAAyB,UAAU,WAAW;IAC9C,SAAyB,MAAM,iBAAW;IAE1B,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE,YAAY,CAAC,gBAAgB,CAAC,GAAG,MAAM;IAIrF;;;;;OAKG;IACa,gBAAgB,IAAI;QAAE,MAAM,EAAE,IAAI,CAAA;KAAE;IAI7C,aAAa,IAAI,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC;CAStE;AAED,0FAA0F;AAC1F,eAAO,MAAM,WAAW,kBAAyB,CAAC"}

package/dist/esm/tileMapType.js

@@ -0,0 +1,42 @@
+import { resolveTiledOptions } from "./tiledOptions.js";
+import { tiledSourceType } from "./tiledSourceType.js";
+import { TileMap } from "@codexo/exojs-tilemap";
+import { AssetType } from "@codexo/exojs";
+
+//#region src/tileMapType.ts
+/**
+* The format-independent runtime {@link TileMap} produced from a `.tmj` file -
+* the common case.
+*
+* The `.tmj` itself is acquired once as a `tiledSource` dependency, so loading
+* both the runtime map and the source model for one URL shares a single
+* download and a single parsed document.
+*/
+var TileMapAssetType = class extends AssetType {
+	id = "tileMap";
+	extensions = ["tmj"];
+	_token = TileMap;
+	resourceIdentity({ options }) {
+		return resolveTiledOptions(options).format;
+	}
+	/**
+	* The runtime map has no source data of its own: it is built from the
+	* `tiledSource` asset its factory loads. Acquiring the document here as well
+	* would download, parse and validate it a second time under a second
+	* identity.
+	*/
+	unacquiredSource() {
+		return { source: void 0 };
+	}
+	createFactory() {
+		return { async create(_source, context) {
+			return (await context.dependencies.load(tiledSourceType.asset(context.source, context.options))).toTileMap();
+		} };
+	}
+};
+/** The runtime tilemap asset type for Tiled maps. Install it through `tiledExtension`. */
+const tileMapType = new TileMapAssetType();
+
+//#endregion
+export { TileMapAssetType, tileMapType };
+//# sourceMappingURL=tileMapType.js.map

package/dist/esm/tileMapType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileMapType.js","names":[],"sources":["../../src/tileMapType.ts"],"sourcesContent":["import type { AssetFactory } from '@codexo/exojs';\nimport { type AssetRequest, AssetType } from '@codexo/exojs';\nimport { TileMap } from '@codexo/exojs-tilemap';\n\nimport { resolveTiledOptions, type TiledLoadOptions } from './tiledOptions';\nimport { tiledSourceType } from './tiledSourceType';\n\n/**\n * The format-independent runtime {@link TileMap} produced from a `.tmj` file -\n * the common case.\n *\n * The `.tmj` itself is acquired once as a `tiledSource` dependency, so loading\n * both the runtime map and the source model for one URL shares a single\n * download and a single parsed document.\n */\nexport class TileMapAssetType extends AssetType<void, TileMap, TiledLoadOptions> {\n  public readonly id = 'tileMap';\n  public override readonly extensions = ['tmj'];\n  public override readonly _token = TileMap;\n\n  public override resourceIdentity({ options }: AssetRequest<TiledLoadOptions>): string {\n    return resolveTiledOptions(options).format;\n  }\n\n  /**\n   * The runtime map has no source data of its own: it is built from the\n   * `tiledSource` asset its factory loads. Acquiring the document here as well\n   * would download, parse and validate it a second time under a second\n   * identity.\n   */\n  public override unacquiredSource(): { source: void } {\n    return { source: undefined };\n  }\n\n  public createFactory(): AssetFactory<void, TileMap, TiledLoadOptions> {\n    return {\n      async create(_source, context) {\n        const tiledMap = await context.dependencies.load(tiledSourceType.asset(context.source, context.options));\n\n        return tiledMap.toTileMap();\n      },\n    };\n  }\n}\n\n/** The runtime tilemap asset type for Tiled maps. Install it through `tiledExtension`. */\nexport const tileMapType = new TileMapAssetType();\n"],"mappings":";;;;;;;;;;;;;;AAeA,IAAa,mBAAb,cAAsC,UAA2C;CAC/E,AAAgB,KAAK;CACrB,AAAyB,aAAa,CAAC,KAAK;CAC5C,AAAyB,SAAS;CAElC,AAAgB,iBAAiB,EAAE,WAAmD;EACpF,OAAO,oBAAoB,OAAO,CAAC,CAAC;CACtC;;;;;;;CAQA,AAAgB,mBAAqC;EACnD,OAAO,EAAE,QAAQ,OAAU;CAC7B;CAEA,AAAO,gBAA+D;EACpE,OAAO,EACL,MAAM,OAAO,SAAS,SAAS;GAG7B,QAAO,MAFgB,QAAQ,aAAa,KAAK,gBAAgB,MAAM,QAAQ,QAAQ,QAAQ,OAAO,CAAC,EAExF,CAAC,UAAU;EAC5B,EACF;CACF;AACF;;AAGA,MAAa,cAAc,IAAI,iBAAiB"}

package/dist/esm/tiledBuildInfo.d.ts

@@ -13,3 +13,4 @@ export interface TiledBuildInfo {
     readonly development: boolean;
 }
 export declare const tiledBuildInfo: TiledBuildInfo;
+//# sourceMappingURL=tiledBuildInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tiledBuildInfo.d.ts","sourceRoot":"","sources":["../../src/tiledBuildInfo.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED,eAAO,MAAM,cAAc,EAAE,cAI3B,CAAC"}

package/dist/esm/tiledBuildInfo.js

@@ -1,8 +1,10 @@
+//#region src/tiledBuildInfo.ts
 const tiledBuildInfo = Object.freeze({
-    version: "0.15.3",
-    revision: "3af06d7",
-    development: false,
+	version: "0.16.0",
+	revision: "3a59179",
+	development: false
 });
 
+//#endregion
 export { tiledBuildInfo };
-//# sourceMappingURL=tiledBuildInfo.js.map
+//# sourceMappingURL=tiledBuildInfo.js.map

package/dist/esm/tiledBuildInfo.js.map

@@ -1 +1 @@
-{"version":3,"file":"tiledBuildInfo.js","sources":["../../../src/tiledBuildInfo.ts"],"sourcesContent":[null],"names":[],"mappings":"AAeO,MAAM,cAAc,GAAmB,MAAM,CAAC,MAAM,CAAC;AAC1D,IAAA,OAAO,EAAE,QAAW;AACpB,IAAA,QAAQ,EAAE,SAAY;AACtB,IAAA,WAAW,EAAE,KAAO;AACrB,CAAA;;;;"}
+{"version":3,"file":"tiledBuildInfo.js","names":[],"sources":["../../src/tiledBuildInfo.ts"],"sourcesContent":["/**\n * Immutable compile-time build metadata for `@codexo/exojs-tiled`.\n *\n * `development` mirrors the `__DEV__` compile-time constant and is statically\n * replaced before tree shaking. `version` is the exact `package.json` version\n * of the Tiled package at build time. `revision` is the short\n * source-control revision (appended with `-dirty` when uncommitted changes are\n * present) or `\"unknown\"` when no revision information is available.\n */\nexport interface TiledBuildInfo {\n  readonly version: string;\n  readonly revision: string;\n  readonly development: boolean;\n}\n\nexport const tiledBuildInfo: TiledBuildInfo = Object.freeze({\n  version: __VERSION__,\n  revision: __REVISION__,\n  development: __DEV__,\n});\n"],"mappings":";AAeA,MAAa,iBAAiC,OAAO,OAAO;CAC1D;CACA;CACA;AACF,CAAC"}

package/dist/esm/tiledExtension.d.ts

@@ -2,16 +2,17 @@ import type { Extension } from '@codexo/exojs/extensions';
 /**
  * Default immutable Tiled extension descriptor.
  *
- * Registers two asset bindings:
- * - {@link tiledRuntimeMapBinding} — `loader.load(TileMap, 'world.tmj')` →
- *   returns a format-independent runtime {@link TileMap} (common case).
- * - {@link tiledMapBinding} — `loader.load(TiledMap, 'world.tmj')` →
+ * Installs two asset types:
+ * - {@link tileMapType} - `loader.load(tileMapType.asset('world.tmj'))` returns
+ *   a format-independent runtime {@link TileMap} (common case).
+ * - {@link tiledSourceType} - `loader.load(tiledSourceType.asset('world.tmj'))`
  *   returns the raw parsed {@link TiledMap} source model (advanced/diagnostic).
  *
  * Depends on {@link tilemapExtension} so that snapshot construction always
  * materialises the generic tilemap runtime before the Tiled adapter.
  *
- * Use with `ApplicationOptions.extensions` or call
- * `import '@codexo/exojs-tiled/register'` for global auto-registration.
+ * Pass it to the application that should have it via
+ * `ApplicationOptions.extensions`.
  */
 export declare const tiledExtension: Extension;
+//# sourceMappingURL=tiledExtension.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tiledExtension.d.ts","sourceRoot":"","sources":["../../src/tiledExtension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAM1D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,SAM3B,CAAC"}