serde-ts/dist/de/impl.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Forward = exports.ForwardIterableAccess = exports.ForwardMapAccess = exports.GenericVisitor = exports.GenericSeed = exports.IterableAccess = exports.MapAccess = exports.IterResult = void 0;
exports.deserialize = deserialize;
const registry_1 = require("../registry");
class IterResult {
    static Next(value) {
        return { done: false, value };
    }
    static Done() {
        return { done: true, value: undefined };
    }
}
exports.IterResult = IterResult;
class MapAccess {
    nextEntrySeed(kseed, vseed) {
        const key = this.nextKeySeed(kseed);
        if (!key.done) {
            const value = this.nextValueSeed(vseed);
            if (!value.done) {
                return IterResult.Next([key.value, value.value]);
            }
        }
        return IterResult.Done();
    }
    nextEntry() {
        const key = this.nextKey();
        if (!key.done) {
            const value = this.nextValue();
            if (!value.done) {
                return IterResult.Next([key.value, value.value]);
            }
        }
        return IterResult.Done();
    }
}
exports.MapAccess = MapAccess;
class IterableAccess {
}
exports.IterableAccess = IterableAccess;
class GenericSeed {
    constructor(visitor = new GenericVisitor()) {
        Object.defineProperty(this, "visitor", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.visitor = visitor;
    }
    static deserialize(deserializer, visitor = new GenericVisitor()) {
        return deserializer.deserializeAny(visitor);
    }
    deserialize(deserializer) {
        return GenericSeed.deserialize(deserializer, this.visitor);
    }
}
exports.GenericSeed = GenericSeed;
class GenericVisitor {
    visitBoolean(value) {
        return value;
    }
    visitNumber(value) {
        return value;
    }
    visitBigInt(value) {
        return value;
    }
    visitString(value) {
        return value;
    }
    visitSymbol(value) {
        return value;
    }
    visitNull() {
        return null;
    }
    visitObject(access) {
        const result = [];
        let entry;
        while ((entry = access.nextEntry()) && !entry.done) {
            result.push(entry.value);
        }
        return Object.fromEntries(result);
    }
    visitIterable(access) {
        const result = [];
        let element;
        while ((element = access.nextElement())) {
            result.push(element);
        }
        return result;
    }
}
exports.GenericVisitor = GenericVisitor;
class ForwardMapAccess extends MapAccess {
    constructor(keys, values) {
        super();
        Object.defineProperty(this, "keys", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "values", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "kindex", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 0
        });
        Object.defineProperty(this, "vindex", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 0
        });
        this.keys = keys;
        this.values = values;
    }
    static fromObject(obj) {
        return new ForwardMapAccess(Object.keys(obj), Object.values(obj));
    }
    nextKeySeed(_seed) {
        return this.nextKey();
    }
    nextValueSeed(_seed) {
        return this.nextValue();
    }
    nextKey() {
        if (this.kindex < this.keys.length) {
            return IterResult.Next(this.keys[this.kindex++]);
        }
        else {
            return IterResult.Done();
        }
    }
    nextValue() {
        if (this.vindex < this.values.length) {
            return IterResult.Next(this.values[this.vindex++]);
        }
        else {
            return IterResult.Done();
        }
    }
}
exports.ForwardMapAccess = ForwardMapAccess;
class ForwardIterableAccess extends IterableAccess {
    constructor(items) {
        super();
        Object.defineProperty(this, "items", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "index", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 0
        });
        this.items = items;
    }
    nextElement() {
        if (this.index < this.items.length) {
            return IterResult.Next(this.items[this.index++]);
        }
        else {
            return IterResult.Done();
        }
    }
}
exports.ForwardIterableAccess = ForwardIterableAccess;
class Forward {
    constructor(value) {
        Object.defineProperty(this, "value", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.value = value;
    }
    static with(value) {
        return new this(value);
    }
    deserializeAny(_visitor) {
        throw new Error("Can't forward to deserializeAny");
    }
    deserializeBoolean(visitor) {
        return visitor.visitBoolean(this.value);
    }
    deserializeNumber(visitor) {
        return visitor.visitNumber(this.value);
    }
    deserializeBigInt(visitor) {
        return visitor.visitBigInt(this.value);
    }
    deserializeString(visitor) {
        return visitor.visitString(this.value);
    }
    deserializeSymbol(visitor) {
        return visitor.visitSymbol(this.value);
    }
    deserializeNull(visitor) {
        return visitor.visitNull();
    }
    deserializeObject(visitor) {
        return visitor.visitObject(ForwardMapAccess.fromObject(this.value));
    }
    deserializeIterable(visitor) {
        return visitor.visitIterable(new ForwardIterableAccess(this.value));
    }
    deserializeFunction(_visitor) {
        throw new Error('Method not implemented.');
    }
}
exports.Forward = Forward;
function deserialize(deserializer, into, registry = registry_1.GlobalRegistry) {
    const de = registry.deserializers.get(into);
    if (de == null) {
        throw new ReferenceError(`No deserializer for ${into.name}`);
    }
    else {
        return de(deserializer);
    }
}