@widget-js/core 0.0.6 → 0.0.8

package/dist/cjs/router/encoding.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Encoding Rules ␣ = Space Path: ␣ " < > # ? { } Query: ␣ " < > # & = Hash: ␣ "
+ * < > `
+ *
+ * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)
+ * defines some extra characters to be encoded. Most browsers do not encode them
+ * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to
+ * also encode `!'()*`. Leaving un-encoded only ASCII alphanumeric(`a-zA-Z0-9`)
+ * plus `-._~`. This extra safety should be applied to query by patching the
+ * string returned by encodeURIComponent encodeURI also encodes `[\]^`. `\`
+ * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\`
+ * into a `/` if directly typed in. The _backtick_ (`````) should also be
+ * encoded everywhere because some browsers like FF encode it when directly
+ * written while others don't. Safari and IE don't encode ``"<>{}``` in hash.
+ */
+// const EXTRA_RESERVED_RE = /[!'()*]/g
+// const encodeReservedReplacer = (c: string) => '%' + c.charCodeAt(0).toString(16)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encodeParam = exports.encodePath = exports.encodeQueryKey = exports.encodeQueryValue = exports.encodeHash = exports.PLUS_RE = void 0;
+const HASH_RE = /#/g; // %23
+const AMPERSAND_RE = /&/g; // %26
+const SLASH_RE = /\//g; // %2F
+const EQUAL_RE = /=/g; // %3D
+const IM_RE = /\?/g; // %3F
+exports.PLUS_RE = /\+/g; // %2B
+/**
+ * NOTE: It's not clear to me if we should encode the + symbol in queries, it
+ * seems to be less flexible than not doing so and I can't find out the legacy
+ * systems requiring this for regular requests like text/html. In the standard,
+ * the encoding of the plus character is only mentioned for
+ * application/x-www-form-urlencoded
+ * (https://url.spec.whatwg.org/#urlencoded-parsing) and most browsers seems lo
+ * leave the plus character as is in queries. To be more flexible, we allow the
+ * plus character on the query, but it can also be manually encoded by the user.
+ *
+ * Resources:
+ * - https://url.spec.whatwg.org/#urlencoded-parsing
+ * - https://stackoverflow.com/questions/1634271/url-encoding-the-space-character-or-20
+ */
+const ENC_BRACKET_OPEN_RE = /%5B/g; // [
+const ENC_BRACKET_CLOSE_RE = /%5D/g; // ]
+const ENC_CARET_RE = /%5E/g; // ^
+const ENC_BACKTICK_RE = /%60/g; // `
+const ENC_CURLY_OPEN_RE = /%7B/g; // {
+const ENC_PIPE_RE = /%7C/g; // |
+const ENC_CURLY_CLOSE_RE = /%7D/g; // }
+const ENC_SPACE_RE = /%20/g; // }
+/**
+ * Encode characters that need to be encoded on the path, search and hash
+ * sections of the URL.
+ *
+ * @internal
+ * @param text - string to encode
+ * @returns encoded string
+ */
+function commonEncode(text) {
+    return encodeURI('' + text)
+        .replace(ENC_PIPE_RE, '|')
+        .replace(ENC_BRACKET_OPEN_RE, '[')
+        .replace(ENC_BRACKET_CLOSE_RE, ']');
+}
+/**
+ * Encode characters that need to be encoded on the hash section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+function encodeHash(text) {
+    return commonEncode(text)
+        .replace(ENC_CURLY_OPEN_RE, '{')
+        .replace(ENC_CURLY_CLOSE_RE, '}')
+        .replace(ENC_CARET_RE, '^');
+}
+exports.encodeHash = encodeHash;
+/**
+ * Encode characters that need to be encoded query values on the query
+ * section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+function encodeQueryValue(text) {
+    return (commonEncode(text)
+        // Encode the space as +, encode the + to differentiate it from the space
+        .replace(exports.PLUS_RE, '%2B')
+        .replace(ENC_SPACE_RE, '+')
+        .replace(HASH_RE, '%23')
+        .replace(AMPERSAND_RE, '%26')
+        .replace(ENC_BACKTICK_RE, '`')
+        .replace(ENC_CURLY_OPEN_RE, '{')
+        .replace(ENC_CURLY_CLOSE_RE, '}')
+        .replace(ENC_CARET_RE, '^'));
+}
+exports.encodeQueryValue = encodeQueryValue;
+/**
+ * Like `encodeQueryValue` but also encodes the `=` character.
+ *
+ * @param text - string to encode
+ */
+function encodeQueryKey(text) {
+    return encodeQueryValue(text).replace(EQUAL_RE, '%3D');
+}
+exports.encodeQueryKey = encodeQueryKey;
+/**
+ * Encode characters that need to be encoded on the path section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+function encodePath(text) {
+    return commonEncode(text).replace(HASH_RE, '%23').replace(IM_RE, '%3F');
+}
+exports.encodePath = encodePath;
+/**
+ * Encode characters that need to be encoded on the path section of the URL as a
+ * param. This function encodes everything {@link encodePath} does plus the
+ * slash (`/`) character. If `text` is `null` or `undefined`, returns an empty
+ * string instead.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+function encodeParam(text) {
+    return text == null ? '' : encodePath(text).replace(SLASH_RE, '%2F');
+}
+exports.encodeParam = encodeParam;
+/**
+ * Decode text using `decodeURIComponent`. Returns the original text if it
+ * fails.
+ *
+ * @param text - string to decode
+ * @returns decoded string
+ */
+function decode(text) {
+    try {
+        return decodeURIComponent('' + text);
+    }
+    catch (err) {
+        // __DEV__ && warn(`Error decoding "${text}". Using original value`)
+    }
+    return '' + text;
+}
+exports.decode = decode;

package/dist/cjs/router/query.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeQuery = exports.stringifyQuery = exports.parseQuery = void 0;
+const encoding_1 = require("./encoding");
+const isArray = Array.isArray;
+/**
+ * Transforms a queryString into a {@link LocationQuery} object. Accept both, a
+ * version with the leading `?` and without Should work as URLSearchParams
+ * @internal
+ *
+ * @param search - search string to parse
+ * @returns a query object
+ */
+function parseQuery(search) {
+    const query = {};
+    // avoid creating an object with an empty key and empty value
+    // because of split('&')
+    if (search === '' || search === '?')
+        return query;
+    const hasLeadingIM = search[0] === '?';
+    const searchParams = (hasLeadingIM ? search.slice(1) : search).split('&');
+    for (let i = 0; i < searchParams.length; ++i) {
+        // pre decode the + into space
+        const searchParam = searchParams[i].replace(encoding_1.PLUS_RE, ' ');
+        // allow the = character
+        const eqPos = searchParam.indexOf('=');
+        const key = (0, encoding_1.decode)(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));
+        const value = eqPos < 0 ? null : (0, encoding_1.decode)(searchParam.slice(eqPos + 1));
+        if (key in query) {
+            // an extra variable for ts types
+            let currentValue = query[key];
+            if (!isArray(currentValue)) {
+                currentValue = query[key] = [currentValue];
+            }
+            // we force the modification
+            ;
+            currentValue.push(value);
+        }
+        else {
+            query[key] = value;
+        }
+    }
+    return query;
+}
+exports.parseQuery = parseQuery;
+/**
+ * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it
+ * doesn't prepend a `?`
+ *
+ * @internal
+ *
+ * @param query - query object to stringify
+ * @returns string version of the query without the leading `?`
+ */
+function stringifyQuery(query) {
+    let search = '';
+    for (let key in query) {
+        const value = query[key];
+        key = (0, encoding_1.encodeQueryKey)(key);
+        if (value == null) {
+            // only null adds the value
+            if (value !== undefined) {
+                search += (search.length ? '&' : '') + key;
+            }
+            continue;
+        }
+        // keep null values
+        const values = isArray(value)
+            ? value.map(v => v && (0, encoding_1.encodeQueryValue)(v))
+            : [value && (0, encoding_1.encodeQueryValue)(value)];
+        values.forEach(value => {
+            // skip undefined values in arrays as if they were not present
+            // smaller code than using filter
+            if (value !== undefined) {
+                // only append & with non-empty search
+                search += (search.length ? '&' : '') + key;
+                if (value != null)
+                    search += '=' + value;
+            }
+        });
+    }
+    return search;
+}
+exports.stringifyQuery = stringifyQuery;
+/**
+ * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting
+ * numbers into strings, removing keys with an undefined value and replacing
+ * undefined with null in arrays
+ *
+ * @param query - query object to normalize
+ * @returns a normalized query object
+ */
+function normalizeQuery(query) {
+    const normalizedQuery = {};
+    for (const key in query) {
+        const value = query[key];
+        if (value !== undefined) {
+            normalizedQuery[key] = isArray(value)
+                ? value.map(v => (v == null ? null : '' + v))
+                : value == null
+                    ? value
+                    : '' + value;
+        }
+    }
+    return normalizedQuery;
+}
+exports.normalizeQuery = normalizeQuery;

package/dist/esm/api/ElectronApi.js

@@ -7,64 +7,83 @@ 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 };
-    }
-};
-var ElectronApi = /** @class */ (function () {
-    function ElectronApi() {
-    }
-    ElectronApi.openAddWidgetWindow = function () {
+import { Keys } from "./Keys";
+export 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.BROADCAST_EVENT, JSON.stringify(event));
+            }
+        });
+    }
+    static registerBroadcast(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addIpcListener(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.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;
-}());
-export { ElectronApi };
+    }
+}

package/dist/esm/api/Keys.js

@@ -0,0 +1,7 @@
+export class 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/esm/index.js

@@ -1,2 +1,7 @@
 export * from "./model/Widget";
+export * from "./model/BroadcastEvent";
+export * from "./model/WidgetData";
+export * from "./model/WidgetParams";
 export * from "./api/ElectronApi";
+export * from "./api/Keys";
+export * from "./repository/WidgetDataRepository";

package/dist/esm/model/BroadcastEvent.js

@@ -0,0 +1,8 @@
+export class BroadcastEvent {
+    constructor(type, from, payload) {
+        this.type = type;
+        this.from = from;
+        this.payload = payload;
+    }
+}
+BroadcastEvent.TYPE_WIDGET_UPDATED = "BROADCAST:WIDGET_UPDATED";

package/dist/esm/model/SocialInfo.js

@@ -0,0 +1,6 @@
+export class SocialInfo {
+    constructor(name, url) {
+        this.name = name;
+        this.content = url;
+    }
+}

package/dist/esm/model/Widget.js

@@ -1,47 +1,77 @@
-var Widget = /** @class */ (function () {
-    function Widget(name, title, desc, keywords, lang, w, h, maxW, maxH, minW, minH, url, configUrl, debugUrl) {
+export 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;
-}());
-export { 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"]
+        });
+    }
+}
 export var WidgetKeyword;
 (function (WidgetKeyword) {
     WidgetKeyword["RECOMMEND"] = "recommend";

package/dist/esm/model/WidgetData.js

@@ -0,0 +1,12 @@
+/**
+ * 组件配置数据，用于存储组件自定义页面所设置的数据
+ */
+export class WidgetData {
+    constructor(name, id) {
+        this.id = id;
+        this.name = name;
+    }
+    parseJSON(json) {
+        Object.assign(this, json);
+    }
+}