@bbl-digital/snorre 4.1.91 → 4.1.93

package/lib/core/Editor/index.js

@@ -0,0 +1,113 @@
+/** @jsxImportSource @emotion/react */
+import { useState } from 'react';
+import { Editor as TinyEditor } from '@tinymce/tinymce-react';
+import { ErrorWrapper, Label, styles } from './styles';
+import { basicToolbar, editorBlockFormats, editorContentCss, plugins, richToolbar } from './config';
+import Skeleton from '../Skeleton';
+import Text from '../Text';
+import IconErrorOutline from '../../icons/General/IconErrorOutline';
+import { useTheme } from '@emotion/react';
+import { useIsMobile } from '../../hooks/useIsMobile';
+import { useEffect } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+const TINYMCE_API_KEY = '1n4id0n4p67gr15sq9hvnk965wgh5ku8xjgqt30e2hnpccp3';
+/**
+ * @deprecated Use QuillEditor instead
+ */
+const Editor = ({
+  initialValue,
+  overrideValue,
+  type = 'basic',
+  label,
+  height = 500,
+  maxHeight,
+  maxWidth,
+  customToolbar,
+  invalidMessage,
+  allowImages,
+  pasteAsText,
+  resize = true,
+  validElements,
+  invalidElements = 'button',
+  disabled,
+  onChange,
+  onBlur
+}) => {
+  const [loaded, setLoaded] = useState(false);
+  const [value, setValue] = useState(initialValue || '');
+  const {
+    alert
+  } = useTheme();
+  const isMobile = useIsMobile();
+  const handleChange = (html, editor) => {
+    setValue(html);
+    onChange(html, editor.getContent({
+      format: 'text'
+    }).length);
+  };
+  const handleBlur = () => onBlur?.(value);
+  const toolbar = type === 'basic' ? basicToolbar : type === 'rich' ? richToolbar : customToolbar;
+  useEffect(() => {
+    if (overrideValue === undefined) return;
+    setValue(() => overrideValue);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [overrideValue]);
+  return _jsxs("div", {
+    css: theme => [styles.default(theme), !loaded && styles.hideEditor],
+    children: [label && _jsx(Label, {
+      children: label
+    }), _jsx("div", {
+      className: "editor-wrapper",
+      children: _jsx(TinyEditor, {
+        onBlur: handleBlur,
+        onInit: _e => setLoaded(true),
+        apiKey: TINYMCE_API_KEY,
+        value: value,
+        onEditorChange: handleChange,
+        disabled: disabled,
+        init: {
+          browser_spellcheck: true,
+          height,
+          min_height: 100,
+          max_height: maxHeight,
+          min_width: 100,
+          max_width: maxWidth,
+          toolbar_mode: 'wrap',
+          menubar: false,
+          branding: false,
+          elementpath: false,
+          resize: resize,
+          statusbar: !isMobile,
+          plugins,
+          toolbar,
+          content_style: editorContentCss,
+          language: 'nb_NO',
+          block_formats: editorBlockFormats,
+          paste_data_images: allowImages,
+          paste_as_text: pasteAsText !== undefined ? pasteAsText : type === 'basic',
+          contextmenu: false,
+          invalid_elements: !allowImages ? 'img,' + invalidElements : invalidElements,
+          valid_elements: validElements,
+          default_link_target: '_blank',
+          link_assume_external_targets: 'https',
+          link_title: false,
+          target_list: false
+        }
+      })
+    }), !loaded && _jsx(Skeleton, {
+      height: `${height}px`,
+      width: "100%",
+      borderRadius: "3px",
+      rectangle: true
+    }), invalidMessage && _jsx(ErrorWrapper, {
+      children: invalidMessage && _jsxs(Text, {
+        color: alert,
+        children: [_jsx(IconErrorOutline, {
+          size: "16px",
+          color: alert
+        }), " ", invalidMessage]
+      })
+    })]
+  });
+};
+export default Editor;

package/lib/core/Editor/styles.d.ts

@@ -0,0 +1,14 @@
+import { IAppTheme } from '../../app-shell/theme';
+export declare const styles: {
+    default: (theme: IAppTheme) => import("@emotion/react").SerializedStyles;
+    hideEditor: import("@emotion/react").SerializedStyles;
+};
+export declare const Label: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: React.ElementType;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
+export declare const ErrorWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: React.ElementType;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+//# sourceMappingURL=styles.d.ts.map

package/lib/core/Editor/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/packages/core/Editor/styles.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEjD,eAAO,MAAM,MAAM;qBACA,SAAS;;CAoC3B,CAAA;AAED,eAAO,MAAM,KAAK;;eAnBd,WAAM;2GAwBT,CAAA;AAED,eAAO,MAAM,YAAY;;eA1BrB,WAAM;yGAmCT,CAAA"}

package/lib/core/Editor/styles.js

@@ -0,0 +1,43 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import { css } from '@emotion/react';
+export const styles = {
+  default: theme => /*#__PURE__*/css("display:flex;flex-direction:column;gap:4px;.tox-tinymce{border:1px solid ", theme.border, ";border-radius:3px;}.tox-toolbar__group{border-color:", theme.border, "!important;}.tox-toolbar__primary{background:none!important;border-bottom:1px solid ", theme.border, ";}.tox-statusbar{border-top:none!important;}.editor-wrapper{display:grid;.tox-toolbar--scrolling,.tox-edit-area{&::-webkit-scrollbar{width:2px;height:2px;}}}" + (process.env.NODE_ENV === "production" ? "" : ";label:default;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),
+  hideEditor: process.env.NODE_ENV === "production" ? {
+    name: "l41m35",
+    styles: ".editor-wrapper{display:none;}"
+  } : {
+    name: "c0y57c-hideEditor",
+    styles: ".editor-wrapper{display:none;};label:hideEditor;",
+    map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+    toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+  }
+};
+export const Label = /*#__PURE__*/_styled("span", process.env.NODE_ENV === "production" ? {
+  target: "e1b0idrw1"
+} : {
+  target: "e1b0idrw1",
+  label: "Label"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1ge8ozm",
+  styles: "line-height:22px;font-size:1em;font-weight:600;margin-bottom:4px"
+} : {
+  name: "1ge8ozm",
+  styles: "line-height:22px;font-size:1em;font-weight:600;margin-bottom:4px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+export const ErrorWrapper = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1b0idrw0"
+} : {
+  target: "e1b0idrw0",
+  label: "ErrorWrapper"
+})(process.env.NODE_ENV === "production" ? {
+  name: "p12i1l",
+  styles: "display:grid;&>span{display:flex;align-items:center;gap:6px;margin-left:2px;}"
+} : {
+  name: "p12i1l",
+  styles: "display:grid;&>span{display:flex;align-items:center;gap:6px;margin-left:2px;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});

package/lib/core/EditorQuillReact/EditorQuillReact.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+import EditorQuillReact from '.';
+declare const meta: Meta<typeof EditorQuillReact>;
+export default meta;
+type Story = StoryObj<typeof EditorQuillReact>;
+export declare const Default: Story;
+export declare const Rich: Story;
+//# sourceMappingURL=EditorQuillReact.stories.d.ts.map

package/lib/core/EditorQuillReact/EditorQuillReact.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorQuillReact.stories.d.ts","sourceRoot":"","sources":["../../../src/packages/core/EditorQuillReact/EditorQuillReact.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,gBAAgB,MAAM,GAAG,CAAA;AAEhC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,gBAAgB,CAGvC,CAAA;AAED,eAAe,IAAI,CAAA;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE9C,eAAO,MAAM,OAAO,EAAE,KAOrB,CAAA;AAED,eAAO,MAAM,IAAI,EAAE,KAQlB,CAAA"}

package/lib/core/EditorQuillReact/EditorQuillReact.stories.js

@@ -0,0 +1,59 @@
+import EditorQuillReact from '.';
+const meta = {
+  title: 'Core/EditorQuillReact',
+  component: EditorQuillReact
+};
+export default meta;
+export const Default = {
+  args: {
+    label: 'Editor-label',
+    onChange: e => console.log(e),
+    invalidMessage: 'Memes are not allowed'
+  },
+  name: 'Default'
+};
+export const Rich = {
+  args: {
+    label: 'Editor-label',
+    onChange: e => console.log(e),
+    type: 'rich',
+    allowImages: true
+  },
+  name: 'Rich'
+};
+
+// export const ValidElements: Story = {
+//   args: {
+//     label: 'Editor-label',
+//     onChange: (e) => console.log(e),
+//     type: 'custom',
+//     customToolbar: 'bold italic underline',
+//     validElements: 'strong,p,span,em',
+//   },
+//   name: 'Valid elements',
+// }
+
+// export const InvalidElements: Story = {
+//   args: {
+//     label: 'Editor-label',
+//     onChange: (e) => console.log(e),
+//     type: 'custom',
+//     customToolbar: 'bold italic underline',
+//     invalidElements: 'button,a,h1,h2,h3,h4,h5,h6',
+//   },
+//   name: 'Invalid elements',
+// }
+
+// export const AllProps: Story = {
+//   args: {
+//     label: 'Editor-label',
+//     onChange: (e) => console.log(e),
+//     type: 'rich',
+//     allowImages: true,
+//     invalidElements: 'button,a,h1,h2,h3,h4,h5,h6',
+//     invalidMessage: 'Memes are not allowed',
+//     height: 400,
+//     maxHeight: 600,
+//   },
+//   name: 'All props',
+// }

package/lib/core/EditorQuillReact/IndentAttributor.d.ts

@@ -0,0 +1,7 @@
+declare const Parchment: any;
+export declare class IndentAttributor extends Parchment.StyleAttributor {
+    constructor(...args: any);
+    add(node: any, value: any): any;
+}
+export {};
+//# sourceMappingURL=IndentAttributor.d.ts.map

package/lib/core/EditorQuillReact/IndentAttributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndentAttributor.d.ts","sourceRoot":"","sources":["../../../src/packages/core/EditorQuillReact/IndentAttributor.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,SAAS,EAAgC,GAAG,CAAA;AAClD,qBAAa,gBAAiB,SAAQ,SAAS,CAAC,eAAe;gBACjD,GAAG,IAAI,EAAE,GAAG;IAGxB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG;CAQ1B"}

package/lib/core/EditorQuillReact/IndentAttributor.js

@@ -0,0 +1,15 @@
+import { Quill } from 'react-quill';
+const Parchment = Quill.import('parchment');
+export class IndentAttributor extends Parchment.StyleAttributor {
+  constructor(...args) {
+    super(...args);
+  }
+  add(node, value) {
+    if (value === 0) {
+      this.remove(node);
+      return true;
+    } else {
+      return super.add(node, `${value}em`);
+    }
+  }
+}

package/lib/core/EditorQuillReact/config.d.ts

@@ -0,0 +1,30 @@
+export declare const basicToolbar: (string[] | ({
+    list: string;
+    indent?: undefined;
+} | {
+    indent: string;
+    list?: undefined;
+})[])[];
+export declare const richToolbar: (string[] | {
+    header: (number | boolean)[];
+}[] | ({
+    list: string;
+    indent?: undefined;
+} | {
+    indent: string;
+    list?: undefined;
+})[] | {
+    align: string;
+}[])[];
+export declare const fullToolbar: (string[] | {
+    header: (number | boolean)[];
+}[] | ({
+    list: string;
+    indent?: undefined;
+} | {
+    indent: string;
+    list?: undefined;
+})[] | {
+    align: string;
+}[])[];
+//# sourceMappingURL=config.d.ts.map

package/lib/core/EditorQuillReact/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/packages/core/EditorQuillReact/config.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,YAAY;;;;;;OAAuB,CAAA;AAEhD,eAAO,MAAM,WAAW;;;;;;;;;;MAAkD,CAAA;AAE1E,eAAO,MAAM,WAAW;;;;;;;;;;MAOvB,CAAA"}

package/lib/core/EditorQuillReact/config.js

@@ -0,0 +1,31 @@
+// Toolbar options
+const sizes = [{
+  header: [false, 1, 2, 3, 4, 5, 6]
+}];
+const decorations = ['bold', 'italic', 'underline'];
+const lists = [{
+  list: 'bullet'
+}, {
+  list: 'ordered'
+}, {
+  indent: '+1'
+}, {
+  indent: '-1'
+}];
+const alignments = [{
+  align: ''
+}, {
+  align: 'center'
+}, {
+  align: 'right'
+}, {
+  align: 'justify'
+}];
+const link = 'link';
+const image = 'image';
+const clean = 'clean';
+// const image = 'image'
+
+export const basicToolbar = [decorations, lists];
+export const richToolbar = [sizes, decorations, lists, alignments, [link]];
+export const fullToolbar = [sizes, decorations, lists, alignments, [link, image], [clean]];

package/lib/core/EditorQuillReact/index.d.ts

@@ -0,0 +1,23 @@
+import 'react-quill/dist/quill.snow.css';
+type Props = {
+    initialValue?: string;
+    overrideValue?: string;
+    type?: 'basic' | 'rich' | 'custom';
+    customToolbar?: any;
+    label?: string;
+    height?: number;
+    maxHeight?: number;
+    maxWidth?: number;
+    invalidMessage?: string;
+    allowImages?: boolean;
+    pasteAsText?: boolean;
+    resize?: boolean | 'both';
+    invalidElements?: string;
+    validElements?: string;
+    disabled?: boolean;
+    onBlur?: (value: string) => void;
+    onChange: (value: string, plainTextLength: number) => void;
+};
+declare const EditorQuillReact: ({ initialValue, overrideValue, type, label, height, maxHeight, maxWidth, customToolbar, invalidMessage, allowImages, pasteAsText, resize, validElements, invalidElements, disabled, onChange, onBlur, }: Props) => import("@emotion/react/jsx-runtime").JSX.Element;
+export default EditorQuillReact;
+//# sourceMappingURL=index.d.ts.map

package/lib/core/EditorQuillReact/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packages/core/EditorQuillReact/index.tsx"],"names":[],"mappings":"AAOA,OAAO,iCAAiC,CAAA;AAIxC,KAAK,KAAK,GAAG;IACX,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;IAClC,aAAa,CAAC,EAAE,GAAG,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3D,CAAA;AAoBD,QAAA,MAAM,gBAAgB,4MAkBnB,KAAK,qDAwEP,CAAA;AAED,eAAe,gBAAgB,CAAA"}

package/lib/core/EditorQuillReact/index.js

@@ -0,0 +1,103 @@
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+/** @jsxImportSource @emotion/react */
+import { useState, useEffect } from 'react';
+import Text from '../Text';
+import IconErrorOutline from '../../icons/General/IconErrorOutline';
+import { useTheme } from '@emotion/react';
+import { ErrorWrapper, Label, styles } from './styles';
+import ReactQuill, { Quill } from 'react-quill';
+import 'react-quill/dist/quill.snow.css';
+import { basicToolbar, richToolbar } from './config';
+import { IndentAttributor } from './IndentAttributor';
+import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+const Parchment = Quill.import('parchment');
+
+//Text direction
+Quill.register(Quill.import('attributors/style/direction'), true);
+//Alignment
+Quill.register(Quill.import('attributors/style/align'), true);
+// Text sizes
+const Size = Quill.import('attributors/style/size');
+Size.whitelist = ['0.75em', '1em', '1.5em', '2.5em'];
+Quill.register(Size, true);
+let IndentStyle = new IndentAttributor('indent', 'text-indent', {
+  scope: Parchment.Scope.BLOCK,
+  whitelist: ['1em', '2em', '3em', '4em', '5em', '6em', '7em', '8em', '9em']
+});
+Quill.register(IndentStyle, true);
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "1fttcpj",
+  styles: "display:flex;flex-direction:column"
+} : {
+  name: "beovm0-EditorQuillReact",
+  styles: "display:flex;flex-direction:column;label:EditorQuillReact;",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wYWNrYWdlcy9jb3JlL0VkaXRvclF1aWxsUmVhY3QvaW5kZXgudHN4Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXFHUSIsImZpbGUiOiIuLi8uLi8uLi9zcmMvcGFja2FnZXMvY29yZS9FZGl0b3JRdWlsbFJlYWN0L2luZGV4LnRzeCIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBAanN4SW1wb3J0U291cmNlIEBlbW90aW9uL3JlYWN0ICovXHJcbmltcG9ydCB7IHVzZVN0YXRlLCB1c2VFZmZlY3QgfSBmcm9tICdyZWFjdCdcclxuaW1wb3J0IFRleHQgZnJvbSAnLi4vVGV4dCdcclxuaW1wb3J0IEljb25FcnJvck91dGxpbmUgZnJvbSAnLi4vLi4vaWNvbnMvR2VuZXJhbC9JY29uRXJyb3JPdXRsaW5lJ1xyXG5pbXBvcnQgeyB1c2VUaGVtZSB9IGZyb20gJ0BlbW90aW9uL3JlYWN0J1xyXG5pbXBvcnQgeyBFcnJvcldyYXBwZXIsIExhYmVsLCBzdHlsZXMgfSBmcm9tICcuL3N0eWxlcydcclxuaW1wb3J0IFJlYWN0UXVpbGwsIHsgUXVpbGwgfSBmcm9tICdyZWFjdC1xdWlsbCdcclxuaW1wb3J0ICdyZWFjdC1xdWlsbC9kaXN0L3F1aWxsLnNub3cuY3NzJ1xyXG5pbXBvcnQgeyBiYXNpY1Rvb2xiYXIsIHJpY2hUb29sYmFyIH0gZnJvbSAnLi9jb25maWcnXHJcbmltcG9ydCB7IEluZGVudEF0dHJpYnV0b3IgfSBmcm9tICcuL0luZGVudEF0dHJpYnV0b3InXHJcblxyXG50eXBlIFByb3BzID0ge1xyXG4gIGluaXRpYWxWYWx1ZT86IHN0cmluZ1xyXG4gIG92ZXJyaWRlVmFsdWU/OiBzdHJpbmdcclxuICB0eXBlPzogJ2Jhc2ljJyB8ICdyaWNoJyB8ICdjdXN0b20nXHJcbiAgY3VzdG9tVG9vbGJhcj86IGFueVxyXG4gIGxhYmVsPzogc3RyaW5nXHJcbiAgaGVpZ2h0PzogbnVtYmVyXHJcbiAgbWF4SGVpZ2h0PzogbnVtYmVyXHJcbiAgbWF4V2lkdGg/OiBudW1iZXJcclxuICBpbnZhbGlkTWVzc2FnZT86IHN0cmluZ1xyXG4gIGFsbG93SW1hZ2VzPzogYm9vbGVhblxyXG4gIHBhc3RlQXNUZXh0PzogYm9vbGVhblxyXG4gIHJlc2l6ZT86IGJvb2xlYW4gfCAnYm90aCdcclxuICBpbnZhbGlkRWxlbWVudHM/OiBzdHJpbmdcclxuICB2YWxpZEVsZW1lbnRzPzogc3RyaW5nXHJcbiAgZGlzYWJsZWQ/OiBib29sZWFuXHJcbiAgb25CbHVyPzogKHZhbHVlOiBzdHJpbmcpID0+IHZvaWRcclxuICBvbkNoYW5nZTogKHZhbHVlOiBzdHJpbmcsIHBsYWluVGV4dExlbmd0aDogbnVtYmVyKSA9PiB2b2lkXHJcbn1cclxuXHJcbmNvbnN0IFBhcmNobWVudCA9IFF1aWxsLmltcG9ydCgncGFyY2htZW50JylcclxuXHJcbi8vVGV4dCBkaXJlY3Rpb25cclxuUXVpbGwucmVnaXN0ZXIoUXVpbGwuaW1wb3J0KCdhdHRyaWJ1dG9ycy9zdHlsZS9kaXJlY3Rpb24nKSBhcyBhbnksIHRydWUpXHJcbi8vQWxpZ25tZW50XHJcblF1aWxsLnJlZ2lzdGVyKFF1aWxsLmltcG9ydCgnYXR0cmlidXRvcnMvc3R5bGUvYWxpZ24nKSBhcyBhbnksIHRydWUpXHJcbi8vIFRleHQgc2l6ZXNcclxuY29uc3QgU2l6ZSA9IFF1aWxsLmltcG9ydCgnYXR0cmlidXRvcnMvc3R5bGUvc2l6ZScpIGFzIGFueVxyXG5TaXplLndoaXRlbGlzdCA9IFsnMC43NWVtJywgJzFlbScsICcxLjVlbScsICcyLjVlbSddXHJcblF1aWxsLnJlZ2lzdGVyKFNpemUsIHRydWUpXHJcblxyXG5sZXQgSW5kZW50U3R5bGUgPSBuZXcgSW5kZW50QXR0cmlidXRvcignaW5kZW50JywgJ3RleHQtaW5kZW50Jywge1xyXG4gIHNjb3BlOiBQYXJjaG1lbnQuU2NvcGUuQkxPQ0ssXHJcbiAgd2hpdGVsaXN0OiBbJzFlbScsICcyZW0nLCAnM2VtJywgJzRlbScsICc1ZW0nLCAnNmVtJywgJzdlbScsICc4ZW0nLCAnOWVtJ10sXHJcbn0pXHJcblxyXG5RdWlsbC5yZWdpc3RlcihJbmRlbnRTdHlsZSBhcyBhbnksIHRydWUpXHJcblxyXG5jb25zdCBFZGl0b3JRdWlsbFJlYWN0ID0gKHtcclxuICBpbml0aWFsVmFsdWUsXHJcbiAgb3ZlcnJpZGVWYWx1ZSxcclxuICB0eXBlID0gJ2Jhc2ljJyxcclxuICBsYWJlbCxcclxuICBoZWlnaHQgPSA1MDAsIC8vIHRyZW5nZXIgPz9cclxuICBtYXhIZWlnaHQgPSA1MDAsXHJcbiAgbWF4V2lkdGgsXHJcbiAgY3VzdG9tVG9vbGJhcixcclxuICBpbnZhbGlkTWVzc2FnZSxcclxuICBhbGxvd0ltYWdlcywgLy8gdHJlbmdlciA/P1xyXG4gIHBhc3RlQXNUZXh0LCAvLyB0cmVuZ2VyID8/XHJcbiAgcmVzaXplID0gdHJ1ZSwgLy8gdHJlbmdlciA/P1xyXG4gIHZhbGlkRWxlbWVudHMsIC8vIHRyZW5nZXIgPz9cclxuICBpbnZhbGlkRWxlbWVudHMgPSAnYnV0dG9uJywgLy8gdHJlbmdlciA/P1xyXG4gIGRpc2FibGVkLFxyXG4gIG9uQ2hhbmdlLFxyXG4gIG9uQmx1cixcclxufTogUHJvcHMpID0+IHtcclxuICBjb25zdCBbdmFsdWUsIHNldFZhbHVlXSA9IHVzZVN0YXRlKGluaXRpYWxWYWx1ZSB8fCAnJylcclxuICBjb25zdCB7IGFsZXJ0IH0gPSB1c2VUaGVtZSgpXHJcblxyXG4gIGNvbnN0IGhhbmRsZUNoYW5nZSA9IChcclxuICAgIGh0bWw6IHN0cmluZyxcclxuICAgIF9kZWx0YTogYW55LFxyXG4gICAgX3NvdXJjZTogYW55LFxyXG4gICAgZWRpdG9yOiBSZWFjdFF1aWxsLlVucHJpdmlsZWdlZEVkaXRvclxyXG4gICkgPT4ge1xyXG4gICAgc2V0VmFsdWUoaHRtbClcclxuICAgIG9uQ2hhbmdlKGh0bWwsIGVkaXRvci5nZXRUZXh0KCkudHJpbSgpLmxlbmd0aClcclxuICB9XHJcblxyXG4gIGNvbnN0IGN1c3RvbU1vZHVsZXMgPSB7XHJcbiAgICB0b29sYmFyOiB7XHJcbiAgICAgIGNvbnRhaW5lcjpcclxuICAgICAgICB0eXBlID09PSAnYmFzaWMnXHJcbiAgICAgICAgICA/IGJhc2ljVG9vbGJhclxyXG4gICAgICAgICAgOiB0eXBlID09PSAncmljaCdcclxuICAgICAgICAgID8gcmljaFRvb2xiYXJcclxuICAgICAgICAgIDogY3VzdG9tVG9vbGJhcixcclxuICAgIH0sXHJcbiAgfVxyXG5cclxuICB1c2VFZmZlY3QoKCkgPT4ge1xyXG4gICAgaWYgKG92ZXJyaWRlVmFsdWUgPT09IHVuZGVmaW5lZCkgcmV0dXJuXHJcbiAgICBzZXRWYWx1ZSgoKSA9PiBvdmVycmlkZVZhbHVlKVxyXG4gIH0sIFtvdmVycmlkZVZhbHVlXSlcclxuXHJcbiAgcmV0dXJuIChcclxuICAgIDxkaXYgY3NzPXsodGhlbWUpID0+IFtzdHlsZXMuZGVmYXVsdCh0aGVtZSwgbWF4SGVpZ2h0KV19PlxyXG4gICAgICB7bGFiZWwgJiYgPExhYmVsPntsYWJlbH08L0xhYmVsPn1cclxuICAgICAgPFJlYWN0UXVpbGxcclxuICAgICAgICBjc3M9e3tcclxuICAgICAgICAgIC8vIG1pbkhlaWdodDogMTUwLFxyXG4gICAgICAgICAgLy8gbWF4SGVpZ2h0LFxyXG4gICAgICAgICAgLy8gbWF4V2lkdGgsXHJcbiAgICAgICAgICBkaXNwbGF5OiAnZmxleCcsXHJcbiAgICAgICAgICBmbGV4RGlyZWN0aW9uOiAnY29sdW1uJyxcclxuICAgICAgICB9fVxyXG4gICAgICAgIHRoZW1lPVwic25vd1wiXHJcbiAgICAgICAgcmVhZE9ubHk9e2Rpc2FibGVkfVxyXG4gICAgICAgIGZvcm1hdHM9e1tcclxuICAgICAgICAgICdoZWFkZXInLFxyXG4gICAgICAgICAgJ3NpemUnLFxyXG4gICAgICAgICAgJ2JvbGQnLFxyXG4gICAgICAgICAgJ2l0YWxpYycsXHJcbiAgICAgICAgICAndW5kZXJsaW5lJyxcclxuICAgICAgICAgICdsaXN0JyxcclxuICAgICAgICAgICdpbmRlbnQnLFxyXG4gICAgICAgICAgJ2xpbmsnLFxyXG4gICAgICAgICAgJ2ltYWdlJyxcclxuICAgICAgICAgICdhbGlnbicsXHJcbiAgICAgICAgXX1cclxuICAgICAgICBtb2R1bGVzPXtjdXN0b21Nb2R1bGVzfVxyXG4gICAgICAgIHZhbHVlPXt2YWx1ZX1cclxuICAgICAgICBvbkNoYW5nZT17aGFuZGxlQ2hhbmdlfVxyXG4gICAgICAgIG9uQmx1cj17KCkgPT4gb25CbHVyPy4odmFsdWUpfVxyXG4gICAgICAvPlxyXG5cclxuICAgICAge2ludmFsaWRNZXNzYWdlICYmIChcclxuICAgICAgICA8RXJyb3JXcmFwcGVyPlxyXG4gICAgICAgICAge2ludmFsaWRNZXNzYWdlICYmIChcclxuICAgICAgICAgICAgPFRleHQgY29sb3I9e2FsZXJ0fT5cclxuICAgICAgICAgICAgICA8SWNvbkVycm9yT3V0bGluZSBzaXplPVwiMTZweFwiIGNvbG9yPXthbGVydH0gLz4ge2ludmFsaWRNZXNzYWdlfVxyXG4gICAgICAgICAgICA8L1RleHQ+XHJcbiAgICAgICAgICApfVxyXG4gICAgICAgIDwvRXJyb3JXcmFwcGVyPlxyXG4gICAgICApfVxyXG4gICAgPC9kaXY+XHJcbiAgKVxyXG59XHJcblxyXG5leHBvcnQgZGVmYXVsdCBFZGl0b3JRdWlsbFJlYWN0XHJcbiJdfQ== */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const EditorQuillReact = ({
+  initialValue,
+  overrideValue,
+  type = 'basic',
+  label,
+  height = 500,
+  // trenger ??
+  maxHeight = 500,
+  maxWidth,
+  customToolbar,
+  invalidMessage,
+  allowImages,
+  // trenger ??
+  pasteAsText,
+  // trenger ??
+  resize = true,
+  // trenger ??
+  validElements,
+  // trenger ??
+  invalidElements = 'button',
+  // trenger ??
+  disabled,
+  onChange,
+  onBlur
+}) => {
+  const [value, setValue] = useState(initialValue || '');
+  const {
+    alert
+  } = useTheme();
+  const handleChange = (html, _delta, _source, editor) => {
+    setValue(html);
+    onChange(html, editor.getText().trim().length);
+  };
+  const customModules = {
+    toolbar: {
+      container: type === 'basic' ? basicToolbar : type === 'rich' ? richToolbar : customToolbar
+    }
+  };
+  useEffect(() => {
+    if (overrideValue === undefined) return;
+    setValue(() => overrideValue);
+  }, [overrideValue]);
+  return _jsxs("div", {
+    css: theme => [styles.default(theme, maxHeight)],
+    children: [label && _jsx(Label, {
+      children: label
+    }), _jsx(ReactQuill, {
+      css: _ref,
+      theme: "snow",
+      readOnly: disabled,
+      formats: ['header', 'size', 'bold', 'italic', 'underline', 'list', 'indent', 'link', 'image', 'align'],
+      modules: customModules,
+      value: value,
+      onChange: handleChange,
+      onBlur: () => onBlur?.(value)
+    }), invalidMessage && _jsx(ErrorWrapper, {
+      children: invalidMessage && _jsxs(Text, {
+        color: alert,
+        children: [_jsx(IconErrorOutline, {
+          size: "16px",
+          color: alert
+        }), " ", invalidMessage]
+      })
+    })]
+  });
+};
+export default EditorQuillReact;

package/lib/core/EditorQuillReact/styles.d.ts

@@ -0,0 +1,13 @@
+import { IAppTheme } from '../../app-shell/theme';
+export declare const styles: {
+    default: (theme: IAppTheme, maxHeight: number) => import("@emotion/react").SerializedStyles;
+};
+export declare const Label: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: React.ElementType;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
+export declare const ErrorWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: React.ElementType;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+//# sourceMappingURL=styles.d.ts.map

package/lib/core/EditorQuillReact/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/packages/core/EditorQuillReact/styles.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEjD,eAAO,MAAM,MAAM;qBACA,SAAS,aAAa,MAAM;CAiH9C,CAAA;AAED,eAAO,MAAM,KAAK;;eAlGd,WAAU;2GAuGb,CAAA;AAED,eAAO,MAAM,YAAY;;eAzGrB,WAAU;yGAiHb,CAAA"}

package/lib/core/EditorQuillReact/styles.js

@@ -0,0 +1,34 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import { css } from '@emotion/react';
+export const styles = {
+  default: (theme, maxHeight) => /*#__PURE__*/css("display:flex;flex-direction:column;gap:4px;.ql-snow .ql-picker.ql-size .ql-picker-label[data-value='0.75em']::before{content:'Small';}.ql-snow .ql-picker.ql-size .ql-picker-label[data-value='1em']::before{content:'Normal';}.ql-snow .ql-picker.ql-size .ql-picker-label[data-value='1.5em']::before{content:'Large';}.ql-snow .ql-picker.ql-size .ql-picker-label[data-value='2.5em']::before{content:'Huge';}.ql-snow .ql-picker.ql-size .ql-picker-item[data-value='0.75em']::before{content:'Small';font-size:0.75em!important;}.ql-snow .ql-picker.ql-size .ql-picker-item[data-value='1em']::before{content:'Normal';font-size:1em!important;}.ql-snow .ql-picker.ql-size .ql-picker-item[data-value='1.5em']::before{content:'Large';font-size:1.5em!important;}.ql-snow .ql-picker.ql-size .ql-picker-item[data-value='2.5em']::before{content:'Huge';font-size:2.5em!important;}.ql-toolbar{border:1px solid ", theme.border, ";border-radius:3px 3px 0 0;padding-top:0;padding-bottom:0;.ql-formats{margin-right:0;padding:4px;&:not(:first-of-type){border-left:1px solid ", theme.border, ";}button{width:34px;height:34px;display:flex;align-items:center;justify-content:center;border-radius:3px;svg{height:65%;}&:hover{background:rgb(222, 224, 226);}&.ql-active{background:rgb(200, 203, 207);}}}.ql-picker-label{border-color:transparent!important;}.ql-picker-options{border-radius:3px;padding-left:0;padding-right:0;margin-top:3px!important;.ql-picker-item{padding:4px;&:hover{background:rgb(222, 224, 226);}}}}.ql-container{border:1px solid ", theme.border, ";border-top:none;border-radius:0 0 3px 3px;font-size:16px;}", maxHeight && /*#__PURE__*/css(".ql-editor{min-height:150px;max-height:", maxHeight, "px;}" + (process.env.NODE_ENV === "production" ? "" : ";label:default;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"), ";" + (process.env.NODE_ENV === "production" ? "" : ";label:default;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")
+};
+export const Label = /*#__PURE__*/_styled("span", process.env.NODE_ENV === "production" ? {
+  target: "e199a0771"
+} : {
+  target: "e199a0771",
+  label: "Label"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1ge8ozm",
+  styles: "line-height:22px;font-size:1em;font-weight:600;margin-bottom:4px"
+} : {
+  name: "1ge8ozm",
+  styles: "line-height:22px;font-size:1em;font-weight:600;margin-bottom:4px",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+export const ErrorWrapper = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e199a0770"
+} : {
+  target: "e199a0770",
+  label: "ErrorWrapper"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1t3kewc",
+  styles: "display:grid;&>span{display:flex;align-items:center;gap:6px;}"
+} : {
+  name: "1t3kewc",
+  styles: "display:grid;&>span{display:flex;align-items:center;gap:6px;}",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});

package/lib/core/FileInput/styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/packages/core/FileInput/styles.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;eAoBkC,WACjD;yGAlBJ,CAAA;AAED,eAAO,MAAM,WAAW;;eAe8B,WACjD;yGAhBkC,CAAA;AAEvC,eAAO,MAAM,YAAY;;eAa6B,WACjD;yGAVJ,CAAA;AACD,eAAO,MAAM,eAAe;;eAQ0B,WACjD;yGALJ,CAAA;AAED,eAAO,MAAM,QAAQ;;eAEiC,WACjD;2GAWJ,CAAA;AAED,eAAO,MAAM,MAAM;sBA1BjB,SAAM;uBAIU,SAAS;gCAGpB,SACP;;;;4BAWyB,UACjB;8BAQJ,UAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAKT,CAAA;AAED,eAAO,MAAM,UAAU;;eAvB+B,WACjD;;WAuBc,MAAM;cAAY,OAAO;qHAsB3C,CAAA;AAED,eAAO,MAAM,aAAa;;eAhD4B,WACjD;2GAsDJ,CAAA;AAED,eAAO,MAAM,WAAW;;eAzD8B,WACjD;kHA0DJ,CAAA;AAED,eAAO,MAAM,IAAI;;eA7DqC,WACjD;;cA6DuB,MAAM;2GAMjC,CAAA;AAED,eAAO,MAAM,KAAK;;eAtEoC,WACjD;2GA0EJ,CAAA;AAED,eAAO,MAAM,YAAY;;eA7E6B,WACjD;yGAkFJ,CAAA"}
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/packages/core/FileInput/styles.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;eAoBS,WAAW;yGAjBvC,CAAA;AAED,eAAO,MAAM,WAAW;;eAeK,WAAW;yGAfD,CAAA;AAEvC,eAAO,MAAM,YAAY;;eAaI,WAAW;yGATvC,CAAA;AACD,eAAO,MAAM,eAAe;;eAQC,WAAW;yGAJvC,CAAA;AAED,eAAO,MAAM,QAAQ;;eAEQ,WAAW;2GAYvC,CAAA;AAED,eAAO,MAAM,MAAM;sBA3Be,SAChC;uBAIQ,SAAS;gCAGjB,SAAK;;;;4BAYK,UAAU;8BAOW,UAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAMH,CAAA;AAED,eAAO,MAAM,UAAU;;eAvBM,WAAW;;WAwBrB,MAAM;cAAY,OAAO;qHAsB3C,CAAA;AAED,eAAO,MAAM,aAAa;;eAhDG,WAAW;2GAuDvC,CAAA;AAED,eAAO,MAAM,WAAW;;eAzDK,WAAW;kHA2DvC,CAAA;AAED,eAAO,MAAM,IAAI;;eA7DY,WAAW;;cA8DZ,MAAM;2GAMjC,CAAA;AAED,eAAO,MAAM,KAAK;;eAtEW,WAAW;2GA2EvC,CAAA;AAED,eAAO,MAAM,YAAY;;eA7EI,WAAW;yGAmFvC,CAAA"}