@widget-js/core 0.7.2 → 0.7.4

package/dist/index.cjs

@@ -0,0 +1,2027 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiConstants: () => ApiConstants,
+  AppApi: () => AppApi,
+  AppApiConstants: () => AppApiConstants,
+  AppApiEvent: () => AppApiEvent,
+  AppNotification: () => AppNotification,
+  BaseApi: () => BaseApi,
+  BroadcastApi: () => BroadcastApi,
+  BroadcastEvent: () => BroadcastEvent,
+  BrowserWindowApi: () => BrowserWindowApi,
+  BrowserWindowApiEvent: () => BrowserWindowApiEvent,
+  Channel: () => Channel,
+  ClipboardApi: () => ClipboardApi,
+  ClipboardApiEvent: () => ClipboardApiEvent,
+  DeployMode: () => DeployMode,
+  DeployedPage: () => DeployedPage,
+  DeployedWidget: () => DeployedWidget,
+  DeployedWidgetApi: () => DeployedWidgetApi,
+  DeviceApi: () => DeviceApi,
+  DialogApi: () => DialogApi,
+  ElectronApi: () => ElectronApi,
+  ElectronUtils: () => ElectronUtils,
+  FileApi: () => FileApi,
+  Gravity: () => Gravity,
+  GridRect: () => GridRect,
+  GridSystem: () => GridSystem,
+  HostedMode: () => HostedMode,
+  LogApi: () => LogApi,
+  NotificationApi: () => NotificationApi,
+  NotificationApiEvent: () => NotificationApiEvent,
+  NotificationSize: () => NotificationSize,
+  Page: () => Page,
+  ShortcutApi: () => ShortcutApi,
+  ShortcutApiEvent: () => ShortcutApiEvent,
+  StoreApi: () => StoreApi,
+  ThemeMode: () => ThemeMode,
+  WebSocketEvent: () => WebSocketEvent,
+  WebSocketEventType: () => WebSocketEventType,
+  Widget: () => Widget,
+  WidgetApi: () => WidgetApi,
+  WidgetApiEvent: () => WidgetApiEvent,
+  WidgetData: () => WidgetData,
+  WidgetDataApi: () => WidgetDataApi,
+  WidgetKeyword: () => WidgetKeyword,
+  WidgetPackage: () => WidgetPackage,
+  WidgetParams: () => WidgetParams,
+  WidgetUrlUtils: () => WidgetUrlUtils,
+  normalizeUrl: () => normalizeUrl,
+  parseQuery: () => parseQuery,
+  stringifyQuery: () => stringifyQuery
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/model/DeployMode.ts
+var HostedMode = /* @__PURE__ */ ((HostedMode2) => {
+  HostedMode2[HostedMode2["NORMAL"] = 1] = "NORMAL";
+  HostedMode2[HostedMode2["OVERLAP"] = 16] = "OVERLAP";
+  HostedMode2[HostedMode2["WALLPAPER"] = 256] = "WALLPAPER";
+  HostedMode2[HostedMode2["SCREEN"] = 4096] = "SCREEN";
+  HostedMode2[HostedMode2["BACKGROUND"] = 65536] = "BACKGROUND";
+  HostedMode2[HostedMode2["PAGE"] = 1048576] = "PAGE";
+  HostedMode2[HostedMode2["ALL"] = 1118481] = "ALL";
+  return HostedMode2;
+})(HostedMode || {});
+var DeployMode = /* @__PURE__ */ ((DeployMode2) => {
+  DeployMode2[DeployMode2["NORMAL"] = 1] = "NORMAL";
+  DeployMode2[DeployMode2["OVERLAP"] = 16] = "OVERLAP";
+  DeployMode2[DeployMode2["BACKGROUND"] = 65536] = "BACKGROUND";
+  DeployMode2[DeployMode2["ALL"] = 1118481] = "ALL";
+  return DeployMode2;
+})(DeployMode || {});
+
+// src/utils/LanguageUtils.ts
+function getTextByLanguageCode(langMap, langCode, fallbackToBrowser = true) {
+  let result;
+  if (langCode) {
+    if (langCode in langMap) {
+      return langMap[langCode];
+    }
+  }
+  if (result == void 0 && fallbackToBrowser) {
+    if (typeof navigator != "undefined" && navigator.languages) {
+      const langCode2 = navigator.language;
+      result = getTextByLanguageCode(langMap, langCode2, false);
+      if (result != void 0) {
+        return result;
+      }
+    }
+  }
+  if (result == void 0) {
+    let langCode2 = Object.keys(langMap);
+    if (langCode2.length > 0) {
+      return langMap[langCode2[0]];
+    }
+  }
+  return void 0;
+}
+
+// src/model/Page.ts
+var Page = class {
+  //窗口名称,名称与包名类似，e.g. com.example.countdown
+  name;
+  /**
+   * 窗口标题，显示在界面上的，
+   * https://zh.m.wikipedia.org/zh-hans/ISO_639-1
+   */
+  title;
+  /**
+   * 窗口介绍
+   */
+  description;
+  keywords;
+  /**
+   * 组件默认语言
+   */
+  lang;
+  width;
+  packageName;
+  height;
+  maxWidth;
+  maxHeight;
+  minWidth;
+  minHeight;
+  movable;
+  singleton;
+  resizable;
+  path;
+  meta;
+  backgroundThrottling;
+  /**
+   * 预览图片，可以是GIF
+   */
+  previewImage;
+  constructor(options) {
+    this.name = options.name;
+    this.title = options.title;
+    this.description = options.description;
+    this.keywords = options.keywords;
+    this.lang = options.lang;
+    this.width = options.width;
+    this.height = options.height;
+    this.movable = options.movable ?? true;
+    this.resizable = options.resizable ?? true;
+    this.maxWidth = options.maxWidth ?? options.width;
+    this.maxHeight = options.maxHeight ?? options.height;
+    this.minWidth = options.minWidth ?? options.width;
+    this.minHeight = options.minHeight ?? options.height;
+    this.backgroundThrottling = options.backgroundThrottling ?? true;
+    this.packageName = options.packageName;
+    this.singleton = options.singleton ?? false;
+    this.previewImage = options.previewImage;
+    this.path = options.path;
+    this.meta = options.meta ?? {};
+  }
+  /**
+   * 获取组件标题
+   * @param lang 语言环境，不传则获取默认语言
+   */
+  getTitle(lang) {
+    return getTextByLanguageCode(this.title, lang);
+  }
+  /**
+   * 获取组件描述
+   * @param lang 语言环境，不传则获取默认标题
+   */
+  getDescription(lang) {
+    return getTextByLanguageCode(this.description, lang);
+  }
+  static parseJSON(json) {
+    const object = JSON.parse(json);
+    return this.parseObject(object);
+  }
+  static parseObject(obj) {
+    let widget = new Page({
+      path: "",
+      description: {},
+      height: 0,
+      keywords: [],
+      lang: "zh-CN",
+      name: "",
+      previewImage: "",
+      title: {},
+      width: 0
+    });
+    Object.assign(widget, obj);
+    return widget;
+  }
+  isResizable() {
+    return this.resizable || !(this.minWidth == this.width && this.maxWidth == this.width && this.minHeight == this.height && this.maxHeight == this.height);
+  }
+};
+
+// src/model/Widget.ts
+var Widget = class extends Page {
+  supportDeployMode;
+  /**
+   * 配置页面路径，没有则不能修改
+   */
+  configPagePath;
+  constructor(options) {
+    super(options);
+    this.configPagePath = options.configPagePath;
+    this.supportDeployMode = options.supportDeployMode ?? 1 /* NORMAL */ | 16 /* OVERLAP */;
+  }
+  static parseJSON(json) {
+    const object = JSON.parse(json);
+    return this.parseObject(object);
+  }
+  static parseObject(obj) {
+    let widget = new Widget({
+      path: "",
+      description: {},
+      height: 0,
+      keywords: [],
+      lang: "zh-CN",
+      name: "",
+      previewImage: "",
+      title: {},
+      width: 0
+    });
+    Object.assign(widget, obj);
+    return widget;
+  }
+  /**
+   * 是否支持悬浮窗
+   */
+  isSupportOverlap() {
+    return (this.supportDeployMode & 16 /* OVERLAP */) > 0;
+  }
+  isSupportBackground() {
+    return (this.supportDeployMode & 65536 /* BACKGROUND */) > 0;
+  }
+  /**
+   * 是否支持普通模式
+   */
+  isSupportNormal() {
+    return (this.supportDeployMode & 1 /* NORMAL */) > 0;
+  }
+};
+var WidgetKeyword = /* @__PURE__ */ ((WidgetKeyword2) => {
+  WidgetKeyword2["RECOMMEND"] = "recommend";
+  WidgetKeyword2["TOOLS"] = "tools";
+  WidgetKeyword2["EFFICIENCY"] = "efficiency";
+  WidgetKeyword2["PICTURE"] = "picture";
+  WidgetKeyword2["LIFE"] = "life";
+  WidgetKeyword2["SHORTCUT"] = "shortcut";
+  WidgetKeyword2["COUNTDOWN"] = "countdown";
+  WidgetKeyword2["TIMER"] = "timer";
+  WidgetKeyword2["INFO"] = "info";
+  WidgetKeyword2["DASHBOARD"] = "dashboard";
+  return WidgetKeyword2;
+})(WidgetKeyword || {});
+
+// src/model/event/BroadcastEvent.ts
+var BroadcastEvent = class {
+  event;
+  sender;
+  payload;
+  constructor(options) {
+    this.event = options.event;
+    this.sender = options.sender;
+    this.payload = options.payload;
+  }
+};
+
+// src/model/event/WebSocketEvent.ts
+var WebSocketEventType = /* @__PURE__ */ ((WebSocketEventType2) => {
+  WebSocketEventType2["RESISTER_PACKAGE"] = "ws::cn.widgetjs.core.resister_package";
+  return WebSocketEventType2;
+})(WebSocketEventType || {});
+var WebSocketEvent = class {
+  //类型
+  type;
+  payload;
+  constructor(type, payload) {
+    this.type = type;
+    this.payload = payload;
+  }
+};
+
+// src/model/WidgetData.ts
+var WidgetData = class {
+  /**
+   * 组件id
+   */
+  id;
+  /**
+   * 组件名
+   */
+  name;
+  /**
+   * 背景颜色
+   */
+  backgroundColor;
+  /**
+   * 文字颜色
+   */
+  color;
+  /**
+   * 字体大小
+   */
+  fontSize;
+  /**
+   * 字体
+   */
+  fontFamily;
+  /**
+   * 圆角半径
+   */
+  borderRadius;
+  constructor(name, id) {
+    this.id = id;
+    this.name = name;
+  }
+  parseJSON(json) {
+    Object.assign(this, json);
+  }
+};
+
+// src/router/encoding.ts
+var HASH_RE = /#/g;
+var AMPERSAND_RE = /&/g;
+var EQUAL_RE = /=/g;
+var PLUS_RE = /\+/g;
+var ENC_BRACKET_OPEN_RE = /%5B/g;
+var ENC_BRACKET_CLOSE_RE = /%5D/g;
+var ENC_CARET_RE = /%5E/g;
+var ENC_BACKTICK_RE = /%60/g;
+var ENC_CURLY_OPEN_RE = /%7B/g;
+var ENC_PIPE_RE = /%7C/g;
+var ENC_CURLY_CLOSE_RE = /%7D/g;
+var ENC_SPACE_RE = /%20/g;
+function commonEncode(text) {
+  return encodeURI("" + text).replace(ENC_PIPE_RE, "|").replace(ENC_BRACKET_OPEN_RE, "[").replace(ENC_BRACKET_CLOSE_RE, "]");
+}
+function encodeQueryValue(text) {
+  return commonEncode(text).replace(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, "^");
+}
+function encodeQueryKey(text) {
+  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function decode(text) {
+  try {
+    return decodeURIComponent("" + text);
+  } catch (err) {
+  }
+  return "" + text;
+}
+
+// src/router/query.ts
+var isArray = Array.isArray;
+function parseQuery(search) {
+  const query = {};
+  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) {
+    const searchParam = searchParams[i].replace(PLUS_RE, " ");
+    const eqPos = searchParam.indexOf("=");
+    const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));
+    const value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));
+    if (key in query) {
+      let currentValue = query[key];
+      if (!isArray(currentValue)) {
+        currentValue = query[key] = [currentValue];
+      }
+      ;
+      currentValue.push(value);
+    } else {
+      query[key] = value;
+    }
+  }
+  return query;
+}
+function stringifyQuery(query) {
+  let search = "";
+  for (let key in query) {
+    const value = query[key];
+    key = encodeQueryKey(key);
+    if (value == null) {
+      if (value !== void 0) {
+        search += (search.length ? "&" : "") + key;
+      }
+      continue;
+    }
+    const values = isArray(value) ? value.map((v) => v && encodeQueryValue(v)) : [value && encodeQueryValue(value)];
+    values.forEach((value2) => {
+      if (value2 !== void 0) {
+        search += (search.length ? "&" : "") + key;
+        if (value2 != null)
+          search += "=" + value2;
+      }
+    });
+  }
+  return search;
+}
+
+// src/model/WidgetParams.ts
+var import_change_case = require("change-case");
+var _WidgetParams = class {
+  //组件id
+  id;
+  //网格宽度，1就代表宽度占用1格
+  width;
+  //宽度,单位px
+  widthPx;
+  //宽度,单位px
+  heightPx;
+  //网格高度，2就代表高度占用2格
+  height;
+  x;
+  y;
+  //是否是预览模式，添加组件时，预览状态
+  preview;
+  //语言环境：zh,en,jp...
+  lang;
+  //主题：浅色，深色
+  theme;
+  //
+  mode;
+  //系统设置的组件圆角半径
+  radius;
+  //组件名
+  name;
+  title;
+  /**
+   * 将组件参数转为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 + (0, import_change_case.snakeCase)(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
+   * =>
+   *  {width:2,height:2,id:21,width_px:156,height_px:156}
+   */
+  static fromCurrentLocation() {
+    const href = window.location.href;
+    let strings = href.split("?");
+    if (strings.length > 1) {
+      let queryString = strings[1];
+      return this.fromObject(parseQuery(queryString));
+    }
+    return new _WidgetParams();
+  }
+  static fromLocation(url) {
+    let strings = url.split("?");
+    if (strings.length > 1) {
+      let queryString = strings[1];
+      return this.fromObject(parseQuery(queryString));
+    }
+    return new _WidgetParams();
+  }
+  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_HEIGHT) {
+      widgetEnv.height = parseInt(value);
+    } else if (keyWithoutPrefix == _WidgetParams.PARAM_WIDTH) {
+      widgetEnv.width = 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_PX) {
+      widgetEnv.widthPx = parseInt(value);
+    } else if (keyWithoutPrefix == _WidgetParams.PARAM_HEIGHT_PX) {
+      widgetEnv.heightPx = 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_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) {
+    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;
+  }
+};
+var WidgetParams = _WidgetParams;
+__publicField(WidgetParams, "PARAM_PREFIX", "w_");
+__publicField(WidgetParams, "PARAM_ID", "id");
+__publicField(WidgetParams, "PARAM_WIDTH", "width");
+__publicField(WidgetParams, "PARAM_HEIGHT", "height");
+__publicField(WidgetParams, "PARAM_WIDTH_PX", "width_px");
+__publicField(WidgetParams, "PARAM_HEIGHT_PX", "height_px");
+__publicField(WidgetParams, "PARAM_X", "x");
+__publicField(WidgetParams, "PARAM_Y", "y");
+__publicField(WidgetParams, "PARAM_LANG", "lang");
+__publicField(WidgetParams, "PARAM_THEME", "theme");
+__publicField(WidgetParams, "PARAM_MODE", "mode");
+__publicField(WidgetParams, "PARAM_RADIUS", "radius");
+__publicField(WidgetParams, "PARAM_NAME", "name");
+__publicField(WidgetParams, "PARAM_TITLE", "title");
+__publicField(WidgetParams, "PARAM_PREVIEW", "preview");
+__publicField(WidgetParams, "PARAMS", [
+  _WidgetParams.PARAM_ID,
+  _WidgetParams.PARAM_WIDTH,
+  _WidgetParams.PARAM_HEIGHT,
+  _WidgetParams.PARAM_X,
+  _WidgetParams.PARAM_Y,
+  _WidgetParams.PARAM_LANG,
+  _WidgetParams.PARAM_THEME,
+  _WidgetParams.PARAM_MODE,
+  _WidgetParams.PARAM_WIDTH_PX,
+  _WidgetParams.PARAM_HEIGHT_PX,
+  _WidgetParams.PARAM_NAME,
+  _WidgetParams.PARAM_TITLE,
+  _WidgetParams.PARAM_PREVIEW
+]);
+var ThemeMode = /* @__PURE__ */ ((ThemeMode2) => {
+  ThemeMode2["AUTO"] = "auto";
+  ThemeMode2["LIGHT"] = "LIGHT";
+  ThemeMode2["DARK"] = "DARK";
+  return ThemeMode2;
+})(ThemeMode || {});
+
+// src/model/AppNotification.ts
+var NotificationSize = /* @__PURE__ */ ((NotificationSize2) => {
+  NotificationSize2["SMALL"] = "small";
+  NotificationSize2["NORMAL"] = "normal";
+  NotificationSize2["LARGE"] = "large";
+  return NotificationSize2;
+})(NotificationSize || {});
+var AppNotification = class {
+  type = "info";
+  message;
+  title;
+  targetTime;
+  duration;
+  icon;
+  color;
+  backgroundColor;
+  confirmButtonText;
+  cancelButtonText;
+  cancelBroadcast;
+  confirmBroadcast;
+  size;
+  url;
+  avatar;
+  audio;
+  lyric;
+  createdAt;
+  constructor(option) {
+    this.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.type = option.type ?? "info";
+    this.title = option.title;
+    this.message = option.message;
+    this.targetTime = option.targetTime;
+    this.duration = option.duration ?? 5e3;
+    this.icon = option.icon;
+    this.color = option.color ?? "#5D8AC8";
+    this.confirmButtonText = option.confirmButtonText;
+    this.cancelButtonText = option.cancelButtonText;
+    this.cancelBroadcast = option.cancelBroadcast;
+    this.confirmBroadcast = option.confirmBroadcast;
+    this.size = option.size ?? "normal" /* NORMAL */;
+    this.audio = option.audio;
+    this.avatar = option.avatar;
+    this.lyric = option.lyric;
+    this.backgroundColor = option.backgroundColor ?? "#000000";
+  }
+};
+
+// src/model/DeployedPage.ts
+var DeployedPage = class {
+  name;
+  packageName;
+  x = 0;
+  y = 0;
+  height = 600;
+  width = 800;
+  proxy;
+  id;
+};
+
+// src/model/DeployedWidget.ts
+var DeployedWidget = class extends DeployedPage {
+  shortcut;
+  deployMode;
+  isOverlap() {
+    return (this.deployMode & 16 /* OVERLAP */) > 0;
+  }
+};
+
+// src/model/msic/graphics.ts
+var Gravity = /* @__PURE__ */ ((Gravity2) => {
+  Gravity2["TOP"] = "TOP";
+  Gravity2["LEFT"] = "LEFT";
+  Gravity2["RIGHT"] = "RIGHT";
+  Gravity2["BOTTOM"] = "BOTTOM";
+  return Gravity2;
+})(Gravity || {});
+
+// src/utils/normalizeUrl.ts
+var DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
+var DATA_URL_DEFAULT_CHARSET = "us-ascii";
+var testParameter = (name, filters) => filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name);
+var supportedProtocols = /* @__PURE__ */ new Set([
+  "https:",
+  "http:",
+  "file:"
+]);
+var hasCustomProtocol = (urlString) => {
+  try {
+    const { protocol } = new URL(urlString);
+    return protocol.endsWith(":") && !supportedProtocols.has(protocol);
+  } catch {
+    return false;
+  }
+};
+var normalizeDataURL = (urlString, option) => {
+  const match = /^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$/.exec(urlString);
+  if (!match) {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  let { type, data, hash } = match.groups;
+  const mediaType = type.split(";");
+  hash = option.stripHash ? "" : hash;
+  let isBase64 = false;
+  if (mediaType[mediaType.length - 1] === "base64") {
+    mediaType.pop();
+    isBase64 = true;
+  }
+  const mimeType = mediaType.shift()?.toLowerCase() ?? "";
+  const attributes = mediaType.map((attribute) => {
+    let [key, value = ""] = attribute.split("=").map((item) => item.trim());
+    if (key === "charset") {
+      value = value.toLowerCase();
+      if (value === DATA_URL_DEFAULT_CHARSET) {
+        return "";
+      }
+    }
+    return `${key}${value ? `=${value}` : ""}`;
+  }).filter(Boolean);
+  const normalizedMediaType = [
+    ...attributes
+  ];
+  if (isBase64) {
+    normalizedMediaType.push("base64");
+  }
+  if (normalizedMediaType.length > 0 || mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE) {
+    normalizedMediaType.unshift(mimeType);
+  }
+  return `data:${normalizedMediaType.join(";")},${isBase64 ? data.trim() : data}${hash ? `#${hash}` : ""}`;
+};
+function normalizeUrl(urlString, options) {
+  options = {
+    defaultProtocol: "http",
+    normalizeProtocol: true,
+    forceHttp: false,
+    forceHttps: false,
+    stripAuthentication: true,
+    stripHash: false,
+    stripTextFragment: true,
+    stripWWW: true,
+    removeQueryParameters: [/^utm_\w+/i],
+    removeTrailingSlash: true,
+    removeSingleSlash: true,
+    removeDirectoryIndex: false,
+    removeExplicitPort: false,
+    sortQueryParameters: true,
+    ...options
+  };
+  urlString = urlString.replace("\\\\", "//");
+  if (typeof options.defaultProtocol === "string" && !options.defaultProtocol.endsWith(":")) {
+    options.defaultProtocol = `${options.defaultProtocol}:`;
+  }
+  urlString = urlString.trim();
+  if (/^data:/i.test(urlString)) {
+    return normalizeDataURL(urlString, { stripHash: options.stripHash ?? false });
+  }
+  if (hasCustomProtocol(urlString)) {
+    return urlString;
+  }
+  const hasRelativeProtocol = urlString.startsWith("//");
+  const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
+  if (!isRelativeUrl) {
+    urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
+  }
+  const urlObject = new URL(urlString);
+  if (options.forceHttp && options.forceHttps) {
+    throw new Error("The `forceHttp` and `forceHttps` options cannot be used together");
+  }
+  if (options.forceHttp && urlObject.protocol === "https:") {
+    urlObject.protocol = "http:";
+  }
+  if (options.forceHttps && urlObject.protocol === "http:") {
+    urlObject.protocol = "https:";
+  }
+  if (options.stripAuthentication) {
+    urlObject.username = "";
+    urlObject.password = "";
+  }
+  if (options.stripHash) {
+    urlObject.hash = "";
+  } else if (options.stripTextFragment) {
+    urlObject.hash = urlObject.hash.replace(/#?:~:text.*?$/i, "");
+  }
+  if (urlObject.pathname) {
+    const protocolRegex = /\b[a-z][a-z\d+\-.]{1,50}:\/\//g;
+    let lastIndex = 0;
+    let result = "";
+    for (; ; ) {
+      const match = protocolRegex.exec(urlObject.pathname);
+      if (!match) {
+        break;
+      }
+      const protocol = match[0];
+      const protocolAtIndex = match.index;
+      const intermediate = urlObject.pathname.slice(lastIndex, protocolAtIndex);
+      result += intermediate.replace(/\/{2,}/g, "/");
+      result += protocol;
+      lastIndex = protocolAtIndex + protocol.length;
+    }
+    const remnant = urlObject.pathname.slice(lastIndex, urlObject.pathname.length);
+    result += remnant.replace(/\/{2,}/g, "/");
+    urlObject.pathname = result;
+  }
+  if (urlObject.pathname) {
+    try {
+      urlObject.pathname = decodeURI(urlObject.pathname);
+    } catch {
+    }
+  }
+  if (options.removeDirectoryIndex === true) {
+    options.removeDirectoryIndex = [/^index\.[a-z]+$/];
+  }
+  if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
+    let pathComponents = urlObject.pathname.split("/");
+    const lastComponent = pathComponents[pathComponents.length - 1];
+    if (testParameter(lastComponent, options.removeDirectoryIndex)) {
+      pathComponents = pathComponents.slice(0, -1);
+      urlObject.pathname = pathComponents.slice(1).join("/") + "/";
+    }
+  }
+  if (urlObject.hostname) {
+    urlObject.hostname = urlObject.hostname.replace(/\.$/, "");
+    if (options.stripWWW && /^www\.(?!www\.)[a-z\-\d]{1,63}\.[a-z.\-\d]{2,63}$/.test(urlObject.hostname)) {
+      urlObject.hostname = urlObject.hostname.replace(/^www\./, "");
+    }
+  }
+  if (Array.isArray(options.removeQueryParameters)) {
+    for (const key of [...urlObject.searchParams.keys()]) {
+      if (testParameter(key, options.removeQueryParameters)) {
+        urlObject.searchParams.delete(key);
+      }
+    }
+  }
+  if (!Array.isArray(options.keepQueryParameters) && options.removeQueryParameters === true) {
+    urlObject.search = "";
+  }
+  if (Array.isArray(options.keepQueryParameters) && options.keepQueryParameters.length > 0) {
+    for (const key of [...urlObject.searchParams.keys()]) {
+      if (!testParameter(key, options.keepQueryParameters)) {
+        urlObject.searchParams.delete(key);
+      }
+    }
+  }
+  if (options.sortQueryParameters) {
+    urlObject.searchParams.sort();
+    try {
+      urlObject.search = decodeURIComponent(urlObject.search);
+    } catch {
+    }
+  }
+  if (options.removeTrailingSlash) {
+    urlObject.pathname = urlObject.pathname.replace(/\/$/, "");
+  }
+  if (options.removeExplicitPort && urlObject.port) {
+    urlObject.port = "";
+  }
+  const oldUrlString = urlString;
+  urlString = urlObject.toString();
+  if (!options.removeSingleSlash && urlObject.pathname === "/" && !oldUrlString.endsWith("/") && urlObject.hash === "") {
+    urlString = urlString.replace(/\/$/, "");
+  }
+  if ((options.removeTrailingSlash || urlObject.pathname === "/") && urlObject.hash === "" && options.removeSingleSlash) {
+    urlString = urlString.replace(/\/$/, "");
+  }
+  if (hasRelativeProtocol && !options.normalizeProtocol) {
+    urlString = urlString.replace(/^http:\/\//, "//");
+  }
+  if (options.stripProtocol) {
+    urlString = urlString.replace(/^(?:https?:)?\/\//, "");
+  }
+  return urlString;
+}
+
+// src/utils/WidgetUrlUtils.ts
+var WidgetUrlUtils = class {
+  static getWidgetUrl(widgetUrl, widgetPackage, widgetParams) {
+    let url = "";
+    const arr = [];
+    if (widgetUrl.startsWith("http")) {
+      url = widgetUrl;
+    } else {
+      url = widgetPackage.getIndexUrl() + widgetUrl;
+    }
+    arr.push(url);
+    if (url.includes("?")) {
+      arr.push("&");
+    } else {
+      arr.push("?");
+    }
+    arr.push(widgetParams.toUrlParams().toString());
+    return normalizeUrl(arr.join("")).replaceAll("//", "/");
+  }
+  static getWidgetPackageUrl(url, entry, hash) {
+    const arr = [url];
+    if (url.startsWith("http")) {
+      if (hash) {
+        arr.push("#");
+      }
+    } else {
+      arr.push(`/${entry}`);
+      if (hash) {
+        arr.push("#/");
+      }
+    }
+    return normalizeUrl(arr.join("")).replaceAll("//", "/");
+    ;
+  }
+};
+
+// src/model/WidgetPackage.ts
+var WidgetPackage = class {
+  /**
+   * 组件包名,一般为域名倒写，e.g. com.example
+   */
+  name;
+  /**
+   * 组件包版本，可以为空，默认采用package.json里的版本
+   * e.g. 1.0.2
+   */
+  version;
+  /**
+   * 组件作者署名
+   */
+  author;
+  /**
+   * 组件首页
+   */
+  homepage;
+  /**
+   * 组件描述
+   */
+  title;
+  /**
+   * 组件描述
+   */
+  description;
+  /**
+   * 组件入口文件，通常为 index.html
+   */
+  entry;
+  /**
+   * 组件包的远程入口地址，
+   */
+  remoteEntry;
+  remotePackage;
+  local;
+  remote;
+  /**
+   * 组件包图标
+   */
+  icon;
+  /**
+   * Hash路由模式，默认为true
+   */
+  hash = true;
+  /**
+   * 可能是网络地址，或者本地路径（解压后的文件夹路径）,
+   * 网络地址：https://www.bilibili.com
+   * 本地地址：file:///C:/Users/neo/Desktop
+   * 在测试时。地址通常为: http://127.0.0.1:8080
+   */
+  url;
+  widgets = [];
+  pages = [];
+  devOptions;
+  constructor(options) {
+    this.name = options.name;
+    this.version = options.version;
+    this.author = options.author;
+    this.homepage = options.homepage;
+    this.title = options.title;
+    this.description = options.description;
+    this.entry = options.entry ?? "index.html";
+    this.remoteEntry = options.remoteEntry;
+    this.remotePackage = options.remotePackage;
+    this.hash = options.hash;
+    this.url = "";
+    this.icon = options.icon;
+    this.devOptions = options.devOptions;
+    this.remote = options.remote;
+    if (options.widgets) {
+      for (let widget of options.widgets) {
+        this.widgets.push(widget);
+      }
+    }
+  }
+  static parseJSON(json) {
+    const object = JSON.parse(json);
+    return this.parseObject(object);
+  }
+  static parseObject(obj) {
+    let widgetPackage = new WidgetPackage({
+      author: "",
+      description: {
+        "zh-CN": ""
+      },
+      entry: "",
+      hash: false,
+      homepage: "",
+      name: "",
+      title: {
+        "zh-CN": ""
+      },
+      version: ""
+    });
+    Object.assign(widgetPackage, obj);
+    const widgets = [];
+    if (widgetPackage.widgets) {
+      for (let jsonWidget of widgetPackage.widgets) {
+        let widget = new Widget({
+          previewImage: "",
+          path: "",
+          description: { "zh-CN": "" },
+          height: 0,
+          keywords: [],
+          lang: "zh-CN",
+          name: "",
+          title: { "zh-CN": "" },
+          width: 0
+        });
+        Object.assign(widget, jsonWidget);
+        widgets.push(widget);
+      }
+    }
+    widgetPackage.widgets.splice(0, widgetPackage.widgets.length);
+    widgetPackage.widgets.push(...widgets);
+    return widgetPackage;
+  }
+  /**
+   * 获取组件包标题
+   * @param lang 语言环境，不传则获取默认语言
+   */
+  getTitle(lang) {
+    return getTextByLanguageCode(this.title, lang);
+  }
+  /**
+   * 获取组件包描述
+   * @param lang 语言环境，不传则获取默认标题
+   */
+  getDescription(lang) {
+    return getTextByLanguageCode(this.description, lang);
+  }
+  /**
+   * 获取组件完整路径
+   * 如果url是http链接，直接返回链接
+   * 如果是本地组件：file://链接，则返回 url+entry,
+   * 如果是远程组件：http://链接，则返回 entry,
+   * @example file://C:/users/neo/desktop/index.html#
+   * @example file://C:/users/neo/desktop/index.html#
+   */
+  getIndexUrl(hash) {
+    return WidgetUrlUtils.getWidgetPackageUrl(this.url, this.entry, hash == null ? this.hash : hash);
+  }
+};
+
+// src/utils/ElectronUtils.ts
+var ElectronUtils = class {
+  static hasElectronApi() {
+    return this.getAPI() != null;
+  }
+  /**
+   * 获取ElectronAPI
+   * windows api
+   */
+  static getAPI() {
+    if (Reflect.has(window, "electronAPI")) {
+      return window.electronAPI;
+    } else if (Reflect.has(window.parent, "electronAPI")) {
+      return window.parent.electronAPI;
+    }
+    return null;
+  }
+  static async invokeMethod(channel, method, ...args) {
+    return this.getAPI()?.invoke(channel, method, ...args);
+  }
+  static async invoke(channel, ...args) {
+    return this.getAPI()?.invoke(channel, ...args);
+  }
+};
+
+// src/grid/GridSystem.ts
+var GridRect = class {
+  top;
+  left;
+  width;
+  height;
+  constructor(left, top, width, height) {
+    this.top = top;
+    this.left = left;
+    this.width = width;
+    this.height = height;
+  }
+  get right() {
+    return this.left + this.width;
+  }
+  get bottom() {
+    return this.top + this.height;
+  }
+};
+var GridSystem = class extends GridRect {
+  cellSize;
+  horizontalCellCount;
+  verticalCellCount;
+  screenWidth;
+  screenHeight;
+  /**
+   *
+   * @param cellSize
+   * @param padding     至少保留的边距
+   * @param screenWidth
+   * @param screenHeight
+   */
+  constructor(cellSize, padding, screenWidth, screenHeight) {
+    let gridMaxWidth = screenWidth - padding * 2;
+    let gridMaxHeight = screenHeight - padding * 2;
+    let horizontalPadding = gridMaxWidth % cellSize / 2 + padding;
+    let verticalPadding = gridMaxHeight % cellSize / 2 + padding;
+    const horizontalCellCount = Math.floor(gridMaxWidth / cellSize);
+    const verticalCellCount = Math.floor(gridMaxHeight / cellSize);
+    super(horizontalPadding, verticalPadding, horizontalCellCount * cellSize, verticalCellCount * cellSize);
+    this.cellSize = cellSize;
+    this.screenWidth = screenWidth;
+    this.screenHeight = screenHeight;
+    this.horizontalCellCount = horizontalCellCount;
+    this.verticalCellCount = verticalCellCount;
+  }
+  /**
+   * 将坐标对齐到网格上
+   * @param x
+   * @param y
+   */
+  snapPosition(x, y) {
+    let newX = this.getRangeValue(x - this.left, 0, this.width);
+    let newY = this.getRangeValue(y - this.top, 0, this.height);
+    const diffX = newX % this.cellSize;
+    if (diffX >= this.cellSize / 2) {
+      newX = newX + this.cellSize - diffX;
+    } else {
+      newX = newX - diffX;
+    }
+    const diffY = newY % this.cellSize;
+    if (diffY >= this.cellSize / 2) {
+      newY = newY + this.cellSize - diffY;
+    } else {
+      newY = newY - diffY;
+    }
+    return [newX + this.left, newY + this.top];
+  }
+  snapSize(width, height) {
+    let newWidth = Math.floor(width);
+    let newHeight = Math.floor(height);
+    let diffWidth = newWidth % this.cellSize;
+    let diffHeight = newHeight % this.cellSize;
+    if (diffWidth > this.cellSize / 2) {
+      newWidth = width + this.cellSize - diffWidth;
+    } else {
+      newWidth = width - diffWidth;
+    }
+    if (diffHeight > this.cellSize / 2) {
+      newHeight = height + this.cellSize - diffHeight;
+    } else {
+      newHeight = height - diffHeight;
+    }
+    return [newWidth, newHeight];
+  }
+  /**
+   * 将矩形对齐到网格上
+   * @param rect
+   * @param minWidth
+   * @param maxWidth
+   * @param minHeight
+   * @param maxHeight
+   */
+  snapRect(rect, minWidth, maxWidth, minHeight, maxHeight) {
+    let [newX, newY] = this.snapPosition(rect.left, rect.top);
+    let [newWidth, newHeight] = this.snapSize(rect.width, rect.height);
+    newWidth = this.getRangeValue(newWidth, minWidth, maxWidth);
+    newHeight = this.getRangeValue(newHeight, minHeight, maxHeight);
+    if (newX + newWidth > this.right) {
+      newX = this.right - newWidth;
+    }
+    if (newY + newHeight > this.bottom) {
+      newY = this.bottom - newHeight;
+    }
+    return new GridRect(newX, newY, newWidth, newHeight);
+  }
+  getRangeValue(value, min, max) {
+    if (value < min) {
+      return min;
+    }
+    if (value > max) {
+      return max;
+    }
+    return value;
+  }
+  getWidth() {
+    return this.right - this.left;
+  }
+  getHeight() {
+    return this.bottom - this.top;
+  }
+};
+
+// src/api/ElectronApi.ts
+var ElectronApi = class {
+  static async addIpcListener(key, f) {
+    await ElectronUtils.getAPI()?.addIpcListener(key, f);
+  }
+  static async removeIpcListener(key) {
+    await ElectronUtils.getAPI()?.removeIpcListener(key);
+  }
+};
+
+// src/api/WidgetDataApi.ts
+var import_localforage = __toESM(require("localforage"), 1);
+
+// src/api/Channel.ts
+var Channel = /* @__PURE__ */ ((Channel2) => {
+  Channel2["NOTIFICATION"] = "channel::cn.widgetjs.core.notification";
+  Channel2["BROWSER_WINDOW"] = "channel::cn.widgetjs.core.browser_window";
+  Channel2["BROADCAST"] = "channel::cn.widgetjs.core.broadcast";
+  Channel2["WIDGET"] = "channel::cn.widgetjs.core.widget";
+  Channel2["HOSTED_WIDGET"] = "channel::cn.widgetjs.core.hosted_widget";
+  Channel2["APP"] = "channel::cn.widgetjs.core.app";
+  Channel2["DIALOG"] = "channel::cn.widgetjs.core.dialog";
+  Channel2["CLIPBOARD"] = "channel::cn.widgetjs.core.clipboard";
+  Channel2["FILE"] = "channel::cn.widgetjs.core.file";
+  Channel2["SCREEN"] = "channel::cn.widgetjs.core.screen";
+  Channel2["SHORTCUT"] = "channel::cn.widgetjs.core.shortcut";
+  Channel2["LOG"] = "channel::cn.widgetjs.core.log";
+  Channel2["DEVICE"] = "channel::cn.widgetjs.core.device";
+  Channel2["MOUSE"] = "channel::cn.widgetjs.core.mouse";
+  Channel2["KEYBOARD"] = "channel::cn.widgetjs.core.keyboard";
+  Channel2["STORE"] = "channel::cn.widgetjs.core.store";
+  return Channel2;
+})(Channel || {});
+
+// src/api/BaseApi.ts
+var BaseApi = class {
+  async invokeMethod(method, ...args) {
+    return await ElectronUtils.invokeMethod(this.getChannel(), method, ...args);
+  }
+  async invoke(...args) {
+    return await ElectronUtils.invoke(this.getChannel(), ...args);
+  }
+};
+
+// src/api/BroadcastApi.ts
+var BroadcastApiImpl = class extends BaseApi {
+  async send(event) {
+    await this.invokeMethod("send", event);
+  }
+  async register(...event) {
+    await this.invokeMethod("register", event);
+  }
+  async unregister(...event) {
+    await this.invokeMethod("unregister", event);
+  }
+  getChannel() {
+    return "channel::cn.widgetjs.core.broadcast" /* BROADCAST */;
+  }
+};
+var BroadcastApi = new BroadcastApiImpl();
+
+// src/api/WidgetApi.ts
+var WidgetApiEvent = /* @__PURE__ */ ((WidgetApiEvent2) => {
+  WidgetApiEvent2["DATA_CHANGED"] = "event::cn.widgetjs.core.widget.data-changed";
+  WidgetApiEvent2["EDIT_DESKTOP_WIDGETS"] = "event::cn.widgetjs.core.widget.desktop.edit";
+  return WidgetApiEvent2;
+})(WidgetApiEvent || {});
+var WidgetApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.widget" /* WIDGET */;
+  }
+  async registerWidgets(widgets) {
+    return this.invokeMethod("registerWidgets", JSON.stringify(widgets));
+  }
+  async registerWidgetPackage(widgetPackage) {
+    return this.invokeMethod("registerWidgetPackage", JSON.stringify(widgetPackage));
+  }
+  async getWidgets() {
+    const data = await this.invokeMethod("getWidgets");
+    const widgets = [];
+    if (data) {
+      for (const item of data) {
+        widgets.push(Widget.parseObject(item));
+      }
+    }
+    return widgets;
+  }
+  async getWidgetPackages() {
+    return await this.invokeMethod("getWidgetPackages");
+  }
+  /**
+   *
+   * @param name package name
+   */
+  async getWidget(name) {
+    return Widget.parseObject(await this.invokeMethod("getWidget", name));
+  }
+  /**
+   *
+   * @param name package name
+   */
+  async getWidgetPackage(name) {
+    return WidgetPackage.parseObject(await this.invokeMethod("getWidgetPackage", name));
+  }
+  /**
+   * 获取组件配置地址
+   * @param widgetName
+   */
+  async getWidgetConfigUrl(widgetName, widgetParams) {
+    const widget = await this.getWidget(widgetName);
+    if (!widget)
+      return null;
+    const configPagePath = widget.configPagePath;
+    if (!configPagePath)
+      return null;
+    const widgetPackage = await this.getWidgetPackage(widget.packageName);
+    if (!widgetPackage)
+      return null;
+    return WidgetUrlUtils.getWidgetUrl(configPagePath, widgetPackage, widgetParams);
+  }
+  async getWidgetUrl(widgetName, widgetParams) {
+    const widget = await this.getWidget(widgetName);
+    if (!widget)
+      return null;
+    const widgetPackage = await this.getWidgetPackage(widget.packageName);
+    if (!widgetPackage)
+      return null;
+    return WidgetUrlUtils.getWidgetUrl(widget.path, widgetPackage, widgetParams);
+  }
+  async getWidgetPackageIndexUrl(packageName, hash) {
+    const widgetPackage = await this.getWidgetPackage(packageName);
+    if (!widgetPackage)
+      return null;
+    return widgetPackage.getIndexUrl(hash);
+  }
+  async getWidgetPackageUrl(packageName) {
+    const widgetPackage = await this.getWidgetPackage(packageName);
+    if (!widgetPackage)
+      return null;
+    return widgetPackage.url;
+  }
+  // /**
+  //  * 通过组件名保存组件信息，通常用于存储可以在同类组件中共用的数据
+  //  * @param data
+  //  * @param options
+  //  */
+  // public async saveDataByName<T extends WidgetData>(data: T, options: SaveWidgetOption = {sendBroadcast: true}) {
+  //     const store = this.getStore(data.name);
+  //     const json = JSON.stringify(data);
+  //     const result = await store.setItem(data.name, json);
+  //     if (options.sendBroadcast) {
+  //         const broadcastEvent = new BroadcastEvent({
+  //             event: WidgetApiEvent.DATA_CHANGED,
+  //             payload: {
+  //                 name: data.name,
+  //                 id: options.id,
+  //                 json
+  //             }
+  //         });
+  //         await BroadcastApi.send(broadcastEvent);
+  //     }
+  //     return result;
+  // }
+  //
+  // private stores = new Map<string, LocalForage>()
+  //
+  // /**
+  //  * 获取组件 LocalForage 存储实例
+  //  * @param name
+  //  */
+  // public getStore(name: string): LocalForage {
+  //     if (this.stores.has(name)) {
+  //         return this.stores.get(name)!
+  //     }
+  //     const store = localforage.createInstance({name: name});
+  //     this.stores.set(name, store);
+  //     return store;
+  // }
+};
+var WidgetApi = new WidgetApiImpl();
+
+// src/api/WidgetDataApi.ts
+var WidgetDataApiImpl = class {
+  stores = /* @__PURE__ */ new Map();
+  /**
+   * 保存组件数据
+   * @param data
+   */
+  async save(data) {
+    let store = this.getStore(data.name);
+    let json = JSON.stringify(data);
+    const result = await store.setItem(this.getKey(data.name, data.id), json);
+    const broadcastEvent = new BroadcastEvent({
+      event: "event::cn.widgetjs.core.widget.data-changed" /* DATA_CHANGED */,
+      payload: { name: data.name, json }
+    });
+    await BroadcastApi.send(broadcastEvent);
+    return result;
+  }
+  /**
+   * 获取组件 LocalForage 存储实例
+   * @param name
+   */
+  getStore(name) {
+    if (this.stores.has(name)) {
+      return this.stores.get(name);
+    }
+    const store = import_localforage.default.createInstance({ name });
+    this.stores.set(name, store);
+    return store;
+  }
+  /**
+   * 通过组件名保存组件信息，通常用于存储可以在同类组件中共用的数据
+   * @param data
+   * @param options
+   */
+  async saveByName(data, options = { sendBroadcast: true }) {
+    const store = this.getStore(data.name);
+    const json = JSON.stringify(data);
+    const result = await store.setItem(data.name, json);
+    if (options?.sendBroadcast) {
+      const broadcastEvent = new BroadcastEvent({
+        event: "event::cn.widgetjs.core.widget.data-changed" /* DATA_CHANGED */,
+        payload: { name: data.name, json }
+      });
+      await BroadcastApi.send(broadcastEvent);
+    }
+    return result;
+  }
+  async findByName(...args) {
+    let name = "";
+    let dbStr = "";
+    let data;
+    if (args.length === 2) {
+      name = args[0];
+      const type = args[1];
+      data = new type(name);
+    } else {
+      data = args[0];
+      name = data.name;
+    }
+    let store = this.getStore(name);
+    dbStr = await store.getItem(name);
+    if (dbStr) {
+      data.parseJSON(JSON.parse(dbStr));
+      return data;
+    }
+    return void 0;
+  }
+  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 void 0;
+  }
+  getKey(name, id) {
+    return `${name}@${id}`;
+  }
+};
+var WidgetDataApi = new WidgetDataApiImpl();
+
+// src/api/BrowserWindowApi.ts
+var BrowserWindowApiEvent = /* @__PURE__ */ ((BrowserWindowApiEvent2) => {
+  BrowserWindowApiEvent2["BLUR"] = "event::cn.widgetjs.core.browser-window.blur";
+  BrowserWindowApiEvent2["MOVED"] = "event::cn.widgetjs.core.browser-window.moved";
+  BrowserWindowApiEvent2["FOCUS"] = "event::cn.widgetjs.core.browser-window.focus";
+  BrowserWindowApiEvent2["SNAP_TO_EDGE"] = "event::cn.widgetjs.core.browser-window.snap_to_edge";
+  BrowserWindowApiEvent2["RESIZED"] = "event::cn.widgetjs.core.browser-window.resized";
+  BrowserWindowApiEvent2["CANCEL_SNAP_TO_EDGE"] = "event::cn.widgetjs.core.browser-window.cancel_snap_to_edge";
+  return BrowserWindowApiEvent2;
+})(BrowserWindowApiEvent || {});
+var BrowserWindowApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.browser_window" /* BROWSER_WINDOW */;
+  }
+  async setIgnoreMouseEvent(ignore) {
+    await this.invokeMethod("setIgnoreMouseEvent", ignore);
+  }
+  async show() {
+    await this.invokeMethod("show", true);
+  }
+  async showInactive() {
+    await this.invokeMethod("showInactive", true);
+  }
+  async hide() {
+    await this.invokeMethod("hide", false);
+  }
+  async center() {
+    await this.invokeMethod("center", false);
+  }
+  async setAlwaysOnTop(alwaysOnTop) {
+    await this.invokeMethod("setAlwaysOnTop", alwaysOnTop);
+  }
+  async isAlwaysOnTop() {
+    return await this.invokeMethod("isAlwaysOnTop");
+  }
+  async openUrl(url, option) {
+    if (ElectronUtils.hasElectronApi()) {
+      await this.invokeMethod("openUrl", url, option);
+    } else {
+      window.open(url, "_blank");
+    }
+  }
+  async moveTop() {
+    await this.invokeMethod("moveTop");
+  }
+  async openDevTools() {
+    await this.invokeMethod("openDevTools");
+  }
+  async setPosition(options) {
+    await this.invokeMethod("setPosition", options);
+  }
+  async getPosition() {
+    return await this.invokeMethod("getPosition");
+  }
+  async blur() {
+    return await this.invokeMethod("blur");
+  }
+  async focus() {
+    return await this.invokeMethod("focus");
+  }
+  /**
+   * 设置窗口是否可以拉伸
+   * @param resizable
+   */
+  async setResizable(resizable) {
+    return await this.invokeMethod("setResizable", resizable);
+  }
+  async getBounds() {
+    return await this.invokeMethod("getBounds");
+  }
+  async setBounds(bounds, animate) {
+    return await this.invokeMethod("setBounds", bounds, animate);
+  }
+  async alignToScreen(align) {
+    return await this.invokeMethod("alignToScreen", align);
+  }
+  async startDraggingWindow() {
+    return await this.invokeMethod("startDraggingWindow");
+  }
+  async stopDraggingWindow() {
+    return await this.invokeMethod("stopDraggingWindow");
+  }
+  /**
+   * 通过url检测窗口是否存在
+   * @param url
+   */
+  async existsByUrl(url) {
+    return await this.invokeMethod("existsByUrl", url);
+  }
+  async getMaximumSize() {
+    return await this.invokeMethod("getMaximumSize");
+  }
+  async minimize() {
+    return await this.invokeMethod("minimize");
+  }
+  async maximize() {
+    return await this.invokeMethod("maximize");
+  }
+  async isMaximized() {
+    return await this.invokeMethod("isMaximized");
+  }
+  async isMinimized() {
+    return await this.invokeMethod("isMinimized");
+  }
+  async restore() {
+    return await this.invokeMethod("restore");
+  }
+  async unmaximize() {
+    return await this.invokeMethod("unmaximize");
+  }
+  async setZoomLevel(level) {
+    return await this.invokeMethod("setZoomLevel");
+  }
+  async reload() {
+    return await this.invokeMethod("reload");
+  }
+  async setMovable(movable) {
+    return await this.invokeMethod("setMovable", movable);
+  }
+  async setSize(width, height, animate) {
+    return this.invokeMethod("setSize", width, height, animate);
+  }
+  async isFocused() {
+    return this.invokeMethod("isFocused");
+  }
+  async setMaximumSize(width, height) {
+    return this.invokeMethod("setMaximumSize", width, height);
+  }
+  async setMinimumSize(width, height) {
+    return this.invokeMethod("setMinimumSize", width, height);
+  }
+  getMinimumSize() {
+    return this.invokeMethod("getMinimumSize");
+  }
+};
+var BrowserWindowApi = new BrowserWindowApiImpl();
+
+// src/api/NotificationApi.ts
+var NotificationApiEvent = /* @__PURE__ */ ((NotificationApiEvent2) => {
+  NotificationApiEvent2["CONFIRM"] = "event::cn.widgetjs.core.notification.confirm";
+  NotificationApiEvent2["CANCEL"] = "event::cn.widgetjs.core.notification.cancel";
+  NotificationApiEvent2["HIDE"] = "event::cn.widgetjs.core.notification.hide";
+  return NotificationApiEvent2;
+})(NotificationApiEvent || {});
+var NotificationApiImpl = class extends BaseApi {
+  // static async url(url: string, duration: number = -1) {
+  //     this.invoke(Channel.NOTIFICATION, new AppNotification({
+  //         url, message: "",
+  //         duration,
+  //         type: "url",
+  //     }));
+  // }
+  /**
+   * 来电
+   * @param avatar    头像地址
+   * @param audio     音频地址
+   * @param title     标题文件
+   * @param message   初始消息
+   * @param lyric     歌词字符串
+   */
+  async call(avatar, audio, title, message, lyric) {
+    await this.invoke(new AppNotification({
+      avatar,
+      audio,
+      message,
+      title,
+      duration: -1,
+      lyric,
+      type: "call"
+    }));
+  }
+  async send(notification) {
+    return this.invokeMethod("send", notification);
+  }
+  async reminder(title, message, icon, cancelButtonText, confirmButtonText, cancelBroadcast, confirmBroadcast, duration = 5e3) {
+    return await this.send(new AppNotification({
+      icon,
+      message,
+      title,
+      duration,
+      cancelButtonText,
+      confirmButtonText,
+      cancelBroadcast,
+      confirmBroadcast,
+      type: "reminder"
+    }));
+  }
+  async advanceCountdown(message, targetTime, title) {
+    return await this.send(new AppNotification({
+      title,
+      message,
+      targetTime,
+      type: "advance-countdown"
+    }));
+  }
+  async countdown(message, targetTime) {
+    await this.send(new AppNotification({
+      message,
+      targetTime,
+      backgroundColor: "rgba(0,0,0,0.5)",
+      duration: -1,
+      type: "countdown"
+    }));
+  }
+  async success(message, duration = 5e3) {
+    await this.send(new AppNotification({
+      message,
+      type: "success",
+      icon: "check_circle_line",
+      duration
+    }));
+  }
+  async error(message, duration = 5e3) {
+    await this.send(new AppNotification({
+      message,
+      type: "error",
+      icon: "close_circle_line",
+      duration
+    }));
+  }
+  async warning(message, duration = 5e3) {
+    await this.send(new AppNotification({
+      message,
+      type: "warning",
+      icon: "warning_line",
+      duration
+    }));
+  }
+  async info(message, duration = 5e3) {
+    await this.send(new AppNotification({
+      message,
+      type: "info",
+      icon: "information_line",
+      duration
+    }));
+  }
+  /**
+   * 隐藏通知
+   */
+  async hide() {
+    await this.invokeMethod("hide");
+  }
+  getChannel() {
+    return "channel::cn.widgetjs.core.notification" /* NOTIFICATION */;
+  }
+};
+var NotificationApi = new NotificationApiImpl();
+
+// src/api/HostedWidgetApi.ts
+var DeployedWidgetApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.hosted_widget" /* HOSTED_WIDGET */;
+  }
+  /**
+   * 移除组件
+   * @param id
+   */
+  async removeDeployedWidget(id) {
+    return this.invokeMethod("removeDeployedWidget", id);
+  }
+  addWidget(widgetName, hostMode) {
+    return this.invokeMethod("addWidget", widgetName, hostMode);
+  }
+  /**
+   * 通过组件名移除已添加的组件
+   * @param name  组件名
+   */
+  async removeDeployedWidgetByName(name) {
+    return this.invokeMethod("removeDeployedWidgetByName", name);
+  }
+  /**
+   * 获取已添加的组件
+   * @param name  组件名，可以不传
+   */
+  async getDeployedWidgets(name) {
+    return this.invokeMethod("getDeployedWidgets", name);
+  }
+  async getDeployedWidget(id) {
+    return this.invokeMethod("getDeployedWidget", id);
+  }
+  /**
+   * Opens the dev tools for a widget with the specified ID.
+   *
+   * @param {string} widgetId - The ID of the widget to open the dev tools for.
+   * @return {Promise} A Promise that resolves when the dev tools are opened.
+   */
+  async openDevTools(widgetId) {
+    return this.invokeMethod("openDevTools", widgetId);
+  }
+  async openConfigRoute(widgetId, params) {
+    return this.invokeMethod("openConfigRoute", widgetId, params);
+  }
+  /**
+   * 注册激活、呼出、置顶组件快捷键
+   * @param widgetId  组件id
+   * @param shortcut  如果传空或者不传，则会取消快捷键。更多快捷键配置，请查看Accelerator用法
+   *                  https://www.electronjs.org/docs/latest/api/accelerator
+   */
+  async registerActiveShortcut(widgetId, shortcut) {
+    return this.invokeMethod("registerActiveShortcut", widgetId, shortcut);
+  }
+  async setProxy(widgetId, proxy) {
+    return this.invokeMethod("setProxy", widgetId, proxy);
+  }
+};
+var DeployedWidgetApi = new DeployedWidgetApiImpl();
+
+// src/api/DeviceApi.ts
+var DeviceApiImpl = class extends BaseApi {
+  /**
+   * 获取当前鼠标位置
+   */
+  async getCursorScreenPoint() {
+    return this.invokeMethod("getCursorScreenPoint");
+  }
+  /**
+   * 判断是否所有按键都已经释放
+   */
+  async isAllKeyReleased() {
+    return this.invokeMethod("isAllKeyReleased");
+  }
+  getChannel() {
+    return "channel::cn.widgetjs.core.device" /* DEVICE */;
+  }
+};
+var DeviceApi = new DeviceApiImpl();
+
+// src/api/ClipboardApi.ts
+var ClipboardApiEvent = /* @__PURE__ */ ((ClipboardApiEvent2) => {
+  ClipboardApiEvent2["CHANGED"] = "clipboard-changed";
+  return ClipboardApiEvent2;
+})(ClipboardApiEvent || {});
+var ClipboardApiImpl = class extends BaseApi {
+  async getSelectedText() {
+    return this.invokeMethod("getSelectedText");
+  }
+  async getText() {
+    return this.invokeMethod("getText");
+  }
+  getChannel() {
+    return "channel::cn.widgetjs.core.clipboard" /* CLIPBOARD */;
+  }
+};
+var ClipboardApi = new ClipboardApiImpl();
+
+// src/api/ApiConstants.ts
+var ApiConstants = class {
+};
+__publicField(ApiConstants, "CONFIG_LAUNCH_AT_STARTUP", "CONFIG_LAUNCH_AT_STARTUP");
+__publicField(ApiConstants, "CONFIG_WIDGET_TITLE_COLOR", "CONFIG_WIDGET_TITLE_COLOR");
+__publicField(ApiConstants, "CONFIG_DEBUG_MODE", "cn.widgetjs.config.debug");
+__publicField(ApiConstants, "CONFIG_GRID_CELL_SIZE", "cn.widgetjs.config.grid.size");
+__publicField(ApiConstants, "SHORTCUT_PIN_DESKTOP_WIDGETS", "cn.widgetjs.config.shortcut.pin_desktop_widgets");
+
+// src/api/ShortcutApi.ts
+var ShortcutApiEvent = /* @__PURE__ */ ((ShortcutApiEvent2) => {
+  ShortcutApiEvent2["TRIGGERED"] = "channel::cn.widgetjs.core.shortcut.triggered";
+  return ShortcutApiEvent2;
+})(ShortcutApiEvent || {});
+var ShortcutApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.shortcut" /* SHORTCUT */;
+  }
+  async register(shortcut) {
+    return await this.invokeMethod("register", shortcut);
+  }
+  async unregister(shortcut) {
+    return await this.invokeMethod("unregister", shortcut);
+  }
+};
+var ShortcutApi = new ShortcutApiImpl();
+
+// src/api/AppApi.ts
+var AppApiEvent = /* @__PURE__ */ ((AppApiEvent2) => {
+  AppApiEvent2["CONFIG_CHANGED"] = "event::cn.widgetjs.core.app.config.changed";
+  AppApiEvent2["MOVING_GRID_WINDOW"] = "event::cn.widgetjs.core.app.moving.grid.window";
+  return AppApiEvent2;
+})(AppApiEvent || {});
+var AppApiConstants = /* @__PURE__ */ ((AppApiConstants2) => {
+  AppApiConstants2["CONFIG_GRID_CELL_SIZE"] = "cn.widgetjs.config.grid.size";
+  return AppApiConstants2;
+})(AppApiConstants || {});
+var AppApiImpl = class extends BaseApi {
+  async getIconFile() {
+    return this.invokeMethod("getIconFile");
+  }
+  getChannel() {
+    return "channel::cn.widgetjs.core.app" /* APP */;
+  }
+  async setConfig(key, value) {
+    return await this.invokeMethod("setConfig", key, value);
+  }
+  async getConfig(key, defaultValue) {
+    const value = await this.invokeMethod("getConfig", key);
+    if (value === null || value === void 0) {
+      return defaultValue;
+    }
+    if (typeof defaultValue == "boolean") {
+      return value === "true";
+    }
+    if (typeof defaultValue == "number") {
+      return Number(value);
+    }
+    return value;
+  }
+  async openAddWidgetWindow() {
+    return this.invokeMethod("openAddWidgetWindow");
+  }
+  /**
+   * 获取应用版本号，格式为 x.y.z
+   */
+  async getVersion() {
+    return this.invokeMethod("getVersion");
+  }
+  async getPreloadPath() {
+    return this.invokeMethod("getPreloadPath");
+  }
+  async openSettingWindow() {
+    return this.invokeMethod("openSettingWindow");
+  }
+};
+var AppApi = new AppApiImpl();
+
+// src/api/DialogApi.ts
+var DialogApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.dialog" /* DIALOG */;
+  }
+  /**
+   * 选取单个文件
+   * @param extensions 允许的文件后缀格式，如：["txt","docx","gif"]
+   */
+  pickFile(extensions) {
+    return this.invokeMethod("pickFile", extensions);
+  }
+  pickFolder() {
+    return this.invokeMethod("pickFolder");
+  }
+};
+var DialogApi = new DialogApiImpl();
+
+// src/api/StoreApi.ts
+var StoreApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.store" /* STORE */;
+  }
+  async delete(key) {
+    return this.invokeMethod("delete", key);
+  }
+  async get(key, defaultValue) {
+    const result = await this.invokeMethod("get", key);
+    if (result == null && defaultValue != void 0) {
+      return defaultValue;
+    }
+    return result;
+  }
+  async getObject(key, defaultValue) {
+    const result = await this.invokeMethod("get", key);
+    if (result) {
+      return JSON.parse(result);
+    }
+    if (defaultValue != void 0) {
+      return defaultValue;
+    }
+    return void 0;
+  }
+  async set(key, value) {
+    if (typeof value == "object") {
+      return this.invokeMethod("set", key, JSON.stringify(value));
+    }
+    return this.invokeMethod("set", key, value);
+  }
+};
+var StoreApi = new StoreApiImpl();
+
+// src/api/LogApi.ts
+var LogApiImpl = class extends BaseApi {
+  getChannel() {
+    return "channel::cn.widgetjs.core.log" /* LOG */;
+  }
+  info(...data) {
+    console.info(...data);
+    this.invokeMethod("info", ...data);
+  }
+  error(...data) {
+    console.error(...data);
+    this.invokeMethod("error", ...data);
+  }
+  warn(...data) {
+    console.warn(...data);
+    this.invokeMethod("warn", ...data);
+  }
+  log(...data) {
+    console.log(...data);
+    this.invokeMethod("log", ...data);
+  }
+};
+var LogApi = new LogApiImpl();
+
+// src/api/FileApi.ts
+var FileApiImpl = class extends BaseApi {
+  getFileType(filePath) {
+    return this.invokeMethod("getFileType", filePath);
+  }
+  isDirectory(filePath) {
+    return this.invokeMethod("isDirectory", filePath);
+  }
+  getChannel() {
+    return "channel::cn.widgetjs.core.file" /* FILE */;
+  }
+  readDirectory(path, options) {
+    return this.invokeMethod("readDirectory", path, options);
+  }
+};
+var FileApi = new FileApiImpl();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiConstants,
+  AppApi,
+  AppApiConstants,
+  AppApiEvent,
+  AppNotification,
+  BaseApi,
+  BroadcastApi,
+  BroadcastEvent,
+  BrowserWindowApi,
+  BrowserWindowApiEvent,
+  Channel,
+  ClipboardApi,
+  ClipboardApiEvent,
+  DeployMode,
+  DeployedPage,
+  DeployedWidget,
+  DeployedWidgetApi,
+  DeviceApi,
+  DialogApi,
+  ElectronApi,
+  ElectronUtils,
+  FileApi,
+  Gravity,
+  GridRect,
+  GridSystem,
+  HostedMode,
+  LogApi,
+  NotificationApi,
+  NotificationApiEvent,
+  NotificationSize,
+  Page,
+  ShortcutApi,
+  ShortcutApiEvent,
+  StoreApi,
+  ThemeMode,
+  WebSocketEvent,
+  WebSocketEventType,
+  Widget,
+  WidgetApi,
+  WidgetApiEvent,
+  WidgetData,
+  WidgetDataApi,
+  WidgetKeyword,
+  WidgetPackage,
+  WidgetParams,
+  WidgetUrlUtils,
+  normalizeUrl,
+  parseQuery,
+  stringifyQuery
+});
+//# sourceMappingURL=index.cjs.map