@canvasengine/tiled 2.0.0-beta.25

package/dist/parser/open-file.d.ts

@@ -0,0 +1,24 @@
+import { TiledMap } from '../types/Map';
+type ParseOptions = {
+    getOnlyBasename?: boolean;
+};
+export declare class TiledParserFile {
+    private file;
+    private basePath;
+    constructor(file: string, { basePath, staticDir, relativePath }?: {
+        basePath?: string | undefined;
+        staticDir?: string | undefined;
+        relativePath?: string | undefined;
+    });
+    static isBrowser(): boolean;
+    static typeOfFile(file: string): {
+        isXml: boolean;
+        isObject: boolean;
+        isHttp: boolean;
+        isPath: boolean;
+    };
+    private _parseFile;
+    parseFile(cb: Function, options?: ParseOptions): void;
+    parseFilePromise(options?: ParseOptions): Promise<TiledMap>;
+}
+export {};

package/dist/parser/parser.d.ts

@@ -0,0 +1,27 @@
+import { TiledMap } from '../types/Map';
+import { TiledTileset } from '../types/Tileset';
+import { Buffer } from 'buffer';
+export declare class TiledParser {
+    private xml;
+    private filePath;
+    private basePath;
+    private layers;
+    constructor(xml: string, filePath?: string, basePath?: string);
+    static propToNumber: (obj: any, props: string[]) => any;
+    static propToBool: (obj: any, props: string[]) => any;
+    static toArray<T>(prop: any): T[];
+    getImagePath(image: string): string;
+    /**
+     * Check if the object is a tileset source reference
+     * Tileset sources should not have their paths transformed with getImagePath
+     */
+    private isTilesetSource;
+    transform: (obj: any) => any;
+    static unpackTileBytes(buffer: Buffer, size: number): number[] | never;
+    static decode(obj: {
+        encoding: string;
+        data: string;
+    }, size: number): string | number[];
+    parseMap(): TiledMap;
+    parseTileset(): TiledTileset;
+}

package/dist/types/Layer.d.ts

@@ -0,0 +1,116 @@
+import { TiledObject } from './Objects';
+import { TiledChunk, TiledCompression, TiledEncoding, TiledImage } from './Types';
+export declare enum TiledLayerType {
+    Tile = "tilelayer",
+    ObjectGroup = "objectgroup",
+    Image = "imagelayer",
+    Group = "group"
+}
+export interface TiledLayer {
+    /**
+     * Incremental ID - unique across all layers
+     */
+    id: number;
+    /**
+     * Image used by this layer. imagelayer only.
+     */
+    image: TiledImage;
+    /**
+     * Array of unsigned int (GIDs) or base64-encoded data. tilelayer only.
+     */
+    data: number[] | string;
+    /**
+     * 	Array of chunks (optional). tilelayer only.
+     */
+    chunks: TiledChunk[];
+    /**
+     * Column count. Same as map width for fixed-size maps.
+     */
+    width: number;
+    /**
+     * Row count. Same as map height for fixed-size maps.
+     */
+    height: number;
+    /**
+     * Name assigned to this layer
+     */
+    name: string;
+    /**
+     * From [0, 1]
+     */
+    opacity: number;
+    properties: {
+        [key: string]: any;
+    };
+    /**
+     * csv (default) or base64. tilelayer only.
+     */
+    encoding: TiledEncoding;
+    /**
+     * zlib, gzip, zstd (since Tiled 1.3) or empty (default). tilelayer only.
+     */
+    compression?: TiledCompression;
+    /**
+     * Type of layer (tilelayer, objectgroup)
+     */
+    type: TiledLayerType;
+    /**
+     * @since 1.9
+     */
+    class: string;
+    /**
+     * Whether layer is shown or hidden in editor
+     */
+    visible: boolean;
+    /**
+     * Horizontal layer offset in tiles. Always 0.
+     */
+    x: number;
+    /**
+     * Vertical layer offset in tiles. Always 0.
+     */
+    y: number;
+    /**
+     * Layer order in the original Tiled source
+     */
+    order: number;
+    /**
+     * Horizontal layer offset in pixels (default: 0)
+     */
+    offsetx: number;
+    /**
+     * Vertical layer offset in pixels (default: 0)
+     */
+    offsety: number;
+    /**
+     * X coordinate where layer content starts (for infinite maps)
+     */
+    startx: number;
+    /**
+     * Y coordinate where layer content starts (for infinite maps)
+     */
+    starty: number;
+    /**
+     * Hex-formatted color (#RRGGBB or #AARRGGBB) that is multiplied with any graphics drawn by this layer or any child layers (optional).
+     */
+    tintcolor: string;
+    /**
+     * Hex-formatted color (#RRGGBB) (optional). imagelayer only.
+     */
+    transparentcolor: string;
+    /**
+     * topdown (default) or index. objectgroup only.
+     */
+    draworder: 'topdown' | 'index' | 'objectgroup';
+    /**
+     * Array of objects. objectgroup only.
+     */
+    objects: TiledObject[];
+    layers: TiledLayer[];
+    parallaxx: number;
+    parallaxy: number;
+    repeatx: number;
+    repeaty: number;
+    locked: boolean;
+    color: string;
+}

package/dist/types/Map.d.ts

@@ -0,0 +1,72 @@
+import { TiledLayer } from './Layer';
+import { TiledTileset } from './Tileset';
+export interface TiledMap {
+    type: 'map';
+    version: number;
+    width: number;
+    /**
+     * Number of tile rows
+     */
+    height: number;
+    /**
+     * Length of the side of a hex tile in pixels (hexagonal maps only)
+     */
+    hexsidelength: number;
+    /**
+     * Map grid height
+     */
+    tileheight: number;
+    /**
+     * Map grid width
+     */
+    tilewidth: number;
+    /**
+     *	Hex-formatted color (#RRGGBB or #AARRGGBB) (optional)
+     */
+    backgroundcolor: string;
+    /**
+     * The compression level to use for tile layer data (defaults to -1, which means to use the algorithm default)
+     */
+    compressionlevel: number;
+    /**
+     * Whether the map has infinite dimensions
+     */
+    infinite: boolean;
+    /**
+     *	Auto-increments for each layer
+     */
+    nextlayerid: number;
+    /**
+     * Auto-increments for each placed object
+     */
+    nextobjectid: number;
+    /**
+     * Map orientation (orthogonal, isometric, staggered or hexagonal)
+     */
+    orientation: 'orthogonal' | 'isometric' | 'staggered' | 'hexagonal';
+    layers: TiledLayer[];
+    properties: {
+        [key: string]: any;
+    };
+    tilesets: TiledTileset[];
+    /**
+     * Render order: right-down (the default), right-up, left-down or left-up (currently only supported for orthogonal maps)
+     */
+    renderorder: 'right-down' | 'right-up' | 'left-down' | 'left-up';
+    /**
+     * x or y (staggered / hexagonal maps only)
+     */
+    staggeraxis: 'x' | 'y';
+    /**
+     * odd or even (staggered / hexagonal maps only)
+     */
+    staggerindex: 'odd' | 'even';
+    /**
+     * The Tiled version used to save the file
+     */
+    tiledversion: string;
+    /**
+     * @since 1.9
+     */
+    class: string;
+}

package/dist/types/Objects.d.ts

@@ -0,0 +1,57 @@
+import { TiledText } from './Text';
+import { TiledPoint } from './Types';
+export interface TiledObject {
+    id: number;
+    /**
+     * Tile object id
+     */
+    gid: number;
+    /**
+     * Used to mark an object as a point
+     */
+    point: boolean;
+    height: number;
+    name: string;
+    properties: {
+        [key: string]: any;
+    };
+    /**
+     * Angle in degrees clockwise
+     */
+    rotation: number;
+    type: string;
+    /**
+     * @since 1.9
+     */
+    class: string;
+    visible: boolean;
+    width: number;
+    /**
+     * X coordinate in pixels
+     */
+    x: number;
+    /**
+     * Y coordinate in pixels
+     */
+    y: number;
+    /**
+     * Reference to a template file, in case object is a template instance
+     */
+    template: string;
+    /**
+     *	Only used for text objects
+     */
+    text: TiledText;
+    /**
+     * Whether or not object is an ellipse
+     */
+    ellipse: boolean;
+    /**
+     * Polygon points
+     */
+    polygon: TiledPoint[];
+    /**
+     * Polyline points
+     */
+    polyline: TiledPoint[];
+}

package/dist/types/Text.d.ts

@@ -0,0 +1,47 @@
+export interface TiledText {
+    text: string;
+    /**
+     * Whether to use a bold font (default: false)
+     */
+    bold: boolean;
+    /**
+     * Hex-formatted color (#RRGGBB or #AARRGGBB) (default: #000000)
+     */
+    color: string;
+    /**
+     * Font family (default: sans-serif)
+     */
+    fontfamily: string;
+    /**
+     * Horizontal alignment (center, right, justify or left (default))
+     */
+    halign: 'center' | 'right' | 'justify' | 'left';
+    /**
+     * Whether to use an italic font (default: false)
+     */
+    italic: boolean;
+    /**
+     * Whether to use kerning when placing characters (default: true)
+     */
+    kerning: boolean;
+    /**
+     * Pixel size of font (default: 16)
+     */
+    pixelsize: number;
+    /**
+     * Whether to strike out the text (default: false)
+     */
+    strikeout: boolean;
+    /**
+     * Whether to underline the text (default: false)
+     */
+    underline: boolean;
+    /**
+     * Vertical alignment (center, bottom or top (default))
+     */
+    valign: 'center' | 'bottom' | 'top';
+    /**
+     * Whether the text is wrapped within the object bounds (default: false)
+     */
+    wrap: boolean;
+}

package/dist/types/Tile.d.ts

@@ -0,0 +1,17 @@
+import { TiledObject } from './Objects';
+import { TiledFrame } from './Types';
+export interface TilesetTile {
+    gid: number;
+    id: number;
+    type: string;
+    image: string;
+    imageheight: number;
+    imagewidth: number;
+    animations: TiledFrame[];
+    properties: {
+        [key: string]: any;
+    };
+    terrain: number[];
+    objects: TiledObject[];
+    probability: number;
+}

package/dist/types/Tileset.d.ts

@@ -0,0 +1,92 @@
+import { TilesetTile } from './Tile';
+import { TiledGrid, TiledMapTerrain, TiledTileOffset, TiledWangSet } from './Types';
+export interface TiledTileset {
+    type: 'tileset';
+    /**
+     * The JSON format version
+     */
+    version: number;
+    /**
+     * GID corresponding to the first tile in the set
+     */
+    firstgid: number;
+    /**
+     * Image used for tiles in this set
+     */
+    image: {
+        source: string;
+        height: number;
+        width: number;
+    };
+    /**
+     * Height of source image in pixels
+     */
+    imageheight: number;
+    /**
+     * Width of source image in pixels
+     */
+    imagewidth: number;
+    /**
+     * (optional)
+     */
+    grid: TiledGrid;
+    /**
+     * Buffer between image edge and first tile (pixels)
+     */
+    margin: number;
+    /**
+     * Alignment to use for tile objects (unspecified (default), topleft, top, topright, left, center, right, bottomleft, bottom or bottomright) (since 1.4)
+     */
+    objectalignment: 'unspecified' | 'topleft' | 'top' | 'topright' | 'left' | 'center' | 'right' | 'bottomleft' | 'bottom' | 'bottomright';
+    /**
+     * Refers to external tileset file (should be JSON)
+     */
+    source: string;
+    /**
+     * Spacing between adjacent tiles in image (pixels)
+     */
+    spacing: number;
+    columns: number;
+    rows: number;
+    /**
+     * Maximum height of tiles in this set
+     */
+    tileheight: number;
+    tilewidth: number;
+    /**
+     * Array of Tiles (optional)
+     */
+    tiles: TilesetTile[];
+    name: string;
+    properties: {
+        [key: string]: any;
+    };
+    /**
+     * The number of tiles in this tileset
+     */
+    tilecount: number;
+    /**
+     * Optional
+     */
+    tileoffset: TiledTileOffset;
+    /**
+     * The Tiled version used to save the file
+     */
+    tiledversion: string;
+    /**
+     * Hex-formatted color (#RRGGBB or #AARRGGBB) (optional)
+     */
+    backgroundcolor: string;
+    /**
+     * Hex-formatted color (#RRGGBB) (optional)
+     */
+    transparentcolor: string;
+    /**
+     * Array of Terrains (optional)
+     */
+    terrains: TiledMapTerrain[];
+    /**
+     * Array of Wang sets (since 1.1.5)
+     */
+    wangsets: TiledWangSet[];
+}

package/dist/types/Types.d.ts

@@ -0,0 +1,147 @@
+export interface TiledProperty<T = unknown> {
+    /**
+     * Name of the property
+     */
+    name: string;
+    /**
+     * Type of the property (string (default), int, float, bool, color or file (since 0.16, with color and file added in 0.17))
+     */
+    type: 'string' | 'int' | 'float' | 'bool' | 'color' | 'file';
+    /**
+     * Value of the property
+     */
+    value: T;
+}
+export type TiledEncoding = 'csv' | 'base64';
+export type TiledCompression = 'zlib' | 'gzip' | 'zstd';
+export interface TiledChunk {
+    /**
+     * Array of unsigned int (GIDs) or base64-encoded data
+     */
+    data: number[] | string;
+    /**
+     * Height in tiles
+     */
+    height: number;
+    /**
+     * Width in tiles
+     */
+    width: number;
+    /**
+     * X coordinate in tiles
+     */
+    x: number;
+    /**
+     * Y coordinate in tiles
+     */
+    y: number;
+}
+export interface TiledTileOffset {
+    /**
+     * Horizontal offset in pixels
+     */
+    x: number;
+    /**
+     * Vertical offset in pixels (positive is down)
+     */
+    y: number;
+}
+export interface TiledWangSet {
+    /**
+     * Array of Wang colors
+     */
+    cornercolors: TiledWangColor[];
+    /**
+     * Array of Wang colors
+     */
+    edgecolors: TiledWangColor[];
+    name: string;
+    properties: TiledProperty[];
+    /**
+     * Local ID of tile representing the Wang set
+     */
+    tile: number;
+    wangtiles: TiledWangTile[];
+}
+export interface TiledWangTile {
+    /**
+     * Array of Wang color indexes (uchar[8]
+     */
+    wangid: number[];
+    /**
+     * Tile is flipped diagonally (default: false)
+     */
+    dflip: boolean;
+    /**
+     * Tile is flipped horizontally (default: false)
+     */
+    hflip: boolean;
+    /**
+     * Local ID of tile
+     */
+    tileid: number;
+    /**
+     * Tile is flipped vertically (default: false)
+     */
+    vflip: boolean;
+}
+export interface TiledWangColor {
+    /**
+     * Hex-formatted color (#RRGGBB or #AARRGGBB)
+     */
+    color: string;
+    /**
+     * Name of the Wang color
+     */
+    name: string;
+    /**
+     * Probability used when randomizing
+     */
+    probability: number;
+    /**
+     * Local ID of tile representing the Wang color
+     */
+    tile: number;
+}
+export interface TiledGrid {
+    /**
+     *	orthogonal (default) or isometric
+     */
+    orientation: 'orthogonal' | 'isometric';
+    /**
+     * Cell width of tile grid
+     */
+    width: number;
+    /**
+     * Cell height of tile grid
+     */
+    height: number;
+}
+export interface TiledFrame {
+    /**
+     * Frame duration in milliseconds
+     */
+    duration: number;
+    /**
+     * 	Local tile ID representing this frame
+     */
+    tileid: number;
+}
+export interface TiledMapTerrain {
+    name: string;
+    /**
+     * Local ID of tile representing terrain
+     */
+    tile: number;
+    properties: TiledProperty[];
+}
+export interface TiledPoint {
+    x: number;
+    y: number;
+}
+export interface TiledImage {
+    source: string;
+    width: number;
+    height: number;
+    trans?: string;
+}

package/dist/types/WorldMaps.d.ts

@@ -0,0 +1,12 @@
+export interface TiledWorldMap {
+    fileName: string;
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+}
+export interface TiledWorld {
+    maps: TiledWorldMap[];
+    onlyShowAdjacentMaps: boolean;
+    type: 'world';
+}

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+export declare function isTiledFormat(val: any): boolean;
+/**
+ * Join path segments with forward slashes
+ * @param {...string} segments - Path segments to join
+ * @returns {string} Joined path
+ * @example
+ * joinPath('base', 'static', 'file.json') // returns 'base/static/file.json'
+ */
+export declare function joinPath(...segments: string[]): string;
+export declare function getBaseName(path: string): string;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@canvasengine/tiled",
+  "version": "2.0.0-beta.25",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^18.15.10",
+    "typescript": "^5.0.2",
+    "vite": "^6.2.5",
+    "vite-plugin-dts": "^4.5.3",
+    "vitest": "^3.1.1"
+  },
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "xml-js": "^1.6.11",
+    "xmlbuilder": "^15.1.1"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest"
+  }
+}

package/readme.md

@@ -0,0 +1 @@
+Time was saved on writing the types. Thanks to  https://github.com/excaliburjs/excalibur-tiled/blob/main/src