@gravity-ui/markdown-editor 13.0.0

package/build/cjs/utils/node-children.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChildByIndex = exports.getChildByNode = exports.getChildBy = void 0;
+function getChildBy(parent, f) {
+    let result = null;
+    parent.forEach((node, offset, index) => {
+        const child = { node, offset, index };
+        if (f(child)) {
+            result = child;
+        }
+    });
+    return result;
+}
+exports.getChildBy = getChildBy;
+function getChildByNode(parent, child) {
+    return getChildBy(parent, ({ node }) => node === child);
+}
+exports.getChildByNode = getChildByNode;
+function getChildByIndex(parent, childIndex) {
+    return getChildBy(parent, ({ index }) => index === childIndex);
+}
+exports.getChildByIndex = getChildByIndex;

package/build/cjs/utils/nodes.d.ts

@@ -0,0 +1,15 @@
+import { Fragment, Node } from 'prosemirror-model';
+export declare function findFirstTextblockChild(parent: Node | Fragment): {
+    node: Node;
+    offset: number;
+} | null;
+export declare const isNodeEmpty: (node: Node) => boolean;
+export declare const isSelectableNode: (node: Node) => boolean;
+export declare function isCodeBlock(node: Node): boolean;
+export declare type NodeChild = {
+    node: Node;
+    offset: number;
+    index: number;
+};
+export declare function getChildrenOfNode(node: Node | Fragment): NodeChild[];
+export declare function getLastChildOfNode(node: Node | Fragment): NodeChild;

package/build/cjs/utils/nodes.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastChildOfNode = exports.getChildrenOfNode = exports.isCodeBlock = exports.isSelectableNode = exports.isNodeEmpty = exports.findFirstTextblockChild = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_utils_1 = require("prosemirror-utils");
+function findFirstTextblockChild(parent) {
+    if (parent instanceof prosemirror_model_1.Node && (!parent.isBlock || parent.isAtom))
+        return null;
+    for (const child of getChildrenOfNode(parent)) {
+        if (child.node.isTextblock)
+            return child;
+        const nestedTextBlockChild = findFirstTextblockChild(child.node);
+        if (nestedTextBlockChild) {
+            return {
+                node: nestedTextBlockChild.node,
+                offset: child.offset + nestedTextBlockChild.offset,
+            };
+        }
+    }
+    return null;
+}
+exports.findFirstTextblockChild = findFirstTextblockChild;
+const isNodeEmpty = (node) => {
+    const emptyChildren = (0, prosemirror_utils_1.findChildren)(node, (n) => (!n.isText && !n.isAtom && n.content.size === 0) || (n.isText && !n.textContent), true);
+    let descendantsCount = 0;
+    node.descendants(() => {
+        descendantsCount++;
+    });
+    return emptyChildren.length === descendantsCount;
+};
+exports.isNodeEmpty = isNodeEmpty;
+const isSelectableNode = (node) => {
+    if (node.type.spec.selectable === false)
+        return false;
+    if (node.type.isText && node.type.spec.selectable !== true)
+        return false;
+    return true;
+};
+exports.isSelectableNode = isSelectableNode;
+function isCodeBlock(node) {
+    return node.isTextblock && Boolean(node.type.spec.code);
+}
+exports.isCodeBlock = isCodeBlock;
+function getChildrenOfNode(node) {
+    const children = [];
+    node.forEach((node, offset, index) => children.push({ node, offset, index }));
+    return children;
+}
+exports.getChildrenOfNode = getChildrenOfNode;
+function getLastChildOfNode(node) {
+    const children = getChildrenOfNode(node);
+    return children[children.length - 1];
+}
+exports.getLastChildOfNode = getLastChildOfNode;

package/build/cjs/utils/placeholder.d.ts

@@ -0,0 +1,3 @@
+import type { Node, NodeSpec } from 'prosemirror-model';
+export declare type PlaceholderOptions = Record<string, NonNullable<NodeSpec['placeholder']>['content']>;
+export declare const getPlaceholderContent: (node: Node, parent?: Node | null) => string | null;

package/build/cjs/utils/placeholder.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlaceholderContent = void 0;
+const getPlaceholderContent = (node, parent) => {
+    var _a;
+    const content = ((_a = node.type.spec.placeholder) === null || _a === void 0 ? void 0 : _a.content) || '';
+    return typeof content === 'function' ? content(node, parent) : content;
+};
+exports.getPlaceholderContent = getPlaceholderContent;

package/build/cjs/utils/platform.d.ts

@@ -0,0 +1 @@
+export declare const isMac: () => boolean;

package/build/cjs/utils/platform.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMac = void 0;
+const isMac = () => typeof navigator === 'undefined' ? false : /Mac/.test(navigator.platform);
+exports.isMac = isMac;

package/build/cjs/utils/remove-node.d.ts

@@ -0,0 +1,8 @@
+import { Node } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+export declare const removeNode: (params: {
+    node: Node;
+    pos: number;
+    tr: Transaction;
+    dispatch: (tr: Transaction) => void;
+}) => void;

package/build/cjs/utils/remove-node.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeNode = void 0;
+const removeNode = ({ node, pos, tr, dispatch }) => {
+    dispatch(tr.delete(pos, pos + node.nodeSize));
+};
+exports.removeNode = removeNode;

package/build/cjs/utils/rulebuilders.d.ts

@@ -0,0 +1,4 @@
+import { InputRule } from 'prosemirror-inputrules';
+import { Attrs, Node, NodeType } from 'prosemirror-model';
+export declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;
+export declare function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)): InputRule;

package/build/cjs/utils/rulebuilders.js

@@ -0,0 +1,63 @@
+"use strict";
+///
+/// Copy of https://github.com/ProseMirror/prosemirror-inputrules/blob/1.4.0/src/rulebuilders.ts
+/// Added a check for the presence of a code mark
+///
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textblockTypeInputRule = exports.wrappingInputRule = void 0;
+const prosemirror_inputrules_1 = require("prosemirror-inputrules");
+const prosemirror_transform_1 = require("prosemirror-transform");
+const inputrules_1 = require("./inputrules");
+/// Build an input rule for automatically wrapping a textblock when a
+/// given string is typed. The `regexp` argument is
+/// directly passed through to the `InputRule` constructor. You'll
+/// probably want the regexp to start with `^`, so that the pattern can
+/// only occur at the start of a textblock.
+///
+/// `nodeType` is the type of node to wrap in. If it needs attributes,
+/// you can either pass them directly, or pass a function that will
+/// compute them from the regular expression match.
+///
+/// By default, if there's a node with the same type above the newly
+/// wrapped node, the rule will try to [join](#transform.Transform.join) those
+/// two nodes. You can pass a join predicate, which takes a regular
+/// expression match and the node before the wrapped node, and can
+/// return a boolean to indicate whether a join should happen.
+function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new prosemirror_inputrules_1.InputRule(regexp, (state, match, start, end) => {
+        if ((0, inputrules_1.hasCodeMark)(state, match, start, end))
+            return null;
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const tr = state.tr.delete(start, end);
+        const $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && (0, prosemirror_transform_1.findWrapping)(range, nodeType, attrs);
+        if (!wrapping)
+            return null;
+        tr.wrap(range, wrapping);
+        const before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before &&
+            before.type == nodeType &&
+            (0, prosemirror_transform_1.canJoin)(tr.doc, start - 1) &&
+            (!joinPredicate || joinPredicate(match, before)))
+            tr.join(start - 1);
+        return tr;
+    });
+}
+exports.wrappingInputRule = wrappingInputRule;
+/// Build an input rule that changes the type of a textblock when the
+/// matched text is typed into it. You'll usually want to start your
+/// regexp with `^` to that it is only matched at the start of a
+/// textblock. The optional `getAttrs` parameter can be used to compute
+/// the new node's attributes, and works the same as in the
+/// `wrappingInputRule` function.
+function textblockTypeInputRule(regexp, nodeType, getAttrs = null) {
+    return new prosemirror_inputrules_1.InputRule(regexp, (state, match, start, end) => {
+        if ((0, inputrules_1.hasCodeMark)(state, match, start, end))
+            return null;
+        const $start = state.doc.resolve(start);
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
+            return null;
+        return state.tr.delete(start, end).setBlockType(start, start, nodeType, attrs);
+    });
+}
+exports.textblockTypeInputRule = textblockTypeInputRule;

package/build/cjs/utils/schema.d.ts

@@ -0,0 +1,4 @@
+import { Node, NodeType, Schema } from 'prosemirror-model';
+export declare const nodeTypeFactory: (nodeName: string) => (schema: Schema) => NodeType;
+export declare const markTypeFactory: (markName: string) => (schema: Schema) => import("prosemirror-model").MarkType;
+export declare function isSameNodeType(a: Node | NodeType, b: Node | NodeType): boolean;

package/build/cjs/utils/schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameNodeType = exports.markTypeFactory = exports.nodeTypeFactory = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const nodeTypeFactory = (nodeName) => (schema) => schema.nodes[nodeName];
+exports.nodeTypeFactory = nodeTypeFactory;
+const markTypeFactory = (markName) => (schema) => schema.marks[markName];
+exports.markTypeFactory = markTypeFactory;
+function isSameNodeType(a, b) {
+    const aType = a instanceof prosemirror_model_1.Node ? a.type : a;
+    const bType = b instanceof prosemirror_model_1.Node ? b.type : b;
+    return aType === bType;
+}
+exports.isSameNodeType = isSameNodeType;

package/build/cjs/utils/selection.d.ts

@@ -0,0 +1,13 @@
+import type { Node, NodeType, ResolvedPos } from 'prosemirror-model';
+import { NodeSelection, Selection, TextSelection } from 'prosemirror-state';
+export declare const isTextSelection: (selection: Selection) => selection is TextSelection;
+export declare const isNodeSelection: (selection: Selection) => selection is NodeSelection;
+export declare const isWholeSelection: (selection: Selection) => boolean;
+export declare const get$Cursor: (selection: Selection) => ResolvedPos | null;
+export declare function get$CursorAtBlockStart(selection: Selection): ResolvedPos | null;
+export declare const equalNodeType: (nodeType: NodeType[] | NodeType, node: Node) => boolean;
+export declare const findSelectedNodeOfType: (nodeType: NodeType) => (selection: Selection) => {
+    node: Node;
+    pos: number;
+    depth: number;
+} | null;

package/build/cjs/utils/selection.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSelectedNodeOfType = exports.equalNodeType = exports.get$CursorAtBlockStart = exports.get$Cursor = exports.isWholeSelection = exports.isNodeSelection = exports.isTextSelection = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+prosemirror_state_1.NodeSelection.prototype.selectionName = 'NodeSelection';
+prosemirror_state_1.TextSelection.prototype.selectionName = 'TextSelection';
+prosemirror_state_1.AllSelection.prototype.selectionName = 'AllSelection';
+const isTextSelection = (selection) => selection.selectionName === prosemirror_state_1.TextSelection.prototype.selectionName;
+exports.isTextSelection = isTextSelection;
+const isNodeSelection = (selection) => selection.selectionName === prosemirror_state_1.NodeSelection.prototype.selectionName;
+exports.isNodeSelection = isNodeSelection;
+// ts broke down when use "selection is AllSelection" return type
+// maybe because AllSelection has same class type with different constructor
+const isWholeSelection = (selection) => selection.selectionName === prosemirror_state_1.AllSelection.prototype.selectionName;
+exports.isWholeSelection = isWholeSelection;
+const get$Cursor = (selection) => {
+    return (0, exports.isTextSelection)(selection) ? selection.$cursor : null;
+};
+exports.get$Cursor = get$Cursor;
+function get$CursorAtBlockStart(selection) {
+    const $cursor = (0, exports.get$Cursor)(selection);
+    if (!$cursor || $cursor.parentOffset > 0 || $cursor.parent.isInline)
+        return null;
+    return $cursor;
+}
+exports.get$CursorAtBlockStart = get$CursorAtBlockStart;
+const equalNodeType = function equalNodeType(nodeType, node) {
+    return (Array.isArray(nodeType) && nodeType.indexOf(node.type) > -1) || node.type === nodeType;
+};
+exports.equalNodeType = equalNodeType;
+const findSelectedNodeOfType = (nodeType) => {
+    return function (selection) {
+        if ((0, exports.isNodeSelection)(selection)) {
+            const node = selection.node, $from = selection.$from;
+            if ((0, exports.equalNodeType)(nodeType, node)) {
+                return { node: node, pos: $from.pos, depth: $from.depth };
+            }
+        }
+        return null;
+    };
+};
+exports.findSelectedNodeOfType = findSelectedNodeOfType;

package/build/cjs/utils/serialize-for-clipboard.d.ts

@@ -0,0 +1,11 @@
+import type { Slice } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+import { __serializeForClipboard } from 'prosemirror-view';
+declare module 'prosemirror-view' {
+    type SerializeForClipboard = (view: EditorView, slice: Slice) => {
+        dom: HTMLElement;
+        text: string;
+    };
+    const __serializeForClipboard: SerializeForClipboard;
+}
+export { __serializeForClipboard as serializeForClipboard };

package/build/cjs/utils/serialize-for-clipboard.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeForClipboard = void 0;
+const prosemirror_view_1 = require("prosemirror-view");
+Object.defineProperty(exports, "serializeForClipboard", { enumerable: true, get: function () { return prosemirror_view_1.__serializeForClipboard; } });
+if (!prosemirror_view_1.__serializeForClipboard)
+    throw new Error('__serializeForClipboard not exported from prosemirror-view module.');

package/build/cjs/utils/sync-scroll.d.ts

@@ -0,0 +1,19 @@
+import type { RefObject } from 'react';
+export declare type CodeLineElement = {
+    el: HTMLElement;
+    line: number;
+};
+export declare function getElementsForSourceLine(targetLine: number, lines: CodeLineElement[]): {
+    previous: CodeLineElement;
+    next?: CodeLineElement;
+};
+export declare function getElementBounds({ el: element }: CodeLineElement): {
+    top: number;
+    height: number;
+};
+export declare function scrollToRevealSourceLine(line: number, lines: CodeLineElement[], outerRef: React.RefObject<HTMLElement>): void;
+export declare function getEditorLineNumberForOffset(offset: number, lines: CodeLineElement[], outerRef: RefObject<HTMLElement>): number | null;
+export declare function getLineElementsAtPageOffset(offset: number, lines: CodeLineElement[], outerRef: RefObject<HTMLElement>): {
+    previous: CodeLineElement | null;
+    next?: CodeLineElement;
+};

package/build/cjs/utils/sync-scroll.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLineElementsAtPageOffset = exports.getEditorLineNumberForOffset = exports.scrollToRevealSourceLine = exports.getElementBounds = exports.getElementsForSourceLine = void 0;
+function getElementsForSourceLine(targetLine, lines) {
+    const lineNumber = Math.floor(targetLine);
+    let previous = lines[0] || null;
+    for (const entry of lines) {
+        if (entry.line === lineNumber) {
+            return { previous: entry, next: undefined };
+        }
+        else if (entry.line > lineNumber) {
+            return { previous, next: entry };
+        }
+        previous = entry;
+    }
+    return { previous };
+}
+exports.getElementsForSourceLine = getElementsForSourceLine;
+function getElementBounds({ el: element }) {
+    // Some code line elements may contain other code line elements.
+    // In those cases, only take the height up to that child.
+    const codeLineChild = element.querySelector(`.line`);
+    if (codeLineChild) {
+        const height = Math.max(1, codeLineChild.offsetTop - element.offsetTop);
+        return {
+            top: element.offsetTop,
+            height,
+        };
+    }
+    return { top: element.offsetTop, height: element.offsetHeight };
+}
+exports.getElementBounds = getElementBounds;
+function scrollToRevealSourceLine(line, lines, outerRef) {
+    const outer = outerRef.current;
+    if (!outer)
+        return;
+    if (line <= 0) {
+        outer.scroll(outer.scrollLeft, 0);
+        return;
+    }
+    const { previous, next } = getElementsForSourceLine(line, lines);
+    if (!previous) {
+        return;
+    }
+    let scrollTo = 0;
+    const rect = getElementBounds(previous);
+    const previousTop = rect.top;
+    if (next && next.line !== previous.line) {
+        // Between two elements. Go to percentage offset between them.
+        const betweenProgress = (line - previous.line) / (next.line - previous.line);
+        const previousEnd = previousTop + rect.height;
+        const betweenHeight = next.el.offsetTop - previousEnd;
+        scrollTo = previousEnd + betweenProgress * betweenHeight;
+    }
+    else {
+        const progressInElement = line - Math.floor(line);
+        scrollTo = previousTop + rect.height * progressInElement;
+    }
+    scrollTo = Math.abs(scrollTo) < 1 ? Math.sign(scrollTo) : scrollTo;
+    outer.scroll(outer.scrollLeft, Math.max(1, scrollTo));
+}
+exports.scrollToRevealSourceLine = scrollToRevealSourceLine;
+function getEditorLineNumberForOffset(offset, lines, outerRef) {
+    if (!outerRef.current)
+        return null;
+    const { previous, next } = getLineElementsAtPageOffset(offset, lines, outerRef);
+    if (previous) {
+        if (previous.line < 0) {
+            return 0;
+        }
+        const previousBounds = getElementBounds(previous);
+        const offsetFromPrevious = offset - previousBounds.top;
+        if (next) {
+            const progressBetweenElements = offsetFromPrevious / (getElementBounds(next).top - previousBounds.top);
+            return previous.line + progressBetweenElements * (next.line - previous.line);
+        }
+        else {
+            const progressWithinElement = offsetFromPrevious / previousBounds.height;
+            return previous.line + progressWithinElement;
+        }
+    }
+    return null;
+}
+exports.getEditorLineNumberForOffset = getEditorLineNumberForOffset;
+function getLineElementsAtPageOffset(offset, lines, outerRef) {
+    const outer = outerRef.current;
+    if (!outer)
+        return { previous: null };
+    const position = offset;
+    let lo = -1;
+    let hi = lines.length - 1;
+    while (lo + 1 < hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        const bounds = getElementBounds(lines[mid]);
+        if (bounds.top + bounds.height >= position) {
+            hi = mid;
+        }
+        else {
+            lo = mid;
+        }
+    }
+    const hiElement = lines[hi];
+    const hiBounds = getElementBounds(hiElement);
+    if (hi >= 1 && hiBounds.top > position) {
+        const loElement = lines[lo];
+        return { previous: loElement, next: hiElement };
+    }
+    if (hi > 1 && hi < lines.length && hiBounds.top + hiBounds.height > position) {
+        return { previous: hiElement, next: lines[hi + 1] };
+    }
+    return { previous: hiElement };
+}
+exports.getLineElementsAtPageOffset = getLineElementsAtPageOffset;

package/build/cjs/utils/upload.d.ts

@@ -0,0 +1,21 @@
+export declare type FileUploadResult = {
+    url: string;
+    /** override file name */
+    name?: string;
+    /** override file type */
+    type?: string;
+};
+export declare type FileUploadHandler = (file: File) => Promise<FileUploadResult>;
+export declare type UploadSuccessItem = {
+    file: File;
+    result: FileUploadResult;
+};
+export declare type UploadFailedItem = {
+    file: File;
+    error: Error;
+};
+export declare type BatchUploadResult = {
+    success: readonly UploadSuccessItem[];
+    failed: readonly UploadFailedItem[];
+};
+export declare function batchUploadFiles(files: readonly File[], handler: FileUploadHandler, onFileUpload?: (item: UploadSuccessItem) => void, onFileFail?: (item: UploadFailedItem) => void): Promise<BatchUploadResult>;

package/build/cjs/utils/upload.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchUploadFiles = void 0;
+async function batchUploadFiles(files, handler, onFileUpload, onFileFail) {
+    const success = [];
+    const failed = [];
+    await Promise.allSettled(files.map((file) => handler(file)
+        .then((result) => {
+        const item = { result, file };
+        success.push(item);
+        onFileUpload === null || onFileUpload === void 0 ? void 0 : onFileUpload(item);
+    }, (error) => {
+        const item = { error, file };
+        failed.push(item);
+        onFileFail === null || onFileFail === void 0 ? void 0 : onFileFail(item);
+    })
+        .catch(console.error)));
+    return { success, failed };
+}
+exports.batchUploadFiles = batchUploadFiles;

package/build/cjs/version.d.ts

@@ -0,0 +1,2 @@
+/** During build process, the current version will be injected here */
+export declare const VERSION: string;

package/build/cjs/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+/** During build process, the current version will be injected here */
+exports.VERSION = typeof '13.0.0' !== 'undefined' ? '13.0.0' : 'unknown';

package/build/cjs/view/components/YfmHtml/YfmHtml.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { ClassNameProps } from '../../../classname';
+export declare type YfmHtmlProps = ClassNameProps & {
+    html: string;
+    linksVisited?: boolean;
+    noListReset?: boolean;
+    qa?: string;
+};
+export declare const YfmHtml: React.ForwardRefExoticComponent<ClassNameProps & {
+    html: string;
+    linksVisited?: boolean | undefined;
+    noListReset?: boolean | undefined;
+    qa?: string | undefined;
+} & React.RefAttributes<HTMLDivElement>>;

package/build/cjs/view/components/YfmHtml/YfmHtml.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YfmHtml = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importStar(require("react"));
+const classnames_1 = require("@bem-react/classnames");
+exports.YfmHtml = (0, react_1.forwardRef)(function YfmHtml(props, ref) {
+    const { html, linksVisited, noListReset, className, qa } = props;
+    return (react_1.default.createElement("div", { ref: ref, dangerouslySetInnerHTML: { __html: html }, className: (0, classnames_1.classnames)('yfm', linksVisited ? 'yfm_links-visited' : undefined, noListReset ? 'yfm_no-list-reset' : undefined, className), "data-qa": qa }));
+});

package/build/cjs/view/components/YfmHtml/index.d.ts

@@ -0,0 +1 @@
+export * from './YfmHtml';

package/build/cjs/view/components/YfmHtml/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./YfmHtml"), exports);

package/build/cjs/view/components/index.d.ts

@@ -0,0 +1 @@
+export * from './YfmHtml';

package/build/cjs/view/components/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./YfmHtml"), exports);

package/build/cjs/view/hocs/withLatex/index.d.ts

@@ -0,0 +1,11 @@
+import React, { ComponentType, RefAttributes } from 'react';
+import type { PluginRuntime, TransformMeta } from './types';
+export declare type WithLatexOptions = {
+    runtime: PluginRuntime;
+};
+export declare type WithLatexProps = {
+    meta: TransformMeta;
+};
+export declare function withLatex(opts: WithLatexOptions): <T extends {
+    html: string;
+}>(Component: React.ComponentType<T & React.RefAttributes<HTMLDivElement>>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<T & WithLatexProps> & React.RefAttributes<HTMLDivElement>>;

package/build/cjs/view/hocs/withLatex/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withLatex = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importStar(require("react"));
+const react_2 = require("@diplodoc/latex-extension/react");
+const useLatexRuntime_1 = require("./useLatexRuntime");
+function withLatex(opts) {
+    return (Component) => (0, react_1.forwardRef)(function WithLatex(props, ref) {
+        const { meta, html } = props;
+        const renderLatex = (0, react_2.useLatex)();
+        (0, useLatexRuntime_1.useLatexRuntime)(meta, opts.runtime);
+        (0, react_1.useEffect)(() => {
+            renderLatex({ throwOnError: false });
+        }, [html, renderLatex]);
+        return react_1.default.createElement(Component, Object.assign({}, props, { ref: ref }));
+    });
+}
+exports.withLatex = withLatex;

package/build/cjs/view/hocs/withLatex/types.d.ts

@@ -0,0 +1,3 @@
+import type { PluginOptions } from '@diplodoc/latex-extension/plugin/transform';
+export type { TransformMeta } from '../../types';
+export declare type PluginRuntime = PluginOptions['runtime'];

package/build/cjs/view/hocs/withLatex/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/view/hocs/withLatex/useLatexRuntime.d.ts

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

package/build/cjs/view/hocs/withLatex/useLatexRuntime.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLatexRuntime = void 0;
+/** @internal */
+function useLatexRuntime(meta, runtime) {
+    var _a, _b;
+    const [script, style] = typeof runtime === 'string' ? [runtime, runtime] : [runtime.script, runtime.style];
+    if ((_a = meta === null || meta === void 0 ? void 0 : meta.script) === null || _a === void 0 ? void 0 : _a.includes(script)) {
+        Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "latex-runtime" */ '@diplodoc/latex-extension/runtime')));
+    }
+    if ((_b = meta === null || meta === void 0 ? void 0 : meta.style) === null || _b === void 0 ? void 0 : _b.includes(style)) {
+        // @ts-expect-error // no types for styles
+        Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "latex-styles" */ '@diplodoc/latex-extension/runtime/styles')));
+    }
+}
+exports.useLatexRuntime = useLatexRuntime;

package/build/cjs/view/hocs/withMermaid/index.d.ts

@@ -0,0 +1,14 @@
+import React, { ComponentType, RefAttributes } from 'react';
+import { useMermaid } from '@diplodoc/mermaid-extension/react';
+import type { PluginRuntime, TransformMeta } from './types';
+export declare type MermaidConfig = Parameters<ReturnType<typeof useMermaid>>[0];
+export declare type WithMermaidOptions = {
+    runtime: PluginRuntime;
+};
+export declare type WithMermaidProps = {
+    meta: TransformMeta;
+    mermaidConfig: MermaidConfig;
+};
+export declare function withMermaid(opts: WithMermaidOptions): <T extends {
+    html: string;
+}>(Component: React.ComponentType<T & React.RefAttributes<HTMLDivElement>>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<T & WithMermaidProps> & React.RefAttributes<HTMLDivElement>>;