@codexo/exojs-tiled 0.12.0 → 0.13.0

package/dist/esm/data.d.ts

@@ -0,0 +1,217 @@
+/** A 2D point as written by Tiled (used for tile offsets and object shapes). */
+export interface TiledPointData {
+    readonly x: number;
+    readonly y: number;
+}
+/** The `type` discriminant of a Tiled custom property. */
+export type TiledPropertyType = 'string' | 'int' | 'float' | 'bool' | 'color' | 'file' | 'object' | 'class';
+/**
+ * The value of a `class`-typed custom property: a nested map of member name
+ * to value, recursively allowing further `class` members.
+ */
+export interface TiledClassPropertyValueData {
+    readonly [name: string]: string | number | boolean | TiledClassPropertyValueData;
+}
+/**
+ * One custom property entry as written by Tiled (`properties` arrays on
+ * maps, tilesets, tiles, layers and objects).
+ *
+ * - `string` / `color` / `file` → `value` is a `string`
+ * - `int` / `float` / `object` → `value` is a `number` (an `object` value is
+ *   the referenced object's id)
+ * - `bool` → `value` is a `boolean`
+ * - `class` → `value` is a {@link TiledClassPropertyValueData}; `propertytype`
+ *   names the class
+ */
+export interface TiledPropertyData {
+    readonly name: string;
+    readonly type: TiledPropertyType;
+    readonly propertytype?: string;
+    readonly value: string | number | boolean | TiledClassPropertyValueData;
+}
+/** One frame of a tile's animation sequence. */
+export interface TiledAnimationFrameData {
+    /** Local tile id (within the owning tileset) shown during this frame. */
+    readonly tileid: number;
+    /** Frame duration in milliseconds. */
+    readonly duration: number;
+}
+/**
+ * A per-tile definition within a tileset's `tiles` array. Sparse — only
+ * tiles carrying metadata (properties, animation, a collision objectgroup,
+ * or a collection-of-images source) appear here.
+ */
+export interface TiledTileData {
+    /** Local tile id within the owning tileset. */
+    readonly id: number;
+    /** Tile class (`class`/`type` field depending on Tiled version). */
+    readonly type?: string;
+    readonly properties?: readonly TiledPropertyData[];
+    readonly animation?: readonly TiledAnimationFrameData[];
+    /** Per-tile collision shapes, structurally identical to an object layer. */
+    readonly objectgroup?: TiledObjectLayerData;
+    /** Collection-of-images tile source, relative to the tileset's location. */
+    readonly image?: string;
+    readonly imagewidth?: number;
+    readonly imageheight?: number;
+}
+/**
+ * A Tiled tileset, as the root of a standalone `.tsj` file or (minus
+ * `firstgid`) embedded inline in a map's `tilesets` array.
+ */
+export interface TiledTilesetData {
+    readonly name: string;
+    readonly class?: string;
+    readonly tilewidth: number;
+    readonly tileheight: number;
+    readonly tilecount: number;
+    readonly columns: number;
+    readonly spacing?: number;
+    readonly margin?: number;
+    /** Single-image ("atlas") tileset source, relative to the tileset's location. Absent for collection-of-images tilesets. */
+    readonly image?: string;
+    readonly imagewidth?: number;
+    readonly imageheight?: number;
+    readonly tileoffset?: TiledPointData;
+    readonly objectalignment?: string;
+    readonly tiles?: readonly TiledTileData[];
+    readonly properties?: readonly TiledPropertyData[];
+    readonly tiledversion?: string;
+    readonly version?: string | number;
+}
+/** A map's `tilesets[]` entry referencing an external `.tsj` file by relative path. */
+export interface TiledExternalTilesetRefData {
+    readonly firstgid: number;
+    readonly source: string;
+}
+/** A map's `tilesets[]` entry with the tileset embedded inline. */
+export type TiledEmbeddedTilesetRefData = TiledTilesetData & {
+    readonly firstgid: number;
+};
+/** One entry of {@link TiledMapData.tilesets} — either external (`source`) or embedded. */
+export type TiledTilesetRefData = TiledExternalTilesetRefData | TiledEmbeddedTilesetRefData;
+/** Text rendering options for a `text` object (object layers). */
+export interface TiledTextData {
+    readonly text: string;
+    readonly bold?: boolean;
+    readonly color?: string;
+    readonly fontfamily?: string;
+    readonly halign?: 'center' | 'right' | 'justify' | 'left';
+    readonly italic?: boolean;
+    readonly kerning?: boolean;
+    readonly pixelsize?: number;
+    readonly strikeout?: boolean;
+    readonly underline?: boolean;
+    readonly valign?: 'center' | 'bottom' | 'top';
+    readonly wrap?: boolean;
+}
+/**
+ * An object placed in an object layer (or a tile's collision `objectgroup`).
+ * The shape is determined by which of `point` / `ellipse` / `polygon` /
+ * `polyline` / `text` / `gid` is present; absent of all of these, the object
+ * is a plain rectangle.
+ */
+export interface TiledObjectData {
+    readonly id: number;
+    readonly name: string;
+    /** Object class (empty string if unset). */
+    readonly type: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly rotation: number;
+    readonly visible: boolean;
+    /** Tile object reference; may carry flip/rotation flag bits in the high bits. */
+    readonly gid?: number;
+    readonly point?: boolean;
+    readonly ellipse?: boolean;
+    readonly polygon?: readonly TiledPointData[];
+    readonly polyline?: readonly TiledPointData[];
+    readonly text?: TiledTextData;
+    /** Path to a `.tx` object template this object was instantiated from. */
+    readonly template?: string;
+    readonly properties?: readonly TiledPropertyData[];
+}
+/** Fields shared by every layer type. */
+export interface TiledLayerDataBase {
+    readonly id: number;
+    readonly name: string;
+    readonly class?: string;
+    readonly visible: boolean;
+    readonly opacity: number;
+    readonly x: number;
+    readonly y: number;
+    readonly offsetx?: number;
+    readonly offsety?: number;
+    readonly parallaxx?: number;
+    readonly parallaxy?: number;
+    readonly tintcolor?: string;
+    readonly properties?: readonly TiledPropertyData[];
+}
+/** A chunk of tile data within an infinite tile layer. */
+export interface TiledChunkData {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly data: readonly number[];
+}
+/**
+ * A finite-map tile layer has `data` (a flat, row-major array of GIDs of
+ * length `width * height`). An infinite-map tile layer has `chunks` instead.
+ */
+export interface TiledTileLayerData extends TiledLayerDataBase {
+    readonly type: 'tilelayer';
+    readonly width: number;
+    readonly height: number;
+    readonly data?: readonly number[];
+    readonly chunks?: readonly TiledChunkData[];
+}
+export interface TiledObjectLayerData extends TiledLayerDataBase {
+    readonly type: 'objectgroup';
+    readonly draworder?: 'topdown' | 'index';
+    readonly objects: readonly TiledObjectData[];
+}
+export interface TiledImageLayerData extends TiledLayerDataBase {
+    readonly type: 'imagelayer';
+    /** Image source, relative to the map's location. Empty string if unset. */
+    readonly image: string;
+    readonly repeatx?: boolean;
+    readonly repeaty?: boolean;
+}
+export interface TiledGroupLayerData extends TiledLayerDataBase {
+    readonly type: 'group';
+    readonly layers: readonly TiledLayerData[];
+}
+/** Discriminated union of all four Tiled layer types, keyed by `type`. */
+export type TiledLayerData = TiledTileLayerData | TiledObjectLayerData | TiledImageLayerData | TiledGroupLayerData;
+/** The orientation values Tiled may write for a map. */
+export type TiledOrientation = 'orthogonal' | 'isometric' | 'staggered' | 'hexagonal';
+/** The render-order values Tiled may write for an orthogonal map. */
+export type TiledRenderOrder = 'right-down' | 'right-up' | 'left-down' | 'left-up';
+/** The root of a `.tmj` map file. */
+export interface TiledMapData {
+    readonly type: 'map';
+    readonly version: string | number;
+    readonly tiledversion?: string;
+    readonly class?: string;
+    readonly orientation: TiledOrientation;
+    readonly renderorder?: TiledRenderOrder;
+    /** Map width in tiles. */
+    readonly width: number;
+    /** Map height in tiles. */
+    readonly height: number;
+    /** Tile grid cell width in pixels. */
+    readonly tilewidth: number;
+    /** Tile grid cell height in pixels. */
+    readonly tileheight: number;
+    readonly infinite: boolean;
+    readonly compressionlevel?: number;
+    readonly nextlayerid?: number;
+    readonly nextobjectid?: number;
+    readonly backgroundcolor?: string;
+    readonly layers: readonly TiledLayerData[];
+    readonly tilesets: readonly TiledTilesetRefData[];
+    readonly properties?: readonly TiledPropertyData[];
+}

package/dist/esm/gid.d.ts

@@ -0,0 +1,13 @@
+export declare const TILED_FLIPPED_HORIZONTALLY_FLAG = 2147483648;
+export declare const TILED_FLIPPED_VERTICALLY_FLAG = 1073741824;
+export declare const TILED_FLIPPED_DIAGONALLY_FLAG = 536870912;
+export declare const TILED_ROTATED_HEXAGONAL_120_FLAG = 268435456;
+/**
+ * Strips the flip/rotation flag bits from a raw Tiled GID, returning the
+ * plain tileset-relative global tile id (0 = empty cell).
+ *
+ * GIDs may exceed `2^31` (the horizontal-flip flag alone is `2^31`), so the
+ * value is first coerced to an unsigned 32-bit integer via `>>> 0`.
+ * @internal
+ */
+export declare function maskTiledGid(raw: number): number;

package/dist/esm/gid.js

@@ -0,0 +1,28 @@
+// Tiled GID flip-flag bits (TMJ tile-layer `data` / object `gid` values).
+// The high four bits of a 32-bit GID encode flip/rotation state; the
+// remaining 28 bits are the actual tileset-relative global tile id.
+//
+// These constants exist only to mask flip bits off before resolving a GID
+// against a tileset's [firstgid, firstgid + tilecount) range during source
+// validation. Converting flip bits into a runtime `TileTransform` is a C2
+// (runtime conversion) concern and is intentionally not implemented here.
+// @internal
+const TILED_FLIPPED_HORIZONTALLY_FLAG = 0x80000000;
+const TILED_FLIPPED_VERTICALLY_FLAG = 0x40000000;
+const TILED_FLIPPED_DIAGONALLY_FLAG = 0x20000000;
+/** Mask isolating the 28-bit tile id, clearing all four flip/rotation flag bits. */
+const TILED_GID_MASK = 0x0fffffff;
+/**
+ * Strips the flip/rotation flag bits from a raw Tiled GID, returning the
+ * plain tileset-relative global tile id (0 = empty cell).
+ *
+ * GIDs may exceed `2^31` (the horizontal-flip flag alone is `2^31`), so the
+ * value is first coerced to an unsigned 32-bit integer via `>>> 0`.
+ * @internal
+ */
+function maskTiledGid(raw) {
+    return (raw >>> 0) & TILED_GID_MASK;
+}
+
+export { TILED_FLIPPED_DIAGONALLY_FLAG, TILED_FLIPPED_HORIZONTALLY_FLAG, TILED_FLIPPED_VERTICALLY_FLAG, maskTiledGid };
+//# sourceMappingURL=gid.js.map

package/dist/esm/gid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gid.js","sources":["../../../src/gid.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEO,MAAM,+BAA+B,GAAG;AACxC,MAAM,6BAA6B,GAAG;AACtC,MAAM,6BAA6B,GAAG;AAG7C;AACA,MAAM,cAAc,GAAG,UAAU;AAEjC;;;;;;;AAOG;AACG,SAAU,YAAY,CAAC,GAAW,EAAA;AACtC,IAAA,OAAO,CAAC,GAAG,KAAK,CAAC,IAAI,cAAc;AACrC;;;;"}

package/dist/esm/index.js

@@ -1,4 +1,11 @@
-export { tiledExtension } from './tiledExtension.js';
 export { tiledBuildInfo } from './tiledBuildInfo.js';
+export { tiledExtension } from './tiledExtension.js';
+export { tiledMapBinding } from './tiledMapBinding.js';
+export { tiledRuntimeMapBinding } from './tiledRuntimeMapBinding.js';
+export { TILE_TRANSFORM_IDENTITY, TileLayer, TileLayerNode, TileMap, TileMapBand, TileMapNode, TileMapView, TileSet, tilemapExtension } from '@codexo/exojs-tilemap';
+export { TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer, createTiledLayer } from './TiledLayer.js';
 export { TiledMap } from './TiledMap.js';
+export { TiledObject } from './TiledObject.js';
+export { TiledTileset } from './TiledTileset.js';
+export { TiledFormatError } from './validate.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/dist/esm/loadTiledMap.d.ts

@@ -0,0 +1,9 @@
+import { type AssetLoaderContext } from '@codexo/exojs';
+import { TiledMap } from './TiledMap';
+/**
+ * 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
+ */
+export declare function loadTiledMap(source: string, context: AssetLoaderContext): Promise<TiledMap>;

package/dist/esm/loadTiledMap.js

@@ -0,0 +1,68 @@
+import { Texture } from '@codexo/exojs';
+import { TiledMap } from './TiledMap.js';
+import { TiledTileset } from './TiledTileset.js';
+import { resolveTiledUrl } from './url.js';
+import { validateTiledMapData, validateTiledTilesetFileData } from './validate.js';
+
+/**
+ * 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 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);
+}
+/**
+ * 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);
+    const data = validateTiledMapData(raw, source);
+    const tilesets = await Promise.all(data.tilesets.map(ref => loadTiledTileset(ref, source, context)));
+    return new TiledMap(source, data, tilesets);
+}
+
+export { loadTiledMap };
+//# sourceMappingURL=loadTiledMap.js.map

package/dist/esm/loadTiledMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadTiledMap.js","sources":["../../../src/loadTiledMap.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAQA;;;;;;;;;AASG;AACH,eAAe,yBAAyB,CAAC,IAAsB,EAAE,OAAe,EAAE,OAA2B,EAAE,MAAe,EAAA;AAC5H,IAAA,IAAI,QAA4B;AAChC,IAAA,IAAI,OAA4B;AAEhC,IAAA,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;QAC5B,QAAQ,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC;AAC/C,QAAA,OAAO,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC;IACxD;AAEA,IAAA,IAAI,YAA8C;AAElD,IAAA,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;AAC5B,QAAA,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;AAC7B,YAAA,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;gBAC5B;YACF;YAEA,MAAM,YAAY,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC;AACzD,YAAA,MAAM,WAAW,GAAY,MAAM,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC;AAE7E,YAAA,YAAY,KAAK,IAAI,GAAG,EAAE;YAC1B,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,WAAW,CAAC;QACxC;IACF;IAEA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE;AACpD;AAEA;;;;AAIG;AACH,eAAe,gBAAgB,CAAC,GAAwB,EAAE,SAAiB,EAAE,OAA2B,EAAA;AACtG,IAAA,IAAI,QAAQ,IAAI,GAAG,EAAE;QACnB,MAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;QACrD,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC;QAC3C,MAAM,IAAI,GAAG,4BAA4B,CAAC,GAAG,EAAE,MAAM,CAAC;AACtD,QAAA,MAAM,SAAS,GAAG,MAAM,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;QAEhF,OAAO,IAAI,YAAY,CAAC,IAAI,EAAE,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;IACxD;IAEA,MAAM,SAAS,GAAG,MAAM,yBAAyB,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,CAAC;IAE1E,OAAO,IAAI,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;AACvD;AAEA;;;;;AAKG;AACI,eAAe,YAAY,CAAC,MAAc,EAAE,OAA2B,EAAA;IAC5E,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC;IAC3C,MAAM,IAAI,GAAG,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC;IAC9C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEpG,OAAO,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC;AAC7C;;;;"}

package/dist/esm/public.d.ts

@@ -1,6 +1,45 @@
-export type { Extension, AssetBinding, AssetHandler, AssetLoadRequest } from '@codexo/exojs/extensions';
-export { tiledExtension } from './tiledExtension';
+export { type TiledLoadOptions } from './tiledOptions';
+export type { AssetBinding, AssetHandler, AssetLoadRequest, 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, PackedTile, ReadonlyTileChunk, ResolvedTile, TileDefinition, TileLayerNodeOptions, TileLayerOptions, TileLayerSelector, TileMapBandDefinition, TileMapNodeOptions, TileMapOptions, TileMapViewOptions, TileProperties, TilePropertyValue, TileSetOptions, TileTransform, } from '@codexo/exojs-tilemap';
+export { TILE_TRANSFORM_IDENTITY, TileLayer, TileLayerNode, TileMap, TileMapBand, tilemapExtension, TileMapNode, TileMapView, TileSet, } 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, } from './data';
+export type { TiledLayerType } from './TiledLayer';
+export { createTiledLayer, TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer, } from './TiledLayer';
 export { TiledMap } from './TiledMap';
-export type { TiledLayer, TiledMapData, TiledObject, TiledProperty, TiledTileset } from './TiledMap';
+export { TiledObject } from './TiledObject';
+export type { TiledTilesetResources } from './TiledTileset';
+export { TiledTileset } from './TiledTileset';
+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 AssetDefinitions {
+        tileMap: {
+            resource: TileMap;
+            config: {
+                source: string;
+                format?: 'tiled';
+            };
+        };
+        tiledMap: {
+            resource: TiledMap;
+            config: {
+                source: string;
+                format?: 'tiled';
+            };
+        };
+    }
+}

package/dist/esm/register.js

@@ -1,7 +1,14 @@
 import { ExtensionRegistry } from '@codexo/exojs/extensions';
 import { tiledExtension } from './tiledExtension.js';
 export { tiledBuildInfo } from './tiledBuildInfo.js';
+export { tiledMapBinding } from './tiledMapBinding.js';
+export { tiledRuntimeMapBinding } from './tiledRuntimeMapBinding.js';
+export { TILE_TRANSFORM_IDENTITY, TileLayer, TileLayerNode, TileMap, TileMapBand, TileMapNode, TileMapView, TileSet, tilemapExtension } from '@codexo/exojs-tilemap';
+export { TiledGroupLayer, TiledImageLayer, TiledLayer, TiledObjectLayer, TiledTileLayer, createTiledLayer } from './TiledLayer.js';
 export { TiledMap } from './TiledMap.js';
+export { TiledObject } from './TiledObject.js';
+export { TiledTileset } from './TiledTileset.js';
+export { TiledFormatError } from './validate.js';
 
 // @codexo/exojs-tiled/register — explicit registration entry.
 // Importing this entry registers the default tiledExtension descriptor

package/dist/esm/register.js.map

@@ -1 +1 @@
-{"version":3,"file":"register.js","sources":["../../../src/register.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AAMA,iBAAiB,CAAC,QAAQ,CAAC,cAAc,CAAC;;;;"}
+{"version":3,"file":"register.js","sources":["../../../src/register.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AAMA,iBAAiB,CAAC,QAAQ,CAAC,cAAc,CAAC;;;;"}

package/dist/esm/tiledBuildInfo.js

@@ -1,6 +1,6 @@
 const tiledBuildInfo = Object.freeze({
-    version: "0.12.0",
-    revision: "599bc56",
+    version: "0.13.0",
+    revision: "83ebf7f",
     development: false,
 });
 

package/dist/esm/tiledExtension.d.ts

@@ -1,6 +1,16 @@
 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')` →
+ *   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.
  */

package/dist/esm/tiledExtension.js

@@ -1,59 +1,30 @@
-import { Texture } from '@codexo/exojs';
-import { TiledMap } from './TiledMap.js';
+import { tilemapExtension } from '@codexo/exojs-tilemap';
+import { tiledMapBinding } from './tiledMapBinding.js';
+import { tiledRuntimeMapBinding } from './tiledRuntimeMapBinding.js';
 
-/**
- * Resolve a tileset image reference relative to the map's source path.
- * `new URL(ref, source)` only works when `source` is an absolute URL; the
- * loader is frequently called with relative paths, so fall back to a synthetic
- * base and strip it.
- */
-function resolveRelative(ref, source) {
-    try {
-        return new URL(ref, source).href;
-    }
-    catch {
-        const base = 'https://exojs.invalid/';
-        return new URL(ref, base + source.replace(/^\/+/, '')).href.slice(base.length);
-    }
-}
-const tiledBinding = {
-    type: TiledMap,
-    typeNames: ['tiledMap'],
-    extensions: ['tmj'],
-    create(loader) {
-        return {
-            async load({ source }, context) {
-                const data = await context.fetchJson(source);
-                if (!data || typeof data !== 'object' || !Array.isArray(data.tilesets)) {
-                    throw new Error(`TiledMap: invalid or unsupported map file at "${source}".`);
-                }
-                if (data.infinite === true) {
-                    throw new Error(`TiledMap: infinite maps are not supported (at "${source}").`);
-                }
-                if (data.orientation !== undefined && data.orientation !== 'orthogonal') {
-                    throw new Error(`TiledMap: only orthogonal orientation is supported (got "${data.orientation}" at "${source}").`);
-                }
-                // Load tileset textures. Sub-assets are owned by the Loader cache —
-                // TiledMap must NOT destroy them.
-                const tilesetTextures = (await Promise.all(data.tilesets
-                    .filter(ts => ts.image !== undefined)
-                    .map(ts => loader.load(Texture, resolveRelative(ts.image, source)))));
-                return new TiledMap(data, tilesetTextures);
-            },
-            destroy() {
-                // This handler holds no loader-local resources.
-            },
-        };
-    },
-};
 /**
  * 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')` →
+ *   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.
  */
 const tiledExtension = Object.freeze({
     id: '@codexo/exojs-tiled',
-    assets: [tiledBinding],
+    dependencies: [tilemapExtension],
+    // Localized erasure cast: typed bindings (Options=TiledLoadOptions) meet the
+    // untyped Extension.assets contract here. Runtime behavior is unaffected —
+    // materializeAssetBindings calls create() and bindAsset() correctly regardless
+    // of the erased Options type.
+    assets: [tiledRuntimeMapBinding, tiledMapBinding],
 });
 
 export { tiledExtension };

package/dist/esm/tiledExtension.js.map

@@ -1 +1 @@
-{"version":3,"file":"tiledExtension.js","sources":["../../../src/tiledExtension.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;AAKG;AACH,SAAS,eAAe,CAAC,GAAW,EAAE,MAAc,EAAA;AAClD,IAAA,IAAI;QACF,OAAO,IAAI,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,IAAI;IAClC;AAAE,IAAA,MAAM;QACN,MAAM,IAAI,GAAG,wBAAwB;QACrC,OAAO,IAAI,GAAG,CAAC,GAAG,EAAE,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;IAChF;AACF;AAEA,MAAM,YAAY,GAA2B;AAC3C,IAAA,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,CAAC,UAAU,CAAC;IACvB,UAAU,EAAE,CAAC,KAAK,CAAC;AACnB,IAAA,MAAM,CAAC,MAAc,EAAA;QACnB,OAAO;AACL,YAAA,MAAM,IAAI,CAAC,EAAE,MAAM,EAAoB,EAAE,OAA2B,EAAA;gBAClE,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,SAAS,CAAe,MAAM,CAAC;AAE1D,gBAAA,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AACtE,oBAAA,MAAM,IAAI,KAAK,CAAC,iDAAiD,MAAM,CAAA,EAAA,CAAI,CAAC;gBAC9E;AAEA,gBAAA,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;AAC1B,oBAAA,MAAM,IAAI,KAAK,CAAC,kDAAkD,MAAM,CAAA,GAAA,CAAK,CAAC;gBAChF;AAEA,gBAAA,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,KAAK,YAAY,EAAE;oBACvE,MAAM,IAAI,KAAK,CAAC,CAAA,yDAAA,EAA4D,IAAI,CAAC,WAAW,CAAA,MAAA,EAAS,MAAM,CAAA,GAAA,CAAK,CAAC;gBACnH;;;gBAIA,MAAM,eAAe,IAAI,MAAM,OAAO,CAAC,GAAG,CACxC,IAAI,CAAC;qBACF,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,KAAK,SAAS;qBACnC,GAAG,CAAC,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,eAAe,CAAC,EAAE,CAAC,KAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CACvE,CAAc;AAEf,gBAAA,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;YAC5C,CAAC;YACD,OAAO,GAAA;;YAEP,CAAC;SACF;IACH,CAAC;CACF;AAED;;;;AAIG;AACI,MAAM,cAAc,GAAc,MAAM,CAAC,MAAM,CAAC;AACrD,IAAA,EAAE,EAAE,qBAAqB;IACzB,MAAM,EAAE,CAAC,YAAY,CAAC;AACvB,CAAA;;;;"}
+{"version":3,"file":"tiledExtension.js","sources":["../../../src/tiledExtension.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;AAcG;AACI,MAAM,cAAc,GAAc,MAAM,CAAC,MAAM,CAAC;AACrD,IAAA,EAAE,EAAE,qBAAqB;IACzB,YAAY,EAAE,CAAC,gBAAgB,CAAC;;;;;AAKhC,IAAA,MAAM,EAAE,CAAC,sBAAsB,EAAE,eAAe,CAA8B;AAC/E,CAAA;;;;"}

package/dist/esm/tiledMapBinding.d.ts

@@ -0,0 +1,19 @@
+import { TiledMap } from './TiledMap';
+import { type TiledLoadOptions } from './tiledOptions';
+/**
+ * Declarative asset binding for {@link TiledMap}.
+ *
+ * Token-only: `loader.load(TiledMap, 'world.tmj')` resolves through this
+ * binding, but no `extensions` are claimed, so a plain
+ * `loader.load('world.tmj')` does not resolve to `TiledMap`. The `.tmj`
+ * extension (and generic `.json` Tiled loading) is reserved for the
+ * format-independent `TileMap` runtime asset binding.
+ */
+export declare const tiledMapBinding: {
+    type: typeof TiledMap;
+    typeNames: string[];
+    create(): {
+        getIdentityKey(req: import("@codexo/exojs").AssetLoadRequest<TiledLoadOptions>): string;
+        load(req: import("@codexo/exojs").AssetLoadRequest<TiledLoadOptions>, ctx: import("@codexo/exojs").AssetLoaderContext): Promise<TiledMap>;
+    };
+};

package/dist/esm/tiledMapBinding.js

@@ -0,0 +1,31 @@
+import { loadTiledMap } from './loadTiledMap.js';
+import { TiledMap } from './TiledMap.js';
+import { resolveTiledOptions } from './tiledOptions.js';
+
+/**
+ * Declarative asset binding for {@link TiledMap}.
+ *
+ * Token-only: `loader.load(TiledMap, 'world.tmj')` resolves through this
+ * binding, but no `extensions` are claimed, so a plain
+ * `loader.load('world.tmj')` does not resolve to `TiledMap`. The `.tmj`
+ * extension (and generic `.json` Tiled loading) is reserved for the
+ * format-independent `TileMap` runtime asset binding.
+ */
+const tiledMapBinding = {
+    type: TiledMap,
+    typeNames: ['tiledMap'],
+    create() {
+        return {
+            getIdentityKey(req) {
+                const o = resolveTiledOptions(req.options);
+                return `${req.source}|${o.format}`;
+            },
+            async load(req, ctx) {
+                return loadTiledMap(req.source, ctx);
+            },
+        };
+    },
+};
+
+export { tiledMapBinding };
+//# sourceMappingURL=tiledMapBinding.js.map

package/dist/esm/tiledMapBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiledMapBinding.js","sources":["../../../src/tiledMapBinding.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;AAQG;AACI,MAAM,eAAe,GAAG;AAC7B,IAAA,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,CAAC,UAAU,CAAC;IACvB,MAAM,GAAA;QACJ,OAAO;AACL,YAAA,cAAc,CAAC,GAAG,EAAA;gBAChB,MAAM,CAAC,GAAG,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC;gBAC1C,OAAO,CAAA,EAAG,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,CAAA,CAAE;YACpC,CAAC;AACD,YAAA,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,EAAA;gBACjB,OAAO,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC;YACtC,CAAC;SACiD;IACtD,CAAC;;;;;"}

package/dist/esm/tiledOptions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Options accepted by both the runtime (`TileMap`) and source (`TiledMap`)
+ * asset bindings when loading a Tiled map.
+ * @advanced
+ */
+export interface TiledLoadOptions {
+    /**
+     * Explicit format hint for ambiguous file extensions.
+     *
+     * `.tmj`/`.tsj` paths are recognised by extension and need no hint. Provide
+     * `format: 'tiled'` when loading Tiled map data from a generic `.json` path:
+     * `loader.load(TileMap, 'world.json', { format: 'tiled' })`. `'tiled'` is the
+     * only accepted value, so a foreign format (e.g. `'ldtk'`) is a compile error
+     * rather than a silent runtime fall-through.
+     *
+     * The hint participates in the asset identity key, so the same source loaded
+     * under different (future) formats resolves to distinct cache entries.
+     */
+    readonly format?: 'tiled';
+}
+/**
+ * Applies defaults and returns a normalized options object.
+ *
+ * Tiled parsing is unconditionally strict: {@link validateTiledMapData} throws
+ * a `TiledFormatError` on any malformed *known* field and silently preserves
+ * unknown fields. There is intentionally no `strict` toggle — a permissive
+ * parse mode is a potential v0.14 follow-up, not part of v0.13.
+ */
+export declare function resolveTiledOptions(options: TiledLoadOptions | undefined): {
+    format: 'tiled';
+};