@tinacms/mdx 0.0.0-20220718185604 → 0.60.3

package/dist/stringify/index.js

@@ -0,0 +1,195 @@
+/**
+
+Copyright 2021 Forestry.io Holdings, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*/
+import { toMarkdown } from 'mdast-util-to-markdown';
+import { mdxJsxToMarkdown, } from 'mdast-util-mdx-jsx';
+import { eat } from './marks';
+import { stringifyProps } from './acorn';
+export var stringifyMDX = function (value, field, imageCallback) {
+    var _a;
+    if (value === null || value === void 0 ? void 0 : value.children[0]) {
+        if ((value === null || value === void 0 ? void 0 : value.children[0].type) === 'invalid_markdown') {
+            return value.children[0].value;
+        }
+    }
+    var res = toMarkdown(rootElement(value, field, imageCallback), {
+        extensions: [mdxJsxToMarkdown()],
+        listItemIndent: 'one'
+    });
+    var templatesWithMatchers = (_a = field.templates) === null || _a === void 0 ? void 0 : _a.filter(function (template) { return template.match; });
+    var preprocessedString = res;
+    templatesWithMatchers === null || templatesWithMatchers === void 0 ? void 0 : templatesWithMatchers.forEach(function (template) {
+        if (typeof template === 'string') {
+            throw new Error('Global templates are not supported');
+        }
+        if (template.match) {
+            preprocessedString = preprocessedString.replaceAll("<" + template.name + ">`", template.match.start + " ");
+            preprocessedString = preprocessedString.replaceAll("`</" + template.name + ">", " " + template.match.end);
+        }
+    });
+    return preprocessedString;
+};
+export var rootElement = function (content, field, imageCallback) {
+    var children = [];
+    content.children.forEach(function (child) {
+        var value = blockElement(child, field, imageCallback);
+        if (value) {
+            children.push(value);
+        }
+    });
+    return {
+        type: 'root',
+        children: children
+    };
+};
+export var blockElement = function (content, field, imageCallback) {
+    switch (content.type) {
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6':
+            return {
+                type: 'heading',
+                // @ts-ignore Type 'number' is not assignable to type '1 | 2 | 3 | 4 | 5 | 6'
+                depth: { h1: 1, h2: 2, h3: 3, h4: 4, h5: 5, h6: 6 }[content.type],
+                children: eat(content.children, field, imageCallback)
+            };
+        case 'p':
+            // Ignore empty blocks
+            if (content.children.length === 1) {
+                var onlyChild = content.children[0];
+                if (onlyChild && onlyChild.type === 'text' && onlyChild.text === '') {
+                    return null;
+                }
+            }
+            return {
+                type: 'paragraph',
+                children: eat(content.children, field, imageCallback)
+            };
+        case 'code_block':
+            return {
+                type: 'code',
+                lang: content.lang,
+                value: content.value
+            };
+        case 'mdxJsxFlowElement':
+            var _a = stringifyProps(content, field, false, imageCallback), children = _a.children, attributes = _a.attributes;
+            return {
+                type: 'mdxJsxFlowElement',
+                name: content.name,
+                attributes: attributes,
+                children: children
+            };
+        case 'blockquote':
+            return {
+                type: 'blockquote',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: eat(content.children, field, imageCallback)
+                    },
+                ]
+            };
+        case 'hr':
+            return {
+                type: 'thematicBreak'
+            };
+        case 'ol':
+        case 'ul':
+            return {
+                type: 'list',
+                ordered: content.type === 'ol',
+                spread: false,
+                children: content.children.map(function (child) {
+                    return listItemElement(child, field, imageCallback);
+                })
+            };
+        case 'html': {
+            return {
+                type: 'html',
+                value: content.value
+            };
+        }
+        default:
+            throw new Error("BlockElement: " + content.type + " is not yet supported");
+    }
+};
+var listItemElement = function (content, field, imageCallback) {
+    return {
+        type: 'listItem',
+        // spread is always false since we don't support block elements in list items
+        // good explanation of the difference: https://stackoverflow.com/questions/43503528/extra-lines-appearing-between-list-items-in-github-markdown
+        spread: false,
+        children: content.children.map(function (child) {
+            if (child.type === 'lic') {
+                return {
+                    type: 'paragraph',
+                    children: eat(child.children, field, imageCallback)
+                };
+            }
+            return blockContentElement(child, field, imageCallback);
+        })
+    };
+};
+var blockContentElement = function (content, field, imageCallback) {
+    switch (content.type) {
+        case 'blockquote':
+            return {
+                type: 'blockquote',
+                children: content.children.map(function (child) {
+                    // FIXME: text nodes are probably passed in here by the rich text editor
+                    // @ts-ignore
+                    return blockContentElement(child, field, imageCallback);
+                })
+            };
+        case 'p':
+            return {
+                type: 'paragraph',
+                children: eat(content.children, field, imageCallback)
+            };
+        case 'ol':
+        case 'ul':
+            return {
+                type: 'list',
+                ordered: content.type === 'ol',
+                spread: false,
+                children: content.children.map(function (child) {
+                    return listItemElement(child, field, imageCallback);
+                })
+            };
+        default:
+            throw new Error("BlockContentElement: " + content.type + " is not yet supported");
+    }
+};
+export var getMarks = function (content) {
+    var marks = [];
+    if (content.type !== 'text') {
+        return [];
+    }
+    if (content.bold) {
+        marks.push('strong');
+    }
+    if (content.italic) {
+        marks.push('emphasis');
+    }
+    if (content.code) {
+        marks.push('inlineCode');
+    }
+    return marks;
+};

package/dist/stringify/marks.js

@@ -0,0 +1,250 @@
+/**
+
+Copyright 2021 Forestry.io Holdings, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*/
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+import { getMarks } from './index';
+import { stringifyPropsInline } from './acorn';
+var matches = function (a, b) {
+    return a.some(function (v) { return b.includes(v); });
+};
+/**
+ *
+ * Links can contain marks inside them, and in the scenario that there is a link with a single
+ * child with a mark on it, we want to possibly merge those marks with adjacent ones:
+ * ```markdown
+ * *Hello [world](https://example.com)*
+ * ```
+ * Without "flattening" text nodes like this, this shape:
+ * ```js
+ * [
+ *   {
+ *      type: 'text',
+ *      text: 'Hello',
+ *      italic: true
+ *    },
+ *    {
+ *      type: 'link',
+ *      url: 'https://example.com',
+ *      children: [{
+ *        type: 'text',
+ *        text: 'world',
+ *        italic: true
+ *      }]
+ *    }
+ *  ]
+ * ```
+ * Would result in this markdown:
+ * ```markdown
+ * *Hello **[world](https://example.com)*
+ * ```
+ * So instead we place a callback on the text node, treat is any other text node,
+ * and at the end we replace it with it's callback value (inside cleanNodes)
+ */
+var replaceLinksWithTextNodes = function (content) {
+    var newItems = [];
+    content.forEach(function (item) {
+        if (item.type === 'a') {
+            if (item.children.length === 1) {
+                var firstChild = item.children[0];
+                if ((firstChild === null || firstChild === void 0 ? void 0 : firstChild.type) === 'text') {
+                    newItems.push(__assign(__assign({}, firstChild), { linkifyTextNode: function (a) {
+                            return {
+                                type: 'link',
+                                url: item.url,
+                                title: item.title,
+                                children: [text({ text: a.value })]
+                            };
+                        } }));
+                }
+                else {
+                    newItems.push(item);
+                }
+            }
+            else {
+                newItems.push(item);
+            }
+        }
+        else {
+            newItems.push(item);
+        }
+    });
+    return newItems;
+};
+/**
+ * Links should be processed via 'linkifyTextNode', otherwise handle phrasing content
+ */
+var inlineElementExceptLink = function (content, field, imageCallback) {
+    switch (content.type) {
+        case 'a':
+            throw new Error("Unexpected node of type \"a\", link elements should be processed after all inline elements have resolved");
+        case 'img':
+            return {
+                type: 'image',
+                url: imageCallback(content.url),
+                alt: content.alt,
+                title: content.caption
+            };
+        case 'break':
+            return {
+                type: 'break'
+            };
+        case 'mdxJsxTextElement': {
+            var _a = stringifyPropsInline(content, field, imageCallback), attributes = _a.attributes, children = _a.children;
+            return {
+                type: 'mdxJsxTextElement',
+                name: content.name,
+                attributes: attributes,
+                children: children
+            };
+        }
+        case 'html_inline': {
+            return {
+                type: 'html',
+                value: content.value
+            };
+        }
+        default:
+            // @ts-expect-error type is 'never'
+            if (!content.type && typeof content.text === 'string') {
+                return text(content);
+            }
+            throw new Error("InlineElement: " + content.type + " is not supported");
+    }
+};
+var text = function (content) {
+    return {
+        type: 'text',
+        value: content.text
+    };
+};
+export var eat = function (c, field, imageCallback) {
+    var content = replaceLinksWithTextNodes(c);
+    var first = content[0];
+    if (!first) {
+        return [];
+    }
+    if (first && (first === null || first === void 0 ? void 0 : first.type) !== 'text') {
+        // non-text nodes can't be merged. Eg. img, break. So process them and move on to the rest
+        return __spreadArray([
+            inlineElementExceptLink(first, field, imageCallback)
+        ], eat(content.slice(1), field, imageCallback));
+    }
+    var marks = getMarks(first);
+    if (marks.length === 0) {
+        if (first.linkifyTextNode) {
+            return __spreadArray([
+                first.linkifyTextNode(text(first))
+            ], eat(content.slice(1), field, imageCallback));
+        }
+        else {
+            return __spreadArray([text(first)], eat(content.slice(1), field, imageCallback));
+        }
+    }
+    var nonMatchingSiblingIndex = 0;
+    if (content.slice(1).every(function (content, index) {
+        if (matches(marks, getMarks(content))) {
+            return true;
+        }
+        else {
+            nonMatchingSiblingIndex = index;
+            return false;
+        }
+    })) {
+        // Every sibling matches, so capture all of them in this node
+        nonMatchingSiblingIndex = content.length - 1;
+    }
+    var matchingSiblings = content.slice(1, nonMatchingSiblingIndex + 1);
+    var markCounts = {};
+    marks.forEach(function (mark) {
+        var count = 1;
+        matchingSiblings.every(function (sibling, index) {
+            if (getMarks(sibling).includes(mark)) {
+                count = index + 1;
+                return true;
+            }
+        });
+        markCounts[mark] = count;
+    });
+    var count = 0;
+    var markToProcess = null;
+    Object.entries(markCounts).forEach(function (_a) {
+        var mark = _a[0], markCount = _a[1];
+        var m = mark;
+        if (markCount > count) {
+            count = markCount;
+            markToProcess = m;
+        }
+    });
+    if (!markToProcess) {
+        return __spreadArray([text(first)], eat(content.slice(1), field, imageCallback));
+    }
+    if (markToProcess === 'inlineCode') {
+        if (nonMatchingSiblingIndex) {
+            throw new Error("Marks inside inline code are not supported");
+        }
+        return __spreadArray([
+            {
+                type: markToProcess,
+                value: first.text
+            }
+        ], eat(content.slice(nonMatchingSiblingIndex + 1), field, imageCallback));
+    }
+    return __spreadArray([
+        {
+            type: markToProcess,
+            children: eat(__spreadArray([], __spreadArray([first], matchingSiblings).map(function (sibling) {
+                return cleanNode(sibling, markToProcess);
+            })), field, imageCallback)
+        }
+    ], eat(content.slice(nonMatchingSiblingIndex + 1), field, imageCallback));
+};
+var cleanNode = function (node, mark) {
+    if (!mark) {
+        return node;
+    }
+    var cleanedNode = {};
+    var markToClear = {
+        strong: 'bold',
+        emphasis: 'italic',
+        inlineCode: 'code'
+    }[mark];
+    Object.entries(node).map(function (_a) {
+        var key = _a[0], value = _a[1];
+        if (key !== markToClear) {
+            cleanedNode[key] = value;
+        }
+    });
+    if (node.linkifyTextNode) {
+        cleanedNode.callback = node.linkifyTextNode;
+    }
+    return cleanedNode;
+};

package/dist/tests/autotest/_config.d.ts

@@ -0,0 +1,4 @@
+import type { RichTypeInner } from '@tinacms/schema-tools';
+export { output } from '../setup';
+export { parseMDX, stringifyMDX } from '../..';
+export declare const field: RichTypeInner;

package/dist/tests/autotest/_config.js

@@ -0,0 +1,159 @@
+export { output } from '../setup';
+export { parseMDX, stringifyMDX } from '../..';
+export var field = {
+    name: 'body',
+    type: 'rich-text',
+    templates: [
+        {
+            name: 'Greeting',
+            label: 'Greeting',
+            inline: true,
+            fields: [{ type: 'string', name: 'message' }]
+        },
+        {
+            name: 'Blockquote',
+            label: 'Blockquote',
+            fields: [
+                { type: 'string', name: 'author' },
+                { type: 'rich-text', name: 'children' },
+            ]
+        },
+        {
+            name: 'Cta',
+            label: 'Call-to-action',
+            fields: [
+                { type: 'rich-text', name: 'description' },
+                { type: 'rich-text', name: 'children' },
+            ]
+        },
+        {
+            name: 'MaybeShow',
+            label: 'Maybe Show',
+            fields: [{ type: 'boolean', name: 'toggle' }]
+        },
+        {
+            name: 'Count',
+            label: 'Count',
+            fields: [{ type: 'number', name: 'number' }]
+        },
+        {
+            name: 'Tags',
+            label: 'Tags',
+            fields: [{ type: 'string', name: 'items', list: true }]
+        },
+        {
+            name: 'Date',
+            label: 'Date',
+            fields: [{ type: 'datetime', name: 'here' }]
+        },
+        {
+            name: 'Ratings',
+            label: 'Ratings',
+            fields: [{ type: 'number', name: 'value', list: true }]
+        },
+        {
+            name: 'Playground',
+            label: 'Playground',
+            fields: [
+                { type: 'string', name: 'code' },
+                {
+                    name: 'config',
+                    type: 'object',
+                    list: true,
+                    fields: [
+                        {
+                            type: 'string',
+                            name: 'key'
+                        },
+                        {
+                            type: 'string',
+                            name: 'value'
+                        },
+                    ]
+                },
+            ]
+        },
+        {
+            name: 'Action',
+            label: 'Action',
+            fields: [
+                {
+                    type: 'object',
+                    name: 'action',
+                    templates: [
+                        {
+                            label: 'Popup',
+                            name: 'popup',
+                            fields: [
+                                {
+                                    type: 'string',
+                                    name: 'title'
+                                },
+                                {
+                                    type: 'string',
+                                    name: 'descrption'
+                                },
+                            ]
+                        },
+                        {
+                            label: 'Link',
+                            name: 'link',
+                            fields: [
+                                {
+                                    type: 'string',
+                                    name: 'title'
+                                },
+                                {
+                                    type: 'string',
+                                    name: 'url'
+                                },
+                            ]
+                        },
+                    ]
+                },
+            ]
+        },
+        {
+            name: 'Shortcode1',
+            label: 'Shortcode 1',
+            inline: true,
+            match: {
+                start: '{{<',
+                end: '>}}'
+            },
+            fields: [
+                {
+                    name: 'text',
+                    label: 'Text',
+                    type: 'string',
+                    required: true,
+                    isTitle: true,
+                    ui: {
+                        component: 'textarea'
+                    }
+                },
+            ]
+        },
+        {
+            name: 'Shortcode2',
+            label: 'Shortcode 2',
+            inline: true,
+            match: {
+                start: '{{%',
+                end: '%}}'
+            },
+            fields: [
+                {
+                    name: 'text',
+                    required: true,
+                    isTitle: true,
+                    label: 'Text',
+                    type: 'string',
+                    ui: {
+                        component: 'textarea'
+                    }
+                },
+            ]
+        },
+    ]
+};

package/dist/tests/autotest/_runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/autotest/_runner.test.js

@@ -0,0 +1,77 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { describe, expect, it } from 'vitest';
+import { field, parseMDX, stringifyMDX } from './_config';
+import { setupNewTests, writeAutoformatFile, writeTestFile } from '../setup';
+var content = import.meta.glob('./*.md', { as: 'raw' });
+var outputString = import.meta.glob('./*.ts', { as: 'raw' });
+setupNewTests(content, outputString, function (_a) {
+    var name = _a.name, markdownContent = _a.markdownContent;
+    describe("setting up " + name, function () {
+        it("verifies that stringifying the parsed output will match the original string", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var markdownString, astResult, stringResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, markdownContent()];
+                    case 1:
+                        markdownString = _a.sent();
+                        astResult = parseMDX(markdownString, field, function (v) { return v; });
+                        stringResult = stringifyMDX(astResult, field, function (v) { return v; });
+                        try {
+                            expect(stringResult).toEqual(markdownString);
+                            // If `expect` doesn't throw, save the file
+                            writeTestFile(__dirname, name, astResult);
+                        }
+                        catch (e) {
+                            if (name.startsWith('./autoformat')) {
+                                console.log('we shoud write another file', stringResult);
+                                writeTestFile(__dirname, name, astResult, true);
+                                writeAutoformatFile(__dirname, name, stringResult);
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+it("true is true", function () {
+    expect(true).toBe(true);
+});

package/dist/tests/autotest/autoformat block elements in list items.test.d.ts

@@ -0,0 +1 @@
+export {};