@curvenote/schema/dist/cjs/nodes/code.js

Schema and markdown parser for @curvenote/editor

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.toTex = exports.toMarkdown = void 0;
const utils_1 = require("../serialize/tex/utils");
const types_1 = require("./types");
const utils_2 = require("./utils");
const toLanguage = {
    text: 'text/plain',
    js: 'javascript',
    json: 'Json',
    cpp: 'text/x-c++src',
    'c++': 'text/x-c++src',
    c: 'text/x-csrc',
    csharp: 'text/x-csharp',
    objectivec: 'text/x-objectivec',
    java: 'text/x-java',
    scala: 'text/x-scala',
    html: 'htmlmixed',
    yaml: 'text/x-yaml',
};
const fromLanguage = {
    'text/plain': 'text',
    javascript: 'js',
    Json: 'json',
    'text/x-c++src': 'cpp',
    'text/x-csrc': 'c',
    'text/x-csharp': 'csharp',
    'text/x-objectivec': 'objectivec',
    'text/x-java': 'java',
    'text/x-scala': 'scala',
    htmlmixed: 'html',
    'text/x-yaml': 'yaml',
};
function languageToLang(language) {
    if (!language)
        return undefined;
    const translation = fromLanguage[language];
    if (translation)
        return translation;
    return language.toLowerCase();
}
function langToLanguage(lang) {
    if (!lang)
        return undefined;
    const translation = toLanguage[lang.toLowerCase()];
    if (translation)
        return translation;
    return lang.toLowerCase();
}
const code_block = {
    attrs: Object.assign(Object.assign({}, (0, utils_2.getNumberedDefaultAttrs)()), { language: { default: null }, linenumbers: { default: false }, title: { default: '' } }),
    content: `${types_1.NodeGroups.text}*`,
    marks: '',
    group: types_1.NodeGroups.block,
    code: true,
    defining: true,
    parseDOM: [
        {
            tag: 'pre',
            preserveWhitespace: 'full',
            getAttrs(dom) {
                var _a;
                return Object.assign(Object.assign({}, (0, utils_2.getNumberedAttrs)(dom)), { language: dom.getAttribute('language') || null, linenumbers: (0, utils_2.readBooleanDomAttr)(dom, 'linenumbers'), title: (_a = dom.getAttribute('title')) !== null && _a !== void 0 ? _a : '' });
            },
        },
    ],
    toDOM(node) {
        const { language, title, linenumbers } = node.attrs;
        return [
            'pre',
            Object.assign(Object.assign({}, (0, utils_2.setNumberedAttrs)(node.attrs)), { language,
                title, linenumbers: (0, utils_2.convertToBooleanAttribute)(linenumbers) }),
            ['code', 0],
        ];
    },
    attrsFromMyst: (token) => ({
        id: token.identifier || null,
        label: token.label || null,
        numbered: false,
        language: langToLanguage(token.lang) || null,
        linenumbers: token.showLineNumbers || false,
        title: '',
    }),
    toMyst: (props) => {
        var _a;
        if (((_a = props.children) === null || _a === void 0 ? void 0 : _a.length) === 1) {
            return {
                type: 'code',
                lang: languageToLang(props.language || undefined),
                showLineNumbers: props.linenumbers || undefined,
                value: props.children[0].value || '',
            };
        }
        throw new Error(`Code block node does not have one child`);
    },
};
const toMarkdown = (state, node) => {
    var _a, _b, _c;
    const { language } = node.attrs;
    const numTicks = Math.max((_c = (_b = (_a = node.textContent) === null || _a === void 0 ? void 0 : _a.match(/([`]+)/)) === null || _b === void 0 ? void 0 : _b[1].length) !== null && _c !== void 0 ? _c : 0, 2) + 1;
    const fence = '`'.repeat(numTicks);
    state.write(`${fence}${languageToLang(language) || ''}\n`);
    state.text(node.textContent, false);
    state.ensureNewLine();
    state.write(fence);
    state.closeBlock(node);
};
exports.toMarkdown = toMarkdown;
exports.toTex = (0, utils_1.createLatexStatement)(() => ({
    command: 'verbatim',
}), (state, node) => {
    state.renderContent(node);
});
exports.default = code_block;
//# sourceMappingURL=code.js.map