import analyser and migrate to solidjs, untested

script/viewer/Analyse/Data/AsyncParser.js

@@ -0,0 +1,58 @@
+"use strict";
+exports.__esModule = true;
+exports.AsyncParser = void 0;
+var parser_worker_1 = require("@demostf/parser-worker");
+var AsyncParser = /** @class */ (function () {
+    function AsyncParser(buffer, progressCallback) {
+        this.buffer = buffer;
+        this.progressCallback = progressCallback;
+    }
+    AsyncParser.prototype.cache = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var worker = new Worker(new URL('./ParseWorker.ts', import.meta.url));
+            worker.postMessage({
+                buffer: _this.buffer
+            }, [_this.buffer]);
+            worker.onmessage = function (event) {
+                if (event.data.error) {
+                    reject(event.data.error);
+                    return;
+                }
+                else if (event.data.progress) {
+                    _this.progressCallback(event.data.progress);
+                    return;
+                }
+                else if (event.data.demo) {
+                    var cachedData = event.data.demo;
+                    console.log("packed data: ".concat((cachedData.data.length / (1024 * 1024)).toFixed(1), "MB"));
+                    _this.world = cachedData.world;
+                    _this.demo = new parser_worker_1.ParsedDemo(cachedData.playerCount, cachedData.buildingCount, cachedData.world, cachedData.header, cachedData.data, cachedData.kills, cachedData.playerInfo, cachedData.tickCount);
+                    resolve(_this.demo);
+                }
+            };
+        });
+    };
+    AsyncParser.prototype.getPlayersAtTick = function (tick) {
+        var players = [];
+        for (var i = 0; i < this.demo.playerCount; i++) {
+            players.push(this.demo.getPlayer(tick, i));
+        }
+        return players;
+    };
+    AsyncParser.prototype.getBuildingsAtTick = function (tick) {
+        var buildings = [];
+        for (var i = 0; i < this.demo.buildingCount; i++) {
+            var building = this.demo.getBuilding(tick, i);
+            if (building.health > 0) {
+                buildings.push(building);
+            }
+        }
+        return buildings;
+    };
+    AsyncParser.prototype.getKills = function () {
+        return this.demo.kills;
+    };
+    return AsyncParser;
+}());
+exports.AsyncParser = AsyncParser;

script/viewer/Analyse/Data/AsyncParser.ts

@@ -0,0 +1,63 @@
+import {ParsedDemo, PlayerState, WorldBoundaries, Header, Kill, BuildingState} from "@demostf/parser-worker";
+import {getMapBoundaries} from "../MapBoundries";
+
+export class AsyncParser {
+	buffer: ArrayBuffer;
+	demo: ParsedDemo;
+	world: WorldBoundaries;
+	progressCallback: (progress: number) => void;
+
+	constructor(buffer: ArrayBuffer, progressCallback: (progress: number) => void) {
+		this.buffer = buffer;
+		this.progressCallback = progressCallback;
+	}
+
+	cache(): Promise<ParsedDemo> {
+		return new Promise((resolve, reject) => {
+			const worker = new Worker(new URL('./ParseWorker.ts', import.meta.url));
+			worker.postMessage({
+				buffer: this.buffer
+			}, [this.buffer]);
+			worker.onmessage = (event) => {
+				if (event.data.error) {
+					reject(event.data.error);
+					return;
+				} else if (event.data.progress) {
+					this.progressCallback(event.data.progress);
+					return;
+				} else if (event.data.demo) {
+					const cachedData: ParsedDemo = event.data.demo;
+					console.log(`packed data: ${(cachedData.data.length / (1024 * 1024)).toFixed(1)}MB`);
+					this.world = cachedData.world;
+					this.demo = new ParsedDemo(cachedData.playerCount, cachedData.buildingCount, cachedData.world, cachedData.header, cachedData.data, cachedData.kills, cachedData.playerInfo, cachedData.tickCount);
+					resolve(this.demo);
+				}
+			}
+		});
+	}
+
+	getPlayersAtTick(tick: number): PlayerState[] {
+		const players: PlayerState[] = [];
+		for (let i = 0; i < this.demo.playerCount; i++) {
+			players.push(this.demo.getPlayer(tick, i));
+		}
+
+		return players;
+	}
+
+	getBuildingsAtTick(tick: number): BuildingState[] {
+		const buildings: BuildingState[] = [];
+		for (let i = 0; i < this.demo.buildingCount; i++) {
+			const building = this.demo.getBuilding(tick, i);
+			if (building.health > 0) {
+				buildings.push(building);
+			}
+		}
+
+		return buildings;
+	}
+
+	getKills(): Kill[] {
+		return this.demo.kills
+	}
+}

script/viewer/Analyse/Data/ParseWorker.js

@@ -0,0 +1,25 @@
+"use strict";
+exports.__esModule = true;
+var parser_worker_1 = require("@demostf/parser-worker");
+/**
+ * @global postMessage
+ * @param event
+ */
+onmessage = function (event) {
+    var buffer = event.data.buffer;
+    var bytes = new Uint8Array(buffer);
+    (0, parser_worker_1.parseDemo)(bytes, function (progress) {
+        postMessage({
+            progress: progress
+        });
+    }).then(function (parsed) {
+        postMessage({
+            demo: parsed
+        }, [parsed.data.buffer]);
+    })["catch"](function (e) {
+        console.error(e);
+        postMessage({
+            error: e.message
+        });
+    });
+};

script/viewer/Analyse/Data/ParseWorker.ts

@@ -0,0 +1,27 @@
+import {parseDemo} from "@demostf/parser-worker";
+
+declare function postMessage(message: any, transfer?: any[]): void;
+
+/**
+ * @global postMessage
+ * @param event
+ */
+onmessage = (event: MessageEvent) => {
+	const buffer: ArrayBuffer = event.data.buffer;
+	const bytes = new Uint8Array(buffer);
+	parseDemo(bytes, (progress) => {
+		postMessage({
+			progress
+		});
+	}).then(parsed => {
+		postMessage({
+			demo: parsed
+		}, [parsed.data.buffer]);
+	}).catch(e => {
+		console.error(e);
+		postMessage({
+			error: e.message
+		});
+	});
+
+};