parse-tmx 1.8.2 → 1.9.1

package/dist/index.d.ts

@@ -1,2 +1,307 @@
+interface TMXEditorSettingsParsed extends Record<string, unknown> {
+}
 
-export {  }
+interface TMXFlipsParsed {
+    H: boolean;
+    V: boolean;
+    D: boolean;
+}
+
+interface TMXImageShared {
+    height: number;
+    width: number;
+    source: string;
+}
+
+interface TMXImageParsed extends TMXImageShared {
+}
+
+declare enum Shape {
+    Ellipse = "ellipse",
+    Point = "point",
+    Polygon = "polygon",
+    Rectangle = "rectangle"
+}
+
+type TMXPropertiesParsed = Record<string, unknown>[];
+
+interface TMXObjectShared {
+    id: number;
+    type: string;
+    gid: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface TMXObjectParsed extends TMXObjectShared {
+    name: string;
+    value: string;
+    shape: Shape;
+    points?: [number, number][];
+    text?: string;
+    flips?: TMXFlipsParsed;
+    properties?: TMXPropertiesParsed;
+}
+
+interface TMXLayerShared {
+    id: number;
+    name: string;
+    type: string;
+    width: number;
+    height: number;
+    x?: number;
+    y?: number;
+    locked?: number;
+    opacity?: number;
+    visible?: number;
+    tintcolor?: string;
+    offsetx?: number;
+    offsety?: number;
+    parallaxx?: number;
+    parallaxy?: number;
+}
+
+interface TMXLayerParsed extends TMXLayerShared {
+    data?: number[];
+    image?: TMXImageParsed;
+    flips?: TMXFlipsParsed[];
+    objects?: TMXObjectParsed[];
+    properties?: TMXPropertiesParsed;
+}
+
+interface TMXGroupLayerShared {
+    id: number;
+    name: string;
+    type: string;
+}
+
+interface TMXGroupLayerParsed extends TMXGroupLayerShared {
+    layers: TMXLayerParsed[];
+    properties?: TMXPropertiesParsed;
+}
+
+interface TMXTileShared {
+    id: number;
+    gid?: number;
+    probability?: number;
+}
+
+interface TMXTileParsed extends TMXTileShared {
+    id: number;
+    type: string;
+    animation?: {
+        frames: number[];
+    };
+    objects?: TMXObjectParsed[];
+    properties?: TMXPropertiesParsed;
+}
+
+interface TMXBaseTilesetShared {
+    firstgid: number;
+}
+
+interface TMXEmbeddedTilesetShared extends TMXBaseTilesetShared {
+    columns: number;
+    name: string;
+    spacing?: number;
+    margin?: number;
+    tilecount: number;
+    tilewidth: number;
+    tileheight: number;
+    imagewidth: number;
+    imageheight: number;
+}
+
+interface TMXEmbeddedTilesetParsed extends TMXEmbeddedTilesetShared {
+    image: TMXImageParsed;
+    tiles: TMXTileParsed[];
+}
+
+interface TMXExternalTilesetShared extends TMXBaseTilesetShared {
+    source: string;
+}
+
+interface TMXExternalTilesetParsed extends TMXExternalTilesetShared {
+}
+
+type TMXTilesetParsed = TMXEmbeddedTilesetParsed | TMXExternalTilesetParsed;
+
+declare class TMXMapShared {
+    version: number;
+    tiledversion: string;
+    orientation: string;
+    renderorder: string;
+    width: number;
+    height: number;
+    tilewidth: number;
+    tileheight: number;
+    infinite: number;
+    nextlayerid: number;
+    nextobjectid: number;
+}
+
+declare class TMXMapParsed extends TMXMapShared {
+    editorsettings: TMXEditorSettingsParsed;
+    tilesets: TMXTilesetParsed[];
+    layers: (TMXLayerParsed | TMXGroupLayerParsed)[];
+    properties: TMXPropertiesParsed;
+    constructor(init?: Partial<TMXMapParsed>);
+}
+
+interface TMXParsed {
+    map: TMXMapParsed;
+}
+
+declare const parseTmx: (xmlString: string, translateFlips?: boolean) => Promise<TMXParsed>;
+
+declare enum Compression {
+    Gzip = "gzip",
+    Zlib = "zlib"
+}
+
+declare enum Encoding {
+    Base64 = "base64",
+    Csv = "csv"
+}
+
+declare enum Flipped {
+    Diagonally = 536870912,
+    Horizontally = 2147483648,
+    Vertically = 1073741824
+}
+
+declare const isExternalTileset: (tileset: TMXEmbeddedTilesetShared | TMXExternalTilesetShared) => tileset is TMXExternalTilesetShared;
+
+declare const parseFlips: (gid: number) => TMXFlipsParsed;
+
+interface BaseTMXNode<T> extends Record<string, unknown> {
+    $: T;
+}
+type TMXNode<T, TChildNode extends BaseTMXNode<unknown> | undefined = undefined> = BaseTMXNode<T> & {
+    $$: TChildNode extends undefined ? undefined : TChildNode[];
+};
+
+interface TMXDataNode extends TMXNode<{
+    encoding: Encoding;
+    compression?: Compression | null;
+}> {
+    _: string;
+}
+
+interface TMXImageNode extends TMXNode<TMXImageShared> {
+}
+
+interface TMXPropertyNode extends TMXNode<{
+    name: string;
+    value?: string;
+}> {
+    _: string;
+}
+
+interface TMXPropertiesNode extends TMXNode<Record<string, never>, TMXPropertyNode> {
+}
+
+interface TMXObjectNode extends TMXNode<TMXObjectShared, TMXDataNode | TMXPropertiesNode> {
+    polygon?: TMXNode<{
+        points: string;
+    }>[];
+    text?: TMXDataNode[];
+    properties?: {
+        property: TMXPropertyNode[];
+    }[];
+}
+
+interface TMXTileNode extends TMXNode<TMXTileShared, TMXPropertiesNode> {
+    animation?: Record<string, TMXNode<number>[]>[];
+    objectgroup?: Record<string, TMXObjectNode[]>[];
+    properties?: {
+        property: TMXPropertyNode[];
+    }[];
+}
+
+interface TMXEmbeddedTilesetNode extends TMXNode<TMXEmbeddedTilesetShared, TMXImageNode | TMXTileNode> {
+    tile?: TMXTileNode[];
+}
+
+interface TMXLayerNode extends TMXNode<TMXLayerShared, TMXEmbeddedTilesetNode | TMXDataNode | TMXPropertiesNode> {
+    data?: TMXEmbeddedTilesetNode[] | TMXDataNode[];
+    image?: TMXImageNode[];
+    object?: TMXObjectNode[];
+    properties?: {
+        property: TMXPropertyNode[];
+    }[];
+}
+
+interface TMXGroupLayerNode extends TMXNode<TMXGroupLayerShared, TMXLayerNode> {
+    properties?: {
+        property: TMXPropertyNode[];
+    }[];
+}
+
+declare const parseGroup: (node: TMXGroupLayerNode, expectedCount: number, translateFlips: boolean) => Promise<TMXGroupLayerParsed>;
+
+declare const parseLayer: (node: TMXLayerNode) => TMXLayerParsed;
+
+declare const parseNode: <TNode extends TMXLayerNode | TMXGroupLayerNode, TParsedNode = TNode extends TMXLayerNode ? TMXLayerParsed : TMXGroupLayerParsed>(node: TMXLayerNode | TMXGroupLayerNode, expectedCount: number, translateFlips: boolean) => Promise<TParsedNode> | TParsedNode;
+
+declare const parseObject: (node: TMXObjectNode) => TMXObjectParsed;
+
+declare const parseObjectShape: (node: TMXObjectNode) => Shape;
+
+declare const parseProperties: (properties?: {
+    property: TMXPropertyNode[];
+}[]) => TMXPropertiesParsed | undefined;
+
+declare const parseTile: (node: TMXTileNode) => TMXTileParsed;
+
+declare const parseTileId: (gid: number) => number;
+
+declare const parseTileLayer: (node: TMXLayerNode, expectedCount: number, translateFlips: boolean) => Promise<TMXLayerParsed>;
+
+interface TMXExternalTilesetNode extends TMXNode<TMXExternalTilesetShared> {
+}
+
+type TMXTilesetNode = TMXEmbeddedTilesetNode | TMXExternalTilesetNode;
+
+declare const parseTileset: (node: TMXTilesetNode) => TMXTilesetParsed;
+
+declare const unpackTileBytes: (buffer: Buffer, expectedCount: number) => number[];
+
+interface TMXExportShared {
+    target: string;
+    format: string;
+}
+
+interface TMXExportNode extends TMXNode<TMXExportShared> {
+}
+
+interface TMXEditorSettingsNode extends TMXNode<Record<string, never>, TMXExportNode> {
+}
+
+interface TMXMapNode extends TMXNode<TMXMapShared, TMXEditorSettingsNode | TMXTilesetNode | TMXGroupLayerNode | TMXPropertiesNode> {
+}
+
+interface TMX {
+    map: TMXMapNode;
+}
+
+declare enum TMXNodeType {
+    EditorSettings = "editorsettings",
+    Export = "export",
+    Group = "group",
+    Image = "image",
+    ImageLayer = "imagelayer",
+    Layer = "layer",
+    Object = "object",
+    Objectgroup = "objectgroup",
+    Properties = "properties",
+    Property = "property",
+    Tileset = "tileset"
+}
+
+interface TMXExportParsed extends TMXExportShared {
+}
+
+export { Compression, Encoding, Flipped, Shape, type TMX, type TMXBaseTilesetShared, type TMXDataNode, type TMXEditorSettingsNode, type TMXEditorSettingsParsed, type TMXEmbeddedTilesetNode, type TMXEmbeddedTilesetParsed, type TMXEmbeddedTilesetShared, type TMXExportNode, type TMXExportParsed, type TMXExportShared, type TMXExternalTilesetNode, type TMXExternalTilesetParsed, type TMXExternalTilesetShared, type TMXFlipsParsed, type TMXGroupLayerNode, type TMXGroupLayerParsed, type TMXGroupLayerShared, type TMXImageNode, type TMXImageParsed, type TMXImageShared, type TMXLayerNode, type TMXLayerParsed, type TMXLayerShared, type TMXMapNode, TMXMapParsed, TMXMapShared, type TMXNode, TMXNodeType, type TMXObjectNode, type TMXObjectParsed, type TMXObjectShared, type TMXParsed, type TMXPropertiesNode, type TMXPropertiesParsed, type TMXPropertyNode, type TMXTileNode, type TMXTileParsed, type TMXTileShared, type TMXTilesetNode, type TMXTilesetParsed, isExternalTileset, parseFlips, parseGroup, parseLayer, parseNode, parseObject, parseObjectShape, parseProperties, parseTile, parseTileId, parseTileLayer, parseTileset, parseTmx, unpackTileBytes };

package/dist/index.js

@@ -1 +1,306 @@
+import { exhaustiveGuard, InvalidOperationError, Operation, parseXmlString } from '@esposter/shared';
+import { gunzip, inflate } from 'node:zlib';
 
+var TMXNodeType;
+(function (TMXNodeType) {
+    TMXNodeType["EditorSettings"] = "editorsettings";
+    TMXNodeType["Export"] = "export";
+    TMXNodeType["Group"] = "group";
+    TMXNodeType["Image"] = "image";
+    TMXNodeType["ImageLayer"] = "imagelayer";
+    TMXNodeType["Layer"] = "layer";
+    TMXNodeType["Object"] = "object";
+    TMXNodeType["Objectgroup"] = "objectgroup";
+    TMXNodeType["Properties"] = "properties";
+    TMXNodeType["Property"] = "property";
+    TMXNodeType["Tileset"] = "tileset";
+})(TMXNodeType || (TMXNodeType = {}));
+
+class TMXMapShared {
+    version = 0;
+    tiledversion = "";
+    orientation = "";
+    renderorder = "";
+    width = 0;
+    height = 0;
+    tilewidth = 0;
+    tileheight = 0;
+    infinite = 0;
+    nextlayerid = 0;
+    nextobjectid = 0;
+}
+
+class TMXMapParsed extends TMXMapShared {
+    editorsettings = {};
+    tilesets = [];
+    layers = [];
+    properties = [];
+    constructor(init) {
+        super();
+        Object.assign(this, init);
+    }
+}
+
+const parseGroup = async (node, expectedCount, translateFlips) => {
+    const { $, $$ } = node;
+    const group = structuredClone($);
+    group.type = node["#name"];
+    if ($$)
+        group.layers = await Promise.all($$.map((l) => parseNode(l, expectedCount, translateFlips)));
+    return group;
+};
+
+var Flipped;
+(function (Flipped) {
+    Flipped[Flipped["Diagonally"] = 536870912] = "Diagonally";
+    Flipped[Flipped["Horizontally"] = 2147483648] = "Horizontally";
+    Flipped[Flipped["Vertically"] = 1073741824] = "Vertically";
+})(Flipped || (Flipped = {}));
+
+const parseFlips = (gid) => ({
+    H: Boolean(gid & Flipped.Horizontally),
+    V: Boolean(gid & Flipped.Vertically),
+    D: Boolean(gid & Flipped.Diagonally),
+});
+
+var Shape;
+(function (Shape) {
+    Shape["Ellipse"] = "ellipse";
+    Shape["Point"] = "point";
+    Shape["Polygon"] = "polygon";
+    Shape["Rectangle"] = "rectangle";
+})(Shape || (Shape = {}));
+
+const parseObjectShape = (node) => {
+    if ("point" in node)
+        return Shape.Point;
+    else if ("ellipse" in node)
+        return Shape.Ellipse;
+    else if ("polygon" in node)
+        return Shape.Polygon;
+    else
+        return Shape.Rectangle;
+};
+
+const parseProperties = (properties) => properties
+    ? properties.map(({ property }) => {
+        const { $, _ } = property[0];
+        const { name, value } = $;
+        return { name, value: value ?? _ };
+    })
+    : undefined;
+
+const parseTileId = (gid) => (gid &= ~Object.values(Flipped).reduce((acc, curr) => acc | curr, 0));
+
+const parseObject = (node) => {
+    const { $, polygon, text, properties } = node;
+    const object = structuredClone($);
+    object.shape = parseObjectShape(node);
+    if (properties)
+        object.properties = parseProperties(properties);
+    if (polygon)
+        object.points = polygon[0].$.points.split(" ").map((point) => {
+            const [x, y] = point.split(",");
+            return [parseFloat(x), parseFloat(y)];
+        });
+    if (text) {
+        const textNode = text[0];
+        object.text = textNode._;
+        object.properties = Object.assign({}, object.properties, textNode.$);
+    }
+    if (object.gid) {
+        object.flips = parseFlips(object.gid);
+        object.gid = parseTileId(object.gid);
+    }
+    return object;
+};
+
+const parseLayer = (node) => {
+    const { $, image, object, properties } = node;
+    const layer = structuredClone($);
+    layer.type = node["#name"];
+    layer.visible = 1;
+    if (image)
+        layer.image = structuredClone(image[0].$);
+    if (object)
+        layer.objects = object.map((o) => parseObject(o));
+    if (properties)
+        layer.properties = parseProperties(properties);
+    return layer;
+};
+
+var Compression;
+(function (Compression) {
+    Compression["Gzip"] = "gzip";
+    Compression["Zlib"] = "zlib";
+})(Compression || (Compression = {}));
+
+var Encoding;
+(function (Encoding) {
+    Encoding["Base64"] = "base64";
+    Encoding["Csv"] = "csv";
+})(Encoding || (Encoding = {}));
+
+const unpackTileBytes = (buffer, expectedCount) => {
+    const unpackedTiles = [];
+    if (buffer.length !== expectedCount)
+        throw new Error(`Expected ${expectedCount} bytes of tile data; received ${buffer.length}`);
+    for (let i = 0; i < expectedCount; i += 4)
+        unpackedTiles.push(buffer.readUInt32LE(i));
+    return unpackedTiles;
+};
+
+const isTMXEmbeddedTilesetNode = (node) => "tile" in node;
+const parseTileLayer = async (node, expectedCount, translateFlips) => {
+    const { data, properties } = node;
+    if (!data)
+        throw new Error("TMXLayer data corrupted!");
+    const layer = structuredClone(node.$);
+    layer.type = node["#name"];
+    if (properties)
+        layer.properties = parseProperties(properties);
+    const nodeData = data[0];
+    // Xml Deprecated
+    if (isTMXEmbeddedTilesetNode(nodeData))
+        layer.data = nodeData.tile?.map(({ $ }) => $.gid ?? 0) ?? [];
+    else {
+        // Csv, Base64
+        const { $, _ } = nodeData;
+        const { encoding, compression } = $;
+        const layerData = _.trim();
+        switch (encoding) {
+            case Encoding.Csv:
+                layer.data = layerData.split(",").map((d) => parseInt(d));
+                break;
+            case Encoding.Base64: {
+                const buffer = Buffer.from(layerData, encoding);
+                switch (compression) {
+                    case Compression.Gzip:
+                    case Compression.Zlib:
+                        {
+                            const decompress = compression === Compression.Gzip ? gunzip : inflate;
+                            layer.data = await new Promise((resolve, reject) => {
+                                decompress(buffer, (err, buf) => {
+                                    if (err)
+                                        reject(err);
+                                    resolve(unpackTileBytes(buf, expectedCount));
+                                });
+                            });
+                        }
+                        break;
+                    case null:
+                    case undefined:
+                        layer.data = unpackTileBytes(buffer, expectedCount);
+                        break;
+                    default:
+                        exhaustiveGuard(compression);
+                }
+                break;
+            }
+            default:
+                exhaustiveGuard(encoding);
+        }
+    }
+    if (translateFlips) {
+        layer.flips = [];
+        layer.data ??= [];
+        for (const gid of layer.data) {
+            layer.flips.push(parseFlips(gid));
+            layer.data.push(parseTileId(gid));
+        }
+    }
+    return layer;
+};
+
+const parseNode = (node, expectedCount, translateFlips) => {
+    const tmxNodeType = node["#name"];
+    switch (tmxNodeType) {
+        case TMXNodeType.Group:
+            return parseGroup(node, expectedCount, translateFlips);
+        case TMXNodeType.Layer:
+            return parseTileLayer(node, expectedCount, translateFlips);
+        case TMXNodeType.ImageLayer:
+        case TMXNodeType.Objectgroup:
+            return parseLayer(node);
+        default:
+            throw new InvalidOperationError(Operation.Read, parseNode.name, tmxNodeType);
+    }
+};
+
+const isExternalTileset = (tileset) => "source" in tileset;
+
+const parseTile = (node) => {
+    const { $, animation, objectgroup, properties } = node;
+    const tile = structuredClone($);
+    if (animation)
+        tile.animation = {
+            frames: animation[0].frame.map(({ $ }) => structuredClone($)),
+        };
+    if (objectgroup)
+        tile.objects = objectgroup[0].object.map((o) => parseObject(o));
+    if (properties)
+        tile.properties = parseProperties(properties);
+    return tile;
+};
+
+const parseTileset = (node) => {
+    if (isExternalTileset(node.$))
+        return structuredClone(node.$);
+    const { $, $$, tile } = node;
+    for (const childNode of $$ ?? []) {
+        const tmxNodeType = childNode["#name"];
+        if (tmxNodeType !== TMXNodeType.Image)
+            continue;
+        const image = structuredClone(childNode.$);
+        const tiles = tile?.map((t) => parseTile(t)) ?? [];
+        return { ...$, image, tiles };
+    }
+    throw new InvalidOperationError(Operation.Read, parseTileset.name, $.name);
+};
+
+// We will try and match phaser's transform when exporting tmx => json tilemaps
+// but also support extra functionality like using external tilesets
+const parseTmx = async (xmlString, translateFlips = false) => {
+    const { map: { $, $$ }, } = (await parseXmlString(xmlString));
+    const map = new TMXMapParsed(structuredClone($));
+    const expectedCount = map.width * map.height * 4;
+    await Promise.all($$.map(async (node) => {
+        const tmxNodeType = node["#name"];
+        switch (tmxNodeType) {
+            case TMXNodeType.EditorSettings:
+                if (!node.$$)
+                    break;
+                map.editorsettings = { ...node.$$.map((n) => ({ [n["#name"]]: n.$ })) };
+                break;
+            case TMXNodeType.Group:
+            case TMXNodeType.ImageLayer:
+            case TMXNodeType.Layer:
+            case TMXNodeType.Objectgroup:
+                {
+                    const layer = await parseNode(node, expectedCount, translateFlips);
+                    map.layers.push(layer);
+                }
+                break;
+            case TMXNodeType.Properties:
+                if (!node.$$)
+                    break;
+                map.properties = {
+                    ...node.$$.map(({ $: { name, value } }) => ({ [name]: value })),
+                };
+                break;
+            case TMXNodeType.Tileset:
+                map.tilesets.push(parseTileset(node));
+                break;
+            case TMXNodeType.Export:
+            case TMXNodeType.Image:
+            case TMXNodeType.Object:
+            case TMXNodeType.Property:
+                break;
+            default:
+                exhaustiveGuard(tmxNodeType);
+        }
+    }));
+    return { map };
+};
+
+export { Compression, Encoding, Flipped, Shape, TMXMapParsed, TMXMapShared, TMXNodeType, isExternalTileset, parseFlips, parseGroup, parseLayer, parseNode, parseObject, parseObjectShape, parseProperties, parseTile, parseTileId, parseTileLayer, parseTileset, parseTmx, unpackTileBytes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parse-tmx",
-  "version": "1.8.2",
+  "version": "1.9.1",
   "description": "A parser for tmx",
   "type": "module",
   "main": "dist/index.js",
@@ -30,11 +30,11 @@
     "export:gen": "ctix build --config ../configuration/.ctirc"
   },
   "dependencies": {
-    "@esposter/shared": "1.8.2"
+    "@esposter/shared": "1.9.1"
   },
   "devDependencies": {
-    "@esposter/configuration": "1.8.2",
+    "@esposter/configuration": "1.9.1",
     "@types/node": "^20.12.12"
   },
-  "gitHead": "1309cedda61626596ffec34619259fa275b9add0"
+  "gitHead": "39cc371b6c74450fd3b708847d4249a6c3d19deb"
 }