@npmstuff/argdown-core/dist-esm/model/model.js

A pluggable parser for the Argdown argumentation syntax

export var ArgdownTypes;
(function (ArgdownTypes) {
    ArgdownTypes["EQUIVALENCE_CLASS"] = "equivalence-class";
    ArgdownTypes["STATEMENT"] = "statement";
    ArgdownTypes["STATEMENT_REFERENCE"] = "statement-reference";
    ArgdownTypes["ARGUMENT"] = "argument";
    ArgdownTypes["RELATION"] = "relation";
    ArgdownTypes["INFERENCE"] = "inference";
    ArgdownTypes["STATEMENT_MAP_NODE"] = "statement-map-node";
    ArgdownTypes["ARGUMENT_MAP_NODE"] = "argument-map-node";
    ArgdownTypes["GROUP_MAP_NODE"] = "group-map-node";
    ArgdownTypes["MAP_EDGE"] = "map-edge";
    ArgdownTypes["SECTION"] = "section";
    ArgdownTypes["RULE_NODE"] = "rule-node";
    ArgdownTypes["TOKEN_NODE"] = "token-node";
})(ArgdownTypes || (ArgdownTypes = {}));
export var RelationType;
(function (RelationType) {
    RelationType["ATTACK"] = "attack";
    RelationType["SUPPORT"] = "support";
    RelationType["ENTAILS"] = "entails";
    RelationType["CONTRARY"] = "contrary";
    RelationType["CONTRADICTORY"] = "contradictory";
    RelationType["UNDERCUT"] = "undercut";
})(RelationType || (RelationType = {}));
export var RangeType;
(function (RangeType) {
    RangeType["BOLD"] = "bold";
    RangeType["ITALIC"] = "italic";
    RangeType["LINK"] = "link";
    RangeType["TAG"] = "tag";
    RangeType["STATEMENT_MENTION"] = "statement-mention";
    RangeType["ARGUMENT_MENTION"] = "argument-mention";
    RangeType["SPECIAL_CHAR"] = "special-char";
})(RangeType || (RangeType = {}));
export var IRuleNode;
(function (IRuleNode) {
    IRuleNode.create = (name, children) => {
        const firstChild = children[0];
        const lastChild = children[children.length - 1];
        if (!firstChild || !lastChild) {
            return {
                type: ArgdownTypes.RULE_NODE,
                name,
                children: []
            };
        }
        return {
            type: ArgdownTypes.RULE_NODE,
            name,
            startLine: firstChild.startLine,
            startColumn: firstChild.startColumn,
            endLine: lastChild.endLine,
            endColumn: lastChild.endColumn,
            children
        };
    };
})(IRuleNode || (IRuleNode = {}));
export var IArgument;
(function (IArgument) {
    IArgument.getCanonicalMember = (a) => {
        if (!a.members || a.members.length <= 0) {
            return undefined;
        }
        let defaultCanonical = undefined;
        for (let i = a.members.length - 1; i >= 0; i--) {
            const current = a.members[i];
            if (!current.isReference) {
                if (current.data && current.data.isCanonical) {
                    return current;
                }
                if (!defaultCanonical) {
                    defaultCanonical = current;
                }
            }
        }
        return defaultCanonical;
    };
    IArgument.getCanonicalMemberText = (a) => {
        const s = IArgument.getCanonicalMember(a);
        if (s) {
            return s.text;
        }
        return;
    };
})(IArgument || (IArgument = {}));
export var StatementRole;
(function (StatementRole) {
    StatementRole["PREMISE"] = "premise";
    StatementRole["INTERMEDIARY_CONCLUSION"] = "intermediary-conclusion";
    StatementRole["MAIN_CONCLUSION"] = "main-conclusion";
    StatementRole["ARGUMENT_DESCRIPTION"] = "argument-description";
    StatementRole["TOP_LEVEL_STATEMENT"] = "top-level-statement";
    StatementRole["RELATION_STATEMENT"] = "relation-statement";
})(StatementRole || (StatementRole = {}));
export var IEquivalenceClass;
(function (IEquivalenceClass) {
    IEquivalenceClass.create = (title) => {
        return {
            type: ArgdownTypes.EQUIVALENCE_CLASS,
            title,
            relations: [],
            members: []
        };
    };
    IEquivalenceClass.getCanonicalMember = (ec) => {
        if (!ec.members || ec.members.length <= 0) {
            return undefined;
        }
        let defaultCanonical = undefined;
        for (let i = ec.members.length - 1; i >= 0; i--) {
            const current = ec.members[i];
            if (!current.isReference) {
                if (current.data && current.data.isCanonical) {
                    return current;
                }
                if (!defaultCanonical) {
                    defaultCanonical = current;
                }
            }
        }
        return defaultCanonical;
    };
    IEquivalenceClass.getCanonicalMemberText = (ec) => {
        let statement = IEquivalenceClass.getCanonicalMember(ec);
        if (statement) {
            return statement.text;
        }
        return;
    };
})(IEquivalenceClass || (IEquivalenceClass = {}));
export var IRelation;
(function (IRelation) {
    IRelation.toString = (r) => {
        return `Relation(from: ${r.from.title}, to: ${r.to.title}, relationType: ${r.relationType})`;
    };
    IRelation.isSymmetric = (r) => {
        return (r.relationType === RelationType.CONTRARY ||
            r.relationType === RelationType.CONTRADICTORY);
    };
})(IRelation || (IRelation = {}));
export var IMapEdge;
(function (IMapEdge) {
    IMapEdge.toString = (e) => {
        return `Edge(type: ${e.type} from: ${e.from.title} to: ${e.to.title})`;
    };
})(IMapEdge || (IMapEdge = {}));
export const isGroupMapNode = (n) => {
    return n.type === ArgdownTypes.GROUP_MAP_NODE;
};
export const isRuleNode = (n) => {
    return n.type === ArgdownTypes.RULE_NODE;
};
export const isTokenNode = (n) => {
    return !n.type && n.tokenType != null;
};
export const isReconstructed = (a) => {
    return a.pcs !== undefined && a.pcs.length > 0;
};
export const isConclusion = (s) => {
    return ((s.role === StatementRole.INTERMEDIARY_CONCLUSION ||
        s.role === StatementRole.MAIN_CONCLUSION) &&
        s.inference != undefined);
};
export const isPCSStatement = (s) => {
    return (s.role === StatementRole.PREMISE ||
        s.role === StatementRole.INTERMEDIARY_CONCLUSION ||
        s.role == StatementRole.MAIN_CONCLUSION);
};
//# sourceMappingURL=model.js.map