added exports to I think everything

Author: benni-tec

packages/tiled/lib/src/chunk.dart

@@ -17,7 +17,7 @@ part of tiled;
 /// The data inside is a compressed (encoded) representation of a list
 /// (that sequentially represents a matrix) of integers representing
 /// [Gid]s.
-class Chunk {
+class Chunk extends Exportable {
   List<int> data;
 
   int x;
@@ -59,4 +59,22 @@ class Chunk {
 
     return Chunk(data: data, x: x, y: y, width: width, height: height);
   }
+
+  @override
+  ExportElement export(ExportSettings settings) {
+    final common = {
+      'x': x.toExport(),
+      'y': y.toExport(),
+      'width': width.toExport(),
+      'height': height.toExport(),
+    };
+
+    return ExportElement(
+      'chunk',
+      common,
+      {
+        'data': TileData(data).export(settings),
+      },
+    );
+  }
 }

packages/tiled/lib/src/common/frame.dart

@@ -8,7 +8,7 @@ part of tiled;
 /// * tileid: The local ID of a tile within the parent <tileset>.
 /// * duration: How long (in milliseconds) this frame should be displayed
 ///   before advancing to the next frame.
-class Frame {
+class Frame extends Exportable {
   int tileId;
   int duration;
 
@@ -22,4 +22,10 @@ class Frame {
           tileId: parser.getInt('tileid'),
           duration: parser.getInt('duration'),
         );
+
+  @override
+  ExportResolver export(ExportSettings settings) => ExportElement('frame', {
+    'tileid': tileId.toExport(),
+    'duration': duration.toExport(),
+  }, {});
 }

packages/tiled/lib/src/common/gid.dart

@@ -32,7 +32,7 @@ part of tiled;
 /// When rendering a tile, the order of operation matters. The diagonal flip
 /// (x/y axis swap) is done first, followed by the horizontal and vertical
 /// flips.
-class Gid extends UnaryExportable {
+class Gid extends ExportValue {
   static const int flippedHorizontallyFlag = 0x80000000;
   static const int flippedVerticallyFlag = 0x40000000;
   static const int flippedDiagonallyFlag = 0x20000000;
@@ -83,11 +83,16 @@ class Gid extends UnaryExportable {
     });
   }
 
-  @override
   String export() => ((tile & ~flagBits) |
           (flips.horizontally ? flippedHorizontallyFlag : 0) |
           (flips.vertically ? flippedVerticallyFlag : 0) |
           (flips.diagonally ? flippedDiagonallyFlag : 0) |
           (flips.antiDiagonally ? flippedAntiDiagonallyFlag : 0))
       .toString();
+
+  @override
+  String get json => export();
+
+  @override
+  String get xml => export();
 }

packages/tiled/lib/src/common/iterable.dart

@@ -0,0 +1,17 @@
+part of tiled;
+
+extension Grouping<V> on Iterable<V> {
+  Map<K, List<V>> groupBy<K>(K Function(V value) key) {
+    final out = <K, List<V>>{};
+    for (final v in this) {
+      final k = key(v);
+      if (!out.containsKey(k)) {
+        out[k] = [v];
+      } else {
+        out[k]!.add(v);
+      }
+    }
+
+    return out;
+  }
+}

packages/tiled/lib/src/common/map.dart

@@ -1,3 +1,5 @@
+part of tiled;
+
 extension Null<K, V> on Map<K, V?> {
   Map<K, V> nonNulls() => {for (final e in entries.where((e) => e.value is V)) e.key : e.value as V};
 }

packages/tiled/lib/src/common/property.dart

@@ -86,6 +86,14 @@ class Property<T> {
         );
     }
   }
+
+  ExportValue get exportValue => value.toString().toExport();
+
+  ExportElement export() => ExportElement('property', {
+        'name': name.toExport(),
+        'type': type.name.toExport(),
+        'value': exportValue,
+      }, {});
 }
 
 /// A wrapper for a Tiled property set
@@ -164,6 +172,9 @@ class ColorProperty extends Property<ColorData> {
     required super.value,
     required this.hexValue,
   }) : super(type: PropertyType.color);
+
+  @override
+  ExportValue get exportValue => value.toExport();
 }
 
 /// [value] is the string text
@@ -180,6 +191,10 @@ class FileProperty extends Property<String> {
     required super.name,
     required super.value,
   }) : super(type: PropertyType.file);
+
+  @override
+  ExportValue get exportValue =>
+      value.isNotEmpty ? value.toExport() : '.'.toExport();
 }
 
 /// [value] is the integer number

packages/tiled/lib/src/common/tiled_image.dart

@@ -18,7 +18,7 @@ part of tiled;
 ///   when the image changes)
 /// * height: The image height in pixels (optional)
 @immutable
-class TiledImage {
+class TiledImage implements Exportable {
   final String? source;
   final String? format;
   final int? width;
@@ -53,4 +53,19 @@ class TiledImage {
 
   @override
   int get hashCode => source.hashCode;
+
+  @override
+  ExportElement export(ExportSettings settings) => ExportElement(
+        'image',
+        {
+          'width': width?.toExport(),
+          'height': height?.toExport(),
+          'format': format?.toExport(),
+          'source': source?.toExport(),
+          'trans': trans?.toExport(),
+        }.nonNulls(),
+        {
+          // missing data, tiled.dart does not support embedded images
+        },
+      );
 }

packages/tiled/lib/src/data.dart

@@ -0,0 +1,72 @@
+part of tiled;
+
+class TileData extends DelegatingList<int> implements Exportable {
+  TileData(super.base);
+
+  @override
+  ExportResolver export(ExportSettings settings) {
+    String? data;
+    switch (settings.encoding) {
+      case null:
+        break;
+      case FileEncoding.csv:
+        data = join(', ');
+        break;
+      case FileEncoding.base64:
+        data = _base64(settings);
+        break;
+    }
+
+    return ExportFormatSpecific(
+      xml: ExportElement('data', {
+        if (settings.encoding != null)
+          'encoding': settings.encoding!.name.toExport(),
+        if (settings.compression != null)
+          'compression': settings.compression!.name.toExport(),
+      }, {
+        if (data == null)
+          'tiles': ExportList(map(
+            (gid) => ExportElement(
+              'tile',
+              {'gid': gid.toExport()},
+              {},
+            ),
+          ))
+        else
+          'data': data.toExport(),
+      }),
+      json: ExportLiteral(this),
+    );
+  }
+
+  String _base64(ExportSettings settings) {
+    // Compression
+    List<int> compressed;
+    switch (settings.compression) {
+      case Compression.zlib:
+        compressed = const ZLibEncoder().encode(this);
+        break;
+      case Compression.gzip:
+        compressed = GZipEncoder().encode(this)!;
+        break;
+      case Compression.zstd:
+        throw UnsupportedError('zstd is an unsupported compression');
+      case null:
+        compressed = this;
+        break;
+    }
+
+    // Conversion to Uint8List
+    final uint32 = Uint32List.fromList(compressed);
+    final dv = ByteData(compressed.length * 4);
+
+    for (var i = 0; i < compressed.length; ++i) {
+      dv.setInt32(i * 4, uint32[i], Endian.little);
+    }
+
+    final uint8 = dv.buffer.asUint8List();
+
+    // encoding
+    return base64Encode(uint8);
+  }
+}