@codexo/exojs-ldtk 0.15.3 → 0.16.0

package/dist/esm/loadLdtkProject.js

@@ -0,0 +1,31 @@
+import { validateLdtkData } from "./validate.js";
+import { LdtkProject } from "./LdtkProject.js";
+import { loadLdtkTileset } from "./loadLdtkMap.js";
+import { Asset } from "@codexo/exojs";
+
+//#region src/loadLdtkProject.ts
+/**
+* Read and validate a `.ldtk` document and load every tileset atlas it
+* references, without touching any level payload.
+*
+* External `.ldtkl` levels are deliberately left unfetched - that is the whole
+* point of {@link LdtkProject}: the world layout arrives, the levels arrive
+* when a level runtime asks for them.
+*
+* @throws {import('./validate').LdtkFormatError} for a structurally invalid
+* document, or a tileset whose declared atlas cannot hold a single tile. An
+* embed-atlas tileset (`relPath = null`) is skipped with a warning instead.
+* @internal
+*/
+const loadLdtkProject = async (context) => {
+	const source = context.source;
+	const data = validateLdtkData(await context.dependencies.load(Asset.type("json", source)), source);
+	const tilesetEntries = await Promise.all(data.defs.tilesets.map(async (def) => [def.uid, await loadLdtkTileset(def, source, context)]));
+	const tilesets = /* @__PURE__ */ new Map();
+	for (const [uid, tileset] of tilesetEntries) if (tileset !== null) tilesets.set(uid, tileset);
+	return new LdtkProject(source, data, tilesets);
+};
+
+//#endregion
+export { loadLdtkProject };
+//# sourceMappingURL=loadLdtkProject.js.map

package/dist/esm/loadLdtkProject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLdtkProject.js","names":[],"sources":["../../src/loadLdtkProject.ts"],"sourcesContent":["import type { AssetFactoryContext } from '@codexo/exojs';\nimport { Asset } from '@codexo/exojs';\nimport type { TileSet } from '@codexo/exojs-tilemap';\n\nimport { LdtkProject } from './LdtkProject';\nimport { loadLdtkTileset } from './loadLdtkMap';\nimport { validateLdtkData } from './validate';\n\n/**\n * Read and validate a `.ldtk` document and load every tileset atlas it\n * references, without touching any level payload.\n *\n * External `.ldtkl` levels are deliberately left unfetched - that is the whole\n * point of {@link LdtkProject}: the world layout arrives, the levels arrive\n * when a level runtime asks for them.\n *\n * @throws {import('./validate').LdtkFormatError} for a structurally invalid\n * document, or a tileset whose declared atlas cannot hold a single tile. An\n * embed-atlas tileset (`relPath = null`) is skipped with a warning instead.\n * @internal\n */\nexport const loadLdtkProject = async (context: AssetFactoryContext): Promise<LdtkProject> => {\n  const source = context.source;\n  const data = validateLdtkData(await context.dependencies.load(Asset.type('json', source)), source);\n\n  const tilesetEntries = await Promise.all(data.defs.tilesets.map(async def => [def.uid, await loadLdtkTileset(def, source, context)] as const));\n\n  const tilesets = new Map<number, TileSet>();\n\n  for (const [uid, tileset] of tilesetEntries) {\n    if (tileset !== null) tilesets.set(uid, tileset);\n  }\n\n  return new LdtkProject(source, data, tilesets);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqBA,MAAa,kBAAkB,OAAO,YAAuD;CAC3F,MAAM,SAAS,QAAQ;CACvB,MAAM,OAAO,iBAAiB,MAAM,QAAQ,aAAa,KAAK,MAAM,KAAK,QAAQ,MAAM,CAAC,GAAG,MAAM;CAEjG,MAAM,iBAAiB,MAAM,QAAQ,IAAI,KAAK,KAAK,SAAS,IAAI,OAAM,QAAO,CAAC,IAAI,KAAK,MAAM,gBAAgB,KAAK,QAAQ,OAAO,CAAC,CAAU,CAAC;CAE7I,MAAM,2BAAW,IAAI,IAAqB;CAE1C,KAAK,MAAM,CAAC,KAAK,YAAY,gBAC3B,IAAI,YAAY,MAAM,SAAS,IAAI,KAAK,OAAO;CAGjD,OAAO,IAAI,YAAY,QAAQ,MAAM,QAAQ;AAC/C"}

package/dist/esm/public.d.ts

@@ -1,24 +1,39 @@
-export { ldtkMapBinding } from './ldtkBinding';
 export { ldtkExtension } from './ldtkExtension';
+export { LdtkMapAssetType, ldtkMapType, LdtkProjectAssetType, ldtkProjectType } from './ldtkTypes';
 export { LdtkMap } from './LdtkMap';
+export type { LdtkRuntimeOptions } from './LdtkProject';
+export { LdtkProject } from './LdtkProject';
+export { ldtkToMapWorld } from './ldtkToMapWorld';
 export type { LdtkToTileMapOptions } from './ldtkToTileMap';
-export { getLdtkIntGridValueAt, ldtkIntGridCsvProperty, ldtkIntGridValuesProperty, ldtkToTileMap, } from './ldtkToTileMap';
-export type { LdtkData, LdtkDefs, LdtkEntityInstance, LdtkFieldInstance, LdtkIntGridValueDef, LdtkLayerDef, LdtkLayerInstance, LdtkLayerType, LdtkLevel, LdtkTileData, LdtkTilesetDef, LdtkWorldData, LdtkWorldLayout, } from './LdtkData';
-export { ldtkFlipNone, ldtkFlipX, ldtkFlipXy, ldtkFlipY } from './LdtkData';
-export type { ChunkCoord, EllipseObject, ObjectLayerOptions, ObjectPoint, ObjectQuery, ObjectSchema, PackedTile, PointObject, PolygonObject, PolylineObject, ReadonlyTileChunk, RectangleObject, ResolvedTile, TileDefinition, TileLayerOptions, TileMapObject, TileMapObjectKind, TileMapOptions, TileMapViewOptions, TileObject, TileProperties, TilePropertyObjectRef, TilePropertyPoint, TilePropertyTileRef, TilePropertyValue, TileSetOptions, TileTransform, } from '@codexo/exojs-tilemap';
-export { ObjectKind, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileMap, tilemapExtension, TileMapView, TilePropertyKind, TileSet, } from '@codexo/exojs-tilemap';
+export { createLdtkIntGridCellSource, getLdtkIntGridValueAt, ldtkIntGridCsvProperty, ldtkIntGridValuesProperty, ldtkToTileMap } from './ldtkToTileMap';
+export type { LdtkData, LdtkDefs, LdtkEntityInstance, LdtkFieldInstance, LdtkIntGridValueDef, LdtkLayerDef, LdtkLayerInstance, LdtkLayerType, LdtkLevel, LdtkLevelNeighbour, LdtkTileData, LdtkTilesetDef, LdtkWorldData, LdtkWorldLayout, } from './LdtkData';
+export { LDTK_FLIP_NONE, LDTK_FLIP_X, LDTK_FLIP_XY, LDTK_FLIP_Y } from './LdtkData';
+export { LdtkFormatError } from './validate';
+export type { ChunkCoord, EllipseObject, MapBounds, MapLevel, MapLevelCancelOptions, MapLevelLoadContext, MapLevelLoadOptions, MapLevelNeighbour, MapLevelProvider, MapObjectDescriptor, MapObjectFactories, MapObjectFactory, MapObjectSpawnerOptions, MapSpawnErrorReason, MapSpawnOptions, MapWorldOptions, MapWorldRuntimeOptions, ObjectLayerOptions, ObjectPoint, ObjectQuery, ObjectSchema, PackedTile, PointObject, PolygonObject, PolylineObject, ReadonlyTileChunk, RectangleObject, ResolvedTile, TileDefinition, TileLayerOptions, TileMapObject, TileMapObjectKind, TileMapOptions, TileMapViewOptions, TileObject, TileProperties, TilePropertyObjectRef, TilePropertyPoint, TilePropertyTileRef, TilePropertyValue, TileSetOptions, TileTransform, UnknownMapObjectPolicy, } from '@codexo/exojs-tilemap';
+export { MapLevelRuntime, MapLevelSide, mapObjectDescriptor, mapObjectDescriptors, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld, MapWorldRuntime, ObjectKind, ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer, TileMap, tilemapExtension, TileMapView, TilePropertyKind, TileSet, } from '@codexo/exojs-tilemap';
 import type { LdtkMap } from './LdtkMap';
+import type { LdtkProject } from './LdtkProject';
 declare module '@codexo/exojs' {
-    interface ExtensionTypeMap {
-        /** `.ldtk` path-only loads resolve to {@link LdtkMap}. */
-        ldtk: LdtkMap;
+    interface ExtensionKindMap {
+        /** `.ldtk` bare-path loads resolve to the `ldtkMap` type ({@link LdtkMap}). */
+        ldtk: 'ldtkMap';
     }
     interface AssetDefinitions {
+        ldtkProject: {
+            resource: LdtkProject;
+            config: {
+                source: string;
+            };
+            /** See `ldtkMap` - `ldtkProjectType` keeps the default leaf too. */
+            isValue: true;
+        };
         ldtkMap: {
             resource: LdtkMap;
             config: {
                 source: string;
             };
+            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":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnG,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGvJ,YAAY,EACV,QAAQ,EACR,QAAQ,EACR,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGpF,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAK7C,YAAY,EACV,UAAU,EACV,aAAa,EACb,SAAS,EACT,QAAQ,EACR,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,QAAQ,EACR,eAAe,EACf,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,SAAS,EACT,OAAO,EACP,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,OAAO,GACR,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,QAAQ,eAAe,CAAC;IAC7B,UAAU,gBAAgB;QACxB,+EAA+E;QAC/E,IAAI,EAAE,SAAS,CAAC;KACjB;IACD,UAAU,gBAAgB;QACxB,WAAW,EAAE;YACX,QAAQ,EAAE,WAAW,CAAC;YACtB,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC;YAC3B,oEAAoE;YACpE,OAAO,EAAE,IAAI,CAAC;SACf,CAAC;QACF,OAAO,EAAE;YACP,QAAQ,EAAE,OAAO,CAAC;YAClB,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC;YAG3B,OAAO,EAAE,IAAI,CAAC;SACf,CAAC;KACH;CACF"}

package/dist/esm/public.js

@@ -0,0 +1,11 @@
+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 as MapLevelSide$1, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld as MapWorld$1, MapWorldRuntime as MapWorldRuntime$1, ObjectKind, ObjectLayer as ObjectLayer$1, TILE_TRANSFORM_IDENTITY, TileLayer as TileLayer$1, TileMap as TileMap$1, TileMapView, TilePropertyKind as TilePropertyKind$1, TileSet as TileSet$1, mapObjectDescriptor, mapObjectDescriptors, tilemapExtension as tilemapExtension$1 } from "@codexo/exojs-tilemap";
+
+export { LDTK_FLIP_NONE, LDTK_FLIP_X, LDTK_FLIP_XY, LDTK_FLIP_Y, LdtkFormatError, LdtkMap, LdtkMapAssetType, LdtkProject, LdtkProjectAssetType, MapLevelRuntime, MapLevelSide$1 as MapLevelSide, MapObjectSpawner, MapSpawnError, MapSpawnSession, MapWorld$1 as MapWorld, MapWorldRuntime$1 as MapWorldRuntime, ObjectKind, ObjectLayer$1 as ObjectLayer, TILE_TRANSFORM_IDENTITY, TileLayer$1 as TileLayer, TileMap$1 as TileMap, TileMapView, TilePropertyKind$1 as TilePropertyKind, TileSet$1 as TileSet, createLdtkIntGridCellSource, getLdtkIntGridValueAt, ldtkExtension, ldtkIntGridCsvProperty, ldtkIntGridValuesProperty, ldtkMapType, ldtkProjectType, ldtkToMapWorld, ldtkToTileMap, mapObjectDescriptor, mapObjectDescriptors, tilemapExtension$1 as tilemapExtension };

package/dist/esm/url.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolves `ref` (a path read from an LDtk file, e.g. a tileset `relPath` or a
+ * level `externalRelPath`) relative to `base` (the resolved location of the
+ * file that referenced it).
+ *
+ * - If `ref` is already absolute (scheme, protocol- or root-relative, or a
+ *   `data:`/`blob:` URL), it is returned unchanged.
+ * - If `base` is an absolute URL, standard `new URL(ref, base)` resolution is
+ *   used.
+ * - Otherwise both are relative ExoJS asset paths; `../`/`./` segments are
+ *   collapsed via a synthetic origin and the result is returned relative again.
+ *
+ * @internal
+ */
+export declare const resolveLdtkUrl: (ref: string, base: string) => string;
+//# sourceMappingURL=url.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../src/url.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,EAAE,MAAM,MAAM,KAAG,MAgB1D,CAAC"}

package/dist/esm/url.js

@@ -0,0 +1,31 @@
+//#region src/url.ts
+/** 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 an LDtk file, e.g. a tileset `relPath` or a
+* level `externalRelPath`) relative to `base` (the resolved location of the
+* file that referenced it).
+*
+* - If `ref` is already absolute (scheme, protocol- or root-relative, or a
+*   `data:`/`blob:` URL), it is returned unchanged.
+* - If `base` is an absolute URL, standard `new URL(ref, base)` resolution is
+*   used.
+* - Otherwise both are relative ExoJS asset paths; `../`/`./` segments are
+*   collapsed via a synthetic origin and the result is returned relative again.
+*
+* @internal
+*/
+const resolveLdtkUrl = (ref, base) => {
+	if (ABSOLUTE_REF.test(ref)) return ref;
+	if (ABSOLUTE_BASE.test(base)) return new URL(ref, base).href;
+	const relative = new URL(ref, SYNTHETIC_ORIGIN + base.replace(/^\/+/, "")).href.slice(22);
+	return base.startsWith("/") ? `/${relative}` : relative;
+};
+
+//#endregion
+export { resolveLdtkUrl };
+//# sourceMappingURL=url.js.map

package/dist/esm/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":[],"sources":["../../src/url.ts"],"sourcesContent":["// Relative-path resolution for LDtk source references (.ldtk → tileset image,\n// .ldtk → external .ldtkl level). LDtk stores every cross-file reference as a\n// path relative to the file that contains it; ExoJS asset sources are themselves\n// often relative (resolved against an asset root configured outside the Loader),\n// so plain `new URL(ref, base)` cannot be used directly when `base` has no\n// scheme - it throws `Invalid URL`. Mirrors the Tiled adapter's `resolveTiledUrl`.\n\n/** Matches references that are already absolute and must not be re-resolved: scheme:, protocol-relative `//`, root-relative `/`, and data/blob URLs. */\nconst ABSOLUTE_REF = /^(?:[a-z][a-z\\d+.-]*:|\\/\\/|\\/)/i;\n\n/** Matches a base that is itself an absolute URL with a scheme. */\nconst ABSOLUTE_BASE = /^[a-z][a-z\\d+.-]*:/i;\n\n/** Synthetic origin used to borrow `URL`'s `../`/`./` collapsing for relative bases. */\nconst SYNTHETIC_ORIGIN = 'https://exojs.invalid/';\n\n/**\n * Resolves `ref` (a path read from an LDtk file, e.g. a tileset `relPath` or a\n * level `externalRelPath`) relative to `base` (the resolved location of the\n * file that referenced it).\n *\n * - If `ref` is already absolute (scheme, protocol- or root-relative, or a\n *   `data:`/`blob:` URL), it is returned unchanged.\n * - If `base` is an absolute URL, standard `new URL(ref, base)` resolution is\n *   used.\n * - Otherwise both are relative ExoJS asset paths; `../`/`./` segments are\n *   collapsed via a synthetic origin and the result is returned relative again.\n *\n * @internal\n */\nexport const resolveLdtkUrl = (ref: string, base: string): string => {\n  if (ABSOLUTE_REF.test(ref)) {\n    return ref;\n  }\n\n  if (ABSOLUTE_BASE.test(base)) {\n    return new URL(ref, base).href;\n  }\n\n  const resolved = new URL(ref, SYNTHETIC_ORIGIN + base.replace(/^\\/+/, ''));\n  const relative = resolved.href.slice(SYNTHETIC_ORIGIN.length);\n\n  // A root-relative base must produce a root-relative result again - dropping\n  // the leading slash would make the browser re-resolve the reference against\n  // the document base URL (e.g. `/site/assets/x.png` → `/site/site/assets/...`).\n  return base.startsWith('/') ? `/${relative}` : relative;\n};\n"],"mappings":";;AAQA,MAAM,eAAe;;AAGrB,MAAM,gBAAgB;;AAGtB,MAAM,mBAAmB;;;;;;;;;;;;;;;AAgBzB,MAAa,kBAAkB,KAAa,SAAyB;CACnE,IAAI,aAAa,KAAK,GAAG,GACvB,OAAO;CAGT,IAAI,cAAc,KAAK,IAAI,GACzB,OAAO,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC;CAI5B,MAAM,WAAW,IADI,IAAI,KAAK,mBAAmB,KAAK,QAAQ,QAAQ,EAAE,CAChD,CAAC,CAAC,KAAK,MAAM,EAAuB;CAK5D,OAAO,KAAK,WAAW,GAAG,IAAI,IAAI,aAAa;AACjD"}

package/dist/esm/validate.d.ts

@@ -0,0 +1,27 @@
+import type { LdtkData, LdtkLevel } from './LdtkData';
+/**
+ * Thrown when an LDtk 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. `levels[0].layerInstances[1].gridTiles[0].px`) to the
+ * offending value, or `''` for the document root.
+ */
+export declare class LdtkFormatError extends Error {
+    readonly source: string;
+    readonly path: string;
+    constructor(source: string, path: string, message: string);
+}
+/**
+ * Validate the root of a `.ldtk` file and return it typed as {@link LdtkData}.
+ * Throws {@link LdtkFormatError} on any structural problem, naming the source
+ * URL and the property path of the offending value.
+ * @internal
+ */
+export declare const validateLdtkData: (raw: unknown, source: string) => LdtkData;
+/**
+ * Validate an external `.ldtkl` payload and return it typed as
+ * {@link LdtkLevel}. Paths in a thrown {@link LdtkFormatError} are relative to
+ * the level object, since that object is the root of the `.ldtkl` file.
+ * @internal
+ */
+export declare const validateLdtkLevelData: (raw: unknown, source: string) => LdtkLevel;
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAiB,SAAS,EAAmB,MAAM,YAAY,CAAC;AAEtF;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAMjE;AAyYD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,KAAG,QAgB/D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,OAAO,EAAE,QAAQ,MAAM,KAAG,SAIpE,CAAC"}

package/dist/esm/validate.js

@@ -0,0 +1,327 @@
+//#region src/validate.ts
+/**
+* Thrown when an LDtk 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. `levels[0].layerInstances[1].gridTiles[0].px`) to the
+* offending value, or `''` for the document root.
+*/
+var LdtkFormatError = class extends Error {
+	source;
+	path;
+	constructor(source, path, message) {
+		super(`Invalid LDtk data in "${source}" at ${path === "" ? "<root>" : path}: ${message}`);
+		this.name = "LdtkFormatError";
+		this.source = source;
+		this.path = path;
+	}
+};
+const describeValue = (value) => {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return "an array";
+	return typeof value;
+};
+const joinPath = (path, key) => {
+	if (typeof key === "number") return `${path}[${key}]`;
+	return path === "" ? key : `${path}.${key}`;
+};
+const expectObject = (value, source, path) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new LdtkFormatError(source, path, `expected an object, got ${describeValue(value)}`);
+	return value;
+};
+const expectArray = (value, source, path) => {
+	if (!Array.isArray(value)) throw new LdtkFormatError(source, path, `expected an array, got ${describeValue(value)}`);
+	return value;
+};
+const expectString = (value, source, path) => {
+	if (typeof value !== "string") throw new LdtkFormatError(source, path, `expected a string, got ${describeValue(value)}`);
+	return value;
+};
+const expectNumber = (value, source, path) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new LdtkFormatError(source, path, `expected a finite number, got ${describeValue(value)}`);
+	return value;
+};
+const expectInteger = (value, source, path) => {
+	const n = expectNumber(value, source, path);
+	if (!Number.isInteger(n)) throw new LdtkFormatError(source, path, `expected an integer, got ${n}`);
+	return n;
+};
+const expectNonNegativeInteger = (value, source, path) => {
+	const n = expectInteger(value, source, path);
+	if (n < 0) throw new LdtkFormatError(source, path, `expected a non-negative integer, got ${n}`);
+	return n;
+};
+const expectPositiveInteger = (value, source, path) => {
+	const n = expectInteger(value, source, path);
+	if (n <= 0) throw new LdtkFormatError(source, path, `expected a positive integer, got ${n}`);
+	return n;
+};
+const expectBoolean = (value, source, path) => {
+	if (typeof value !== "boolean") throw new LdtkFormatError(source, path, `expected a boolean, got ${describeValue(value)}`);
+};
+/** `[x, y]` pixel/grid pairs (`px`, `src`, `__pivot`) are always two finite numbers. */
+const expectNumberPair = (value, source, path) => {
+	const pair = expectArray(value, source, path);
+	if (pair.length !== 2) throw new LdtkFormatError(source, path, `expected a pair of numbers, got ${pair.length} entries`);
+	expectNumber(pair[0], source, joinPath(path, 0));
+	expectNumber(pair[1], source, joinPath(path, 1));
+};
+const optionalNumber = (obj, key, source, path) => {
+	if (obj[key] !== void 0) expectNumber(obj[key], source, joinPath(path, key));
+};
+const optionalNonNegativeInteger = (obj, key, source, path) => {
+	if (obj[key] !== void 0) expectNonNegativeInteger(obj[key], source, joinPath(path, key));
+};
+/**
+* LDtk writes an unset optional as an explicit `null` rather than omitting the
+* key, so a validator that only tolerates `undefined` rejects the files the
+* editor actually produces.
+*/
+const nullableString = (obj, key, source, path) => {
+	if (obj[key] !== void 0 && obj[key] !== null) expectString(obj[key], source, joinPath(path, key));
+};
+/** See {@link nullableString}. */
+const nullableInteger = (obj, key, source, path) => {
+	if (obj[key] !== void 0 && obj[key] !== null) expectInteger(obj[key], source, joinPath(path, key));
+};
+const optionalBoolean = (obj, key, source, path) => {
+	if (obj[key] !== void 0) expectBoolean(obj[key], source, joinPath(path, key));
+};
+const eachEntry = (value, source, path, visit) => {
+	const array = expectArray(value, source, path);
+	for (let i = 0; i < array.length; i++) visit(array[i], joinPath(path, i));
+};
+const LAYER_TYPES = [
+	"Tiles",
+	"IntGrid",
+	"Entities",
+	"AutoLayer"
+];
+const WORLD_LAYOUTS = [
+	"Free",
+	"GridVania",
+	"LinearHorizontal",
+	"LinearVertical"
+];
+const validateLayerType = (value, source, path) => {
+	const type = expectString(value, source, path);
+	if (!LAYER_TYPES.includes(type)) throw new LdtkFormatError(source, path, `unknown layer type "${type}" (expected one of ${LAYER_TYPES.join(", ")})`);
+};
+const validateTilesetDef = (raw, source, path) => {
+	const def = expectObject(raw, source, path);
+	expectInteger(def.uid, source, joinPath(path, "uid"));
+	expectString(def.identifier, source, joinPath(path, "identifier"));
+	const relPathPath = joinPath(path, "relPath");
+	if (def.relPath !== null) expectString(def.relPath, source, relPathPath);
+	expectPositiveInteger(def.tileGridSize, source, joinPath(path, "tileGridSize"));
+	expectNonNegativeInteger(def.pxWid, source, joinPath(path, "pxWid"));
+	expectNonNegativeInteger(def.pxHei, source, joinPath(path, "pxHei"));
+	optionalNonNegativeInteger(def, "spacing", source, path);
+	optionalNonNegativeInteger(def, "padding", source, path);
+};
+const validateIntGridValueDef = (raw, source, path) => {
+	const value = expectObject(raw, source, path);
+	expectNumber(value.value, source, joinPath(path, "value"));
+	const identifierPath = joinPath(path, "identifier");
+	if (value.identifier !== null) expectString(value.identifier, source, identifierPath);
+	expectString(value.color, source, joinPath(path, "color"));
+};
+const validateLayerDef = (raw, source, path) => {
+	const def = expectObject(raw, source, path);
+	expectInteger(def.uid, source, joinPath(path, "uid"));
+	expectString(def.identifier, source, joinPath(path, "identifier"));
+	validateLayerType(def.type, source, joinPath(path, "type"));
+	expectNonNegativeInteger(def.gridSize, source, joinPath(path, "gridSize"));
+	optionalNumber(def, "pxOffsetX", source, path);
+	optionalNumber(def, "pxOffsetY", source, path);
+	optionalNumber(def, "parallaxFactorX", source, path);
+	optionalNumber(def, "parallaxFactorY", source, path);
+	optionalBoolean(def, "parallaxScaling", source, path);
+	if (def.intGridValues !== void 0) eachEntry(def.intGridValues, source, joinPath(path, "intGridValues"), (item, itemPath) => validateIntGridValueDef(item, source, itemPath));
+};
+const validateDefs = (raw, source, path) => {
+	const defs = expectObject(raw, source, path);
+	eachEntry(defs.tilesets, source, joinPath(path, "tilesets"), (item, itemPath) => validateTilesetDef(item, source, itemPath));
+	eachEntry(defs.layers, source, joinPath(path, "layers"), (item, itemPath) => validateLayerDef(item, source, itemPath));
+};
+/**
+* Validate one field-instance `__value` against the shape its `__type` declares.
+*
+* `null` is LDtk's "not set" and always passes - the conversion drops the
+* property. Everything else is checked here because the conversion pass casts
+* rather than probes: a `Point` whose value is not `{cx, cy}` used to reach the
+* runtime as a point with `undefined` coordinates, indistinguishable from a
+* genuine one until something read it.
+*
+* A `__type` this package does not model (a future LDtk field type, or an
+* `Array<T>` element type of one) is left unchecked: forward compatibility
+* matters more than rejecting a value the conversion already skips.
+*/
+const validateFieldValue = (typeName, value, source, path) => {
+	if (value === null || value === void 0) return;
+	switch (typeName) {
+		case "Int":
+			expectInteger(value, source, path);
+			return;
+		case "Float":
+			expectNumber(value, source, path);
+			return;
+		case "Bool":
+			expectBoolean(value, source, path);
+			return;
+		case "String":
+		case "Multilines":
+		case "Color":
+		case "FilePath":
+		case "Enum":
+			expectString(value, source, path);
+			return;
+		case "Point": {
+			const point = expectObject(value, source, path);
+			expectNumber(point.cx, source, joinPath(path, "cx"));
+			expectNumber(point.cy, source, joinPath(path, "cy"));
+			return;
+		}
+		case "EntityRef": {
+			const ref = expectObject(value, source, path);
+			for (const key of [
+				"entityIid",
+				"layerIid",
+				"levelIid",
+				"worldIid"
+			]) expectString(ref[key], source, joinPath(path, key));
+			return;
+		}
+		case "Tile": {
+			const tile = expectObject(value, source, path);
+			expectInteger(tile.tilesetUid, source, joinPath(path, "tilesetUid"));
+			for (const key of [
+				"x",
+				"y",
+				"w",
+				"h"
+			]) expectNumber(tile[key], source, joinPath(path, key));
+			return;
+		}
+		default: if (typeName.startsWith("Array<") && typeName.endsWith(">")) {
+			const elementType = typeName.slice(6, -1);
+			eachEntry(value, source, path, (item, itemPath) => validateFieldValue(elementType, item, source, itemPath));
+		}
+	}
+};
+/**
+* A field instance is validated down to its identifier, declared type and the
+* shape of `__value` that type implies - see {@link validateFieldValue}.
+*/
+const validateFieldInstance = (raw, source, path) => {
+	const field = expectObject(raw, source, path);
+	expectString(field.__identifier, source, joinPath(path, "__identifier"));
+	const typeName = expectString(field.__type, source, joinPath(path, "__type"));
+	validateFieldValue(typeName, field.__value, source, joinPath(path, "__value"));
+};
+const validateFieldInstances = (value, source, path) => {
+	eachEntry(value, source, path, (item, itemPath) => validateFieldInstance(item, source, itemPath));
+};
+const validateTile = (raw, source, path) => {
+	const tile = expectObject(raw, source, path);
+	expectNumberPair(tile.px, source, joinPath(path, "px"));
+	expectNumberPair(tile.src, source, joinPath(path, "src"));
+	expectNumber(tile.f, source, joinPath(path, "f"));
+	expectNumber(tile.t, source, joinPath(path, "t"));
+};
+const validateTiles = (value, source, path) => {
+	eachEntry(value, source, path, (item, itemPath) => validateTile(item, source, itemPath));
+};
+const validateEntityInstance = (raw, source, path) => {
+	const entity = expectObject(raw, source, path);
+	expectString(entity.__identifier, source, joinPath(path, "__identifier"));
+	expectString(entity.__type, source, joinPath(path, "__type"));
+	expectNumberPair(entity.px, source, joinPath(path, "px"));
+	expectNumber(entity.width, source, joinPath(path, "width"));
+	expectNumber(entity.height, source, joinPath(path, "height"));
+	expectNumberPair(entity.__pivot, source, joinPath(path, "__pivot"));
+	expectString(entity.iid, source, joinPath(path, "iid"));
+	expectInteger(entity.defUid, source, joinPath(path, "defUid"));
+	validateFieldInstances(entity.fieldInstances, source, joinPath(path, "fieldInstances"));
+};
+const validateLayerInstance = (raw, source, path) => {
+	const layer = expectObject(raw, source, path);
+	expectString(layer.__identifier, source, joinPath(path, "__identifier"));
+	validateLayerType(layer.__type, source, joinPath(path, "__type"));
+	expectNonNegativeInteger(layer.__cWid, source, joinPath(path, "__cWid"));
+	expectNonNegativeInteger(layer.__cHei, source, joinPath(path, "__cHei"));
+	expectNonNegativeInteger(layer.__gridSize, source, joinPath(path, "__gridSize"));
+	expectInteger(layer.layerDefUid, source, joinPath(path, "layerDefUid"));
+	expectInteger(layer.levelId, source, joinPath(path, "levelId"));
+	expectBoolean(layer.visible, source, joinPath(path, "visible"));
+	expectString(layer.iid, source, joinPath(path, "iid"));
+	nullableInteger(layer, "__tilesetDefUid", source, path);
+	if (layer.gridTiles !== void 0) validateTiles(layer.gridTiles, source, joinPath(path, "gridTiles"));
+	if (layer.autoLayerTiles !== void 0) validateTiles(layer.autoLayerTiles, source, joinPath(path, "autoLayerTiles"));
+	if (layer.entityInstances !== void 0) eachEntry(layer.entityInstances, source, joinPath(path, "entityInstances"), (item, itemPath) => validateEntityInstance(item, source, itemPath));
+	if (layer.intGridCsv !== void 0) eachEntry(layer.intGridCsv, source, joinPath(path, "intGridCsv"), (item, itemPath) => expectNumber(item, source, itemPath));
+	optionalNumber(layer, "pxOffsetX", source, path);
+	optionalNumber(layer, "pxOffsetY", source, path);
+	optionalNumber(layer, "opacity", source, path);
+};
+const validateLevel = (raw, source, path) => {
+	const level = expectObject(raw, source, path);
+	expectString(level.identifier, source, joinPath(path, "identifier"));
+	expectInteger(level.uid, source, joinPath(path, "uid"));
+	expectString(level.iid, source, joinPath(path, "iid"));
+	expectNumber(level.worldX, source, joinPath(path, "worldX"));
+	expectNumber(level.worldY, source, joinPath(path, "worldY"));
+	expectNumber(level.pxWid, source, joinPath(path, "pxWid"));
+	expectNumber(level.pxHei, source, joinPath(path, "pxHei"));
+	nullableString(level, "externalRelPath", source, path);
+	if (level.__neighbours !== void 0 && level.__neighbours !== null) eachEntry(level.__neighbours, source, joinPath(path, "__neighbours"), (item, itemPath) => {
+		const neighbour = expectObject(item, source, itemPath);
+		expectString(neighbour.levelIid, source, joinPath(itemPath, "levelIid"));
+		expectString(neighbour.dir, source, joinPath(itemPath, "dir"));
+	});
+	if (level.fieldInstances !== void 0) validateFieldInstances(level.fieldInstances, source, joinPath(path, "fieldInstances"));
+	const layerInstancesPath = joinPath(path, "layerInstances");
+	if (level.layerInstances !== null) eachEntry(level.layerInstances, source, layerInstancesPath, (item, itemPath) => validateLayerInstance(item, source, itemPath));
+};
+const validateWorld = (raw, source, path) => {
+	const world = expectObject(raw, source, path);
+	expectString(world.identifier, source, joinPath(path, "identifier"));
+	expectString(world.iid, source, joinPath(path, "iid"));
+	expectNumber(world.worldGridWidth, source, joinPath(path, "worldGridWidth"));
+	expectNumber(world.worldGridHeight, source, joinPath(path, "worldGridHeight"));
+	const layoutPath = joinPath(path, "worldLayout");
+	if (world.worldLayout !== null) {
+		const layout = expectString(world.worldLayout, source, layoutPath);
+		if (!WORLD_LAYOUTS.includes(layout)) throw new LdtkFormatError(source, layoutPath, `unknown world layout "${layout}" (expected one of ${WORLD_LAYOUTS.join(", ")} or null)`);
+	}
+	eachEntry(world.levels, source, joinPath(path, "levels"), (item, itemPath) => validateLevel(item, source, itemPath));
+};
+/**
+* Validate the root of a `.ldtk` file and return it typed as {@link LdtkData}.
+* Throws {@link LdtkFormatError} on any structural problem, naming the source
+* URL and the property path of the offending value.
+* @internal
+*/
+const validateLdtkData = (raw, source) => {
+	const root = expectObject(raw, source, "");
+	expectString(root.jsonVersion, source, "jsonVersion");
+	optionalNumber(root, "defaultGridSize", source, "");
+	validateDefs(root.defs, source, "defs");
+	eachEntry(root.levels, source, "levels", (item, itemPath) => validateLevel(item, source, itemPath));
+	if (root.worlds !== void 0) eachEntry(root.worlds, source, "worlds", (item, itemPath) => validateWorld(item, source, itemPath));
+	return raw;
+};
+/**
+* Validate an external `.ldtkl` payload and return it typed as
+* {@link LdtkLevel}. Paths in a thrown {@link LdtkFormatError} are relative to
+* the level object, since that object is the root of the `.ldtkl` file.
+* @internal
+*/
+const validateLdtkLevelData = (raw, source) => {
+	validateLevel(raw, source, "");
+	return raw;
+};
+
+//#endregion
+export { LdtkFormatError, validateLdtkData, validateLdtkLevelData };
+//# sourceMappingURL=validate.js.map

package/dist/esm/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","names":[],"sources":["../../src/validate.ts"],"sourcesContent":["// Runtime validation for LDtk JSON (`.ldtk` / `.ldtkl`) documents. Both entry\n// points take `unknown` (the result of `JSON.parse`) and either return the same\n// value typed as `LdtkData` / `LdtkLevel`, or throw an {@link LdtkFormatError}\n// carrying the source URL and a JSON-path-like pointer to the offending value.\n//\n// Deliberately leaner than the Tiled adapter's `validate.ts`: it checks the\n// fields declared as required by this package's `LdtkData` model plus the\n// optional ones the adapter actually reads, and nothing else. Field-instance\n// `__value`s are checked against the shape their `__type` declares, because the\n// conversion pass casts rather than probes; a `__type` this package does not\n// model is left alone so a future LDtk field type still loads.\n//\n// Unlike the Tiled validator, this one asserts in place and hands the caller\n// back the very object it was given rather than rebuilding a normalised copy.\n// That keeps `LdtkMap.data` byte-for-byte what LDtk wrote, matching the\n// \"unknown fields are not stripped at parse time\" contract documented on\n// `LdtkData`.\n\nimport type { LdtkData, LdtkLayerType, LdtkLevel, LdtkWorldLayout } from './LdtkData';\n\n/**\n * Thrown when an LDtk JSON document does not match the expected shape.\n * `source` is the URL of the file being parsed; `path` is a JSON-path-like\n * pointer (e.g. `levels[0].layerInstances[1].gridTiles[0].px`) to the\n * offending value, or `''` for the document root.\n */\nexport class LdtkFormatError extends Error {\n  public readonly source: string;\n  public readonly path: string;\n\n  public constructor(source: string, path: string, message: string) {\n    super(`Invalid LDtk data in \"${source}\" at ${path === '' ? '<root>' : path}: ${message}`);\n    this.name = 'LdtkFormatError';\n    this.source = source;\n    this.path = path;\n  }\n}\n\n// ── Primitive helpers ────────────────────────────────────────────────────────\n\nconst describeValue = (value: unknown): string => {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n  if (Array.isArray(value)) return 'an array';\n  return typeof value;\n};\n\nconst joinPath = (path: string, key: string | number): string => {\n  if (typeof key === 'number') return `${path}[${key}]`;\n  return path === '' ? key : `${path}.${key}`;\n};\n\nconst expectObject = (value: unknown, source: string, path: string): Record<string, unknown> => {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new LdtkFormatError(source, path, `expected an object, got ${describeValue(value)}`);\n  }\n  return value as Record<string, unknown>;\n};\n\nconst expectArray = (value: unknown, source: string, path: string): readonly unknown[] => {\n  if (!Array.isArray(value)) {\n    throw new LdtkFormatError(source, path, `expected an array, got ${describeValue(value)}`);\n  }\n  return value as readonly unknown[];\n};\n\nconst expectString = (value: unknown, source: string, path: string): string => {\n  if (typeof value !== 'string') {\n    throw new LdtkFormatError(source, path, `expected a string, got ${describeValue(value)}`);\n  }\n  return value;\n};\n\nconst expectNumber = (value: unknown, source: string, path: string): number => {\n  if (typeof value !== 'number' || !Number.isFinite(value)) {\n    throw new LdtkFormatError(source, path, `expected a finite number, got ${describeValue(value)}`);\n  }\n  return value;\n};\n\nconst expectInteger = (value: unknown, source: string, path: string): number => {\n  const n = expectNumber(value, source, path);\n  if (!Number.isInteger(n)) {\n    throw new LdtkFormatError(source, path, `expected an integer, got ${n}`);\n  }\n  return n;\n};\n\nconst expectNonNegativeInteger = (value: unknown, source: string, path: string): number => {\n  const n = expectInteger(value, source, path);\n  if (n < 0) {\n    throw new LdtkFormatError(source, path, `expected a non-negative integer, got ${n}`);\n  }\n  return n;\n};\n\nconst expectPositiveInteger = (value: unknown, source: string, path: string): number => {\n  const n = expectInteger(value, source, path);\n  if (n <= 0) {\n    throw new LdtkFormatError(source, path, `expected a positive integer, got ${n}`);\n  }\n  return n;\n};\n\nconst expectBoolean = (value: unknown, source: string, path: string): void => {\n  if (typeof value !== 'boolean') {\n    throw new LdtkFormatError(source, path, `expected a boolean, got ${describeValue(value)}`);\n  }\n};\n\n/** `[x, y]` pixel/grid pairs (`px`, `src`, `__pivot`) are always two finite numbers. */\nconst expectNumberPair = (value: unknown, source: string, path: string): void => {\n  const pair = expectArray(value, source, path);\n  if (pair.length !== 2) {\n    throw new LdtkFormatError(source, path, `expected a pair of numbers, got ${pair.length} entries`);\n  }\n  expectNumber(pair[0], source, joinPath(path, 0));\n  expectNumber(pair[1], source, joinPath(path, 1));\n};\n\nconst optionalNumber = (obj: Record<string, unknown>, key: string, source: string, path: string): void => {\n  if (obj[key] !== undefined) expectNumber(obj[key], source, joinPath(path, key));\n};\n\nconst optionalNonNegativeInteger = (obj: Record<string, unknown>, key: string, source: string, path: string): void => {\n  if (obj[key] !== undefined) expectNonNegativeInteger(obj[key], source, joinPath(path, key));\n};\n\n/**\n * LDtk writes an unset optional as an explicit `null` rather than omitting the\n * key, so a validator that only tolerates `undefined` rejects the files the\n * editor actually produces.\n */\nconst nullableString = (obj: Record<string, unknown>, key: string, source: string, path: string): void => {\n  if (obj[key] !== undefined && obj[key] !== null) expectString(obj[key], source, joinPath(path, key));\n};\n\n/** See {@link nullableString}. */\nconst nullableInteger = (obj: Record<string, unknown>, key: string, source: string, path: string): void => {\n  if (obj[key] !== undefined && obj[key] !== null) expectInteger(obj[key], source, joinPath(path, key));\n};\n\nconst optionalBoolean = (obj: Record<string, unknown>, key: string, source: string, path: string): void => {\n  if (obj[key] !== undefined) expectBoolean(obj[key], source, joinPath(path, key));\n};\n\nconst eachEntry = (value: unknown, source: string, path: string, visit: (item: unknown, itemPath: string) => void): void => {\n  const array = expectArray(value, source, path);\n  for (let i = 0; i < array.length; i++) {\n    visit(array[i], joinPath(path, i));\n  }\n};\n\n// ── Definitions ──────────────────────────────────────────────────────────────\n\nconst LAYER_TYPES: readonly LdtkLayerType[] = ['Tiles', 'IntGrid', 'Entities', 'AutoLayer'];\nconst WORLD_LAYOUTS: readonly LdtkWorldLayout[] = ['Free', 'GridVania', 'LinearHorizontal', 'LinearVertical'];\n\nconst validateLayerType = (value: unknown, source: string, path: string): void => {\n  const type = expectString(value, source, path);\n  if (!LAYER_TYPES.includes(type as LdtkLayerType)) {\n    throw new LdtkFormatError(source, path, `unknown layer type \"${type}\" (expected one of ${LAYER_TYPES.join(', ')})`);\n  }\n};\n\nconst validateTilesetDef = (raw: unknown, source: string, path: string): void => {\n  const def = expectObject(raw, source, path);\n\n  expectInteger(def.uid, source, joinPath(path, 'uid'));\n  expectString(def.identifier, source, joinPath(path, 'identifier'));\n\n  // `relPath` is null for an embedded (\"embed atlas\") tileset, which the loader\n  // skips - anything other than a string or null is malformed.\n  const relPathPath = joinPath(path, 'relPath');\n  if (def.relPath !== null) expectString(def.relPath, source, relPathPath);\n\n  // A zero or negative grid size would make the loader's column arithmetic\n  // divide by zero and yield a non-finite tile count.\n  expectPositiveInteger(def.tileGridSize, source, joinPath(path, 'tileGridSize'));\n  expectNonNegativeInteger(def.pxWid, source, joinPath(path, 'pxWid'));\n  expectNonNegativeInteger(def.pxHei, source, joinPath(path, 'pxHei'));\n  optionalNonNegativeInteger(def, 'spacing', source, path);\n  optionalNonNegativeInteger(def, 'padding', source, path);\n};\n\nconst validateIntGridValueDef = (raw: unknown, source: string, path: string): void => {\n  const value = expectObject(raw, source, path);\n\n  expectNumber(value.value, source, joinPath(path, 'value'));\n  const identifierPath = joinPath(path, 'identifier');\n  if (value.identifier !== null) expectString(value.identifier, source, identifierPath);\n  expectString(value.color, source, joinPath(path, 'color'));\n};\n\nconst validateLayerDef = (raw: unknown, source: string, path: string): void => {\n  const def = expectObject(raw, source, path);\n\n  expectInteger(def.uid, source, joinPath(path, 'uid'));\n  expectString(def.identifier, source, joinPath(path, 'identifier'));\n  validateLayerType(def.type, source, joinPath(path, 'type'));\n  expectNonNegativeInteger(def.gridSize, source, joinPath(path, 'gridSize'));\n  optionalNumber(def, 'pxOffsetX', source, path);\n  optionalNumber(def, 'pxOffsetY', source, path);\n  optionalNumber(def, 'parallaxFactorX', source, path);\n  optionalNumber(def, 'parallaxFactorY', source, path);\n  optionalBoolean(def, 'parallaxScaling', source, path);\n\n  if (def.intGridValues !== undefined) {\n    eachEntry(def.intGridValues, source, joinPath(path, 'intGridValues'), (item, itemPath) => validateIntGridValueDef(item, source, itemPath));\n  }\n};\n\nconst validateDefs = (raw: unknown, source: string, path: string): void => {\n  const defs = expectObject(raw, source, path);\n\n  eachEntry(defs.tilesets, source, joinPath(path, 'tilesets'), (item, itemPath) => validateTilesetDef(item, source, itemPath));\n  eachEntry(defs.layers, source, joinPath(path, 'layers'), (item, itemPath) => validateLayerDef(item, source, itemPath));\n};\n\n// ── Instances ────────────────────────────────────────────────────────────────\n\n/**\n * Validate one field-instance `__value` against the shape its `__type` declares.\n *\n * `null` is LDtk's \"not set\" and always passes - the conversion drops the\n * property. Everything else is checked here because the conversion pass casts\n * rather than probes: a `Point` whose value is not `{cx, cy}` used to reach the\n * runtime as a point with `undefined` coordinates, indistinguishable from a\n * genuine one until something read it.\n *\n * A `__type` this package does not model (a future LDtk field type, or an\n * `Array<T>` element type of one) is left unchecked: forward compatibility\n * matters more than rejecting a value the conversion already skips.\n */\nconst validateFieldValue = (typeName: string, value: unknown, source: string, path: string): void => {\n  if (value === null || value === undefined) return;\n\n  switch (typeName) {\n    case 'Int':\n      expectInteger(value, source, path);\n      return;\n\n    case 'Float':\n      expectNumber(value, source, path);\n      return;\n\n    case 'Bool':\n      expectBoolean(value, source, path);\n      return;\n\n    case 'String':\n    case 'Multilines':\n    case 'Color':\n    case 'FilePath':\n    case 'Enum':\n      expectString(value, source, path);\n      return;\n\n    case 'Point': {\n      const point = expectObject(value, source, path);\n\n      expectNumber(point.cx, source, joinPath(path, 'cx'));\n      expectNumber(point.cy, source, joinPath(path, 'cy'));\n\n      return;\n    }\n\n    case 'EntityRef': {\n      const ref = expectObject(value, source, path);\n\n      for (const key of ['entityIid', 'layerIid', 'levelIid', 'worldIid'] as const) {\n        expectString(ref[key], source, joinPath(path, key));\n      }\n\n      return;\n    }\n\n    case 'Tile': {\n      const tile = expectObject(value, source, path);\n\n      expectInteger(tile.tilesetUid, source, joinPath(path, 'tilesetUid'));\n\n      for (const key of ['x', 'y', 'w', 'h'] as const) {\n        expectNumber(tile[key], source, joinPath(path, key));\n      }\n\n      return;\n    }\n\n    default:\n      if (typeName.startsWith('Array<') && typeName.endsWith('>')) {\n        const elementType = typeName.slice('Array<'.length, -1);\n\n        eachEntry(value, source, path, (item, itemPath) => validateFieldValue(elementType, item, source, itemPath));\n      }\n  }\n};\n\n/**\n * A field instance is validated down to its identifier, declared type and the\n * shape of `__value` that type implies - see {@link validateFieldValue}.\n */\nconst validateFieldInstance = (raw: unknown, source: string, path: string): void => {\n  const field = expectObject(raw, source, path);\n\n  expectString(field.__identifier, source, joinPath(path, '__identifier'));\n\n  const typeName = expectString(field.__type, source, joinPath(path, '__type'));\n\n  validateFieldValue(typeName, field.__value, source, joinPath(path, '__value'));\n};\n\nconst validateFieldInstances = (value: unknown, source: string, path: string): void => {\n  eachEntry(value, source, path, (item, itemPath) => validateFieldInstance(item, source, itemPath));\n};\n\nconst validateTile = (raw: unknown, source: string, path: string): void => {\n  const tile = expectObject(raw, source, path);\n\n  expectNumberPair(tile.px, source, joinPath(path, 'px'));\n  expectNumberPair(tile.src, source, joinPath(path, 'src'));\n  expectNumber(tile.f, source, joinPath(path, 'f'));\n  expectNumber(tile.t, source, joinPath(path, 't'));\n};\n\nconst validateTiles = (value: unknown, source: string, path: string): void => {\n  eachEntry(value, source, path, (item, itemPath) => validateTile(item, source, itemPath));\n};\n\nconst validateEntityInstance = (raw: unknown, source: string, path: string): void => {\n  const entity = expectObject(raw, source, path);\n\n  expectString(entity.__identifier, source, joinPath(path, '__identifier'));\n  expectString(entity.__type, source, joinPath(path, '__type'));\n  expectNumberPair(entity.px, source, joinPath(path, 'px'));\n  expectNumber(entity.width, source, joinPath(path, 'width'));\n  expectNumber(entity.height, source, joinPath(path, 'height'));\n  expectNumberPair(entity.__pivot, source, joinPath(path, '__pivot'));\n  expectString(entity.iid, source, joinPath(path, 'iid'));\n  expectInteger(entity.defUid, source, joinPath(path, 'defUid'));\n  validateFieldInstances(entity.fieldInstances, source, joinPath(path, 'fieldInstances'));\n};\n\nconst validateLayerInstance = (raw: unknown, source: string, path: string): void => {\n  const layer = expectObject(raw, source, path);\n\n  expectString(layer.__identifier, source, joinPath(path, '__identifier'));\n  validateLayerType(layer.__type, source, joinPath(path, '__type'));\n  expectNonNegativeInteger(layer.__cWid, source, joinPath(path, '__cWid'));\n  expectNonNegativeInteger(layer.__cHei, source, joinPath(path, '__cHei'));\n  expectNonNegativeInteger(layer.__gridSize, source, joinPath(path, '__gridSize'));\n  expectInteger(layer.layerDefUid, source, joinPath(path, 'layerDefUid'));\n  expectInteger(layer.levelId, source, joinPath(path, 'levelId'));\n  expectBoolean(layer.visible, source, joinPath(path, 'visible'));\n  expectString(layer.iid, source, joinPath(path, 'iid'));\n\n  nullableInteger(layer, '__tilesetDefUid', source, path);\n  if (layer.gridTiles !== undefined) {\n    validateTiles(layer.gridTiles, source, joinPath(path, 'gridTiles'));\n  }\n  if (layer.autoLayerTiles !== undefined) {\n    validateTiles(layer.autoLayerTiles, source, joinPath(path, 'autoLayerTiles'));\n  }\n  if (layer.entityInstances !== undefined) {\n    eachEntry(layer.entityInstances, source, joinPath(path, 'entityInstances'), (item, itemPath) => validateEntityInstance(item, source, itemPath));\n  }\n  if (layer.intGridCsv !== undefined) {\n    eachEntry(layer.intGridCsv, source, joinPath(path, 'intGridCsv'), (item, itemPath) => expectNumber(item, source, itemPath));\n  }\n  optionalNumber(layer, 'pxOffsetX', source, path);\n  optionalNumber(layer, 'pxOffsetY', source, path);\n  optionalNumber(layer, 'opacity', source, path);\n};\n\nconst validateLevel = (raw: unknown, source: string, path: string): void => {\n  const level = expectObject(raw, source, path);\n\n  expectString(level.identifier, source, joinPath(path, 'identifier'));\n  expectInteger(level.uid, source, joinPath(path, 'uid'));\n  expectString(level.iid, source, joinPath(path, 'iid'));\n  expectNumber(level.worldX, source, joinPath(path, 'worldX'));\n  expectNumber(level.worldY, source, joinPath(path, 'worldY'));\n  expectNumber(level.pxWid, source, joinPath(path, 'pxWid'));\n  expectNumber(level.pxHei, source, joinPath(path, 'pxHei'));\n  nullableString(level, 'externalRelPath', source, path);\n\n  // Same explicit-null rule as the fields above: an isolated level can arrive\n  // with a null here rather than an empty array.\n  if (level.__neighbours !== undefined && level.__neighbours !== null) {\n    eachEntry(level.__neighbours, source, joinPath(path, '__neighbours'), (item, itemPath) => {\n      const neighbour = expectObject(item, source, itemPath);\n      expectString(neighbour.levelIid, source, joinPath(itemPath, 'levelIid'));\n      expectString(neighbour.dir, source, joinPath(itemPath, 'dir'));\n    });\n  }\n\n  if (level.fieldInstances !== undefined) {\n    validateFieldInstances(level.fieldInstances, source, joinPath(path, 'fieldInstances'));\n  }\n\n  // `null` marks a level whose layers live in a separate `.ldtkl` file; the\n  // loader resolves those before conversion.\n  const layerInstancesPath = joinPath(path, 'layerInstances');\n  if (level.layerInstances !== null) {\n    eachEntry(level.layerInstances, source, layerInstancesPath, (item, itemPath) => validateLayerInstance(item, source, itemPath));\n  }\n};\n\nconst validateWorld = (raw: unknown, source: string, path: string): void => {\n  const world = expectObject(raw, source, path);\n\n  expectString(world.identifier, source, joinPath(path, 'identifier'));\n  expectString(world.iid, source, joinPath(path, 'iid'));\n  expectNumber(world.worldGridWidth, source, joinPath(path, 'worldGridWidth'));\n  expectNumber(world.worldGridHeight, source, joinPath(path, 'worldGridHeight'));\n\n  const layoutPath = joinPath(path, 'worldLayout');\n  if (world.worldLayout !== null) {\n    const layout = expectString(world.worldLayout, source, layoutPath);\n    if (!WORLD_LAYOUTS.includes(layout as LdtkWorldLayout)) {\n      throw new LdtkFormatError(source, layoutPath, `unknown world layout \"${layout}\" (expected one of ${WORLD_LAYOUTS.join(', ')} or null)`);\n    }\n  }\n\n  eachEntry(world.levels, source, joinPath(path, 'levels'), (item, itemPath) => validateLevel(item, source, itemPath));\n};\n\n// ── Entry points ─────────────────────────────────────────────────────────────\n\n/**\n * Validate the root of a `.ldtk` file and return it typed as {@link LdtkData}.\n * Throws {@link LdtkFormatError} on any structural problem, naming the source\n * URL and the property path of the offending value.\n * @internal\n */\nexport const validateLdtkData = (raw: unknown, source: string): LdtkData => {\n  const root = expectObject(raw, source, '');\n\n  expectString(root.jsonVersion, source, 'jsonVersion');\n  optionalNumber(root, 'defaultGridSize', source, '');\n  validateDefs(root.defs, source, 'defs');\n\n  // Both root shapes carry `levels`: it holds every level in a single-world\n  // document and is present-but-empty once `worlds[]` is used.\n  eachEntry(root.levels, source, 'levels', (item, itemPath) => validateLevel(item, source, itemPath));\n\n  if (root.worlds !== undefined) {\n    eachEntry(root.worlds, source, 'worlds', (item, itemPath) => validateWorld(item, source, itemPath));\n  }\n\n  return raw as LdtkData;\n};\n\n/**\n * Validate an external `.ldtkl` payload and return it typed as\n * {@link LdtkLevel}. Paths in a thrown {@link LdtkFormatError} are relative to\n * the level object, since that object is the root of the `.ldtkl` file.\n * @internal\n */\nexport const validateLdtkLevelData = (raw: unknown, source: string): LdtkLevel => {\n  validateLevel(raw, source, '');\n\n  return raw as LdtkLevel;\n};\n"],"mappings":"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"}