layplux 0.0.1

package/dist/cjs/managers/skeleton.cjs

@@ -0,0 +1,208 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var skeleton_exports = {};
+__export(skeleton_exports, {
+  useSkeleton: () => useSkeleton
+});
+module.exports = __toCommonJS(skeleton_exports);
+var import_vue = require("vue");
+var import_area = require("./area");
+var import_widget = require("./widget");
+var import_widget_container = require("./widget-container");
+var import_utils = require("../utils");
+var import_theme = require("./theme");
+function useSkeleton() {
+  const widgets = [];
+  const self = {};
+  const containers = /* @__PURE__ */ new Map();
+  const focusTracker = new import_utils.FocusTracker();
+  const event = (0, import_utils.createPluginEventBus)("skeleton");
+  const locale = (0, import_vue.ref)((0, import_utils.getBuiltInLocale)("zh-CN"));
+  function setLocale(name) {
+    locale.value = (0, import_utils.getBuiltInLocale)(name);
+  }
+  const theme = (0, import_vue.ref)("system");
+  const systemDark = (0, import_vue.ref)(
+    typeof window !== "undefined" ? window.matchMedia("(prefers-color-scheme: dark)").matches : false
+  );
+  function resolveTheme() {
+    if (theme.value === "system") {
+      return systemDark.value ? "dark" : "light";
+    }
+    return theme.value;
+  }
+  function isDark() {
+    return resolveTheme() === "dark";
+  }
+  function setTheme(t) {
+    theme.value = t;
+  }
+  const themeName = (0, import_vue.ref)("default");
+  function setThemeName(name) {
+    themeName.value = name;
+  }
+  function registerTheme(name, vars) {
+    (0, import_theme.injectThemeCSS)(name, vars);
+  }
+  if (typeof window !== "undefined") {
+    window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", (e) => {
+      systemDark.value = e.matches;
+    });
+  }
+  const topArea = (0, import_area.useArea)(
+    {
+      createContainer
+    },
+    "topArea",
+    (config, container) => createWidget(config, container)
+  );
+  const bottomArea = (0, import_area.useArea)(
+    {
+      createContainer
+    },
+    "bottomArea",
+    (config, container) => createWidget(config, container)
+  );
+  const leftTopArea = (0, import_area.useArea)(
+    {
+      createContainer
+    },
+    "leftTopArea",
+    (config, container) => createWidget(config, container)
+  );
+  const leftBottomArea = (0, import_area.useArea)(
+    {
+      createContainer
+    },
+    "leftBottomArea",
+    (config, container) => createWidget(config, container)
+  );
+  const rightTopArea = (0, import_area.useArea)(
+    { createContainer },
+    "rightTopArea",
+    (config, container) => createWidget(config, container)
+  );
+  const rightBottomArea = (0, import_area.useArea)(
+    { createContainer },
+    "rightBottomArea",
+    (config, container) => createWidget(config, container)
+  );
+  const bottomRightArea = (0, import_area.useArea)(
+    { createContainer },
+    "bottomRightArea",
+    (config, container) => createWidget(config, container)
+  );
+  const bottomLeftArea = (0, import_area.useArea)(
+    {
+      createContainer
+    },
+    "bottomLeftArea",
+    (config, container) => createWidget(config, container)
+  );
+  const centerArea = (0, import_area.useArea)(
+    { createContainer },
+    "centerArea",
+    (config, container) => createWidget(config, container)
+  );
+  function createWidget(config, container) {
+    if ((0, import_widget.isWidget)(config)) {
+      return config;
+    }
+    const widget = (0, import_widget.useWidget)(config, container, self);
+    widgets.push(widget);
+    event.emitGlobal("skeleton:widget-added", { widget });
+    return widget;
+  }
+  const focusedId = (0, import_vue.ref)(null);
+  function toggleFocus(id) {
+    if (focusedId.value === id) {
+      blur();
+    } else {
+      focus(id);
+    }
+  }
+  function focus(id) {
+    focusedId.value = id;
+    event.emitGlobal("skeleton:focus-changed", { focusedId: id });
+  }
+  function blur() {
+    focusedId.value = null;
+    event.emitGlobal("skeleton:focus-changed", { focusedId: null });
+  }
+  function add(config, extraConfig) {
+    if (extraConfig) {
+      config = { ...config, ...extraConfig };
+    }
+    const { area } = config;
+    if (area === "topArea") {
+      topArea.add(config);
+    } else if (area === "bottomArea") {
+      bottomArea.add(config);
+    } else if (area === "leftTopArea") {
+      leftTopArea.add(config);
+    } else if (area === "leftBottomArea") {
+      leftBottomArea.add(config);
+    } else if (area === "bottomLeftArea") {
+      bottomLeftArea.add(config);
+    } else if (area === "rightTopArea") {
+      rightTopArea.add(config);
+    } else if (area === "rightBottomArea") {
+      rightBottomArea.add(config);
+    } else if (area === "bottomRightArea") {
+      bottomRightArea.add(config);
+    } else if (area === "centerArea") {
+      centerArea.add(config);
+    }
+  }
+  function createContainer(name, handle) {
+    const container = (0, import_widget_container.useWidgetContainer)(handle, self);
+    containers.set(name, container);
+    return container;
+  }
+  Object.assign(self, {
+    widgets,
+    topArea,
+    bottomArea,
+    leftTopArea,
+    leftBottomArea,
+    rightTopArea,
+    rightBottomArea,
+    bottomRightArea,
+    bottomLeftArea,
+    centerArea,
+    focusedId,
+    focusTracker,
+    event,
+    locale,
+    setLocale,
+    theme,
+    resolveTheme,
+    isDark,
+    setTheme,
+    themeName,
+    setThemeName,
+    registerTheme,
+    toggleFocus,
+    focus,
+    blur,
+    add,
+    createContainer
+  });
+  return self;
+}

package/dist/cjs/managers/theme.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var theme_exports = {};
+__export(theme_exports, {
+  injectThemeCSS: () => injectThemeCSS
+});
+module.exports = __toCommonJS(theme_exports);
+function injectThemeCSS(name, vars) {
+  const styleId = `layplux-theme-${name}`;
+  let styleEl = document.getElementById(styleId);
+  if (!styleEl) {
+    styleEl = document.createElement("style");
+    styleEl.id = styleId;
+    document.head.appendChild(styleEl);
+  }
+  const varLines = Object.entries(vars).map(([key, value]) => `    ${key}: ${value};`).join("\n");
+  styleEl.textContent = `.layplux-root[data-theme='${name}'] {
+${varLines}
+}
+`;
+}

package/dist/cjs/managers/widget-container.cjs

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var widget_container_exports = {};
+__export(widget_container_exports, {
+  useWidgetContainer: () => useWidgetContainer
+});
+module.exports = __toCommonJS(widget_container_exports);
+var import_vue = require("vue");
+function useWidgetContainer(handle, skeleton) {
+  const maps = {};
+  const items = (0, import_vue.ref)([]);
+  const activeId = (0, import_vue.ref)(null);
+  const self = {
+    items,
+    activeId,
+    add,
+    get,
+    getAt,
+    indexOf,
+    remove,
+    activate,
+    deactivate,
+    toggleActive
+  };
+  function add(item) {
+    const nItem = handle(item, self);
+    const origin = get(nItem.name);
+    if (origin === nItem) return origin;
+    const i = origin ? items.value.indexOf(origin) : -1;
+    if (i > -1) {
+      items.value.splice(i, 1, nItem);
+    } else {
+      items.value.push(nItem);
+    }
+    maps[nItem.name] = nItem;
+    return nItem;
+  }
+  function get(name) {
+    return maps[name] || null;
+  }
+  function getAt(index) {
+    return items.value[index] || null;
+  }
+  function indexOf(item) {
+    return items.value.indexOf(item);
+  }
+  function remove(name) {
+    const item = maps[name];
+    if (!item) return null;
+    const i = items.value.indexOf(item);
+    if (i > -1) items.value.splice(i, 1);
+    delete maps[name];
+    skeleton.event.emitGlobal("skeleton:widget-removed", { name });
+    return item;
+  }
+  function activate(id) {
+    if (!maps[id]) return;
+    activeId.value = id;
+    skeleton.focus(id);
+    maps[id].focusable.active();
+    skeleton.event.emitGlobal(`widget:${id}:activated`, { widget: maps[id] });
+  }
+  function deactivate() {
+    const current = activeId.value;
+    activeId.value = null;
+    skeleton.blur();
+    if (current && maps[current]) {
+      maps[current].focusable.suspense();
+      skeleton.event.emitGlobal(`widget:${current}:deactivated`, { widget: maps[current] });
+    }
+  }
+  function toggleActive(id) {
+    if (activeId.value === id) {
+      deactivate();
+    } else {
+      activate(id);
+    }
+  }
+  return self;
+}

package/dist/cjs/managers/widget.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var widget_exports = {};
+__export(widget_exports, {
+  isWidget: () => isWidget,
+  useWidget: () => useWidget
+});
+module.exports = __toCommonJS(widget_exports);
+var import_vue = require("vue");
+var import_utils = require("../utils");
+var import_components = require("../components");
+var import_pane = require("./pane");
+function useWidget(config, container, skeleton) {
+  const { name, props, type } = config;
+  const active = (0, import_vue.computed)(() => container?.activeId.value === name);
+  const focused = (0, import_vue.computed)(() => skeleton?.focusedId.value === name);
+  const id = (0, import_utils.uniqueId)(type);
+  const align = props?.align ?? "left";
+  const pane = (0, import_pane.usePane)();
+  const focusable = skeleton.focusTracker.create({
+    range: (e) => {
+      const target = e.target;
+      if (!target) {
+        return false;
+      }
+      const el = document.getElementById(id);
+      if (el?.contains(target)) {
+        return true;
+      }
+      if (target.classList.contains("layplux-resize-handle")) {
+        return true;
+      }
+      return false;
+    },
+    onActive: () => {
+      widget.container?.activate(name);
+      skeleton.event?.emitGlobal(`widget:${name}:focus`, { widget });
+    },
+    onBlur: () => {
+      skeleton.blur();
+      skeleton.event?.emitGlobal(`widget:${name}:blur`, { widget });
+      if (pane.viewMode.value === "DockUnpinned" || pane.viewMode.value === "Undock") {
+        container?.deactivate();
+      }
+    }
+  });
+  function renderBody() {
+    const { content, contentProps } = config;
+    return (0, import_utils.createContent)(content, { ...contentProps, config, event: widget.event });
+  }
+  function renderContent() {
+    return (0, import_vue.h)(import_components.WidgetView, { key: id, widget });
+  }
+  function renderTitle() {
+    return (0, import_vue.h)(import_components.WidgetTitleView, { key: id, widget });
+  }
+  const widget = {
+    id,
+    type,
+    isWidget: true,
+    name,
+    align,
+    config,
+    active,
+    focused,
+    container,
+    pane,
+    focusable,
+    event: skeleton.event,
+    renderBody,
+    renderContent,
+    renderTitle
+  };
+  props?.onInit?.(widget);
+  if (skeleton?.event) {
+    (0, import_vue.watch)(
+      () => pane.viewMode.value,
+      (mode) => {
+        skeleton.event.emitGlobal(`widget:${name}:view-mode-changed`, { widget, mode });
+      }
+    );
+  }
+  return widget;
+}
+function isWidget(obj) {
+  return obj && obj.isWidget;
+}

package/dist/cjs/types/config.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+module.exports = __toCommonJS(config_exports);

package/dist/cjs/types/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./config"), module.exports);

package/dist/cjs/types/locale.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locale_exports = {};
+module.exports = __toCommonJS(locale_exports);

package/dist/cjs/utils/event-bus.cjs

@@ -0,0 +1,154 @@
+"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 __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 event_bus_exports = {};
+__export(event_bus_exports, {
+  createPluginEventBus: () => createPluginEventBus,
+  emitSystemEvent: () => emitSystemEvent,
+  getGlobalEmitter: () => getGlobalEmitter,
+  onSystemEvent: () => onSystemEvent
+});
+module.exports = __toCommonJS(event_bus_exports);
+var import_eventemitter2 = __toESM(require("eventemitter2"), 1);
+const globalEmitter = new import_eventemitter2.default({
+  wildcard: true,
+  // 开启通配符
+  delimiter: ":",
+  // 命名空间分隔符，与原版 createModuleEventBus 保持一致
+  newListener: false,
+  // 不触发 newListener 事件，减少不必要开销
+  maxListeners: 200,
+  // 对标原版 createModuleEventBus(pluginName, 200) 的容量参数
+  verboseMemoryLeak: true
+  // 超出 maxListeners 时打印详细的内存泄漏警告
+});
+function createPluginEventBus(namespace) {
+  const privateEmitter = new import_eventemitter2.default({
+    wildcard: true,
+    delimiter: ":",
+    newListener: false,
+    maxListeners: 200,
+    verboseMemoryLeak: true
+  });
+  const prefixed = (event) => `${namespace}:${event}`;
+  return {
+    // ── 私有事件（自动加 namespace 前缀）──────────────────────────
+    emit(event, payload) {
+      privateEmitter.emit(prefixed(event), payload);
+    },
+    /**
+     * 订阅私有事件，返回取消订阅函数。
+     * 利用 EventEmitter2 的 Listener 对象的 .off() 方法，
+     * 无需调用方保存 handler 引用。
+     */
+    on(event, handler) {
+      const listener = privateEmitter.on(
+        prefixed(event),
+        handler,
+        { objectify: true }
+        // 返回 Listener 对象而非 emitter 本身
+      );
+      return () => listener.off();
+    },
+    off(event, handler) {
+      privateEmitter.off(prefixed(event), handler);
+    },
+    /**
+     * 订阅一次后自动取消
+     */
+    once(event, handler) {
+      const listener = privateEmitter.once(prefixed(event), handler, {
+        objectify: true
+      });
+      return () => listener.off();
+    },
+    // ── 全局事件（跨插件通信，走 globalEmitter）────────────────────
+    emitGlobal(event, payload) {
+      globalEmitter.emit(event, payload);
+    },
+    /**
+     * 订阅全局事件，支持通配符：
+     *   onGlobal('layout:*', fn)       → 订阅所有 layout 事件
+     *   onGlobal('layout:panel-**', fn)→ 订阅所有 layout:panel 开头的事件
+     *   onGlobal('**', fn)             → 订阅所有全局事件（慎用）
+     */
+    onGlobal(event, handler) {
+      const listener = globalEmitter.on(event, handler, {
+        objectify: true
+      });
+      return () => listener.off();
+    },
+    offGlobal(event, handler) {
+      globalEmitter.off(event, handler);
+    },
+    onGlobalOnce(event, handler) {
+      const listener = globalEmitter.once(event, handler, {
+        objectify: true
+      });
+      return () => listener.off();
+    },
+    /**
+     * 等待某个全局事件触发，返回 Promise（EventEmitter2 原生支持）
+     * 适合插件 setup 中等待其他插件就绪的场景：
+     *   await ctx.event.waitForGlobal('explorer:ready', 5000)
+     */
+    waitForGlobal(event, timeoutMs) {
+      return new Promise((resolve, reject) => {
+        const timer = timeoutMs ? setTimeout(() => {
+          globalEmitter.off(event, onEvent);
+          reject(new Error(`[EventBus] Timeout waiting for "${event}" after ${timeoutMs}ms`));
+        }, timeoutMs) : null;
+        function onEvent(payload) {
+          if (timer) clearTimeout(timer);
+          resolve(payload);
+        }
+        globalEmitter.once(event, onEvent);
+      });
+    },
+    // ── 清理（插件 destroy 时调用）─────────────────────────────────
+    /**
+     * 移除该插件私有 emitter 上的所有监听器。
+     * 全局监听器需要单独 offGlobal（插件应在 teardown 中手动清理）。
+     */
+    removeAllListeners() {
+      privateEmitter.removeAllListeners();
+    }
+  };
+}
+function emitSystemEvent(event, payload) {
+  globalEmitter.emit(event, payload);
+}
+function onSystemEvent(event, handler) {
+  const listener = globalEmitter.on(event, handler, {
+    objectify: true
+  });
+  return () => listener.off();
+}
+function getGlobalEmitter() {
+  return globalEmitter;
+}