@codexo/exojs-tiled 0.12.0 → 0.14.0

package/dist/esm/tiledOptions.js

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+function resolveTiledOptions(options) {
+    return {
+        format: options?.format ?? 'tiled',
+    };
+}
+
+export { resolveTiledOptions };
+//# sourceMappingURL=tiledOptions.js.map

package/dist/esm/tiledOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiledOptions.js","sources":["../../../src/tiledOptions.ts"],"sourcesContent":[null],"names":[],"mappings":"AAqBA;;;;;;;AAOG;AACG,SAAU,mBAAmB,CAAC,OAAqC,EAAA;IACvE,OAAO;AACL,QAAA,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,OAAO;KACnC;AACH;;;;"}

package/dist/esm/tiledRuntimeMapBinding.d.ts

@@ -0,0 +1,29 @@
+import { TileMap } from '@codexo/exojs-tilemap';
+import { type TiledLoadOptions } from './tiledOptions';
+/**
+ * Declarative asset binding for the runtime {@link TileMap} produced from a
+ * `.tmj` Tiled map file.
+ *
+ * This is the common-case binding: `loader.load(TileMap, 'world.tmj')` fetches
+ * and validates the TMJ, resolves external `.tsj` tilesets, loads tileset
+ * textures via the sub-load `loader.load(TiledMap, source)`, and synchronously
+ * converts the parsed {@link TiledMap} source model into a format-independent
+ * runtime {@link TileMap} via {@link TiledMap.toTileMap}.
+ *
+ * The sub-load flow guarantees that calling both `load(TileMap)` and
+ * `load(TiledMap)` for the same URL shares the Loader's cached `TiledMap`
+ * (no duplicate JSON fetches).
+ *
+ * Claiming the `tmj` extension enables the auto-routing shorthand
+ * `loader.load('world.tmj')` — the {@link ExtensionTypeMap} augmentation in
+ * this package maps `'tmj' → TileMap`.
+ */
+export declare const tiledRuntimeMapBinding: {
+    type: typeof TileMap;
+    typeNames: string[];
+    extensions: string[];
+    create(): {
+        getIdentityKey(req: import("@codexo/exojs").AssetLoadRequest<TiledLoadOptions>): string;
+        load(req: import("@codexo/exojs").AssetLoadRequest<TiledLoadOptions>, ctx: import("@codexo/exojs").AssetLoaderContext): Promise<TileMap>;
+    };
+};

package/dist/esm/tiledRuntimeMapBinding.js

@@ -0,0 +1,42 @@
+import { TileMap } from '@codexo/exojs-tilemap';
+import { TiledMap } from './TiledMap.js';
+import { resolveTiledOptions } from './tiledOptions.js';
+
+/**
+ * Declarative asset binding for the runtime {@link TileMap} produced from a
+ * `.tmj` Tiled map file.
+ *
+ * This is the common-case binding: `loader.load(TileMap, 'world.tmj')` fetches
+ * and validates the TMJ, resolves external `.tsj` tilesets, loads tileset
+ * textures via the sub-load `loader.load(TiledMap, source)`, and synchronously
+ * converts the parsed {@link TiledMap} source model into a format-independent
+ * runtime {@link TileMap} via {@link TiledMap.toTileMap}.
+ *
+ * The sub-load flow guarantees that calling both `load(TileMap)` and
+ * `load(TiledMap)` for the same URL shares the Loader's cached `TiledMap`
+ * (no duplicate JSON fetches).
+ *
+ * Claiming the `tmj` extension enables the auto-routing shorthand
+ * `loader.load('world.tmj')` — the {@link ExtensionTypeMap} augmentation in
+ * this package maps `'tmj' → TileMap`.
+ */
+const tiledRuntimeMapBinding = {
+    type: TileMap,
+    typeNames: ['tileMap'],
+    extensions: ['tmj'],
+    create() {
+        return {
+            getIdentityKey(req) {
+                const o = resolveTiledOptions(req.options);
+                return `${req.source}|${o.format}`;
+            },
+            async load(req, ctx) {
+                const tiledMap = await ctx.loader.load(TiledMap, req.source, req.options);
+                return tiledMap.toTileMap();
+            },
+        };
+    },
+};
+
+export { tiledRuntimeMapBinding };
+//# sourceMappingURL=tiledRuntimeMapBinding.js.map

package/dist/esm/tiledRuntimeMapBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiledRuntimeMapBinding.js","sources":["../../../src/tiledRuntimeMapBinding.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,sBAAsB,GAAG;AACpC,IAAA,IAAI,EAAE,OAAO;IACb,SAAS,EAAE,CAAC,SAAS,CAAC;IACtB,UAAU,EAAE,CAAC,KAAK,CAAC;IACnB,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;AACjB,gBAAA,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC;AACzE,gBAAA,OAAO,QAAQ,CAAC,SAAS,EAAE;YAC7B,CAAC;SACgD;IACrD,CAAC;;;;;"}

package/dist/esm/url.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolves `ref` (a path read from a Tiled JSON file, e.g. a tileset
+ * `source` or an `image`) relative to `base` (the resolved location of the
+ * file that referenced it).
+ *
+ * - If `ref` is already absolute (has a scheme, is protocol- or
+ *   root-relative, or is a `data:`/`blob:` URL), it is returned unchanged.
+ * - If `base` is an absolute URL, standard `new URL(ref, base)` resolution
+ *   is used.
+ * - Otherwise both `ref` and `base` are relative ExoJS asset paths; `../`
+ *   and `./` segments are collapsed via a synthetic origin and the result is
+ *   returned relative again.
+ *
+ * Query strings and fragments on `ref` are preserved.
+ *
+ * @internal
+ */
+export declare function resolveTiledUrl(ref: string, base: string): string;

package/dist/esm/url.js

@@ -0,0 +1,41 @@
+// Relative-path resolution for Tiled source references (TMJ → TSJ, TMJ/TSJ →
+// image). Tiled stores every cross-file reference as a path relative to the
+// file that contains it; ExoJS asset sources are themselves often relative
+// (resolved against an asset root configured outside the Loader), so plain
+// `new URL(ref, base)` cannot be used directly when `base` has no scheme.
+/** Matches references that are already absolute and must not be re-resolved: scheme:, protocol-relative `//`, root-relative `/`, and data/blob URLs. */
+const ABSOLUTE_REF = /^(?:[a-z][a-z\d+.-]*:|\/\/|\/)/i;
+/** Matches a base that is itself an absolute URL with a scheme. */
+const ABSOLUTE_BASE = /^[a-z][a-z\d+.-]*:/i;
+/** Synthetic origin used to borrow `URL`'s `../`/`./` collapsing for relative bases. */
+const SYNTHETIC_ORIGIN = 'https://exojs.invalid/';
+/**
+ * Resolves `ref` (a path read from a Tiled JSON file, e.g. a tileset
+ * `source` or an `image`) relative to `base` (the resolved location of the
+ * file that referenced it).
+ *
+ * - If `ref` is already absolute (has a scheme, is protocol- or
+ *   root-relative, or is a `data:`/`blob:` URL), it is returned unchanged.
+ * - If `base` is an absolute URL, standard `new URL(ref, base)` resolution
+ *   is used.
+ * - Otherwise both `ref` and `base` are relative ExoJS asset paths; `../`
+ *   and `./` segments are collapsed via a synthetic origin and the result is
+ *   returned relative again.
+ *
+ * Query strings and fragments on `ref` are preserved.
+ *
+ * @internal
+ */
+function resolveTiledUrl(ref, base) {
+    if (ABSOLUTE_REF.test(ref)) {
+        return ref;
+    }
+    if (ABSOLUTE_BASE.test(base)) {
+        return new URL(ref, base).href;
+    }
+    const resolved = new URL(ref, SYNTHETIC_ORIGIN + base.replace(/^\/+/, ''));
+    return resolved.href.slice(SYNTHETIC_ORIGIN.length);
+}
+
+export { resolveTiledUrl };
+//# sourceMappingURL=url.js.map

package/dist/esm/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","sources":["../../../src/url.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AAEA;AACA,MAAM,YAAY,GAAG,iCAAiC;AAEtD;AACA,MAAM,aAAa,GAAG,qBAAqB;AAE3C;AACA,MAAM,gBAAgB,GAAG,wBAAwB;AAEjD;;;;;;;;;;;;;;;;AAgBG;AACG,SAAU,eAAe,CAAC,GAAW,EAAE,IAAY,EAAA;AACvD,IAAA,IAAI,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;AAC1B,QAAA,OAAO,GAAG;IACZ;AAEA,IAAA,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC5B,OAAO,IAAI,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,IAAI;IAChC;AAEA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAE1E,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC;AACrD;;;;"}

package/dist/esm/validate.d.ts

@@ -0,0 +1,49 @@
+import type { TiledAnimationFrameData, TiledLayerData, TiledMapData, TiledObjectData, TiledPropertyData, TiledTileData, TiledTilesetData, TiledTilesetRefData } from './data';
+/**
+ * Thrown when a Tiled JSON document does not match the expected shape.
+ * `source` is the URL of the file being parsed; `path` is a JSON-path-like
+ * pointer (e.g. `layers[2].objects[0].properties[1].value`) to the offending
+ * value, or `''` for the document root.
+ */
+export declare class TiledFormatError extends Error {
+    readonly source: string;
+    readonly path: string;
+    constructor(source: string, path: string, message: string);
+}
+/** @internal */
+export declare function validateTiledPropertyData(raw: unknown, source: string, path: string): TiledPropertyData;
+/** @internal */
+export declare function validateTiledAnimationFrameData(raw: unknown, source: string, path: string): TiledAnimationFrameData;
+/** @internal */
+export declare function validateTiledObjectData(raw: unknown, source: string, path: string): TiledObjectData;
+/** @internal */
+export declare function validateTiledLayerData(raw: unknown, source: string, path: string): TiledLayerData;
+/**
+ * Walks a layer tree and ensures every tile layer's `data`/`chunks` choice
+ * matches the map's `infinite` flag. Tiled itself is consistent across an
+ * entire map; a mismatch indicates a hand-edited or corrupt file.
+ * @internal
+ */
+export declare function checkTiledLayerInfiniteConsistency(layers: readonly TiledLayerData[], infinite: boolean, source: string, path: string): void;
+/** @internal */
+export declare function validateTiledTileData(raw: unknown, source: string, path: string): TiledTileData;
+/** @internal */
+export declare function validateTiledTilesetData(obj: Record<string, unknown>, source: string, path: string): TiledTilesetData;
+/**
+ * Validates one entry of a map's `tilesets` array: either `{ firstgid,
+ * source }` (external `.tsj`) or `{ firstgid, ...embedded tileset fields }`.
+ * @internal
+ */
+export declare function validateTiledTilesetRefData(raw: unknown, source: string, path: string): TiledTilesetRefData;
+/**
+ * Validates the root of a `.tmj` file. Throws {@link TiledFormatError} on
+ * any structural problem, including unsupported tile-layer encodings and
+ * `infinite`/`data`/`chunks` inconsistencies.
+ * @internal
+ */
+export declare function validateTiledMapData(raw: unknown, source: string): TiledMapData;
+/**
+ * Validates a standalone `.tsj` tileset file's root object.
+ * @internal
+ */
+export declare function validateTiledTilesetFileData(raw: unknown, source: string): TiledTilesetData;