@pareto-engineering/design-system 4.0.0-alpha.9 → 4.0.0

package/dist/es/f/fields/EditorInput/common/ColorPicker/styles.scss

@@ -0,0 +1,36 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+
+@use "@pareto-engineering/bem";
+@use "react-color-palette/css";
+
+$default-width: 20rem;
+
+.#{bem.$base}.color-picker {
+  cursor: pointer;
+  position: relative;
+
+  > button {
+    align-items: center;
+    background-color: var(--x);
+    border: 0;
+    color: var(--on-background-inputs);
+    display: flex;
+    gap: calc(var(--gap) / 2);
+    padding: calc(var(--theme-default-padding) / 2);
+
+    &:hover {
+      background: var(--hard-x);
+      border-radius: calc(var(--theme-default-border-radius) / 2);
+    }
+  }
+
+
+  > .#{bem.$base}.popover {
+    background-color: var(--background-far);
+    border: 1px solid var(--hard-background-cards);
+    border-radius: calc(var(--theme-default-border-radius) / 2);
+    color: var(--heading);
+    padding: calc(var(--theme-default-padding) / 2);
+    width: $default-width;
+  }
+}

package/dist/es/f/fields/EditorInput/common/FontSizeDropDown/FontSizeDropDown.js

@@ -0,0 +1,81 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+import * as React from 'react';
+import { useState, useRef, useCallback } from 'react';
+import { $getSelection, $isRangeSelection } from 'lexical';
+import { $patchStyleText } from '@lexical/selection';
+import PropTypes from 'prop-types';
+import styleNames from '@pareto-engineering/bem/exports';
+import "./styles.scss";
+import { Popover } from "../../../../../a";
+import { useOutsideClick } from "../../../../../utils";
+
+// Local Definitions
+
+const baseClassName = styleNames.base;
+const componentClassName = 'font-size-drop-down';
+const FONT_SIZE_OPTIONS = [['10px', '10px'], ['11px', '11px'], ['12px', '12px'], ['13px', '13px'], ['14px', '14px'], ['15px', '15px'], ['16px', '16px'], ['17px', '17px'], ['18px', '18px'], ['19px', '19px'], ['20px', '20px']];
+
+/**
+ * This is the component description.
+ */
+const FontSizeDropDown = ({
+  id,
+  className: userClassName,
+  style,
+  editor,
+  value
+  // ...otherProps
+}) => {
+  const parentRef = useRef(null);
+  const [isOpen, setIsOpen] = useState(false);
+  useOutsideClick(parentRef, () => setIsOpen(false));
+  const handleClick = useCallback(option => {
+    editor.update(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        $patchStyleText(selection, {
+          'font-size': option
+        });
+      }
+    });
+  }, [editor]);
+  return /*#__PURE__*/React.createElement("button", {
+    id: id,
+    className: [baseClassName, componentClassName, userClassName, 'group'].filter(e => e).join(' '),
+    style: style,
+    ref: parentRef,
+    type: "button",
+    onClick: () => setIsOpen(!isOpen)
+    // {...otherProps}
+  }, /*#__PURE__*/React.createElement("span", null, value), /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "V"), isOpen && /*#__PURE__*/React.createElement(Popover, {
+    parentRef: parentRef,
+    isOpen: isOpen,
+    color: "background-far"
+  }, FONT_SIZE_OPTIONS.map(([option, text]) => /*#__PURE__*/React.createElement("button", {
+    className: `item ${value === option ? 'active' : ''}`,
+    onClick: () => handleClick(option),
+    type: "button"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "text"
+  }, text)))));
+};
+FontSizeDropDown.propTypes = {
+  /**
+   * The HTML id for this element
+   */
+  id: PropTypes.string,
+  /**
+   * The HTML class names for this element
+   */
+  className: PropTypes.string,
+  /**
+   * The React-written, css properties for this element.
+   */
+  style: PropTypes.objectOf(PropTypes.string)
+};
+FontSizeDropDown.defaultProps = {
+  // someProp:false
+};
+export default FontSizeDropDown;

package/dist/es/f/fields/EditorInput/common/FontSizeDropDown/index.js

@@ -0,0 +1,2 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+export { default as FontSizeDropDown } from "./FontSizeDropDown";

package/dist/es/f/fields/EditorInput/common/FontSizeDropDown/styles.scss

@@ -0,0 +1,55 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+
+@use "@pareto-engineering/bem";
+
+$default-width: 4.5rem;
+
+.#{bem.$base}.font-size-drop-down {
+  align-items: center;
+  background-color: var(--x);
+  border: 0;
+  color: var(--on-background-inputs);
+  cursor: pointer;
+  display: flex;
+  gap: calc(var(--gap) / 2);
+  margin-inline: calc(var(--theme-default-padding) / 4);
+  padding: calc(var(--theme-default-padding) / 2);
+  position: relative;
+
+  &:hover {
+    background: var(--hard-x);
+    border-radius: calc(var(--theme-default-border-radius) / 2);
+  }
+
+  > .#{bem.$base}.popover {
+    background-color: var(--background-far);
+    border: 1px solid var(--hard-background-cards);
+    border-radius: calc(var(--theme-default-border-radius) / 2);
+    color: var(--heading);
+    display: flex;
+    flex-direction: column;
+    padding: calc(var(--theme-default-padding) / 2);
+    width: $default-width;
+
+    > .item {
+      align-items: center;
+      background-color: var(--x);
+      border: 0;
+      border-radius: calc(var(--theme-default-border-radius) / 2);
+      color: var(--paragraph);
+      cursor: pointer;
+      display: flex;
+      gap: calc(var(--gap) / 2);
+      padding: calc(var(--theme-default-padding) / 2);
+      transition: all .2s;
+
+      &:hover {
+        background-color: var(--hard-x);
+      }
+
+      &.active {
+        background-color: var(--hard-ui-main);
+      }
+    }
+  }
+}

package/dist/es/f/fields/EditorInput/common/StopPropagationPlugin.js

@@ -0,0 +1,23 @@
+import { useInsertionEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+const StopPropagationPlugin = ({
+  stopPropagationKeys
+}) => {
+  const [editor] = useLexicalComposerContext();
+  useInsertionEffect(() => {
+    const onKeyDown = e => {
+      if (stopPropagationKeys?.includes(e.key)) {
+        e.stopPropagation();
+      }
+    };
+    return editor.registerRootListener((rootElement, prevRootElement) => {
+      if (prevRootElement !== null) {
+        prevRootElement.removeEventListener('keydown', onKeyDown);
+      }
+      if (rootElement !== null) {
+        rootElement.addEventListener('keydown', onKeyDown);
+      }
+    });
+  }, [editor]);
+};
+export default StopPropagationPlugin;

package/dist/es/f/fields/EditorInput/common/ToolbarPlugin/ToolbarPlugin.js

@@ -0,0 +1,277 @@
+/* eslint-disable import/no-extraneous-dependencies -- required here */
+import * as React from 'react';
+import { useEffect, useState, useCallback } from 'react';
+import PropTypes from 'prop-types';
+import { mergeRegister, $getNearestNodeOfType, $findMatchingParent } from '@lexical/utils';
+import { $isHeadingNode } from '@lexical/rich-text';
+import { $getSelection, $isRangeSelection, $isRootOrShadowRoot, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, UNDO_COMMAND, REDO_COMMAND, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_CRITICAL, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, DEPRECATED_$isGridSelection } from 'lexical';
+import { $isListNode, ListNode } from '@lexical/list';
+import { $getSelectionStyleValueForProperty, $isAtNodeEnd, $patchStyleText } from '@lexical/selection';
+import { $isLinkNode, TOGGLE_LINK_COMMAND } from '@lexical/link';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $isTableNode } from '@lexical/table';
+import styleNames from '@pareto-engineering/bem/exports';
+import { BlockFormatDropDown } from "../BlockFormatDropDown";
+import { ColorPicker } from "../ColorPicker";
+import { FontSizeDropDown } from "../FontSizeDropDown";
+
+// Local Definitions
+import "./styles.scss";
+const getSelectedNode = selection => {
+  const {
+    anchor,
+    focus
+  } = selection;
+  const anchorNode = selection.anchor.getNode();
+  const focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  const isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  }
+  return $isAtNodeEnd(anchor) ? focusNode : anchorNode;
+};
+export const blockTypeToBlockName = {
+  bullet: 'Bulleted List',
+  check: 'Check List',
+  code: 'Code Block',
+  h1: 'Heading 1',
+  h2: 'Heading 2',
+  h3: 'Heading 3',
+  number: 'Numbered List',
+  paragraph: 'Normal',
+  quote: 'Quote'
+};
+const baseClassName = styleNames.base;
+const componentClassName = 'toolbar-plugin';
+
+/**
+ * This is the component description
+ */
+const ToolbarPlugin = ({
+  id,
+  className: userClassName,
+  style: inlineStyles,
+  baseBgColor
+  // ...otherProps
+}) => {
+  const [editor] = useLexicalComposerContext();
+  const [activeEditor, setActiveEditor] = useState(editor);
+  const [blockType, setBlockType] = useState('paragraph');
+  const [rootType, setRootType] = useState('root');
+  const [fontSize, setFontSize] = useState('15px');
+  const [isEditable, setIsEditable] = useState(() => editor.isEditable());
+  const [isBold, setIsBold] = useState(false);
+  const [isItalic, setIsItalic] = useState(false);
+  const [isStrikethrough, setIsStrikethrough] = useState(false);
+  const [isLink, setIsLink] = useState(false);
+  const [isUnderline, setIsUnderline] = useState(false);
+  const [canRedo, setCanRedo] = useState(false);
+  const [canUndo, setCanUndo] = useState(false);
+  const formatLink = useCallback(() => {
+    if (!isLink) {
+      // eslint-disable-next-line no-alert
+      const path = prompt('Enter the full URL. Ex: https://www.example.com');
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND, path);
+    } else {
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+    }
+  }, [editor, isLink]);
+  const $updateToolbar = useCallback(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      const anchorNode = selection.anchor.getNode();
+      let element = anchorNode.getKey() === 'root' ? anchorNode : $findMatchingParent(anchorNode, e => {
+        const parent = e.getParent();
+        return parent !== null && $isRootOrShadowRoot(parent);
+      });
+      if (element === null) {
+        element = anchorNode.getTopLevelElementOrThrow();
+      }
+      const elementKey = element.getKey();
+      const elementDOM = activeEditor.getElementByKey(elementKey);
+
+      // Update text format
+      setIsBold(selection.hasFormat('bold'));
+      setIsItalic(selection.hasFormat('italic'));
+      setIsUnderline(selection.hasFormat('underline'));
+      setIsStrikethrough(selection.hasFormat('strikethrough'));
+
+      // Update links
+      const node = getSelectedNode(selection);
+      const parent = node.getParent();
+      if ($isLinkNode(parent) || $isLinkNode(node)) {
+        setIsLink(true);
+      } else {
+        setIsLink(false);
+      }
+      const tableNode = $findMatchingParent(node, $isTableNode);
+      if ($isTableNode(tableNode)) {
+        setRootType('table');
+      } else {
+        setRootType('root');
+      }
+      if (elementDOM !== null) {
+        if ($isListNode(element)) {
+          const parentList = $getNearestNodeOfType(anchorNode, ListNode);
+          const type = parentList ? parentList.getListType() : element.getListType();
+          setBlockType(type);
+        } else {
+          const type = $isHeadingNode(element) ? element.getTag() : element.getType();
+          if (type in blockTypeToBlockName) {
+            setBlockType(type);
+          }
+        }
+      }
+      setFontSize($getSelectionStyleValueForProperty(selection, 'font-size', '15px'));
+    }
+  }, [activeEditor]);
+  useEffect(() => editor.registerCommand(SELECTION_CHANGE_COMMAND, (_payload, newEditor) => {
+    $updateToolbar();
+    setActiveEditor(newEditor);
+    return false;
+  }, COMMAND_PRIORITY_CRITICAL), [editor, $updateToolbar]);
+  useEffect(() => mergeRegister(editor.registerEditableListener(editable => {
+    setIsEditable(editable);
+  }), activeEditor.registerUpdateListener(({
+    editorState
+  }) => {
+    editorState.read(() => {
+      $updateToolbar();
+    });
+  }), activeEditor.registerCommand(CAN_UNDO_COMMAND, payload => {
+    setCanUndo(payload);
+    return false;
+  }, COMMAND_PRIORITY_CRITICAL), activeEditor.registerCommand(CAN_REDO_COMMAND, payload => {
+    setCanRedo(payload);
+    return false;
+  }, COMMAND_PRIORITY_CRITICAL)), [$updateToolbar, activeEditor, editor]);
+  const applyStyleText = useCallback(styles => {
+    activeEditor.update(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection) || DEPRECATED_$isGridSelection(selection)) {
+        $patchStyleText(selection, styles);
+      }
+    });
+  }, [activeEditor]);
+  const onFontColorSelect = useCallback(value => {
+    applyStyleText({
+      color: value
+    });
+  }, [applyStyleText]);
+  const onBgColorSelect = useCallback(value => {
+    applyStyleText({
+      'background-color': value
+    });
+  }, [applyStyleText]);
+  return /*#__PURE__*/React.createElement("div", {
+    id: id,
+    className: [baseClassName, componentClassName, userClassName, `x-${baseBgColor}`].filter(e => e).join(' '),
+    style: inlineStyles
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "group"
+  }, /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: () => editor.dispatchCommand(UNDO_COMMAND),
+    className: "ai-icon",
+    disabled: !canUndo || !isEditable
+  }, "A"), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: "ai-icon",
+    onClick: () => editor.dispatchCommand(REDO_COMMAND),
+    disabled: !canRedo || !isEditable
+  }, "B")), /*#__PURE__*/React.createElement(BlockFormatDropDown, {
+    blockType: blockType,
+    editor: editor,
+    rootType: rootType
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "group"
+  }, /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: isBold ? 'active' : undefined,
+    onClick: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "|")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: isItalic ? 'active' : undefined,
+    onClick: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "}")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: isUnderline ? 'active' : undefined,
+    onClick: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "~")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: isStrikethrough ? 'active' : undefined,
+    onClick: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "?")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: isLink ? 'active' : undefined,
+    onClick: formatLink
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "]"))), /*#__PURE__*/React.createElement(FontSizeDropDown, {
+    editor: editor,
+    value: fontSize
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "group"
+  }, /*#__PURE__*/React.createElement(ColorPicker, {
+    icon: "'",
+    onChange: onFontColorSelect
+  }), /*#__PURE__*/React.createElement(ColorPicker, {
+    icon: "#",
+    onChange: onBgColorSelect
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "group"
+  }, /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: () => editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'left')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "^")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: () => editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'center')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "_")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: () => editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'right')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "`")), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: () => editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'justify')
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "icon"
+  }, "{"))));
+};
+ToolbarPlugin.propTypes = {
+  /**
+   * The HTML id for this element
+   */
+  id: PropTypes.string,
+  /**
+   * The HTML class names for this element
+   */
+  className: PropTypes.string,
+  /**
+   * The React-written, css properties for this element.
+   */
+  style: PropTypes.objectOf(PropTypes.string),
+  /**
+   * Base background color
+   */
+  baseBgColor: PropTypes.string
+};
+ToolbarPlugin.defaultProps = {
+  baseBgColor: 'background-far'
+};
+export default ToolbarPlugin;

package/dist/es/f/fields/EditorInput/common/ToolbarPlugin/index.js

@@ -0,0 +1,2 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+export { default as ToolbarPlugin } from "./ToolbarPlugin";

package/dist/es/f/fields/EditorInput/common/ToolbarPlugin/styles.scss

@@ -0,0 +1,56 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+
+@use "@pareto-engineering/bem";
+@use "@pareto-engineering/styles/src/mixins";
+@use "@pareto-engineering/styles/src/globals" as *;
+
+
+$default-gap: calc(var(--gap) / 2);
+$default-padding: .55em .75em;
+$default-input-border-radius: var(--theme-default-input-border-radius);
+$default-border: var(--theme-default-input-border);
+$default-icon-color: var(--soft-ui-icons);
+
+.#{bem.$base}.toolbar-plugin {
+  align-items: center;
+  border-inline: $default-border;
+  border-top: $default-border;
+  border-top-left-radius: $default-input-border-radius;
+  border-top-right-radius: $default-input-border-radius;
+  display: flex;
+  flex-wrap: wrap;
+  padding-block: calc(var(--theme-default-padding) / 4);
+
+  > .ds + .group {
+    border-left: 1px solid var(--soft-background-inputs);
+  }
+
+  > .group {
+    display: flex;
+    gap: calc(var(--gap) / 2);
+
+    > button {
+      background: var(--x);
+      border: 0;
+      border-radius: calc(var(--theme-default-border-radius) / 2);
+      color: $default-icon-color;
+      cursor: pointer;
+      margin: 0;
+      padding: $default-padding;
+
+      &:hover,
+      &.active {
+        background: var(--hard-x);
+      }
+    }
+
+    &:not(.#{bem.$base}) {
+      padding-inline: calc(var(--theme-default-padding) / 4);
+    }
+
+
+    &:not(:last-child, .#{bem.$base}) {
+      border-right: 1px solid var(--soft-background-inputs);
+    }
+  }
+}

package/dist/es/f/fields/EditorInput/common/TreeViewPlugin.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { TreeView } from '@lexical/react/LexicalTreeView';
+const TreeViewPlugin = () => {
+  const [editor] = useLexicalComposerContext();
+  return /*#__PURE__*/React.createElement(TreeView, {
+    viewClassName: "tree-view-output",
+    editor: editor
+  });
+};
+export default TreeViewPlugin;

package/dist/es/f/fields/EditorInput/common/index.js

@@ -0,0 +1,6 @@
+export { BlockFormatDropDown } from "./BlockFormatDropDown";
+export { default as TreeViewPlugin } from "./TreeViewPlugin";
+export { default as StopPropagationPlugin } from "./StopPropagationPlugin";
+export { ToolbarPlugin } from "./ToolbarPlugin";
+export { ColorPicker } from "./ColorPicker";
+export { FontSizeDropDown } from "./FontSizeDropDown";

package/dist/es/f/fields/EditorInput/index.js

@@ -0,0 +1,2 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+export { default as EditorInput } from "./EditorInput";