@tencentcloud/roomkit-electron-vue3 2.6.7 → 2.7.1

package/es/components/Whiteboard/ToolBox/Text/index.vue.mjs

@@ -0,0 +1,152 @@
+import { defineComponent, ref, reactive, watch, withDirectives, openBlock, createBlock, mergeProps, withCtx, createVNode, normalizeClass, unref, createElementBlock, createElementVNode, toDisplayString, Fragment, renderList, withModifiers, createCommentVNode } from "vue";
+import { DrawingTool } from "../../type.mjs";
+import { useI18n } from "../../../../locales/index.mjs";
+import IconButton from "../../../common/base/IconButton.vue.mjs";
+import vClickOutside from "../../../../directives/vClickOutside.mjs";
+/* empty css                       */
+import TextIcon from "../Icon/TextIcon.vue.mjs";
+import SizeIcon1 from "../Image/H1.svg.mjs";
+import SizeIcon2 from "../Image/H2.svg.mjs";
+import SizeIcon3 from "../Image/H3.svg.mjs";
+import SizeIcon4 from "../Image/H4.svg.mjs";
+import BlueIcon from "../Image/BlueIcon.svg.mjs";
+import PurpleIcon from "../Image/PurpleIcon.svg.mjs";
+import YellowIcon from "../Image/YellowIcon.svg.mjs";
+import OrangeIcon from "../Image/OrangeIcon.svg.mjs";
+import RedIcon from "../Image/RedIcon.svg.mjs";
+import GreenIcon from "../Image/GreenIcon.svg.mjs";
+import DeepBlueIcon from "../Image/DeepBlueIcon.svg.mjs";
+import BlackIcon from "../Image/BlackIcon.svg.mjs";
+import DarkGrayIcon from "../Image/DarkGrayIcon.svg.mjs";
+import GrayIcon from "../Image/GrayIcon.svg.mjs";
+import LightGrayIcon from "../Image/LightGrayIcon.svg.mjs";
+import WhiteIcon from "../Image/WhiteIcon.svg.mjs";
+const _hoisted_1 = {
+  key: 0,
+  class: "text-tool-setting whiteboard-tool-setting"
+};
+const _hoisted_2 = { class: "size-setting-title setting-title" };
+const _hoisted_3 = { class: "size-setting-section setting-section" };
+const _hoisted_4 = ["onClick"];
+const _hoisted_5 = ["src"];
+const _hoisted_6 = { class: "color-setting-title setting-title" };
+const _hoisted_7 = { class: "color-setting-section setting-section" };
+const _hoisted_8 = ["onClick"];
+const _hoisted_9 = ["src"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: {
+    activeTool: String
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const { t } = useI18n();
+    const textSizes = [
+      { icon: SizeIcon1, size: 32 },
+      { icon: SizeIcon2, size: 24 },
+      { icon: SizeIcon3, size: 18.72 },
+      { icon: SizeIcon4, size: 16 }
+    ];
+    const textColors = [
+      { color: "#4791FF", icon: BlueIcon },
+      { color: "#5940D7", icon: PurpleIcon },
+      { color: "#F5C342", icon: YellowIcon },
+      { color: "#E05734", icon: OrangeIcon },
+      { color: "#DC3859", icon: RedIcon },
+      { color: "#1AD32C", icon: GreenIcon },
+      { color: "#104683", icon: DeepBlueIcon },
+      { color: "#22262E", icon: BlackIcon },
+      { color: "#86909A", icon: DarkGrayIcon },
+      { color: "#B5BBC3", icon: GrayIcon },
+      { color: "#DBDDE2", icon: LightGrayIcon },
+      { color: "#EAEEF3", icon: WhiteIcon }
+    ];
+    const showSettings = ref(false);
+    const props = __props;
+    function handleHideButtonSetting() {
+      if (props.activeTool === DrawingTool.Text) {
+        showSettings.value = false;
+      }
+    }
+    const toolSetting = reactive({
+      drawingTool: DrawingTool.Text,
+      shapeOptions: {
+        strokeWidth: 18.72,
+        stroke: "#22262E"
+      }
+    });
+    const emit = __emit;
+    watch(
+      () => props.activeTool,
+      () => {
+        showSettings.value = false;
+      }
+    );
+    const onClick = () => {
+      showSettings.value = !showSettings.value;
+      emit("click", toolSetting);
+    };
+    const handleSizeClick = (size) => {
+      if (size === toolSetting.shapeOptions.strokeWidth) {
+        return;
+      }
+      toolSetting.shapeOptions.strokeWidth = size;
+      emit("click", toolSetting);
+    };
+    const handleColorClick = (color) => {
+      if (toolSetting.shapeOptions.stroke !== color) {
+        toolSetting.shapeOptions.stroke = color;
+        emit("click", toolSetting);
+      }
+    };
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createBlock(IconButton, mergeProps({ class: "tool-button" }, _ctx.$attrs, { onClickIcon: onClick }), {
+        default: withCtx(() => [
+          createVNode(TextIcon, {
+            class: normalizeClass({ "whiteboard-icon-active": __props.activeTool === unref(DrawingTool).Text })
+          }, null, 8, ["class"]),
+          showSettings.value && __props.activeTool === "Text" ? (openBlock(), createElementBlock("div", _hoisted_1, [
+            createElementVNode("div", _hoisted_2, toDisplayString(unref(t)("Text Size")), 1),
+            createElementVNode("div", _hoisted_3, [
+              (openBlock(), createElementBlock(Fragment, null, renderList(textSizes, (textSize) => {
+                return createElementVNode("button", {
+                  key: textSize.size,
+                  class: normalizeClass(["size-button setting-option-button", {
+                    "button-active": textSize.size === toolSetting.shapeOptions.strokeWidth
+                  }]),
+                  onClick: withModifiers(($event) => handleSizeClick(textSize.size), ["stop"])
+                }, [
+                  createElementVNode("img", {
+                    src: textSize.icon
+                  }, null, 8, _hoisted_5)
+                ], 10, _hoisted_4);
+              }), 64))
+            ]),
+            createElementVNode("div", _hoisted_6, toDisplayString(unref(t)("Text Color")), 1),
+            createElementVNode("div", _hoisted_7, [
+              (openBlock(), createElementBlock(Fragment, null, renderList(textColors, (textColor) => {
+                return createElementVNode("button", {
+                  key: textColor.color,
+                  class: normalizeClass(["color-button setting-option-button", {
+                    "button-active": textColor.color === toolSetting.shapeOptions.stroke
+                  }]),
+                  onClick: withModifiers(($event) => handleColorClick(textColor.color), ["stop"])
+                }, [
+                  createElementVNode("img", {
+                    src: textColor.icon
+                  }, null, 8, _hoisted_9)
+                ], 10, _hoisted_8);
+              }), 64))
+            ])
+          ])) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 16)), [
+        [unref(vClickOutside), handleHideButtonSetting]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/Whiteboard/ToolBox/Text/index.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./index.vue.mjs";
+export {
+  _sfc_main as default
+};

package/es/components/Whiteboard/ToolBox/UndoButton.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{
+    step: NumberConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+    step: NumberConstructor;
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/es/components/Whiteboard/ToolBox/UndoButton.vue.mjs

@@ -0,0 +1,36 @@
+import { defineComponent, openBlock, createBlock, withCtx, createVNode, normalizeClass } from "vue";
+import { DrawingTool } from "../type.mjs";
+import IconButton from "../../common/base/IconButton.vue.mjs";
+import UndoIcon from "./Icon/UndoIcon.vue.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "UndoButton",
+  props: {
+    step: Number
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const onClick = () => {
+      emit("click", {
+        drawingTool: DrawingTool.Undo
+      });
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(IconButton, {
+        class: "tool-button",
+        onClickIcon: onClick
+      }, {
+        default: withCtx(() => [
+          createVNode(UndoIcon, {
+            class: normalizeClass({ "tool-disabled": props.step === 0 })
+          }, null, 8, ["class"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/Whiteboard/ToolBox/UndoButton.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./UndoButton.vue.mjs";
+export {
+  _sfc_main as default
+};

package/es/components/Whiteboard/ToolBox/index.vue.d.ts

@@ -0,0 +1,16 @@
+import { ToolSettings } from '../type';
+
+declare const _default: import('vue').DefineComponent<{
+    step: NumberConstructor;
+    historyListLength: NumberConstructor;
+    changeTool: StringConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    updateSetting: (toolSetting: ToolSettings) => void;
+}, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+    step: NumberConstructor;
+    historyListLength: NumberConstructor;
+    changeTool: StringConstructor;
+}>> & {
+    onUpdateSetting?: ((toolSetting: ToolSettings) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/es/components/Whiteboard/ToolBox/index.vue.mjs

@@ -0,0 +1,174 @@
+import { defineComponent, computed, ref, openBlock, createElementBlock, createElementVNode, createVNode, Fragment, renderList, createBlock, resolveDynamicComponent, normalizeClass, createCommentVNode } from "vue";
+import { getUrlParam } from "../../../utils/utils.mjs";
+import _sfc_main$1 from "./SelectButton.vue.mjs";
+import _sfc_main$2 from "./LaserButton.vue.mjs";
+import _sfc_main$3 from "./Pencil/index.vue.mjs";
+import _sfc_main$4 from "./Shape/index.vue.mjs";
+import _sfc_main$5 from "./EraserButton.vue.mjs";
+import _sfc_main$6 from "./Arrow/index.vue.mjs";
+import _sfc_main$7 from "./Text/index.vue.mjs";
+import _sfc_main$8 from "./ImageButton.vue.mjs";
+import _sfc_main$a from "./RedoButton.vue.mjs";
+import _sfc_main$9 from "./UndoButton.vue.mjs";
+import _sfc_main$b from "./ClearButton.vue.mjs";
+import _sfc_main$c from "./DownloadButton.vue.mjs";
+import _sfc_main$d from "./RetractButton.vue.mjs";
+import TopLines from "./Icon/TopLine.vue.mjs";
+import Separator from "./Icon/SeparatorLine.vue.mjs";
+const _hoisted_1 = { class: "whiteboard-tool-box" };
+const _hoisted_2 = { class: "tool-box-top" };
+const _hoisted_3 = { class: "tool-box-top-lines" };
+const _hoisted_4 = {
+  key: 0,
+  class: "separator-box"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: {
+    step: Number,
+    historyListLength: Number,
+    changeTool: String
+  },
+  emits: ["updateSetting"],
+  setup(__props, { emit: __emit }) {
+    let isAnnotationWin = false;
+    const annotationParam = getUrlParam("isAnnotationWin");
+    if (annotationParam && annotationParam === "true") {
+      isAnnotationWin = true;
+    }
+    const props = __props;
+    const tools = [
+      {
+        id: "Select",
+        component: _sfc_main$1,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Laser",
+        component: _sfc_main$2,
+        showSeparator: true,
+        showAnnotationWin: true
+      },
+      {
+        id: "Pencil",
+        component: _sfc_main$3,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Shape",
+        component: _sfc_main$4,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Eraser",
+        component: _sfc_main$5,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Arrow",
+        component: _sfc_main$6,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Text",
+        component: _sfc_main$7,
+        showSeparator: true,
+        showAnnotationWin: true
+      },
+      {
+        id: "Image",
+        component: _sfc_main$8,
+        showSeparator: false,
+        showAnnotationWin: false
+      },
+      {
+        id: "Undo",
+        component: _sfc_main$9,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Redo",
+        component: _sfc_main$a,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Clear",
+        component: _sfc_main$b,
+        showSeparator: false,
+        showAnnotationWin: true
+      },
+      {
+        id: "Download",
+        component: _sfc_main$c,
+        showSeparator: false,
+        showAnnotationWin: false
+      }
+    ];
+    const filteredTools = computed(() => {
+      const filtered = tools.filter(
+        (tool) => !isAnnotationWin || tool.showAnnotationWin
+      );
+      const newElement = {
+        id: "Retract",
+        component: _sfc_main$d,
+        showSeparator: false,
+        showAnnotationWin: true
+      };
+      if (isAnnotationWin === true) {
+        return [...filtered, newElement];
+      }
+      return filtered;
+    });
+    const activeTool = ref("Pencil");
+    const emit = __emit;
+    function setActiveButton(toolSetting) {
+      if (toolSetting.drawingTool === "Redo" || toolSetting.drawingTool === "Undo" || toolSetting.drawingTool === "Download" || toolSetting.drawingTool === "Image" || toolSetting.drawingTool === "Clear" || toolSetting.drawingTool === "Retract") {
+        emit("updateSetting", toolSetting);
+        return;
+      }
+      if (toolSetting.drawingTool === "Line" || toolSetting.drawingTool === "Rectangle" || toolSetting.drawingTool === "Circle" || toolSetting.drawingTool === "Triangle") {
+        activeTool.value = "Shape";
+      } else {
+        activeTool.value = toolSetting.drawingTool;
+      }
+      emit("updateSetting", toolSetting);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            createVNode(TopLines)
+          ])
+        ]),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(filteredTools.value, (tool) => {
+          return openBlock(), createElementBlock("div", {
+            class: "box",
+            key: tool.id
+          }, [
+            (openBlock(), createBlock(resolveDynamicComponent(tool.component), {
+              onClick: setActiveButton,
+              class: normalizeClass({ active: activeTool.value === tool.id }),
+              "active-tool": activeTool.value,
+              step: props.step,
+              "history-list-length": props.historyListLength,
+              "change-tool": __props.changeTool
+            }, null, 8, ["class", "active-tool", "step", "history-list-length", "change-tool"])),
+            tool.showSeparator === true ? (openBlock(), createElementBlock("div", _hoisted_4, [
+              createVNode(Separator)
+            ])) : createCommentVNode("", true)
+          ]);
+        }), 128))
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/Whiteboard/ToolBox/index.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./index.vue.mjs";
+/* empty css            */
+export {
+  _sfc_main as default
+};

package/es/components/Whiteboard/core/arrow.mjs

@@ -9,6 +9,8 @@ fabric.Arrow = fabric.util.createClass(fabric.Line, {
     }
     options = options || {};
     this.callSuper("initialize", points, options);
+    this.arrowWidth = 7;
+    this.arrowHeight = 7;
   },
   _render(ctx) {
     this.callSuper("_render", ctx);
@@ -19,9 +21,9 @@ fabric.Arrow = fabric.util.createClass(fabric.Line, {
     ctx.translate((this.x2 - this.x1) / 2, (this.y2 - this.y1) / 2);
     ctx.rotate(angle);
     ctx.beginPath();
-    ctx.moveTo(5, 0);
-    ctx.lineTo(-5, 5);
-    ctx.lineTo(-5, -5);
+    ctx.moveTo(this.arrowWidth, 0);
+    ctx.lineTo(-this.arrowWidth, this.arrowHeight);
+    ctx.lineTo(-this.arrowWidth, -this.arrowHeight);
     ctx.closePath();
     ctx.fillStyle = this.stroke;
     ctx.fill();
@@ -30,7 +32,10 @@ fabric.Arrow = fabric.util.createClass(fabric.Line, {
 });
 fabric.Arrow.fromObject = (options, callback) => {
   const { x1, x2, y1, y2 } = options;
-  return callback(new fabric.Arrow([x1, y1, x2, y2], options));
+  const arrow = new fabric.Arrow([x1, y1, x2, y2], {
+    ...options
+  });
+  callback(arrow);
 };
 const Arrow = fabric.Arrow;
 export {

package/es/components/Whiteboard/core/historyManager.d.ts

@@ -0,0 +1,27 @@
+import { default as FabricCanvas } from './index';
+import { default as EventEmitter } from './../emitter';
+import { IEvent } from 'fabric/fabric-impl';
+
+interface HistoryManagerEvent {
+    'change-step': IEvent;
+    'change-history': IEvent;
+    [key: string | symbol]: IEvent | any | undefined;
+}
+declare class HistoryManager extends EventEmitter<HistoryManagerEvent> {
+    private canvas;
+    private step;
+    private historyList;
+    constructor(canvas: FabricCanvas);
+    private renderCanvas;
+    undo(): void;
+    redo(): void;
+    private addToUndoStack;
+    clearHistoryList(): void;
+    isCanvasEmpty(): boolean;
+    clear(): void;
+    private initEvent;
+    private setupIpcListeners;
+    private addToUndoUpdate;
+    destroy(): void;
+}
+export default HistoryManager;

package/es/components/Whiteboard/core/historyManager.mjs

@@ -0,0 +1,96 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { inject } from "vue";
+import { ipcRenderer } from "electron";
+import bus from "../../../hooks/useMitt.mjs";
+import EventEmitter from "../emitter.mjs";
+class HistoryManager extends EventEmitter {
+  constructor(canvas) {
+    super();
+    __publicField(this, "canvas", inject("canvas"));
+    __publicField(this, "step", 0);
+    __publicField(this, "historyList", []);
+    this.canvas = canvas;
+    this.initEvent();
+    this.setupIpcListeners();
+  }
+  renderCanvas(data) {
+    if (!this.canvas) return;
+    this.canvas.loadFromJSON(data, () => {
+      var _a;
+      (_a = this.canvas) == null ? void 0 : _a.renderAll();
+    });
+  }
+  undo() {
+    bus.emit("exitTextEditing");
+    if (!this.canvas || this.step === 0) return;
+    this.step = this.step - 1;
+    this.emit("change-step", this.step);
+    this.step === 0 ? this.canvas.clearCanvas() : this.renderCanvas(this.historyList[this.step - 1]);
+  }
+  redo() {
+    if (!this.canvas || this.step >= this.historyList.length) return;
+    const canvasState = this.historyList[this.step];
+    this.step = this.step + 1;
+    this.emit("change-step", this.step);
+    this.renderCanvas(canvasState);
+  }
+  addToUndoStack() {
+    if (!this.canvas) return;
+    const data = this.canvas.toJSON();
+    if (this.historyList.length !== this.step) {
+      this.historyList = this.historyList.slice(0, this.step);
+    }
+    this.historyList.push(data);
+    this.emit("change-history", this.historyList.length);
+    this.step = this.historyList.length;
+    this.emit("change-step", this.step);
+  }
+  clearHistoryList() {
+    this.historyList = [];
+    this.step = 0;
+  }
+  isCanvasEmpty() {
+    var _a;
+    return ((_a = this.canvas) == null ? void 0 : _a.getObjects().length) === 0;
+  }
+  clear() {
+    var _a;
+    if (this.isCanvasEmpty() === true) {
+      return;
+    }
+    (_a = this.canvas) == null ? void 0 : _a.clearCanvas();
+    if (this.historyList.length > 0) {
+      this.addToUndoStack();
+    }
+  }
+  initEvent() {
+    if (this.canvas) {
+      this.canvas.on("push-canvas-to-stack", this.addToUndoUpdate.bind(this));
+    }
+  }
+  setupIpcListeners() {
+    ipcRenderer.on(
+      "whiteboard:clear",
+      this.clearHistoryList = this.clearHistoryList.bind(this)
+    );
+    ipcRenderer.on(
+      "annotation:clear",
+      this.clearHistoryList = this.clearHistoryList.bind(this)
+    );
+  }
+  addToUndoUpdate() {
+    this.addToUndoStack();
+  }
+  destroy() {
+    if (this.canvas) {
+      this.canvas.off("push-canvas-to-stack", this.addToUndoUpdate);
+    }
+    ipcRenderer.removeAllListeners("whiteboard:clear");
+    ipcRenderer.removeAllListeners("annotation:clear");
+  }
+}
+export {
+  HistoryManager as default
+};

package/es/components/Whiteboard/core/index.d.ts

@@ -1,5 +1,6 @@
 import { Canvas as ICanvas, Object as IObject, ILineOptions, IImageOptions, IRectOptions, ICircleOptions, ITextOptions, IEllipseOptions, IEvent, ICanvasOptions, ITriangleOptions } from 'fabric/fabric-impl';
 import { default as EventEmitter } from './../emitter';
+import { DrawingTool, ToolSettings } from './../type';
 
 interface FabricEvents {
     'object:added': IEvent;
@@ -12,13 +13,6 @@ interface FabricEvents {
     'push-canvas-to-stack': IEvent;
     [key: string | symbol]: IEvent | any | undefined;
 }
-export type DrawingTool = 'rectangle' | 'triangle' | 'circle' | 'ellipse' | 'line' | 'arrow' | 'text' | 'pencil' | 'select' | 'eraser' | '';
-interface ShapeOptions {
-    stroke?: string;
-    strokeWidth?: number;
-    fill?: string;
-    opacity?: number;
-}
 declare class FabricCanvas extends EventEmitter<FabricEvents> {
     private canvas;
     private currentShape;
@@ -35,7 +29,7 @@ declare class FabricCanvas extends EventEmitter<FabricEvents> {
     private isValidSelection;
     constructor(canvasId: string);
     getCanvas(): ICanvas;
-    clearCanvas(): void;
+    renderCanvas(data: any): void;
     setBackgroundColor(color: string): void;
     setBackgroundImage(imageUrl: string, options?: IImageOptions): void;
     addObject(object: IObject): void;
@@ -50,9 +44,13 @@ declare class FabricCanvas extends EventEmitter<FabricEvents> {
     exitTextEditing(): void;
     setObjectsSelectable(objectsSelectable: boolean): void;
     setEvented(): void;
+    clearCanvas(): void;
     reloadCanvas(): void;
     setDrawingTool(tool: DrawingTool): void;
-    setOptions(options: ShapeOptions): void;
+    setOptions(toolSetting: ToolSettings): void;
+    setTextOptions(): ITextOptions;
+    setPencilBrushOptions(): void;
+    discardActiveObject(): void;
     drawRect(options: IRectOptions): void;
     drawTriangle(options: ITriangleOptions): void;
     drawCircle(options: ICircleOptions): void;
@@ -64,7 +62,7 @@ declare class FabricCanvas extends EventEmitter<FabricEvents> {
     insertImage(url: string, options?: IImageOptions): void;
     insertPPT(urls: string[]): void;
     setCurrentScense(index: number): void;
-    setEraser(options?: any): void;
+    setEraser(): void;
     private initEvent;
     private onMouseDown;
     private onMouseMove;