@widget-js/core 0.0.6 → 0.0.8

package/dist/cjs/api/ElectronApi.js

@@ -8,66 +8,86 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElectronApi = void 0;
-var ElectronApi = /** @class */ (function () {
-    function ElectronApi() {
-    }
-    ElectronApi.openAddWidgetWindow = function () {
+const Keys_1 = require("./Keys");
+class ElectronApi {
+    static openAddWidgetWindow() {
         if (this.hasElectronApi()) {
             // @ts-ignore
             window.electronAPI.invokeIpc("openAddWidgetWindow");
         }
-    };
-    ElectronApi.registerWidgets = function (widgets) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.hasElectronApi()) return [3 /*break*/, 2];
-                        data = JSON.parse(JSON.stringify(widgets.map(function (item) { return item.stringify(); })));
-                        // @ts-ignore
-                        return [4 /*yield*/, window.electronAPI.invokeIpc("registerWidgets", data)];
-                    case 1:
-                        // @ts-ignore
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
-                }
+    }
+    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 setConfig(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasElectronApi()) {
+                // @ts-ignore
+                yield window.electronAPI.invokeIpc("setConfig", { key, value });
+            }
+        });
+    }
+    static sendBroadcastEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasElectronApi()) {
+                // @ts-ignore
+                yield window.electronAPI.invokeIpc(Keys_1.Keys.BROADCAST_EVENT, JSON.stringify(event));
+            }
+        });
+    }
+    static registerBroadcast(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addIpcListener(Keys_1.Keys.BROADCAST_EVENT, (json) => {
+                callback(JSON.parse(json));
             });
         });
-    };
-    ElectronApi.hasElectronApi = function () {
+    }
+    static unregisterBroadcast() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.removeIpcListener(Keys_1.Keys.BROADCAST_EVENT);
+        });
+    }
+    static addIpcListener(key, f) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasElectronApi()) {
+                // @ts-ignore
+                yield window.electronAPI.addIpcListener(key, f);
+            }
+        });
+    }
+    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 hasElectronApi() {
         return Reflect.has(window, "electronAPI");
-    };
-    return ElectronApi;
-}());
+    }
+}
 exports.ElectronApi = ElectronApi;

package/dist/cjs/api/Keys.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Keys = void 0;
+class Keys {
+}
+exports.Keys = Keys;
+Keys.CONFIG_LAUNCH_AT_STARTUP = "LAUNCH_AT_STARTUP";
+Keys.CONFIG_WIDGET_SHADOW = "WIDGET_SHADOW";
+Keys.CHANNEL_MAIN = "WeiZ5kaKijae";
+Keys.EVENT_WIDGET_UPDATED = "WIDGET_SHADOW";
+Keys.BROADCAST_EVENT = "sendBroadcastEvent";

package/dist/cjs/index.js

@@ -15,4 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./model/Widget"), exports);
+__exportStar(require("./model/BroadcastEvent"), exports);
+__exportStar(require("./model/WidgetData"), exports);
+__exportStar(require("./model/WidgetParams"), exports);
 __exportStar(require("./api/ElectronApi"), exports);
+__exportStar(require("./api/Keys"), exports);
+__exportStar(require("./repository/WidgetDataRepository"), exports);

package/dist/cjs/model/BroadcastEvent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastEvent = void 0;
+class BroadcastEvent {
+    constructor(type, from, payload) {
+        this.type = type;
+        this.from = from;
+        this.payload = payload;
+    }
+}
+exports.BroadcastEvent = BroadcastEvent;
+BroadcastEvent.TYPE_WIDGET_UPDATED = "BROADCAST:WIDGET_UPDATED";

package/dist/cjs/model/SocialInfo.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialInfo = void 0;
+class SocialInfo {
+    constructor(name, url) {
+        this.name = name;
+        this.content = url;
+    }
+}
+exports.SocialInfo = SocialInfo;

package/dist/cjs/model/Widget.js

@@ -1,49 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WidgetKeyword = exports.Widget = void 0;
-var Widget = /** @class */ (function () {
-    function Widget(name, title, desc, keywords, lang, w, h, maxW, maxH, minW, minH, url, configUrl, debugUrl) {
+class Widget {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
         /**
          * 组件默认语言
          */
         this.lang = "zh";
-        this.name = name;
-        this.title = title;
-        this.desc = desc;
-        this.keywords = keywords;
-        this.lang = lang;
-        this.w = w;
-        this.h = h;
-        this.maxW = maxW;
-        this.maxH = maxH;
-        this.minW = minW;
-        this.minH = minH;
-        this.url = url;
-        this.configUrl = configUrl;
-        this.debugUrl = debugUrl;
+        this.name = options.name;
+        this.title = options.title;
+        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.url = options.url;
+        this.configUrl = options.configUrl;
+        this.extraUrl = (_e = options.extraUrl) !== null && _e !== void 0 ? _e : new Map();
     }
     /**
      * 获取组件标题
      * @param lang 语言环境，不传则获取默认语言
      */
-    Widget.prototype.getTitle = function (lang) {
+    getTitle(lang) {
         return lang ? this.title.get(lang) : this.title.get(this.lang);
-    };
+    }
     /**
      * 获取组件标描述
      * @param lang 语言环境，不传则获取默认标题
      */
-    Widget.prototype.getDesc = function (lang) {
-        return lang ? this.desc.get(lang) : this.desc.get(this.lang);
-    };
-    Widget.prototype.stringify = function () {
-        var jsonObject = JSON.parse(JSON.stringify(this));
-        jsonObject["title"] = Object.fromEntries(this.title);
-        jsonObject["desc"] = Object.fromEntries(this.desc);
-        return JSON.stringify(jsonObject);
-    };
-    return Widget;
-}());
+    getDescription(lang) {
+        return lang ? this.description.get(lang) : this.description.get(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) {
+        const object = JSON.parse(json);
+        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"]
+        });
+    }
+}
 exports.Widget = Widget;
 var WidgetKeyword;
 (function (WidgetKeyword) {

package/dist/cjs/model/WidgetData.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetData = void 0;
+/**
+ * 组件配置数据，用于存储组件自定义页面所设置的数据
+ */
+class WidgetData {
+    constructor(name, id) {
+        this.id = id;
+        this.name = name;
+    }
+    parseJSON(json) {
+        Object.assign(this, json);
+    }
+}
+exports.WidgetData = WidgetData;

package/dist/cjs/model/WidgetParams.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetHostMode = exports.ThemeMode = exports.WidgetParams = void 0;
+/**
+ * 组件参数，如宽，高，id，语言等环境参数
+ */
+const query_1 = require("../router/query");
+class WidgetParams {
+    /**
+     * 将组件参数转为url参数
+     * @param object
+     * @return URLSearchParams  w_w=2&w_h=2&w_id=21&w_width=156&w_height=156
+     */
+    toUrlParams() {
+        const urlParams = new URLSearchParams();
+        const ownPropertyNames = Object.getOwnPropertyNames(this);
+        for (let ownPropertyName of ownPropertyNames) {
+            const key = ownPropertyName;
+            const value = this[key];
+            if (value) {
+                urlParams.append(WidgetParams.PARAM_PREFIX + ownPropertyName, value.toString());
+            }
+        }
+        return urlParams;
+    }
+    getPersistKey() {
+        return `${this.name}-${this.id}`;
+    }
+    /**
+     * 从当前地址解析组件参数：
+     * 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}
+     */
+    static fromCurrentLocation() {
+        const href = window.location.href;
+        let queryString = href.split("?")[1];
+        return this.fromObject((0, query_1.parseQuery)(queryString));
+    }
+    static setValue(widgetEnv, key, value) {
+        const keyWithoutPrefix = key.replace(this.PARAM_PREFIX, "");
+        if (keyWithoutPrefix == WidgetParams.PARAM_ID) {
+            widgetEnv.id = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_X) {
+            widgetEnv.x = parseInt(value);
+        }
+        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_W) {
+            widgetEnv.w = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_LANG) {
+            widgetEnv.lang = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_THEME) {
+            widgetEnv.theme = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_MODE) {
+            widgetEnv.mode = parseInt(value);
+        }
+        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_HEIGHT) {
+            widgetEnv.height = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_NAME) {
+            widgetEnv.name = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_TITLE) {
+            widgetEnv.title = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_PREVIEW) {
+            widgetEnv.preview = (value === 'true');
+        }
+    }
+    /**
+     * 从对象键值对中初始化组件参数
+     * {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}
+     * @param object
+     */
+    static fromObject(object) {
+        const widgetEnv = new WidgetParams();
+        const ownPropertyNames = Object.getOwnPropertyNames(object);
+        for (let ownPropertyName of ownPropertyNames) {
+            const key = ownPropertyName;
+            const value = object[key];
+            this.setValue(widgetEnv, key, value);
+        }
+        return widgetEnv;
+    }
+}
+exports.WidgetParams = 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_X = "x";
+WidgetParams.PARAM_Y = "y";
+WidgetParams.PARAM_LANG = "lang";
+WidgetParams.PARAM_THEME = "theme";
+WidgetParams.PARAM_MODE = "mode";
+WidgetParams.PARAM_RADIUS = "radius";
+WidgetParams.PARAM_NAME = "name";
+WidgetParams.PARAM_TITLE = "title";
+WidgetParams.PARAM_PREVIEW = "preview";
+WidgetParams.PARAMS = [
+    WidgetParams.PARAM_ID,
+    WidgetParams.PARAM_W,
+    WidgetParams.PARAM_H,
+    WidgetParams.PARAM_X,
+    WidgetParams.PARAM_Y,
+    WidgetParams.PARAM_LANG,
+    WidgetParams.PARAM_THEME,
+    WidgetParams.PARAM_MODE,
+    WidgetParams.PARAM_WIDTH,
+    WidgetParams.PARAM_HEIGHT,
+    WidgetParams.PARAM_NAME,
+    WidgetParams.PARAM_TITLE,
+    WidgetParams.PARAM_PREVIEW,
+];
+var ThemeMode;
+(function (ThemeMode) {
+    ThemeMode["AUTO"] = "auto";
+    ThemeMode["LIGHT"] = "LIGHT";
+    ThemeMode["DARK"] = "DARK";
+})(ThemeMode = exports.ThemeMode || (exports.ThemeMode = {}));
+var WidgetHostMode;
+(function (WidgetHostMode) {
+    WidgetHostMode[WidgetHostMode["DEFAULT"] = 0] = "DEFAULT";
+    WidgetHostMode[WidgetHostMode["OVERLAP"] = 1] = "OVERLAP";
+})(WidgetHostMode = exports.WidgetHostMode || (exports.WidgetHostMode = {}));

package/dist/cjs/repository/WidgetDataRepository.js

@@ -0,0 +1,88 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetDataRepository = void 0;
+const localforage_1 = __importDefault(require("localforage"));
+const BroadcastEvent_1 = require("../model/BroadcastEvent");
+const ElectronApi_1 = require("../api/ElectronApi");
+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_1.BroadcastEvent(BroadcastEvent_1.BroadcastEvent.TYPE_WIDGET_UPDATED, "", data);
+            yield ElectronApi_1.ElectronApi.sendBroadcastEvent(broadcastEvent);
+            return result;
+        });
+    }
+    /**
+     * 获取组件 LocalForage 存储实例
+     * @param name
+     */
+    static getStore(name) {
+        if (this.stores.has(name)) {
+            return this.stores.get(name);
+        }
+        const store = localforage_1.default.createInstance({ name: name });
+        this.stores.set(name, store);
+        return store;
+    }
+    /**
+     * 通过组件名保存组件信息，通常用于存储可以在同类组件中共用的数据
+     * @param name
+     * @param json
+     */
+    static saveByName(name, json) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let store = this.getStore(name);
+            const result = yield store.setItem(name, json);
+            const broadcastEvent = new BroadcastEvent_1.BroadcastEvent(BroadcastEvent_1.BroadcastEvent.TYPE_WIDGET_UPDATED, "", { name, json });
+            yield ElectronApi_1.ElectronApi.sendBroadcastEvent(broadcastEvent);
+            return result;
+        });
+    }
+    static findWithName(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 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 getKey(name, id) {
+        return `${name}@${id}`;
+    }
+}
+exports.WidgetDataRepository = WidgetDataRepository;
+WidgetDataRepository.stores = new Map();