easy-email-pro-theme 0.2.0

package/lib/typings/typings/custom-types.d.ts

@@ -0,0 +1,96 @@
+import { defaultAttributeFields } from "../components/ConfigurationPanel/components/AttributeField";
+import type { Element, ElementMap, ExtendedType, PageElement, PickObjectValueByKey } from "easy-email-pro-core";
+import type { BasicEditorProps, BasicEmailTemplate, EmailEditorProps } from "easy-email-pro-editor";
+import React from "react";
+import { Path } from "slate";
+export type ThemeConfigProps = Omit<EmailEditorProps, "children">;
+export interface CustomThemeTypes {
+    [key: string]: unknown;
+}
+export type BasicConfigPanelsMap = {
+    [K in PickObjectValueByKey<Element, "type">]: React.FC<{
+        nodePath: Path;
+    }>;
+};
+export type BasicAttributeFieldsMap = typeof defaultAttributeFields;
+export type AttributeFieldsMap = ExtendedType<"AttributeFieldsMap", BasicAttributeFieldsMap, CustomThemeTypes>;
+export interface CategoryGridItem<T extends keyof ElementMap = any> {
+    label: string;
+    active?: boolean;
+    blocks: Array<{
+        type: Element["type"];
+        payload?: Partial<ElementMap[T]>;
+        title?: string | undefined;
+        icon?: React.ReactNode;
+    }>;
+    displayType?: "grid";
+}
+export type Categories = Array<CategoryGridItem | {
+    label: string;
+    active?: boolean;
+    blocks: Array<{
+        payload: string[][];
+        title: string | undefined;
+    }>;
+    displayType: "column";
+} | {
+    label: string;
+    active?: boolean;
+    blocks: Array<{
+        payload?: Partial<Element>;
+    }>;
+    displayType: "widget";
+} | {
+    label: string;
+    active?: boolean;
+    blocks: Array<React.ReactNode>;
+    displayType: "custom";
+}>;
+export interface PluginsCustomEditorTypes {
+    AttributeFieldsMap?: AttributeFieldsMap;
+    EmailEditorProps: BasicEditorProps & {
+        categories?: Categories;
+        attributeFields?: AttributeFieldsMap;
+        showSourceCode?: boolean;
+        universalElementSetting?: {
+            elements: Record<string, Element>;
+            list: Array<{
+                label: string;
+                elements: Array<{
+                    element: Element;
+                    thumbnail: string;
+                }>;
+            }>;
+            onAddElement: (params: {
+                name: string;
+                element: Element;
+                thumbnail: Blob;
+            }) => Promise<Element>;
+            onUpdateElement: (params: {
+                uid: string;
+                element: Element;
+                thumbnail: Blob;
+            }) => Promise<any>;
+        };
+        quantityLimitCheck?: (params: {
+            element: Element;
+            pageData: PageElement;
+        }) => boolean;
+        controller?: boolean;
+        showPreview?: boolean;
+        showSidebar?: boolean;
+        unsplash?: {
+            clientId: string;
+            presetList?: Array<{
+                query: string;
+                label: string;
+                image: string;
+            }>;
+        };
+    };
+    EmailTemplate: BasicEmailTemplate;
+}
+declare module "easy-email-pro-editor" {
+    interface CustomEditorTypes extends PluginsCustomEditorTypes {
+    }
+}

package/lib/typings/typings/index.d.ts

@@ -0,0 +1 @@
+export * from "./custom-types";

package/lib/typings/utils/Uploader.d.ts

@@ -0,0 +1,35 @@
+interface Options {
+    limit?: number;
+    accept?: string;
+    minSize?: number;
+    maxSize?: number;
+    autoUpload?: boolean;
+}
+export type UploadItem = {
+    idx: string;
+    url: string;
+    status: "pending" | "done" | "error";
+};
+export type UploaderEventMap = {
+    start: (data: UploadItem[]) => void;
+    progress: (data: UploadItem[]) => void;
+    end: (data: UploadItem[]) => void;
+};
+export type UploaderServer = (file: Blob) => Promise<string>;
+export declare class Uploader {
+    private options;
+    private el;
+    private uploadServer;
+    private handler;
+    constructor(uploadServer: UploaderServer, options: Options);
+    private createInput;
+    uploadFiles(files: File[]): Promise<void>;
+    private uploadFile;
+    private checkFile;
+    private checkTypes;
+    private checkSize;
+    chooseFile(): void;
+    on<K extends keyof UploaderEventMap>(event: K, fn: UploaderEventMap[K]): void;
+    off<K extends keyof UploaderEventMap>(event: K, fn: UploaderEventMap[K]): void;
+}
+export {};

package/lib/typings/utils/environment.d.ts

@@ -0,0 +1 @@
+export declare const IS_APPLE: boolean;

package/lib/typings/utils/generateLogic.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { LogicCondition } from "easy-email-pro-core";
+export declare const generateLogic: (option: LogicCondition) => JSX.Element | null;

package/lib/typings/utils/getElementPageLayout.d.ts

@@ -0,0 +1,16 @@
+import { CustomSlateEditor } from "easy-email-pro-editor";
+export declare const getElementPageLayout: (params: {
+    editor: CustomSlateEditor;
+    overlayElement: HTMLElement;
+    relativedElement: HTMLElement | Range;
+    overlayElementHeight?: number;
+}) => {
+    pageXOffset: number;
+    pageYOffset: number;
+    isBottomEnough: boolean;
+    isTopEnough: boolean;
+    iframeRect: DOMRect;
+    relativedElementReact: DOMRect;
+    overlayRect: DOMRect;
+    overlayRectHeight: number;
+} | undefined;

package/lib/typings/utils/getFallbackValue.d.ts

@@ -0,0 +1,7 @@
+import { ActiveTabKeys } from "easy-email-pro-editor";
+import { useElementDefault } from "..";
+export declare const getFallbackValue: (params: {
+    mode: ActiveTabKeys;
+    defaultElement?: ReturnType<typeof useElementDefault> | null;
+    name: string;
+}) => any;

package/lib/typings/utils/hideCursor.d.ts

@@ -0,0 +1,2 @@
+import { CustomSlateEditor } from "easy-email-pro-editor";
+export declare const hideCursor: (editor: CustomSlateEditor) => void;

package/lib/typings/utils/hotkeys.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+/**
+ * Hotkeys.
+ */
+declare const _default: {
+    isSelectBlock: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isMergeTag: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isSave: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isFormatBold: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isFormatItalic: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isFormatUnderline: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isUndo: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    isRedo: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    alignCenter: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    alignLeft: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+    alignRight: (event: KeyboardEvent | import("react").KeyboardEvent<HTMLDivElement>) => boolean;
+};
+export default _default;

package/lib/typings/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./mjmlToJson";
+export * from "./previewLoadImage";

package/lib/typings/utils/isValidHttpUrl.d.ts

@@ -0,0 +1 @@
+export declare function isValidHttpUrl(str: string): boolean;

package/lib/typings/utils/mjmlToJson/HtmlNodeAdapter.d.ts

@@ -0,0 +1,2 @@
+import { Element as BeacasElement, TextNode } from "easy-email-pro-core";
+export declare const HtmlNodeAdapter: (content: string) => (BeacasElement | TextNode)[];

package/lib/typings/utils/mjmlToJson/basicElementToStandardElement.d.ts

@@ -0,0 +1,2 @@
+import { Element } from "easy-email-pro-core";
+export declare function basicElementToStandardElement(element: Element): Element;

package/lib/typings/utils/mjmlToJson/formatPadding.d.ts

@@ -0,0 +1 @@
+export declare const formatPadding: <T extends Record<string, any>>(element: T) => T;

package/lib/typings/utils/mjmlToJson/index.d.ts

@@ -0,0 +1,2 @@
+import { PageElement } from "easy-email-pro-core";
+export declare const mjmlToJson: (content: string) => PageElement;

package/lib/typings/utils/onDrag.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param event
+ */
+export declare const onDrag: ({ event, onMove, onEnd, contentWindow, }: {
+    event: PointerEvent;
+    onMove: (x: number, y: number) => void;
+    onEnd?: (() => void) | undefined;
+    contentWindow?: Window | undefined;
+}) => void;

package/lib/typings/utils/previewLoadImage.d.ts

@@ -0,0 +1 @@
+export declare function previewLoadImage(url: string): Promise<HTMLImageElement>;

package/lib/vb-dfbee74a.mjs

@@ -0,0 +1,365 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.36.1(6c56744c3419458f0dd48864520b759d1a3a1ca8)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var conf = {
+  comments: {
+    lineComment: "'",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["<", ">"],
+    ["addhandler", "end addhandler"],
+    ["class", "end class"],
+    ["enum", "end enum"],
+    ["event", "end event"],
+    ["function", "end function"],
+    ["get", "end get"],
+    ["if", "end if"],
+    ["interface", "end interface"],
+    ["module", "end module"],
+    ["namespace", "end namespace"],
+    ["operator", "end operator"],
+    ["property", "end property"],
+    ["raiseevent", "end raiseevent"],
+    ["removehandler", "end removehandler"],
+    ["select", "end select"],
+    ["set", "end set"],
+    ["structure", "end structure"],
+    ["sub", "end sub"],
+    ["synclock", "end synclock"],
+    ["try", "end try"],
+    ["while", "end while"],
+    ["with", "end with"],
+    ["using", "end using"],
+    ["do", "loop"],
+    ["for", "next"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}", notIn: ["string", "comment"] },
+    { open: "[", close: "]", notIn: ["string", "comment"] },
+    { open: "(", close: ")", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["string", "comment"] },
+    { open: "<", close: ">", notIn: ["string", "comment"] }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*#Region\\b"),
+      end: new RegExp("^\\s*#End Region\\b")
+    }
+  }
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".vb",
+  ignoreCase: true,
+  brackets: [
+    { token: "delimiter.bracket", open: "{", close: "}" },
+    { token: "delimiter.array", open: "[", close: "]" },
+    { token: "delimiter.parenthesis", open: "(", close: ")" },
+    { token: "delimiter.angle", open: "<", close: ">" },
+    {
+      token: "keyword.tag-addhandler",
+      open: "addhandler",
+      close: "end addhandler"
+    },
+    { token: "keyword.tag-class", open: "class", close: "end class" },
+    { token: "keyword.tag-enum", open: "enum", close: "end enum" },
+    { token: "keyword.tag-event", open: "event", close: "end event" },
+    {
+      token: "keyword.tag-function",
+      open: "function",
+      close: "end function"
+    },
+    { token: "keyword.tag-get", open: "get", close: "end get" },
+    { token: "keyword.tag-if", open: "if", close: "end if" },
+    {
+      token: "keyword.tag-interface",
+      open: "interface",
+      close: "end interface"
+    },
+    { token: "keyword.tag-module", open: "module", close: "end module" },
+    {
+      token: "keyword.tag-namespace",
+      open: "namespace",
+      close: "end namespace"
+    },
+    {
+      token: "keyword.tag-operator",
+      open: "operator",
+      close: "end operator"
+    },
+    {
+      token: "keyword.tag-property",
+      open: "property",
+      close: "end property"
+    },
+    {
+      token: "keyword.tag-raiseevent",
+      open: "raiseevent",
+      close: "end raiseevent"
+    },
+    {
+      token: "keyword.tag-removehandler",
+      open: "removehandler",
+      close: "end removehandler"
+    },
+    { token: "keyword.tag-select", open: "select", close: "end select" },
+    { token: "keyword.tag-set", open: "set", close: "end set" },
+    {
+      token: "keyword.tag-structure",
+      open: "structure",
+      close: "end structure"
+    },
+    { token: "keyword.tag-sub", open: "sub", close: "end sub" },
+    {
+      token: "keyword.tag-synclock",
+      open: "synclock",
+      close: "end synclock"
+    },
+    { token: "keyword.tag-try", open: "try", close: "end try" },
+    { token: "keyword.tag-while", open: "while", close: "end while" },
+    { token: "keyword.tag-with", open: "with", close: "end with" },
+    { token: "keyword.tag-using", open: "using", close: "end using" },
+    { token: "keyword.tag-do", open: "do", close: "loop" },
+    { token: "keyword.tag-for", open: "for", close: "next" }
+  ],
+  keywords: [
+    "AddHandler",
+    "AddressOf",
+    "Alias",
+    "And",
+    "AndAlso",
+    "As",
+    "Async",
+    "Boolean",
+    "ByRef",
+    "Byte",
+    "ByVal",
+    "Call",
+    "Case",
+    "Catch",
+    "CBool",
+    "CByte",
+    "CChar",
+    "CDate",
+    "CDbl",
+    "CDec",
+    "Char",
+    "CInt",
+    "Class",
+    "CLng",
+    "CObj",
+    "Const",
+    "Continue",
+    "CSByte",
+    "CShort",
+    "CSng",
+    "CStr",
+    "CType",
+    "CUInt",
+    "CULng",
+    "CUShort",
+    "Date",
+    "Decimal",
+    "Declare",
+    "Default",
+    "Delegate",
+    "Dim",
+    "DirectCast",
+    "Do",
+    "Double",
+    "Each",
+    "Else",
+    "ElseIf",
+    "End",
+    "EndIf",
+    "Enum",
+    "Erase",
+    "Error",
+    "Event",
+    "Exit",
+    "False",
+    "Finally",
+    "For",
+    "Friend",
+    "Function",
+    "Get",
+    "GetType",
+    "GetXMLNamespace",
+    "Global",
+    "GoSub",
+    "GoTo",
+    "Handles",
+    "If",
+    "Implements",
+    "Imports",
+    "In",
+    "Inherits",
+    "Integer",
+    "Interface",
+    "Is",
+    "IsNot",
+    "Let",
+    "Lib",
+    "Like",
+    "Long",
+    "Loop",
+    "Me",
+    "Mod",
+    "Module",
+    "MustInherit",
+    "MustOverride",
+    "MyBase",
+    "MyClass",
+    "NameOf",
+    "Namespace",
+    "Narrowing",
+    "New",
+    "Next",
+    "Not",
+    "Nothing",
+    "NotInheritable",
+    "NotOverridable",
+    "Object",
+    "Of",
+    "On",
+    "Operator",
+    "Option",
+    "Optional",
+    "Or",
+    "OrElse",
+    "Out",
+    "Overloads",
+    "Overridable",
+    "Overrides",
+    "ParamArray",
+    "Partial",
+    "Private",
+    "Property",
+    "Protected",
+    "Public",
+    "RaiseEvent",
+    "ReadOnly",
+    "ReDim",
+    "RemoveHandler",
+    "Resume",
+    "Return",
+    "SByte",
+    "Select",
+    "Set",
+    "Shadows",
+    "Shared",
+    "Short",
+    "Single",
+    "Static",
+    "Step",
+    "Stop",
+    "String",
+    "Structure",
+    "Sub",
+    "SyncLock",
+    "Then",
+    "Throw",
+    "To",
+    "True",
+    "Try",
+    "TryCast",
+    "TypeOf",
+    "UInteger",
+    "ULong",
+    "UShort",
+    "Using",
+    "Variant",
+    "Wend",
+    "When",
+    "While",
+    "Widening",
+    "With",
+    "WithEvents",
+    "WriteOnly",
+    "Xor"
+  ],
+  tagwords: [
+    "If",
+    "Sub",
+    "Select",
+    "Try",
+    "Class",
+    "Enum",
+    "Function",
+    "Get",
+    "Interface",
+    "Module",
+    "Namespace",
+    "Operator",
+    "Set",
+    "Structure",
+    "Using",
+    "While",
+    "With",
+    "Do",
+    "Loop",
+    "For",
+    "Next",
+    "Property",
+    "Continue",
+    "AddHandler",
+    "RemoveHandler",
+    "Event",
+    "RaiseEvent",
+    "SyncLock"
+  ],
+  symbols: /[=><!~?;\.,:&|+\-*\/\^%]+/,
+  integersuffix: /U?[DI%L&S@]?/,
+  floatsuffix: /[R#F!]?/,
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      [/next(?!\w)/, { token: "keyword.tag-for" }],
+      [/loop(?!\w)/, { token: "keyword.tag-do" }],
+      [
+        /end\s+(?!for|do)(addhandler|class|enum|event|function|get|if|interface|module|namespace|operator|property|raiseevent|removehandler|select|set|structure|sub|synclock|try|while|with|using)/,
+        { token: "keyword.tag-$1" }
+      ],
+      [
+        /[a-zA-Z_]\w*/,
+        {
+          cases: {
+            "@tagwords": { token: "keyword.tag-$0" },
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/^\s*#\w+/, "keyword"],
+      [/\d*\d+e([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+      [/\d*\.\d+(e[\-+]?\d+)?(@floatsuffix)/, "number.float"],
+      [/&H[0-9a-f]+(@integersuffix)/, "number.hex"],
+      [/&0[0-7]+(@integersuffix)/, "number.octal"],
+      [/\d+(@integersuffix)/, "number"],
+      [/#.*#/, "number"],
+      [/[{}()\[\]]/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      [/["\u201c\u201d]/, { token: "string.quote", next: "@string" }]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/(\'|REM(?!\w)).*$/, "comment"]
+    ],
+    string: [
+      [/[^"\u201c\u201d]+/, "string"],
+      [/["\u201c\u201d]{2}/, "string.escape"],
+      [/["\u201c\u201d]C?/, { token: "string.quote", next: "@pop" }]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};