@gmb/bitmark-parser-generator 1.0.11

package/dist/esm/ast/BaseBuilder.js

@@ -0,0 +1,69 @@
+import { PropertyKey } from '../model/enum/PropertyKey';
+import { ArrayUtils } from '../utils/ArrayUtils';
+import { BooleanUtils } from '../utils/BooleanUtils';
+import { NumberUtils } from '../utils/NumberUtils';
+import { StringUtils } from '../utils/StringUtils';
+class BaseBuilder {
+    /**
+     * Convert example to an Example.
+     * This function recognises boolean strings and converts them to boolean values.
+     *
+     * @param bitmarkText - bitmark text
+     * @returns bitmark text AST as plain JS object
+     */
+    toExample(exampleIn) {
+        if (exampleIn == null)
+            return undefined;
+        let text = '';
+        const isBooleanString = BooleanUtils.isBooleanString(exampleIn);
+        if (isBooleanString) {
+            if (!BooleanUtils.toBoolean(exampleIn))
+                return undefined;
+            return true;
+        }
+        else {
+            text = exampleIn;
+        }
+        return text;
+    }
+    /**
+     * Convert a raw bitmark property to an AST property.
+     *
+     * @param key
+     * @param value
+     * @returns
+     */
+    toAstProperty(key, value) {
+        var _a;
+        const meta = (_a = PropertyKey.getMetadata(key)) !== null && _a !== void 0 ? _a : {};
+        if (value == null)
+            return undefined;
+        // if (key === 'progress') debugger;
+        // Convert property as needed
+        const processValue = (v) => {
+            if (v == null)
+                return undefined;
+            if (meta.isTrimmedString)
+                v = StringUtils.isString(v) ? StringUtils.trimmedString(v) : undefined;
+            if (meta.isNumber)
+                v = NumberUtils.asNumber(v);
+            if (meta.isBoolean)
+                v = BooleanUtils.toBoolean(v, true);
+            if (meta.isInvertedBoolean)
+                v = !BooleanUtils.toBoolean(v, true);
+            return v;
+        };
+        if (Array.isArray(value)) {
+            const valueArray = value;
+            for (let i = 0, len = valueArray.length; i < len; i++) {
+                valueArray[i] = processValue(valueArray[i]);
+            }
+        }
+        else {
+            value = processValue(value);
+        }
+        return ArrayUtils.asArray(value);
+    }
+}
+export { BaseBuilder };
+//# sourceMappingURL=BaseBuilder.js.map

package/dist/esm/ast/BaseBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseBuilder.js","sourceRoot":"","sources":["../../../src/ast/BaseBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAwC,MAAM,2BAA2B,CAAC;AAC9F,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,WAAW;IACf;;;;;;OAMG;IACO,SAAS,CAAC,SAAuC;QACzD,IAAI,SAAS,IAAI,IAAI;YAAE,OAAO,SAAS,CAAC;QACxC,IAAI,IAAI,GAAG,EAAE,CAAC;QAEd,MAAM,eAAe,GAAG,YAAY,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAChE,IAAI,eAAe,EAAE;YACnB,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,SAAS,CAAC;gBAAE,OAAO,SAAS,CAAC;YACzD,OAAO,IAAI,CAAC;SACb;aAAM;YACL,IAAI,GAAG,SAAmB,CAAC;SAC5B;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACO,aAAa,CAAC,GAAoB,EAAE,KAAsC;;QAClF,MAAM,IAAI,GAAG,MAAA,WAAW,CAAC,WAAW,CAAsB,GAAG,CAAC,mCAAI,EAAE,CAAC;QAErE,IAAI,KAAK,IAAI,IAAI;YAAE,OAAO,SAAS,CAAC;QAEpC,oCAAoC;QAEpC,6BAA6B;QAC7B,MAAM,YAAY,GAAG,CAAC,CAAU,EAAE,EAAE;YAClC,IAAI,CAAC,IAAI,IAAI;gBAAE,OAAO,SAAS,CAAC;YAChC,IAAI,IAAI,CAAC,eAAe;gBAAE,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YACjG,IAAI,IAAI,CAAC,QAAQ;gBAAE,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC/C,IAAI,IAAI,CAAC,SAAS;gBAAE,CAAC,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YACxD,IAAI,IAAI,CAAC,iBAAiB;gBAAE,CAAC,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YACjE,OAAO,CAAC,CAAC;QACX,CAAC,CAAC;QACF,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxB,MAAM,UAAU,GAAG,KAAkB,CAAC;YACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;gBACrD,UAAU,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;aAC7C;SACF;aAAM;YACL,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;SAC7B;QAED,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;CACF;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/esm/ast/Builder.js

@@ -0,0 +1,604 @@
+import { BitType } from '../model/enum/BitType';
+import { BodyBitType } from '../model/enum/BodyBitType';
+import { PropertyKey } from '../model/enum/PropertyKey';
+import { TextFormat } from '../model/enum/TextFormat';
+import { ArrayUtils } from '../utils/ArrayUtils';
+import { BitUtils } from '../utils/BitUtils';
+import { NumberUtils } from '../utils/NumberUtils';
+import { ObjectUtils } from '../utils/ObjectUtils';
+import { env } from '../utils/env/Env';
+import { BaseBuilder } from './BaseBuilder';
+import { NodeValidator } from './rules/NodeValidator';
+/**
+ * Builder to build bitmark AST node programmatically
+ */
+class Builder extends BaseBuilder {
+    /**
+     * Build bitmark node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    bitmark(data) {
+        const { bits, errors } = data;
+        const node = {
+            bits,
+            errors,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build bit node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    bit(data) {
+        var _a;
+        const { bitType, textFormat, resourceType, id, externalId, spaceId, padletId, aiGenerated, releaseVersion, ageRange, language, computerLanguage, subtype, coverImage, publisher, publications, author, subject, date, location, theme, kind, action, thumbImage, focusX, focusY, duration, referenceProperty, deeplink, externalLink, externalLinkText, videoCallLink, bot, list, textReference, isTracked, isInfoOnly, labelTrue, labelFalse, book, quotedPerson, partialAnswer, levelProperty, title, subtitle, level, toc, progress, anchor, reference, referenceEnd, item, lead, hint, instruction, example, partner, extraProperties, resource, body, sampleSolution, statement, responses, choices, footer, markup, parser, } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            bitType,
+            textFormat: (_a = TextFormat.fromValue(textFormat)) !== null && _a !== void 0 ? _a : TextFormat.bitmarkMinusMinus,
+            resourceType: BitUtils.calculateValidResourceType(bitType, resourceType, resource),
+            id: this.toAstProperty(PropertyKey.id, id),
+            externalId: this.toAstProperty(PropertyKey.externalId, externalId),
+            spaceId: this.toAstProperty(PropertyKey.spaceId, spaceId),
+            padletId: this.toAstProperty(PropertyKey.padletId, padletId),
+            aiGenerated: this.toAstProperty(PropertyKey.aiGenerated, aiGenerated),
+            releaseVersion: this.toAstProperty(PropertyKey.releaseVersion, releaseVersion),
+            book,
+            ageRange: this.toAstProperty(PropertyKey.ageRange, ageRange),
+            language: this.toAstProperty(PropertyKey.language, language),
+            computerLanguage: this.toAstProperty(PropertyKey.computerLanguage, computerLanguage),
+            subtype: this.toAstProperty(PropertyKey.subtype, subtype),
+            coverImage: this.toAstProperty(PropertyKey.coverImage, coverImage),
+            publisher: this.toAstProperty(PropertyKey.publisher, publisher),
+            publications: this.toAstProperty(PropertyKey.publications, publications),
+            author: this.toAstProperty(PropertyKey.author, author),
+            subject: this.toAstProperty(PropertyKey.subject, subject),
+            date: this.toAstProperty(PropertyKey.date, date),
+            location: this.toAstProperty(PropertyKey.location, location),
+            theme: this.toAstProperty(PropertyKey.theme, theme),
+            kind: this.toAstProperty(PropertyKey.kind, kind),
+            action: this.toAstProperty(PropertyKey.action, action),
+            thumbImage: this.toAstProperty(PropertyKey.thumbImage, thumbImage),
+            focusX: this.toAstProperty(PropertyKey.focusX, focusX),
+            focusY: this.toAstProperty(PropertyKey.focusY, focusY),
+            deeplink: this.toAstProperty(PropertyKey.deeplink, deeplink),
+            externalLink: this.toAstProperty(PropertyKey.externalLink, externalLink),
+            externalLinkText: this.toAstProperty(PropertyKey.externalLinkText, externalLinkText),
+            videoCallLink: this.toAstProperty(PropertyKey.videoCallLink, videoCallLink),
+            bot: this.toAstProperty(PropertyKey.bot, bot),
+            duration: this.toAstProperty(PropertyKey.duration, duration),
+            referenceProperty: this.toAstProperty(PropertyKey.reference, referenceProperty),
+            list: this.toAstProperty(PropertyKey.list, list),
+            textReference: this.toAstProperty(PropertyKey.textReference, textReference),
+            isTracked: this.toAstProperty(PropertyKey.isTracked, isTracked),
+            isInfoOnly: this.toAstProperty(PropertyKey.isInfoOnly, isInfoOnly),
+            labelTrue: this.toAstProperty(PropertyKey.labelTrue, labelTrue),
+            labelFalse: this.toAstProperty(PropertyKey.labelFalse, labelFalse),
+            quotedPerson: this.toAstProperty(PropertyKey.quotedPerson, quotedPerson),
+            partialAnswer: this.toAstProperty(PropertyKey.partialAnswer, partialAnswer),
+            levelProperty: this.toAstProperty(PropertyKey.level, levelProperty),
+            title,
+            subtitle,
+            level: NumberUtils.asNumber(level),
+            toc: this.toAstProperty(PropertyKey.toc, toc),
+            progress: this.toAstProperty(PropertyKey.progress, progress),
+            anchor,
+            reference,
+            referenceEnd,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            partner,
+            resource,
+            body,
+            sampleSolution: ArrayUtils.asArray(sampleSolution),
+            statement,
+            responses,
+            choices,
+            cardNode: this.cardNode(data),
+            footer,
+            markup,
+            parser,
+            // Must always be last in the AST so key clashes are avoided correctly with other properties
+            extraProperties: this.parseExtraProperties(extraProperties),
+        };
+        // Set default values
+        this.setDefaultBitValues(node);
+        // Add the version to the parser info
+        this.addVersionToParserInfo(node);
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        // Validate and correct invalid bits as much as possible
+        return NodeValidator.validateBit(node);
+    }
+    /**
+     * Build choice node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    choice(data) {
+        const { text, isCorrect, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            text,
+            isCorrect,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build response node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    response(data) {
+        const { text, isCorrect, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            text,
+            isCorrect,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build bot response node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    botResponse(data) {
+        const { response, reaction, feedback, item, lead, hint } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            response,
+            reaction,
+            feedback,
+            itemLead: this.itemLead(item, lead),
+            hint,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node, {
+            ignoreEmptyString: ['response', 'reaction', 'feedback'],
+        });
+        return node;
+    }
+    /**
+     * Build quiz node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    quiz(data) {
+        const { choices, responses, item, lead, hint, instruction, example } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            choices,
+            responses,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build heading node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    heading(data) {
+        var _a;
+        const { forKeys, forValues } = data;
+        if (forKeys == null)
+            return undefined;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            forKeys: forKeys || '',
+            forValues: (_a = ArrayUtils.asArray(forValues)) !== null && _a !== void 0 ? _a : [],
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build pair node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    pair(data) {
+        const { key, keyAudio, keyImage, values, item, lead, hint, instruction, example, isCaseSensitive, isShortAnswer } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            key,
+            keyAudio,
+            keyImage,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+            isShortAnswer,
+            values,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build matrix node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    matrix(data) {
+        const { key, cells, item, lead, hint, instruction, example, isCaseSensitive, isShortAnswer } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            key,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+            isShortAnswer,
+            cells,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build matrixCell node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    matrixCell(data) {
+        const { values, item, lead, hint, instruction, example } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            values,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build question node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    question(data) {
+        const { question, partialAnswer, item, lead, hint, instruction, example, isCaseSensitive, isShortAnswer, sampleSolution, } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            itemLead: this.itemLead(item, lead),
+            question,
+            partialAnswer,
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+            isShortAnswer,
+            sampleSolution,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node, { ignoreEmptyString: ['question'], ignoreFalse: ['isShortAnswer'] });
+        return node;
+    }
+    /**
+     * Build body node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    body(data) {
+        const { bodyParts } = data;
+        const node = {
+            bodyParts,
+        };
+        return node;
+    }
+    /**
+     * Build bodyPartText node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    bodyText(data) {
+        const { text } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            type: BodyBitType.text,
+            data: {
+                bodyText: text,
+            },
+        };
+        return node;
+    }
+    /**
+     * Build footer node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    footerText(data) {
+        const { text } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            footerText: text,
+        };
+        return node;
+    }
+    /**
+     * Build gap node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    gap(data) {
+        const { solutions, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            type: BodyBitType.gap,
+            data: {
+                solutions,
+                itemLead: this.itemLead(item, lead),
+                hint,
+                instruction,
+                example: this.toExample(example),
+                isCaseSensitive,
+            },
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build select node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    select(data) {
+        const { options, prefix, postfix, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            type: BodyBitType.select,
+            data: {
+                prefix,
+                options,
+                postfix,
+                itemLead: this.itemLead(item, lead),
+                hint,
+                instruction,
+                example: this.toExample(example),
+                isCaseSensitive,
+            },
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build selectOption node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    selectOption(data) {
+        const { text, isCorrect, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            text,
+            isCorrect,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build highlight node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    highlight(data) {
+        const { texts, prefix, postfix, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            type: BodyBitType.highlight,
+            data: {
+                prefix,
+                texts,
+                postfix,
+                itemLead: this.itemLead(item, lead),
+                hint,
+                instruction,
+                example: this.toExample(example),
+                isCaseSensitive,
+            },
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build highlightText node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    highlightText(data) {
+        const { text, isCorrect, isHighlighted, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            text,
+            isCorrect,
+            isHighlighted,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build statement node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    statement(data) {
+        const { text, isCorrect, item, lead, hint, instruction, example, isCaseSensitive } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            text,
+            isCorrect,
+            itemLead: this.itemLead(item, lead),
+            hint,
+            instruction,
+            example: this.toExample(example),
+            isCaseSensitive,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build (chat) partner node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    partner(data) {
+        const { name, avatarImage } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            name,
+            avatarImage,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    /**
+     * Build comment node
+     *
+     * @param data - data for the node
+     * @returns
+     */
+    comment(data) {
+        const { text, location } = data;
+        // NOTE: Node order is important and is defined here
+        const node = {
+            text,
+            location,
+        };
+        // Remove Unset Optionals
+        ObjectUtils.removeUnwantedProperties(node);
+        return node;
+    }
+    //
+    // Private
+    //
+    itemLead(item, lead) {
+        let node;
+        // NOTE: Node order is important and is defined here
+        if (item || lead) {
+            node = {
+                item,
+                lead,
+            };
+        }
+        return node;
+    }
+    cardNode(data) {
+        let node;
+        const { heading, elements, questions, statements, quizzes, pairs, matrix, botResponses } = data;
+        if (heading || elements || questions || statements || quizzes || pairs || matrix || botResponses) {
+            node = {
+                heading,
+                elements,
+                questions,
+                statements,
+                quizzes,
+                pairs,
+                matrix,
+                botResponses,
+            };
+            // Remove Unset Optionals
+            ObjectUtils.removeUnwantedProperties(node);
+        }
+        return node;
+    }
+    parseExtraProperties(extraProperties) {
+        if (!extraProperties)
+            return undefined;
+        const entries = Object.entries(extraProperties);
+        if (entries.length === 0)
+            return undefined;
+        const res = {};
+        for (const [key, value] of entries) {
+            res[key] = ArrayUtils.asArray(value) || [value];
+        }
+        return res;
+    }
+    setDefaultBitValues(bit) {
+        // Set AIGenerated == true for all AI generated bits
+        switch (bit.bitType) {
+            case BitType.articleAi:
+            case BitType.noteAi:
+            case BitType.summaryAi:
+                bit.aiGenerated = this.toAstProperty(PropertyKey.aiGenerated, true);
+                break;
+        }
+    }
+    addVersionToParserInfo(bit) {
+        var _a;
+        const parser = (_a = bit.parser) !== null && _a !== void 0 ? _a : {};
+        parser.version = env.appVersion.full;
+        bit.parser = parser;
+    }
+}
+export { Builder };
+//# sourceMappingURL=Builder.js.map