@canvasengine/tiled 2.0.0-beta.25

package/tests/parser.spec.ts

@@ -0,0 +1,112 @@
+import { TiledParser } from '../src/parser/parser'
+import { TiledLayerType } from '../src/types/Layer'
+import { xml, xmlDeepProperties, xmlGroup, xmlImage, xmlObject, xmlProperties, xmlText, xmlTile } from './data'
+import { test, expect } from 'vitest'
+
+test('propToNumber() method', () => {
+    const ret = TiledParser.propToNumber({
+        test: '1',
+        other: '2'
+    }, ['test'])
+    expect(ret.test).toBe(1)
+    expect(ret.other).toBe('2')
+})
+
+test('propToBool() method', () => {
+    const ret = TiledParser.propToBool({
+        test: 'true',
+        other: 'false',
+        foo: 'false'
+    }, ['test', 'other'])
+    expect(ret.test).toBe(true)
+    expect(ret.other).toBe(false)
+    expect(ret.foo).toBe('false')
+})
+
+test('toArray() method', () => {
+    const ret = TiledParser.toArray({ test: 1 })
+    expect(ret).toMatchObject([ { test: 1 }])
+})
+
+test('parseMap() method', () => {
+   const parser = new TiledParser(xml)
+   const map = parser.parseMap()
+   expect(map.version).toBe(1.8)
+   expect(map.width).toBe(10)
+   expect(map.layers).toHaveLength(2)
+   const layer = map.layers[0]
+   expect(layer).toHaveProperty('name', 'Tile Layer 1')
+   expect(layer).toHaveProperty('encoding', 'base64')
+   expect(layer).toHaveProperty('data')
+})
+
+test('parseMap() method - test data', () => {
+    const parser = new TiledParser(xml)
+    const map = parser.parseMap()
+    const data = map.layers[0].data
+    expect(data).toHaveLength(map.width * map.height)
+    expect(data[0]).toBe(1)
+})
+
+test('parseMap() method - test objectgroup', () => {
+    const parser = new TiledParser(xmlObject)
+    const map = parser.parseMap()
+    const layer = map.layers[1]
+    expect(layer.type).toBe(TiledLayerType.ObjectGroup)
+    expect(layer.objects).toHaveLength(1)
+    expect(layer.objects[0]).toMatchObject({ id: 1, x: 62.0593, y: 24.752, width: 19.0124, height: 20.0886 })
+})
+
+test('parseMap() method - test properties', () => {
+    const parser = new TiledParser(xmlProperties)
+    const map = parser.parseMap()
+    const layer = map.layers[1]
+    expect(layer.properties).toMatchObject({ test: 0 })
+    expect(layer.objects[0].properties).toMatchObject({ objectprop: 0 })
+})
+
+test('parseMap() method - test properties', () => {
+    const parser = new TiledParser(xmlDeepProperties)
+    const map = parser.parseMap()
+    const properties: any = map.properties
+    expect(properties.test).toHaveProperty('hp', 5)
+    expect(properties.test).toHaveProperty('mode', 'scenario')
+    expect(properties.test).toHaveProperty('_classname', 'Event')
+})
+
+test('parseMap() method - test group', () => {
+    const parser = new TiledParser(xmlGroup)
+    const map = parser.parseMap()
+    const layer = map.layers[2]
+    expect(layer.type).toBe(TiledLayerType.Group)
+    expect(layer.layers).toHaveLength(1)
+    expect(layer.properties).toMatchObject({ grouptest: 0 })
+})
+
+test('parseMap() method - test image', () => {
+    const parser = new TiledParser(xmlImage)
+    const map = parser.parseMap()
+    const layer = map.layers[1]
+    expect(layer.type).toBe(TiledLayerType.Image)
+    expect(layer).toHaveProperty('image')
+    expect(layer.image).toMatchObject({ source: 'assets/test.png', width: 1536, height: 2112 })
+})
+
+test('parseMap() method - test tileset', () => {
+    const parser = new TiledParser(xmlTile)
+    const map = parser.parseMap()
+    expect(map).toHaveProperty('tilesets')
+    expect(map.tilesets).toHaveLength(1)
+    const tileset = map.tilesets[0]
+    expect(tileset).toHaveProperty('firstgid', 1)
+    expect(tileset).toHaveProperty('source', '[Base]BaseChip_pipo.tsx')
+})
+
+test('parseMap() method - test text object', () => {
+    const parser = new TiledParser(xmlText)
+    const map = parser.parseMap()
+    const layer = map.layers[0].objects[0]
+    expect(layer).toHaveProperty('text')
+    expect(layer.text).toHaveProperty('text', 'Hello World')
+    expect(layer.text).toHaveProperty('wrap', true)
+})

package/tests/tile-properties.spec.ts

@@ -0,0 +1,99 @@
+import { test, expect } from 'vitest'
+import { TiledParser } from "../src/parser/parser"
+import { MapClass } from '../src'
+
+const xmlWithTileProperties = `<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.8" tiledversion="1.8.2" orientation="orthogonal" renderorder="right-down" width="2" height="2" tilewidth="32" tileheight="32" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" name="test" tilewidth="32" tileheight="32" tilecount="4" columns="2">
+  <image source="test.png" width="64" height="64"/>
+  <tile id="0">
+   <properties>
+    <property name="collision" type="bool" value="true"/>
+    <property name="damage" type="int" value="10"/>
+   </properties>
+  </tile>
+  <tile id="1">
+   <properties>
+    <property name="collision" type="bool" value="false"/>
+    <property name="heal" type="int" value="5"/>
+   </properties>
+  </tile>
+ </tileset>
+ <layer id="1" name="Tile Layer 1" width="2" height="2">
+  <data encoding="csv">
+1,2,
+3,4
+</data>
+ </layer>
+</map>`
+
+const tileset = `<?xml version="1.0" encoding="UTF-8"?>
+<tileset version="1.9" tiledversion="1.9.2" name="test" tilewidth="32" tileheight="32" tilecount="4" columns="2">
+ <image source="test.png" width="64" height="64"/>
+ <tile id="0">
+  <properties>
+   <property name="collision" type="bool" value="true"/>
+   <property name="damage" type="int" value="10"/>
+  </properties>
+ </tile>
+ <tile id="1">
+  <properties>
+   <property name="collision" type="bool" value="false"/>
+   <property name="heal" type="int" value="5"/>
+  </properties>
+ </tile>
+</tileset>`
+
+function getMap(xml: string): MapClass {
+    const parser = new TiledParser(xml)
+    const mapData = parser.parseMap()
+    mapData.tilesets = mapData.tilesets.map(source => {
+        const parserTileset = new TiledParser(tileset)
+        const tilesetData = parserTileset.parseTileset()
+        return {
+            ...source,
+            ...tilesetData
+        }
+    })
+    return new MapClass(mapData)
+}
+
+test('Tile properties should be preserved after creation', () => {
+    const map = getMap(xmlWithTileProperties)
+    
+    // Get tile at position (0, 0) which should be tile ID 1 (firstgid=1, so tile 0 from tileset)
+    const tileInfo = map.getTileByPosition(0, 0)
+    const [tile] = tileInfo.tiles
+    
+    expect(tile).toBeDefined()
+    expect(tile.properties).toBeDefined()
+    expect(Object.keys(tile.properties)).toHaveLength(2)
+    expect(tile.getProperty('collision')).toBe(true)
+    expect(tile.getProperty('damage')).toBe(10)
+})
+
+test('Multiple tiles should have their own properties', () => {
+    const map = getMap(xmlWithTileProperties)
+    
+    // Get tile at position (32, 0) which should be tile ID 2 (tile 1 from tileset)
+    const tileInfo = map.getTileByPosition(32, 0)
+    const [tile] = tileInfo.tiles
+    
+    expect(tile).toBeDefined()
+    expect(tile.properties).toBeDefined()
+    expect(Object.keys(tile.properties)).toHaveLength(2)
+    expect(tile.getProperty('collision')).toBe(false)
+    expect(tile.getProperty('heal')).toBe(5)
+})
+
+test('Tiles without properties should have empty properties object', () => {
+    const map = getMap(xmlWithTileProperties)
+    
+    // Get tile at position (0, 32) which should be tile ID 3 (tile 2 from tileset, no properties defined)
+    const tileInfo = map.getTileByPosition(0, 32)
+    const [tile] = tileInfo.tiles
+    
+    expect(tile).toBeDefined()
+    expect(tile.properties).toBeDefined()
+    expect(Object.keys(tile.properties)).toHaveLength(0)
+}) 

package/tests/tiledmap-multi-layers.spec.ts

@@ -0,0 +1,99 @@
+import { TiledParser } from "../src/parser/parser"
+import { tileset } from "./data"
+import { MapClass } from '../src'
+import { test, expect, describe, beforeEach } from 'vitest'
+
+const getXmlMap = (properties = '') => `<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.8" tiledversion="1.8.2" orientation="orthogonal" renderorder="right-down" width="10" height="10" tilewidth="32" tileheight="32" infinite="0" nextlayerid="5" nextobjectid="5">
+ ${properties}
+ <tileset firstgid="1" source="[Base]BaseChip_pipo.tsx"/>
+ <layer id="1" name="Tile Layer 1" width="10" height="10">
+  <data encoding="base64">
+   AQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAA==
+  </data>
+ </layer>
+ <layer id="2" name="Tile Layer 2" width="10" height="10">
+  <data encoding="base64">
+   AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+  </data>
+ </layer>
+ <layer id="3" name="Tile Layer 3" width="10" height="10">
+  <data encoding="base64">
+   AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+  </data>
+ </layer>
+</map>
+`
+
+const xml = getXmlMap()
+const xmlLowMemory = getXmlMap(`
+    <properties>
+        <property name="low-memory" value="true" type="bool"  />
+    </properties>
+`)
+
+function getMap(xml) {
+    const parser = new TiledParser(xml)
+    const mapData = parser.parseMap()
+    mapData.tilesets = mapData.tilesets.map(source => {
+        const parserTileset = new TiledParser(tileset)
+        const tilesetData = parserTileset.parseTileset()
+        return {
+            ...source,
+            ...tilesetData
+        }
+    })
+    return new MapClass(mapData)
+}
+
+test('Has 3 Layers', () => {
+    const map = getMap(xml)
+    expect(map.layers).toHaveLength(3)
+})
+
+test('Test Allocate memory Size', () => {
+    const map = getMap(xml)
+    expect(map['allocateMemory']).toBe(3)
+})
+
+describe('Get Tile In Memory', () => {
+    test('3 tiles found', () => {
+        const map = getMap(xml)
+        const { tiles } = map.getTileByIndex(44)
+        expect(tiles).toHaveLength(3)
+    })
+
+    test('3 tiles found', () => {
+        const map = getMap(xml)
+        const { tiles } = map.getTileByIndex(44)
+        expect(tiles[0].id).toBe(41)
+        expect(tiles[0].layerIndex).toBe(2)
+        expect(tiles[1].id).toBe(41)
+        expect(tiles[1].layerIndex).toBe(1)
+        expect(tiles[2].id).toBe(0)
+        expect(tiles[2].layerIndex).toBe(0)
+    })
+})
+
+describe('Memory Optimization', () => {
+    let map: MapClass
+
+    beforeEach(() => {
+        map = getMap(xmlLowMemory)
+    })
+
+    test('Test Allocate memory Size', () => {
+        expect(map['allocateMemory']).toBe(1)
+    })
+
+    test('1 tile only found', () => {
+        const { tiles } = map.getTileByIndex(44)
+        expect(tiles).toHaveLength(1)
+    })
+
+    test('1 tile only found', () => {
+        const { tiles } = map.getTileByIndex(44)
+        expect(tiles[0].id).toBe(41)
+        expect(tiles[0].layerIndex).toBe(2)
+    })
+})

package/tests/tiledmap.spec.ts

@@ -0,0 +1,223 @@
+import { TiledParser } from "../src/parser/parser"
+import { tileset, xml, xmlGroup, xmlObjectImage, xmlTile } from "./data"
+import { Tileset } from '../src/classes/Tileset'
+import { Layer, MapClass, Tile, TiledLayerType, TiledObjectClass } from '../src'
+import { test, expect, describe } from 'vitest'
+
+function getMap(xml) {
+    const parser = new TiledParser(xml)
+    const mapData = parser.parseMap()
+    mapData.tilesets = mapData.tilesets.map(source => {
+        const parserTileset = new TiledParser(tileset)
+        const tilesetData = parserTileset.parseTileset()
+        return {
+            ...source,
+            ...tilesetData
+        }
+    })
+    return new MapClass(mapData)
+}
+
+
+test('Map is loaded', () => {
+    const map = getMap(xml)
+    expect(map).toBeDefined()
+    expect(map.tilesets[0]).toBeInstanceOf(Tileset)
+    expect(map.layers[0]).toBeInstanceOf(Layer)
+})
+
+test('Map Tile Size', () => {
+    const map = getMap(xml)
+    expect(map.tileheight).toBe(32)
+    expect(map.tilewidth).toBe(32)
+})
+
+test('Layers', () => {
+    const map = getMap(xmlGroup)
+    expect(map.layers).toHaveLength(4)
+    expect(map.layers[2].type).toBe(TiledLayerType.Group)
+})
+
+test('Group Properties', () => {
+    const map = getMap(xmlGroup)
+    const layerGroup = map.layers[2]
+    const prop = layerGroup.getProperty<number>('grouptest')
+    expect(prop).toBe(0)
+})
+
+test('Layers Properties has parent', () => {
+    const map = getMap(xmlGroup)
+    const layer = map.layers[3]
+    const parent = layer.getLayerParent()
+    expect(parent).toBeInstanceOf(Layer)
+    expect(parent?.name).toBe('Group 1')
+})
+
+test('Layers Properties same properties of group parent', () => {
+    const map = getMap(xmlGroup)
+    const layerGroup = map.layers[3]
+    const prop = layerGroup.getProperty<number>('grouptest')
+    expect(prop).toBe(0)
+})
+
+test('Layers Properties same properties of group parent (incrementation z value)', () => {
+    const map = getMap(`<?xml version="1.0" encoding="UTF-8"?>
+    <map version="1.8" tiledversion="1.8.2" orientation="orthogonal" renderorder="right-down" width="10" height="10" tilewidth="32" tileheight="32" infinite="0" nextlayerid="5" nextobjectid="2">
+     <group id="3" name="Group 1">
+      <properties>
+       <property name="z" type="int" value="2"/>
+      </properties>
+      <layer id="4" name="Tile Layer 2" width="10" height="10">
+       <data encoding="base64">
+       AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+      </data>
+      <properties>
+       <property name="z" type="int" value="3"/>
+      </properties>
+      </layer>
+     </group>
+    </map>
+    `)
+    const layerGroup = map.layers[1]
+    const prop = layerGroup.getProperty<number>('z')
+    expect(prop).toBe(5)
+})
+
+test('Layers Properties same properties of group parent (erase parent value)', () => {
+    const map = getMap(`<?xml version="1.0" encoding="UTF-8"?>
+    <map version="1.8" tiledversion="1.8.2" orientation="orthogonal" renderorder="right-down" width="10" height="10" tilewidth="32" tileheight="32" infinite="0" nextlayerid="5" nextobjectid="2">
+     <group id="3" name="Group 1">
+      <properties>
+       <property name="test" type="int" value="2"/>
+      </properties>
+      <layer id="4" name="Tile Layer 2" width="10" height="10">
+       <data encoding="base64">
+       AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+      </data>
+      <properties>
+       <property name="test" type="int" value="3"/>
+      </properties>
+      </layer>
+     </group>
+    </map>
+    `)
+    const layerGroup = map.layers[1]
+    const prop = layerGroup.getProperty<number>('test')
+    expect(prop).toBe(3)
+})
+
+test('Opacity', () => {
+    const map = getMap(`<?xml version="1.0" encoding="UTF-8"?>
+    <map version="1.8" tiledversion="1.8.6" orientation="orthogonal" renderorder="right-down" width="10" height="10" tilewidth="32" tileheight="32" infinite="0" nextlayerid="14" nextobjectid="8">
+     <group id="13" name="Group 1" opacity="0.9">
+      <layer id="12" name="Tile Layer 1" width="10" height="10" opacity="0.56">
+       <data encoding="base64">
+       AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+      </data>
+      </layer>
+     </group>
+    </map>
+    
+    `)
+    const layer1 = map.layers[0]
+    const layer2 = map.layers[1]
+    expect(layer1.opacity).toBe(0.9)
+    expect(layer2.opacity).toBe(0.5)
+})
+
+describe('Test Tiles Index', () => {
+    const xmlZ = `<?xml version="1.0" encoding="UTF-8"?>
+    <map version="1.8" tiledversion="1.8.2" orientation="orthogonal" renderorder="right-down" width="10" height="10" tilewidth="32" tileheight="32" infinite="0" nextlayerid="5" nextobjectid="5">
+     <tileset firstgid="1" source="[Base]BaseChip_pipo.tsx"/>
+     <layer id="1" name="Tile Layer 1" width="10" height="10">
+      <data encoding="base64">
+       AQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAA==
+      </data>
+      <properties>
+            <property name="z" type="int" value="1"/>
+        </properties>
+     </layer>
+     <layer id="2" name="Tile Layer 2" width="10" height="10">
+      <data encoding="base64">
+       AQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAA==
+      </data>
+        <properties>
+            <property name="z" type="int" value="2"/>
+        </properties>
+     </layer>
+    </map>
+    `
+
+    test('getTileIndex()', () => {
+        const map = getMap(xml)
+        const { width } = map
+        expect(map.getTileIndex(32, 32)).toEqual(width + 1)
+    })
+
+    test('getTilePosition() #1', () => {
+        const map = getMap(xml)
+        expect(map.getTilePosition(85)).toMatchObject({
+            x: 5 * 32,
+            y: 8 * 32
+        })
+        expect(map.getTilePosition(11)).toMatchObject({
+            x: 1 * 32,
+            y: 1 * 32
+        })
+        expect(map.getTilePosition(9)).toMatchObject({
+            x: 9 * 32,
+            y: 0 * 32
+        })
+        expect(map.getTilePosition(99)).toMatchObject({
+            x: 9 * 32,
+            y: 9 * 32
+        })
+    })
+
+    test('Tiles Index', () => {
+        const map = getMap(xml)
+        const tileInfo = map.getTileByIndex(0)
+        expect(tileInfo.tiles).toHaveLength(2)
+        expect(tileInfo.hasCollision).toBe(false)
+    })
+
+    test('Tiles Index, Not found layer', () => {
+        const map = getMap(xmlZ)
+        const tileInfo = map.getTileByIndex(0)
+        expect(tileInfo.tiles).toHaveLength(0)
+        expect(tileInfo.hasCollision).toBe(false)
+    })
+
+    test('Tiles Index, Z=1', () => {
+        const map = getMap(xmlZ)
+        const tileInfo = map.getTileByIndex(0, [32, 64])
+        expect(tileInfo.tiles).toHaveLength(2)
+        expect(tileInfo.hasCollision).toBe(false)
+    })
+
+    test('Tiles Index, Z=2', () => {
+        const map = getMap(xmlZ)
+        const tileInfo = map.getTileByIndex(0, [64, 64+32])
+        expect(tileInfo.tiles).toHaveLength(2)
+        expect(tileInfo.hasCollision).toBe(false)
+    })
+
+    const xmlFlipTiled = `<?xml version="1.0" encoding="UTF-8"?>
+    <map version="1.8" tiledversion="1.8.6" orientation="orthogonal" renderorder="right-down" width="10" height="10" tilewidth="32" tileheight="32" infinite="0" nextlayerid="14" nextobjectid="8">
+     <tileset firstgid="1" source="[Base]BaseChip_pipo.tsx"/>
+     <layer id="12" name="Tile Layer 1" width="10" height="10">
+     <data encoding="base64">
+     KQAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
+    </data>
+    </layer>
+    </map>
+    `
+
+    test('Get Flip Tile', () => {
+        const map = getMap(xmlFlipTiled)
+        const tileInfo = map.getTileByIndex(0)
+        const tile = tileInfo.tiles[0]
+        expect(tile.gid).toBe(41)
+        expect(tileInfo.hasCollision).toBe(true)
+    })
+})

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+    "compilerOptions": {
+      "target": "ES2020",
+      "lib": ["dom", "esnext"],
+      "module": "ES2020",
+      "outDir": "./lib",
+      "rootDir": "./src",
+      "strict": true,
+      "sourceMap": true,
+      "strictNullChecks": true,
+      "strictPropertyInitialization": false,
+      "moduleResolution": "node",
+      "esModuleInterop": true,
+      "removeComments": false,
+      "noUnusedParameters": false,
+      "noUnusedLocals": false,
+      "noImplicitThis": false,
+      "noImplicitAny": false,
+      "noImplicitReturns": false,
+      "declaration": true,
+      "experimentalDecorators": true, 
+      "emitDecoratorMetadata": true,
+      "stripInternal": true
+    },
+    "include": [
+        "src"
+    ]
+  }

package/vite.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vite'
+import dts from 'vite-plugin-dts'
+
+export default defineConfig({
+  plugins: [
+    dts({ 
+      include: ['src/**/*.ts'],
+      outDir: 'dist'
+    })
+  ],
+  build: {
+    target: 'esnext',
+    sourcemap: true,
+    minify: false,
+    lib: {
+      entry: 'src/index.ts',
+      formats: ['es'],
+      fileName: 'index'
+    }
+  },
+})