@widget-js/core 0.0.10 → 0.0.12

package/dist/esm/api/ElectronApi.js

@@ -1,89 +1,47 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { Keys } from "./Keys";
+import { ElectronUtils } from "../utils/ElectronUtils";
+import { Channel } from "./Channel";
 export class ElectronApi {
     static openAddWidgetWindow() {
-        if (this.hasElectronApi()) {
-            // @ts-ignore
-            window.electronAPI.invokeIpc("openAddWidgetWindow");
-        }
+        ElectronUtils.getAPI().invokeIpc("openAddWidgetWindow");
     }
-    static registerWidgets(widgets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasElectronApi()) {
-                const data = JSON.parse(JSON.stringify(widgets.map(item => JSON.stringify(item))));
-                // @ts-ignore
-                yield window.electronAPI.invokeIpc("registerWidgets", data);
-            }
-        });
+    static async setConfig(key, value) {
+        await ElectronUtils.getAPI().invokeIpc("setConfig", { key, value });
     }
-    static setConfig(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasElectronApi()) {
-                // @ts-ignore
-                yield window.electronAPI.invokeIpc("setConfig", { key, value });
-            }
-        });
+    static async sendBroadcastEvent(event) {
+        await ElectronUtils.getAPI().invokeIpc(Channel.BROADCAST, JSON.stringify(event));
     }
-    static sendBroadcastEvent(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasElectronApi()) {
-                // @ts-ignore
-                yield window.electronAPI.invokeIpc(Keys.BROADCAST_EVENT, JSON.stringify(event));
-            }
+    static async registerBroadcast(callback) {
+        await this.addIpcListener(Channel.BROADCAST, (json) => {
+            callback(JSON.parse(json));
         });
     }
-    static registerBroadcast(callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.addIpcListener(Keys.BROADCAST_EVENT, (json) => {
-                callback(JSON.parse(json));
-            });
-        });
+    static async unregisterBroadcast() {
+        await this.removeIpcListener(Channel.BROADCAST);
     }
-    static unregisterBroadcast() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.removeIpcListener(Keys.BROADCAST_EVENT);
-        });
+    static async addIpcListener(key, f) {
+        await ElectronUtils.getAPI().addIpcListener(key, f);
     }
-    static addIpcListener(key, f) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasElectronApi()) {
-                // @ts-ignore
-                yield window.electronAPI.addIpcListener(key, f);
-            }
-        });
+    static async removeIpcListener(key) {
+        await ElectronUtils.getAPI().removeIpcListener(key);
     }
-    static removeIpcListener(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasElectronApi()) {
-                // @ts-ignore
-                yield window.electronAPI.removeIpcListener(key);
-            }
-        });
-    }
-    static getConfig(key, defaultValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasElectronApi()) {
-                // @ts-ignore
-                const value = yield window.electronAPI.invokeIpc("getConfig", key);
-                if (value === null || value === undefined) {
-                    return defaultValue;
-                }
-                if (typeof defaultValue == "boolean") {
-                    return value === "true";
-                }
-                return value;
-            }
-        });
+    static async getConfig(key, defaultValue) {
+        const value = await ElectronUtils.getAPI().invokeIpc("getConfig", key);
+        if (value === null || value === undefined) {
+            return defaultValue;
+        }
+        if (typeof defaultValue == "boolean") {
+            return value === "true";
+        }
+        return value;
     }
-    static hasElectronApi() {
-        return Reflect.has(window, "electronAPI");
+    static async upgradeNewVersion(key, defaultValue) {
+        const value = await ElectronUtils.getAPI().invokeIpc("getConfig", key);
+        if (value === null || value === undefined) {
+            return defaultValue;
+        }
+        if (typeof defaultValue == "boolean") {
+            return value === "true";
+        }
+        return value;
     }
 }

package/dist/esm/api/NotificationApi.js

@@ -0,0 +1,79 @@
+import { Notification } from "../model/Notification";
+import { Channel } from "./Channel";
+import { ElectronUtils } from "../utils/ElectronUtils";
+export class NotificationApi {
+    static async call(duration = 5000) {
+        ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+            title: "章鱼哥",
+            type: "call",
+            message: "下班提醒",
+            duration: duration
+        }));
+    }
+    static async advanceCountdown(message, targetTime, title) {
+        ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+            title,
+            message,
+            targetTime,
+            type: "advance-countdown"
+        }));
+    }
+    static async countdown(message, targetTime) {
+        ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+            message,
+            targetTime,
+            type: "countdown"
+        }));
+    }
+    static async success(message, duration = 5000) {
+        if (ElectronUtils.hasElectronApi()) {
+            ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+                message,
+                type: "success",
+                duration
+            }));
+        }
+        else {
+            this.callback("success", message, duration);
+        }
+    }
+    static async error(message, duration = 5000) {
+        if (ElectronUtils.hasElectronApi()) {
+            ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+                message,
+                type: "error",
+                duration
+            }));
+        }
+        else {
+            this.callback("error", message, duration);
+        }
+    }
+    static async warning(message, duration = 5000) {
+        if (ElectronUtils.hasElectronApi()) {
+            ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+                message,
+                type: "warning",
+                duration
+            }));
+        }
+        else {
+            this.callback("warning", message, duration);
+        }
+    }
+    static async message(message, duration = 5000) {
+        if (ElectronUtils.hasElectronApi()) {
+            ElectronUtils.getAPI().invokeIpc(Channel.NOTIFICATION, new Notification({
+                message,
+                type: "message",
+                duration
+            }));
+        }
+        else {
+            this.callback("message", message, duration);
+        }
+    }
+    static setDebugNotification(callback) {
+        this.callback = callback;
+    }
+}

package/dist/esm/api/WidgetApi.js

@@ -0,0 +1,21 @@
+import { Widget } from "../model/Widget";
+import { ElectronUtils } from "../utils/ElectronUtils";
+export class WidgetApi {
+    static async registerWidgets(widgets) {
+        await ElectronUtils.getAPI().invokeIpc("registerWidgets", JSON.stringify(widgets));
+    }
+    static async registerWidgetPackage(widgetPackage) {
+        await ElectronUtils.getAPI().invokeIpc("registerWidgetPackage", JSON.stringify(widgetPackage));
+    }
+    static async getWidgets() {
+        const data = await ElectronUtils.getAPI().invokeIpc("getWidgets");
+        const widgets = [];
+        if (data) {
+            const arr = JSON.parse(data);
+            for (const i in arr) {
+                widgets.push(Widget.parseObject(arr[i]));
+            }
+        }
+        return widgets;
+    }
+}

package/dist/esm/index.js

@@ -2,6 +2,12 @@ export * from "./model/Widget";
 export * from "./model/BroadcastEvent";
 export * from "./model/WidgetData";
 export * from "./model/WidgetParams";
+export * from "./model/Notification";
+export * from "./model/WidgetPackage";
 export * from "./api/ElectronApi";
-export * from "./api/Keys";
 export * from "./repository/WidgetDataRepository";
+export * from "./api/BrowserWindowApi";
+export * from "./api/NotificationApi";
+export * from "./api/Channel";
+export * from "./api/WidgetApi";
+export * from "./utils/ElectronUtils";

package/dist/esm/model/Notification.js

@@ -0,0 +1,11 @@
+export class Notification {
+    constructor(option) {
+        var _a, _b;
+        this.type = "message";
+        this.type = (_a = option.type) !== null && _a !== void 0 ? _a : "message";
+        this.title = option.title;
+        this.message = option.message;
+        this.targetTime = option.targetTime;
+        this.duration = (_b = option.duration) !== null && _b !== void 0 ? _b : 5000;
+    }
+}

package/dist/esm/model/Widget.js

@@ -10,65 +10,51 @@ export class Widget {
         this.description = options.description;
         this.keywords = options.keywords;
         this.lang = options.lang;
-        this.w = options.w;
-        this.h = options.h;
-        this.maxW = (_a = options.maxW) !== null && _a !== void 0 ? _a : options.w;
-        this.maxH = (_b = options.maxH) !== null && _b !== void 0 ? _b : options.h;
-        this.minW = (_c = options.minW) !== null && _c !== void 0 ? _c : options.w;
-        this.minH = (_d = options.minH) !== null && _d !== void 0 ? _d : options.h;
+        this.width = options.width;
+        this.height = options.height;
+        this.maxWidth = (_a = options.maxWidth) !== null && _a !== void 0 ? _a : options.width;
+        this.maxHeight = (_b = options.maxHeight) !== null && _b !== void 0 ? _b : options.height;
+        this.minWidth = (_c = options.minWidth) !== null && _c !== void 0 ? _c : options.width;
+        this.minHeight = (_d = options.minHeight) !== null && _d !== void 0 ? _d : options.height;
         this.url = options.url;
         this.configUrl = options.configUrl;
-        this.extraUrl = (_e = options.extraUrl) !== null && _e !== void 0 ? _e : new Map();
+        this.extraUrl = (_e = options.extraUrl) !== null && _e !== void 0 ? _e : {};
     }
     /**
      * 获取组件标题
      * @param lang 语言环境，不传则获取默认语言
      */
     getTitle(lang) {
-        return lang ? this.title.get(lang) : this.title.get(this.lang);
+        var _a;
+        return lang ? (_a = this.title[lang]) !== null && _a !== void 0 ? _a : this.title[this.lang] : this.title[this.lang];
     }
     /**
      * 获取组件标描述
      * @param lang 语言环境，不传则获取默认标题
      */
     getDescription(lang) {
-        return lang ? this.description.get(lang) : this.description.get(this.lang);
+        return lang ? this.description[lang] : this.description[this.lang];
     }
-    toJSON() {
-        return {
-            name: this.name,
-            title: Object.fromEntries(this.title),
-            description: Object.fromEntries(this.description),
-            keywords: this.keywords,
-            lang: this.lang,
-            w: this.w,
-            h: this.h,
-            maxW: this.maxW,
-            maxH: this.maxH,
-            minW: this.minW,
-            minH: this.minH,
-            url: this.url,
-            configUrl: this.configUrl,
-            extraUrl: Object.fromEntries(this.extraUrl),
-        };
-    }
-    static parse(json) {
+    static parseJSON(json) {
         const object = JSON.parse(json);
+        return this.parseObject(object);
+    }
+    static parseObject(obj) {
         return new Widget({
-            configUrl: object["configUrl"],
-            description: new Map(Object.entries(object["description"])),
-            extraUrl: new Map(Object.entries(object["extraUrl"])),
-            h: object["h"],
-            keywords: object["keywords"],
-            lang: object["lang"],
-            maxH: object["maxH"],
-            maxW: object["maxW"],
-            minH: object["minH"],
-            minW: object["minW"],
-            name: object["name"],
-            title: new Map(Object.entries(object["title"])),
-            url: object["url"],
-            w: object["w"]
+            configUrl: obj["configUrl"],
+            description: obj["description"],
+            extraUrl: obj["extraUrl"],
+            width: obj["width"],
+            keywords: obj["keywords"],
+            lang: obj["lang"],
+            maxHeight: obj["maxHeight"],
+            maxWidth: obj["maxWidth"],
+            height: obj["height"],
+            minHeight: obj["minHeight"],
+            minWidth: obj["minWidth"],
+            name: obj["name"],
+            title: obj["title"],
+            url: obj["url"]
         });
     }
 }

package/dist/esm/model/WidgetPackage.js

@@ -0,0 +1,2 @@
+export class WidgetPackage {
+}

package/dist/esm/model/WidgetParams.js

@@ -27,7 +27,7 @@ export class WidgetParams {
      * 从当前地址解析组件参数：
      * http://localhost:8080/#/widget/config/labor_progress?w_w=2&w_h=2&w_width=156&w_height=156
      * =>
-     *  {w:2,h:2,id:21,width:156,height:156}
+     *  {width:2,height:2,id:21,width_px:156,height_px:156}
      */
     static fromCurrentLocation() {
         const href = window.location.href;
@@ -45,11 +45,11 @@ export class WidgetParams {
         else if (keyWithoutPrefix == WidgetParams.PARAM_Y) {
             widgetEnv.y = parseInt(value);
         }
-        else if (keyWithoutPrefix == WidgetParams.PARAM_H) {
-            widgetEnv.h = parseInt(value);
+        else if (keyWithoutPrefix == WidgetParams.PARAM_HEIGHT) {
+            widgetEnv.height = parseInt(value);
         }
-        else if (keyWithoutPrefix == WidgetParams.PARAM_W) {
-            widgetEnv.w = parseInt(value);
+        else if (keyWithoutPrefix == WidgetParams.PARAM_WIDTH) {
+            widgetEnv.width = parseInt(value);
         }
         else if (keyWithoutPrefix == WidgetParams.PARAM_LANG) {
             widgetEnv.lang = value;
@@ -63,11 +63,11 @@ export class WidgetParams {
         else if (keyWithoutPrefix == WidgetParams.PARAM_RADIUS) {
             widgetEnv.radius = parseInt(value);
         }
-        else if (keyWithoutPrefix == WidgetParams.PARAM_WIDTH) {
-            widgetEnv.width = parseInt(value);
+        else if (keyWithoutPrefix == WidgetParams.PARAM_WIDTH_PX) {
+            widgetEnv.widthPx = parseInt(value);
         }
-        else if (keyWithoutPrefix == WidgetParams.PARAM_HEIGHT) {
-            widgetEnv.height = parseInt(value);
+        else if (keyWithoutPrefix == WidgetParams.PARAM_HEIGHT_PX) {
+            widgetEnv.heightPx = parseInt(value);
         }
         else if (keyWithoutPrefix == WidgetParams.PARAM_NAME) {
             widgetEnv.name = value;
@@ -81,8 +81,8 @@ export class WidgetParams {
     }
     /**
      * 从对象键值对中初始化组件参数
-     * {w_w:2,w_h:2,w_id:21,w_width:156,w_height:156}=>
-     *  {w:2,h:2,id:21,width:156,height:156}
+     * {w_width:2,w_height:2,w_id:21,w_width_px:156,w_height_px:156}=>
+     *  {width:2,height:2,id:21,width_px:156,height_px:156}
      * @param object
      */
     static fromObject(object) {
@@ -98,10 +98,10 @@ export class WidgetParams {
 }
 WidgetParams.PARAM_PREFIX = "w_";
 WidgetParams.PARAM_ID = "id";
-WidgetParams.PARAM_W = "w";
-WidgetParams.PARAM_H = "h";
 WidgetParams.PARAM_WIDTH = "width";
 WidgetParams.PARAM_HEIGHT = "height";
+WidgetParams.PARAM_WIDTH_PX = "width_px";
+WidgetParams.PARAM_HEIGHT_PX = "height_px";
 WidgetParams.PARAM_X = "x";
 WidgetParams.PARAM_Y = "y";
 WidgetParams.PARAM_LANG = "lang";
@@ -113,15 +113,15 @@ WidgetParams.PARAM_TITLE = "title";
 WidgetParams.PARAM_PREVIEW = "preview";
 WidgetParams.PARAMS = [
     WidgetParams.PARAM_ID,
-    WidgetParams.PARAM_W,
-    WidgetParams.PARAM_H,
+    WidgetParams.PARAM_WIDTH,
+    WidgetParams.PARAM_HEIGHT,
     WidgetParams.PARAM_X,
     WidgetParams.PARAM_Y,
     WidgetParams.PARAM_LANG,
     WidgetParams.PARAM_THEME,
     WidgetParams.PARAM_MODE,
-    WidgetParams.PARAM_WIDTH,
-    WidgetParams.PARAM_HEIGHT,
+    WidgetParams.PARAM_WIDTH_PX,
+    WidgetParams.PARAM_HEIGHT_PX,
     WidgetParams.PARAM_NAME,
     WidgetParams.PARAM_TITLE,
     WidgetParams.PARAM_PREVIEW,

package/dist/esm/repository/WidgetDataRepository.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import localforage from "localforage";
 import { BroadcastEvent } from "../model/BroadcastEvent";
 import { ElectronApi } from "../api/ElectronApi";
@@ -15,14 +6,12 @@ export class WidgetDataRepository {
      * 保存组件数据
      * @param data
      */
-    static save(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getStore(data.name);
-            const result = yield store.setItem(this.getKey(data.name, data.id), JSON.stringify(data));
-            const broadcastEvent = new BroadcastEvent(BroadcastEvent.TYPE_WIDGET_UPDATED, "", data);
-            yield ElectronApi.sendBroadcastEvent(broadcastEvent);
-            return result;
-        });
+    static async save(data) {
+        let store = this.getStore(data.name);
+        const result = await store.setItem(this.getKey(data.name, data.id), JSON.stringify(data));
+        const broadcastEvent = new BroadcastEvent(BroadcastEvent.TYPE_WIDGET_UPDATED, "", data);
+        await ElectronApi.sendBroadcastEvent(broadcastEvent);
+        return result;
     }
     /**
      * 获取组件 LocalForage 存储实例
@@ -40,39 +29,33 @@ export class WidgetDataRepository {
      * 通过组件名保存组件信息，通常用于存储可以在同类组件中共用的数据
      * @param data
      */
-    static saveByName(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const store = this.getStore(data.name);
-            const json = JSON.stringify(data);
-            const result = yield store.setItem(data.name, json);
-            const broadcastEvent = new BroadcastEvent(BroadcastEvent.TYPE_WIDGET_UPDATED, "", { name: data.name, json });
-            yield ElectronApi.sendBroadcastEvent(broadcastEvent);
-            return result;
-        });
+    static async saveByName(data) {
+        const store = this.getStore(data.name);
+        const json = JSON.stringify(data);
+        const result = await store.setItem(data.name, json);
+        const broadcastEvent = new BroadcastEvent(BroadcastEvent.TYPE_WIDGET_UPDATED, "", { name: data.name, json });
+        await ElectronApi.sendBroadcastEvent(broadcastEvent);
+        return result;
     }
-    static findByName(name, type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getStore(name);
-            let result = yield store.getItem(name);
-            if (result) {
-                const widgetData = new type(name);
-                widgetData.parseJSON(JSON.parse(result));
-                return widgetData;
-            }
-            return undefined;
-        });
+    static async findByName(name, type) {
+        let store = this.getStore(name);
+        let result = await store.getItem(name);
+        if (result) {
+            const widgetData = new type(name);
+            widgetData.parseJSON(JSON.parse(result));
+            return widgetData;
+        }
+        return undefined;
     }
-    static find(name, id, type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getStore(name);
-            let result = yield store.getItem(this.getKey(name, id));
-            if (result) {
-                const widgetData = new type(name, id);
-                widgetData.parseJSON(JSON.parse(result));
-                return widgetData;
-            }
-            return undefined;
-        });
+    static async find(name, id, type) {
+        let store = this.getStore(name);
+        let result = await store.getItem(this.getKey(name, id));
+        if (result) {
+            const widgetData = new type(name, id);
+            widgetData.parseJSON(JSON.parse(result));
+            return widgetData;
+        }
+        return undefined;
     }
     static getKey(name, id) {
         return `${name}@${id}`;

package/dist/esm/utils/ElectronUtils.js

@@ -0,0 +1,20 @@
+export class ElectronUtils {
+    static hasElectronApi() {
+        return Reflect.has(window, "electronAPI");
+    }
+    /**
+     * 获取ElectronAPI
+     * windows api
+     */
+    static getAPI() {
+        if (Reflect.has(window, "electronAPI")) {
+            //@ts-ignore
+            return window.electronAPI;
+        }
+        else if (Reflect.has(window.parent, "electronAPI")) {
+            //@ts-ignore
+            return window.parent.electronAPI;
+        }
+        return null;
+    }
+}

package/dist/types/api/BrowserWindowApi.d.ts

@@ -0,0 +1,8 @@
+export declare class BrowserWindowApi {
+    static readonly IGNORE_MOUSE_EVENT = "ignore-mouse-event";
+    static readonly WINDOW_VISIBILITY = "window-visibility";
+    static readonly ALWAYS_ON_TOP = "always-on-top";
+    static setIgnoreMouseEvent(ignore: boolean): Promise<void>;
+    static setWindowVisibility(show: boolean): Promise<void>;
+    static setAlwaysOnTop(alwaysOnTop: boolean): Promise<void>;
+}

package/dist/types/api/Channel.d.ts

@@ -0,0 +1,5 @@
+export declare enum Channel {
+    NOTIFICATION = "channel::fun.widget.core.notification",
+    BROWSER_WINDOW = "channel::fun.widget.core.browser_window",
+    BROADCAST = "channel::fun.widget.core.broadcast"
+}

package/dist/types/api/ElectronApi.d.ts

@@ -1,8 +1,6 @@
-import { Widget } from "../model/Widget";
 import { BroadcastEvent } from "../model/BroadcastEvent";
 export declare class ElectronApi {
     static openAddWidgetWindow(): void;
-    static registerWidgets(widgets: Widget[]): Promise<void>;
     static setConfig(key: string, value: string | number | boolean): Promise<void>;
     static sendBroadcastEvent(event: BroadcastEvent): Promise<void>;
     static registerBroadcast(callback: (event: BroadcastEvent) => void): Promise<void>;
@@ -10,5 +8,5 @@ export declare class ElectronApi {
     static addIpcListener(key: String, f: Function): Promise<void>;
     static removeIpcListener(key: String): Promise<void>;
     static getConfig(key: string, defaultValue: string | number | boolean): Promise<any>;
-    static hasElectronApi(): boolean;
+    static upgradeNewVersion(key: string, defaultValue: string | number | boolean): Promise<any>;
 }

package/dist/types/api/NotificationApi.d.ts

@@ -0,0 +1,14 @@
+import { NotificationType } from "../model/Notification";
+type NotificationCallback = (type: NotificationType, message: string, duration: number) => void;
+export declare class NotificationApi {
+    static call(duration?: number): Promise<void>;
+    static advanceCountdown(message: string, targetTime: string, title?: string): Promise<void>;
+    static countdown(message: string, targetTime: string): Promise<void>;
+    static success(message: string, duration?: number): Promise<void>;
+    static error(message: string, duration?: number): Promise<void>;
+    static warning(message: string, duration?: number): Promise<void>;
+    static message(message: string, duration?: number): Promise<void>;
+    private static callback;
+    static setDebugNotification(callback: NotificationCallback): void;
+}
+export {};

package/dist/types/api/WidgetApi.d.ts

@@ -0,0 +1,7 @@
+import { Widget } from "../model/Widget";
+import { WidgetPackage } from "../model/WidgetPackage";
+export declare class WidgetApi {
+    static registerWidgets(widgets: Widget[]): Promise<void>;
+    static registerWidgetPackage(widgetPackage: WidgetPackage): Promise<void>;
+    static getWidgets(): Promise<Widget[]>;
+}

package/dist/types/index.d.ts

@@ -2,6 +2,12 @@ export * from "./model/Widget";
 export * from "./model/BroadcastEvent";
 export * from "./model/WidgetData";
 export * from "./model/WidgetParams";
+export * from "./model/Notification";
+export * from "./model/WidgetPackage";
 export * from "./api/ElectronApi";
-export * from "./api/Keys";
 export * from "./repository/WidgetDataRepository";
+export * from "./api/BrowserWindowApi";
+export * from "./api/NotificationApi";
+export * from "./api/Channel";
+export * from "./api/WidgetApi";
+export * from "./utils/ElectronUtils";

package/dist/types/model/Notification.d.ts

@@ -0,0 +1,16 @@
+export type NotificationType = "call" | "message" | "countdown" | "advance-countdown" | "error" | "success" | "warning" | "info";
+export type NotificationOption = {
+    type?: NotificationType;
+    title?: string;
+    message: string;
+    targetTime?: string;
+    duration?: number;
+};
+export declare class Notification {
+    type: NotificationType;
+    message: string;
+    title?: string;
+    targetTime?: string;
+    duration: number;
+    constructor(option: NotificationOption);
+}