@statechart/scpb/dist/index.mjs

import _Object$keys from 'babel-runtime/core-js/object/keys';
import { Reader, Writer } from 'protobufjs/minimal';
import { decode, encode } from '@statechart/scpb-bitset';

var state = ['compound', 'atomic', 'parallel', 'history_shallow', 'history_deep', 'initial', 'final'];

var transition = ['external', 'targetless', 'internal', 'spontaneous', 'history', 'initial'];

var expression = ['raise', 'cond', 'clause', 'foreach', 'log', 'assign', 'param', 'script', 'send', 'cancel', 'expr', 'literal', 'location', 'script_ext', 'eval'];

function encodeDocument(message, writer) {
    if (!writer) writer = Writer.create();
    if (message.name != null && message.hasOwnProperty("name")) writer.uint32( /* id 1, wireType 2 =*/10).string(message.name);
    var states = message.states || [];
    var stateSize = states.length;
    var transitions = message.transitions || [];
    var transitionSize = transitions.length;
    if (states.length) for (var i = 0; i < states.length; ++i) {
        encodeState(states[i], writer.uint32( /* id 2, wireType 2 =*/18).fork(), stateSize, transitionSize).ldelim();
    }if (transitions.length) for (var _i = 0; _i < transitions.length; ++_i) {
        encodeTransition(transitions[_i], writer.uint32( /* id 3, wireType 2 =*/26).fork(), stateSize, transitionSize).ldelim();
    }if (message.datamodel != null && message.hasOwnProperty("datamodel")) writer.uint32( /* id 4, wireType 2 =*/34).string(message.datamodel);
    if (message.meta != null && message.hasOwnProperty("meta")) for (var keys = _Object$keys(message.meta), _i2 = 0; _i2 < keys.length; ++_i2) {
        writer.uint32( /* id 5, wireType 2 =*/42).fork().uint32( /* id 1, wireType 2 =*/10).string(keys[_i2]).uint32( /* id 2, wireType 2 =*/18).string(message.meta[keys[_i2]]).ldelim();
    }return writer;
}

function encodeState(message, writer, stateSize, transitionSize) {
    if (!writer) writer = Writer.create();
    if (message.type != null && message.hasOwnProperty("type")) writer.uint32( /* id 1, wireType 0 =*/8).uint32(state.indexOf(message.type));
    if (message.idx != null && message.hasOwnProperty("idx")) writer.uint32( /* id 2, wireType 0 =*/16).uint32(message.idx);
    if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 3, wireType 2 =*/26).string(message.id);
    if (message.onEnter != null && message.onEnter.length) for (var i = 0; i < message.onEnter.length; ++i) {
        encodeExpression(message.onEnter[i], writer.uint32( /* id 4, wireType 2 =*/34).fork()).ldelim();
    }if (message.onExit != null && message.onExit.length) for (var _i3 = 0; _i3 < message.onExit.length; ++_i3) {
        encodeExpression(message.onExit[_i3], writer.uint32( /* id 5, wireType 2 =*/42).fork()).ldelim();
    }if (message.invocations != null && message.invocations.length) for (var _i4 = 0; _i4 < message.invocations.length; ++_i4) {
        encodeInvocation(message.invocations[_i4], writer.uint32( /* id 6, wireType 2 =*/50).fork()).ldelim();
    }if (message.data != null && message.data.length) for (var _i5 = 0; _i5 < message.data.length; ++_i5) {
        encodeData(message.data[_i5], writer.uint32( /* id 7, wireType 2 =*/58).fork()).ldelim();
    }if (message.parent != null && message.hasOwnProperty("parent")) writer.uint32( /* id 8, wireType 0 =*/64).uint32(message.parent);
    if (message.children != null && message.hasOwnProperty("children")) writer.uint32( /* id 9, wireType 2 =*/74).bytes(encode(message.children, stateSize));
    if (message.ancestors != null && message.hasOwnProperty("ancestors")) writer.uint32( /* id 10, wireType 2 =*/82).bytes(encode(message.ancestors, stateSize));
    if (message.completion != null && message.hasOwnProperty("completion")) writer.uint32( /* id 11, wireType 2 =*/90).bytes(encode(message.completion, stateSize));
    if (message.transitions != null && message.hasOwnProperty("transitions")) writer.uint32( /* id 12, wireType 2 =*/98).bytes(encode(message.transitions, transitionSize));
    if (message.hasHistory != null && message.hasOwnProperty("hasHistory")) writer.uint32( /* id 13, wireType 0 =*/104).bool(message.hasHistory);
    if (message.name != null && message.hasOwnProperty("name")) writer.uint32( /* id 14, wireType 2 =*/114).string(message.name);
    return writer;
}

function encodeTransition(message, writer, stateSize, transitionSize) {
    if (!writer) writer = Writer.create();
    if (message.type != null && message.hasOwnProperty("type")) writer.uint32( /* id 1, wireType 0 =*/8).uint32(transition.indexOf(message.type));
    if (message.idx != null && message.hasOwnProperty("idx")) writer.uint32( /* id 2, wireType 0 =*/16).uint32(message.idx);
    if (message.source != null && message.hasOwnProperty("source")) writer.uint32( /* id 3, wireType 0 =*/24).uint32(message.source);
    if (message.events != null && message.events.length) for (var i = 0; i < message.events.length; ++i) {
        writer.uint32( /* id 4, wireType 2 =*/34).string(message.events[i]);
    }if (message.condition != null && message.hasOwnProperty("condition")) encodeExpression(message.condition, writer.uint32( /* id 5, wireType 2 =*/42).fork()).ldelim();
    if (message.onTransition != null && message.onTransition.length) for (var _i6 = 0; _i6 < message.onTransition.length; ++_i6) {
        encodeExpression(message.onTransition[_i6], writer.uint32( /* id 6, wireType 2 =*/50).fork()).ldelim();
    }if (message.targets != null && message.hasOwnProperty("targets")) writer.uint32( /* id 7, wireType 2 =*/58).bytes(encode(message.targets, stateSize));
    if (message.conflicts != null && message.hasOwnProperty("conflicts")) writer.uint32( /* id 8, wireType 2 =*/66).bytes(encode(message.conflicts, transitionSize));
    if (message.exits != null && message.hasOwnProperty("exits")) writer.uint32( /* id 9, wireType 2 =*/74).bytes(encode(message.exits, stateSize));
    if (message.name != null && message.hasOwnProperty("name")) writer.uint32( /* id 10, wireType 2 =*/82).string(message.name);
    return writer;
}

function encodeExpression(message, writer) {
    if (!writer) writer = Writer.create();
    if (message.type != null && message.hasOwnProperty("type")) writer.uint32( /* id 1, wireType 0 =*/8).uint32(expression.indexOf(message.type));
    if (message.value != null && message.hasOwnProperty("value")) writer.uint32( /* id 2, wireType 2 =*/18).string(message.value);
    if (message.props != null && message.hasOwnProperty("props")) for (var keys = _Object$keys(message.props), i = 0; i < keys.length; ++i) {
        var value = message.props[keys[i]];
        if (value == null) continue;
        writer.uint32( /* id 3, wireType 2 =*/26).fork().uint32( /* id 1, wireType 2 =*/10).string(keys[i]);
        encodeExpression(value, writer.uint32( /* id 2, wireType 2 =*/18).fork()).ldelim().ldelim();
    }
    if (message.children != null && message.children.length) for (var _i7 = 0; _i7 < message.children.length; ++_i7) {
        encodeExpression(message.children[_i7], writer.uint32( /* id 4, wireType 2 =*/34).fork()).ldelim();
    }return writer;
}

function encodeInvocation(message, writer) {
    if (!writer) writer = Writer.create();
    if (message.type != null && message.hasOwnProperty("type")) encodeExpression(message.type, writer.uint32( /* id 1, wireType 2 =*/10).fork()).ldelim();
    if (message.src != null && message.hasOwnProperty("src")) encodeExpression(message.src, writer.uint32( /* id 2, wireType 2 =*/18).fork()).ldelim();
    if (message.id != null && message.hasOwnProperty("id")) encodeExpression(message.id, writer.uint32( /* id 3, wireType 2 =*/26).fork()).ldelim();
    if (message.params != null && message.params.length) for (var i = 0; i < message.params.length; ++i) {
        encodeExpression(message.params[i], writer.uint32( /* id 4, wireType 2 =*/34).fork()).ldelim();
    }if (message.content != null && message.hasOwnProperty("content")) encodeExpression(message.content, writer.uint32( /* id 5, wireType 2 =*/42).fork()).ldelim();
    if (message.onExit != null && message.onExit.length) for (var _i8 = 0; _i8 < message.onExit.length; ++_i8) {
        encodeExpression(message.onExit[_i8], writer.uint32( /* id 6, wireType 2 =*/50).fork()).ldelim();
    }if (message.autoforward != null && message.hasOwnProperty("autoforward")) writer.uint32( /* id 7, wireType 0 =*/56).bool(message.autoforward);
    return writer;
}

function encodeData(message, writer) {
    if (!writer) writer = Writer.create();
    if (message.id != null && message.hasOwnProperty("id")) writer.uint32( /* id 1, wireType 2 =*/10).string(message.id);
    if (message.value != null && message.hasOwnProperty("value")) encodeExpression(message.value, writer.uint32( /* id 2, wireType 2 =*/18).fork()).ldelim();
    if (message.src != null && message.hasOwnProperty("src")) writer.uint32( /* id 3, wireType 2 =*/26).string(message.src);
    return writer;
}

function decodeDocument(reader, length) {
    if (!(reader instanceof Reader)) reader = Reader.create(reader);
    var end = length === undefined ? reader.len : reader.pos + length,
        message = {
        states: [],
        transitions: [],
        meta: {}
    };
    while (reader.pos < end) {
        var tag = reader.uint32();
        switch (tag >>> 3) {
            case 1:
                message.name = reader.string();
                break;
            case 2:
                message.states.push(decodeState(reader, reader.uint32()));
                break;
            case 3:
                message.transitions.push(decodeTransition(reader, reader.uint32()));
                break;
            case 4:
                message.datamodel = reader.string();
                break;
            case 5:
                reader.skip().pos++;
                var key = reader.string();
                reader.pos++;
                message.meta[key] = reader.string();
                break;
            default:
                reader.skipType(tag & 7);
                break;
        }
    }
    return message;
}

function decodeState(reader, length) {
    if (!(reader instanceof Reader)) reader = Reader.create(reader);
    var end = length === undefined ? reader.len : reader.pos + length,
        message = {
        onEnter: [],
        onExit: [],
        invocations: [],
        data: []
    };
    while (reader.pos < end) {
        var tag = reader.uint32();
        switch (tag >>> 3) {
            case 1:
                message.type = state[reader.uint32()];
                break;
            case 2:
                message.idx = reader.uint32();
                break;
            case 3:
                message.id = reader.string();
                break;
            case 4:
                message.onEnter.push(decodeExpression(reader, reader.uint32()));
                break;
            case 5:
                message.onExit.push(decodeExpression(reader, reader.uint32()));
                break;
            case 6:
                message.invocations.push(decodeInvocation(reader, reader.uint32()));
                break;
            case 7:
                message.data.push(decodeData(reader, reader.uint32()));
                break;
            case 8:
                message.parent = reader.uint32();
                break;
            case 9:
                message.children = decode(reader.bytes());
                break;
            case 10:
                message.ancestors = decode(reader.bytes());
                break;
            case 11:
                message.completion = decode(reader.bytes());
                break;
            case 12:
                message.transitions = decode(reader.bytes());
                break;
            case 13:
                message.hasHistory = reader.bool();
                break;
            case 14:
                message.name = reader.string();
                break;
            default:
                reader.skipType(tag & 7);
                break;
        }
    }
    return message;
}

function decodeTransition(reader, length) {
    if (!(reader instanceof Reader)) reader = Reader.create(reader);
    var end = length === undefined ? reader.len : reader.pos + length,
        message = {
        events: [],
        onTransition: []
    };
    while (reader.pos < end) {
        var tag = reader.uint32();
        switch (tag >>> 3) {
            case 1:
                message.type = transition[reader.uint32()];
                break;
            case 2:
                message.idx = reader.uint32();
                break;
            case 3:
                message.source = reader.uint32();
                break;
            case 4:
                message.events.push(reader.string());
                break;
            case 5:
                message.condition = decodeExpression(reader, reader.uint32());
                break;
            case 6:
                message.onTransition.push(decodeExpression(reader, reader.uint32()));
                break;
            case 7:
                message.targets = decode(reader.bytes());
                break;
            case 8:
                message.conflicts = decode(reader.bytes());
                break;
            case 9:
                message.exits = decode(reader.bytes());
                break;
            case 10:
                message.name = reader.string();
                break;
            default:
                reader.skipType(tag & 7);
                break;
        }
    }
    return message;
}

function decodeExpression(reader, length) {
    if (!(reader instanceof Reader)) reader = Reader.create(reader);
    var end = length === undefined ? reader.len : reader.pos + length,
        message = {
        children: []
    };
    while (reader.pos < end) {
        var tag = reader.uint32();
        switch (tag >>> 3) {
            case 1:
                message.type = expression[reader.uint32()];
                break;
            case 2:
                message.value = reader.string();
                break;
            case 3:
                reader.skip().pos++;
                if (!message.props) message.props = {};
                var key = reader.string();
                reader.pos++;
                message.props[key] = decodeExpression(reader, reader.uint32());
                break;
            case 4:
                message.children.push(decodeExpression(reader, reader.uint32()));
                break;
            default:
                reader.skipType(tag & 7);
                break;
        }
    }
    return message;
}

function decodeInvocation(reader, length) {
    if (!(reader instanceof Reader)) reader = Reader.create(reader);
    var end = length === undefined ? reader.len : reader.pos + length,
        message = {
        params: [],
        onExit: []
    };
    while (reader.pos < end) {
        var tag = reader.uint32();
        switch (tag >>> 3) {
            case 1:
                message.type = decodeExpression(reader, reader.uint32());
                break;
            case 2:
                message.src = decodeExpression(reader, reader.uint32());
                break;
            case 3:
                message.id = decodeExpression(reader, reader.uint32());
                break;
            case 4:
                message.params.push(decodeExpression(reader, reader.uint32()));
                break;
            case 5:
                message.content = decodeExpression(reader, reader.uint32());
                break;
            case 6:
                message.onExit.push(decodeExpression(reader, reader.uint32()));
                break;
            case 7:
                message.autoforward = reader.bool();
                break;
            default:
                reader.skipType(tag & 7);
                break;
        }
    }
    return message;
}

function decodeData(reader, length) {
    if (!(reader instanceof Reader)) reader = Reader.create(reader);
    var end = length === undefined ? reader.len : reader.pos + length,
        message = {};
    while (reader.pos < end) {
        var tag = reader.uint32();
        switch (tag >>> 3) {
            case 1:
                message.id = reader.string();
                break;
            case 2:
                message.value = decodeExpression(reader, reader.uint32());
                break;
            case 3:
                message.src = reader.string();
                break;
            default:
                reader.skipType(tag & 7);
                break;
        }
    }
    return message;
}

export { encodeDocument as encode, decodeDocument as decode };