@ash.ts/io/dist/io.d.ts

Serialization and deserialization for Ash.ts - an entity component system framework for game development

import { ClassType, Engine } from '@ash.ts/core';
import { Signal1 } from '@ash.ts/signals';

interface EncodedObject {
    type: string;
    value: any;
}
interface EncodedComponent extends EncodedObject {
    id: number;
}
interface EncodedEntity {
    name: string;
    components: number[];
}
interface EncodedData {
    entities: EncodedEntity[];
    components: EncodedComponent[];
}

declare class CodecManager {
    stringToClassMap: Map<string, ClassType<any>>;
    classToStringMap: Map<ClassType<any>, string>;
    private codecs;
    private reflectionCodec;
    constructor(classMap: Map<string, ClassType<any>>);
    getCodecForObject(object: any): ObjectCodec<any> | null;
    getCodecForType(type: ClassType<any>): ObjectCodec<any> | null;
    getCodecForComponent(component: any): ObjectCodec<any>;
    getCodecForComponentType(type: ClassType<any>): ObjectCodec<any>;
    addCustomCodec(codec: ObjectCodec<any>, type: ClassType<any>): void;
    encodeComponent(object: any): EncodedObject | null;
    encodeObject(object: any): EncodedObject | null;
    decodeComponent(object: EncodedObject): any | null;
    decodeObject(object: EncodedObject): any | null;
    decodeIntoComponent(target: any, encoded: EncodedObject): void;
    decodeIntoProperty(parent: any, property: string, encoded: EncodedObject): void;
}

interface ObjectCodec<T> {
    encode(object: T, codecManager: CodecManager): EncodedObject | null;
    decode(object: EncodedObject, codecManager: CodecManager): T | null;
    decodeIntoObject(target: T, object: EncodedObject, codecManager: CodecManager): void;
    decodeIntoProperty(parent: any, property: string, object: EncodedObject, codecManager: CodecManager): void;
}

interface EngineCodec<T> {
    addCustomCodec(codec: ObjectCodec<any>, ...types: any[]): void;
    encodeEngine(engine: Engine): T;
    decodeEngine(encodedData: T, engine: Engine): void;
    decodeOverEngine(encodedData: T, engine: Engine): void;
    encodeComplete: Signal1<EncodedData>;
    decodeComplete: Signal1<Engine>;
}

declare class ObjectEngineCodec implements EngineCodec<EncodedData> {
    private encoder;
    private decoder;
    private codecManager;
    private encodeCompleteSignal;
    private decodeCompleteSignal;
    constructor(classMap: Map<string, ClassType<any>>);
    addCustomCodec(codec: ObjectCodec<any>, ...types: any[]): void;
    encodeEngine(engine: Engine): EncodedData;
    decodeEngine(encodedData: EncodedData, engine: Engine): void;
    decodeOverEngine(encodedData: EncodedData, engine: Engine): void;
    get encodeComplete(): Signal1<EncodedData>;
    get decodeComplete(): Signal1<Engine>;
}

declare class JsonEngineCodec extends ObjectEngineCodec implements EngineCodec<string> {
    encodeEngine(engine: Engine): any;
    decodeEngine(encodedData: any, engine: Engine): void;
    decodeOverEngine(encodedData: any, engine: Engine): void;
}

export { CodecManager, EncodedComponent, EncodedData, EncodedEntity, EncodedObject, EngineCodec, JsonEngineCodec, ObjectCodec, ObjectEngineCodec };