layplux 0.0.1

package/dist/cjs/components/popup/index.cjs

@@ -0,0 +1,280 @@
+"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 popup_exports = {};
+__export(popup_exports, {
+  Popup: () => Popup
+});
+module.exports = __toCommonJS(popup_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+function computePosition(triggerRect, popupW, popupH, placement, offsetX, offsetY) {
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  const PADDING = 8;
+  let top = 0;
+  let left = 0;
+  const [main, align] = placement.split("-");
+  if (main === "bottom") {
+    top = triggerRect.bottom + offsetY;
+    if (align === "start") left = triggerRect.left + offsetX;
+    else if (align === "end") left = triggerRect.right - popupW + offsetX;
+    else left = triggerRect.left + triggerRect.width / 2 - popupW / 2 + offsetX;
+    if (top + popupH > vh - PADDING) {
+      top = triggerRect.top - popupH - offsetY;
+      placement = align ? `top-${align}` : "top";
+    }
+  } else if (main === "top") {
+    top = triggerRect.top - popupH - offsetY;
+    if (align === "start") left = triggerRect.left + offsetX;
+    else if (align === "end") left = triggerRect.right - popupW + offsetX;
+    else left = triggerRect.left + triggerRect.width / 2 - popupW / 2 + offsetX;
+    if (top < PADDING) {
+      top = triggerRect.bottom + offsetY;
+      placement = align ? `bottom-${align}` : "bottom";
+    }
+  } else if (main === "right") {
+    left = triggerRect.right + offsetX;
+    if (align === "start") top = triggerRect.top + offsetY;
+    else if (align === "end") top = triggerRect.bottom - popupH + offsetY;
+    else top = triggerRect.top + triggerRect.height / 2 - popupH / 2 + offsetY;
+    if (left + popupW > vw - PADDING) {
+      left = triggerRect.left - popupW - offsetX;
+      placement = align ? `left-${align}` : "left";
+    }
+  } else if (main === "left") {
+    left = triggerRect.left - popupW - offsetX;
+    if (align === "start") top = triggerRect.top + offsetY;
+    else if (align === "end") top = triggerRect.bottom - popupH + offsetY;
+    else top = triggerRect.top + triggerRect.height / 2 - popupH / 2 + offsetY;
+    if (left < PADDING) {
+      left = triggerRect.right + offsetX;
+      placement = align ? `right-${align}` : "right";
+    }
+  }
+  top = Math.max(PADDING, Math.min(top, vh - popupH - PADDING));
+  left = Math.max(PADDING, Math.min(left, vw - popupW - PADDING));
+  return { position: { top, left }, placement };
+}
+const Popup = (0, import_vue.defineComponent)({
+  name: "LaypluxPopup",
+  props: {
+    visible: Boolean,
+    trigger: { type: String, default: "hover" },
+    placement: { type: String, default: "bottom" },
+    offset: { type: Object, default: () => ({ y: 4 }) },
+    mouseEnterDelay: { type: Number, default: 100 },
+    mouseLeaveDelay: { type: Number, default: 100 },
+    disabled: { type: Boolean, default: false },
+    destroyOnClose: { type: Boolean, default: true },
+    getContainer: { type: Function, default: () => document.body }
+  },
+  emits: ["update:visible"],
+  setup(props, { emit, slots }) {
+    const triggerRef = (0, import_vue.ref)();
+    const popupRef = (0, import_vue.ref)();
+    const position = (0, import_vue.ref)({ top: 0, left: 0 });
+    const currentPlacement = (0, import_vue.ref)(props.placement);
+    const mounted = (0, import_vue.ref)(false);
+    const animatingIn = (0, import_vue.ref)(false);
+    let enterTimer = null;
+    let leaveTimer = null;
+    let leaveAnimationTimer = null;
+    const clearTimers = () => {
+      if (enterTimer) {
+        clearTimeout(enterTimer);
+        enterTimer = null;
+      }
+      if (leaveTimer) {
+        clearTimeout(leaveTimer);
+        leaveTimer = null;
+      }
+      if (leaveAnimationTimer) {
+        clearTimeout(leaveAnimationTimer);
+        leaveAnimationTimer = null;
+      }
+    };
+    const updatePosition = () => {
+      if (!triggerRef.value || !popupRef.value) return;
+      const triggerRect = triggerRef.value.getBoundingClientRect();
+      const popupRect = popupRef.value.getBoundingClientRect();
+      const { x: ox = 0, y: oy = 0 } = props.offset;
+      const result = computePosition(
+        triggerRect,
+        popupRect.width,
+        popupRect.height,
+        props.placement,
+        ox,
+        oy
+      );
+      position.value = result.position;
+      currentPlacement.value = result.placement;
+    };
+    const show = () => {
+      if (props.disabled) return;
+      clearTimers();
+      enterTimer = setTimeout(() => {
+        mounted.value = true;
+        emit("update:visible", true);
+        void (0, import_vue.nextTick)(() => {
+          updatePosition();
+          requestAnimationFrame(() => {
+            animatingIn.value = true;
+          });
+        });
+      }, props.mouseEnterDelay);
+    };
+    const hide = (immediate = false) => {
+      clearTimers();
+      const delay = immediate ? 0 : props.mouseLeaveDelay;
+      leaveTimer = setTimeout(() => {
+        animatingIn.value = false;
+        leaveAnimationTimer = setTimeout(() => {
+          mounted.value = false;
+          emit("update:visible", false);
+        }, 200);
+      }, delay);
+    };
+    const toggle = () => {
+      if (mounted.value && animatingIn.value) {
+        hide(true);
+      } else {
+        clearTimers();
+        show();
+      }
+    };
+    (0, import_vue.watch)(
+      () => props.visible,
+      (v) => {
+        if (v && !mounted.value) show();
+        else if (!v && mounted.value) hide(true);
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.placement,
+      (p) => {
+        currentPlacement.value = p;
+      }
+    );
+    const onResize = () => {
+      if (mounted.value && animatingIn.value) updatePosition();
+    };
+    (0, import_vue.onMounted)(() => {
+      window.addEventListener("resize", onResize);
+      window.addEventListener("scroll", onResize, true);
+      document.addEventListener("mousedown", onClickOutside, true);
+      document.addEventListener("keydown", onEsc);
+    });
+    (0, import_vue.onUnmounted)(() => {
+      clearTimers();
+      window.removeEventListener("resize", onResize);
+      window.removeEventListener("scroll", onResize, true);
+      document.removeEventListener("mousedown", onClickOutside, true);
+      document.removeEventListener("keydown", onEsc);
+    });
+    const onClickOutside = (e) => {
+      if (!mounted.value) return;
+      const target = e.target;
+      const trigger = triggerRef.value;
+      const popup = popupRef.value;
+      if (trigger && trigger.contains(target)) return;
+      if (popup && popup.contains(target)) return;
+      if (props.trigger === "click" || props.trigger === "contextmenu") {
+        hide(true);
+      }
+    };
+    const onEsc = (e) => {
+      if (e.key === "Escape" && mounted.value) {
+        hide(true);
+      }
+    };
+    const onTriggerMouseEnter = () => {
+      if (props.trigger === "hover") show();
+    };
+    const onTriggerMouseLeave = () => {
+      if (props.trigger === "hover") hide();
+    };
+    const onTriggerClick = (e) => {
+      if (props.trigger === "click") {
+        e.stopPropagation();
+        toggle();
+      }
+    };
+    const onTriggerFocus = () => {
+      if (props.trigger === "focus") show();
+    };
+    const onTriggerBlur = () => {
+      if (props.trigger === "focus") hide(true);
+    };
+    const onTriggerContextmenu = (e) => {
+      if (props.trigger === "contextmenu") {
+        e.preventDefault();
+        show();
+      }
+    };
+    const onPopupMouseEnter = () => {
+      if (leaveTimer) {
+        clearTimeout(leaveTimer);
+        leaveTimer = null;
+      }
+    };
+    const onPopupMouseLeave = () => {
+      if (props.trigger === "hover") hide();
+    };
+    return () => {
+      const container = props.getContainer();
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "span",
+          {
+            ref: triggerRef,
+            class: "layplux-popup-trigger",
+            onMouseenter: onTriggerMouseEnter,
+            onMouseleave: onTriggerMouseLeave,
+            onClick: onTriggerClick,
+            onFocus: onTriggerFocus,
+            onBlur: onTriggerBlur,
+            onContextmenu: onTriggerContextmenu,
+            children: slots.default?.()
+          }
+        ),
+        (mounted.value || !props.destroyOnClose) && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_vue.Teleport, { to: container, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "div",
+          {
+            ref: popupRef,
+            class: [
+              "layplux-portal",
+              "layplux-popup",
+              currentPlacement.value,
+              animatingIn.value && "layplux-popup--visible"
+            ],
+            style: {
+              position: "fixed",
+              top: `${position.value.top}px`,
+              left: `${position.value.left}px`,
+              zIndex: "var(--layplux-popup-z-index, 2000)"
+            },
+            onMouseenter: onPopupMouseEnter,
+            onMouseleave: onPopupMouseLeave,
+            children: slots.content?.()
+          }
+        ) })
+      ] });
+    };
+  }
+});

package/dist/cjs/components/title/index.cjs

@@ -0,0 +1,76 @@
+"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 title_exports = {};
+__export(title_exports, {
+  TitleView: () => TitleView
+});
+module.exports = __toCommonJS(title_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+var import_utils = require("../../utils");
+const TitleView = (0, import_vue.defineComponent)({
+  name: "TitleView",
+  inheritAttrs: false,
+  props: {
+    icon: [String, Object, Function],
+    title: [String, Object, Function],
+    mode: {
+      type: String,
+      default: "icon-only"
+    },
+    /** 交互状态：idle / active / disabled / error。idle 时 hover 由 CSS :hover 处理 */
+    state: {
+      type: String,
+      default: "idle"
+    },
+    /** 聚焦/选中态，独立于 state，可与任何状态叠加 */
+    focused: {
+      type: Boolean,
+      default: false
+    },
+    size: {
+      type: String,
+      default: "middle"
+    },
+    className: {
+      type: String,
+      default: ""
+    },
+    onClick: Function
+  },
+  setup(props) {
+    return () => {
+      const { icon, title, mode, state, size, focused, className, onClick } = props;
+      const iconNode = icon ? (0, import_utils.createContent)(icon) : null;
+      const titleNode = title ? (0, import_utils.createContent)(title) : null;
+      const classes = [
+        "title-view",
+        `title-view--${mode}`,
+        `title-view--${state}`,
+        `title-view--${size}`,
+        focused && "title-view--focused",
+        className
+      ].filter(Boolean).join(" ");
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { class: classes, onClick, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { class: "title-view__icon", children: iconNode }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { class: "title-view__label", children: titleNode })
+      ] });
+    };
+  }
+});

package/dist/cjs/components/tooltip/index.cjs

@@ -0,0 +1,68 @@
+"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 tooltip_exports = {};
+__export(tooltip_exports, {
+  Tooltip: () => Tooltip
+});
+module.exports = __toCommonJS(tooltip_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+var import_utils = require("../../utils");
+var import_popup = require("../popup");
+const Tooltip = (0, import_vue.defineComponent)({
+  name: "LaypluxTooltip",
+  props: {
+    title: [String, Object, Function],
+    trigger: { type: String, default: "hover" },
+    placement: { type: String, default: "top" },
+    mouseEnterDelay: { type: Number, default: 100 },
+    mouseLeaveDelay: { type: Number, default: 100 },
+    visible: Boolean,
+    disabled: { type: Boolean, default: false },
+    getContainer: { type: Function, default: () => document.body }
+  },
+  emits: ["update:visible"],
+  setup(props, { emit, slots }) {
+    return () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_popup.Popup,
+      {
+        visible: props.visible,
+        trigger: props.trigger,
+        placement: props.placement,
+        disabled: props.disabled,
+        mouseEnterDelay: props.mouseEnterDelay,
+        mouseLeaveDelay: props.mouseLeaveDelay,
+        destroyOnClose: true,
+        getContainer: props.getContainer,
+        "onUpdate:visible": (v) => emit("update:visible", v),
+        children: {
+          default: () => slots.default?.(),
+          content: () => {
+            const hasContent = slots.content;
+            const titleNode = hasContent ? slots.content?.() : (0, import_utils.createContent)(props.title);
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { class: "layplux-tooltip", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { class: "layplux-tooltip__arrow" }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { class: "layplux-tooltip__inner", children: titleNode })
+            ] });
+          }
+        }
+      }
+    );
+  }
+});

package/dist/cjs/components/widget/index.cjs

@@ -0,0 +1,104 @@
+"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, {
+  WidgetTitleView: () => WidgetTitleView,
+  WidgetView: () => WidgetView
+});
+module.exports = __toCommonJS(widget_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+var import_title = require("../title");
+var import_tooltip = require("../tooltip");
+const WidgetView = (0, import_vue.defineComponent)({
+  name: "WidgetView",
+  inheritAttrs: false,
+  props: {
+    widget: Object
+  },
+  setup(props) {
+    const hasError = (0, import_vue.ref)(false);
+    const errorMessage = (0, import_vue.ref)("");
+    (0, import_vue.onErrorCaptured)((err) => {
+      hasError.value = true;
+      errorMessage.value = err.message;
+      console.error(`[Layplux] Widget "${props.widget?.name}" crashed:`, err);
+      return false;
+    });
+    return () => {
+      const { widget } = props;
+      if (hasError.value) {
+        const fallback = widget?.config.props?.errorFallback;
+        if (fallback) {
+          return (0, import_vue.h)(fallback, { error: errorMessage.value, widget });
+        }
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { class: "layplux-widget-error", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+            '\u7EC4\u4EF6 "',
+            widget?.name,
+            '" \u53D1\u751F\u9519\u8BEF'
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: errorMessage.value })
+        ] });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_vue.Fragment, { children: widget?.renderBody() });
+    };
+  }
+});
+const WidgetTitleView = (0, import_vue.defineComponent)({
+  name: "WidgetTitleView",
+  inheritAttrs: false,
+  props: {
+    widget: Object
+  },
+  setup(props) {
+    const tooltipVisible = (0, import_vue.ref)(false);
+    const handleClick = () => {
+      tooltipVisible.value = false;
+      props.widget?.container?.toggleActive(props.widget?.name);
+    };
+    return () => {
+      const { widget } = props;
+      const tooltipTitle = widget?.config.props?.title ?? widget?.name ?? "";
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { class: "widget-title-view", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_tooltip.Tooltip,
+        {
+          visible: tooltipVisible.value,
+          "onUpdate:visible": (v) => {
+            tooltipVisible.value = v;
+          },
+          title: tooltipTitle,
+          placement: "right",
+          mouseEnterDelay: 500,
+          getContainer: () => document.querySelector(".layplux-root") || document.body,
+          children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_title.TitleView,
+            {
+              onClick: handleClick,
+              focused: widget?.focused.value,
+              state: widget?.active.value ? "active" : "idle",
+              icon: widget?.config.props?.icon,
+              title: widget?.config.props?.title
+            }
+          )
+        }
+      ) });
+    };
+  }
+});

package/dist/cjs/index.cjs

@@ -0,0 +1,40 @@
+"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 index_exports = {};
+__export(index_exports, {
+  FocusTracker: () => import_focus_tracker.FocusTracker,
+  Layplux: () => import_layplux.default,
+  createPluginEventBus: () => import_event_bus.createPluginEventBus,
+  useSkeleton: () => import_skeleton.useSkeleton
+});
+module.exports = __toCommonJS(index_exports);
+var import_layplux = __toESM(require("./layout/layplux"), 1);
+var import_skeleton = require("./managers/skeleton");
+var import_event_bus = require("./utils/event-bus");
+var import_focus_tracker = require("./utils/focus-tracker");

package/dist/cjs/layout/glass-overlay.cjs

@@ -0,0 +1,31 @@
+"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 glass_overlay_exports = {};
+__export(glass_overlay_exports, {
+  GlassOverlay: () => GlassOverlay
+});
+module.exports = __toCommonJS(glass_overlay_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+const GlassOverlay = (0, import_vue.defineComponent)({
+  name: "GlassOverlay",
+  setup() {
+    return () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {});
+  }
+});

package/dist/cjs/layout/layered-manager.cjs

@@ -0,0 +1,35 @@
+"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 layered_manager_exports = {};
+__export(layered_manager_exports, {
+  LayeredManager: () => LayeredManager
+});
+module.exports = __toCommonJS(layered_manager_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+var import_skeleton = require("./skeleton");
+const LayeredManager = (0, import_vue.defineComponent)({
+  name: "LayeredManager",
+  props: {
+    skeleton: Object
+  },
+  setup(props) {
+    return () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { class: "layered-manager", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_skeleton.Skeleton, { skeleton: props.skeleton }) });
+  }
+});

package/dist/cjs/layout/layplux.cjs

@@ -0,0 +1,41 @@
+"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 layplux_exports = {};
+__export(layplux_exports, {
+  default: () => layplux_default
+});
+module.exports = __toCommonJS(layplux_exports);
+var import_jsx_runtime = require("vue/jsx-runtime");
+var import_vue = require("vue");
+var import_root_pane = require("./root-pane");
+const Layplux = (0, import_vue.defineComponent)({
+  name: "Layplux",
+  props: {
+    skeleton: Object
+  },
+  setup(props) {
+    return () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_root_pane.RootPane, { skeleton: props.skeleton, children: "Layplux" });
+  }
+});
+var layplux_default = Object.assign(Layplux, {
+  install: (app) => {
+    app.component("Layplux", Layplux);
+    return app;
+  }
+});