Serialization and rehydration

[gotexis]

Would be good to include a serialization guide like the one in this library: https://github.com/NateTheGreatt/bitECS/blob/master/src/Serialize.js

[clibequilibrium]

Would be good to include a serialization guide like the one in this library: https://github.com/NateTheGreatt/bitECS/blob/master/src/Serialize.js

Hi I played around with it. I use simple JSON.stringify combined with pako delfate

import { World } from 'miniplex';
import { Inflate, deflate, inflate } from 'pako';
import { Entity } from '../components';

interface SerializedWorldData {
	entities: Entity[];
}

class WorldSerializer {
	constructor(public readonly world: World<Entity>) {}

	public toJSON(): SerializedWorldData {
		// eslint-disable-next-line @typescript-eslint/no-explicit-any
		const { entities } = this.world as any;

		return {
			entities: entities
		};
	}

	static fromJSON(json: SerializedWorldData): World<Entity> {
		const instance = new WorldSerializer(new World<Entity>(json.entities));
		return instance.world;
	}
}

/**
 * Serializes the world and chunks the array buffer. Uses pako deflate
 * @param world
 * @param chunkSize
 * @returns array of buffers
 */
export function serializeWorld(world: World<Entity>, chunkSize: number): ArrayBuffer[] {
	const deflated = deflate(JSON.stringify(new WorldSerializer(world)));
	const buffers: ArrayBuffer[] = [];

	for (let i = 0; i < deflated.byteLength; i += chunkSize) {
		const chunk = deflated.slice(i, i + chunkSize);
		buffers.push(chunk);
	}

	return buffers;
}

/**
 * Deserializes the world from chunks. Uses pako inflate from provided chunks
 * @param buffers
 * @param maxEntities
 * @returns world
 */
export function deserializeWorld(buffers: ArrayBuffer[] | undefined): World<Entity> {
	let world: World<Entity>;

	// Use pako to inflate the chunks
	if (buffers && buffers.length !== 0) {
		const inflate = new Inflate({ to: 'string' });

		for (let i = 0; i < buffers.length; i++) {
			const chunk = buffers[i];

			if (i >= buffers.length) {
				inflate.push(chunk, true);
			} else {
				inflate.push(chunk, false);
			}
		}

		if (inflate.err) {
			console.error(inflate.err);
			throw new Error(inflate.msg);
		}

		// Deserialize the world from the inflate buffer
		if (inflate.result) {
			world = WorldSerializer.fromJSON(JSON.parse(inflate.result as string));
		} else {
			throw new Error('Fatal error: Inflate result is null during loading.');
		}
	} else {
		world = new World<Entity>();
	}

	return world;
}

It is optimized for both performance and low memory footprint.