@squiz/formatted-text-editor 0.0.0-rbv2-20240530041851

package/lib/utils/converters/remirrorNodeToSquizNode/remirrorNodeToSquizNode.d.ts

@@ -0,0 +1,11 @@
+import { ProsemirrorNode } from 'remirror';
+import { FORMATTED_TEXT_MODELS as FormattedTextModels } from '@squiz/dx-json-schema-lib';
+type FormattedText = FormattedTextModels.v1.FormattedText;
+export declare const resolveNodeTag: (node: ProsemirrorNode) => string;
+/**
+ * Converts Remirror node JSON structure to Squiz component JSON structure.
+ * @param {ProsemirrorNode} node Remirror node to convert to component.
+ * @returns {FormattedText} The converted Squiz component JSON.
+ */
+export declare const remirrorNodeToSquizNode: (node: ProsemirrorNode) => FormattedText | undefined;
+export {};

package/lib/utils/converters/remirrorNodeToSquizNode/remirrorNodeToSquizNode.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remirrorNodeToSquizNode = exports.resolveNodeTag = void 0;
+const remirror_1 = require("remirror");
+const undefinedIfEmpty_1 = require("../../undefinedIfEmpty");
+const Extensions_1 = require("../../../Extensions/Extensions");
+const resolveNodeTag = (node) => {
+    if (node.type.name === Extensions_1.NodeName.Text) {
+        return 'span';
+    }
+    if (node.type.name === Extensions_1.NodeName.CodeBlock) {
+        return 'code';
+    }
+    if (node.type.spec?.toDOM) {
+        const domNode = node.type.spec.toDOM(node);
+        if (domNode instanceof window.Node) {
+            return domNode.nodeName.toLowerCase();
+        }
+        if (typeof domNode === 'object' && 'dom' in domNode && domNode.dom instanceof window.Node) {
+            return domNode.dom.nodeName.toLowerCase();
+        }
+        if (domNode instanceof Array) {
+            // [ tag, attributes, ...children ]
+            return domNode[0].toLowerCase();
+        }
+    }
+    throw new Error('Unexpected Remirror node encountered, cannot resolve tag.');
+};
+exports.resolveNodeTag = resolveNodeTag;
+const resolveFormattingOptions = (node) => {
+    const formattingOptions = {};
+    const textAlignment = node.attrs.nodeTextAlignment;
+    const textAlignmentMap = {
+        none: undefined,
+        left: 'left',
+        right: 'right',
+        center: 'center',
+        start: 'left',
+        end: 'right',
+        justify: 'justify',
+    };
+    if (textAlignment && textAlignmentMap[textAlignment]) {
+        formattingOptions.alignment = textAlignmentMap[textAlignment];
+    }
+    return formattingOptions;
+};
+const resolveFontOptions = (node) => {
+    const fontOptions = {};
+    node.marks.forEach((mark) => {
+        switch (mark.type.name) {
+            case 'underline':
+                fontOptions.underline = true;
+                break;
+        }
+    });
+    return fontOptions;
+};
+const transformAttributes = (attributes, nodeType) => {
+    const transformed = {};
+    Object.keys(attributes).forEach((key) => {
+        // Component service requires attributes to be a string, cast as needed.
+        if (typeof attributes[key] === 'string' || typeof attributes[key] === 'number') {
+            transformed[key] = String(attributes[key]);
+        }
+    });
+    // We assign an attribute here for table controller cells as we need to differentiate
+    // between them and regular table headers (th)
+    if (nodeType === Extensions_1.NodeName.TableControllerCell) {
+        transformed[nodeType] = 'true';
+    }
+    // Another check here for more specific attributes for tables (column widths)
+    if (nodeType === Extensions_1.NodeName.TableControllerCell || nodeType === Extensions_1.NodeName.tableCell) {
+        if (Array.isArray(attributes.colwidth) && attributes.colwidth[0]) {
+            transformed.colwidth = String(attributes.colwidth[0]);
+        }
+    }
+    return transformed;
+};
+const transformFragment = (fragment) => {
+    const transformed = [];
+    fragment.forEach((child) => {
+        transformed.push(transformNode(child));
+    });
+    return transformed;
+};
+const transformNode = (node) => {
+    const formattingOptions = (0, undefinedIfEmpty_1.undefinedIfEmpty)(resolveFormattingOptions(node));
+    const font = (0, undefinedIfEmpty_1.undefinedIfEmpty)(resolveFontOptions(node));
+    let attributes;
+    if (node.type.name === Extensions_1.NodeName.Image ||
+        node.type.name === Extensions_1.NodeName.CodeBlock ||
+        node.type.name === Extensions_1.NodeName.TableControllerCell ||
+        node.type.name === Extensions_1.NodeName.tableCell) {
+        attributes = transformAttributes(node.attrs, node.type.name);
+    }
+    let transformedNode = { type: 'text', value: node.text || '' };
+    // Squiz "text" nodes can't have formatting/font options but Remirror "text" nodes can.
+    // If the node has formatting options wrap in a tag.
+    // If the node isn't a text type assume it is a tag type and wrap in a tag.
+    // If we pick the wrong tag here it will be corrected later as part of looping through the
+    // non-font marks.
+    if (node.type.name !== Extensions_1.NodeName.Text || attributes || formattingOptions || font) {
+        transformedNode = {
+            type: 'tag',
+            tag: (0, exports.resolveNodeTag)(node),
+            children: node.type.name === Extensions_1.NodeName.Text ? [transformedNode] : transformFragment(node.content),
+            attributes,
+            formattingOptions,
+            font,
+        };
+    }
+    if (node.type.name === Extensions_1.NodeName.AssetImage) {
+        transformedNode = {
+            type: 'matrix-image',
+            matrixAssetId: node.attrs.matrixAssetId,
+            matrixIdentifier: node.attrs.matrixIdentifier,
+            matrixDomain: node.attrs.matrixDomain,
+        };
+    }
+    node.marks.forEach((mark) => {
+        transformedNode = transformMark(mark, transformedNode);
+    });
+    if (node.type.name === Extensions_1.NodeName.Unsupported) {
+        const unsupportedNode = node.attrs?.originalNode;
+        return { ...unsupportedNode };
+    }
+    return transformedNode;
+};
+/**
+ * Merges 2 nodes together if they are compatible without losing any important details.
+ * Otherwise will wrap the node.
+ *
+ * @param {FormattedNode} node
+ * @param {FormattedNodeWithChildren} wrappingNode
+ *
+ * @return {FormattedNode}
+ */
+const wrapNodeIfNeeded = (node, wrappingNode, copyFont = true) => {
+    const wrappingNodeChildren = wrappingNode.children || [];
+    if (node.type === 'tag' && wrappingNode.type === 'tag' && (node.tag === 'span' || node.tag === wrappingNode.tag)) {
+        const nodeChildren = node.children || [];
+        // if the node we are wrapping with is a DOM node, and the node being wrapped is
+        // a plain looking DOM node merge the 2 nodes.
+        return {
+            ...node,
+            ...wrappingNode,
+            formattingOptions: (0, undefinedIfEmpty_1.undefinedIfEmpty)({
+                ...node.formattingOptions,
+                ...wrappingNode.formattingOptions,
+            }),
+            attributes: (0, undefinedIfEmpty_1.undefinedIfEmpty)({
+                ...node.attributes,
+                ...wrappingNode.attributes,
+            }),
+            font: (0, undefinedIfEmpty_1.undefinedIfEmpty)(copyFont
+                ? {
+                    ...node.font,
+                    ...wrappingNode.font,
+                }
+                : {}),
+            children: [...nodeChildren, ...wrappingNodeChildren],
+        };
+    }
+    // if the node we are wrapping or the wrapping nodes are not compatible merge them.
+    return {
+        ...wrappingNode,
+        children: [node, ...wrappingNodeChildren],
+    };
+};
+const transformMark = (mark, node) => {
+    switch (mark.type.name) {
+        case 'bold':
+            return wrapNodeIfNeeded(node, {
+                type: 'tag',
+                tag: 'strong',
+                children: [],
+            }, false);
+        case 'italic':
+            return wrapNodeIfNeeded(node, {
+                type: 'tag',
+                tag: 'em',
+                children: [],
+            }, false);
+        case 'underline':
+            return wrapNodeIfNeeded(node, {
+                type: 'tag',
+                tag: 'span',
+                children: [],
+                font: {
+                    underline: mark.type.name === 'underline',
+                },
+            });
+        case 'link':
+            return wrapNodeIfNeeded(node, {
+                type: 'tag',
+                tag: 'a',
+                attributes: transformAttributes(mark.attrs),
+                children: [],
+            }, false);
+        case 'assetLink':
+            return wrapNodeIfNeeded(node, {
+                type: 'link-to-matrix-asset',
+                target: mark.attrs.target,
+                matrixIdentifier: mark.attrs.matrixIdentifier,
+                matrixDomain: mark.attrs.matrixDomain,
+                matrixAssetId: mark.attrs.matrixAssetId,
+                children: [],
+            });
+    }
+    throw new Error(`Unsupported mark "${mark.type.name}" was applied to node.`);
+};
+/**
+ * Converts Remirror node JSON structure to Squiz component JSON structure.
+ * @param {ProsemirrorNode} node Remirror node to convert to component.
+ * @returns {FormattedText} The converted Squiz component JSON.
+ */
+const remirrorNodeToSquizNode = (node) => {
+    if (node?.type?.name !== 'doc') {
+        throw new Error('Unable to convert from Remirror to Node data structure, unexpected node provided.');
+    }
+    // Squiz FormattedText should be set to undefined
+    // To allow validation on required values
+    if ((0, remirror_1.isDocNodeEmpty)(node) || node.childCount === 0) {
+        return undefined;
+    }
+    const transformedFragment = transformFragment(node.content);
+    return transformedFragment;
+};
+exports.remirrorNodeToSquizNode = remirrorNodeToSquizNode;

package/lib/utils/converters/squizNodeToRemirrorNode/squizNodeToRemirrorNode.d.ts

@@ -0,0 +1,9 @@
+import { RemirrorJSON } from '@remirror/core';
+import { FORMATTED_TEXT_MODELS as FormattedTextModels } from '@squiz/dx-json-schema-lib';
+/**
+ * Converts Squiz component JSON structure to Remirror node JSON structure.
+ * @param {FormattedText} nodes Squiz nodes to convert to Remirror.
+ * @export
+ * @returns {RemirrorJSON} The converted Remirror JSON.
+ */
+export declare const squizNodeToRemirrorNode: (nodes?: FormattedTextModels.v1.FormattedText) => RemirrorJSON;

package/lib/utils/converters/squizNodeToRemirrorNode/squizNodeToRemirrorNode.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squizNodeToRemirrorNode = void 0;
+const undefinedIfEmpty_1 = require("../../undefinedIfEmpty");
+const Extensions_1 = require("../../../Extensions/Extensions");
+const getNodeType = (node) => {
+    const typeMap = {
+        'link-to-matrix-asset': Extensions_1.NodeName.Text,
+        'matrix-image': Extensions_1.NodeName.AssetImage,
+        text: 'text',
+    };
+    const tagMap = {
+        h1: 'heading',
+        h2: 'heading',
+        h3: 'heading',
+        h4: 'heading',
+        h5: 'heading',
+        h6: 'heading',
+        img: 'image',
+        pre: 'preformatted',
+        p: 'paragraph',
+        ol: 'orderedList',
+        li: 'listItem',
+        ul: 'bulletList',
+        hr: 'horizontalRule',
+        table: 'table',
+        tr: 'tableRow',
+        th: 'tableHeaderCell',
+        td: 'tableCell',
+        a: Extensions_1.NodeName.Text,
+        em: Extensions_1.NodeName.Text,
+        span: Extensions_1.NodeName.Text,
+        strong: Extensions_1.NodeName.Text,
+        code: Extensions_1.NodeName.CodeBlock,
+        br: Extensions_1.NodeName.hardBreak,
+    };
+    if (typeMap[node.type]) {
+        return typeMap[node.type];
+    }
+    if (node.type === 'tag' && tagMap[node.tag]) {
+        // This is a specific check case for tables as there are some <th> tags which need to be returned
+        // as table controller cells.
+        if (node.attributes?.tableControllerCell) {
+            return 'tableControllerCell';
+        }
+        // Return regular tag for everything else
+        return tagMap[node.tag];
+    }
+    // Unsupported node type
+    throw new Error(node.type === 'tag'
+        ? `Unsupported node type provided: ${node.type} (tag: ${node.tag})`
+        : `Unsupported node type provided: ${node.type}`);
+};
+const getNodeAttributes = (node) => {
+    if (node.type === 'tag' && node.tag === 'table') {
+        return {
+            isControllersInjected: true,
+        };
+    }
+    if (node.type === 'tag' && (node.tag === 'th' || node.tag === 'td')) {
+        return {
+            colspan: parseInt(node.attributes?.colspan ?? '1'),
+            rowspan: parseInt(node.attributes?.rowspan ?? '1'),
+            colwidth: node.attributes?.colwidth ? [parseInt(node.attributes.colwidth)] : null,
+            background: null,
+        };
+    }
+    if (node.type === 'tag' && node.tag === 'img') {
+        return {
+            alt: node.attributes?.alt,
+            height: node.attributes?.height,
+            width: node.attributes?.width,
+            src: node.attributes?.src,
+            title: node.attributes?.title,
+        };
+    }
+    else if (node.type === 'tag' && node.tag === 'code') {
+        return {
+            language: node.attributes?.language || 'markup',
+            wrap: node.attributes?.wrap || true,
+        };
+    }
+    else if (node.type === 'matrix-image') {
+        return {
+            matrixAssetId: node.matrixAssetId,
+            matrixDomain: node.matrixDomain,
+            matrixIdentifier: node.matrixIdentifier,
+        };
+    }
+    else if (node.type === 'tag') {
+        return {
+            nodeIndent: null,
+            nodeTextAlignment: node.formattingOptions?.alignment || null,
+            nodeLineHeight: null,
+            style: '',
+            level: node.tag?.startsWith('h') ? parseInt(node.tag.substring(1)) : undefined,
+        };
+    }
+    return {};
+};
+const getNodeMarks = (node) => {
+    const marks = [];
+    if (node.type === 'tag' && node.tag === 'a') {
+        marks.push({
+            type: Extensions_1.MarkName.Link,
+            attrs: {
+                href: node.attributes?.href,
+                target: node.attributes?.target ?? null,
+                auto: false,
+                title: node.attributes?.title ?? null,
+            },
+        });
+    }
+    else if (node.type === 'link-to-matrix-asset') {
+        marks.push({
+            type: Extensions_1.MarkName.AssetLink,
+            attrs: {
+                matrixAssetId: node.matrixAssetId,
+                matrixDomain: node.matrixDomain,
+                matrixIdentifier: node.matrixIdentifier,
+                target: node.target,
+            },
+        });
+    }
+    else if (node.type === 'tag' && node.tag === 'strong') {
+        marks.push({ type: 'bold' });
+    }
+    else if (node.type === 'tag' && node.tag === 'em') {
+        marks.push({ type: 'italic' });
+    }
+    // Handle font formatting
+    if ('font' in node && node.font !== undefined) {
+        for (const [type, enabled] of Object.entries(node.font)) {
+            if (enabled) {
+                if (type === 'bold' || type === 'italics' || type === 'underline') {
+                    marks.push({ type: type === 'italics' ? 'italic' : type });
+                }
+                else {
+                    throw new Error(`Unsupported mark provided: ${type}`);
+                }
+            }
+        }
+    }
+    return marks;
+};
+const unwrapNodeIfNeeded = (node) => {
+    if (node.type === 'text' && node.content?.length) {
+        return node.content.map((child) => {
+            return {
+                ...child,
+                marks: [...(child.marks || []), ...(node.marks || [])],
+            };
+        });
+    }
+    return [node];
+};
+const formatNode = (node) => {
+    const children = [];
+    if ('children' in node) {
+        node.children?.forEach((child) => {
+            children.push(...formatNode(child));
+        });
+    }
+    return unwrapNodeIfNeeded({
+        type: getNodeType(node),
+        attrs: (0, undefinedIfEmpty_1.undefinedIfEmpty)(getNodeAttributes(node)),
+        marks: (0, undefinedIfEmpty_1.undefinedIfEmpty)(getNodeMarks(node)),
+        text: node.type === 'text' ? node.value : undefined,
+        content: (0, undefinedIfEmpty_1.undefinedIfEmpty)(children),
+    });
+};
+/**
+ * Converts Squiz component JSON structure to Remirror node JSON structure.
+ * @param {FormattedText} nodes Squiz nodes to convert to Remirror.
+ * @export
+ * @returns {RemirrorJSON} The converted Remirror JSON.
+ */
+const squizNodeToRemirrorNode = (nodes = []) => {
+    let children = [];
+    nodes.forEach((node) => {
+        try {
+            children.push(...formatNode(node));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            children.push({
+                type: 'paragraph',
+                content: [
+                    {
+                        type: Extensions_1.NodeName.Unsupported,
+                        attrs: {
+                            originalNode: node,
+                            errorMessage,
+                        },
+                    },
+                ],
+            });
+        }
+    });
+    if (children.find((child) => child.type === 'text')) {
+        children = [{ type: 'paragraph', content: children }];
+    }
+    return { type: 'doc', content: children };
+};
+exports.squizNodeToRemirrorNode = squizNodeToRemirrorNode;

package/lib/utils/createToolbarPositioner.d.ts

@@ -0,0 +1,18 @@
+import { Positioner } from 'remirror/extensions';
+import { Coords } from 'remirror';
+export type ToolbarPositionerProps = {
+    types: string[];
+};
+export type ToolbarPositionerRange = {
+    isSelectionInView: boolean;
+    visible: boolean;
+    marks: Record<string, {
+        isExclusivelyActive: boolean;
+        isActive: boolean;
+    }>;
+    cursor: {
+        from: Coords;
+        to: Coords;
+    };
+};
+export declare const createToolbarPositioner: ({ types }: ToolbarPositionerProps) => Positioner<ToolbarPositionerRange>;

package/lib/utils/createToolbarPositioner.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolbarPositioner = void 0;
+const extensions_1 = require("remirror/extensions");
+const remirror_1 = require("remirror");
+const getCursorRect_1 = require("./getCursorRect");
+/* istanbul ignore next */
+const createToolbarPositioner = ({ types }) => {
+    // Inspired by "createMarkPositioner".
+    // See: https://github.com/remirror/remirror/blob/107cba/packages/remirror__extension-positioner/src/core-positioners.ts#L267
+    return extensions_1.Positioner.create({
+        hasChanged: extensions_1.hasStateChanged,
+        getActive: (props) => {
+            const { state, view } = props;
+            try {
+                const selection = (0, remirror_1.getTextSelection)(state.selection, state.doc);
+                const cursor = { from: view.coordsAtPos(selection.from), to: view.coordsAtPos(selection.to) };
+                const data = {
+                    isSelectionInView: (0, extensions_1.isPositionVisible)((0, getCursorRect_1.getCursorRect)(cursor.from), view.dom) ||
+                        (0, extensions_1.isPositionVisible)((0, getCursorRect_1.getCursorRect)(cursor.to), view.dom),
+                    cursor: cursor,
+                    visible: false,
+                    marks: {},
+                };
+                data.visible = !selection.empty && data.isSelectionInView;
+                types.forEach((type) => {
+                    const markRange = (0, remirror_1.getMarkRange)(selection.$from, type, selection.$to);
+                    if (!markRange) {
+                        data.marks[type] = { isActive: false, isExclusivelyActive: false };
+                        return;
+                    }
+                    // exclusively active =
+                    //   the entire selection has the mark applied.
+                    // active =
+                    //   at least part of the selection has the mark applied. "getMarkRanges" will return an empty array
+                    //   if this isn't the case. if there is no selection the cursor must be within the bounds of the mark,
+                    //   not on the edges.
+                    const isExclusivelyActive = selection.empty
+                        ? selection.from > markRange.from && selection.to < markRange.to
+                        : selection.from >= markRange.from && selection.to <= markRange.to;
+                    const isActive = selection.empty ? selection.from > markRange.from && selection.to < markRange.to : true;
+                    // the toolbar will be visible if there is either a selection, or we are within the bounds of a mark
+                    // we have formatting tools for.
+                    data.visible = data.visible || isExclusivelyActive;
+                    data.marks[type] = { isExclusivelyActive, isActive };
+                });
+                return data.visible ? [data] : extensions_1.Positioner.EMPTY;
+            }
+            catch {
+                return extensions_1.Positioner.EMPTY;
+            }
+        },
+        getPosition: (props) => {
+            const { element, data, view } = props;
+            const { cursor, visible } = data;
+            const { from, to } = cursor;
+            const parent = element.offsetParent ?? view.dom;
+            const parentRect = parent.getBoundingClientRect();
+            const height = Math.abs(to.bottom - from.top);
+            // Hack to get JSDOM to work, positioning doesn't work great here.
+            if (isNaN(parentRect.top)) {
+                return {
+                    rect: new DOMRect(0, 0, 0, 0),
+                    y: 0,
+                    x: 0,
+                    height: 0,
+                    width: 0,
+                    visible: false,
+                };
+            }
+            // True when the selection spans multiple lines.
+            const spansMultipleLines = height > from.bottom - from.top;
+            // The position furthest to the left.
+            const leftmost = Math.min(from.left, to.left);
+            // The position nearest the top.
+            const topmost = Math.min(from.top, to.top);
+            const bottommost = Math.max(from.bottom, to.bottom);
+            const left = parent.scrollLeft + (spansMultipleLines ? to.left - parentRect.left : leftmost - parentRect.left);
+            const top = parent.scrollTop + topmost - parentRect.top;
+            const width = spansMultipleLines ? 1 : Math.abs(from.left - to.right);
+            const rect = new DOMRect(spansMultipleLines ? to.left : leftmost, topmost, width, height);
+            // Get header toolbar by class inside the current element/editor
+            const headerToolbar = element.parentElement?.getElementsByClassName('header-toolbar')?.[0];
+            const headerBarRects = headerToolbar?.getBoundingClientRect();
+            const headerBarHeight = headerBarRects?.height ?? 0;
+            const headerBarBottom = (headerBarRects?.top ?? 0) + headerBarHeight;
+            // If floating toolbar will overlap fixed toolbar, set position to under selection
+            const isOverlapping = headerBarBottom + headerBarHeight > topmost;
+            // This is a good bottom position instead of it being on top of the toolbar when there is an overlap
+            const bottomPosition = parent.scrollTop + bottommost - parentRect.top + 62;
+            const y = isOverlapping ? bottomPosition : top;
+            return { rect, y, x: left, height, width, visible };
+        },
+    });
+};
+exports.createToolbarPositioner = createToolbarPositioner;

package/lib/utils/getCursorRect.d.ts

@@ -0,0 +1,2 @@
+import { Coords } from 'remirror';
+export declare const getCursorRect: (coords: Coords) => DOMRect;

package/lib/utils/getCursorRect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCursorRect = void 0;
+const getCursorRect = (coords) => {
+    return new DOMRect(coords.left, coords.top, 1, coords.top - coords.bottom);
+};
+exports.getCursorRect = getCursorRect;

package/lib/utils/getMarkNamesByGroup.d.ts

@@ -0,0 +1,2 @@
+import { EditorSchema, ExtensionTagType } from '@remirror/core';
+export declare const getMarkNamesByGroup: (schema: EditorSchema, group: ExtensionTagType) => string[];

package/lib/utils/getMarkNamesByGroup.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarkNamesByGroup = void 0;
+const getMarkNamesByGroup = (schema, group) => {
+    return Object.values(schema.marks)
+        .filter((mark) => mark.spec.group?.includes(group))
+        .map((mark) => mark.name);
+};
+exports.getMarkNamesByGroup = getMarkNamesByGroup;

package/lib/utils/getNodeNamesByGroup.d.ts

@@ -0,0 +1,2 @@
+import { EditorSchema, ExtensionTagType } from '@remirror/core';
+export declare const getNodeNamesByGroup: (schema: EditorSchema, group: ExtensionTagType) => string[];

package/lib/utils/getNodeNamesByGroup.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeNamesByGroup = void 0;
+const getNodeNamesByGroup = (schema, group) => {
+    return Object.values(schema.nodes)
+        .filter((node) => node.spec.group?.includes(group))
+        .map((node) => node.name);
+};
+exports.getNodeNamesByGroup = getNodeNamesByGroup;

package/lib/utils/getShortcutSymbol.d.ts

@@ -0,0 +1 @@
+export declare const getShortcutSymbol: () => string;

package/lib/utils/getShortcutSymbol.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShortcutSymbol = void 0;
+const getShortcutSymbol = () => {
+    // If we can detect Mac then we return "⌘" otherwise default to "Ctrl"
+    return window.navigator.userAgent.toLowerCase().indexOf('mac') > -1 ? '⌘' : 'Ctrl';
+};
+exports.getShortcutSymbol = getShortcutSymbol;

package/lib/utils/undefinedIfEmpty.d.ts

@@ -0,0 +1 @@
+export declare const undefinedIfEmpty: <T extends object>(object: T) => T | undefined;

package/lib/utils/undefinedIfEmpty.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undefinedIfEmpty = void 0;
+const undefinedIfEmpty = (object) => {
+    return Object.keys(object).length > 0 ? object : undefined;
+};
+exports.undefinedIfEmpty = undefinedIfEmpty;

package/lib/utils/validation.d.ts

@@ -0,0 +1,3 @@
+export declare const noEmptySpacesValidation: (value: string | undefined) => "Empty space is not allowed" | undefined;
+export declare const hasProperties: <T>(message: string, properties: (keyof T)[]) => (value: T) => string | undefined;
+export declare const regexDataURI: RegExp;

package/lib/utils/validation.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexDataURI = exports.hasProperties = exports.noEmptySpacesValidation = void 0;
+const noEmptySpacesValidation = (value) => {
+    if (value && !(value.trim().length > 0)) {
+        return 'Empty space is not allowed';
+    }
+};
+exports.noEmptySpacesValidation = noEmptySpacesValidation;
+const hasProperties = (message, properties) => (value) => {
+    if (!value || properties.filter((property) => value[property]).length !== properties.length) {
+        return message;
+    }
+};
+exports.hasProperties = hasProperties;
+exports.regexDataURI = /^data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@/?%\s]*)$/i;