@omnipad/core 0.1.1-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1102 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/types/keys.ts
+var STANDARD_KEYS = {
+  // --- System Controls (8-27) ---
+  Backspace: { key: "Backspace", code: "Backspace", keyCode: 8 },
+  Tab: { key: "Tab", code: "Tab", keyCode: 9 },
+  Enter: { key: "Enter", code: "Enter", keyCode: 13 },
+  ShiftLeft: { key: "Shift", code: "ShiftLeft", keyCode: 16 },
+  ControlLeft: { key: "Control", code: "ControlLeft", keyCode: 17 },
+  AltLeft: { key: "Alt", code: "AltLeft", keyCode: 18 },
+  Pause: { key: "Pause", code: "Pause", keyCode: 19 },
+  CapsLock: { key: "CapsLock", code: "CapsLock", keyCode: 20 },
+  Escape: { key: "Escape", code: "Escape", keyCode: 27 },
+  // --- Navigation & Editing (32-46) ---
+  Space: { key: " ", code: "Space", keyCode: 32 },
+  PageUp: { key: "PageUp", code: "PageUp", keyCode: 33 },
+  PageDown: { key: "PageDown", code: "PageDown", keyCode: 34 },
+  End: { key: "End", code: "End", keyCode: 35 },
+  Home: { key: "Home", code: "Home", keyCode: 36 },
+  ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft", keyCode: 37 },
+  ArrowUp: { key: "ArrowUp", code: "ArrowUp", keyCode: 38 },
+  ArrowRight: { key: "ArrowRight", code: "ArrowRight", keyCode: 39 },
+  ArrowDown: { key: "ArrowDown", code: "ArrowDown", keyCode: 40 },
+  PrintScreen: { key: "PrintScreen", code: "PrintScreen", keyCode: 44 },
+  Insert: { key: "Insert", code: "Insert", keyCode: 45 },
+  Delete: { key: "Delete", code: "Delete", keyCode: 46 },
+  // --- Digit Keys 0-9 (48-57) ---
+  Digit0: { key: "0", code: "Digit0", keyCode: 48 },
+  Digit1: { key: "1", code: "Digit1", keyCode: 49 },
+  Digit2: { key: "2", code: "Digit2", keyCode: 50 },
+  Digit3: { key: "3", code: "Digit3", keyCode: 51 },
+  Digit4: { key: "4", code: "Digit4", keyCode: 52 },
+  Digit5: { key: "5", code: "Digit5", keyCode: 53 },
+  Digit6: { key: "6", code: "Digit6", keyCode: 54 },
+  Digit7: { key: "7", code: "Digit7", keyCode: 55 },
+  Digit8: { key: "8", code: "Digit8", keyCode: 56 },
+  Digit9: { key: "9", code: "Digit9", keyCode: 57 },
+  // --- Alpha Keys A-Z (65-90) ---
+  KeyA: { key: "a", code: "KeyA", keyCode: 65 },
+  KeyB: { key: "b", code: "KeyB", keyCode: 66 },
+  KeyC: { key: "c", code: "KeyC", keyCode: 67 },
+  KeyD: { key: "d", code: "KeyD", keyCode: 68 },
+  KeyE: { key: "e", code: "KeyE", keyCode: 69 },
+  KeyF: { key: "f", code: "KeyF", keyCode: 70 },
+  KeyG: { key: "g", code: "KeyG", keyCode: 71 },
+  KeyH: { key: "h", code: "KeyH", keyCode: 72 },
+  KeyI: { key: "i", code: "KeyI", keyCode: 73 },
+  KeyJ: { key: "j", code: "KeyJ", keyCode: 74 },
+  KeyK: { key: "k", code: "KeyK", keyCode: 75 },
+  KeyL: { key: "l", code: "KeyL", keyCode: 76 },
+  KeyM: { key: "m", code: "KeyM", keyCode: 77 },
+  KeyN: { key: "n", code: "KeyN", keyCode: 78 },
+  KeyO: { key: "o", code: "KeyO", keyCode: 79 },
+  KeyP: { key: "p", code: "KeyP", keyCode: 80 },
+  KeyQ: { key: "q", code: "KeyQ", keyCode: 81 },
+  KeyR: { key: "r", code: "KeyR", keyCode: 82 },
+  KeyS: { key: "s", code: "KeyS", keyCode: 83 },
+  KeyT: { key: "t", code: "KeyT", keyCode: 84 },
+  KeyU: { key: "u", code: "KeyU", keyCode: 85 },
+  KeyV: { key: "v", code: "KeyV", keyCode: 86 },
+  KeyW: { key: "w", code: "KeyW", keyCode: 87 },
+  KeyX: { key: "x", code: "KeyX", keyCode: 88 },
+  KeyY: { key: "y", code: "KeyY", keyCode: 89 },
+  KeyZ: { key: "z", code: "KeyZ", keyCode: 90 },
+  // --- Meta & Menu (91-93) ---
+  MetaLeft: { key: "Meta", code: "MetaLeft", keyCode: 91 },
+  ContextMenu: { key: "ContextMenu", code: "ContextMenu", keyCode: 93 },
+  // --- Numpad Digits (96-105) ---
+  Numpad0: { key: "0", code: "Numpad0", keyCode: 96 },
+  Numpad1: { key: "1", code: "Numpad1", keyCode: 97 },
+  Numpad2: { key: "2", code: "Numpad2", keyCode: 98 },
+  Numpad3: { key: "3", code: "Numpad3", keyCode: 99 },
+  Numpad4: { key: "4", code: "Numpad4", keyCode: 100 },
+  Numpad5: { key: "5", code: "Numpad5", keyCode: 101 },
+  Numpad6: { key: "6", code: "Numpad6", keyCode: 102 },
+  Numpad7: { key: "7", code: "Numpad7", keyCode: 103 },
+  Numpad8: { key: "8", code: "Numpad8", keyCode: 104 },
+  Numpad9: { key: "9", code: "Numpad9", keyCode: 105 },
+  // --- Numpad Symbols (106-111) ---
+  NumpadMultiply: { key: "*", code: "NumpadMultiply", keyCode: 106 },
+  NumpadAdd: { key: "+", code: "NumpadAdd", keyCode: 107 },
+  NumpadSubtract: { key: "-", code: "NumpadSubtract", keyCode: 109 },
+  NumpadDecimal: { key: ".", code: "NumpadDecimal", keyCode: 110 },
+  NumpadDivide: { key: "/", code: "NumpadDivide", keyCode: 111 },
+  // --- Function Keys (112-123) ---
+  F1: { key: "F1", code: "F1", keyCode: 112 },
+  F2: { key: "F2", code: "F2", keyCode: 113 },
+  F3: { key: "F3", code: "F3", keyCode: 114 },
+  F4: { key: "F4", code: "F4", keyCode: 115 },
+  F5: { key: "F5", code: "F5", keyCode: 116 },
+  F6: { key: "F6", code: "F6", keyCode: 117 },
+  F7: { key: "F7", code: "F7", keyCode: 118 },
+  F8: { key: "F8", code: "F8", keyCode: 119 },
+  F9: { key: "F9", code: "F9", keyCode: 120 },
+  F10: { key: "F10", code: "F10", keyCode: 121 },
+  F11: { key: "F11", code: "F11", keyCode: 122 },
+  F12: { key: "F12", code: "F12", keyCode: 123 },
+  // --- State Locks (144-145) ---
+  NumLock: { key: "NumLock", code: "NumLock", keyCode: 144 },
+  ScrollLock: { key: "ScrollLock", code: "ScrollLock", keyCode: 145 },
+  // --- Punctuation (186-222) ---
+  Semicolon: { key: ";", code: "Semicolon", keyCode: 186 },
+  Equal: { key: "=", code: "Equal", keyCode: 187 },
+  Comma: { key: ",", code: "Comma", keyCode: 188 },
+  Minus: { key: "-", code: "Minus", keyCode: 189 },
+  Period: { key: ".", code: "Period", keyCode: 190 },
+  Slash: { key: "/", code: "Slash", keyCode: 191 },
+  Backquote: { key: "`", code: "Backquote", keyCode: 192 },
+  BracketLeft: { key: "[", code: "BracketLeft", keyCode: 219 },
+  Backslash: { key: "\\", code: "Backslash", keyCode: 220 },
+  BracketRight: { key: "]", code: "BracketRight", keyCode: 221 },
+  Quote: { key: "'", code: "Quote", keyCode: 222 }
+};
+var KEYS = STANDARD_KEYS;
+
+// src/types/index.ts
+var TYPES = {
+  // --- Zones ---
+  /** Area responsible for capturing touches and spawning dynamic widgets */
+  INPUT_ZONE: "input-zone",
+  /** Area responsible for receiving signals and simulating DOM events */
+  TARGET_ZONE: "target-zone",
+  // --- Widgets ---
+  /** Simulates a physical keyboard key press */
+  KEYBOARD_BUTTON: "keyboard-button",
+  /** Simulates a mouse button click/hold */
+  MOUSE_BUTTON: "mouse-button",
+  /** A joystick that outputs 360-degree or locked direction vectors */
+  ANALOG_STICK: "analog-stick",
+  /** Classic 4/8-way directional pad */
+  D_PAD: "d-pad",
+  /** Trackpad-style relative movement area */
+  TRACKPAD: "trackpad",
+  // --- Virtual Helpers ---
+  /** Logic for the on-screen visual cursor */
+  VIRTUAL_CURSOR: "virtual-cursor",
+  /** The top-level managed container */
+  ROOT_LAYER: "root-layer"
+};
+var ACTION_TYPES = {
+  KEYDOWN: "keydown",
+  KEYUP: "keyup",
+  POINTER: "pointer",
+  POINTERMOVE: "pointermove",
+  POINTERDOWN: "pointerdown",
+  POINTERUP: "pointerup",
+  MOUSE: "mouse",
+  MOUSEMOVE: "mousemove",
+  MOUSEDOWN: "mousedown",
+  MOUSEUP: "mouseup",
+  CLICK: "click"
+};
+var CONTEXT = {
+  /** The key used to propagate Parent IDs through the component tree */
+  PARENT_ID_KEY: "omnipad-parent-id-link"
+};
+
+// src/utils/math.ts
+var subVec = (v1, v2) => {
+  return { x: v1.x - v2.x, y: v1.y - v2.y };
+};
+var addVec = (v1, v2) => {
+  return { x: v1.x + v2.x, y: v1.y + v2.y };
+};
+var scaleVec = (v, s) => {
+  return { x: v.x * s, y: v.y * s };
+};
+var clamp = (val, min, max) => {
+  return Math.max(min, Math.min(max, val));
+};
+var lerp = (start, end, t) => {
+  return start + (end - start) * t;
+};
+var roundTo = (val, precision = 2) => {
+  const m = Math.pow(10, precision);
+  return Math.round(val * m) / m;
+};
+var getDistance = (p1, p2) => {
+  return Math.hypot(p2.x - p1.x, p2.y - p1.y);
+};
+var getAngle = (p1, p2) => {
+  return Math.atan2(p2.y - p1.y, p2.x - p1.x);
+};
+var radToDeg = (rad) => {
+  return rad * 180 / Math.PI;
+};
+var degToRad = (deg) => {
+  return deg * Math.PI / 180;
+};
+var clampVector = (origin, target, radius) => {
+  const dx = target.x - origin.x;
+  const dy = target.y - origin.y;
+  const dist = Math.hypot(dx, dy);
+  if (dist <= radius) return target;
+  const angle = Math.atan2(dy, dx);
+  return {
+    x: origin.x + Math.cos(angle) * radius,
+    y: origin.y + Math.sin(angle) * radius
+  };
+};
+var lockTo8Directions = (rad) => {
+  const step = Math.PI / 4;
+  return Math.round(rad / step) * step;
+};
+var lockTo4Directions = (rad) => {
+  const step = Math.PI / 2;
+  return Math.round(rad / step) * step;
+};
+var percentToPx = (percent, totalPx) => {
+  return roundTo(percent * totalPx / 100);
+};
+var pxToPercent = (px, totalPx) => {
+  if (totalPx === 0) return 0;
+  return roundTo(px * 100 / totalPx);
+};
+var normalizeVec = (v) => {
+  const magnitude = Math.hypot(v.x, v.y);
+  return magnitude === 0 ? { x: 0, y: 0 } : { x: v.x / magnitude, y: v.y / magnitude };
+};
+var radToVec = (rad) => ({
+  x: Math.cos(rad),
+  y: Math.sin(rad)
+});
+var remap = (val, inMin, inMax, outMin, outMax) => {
+  const t = (val - inMin) / (inMax - inMin);
+  return lerp(outMin, outMax, clamp(t, 0, 1));
+};
+var isVec2Equal = (v1, v2, epsilon = 1e-4) => {
+  return Math.abs(v1.x - v2.x) < epsilon && Math.abs(v1.y - v2.y) < epsilon;
+};
+var getDeadzoneScalar = (magnitude, threshold, max) => {
+  if (magnitude < threshold) return 0;
+  const scalar = (magnitude - threshold) / (max - threshold);
+  return clamp(scalar, 0, 1);
+};
+var applyRadialDeadzone = (v, radius, deadzonePercent) => {
+  const magnitude = Math.hypot(v.x, v.y);
+  const threshold = radius * deadzonePercent;
+  const scalar = getDeadzoneScalar(magnitude, threshold, radius);
+  if (scalar === 0) return { x: 0, y: 0 };
+  const direction = { x: v.x / magnitude, y: v.y / magnitude };
+  return scaleVec(direction, scalar);
+};
+var applyAxialDeadzone = (v, threshold, max) => {
+  return {
+    x: getDeadzoneScalar(Math.abs(v.x), threshold, max) * Math.sign(v.x),
+    y: getDeadzoneScalar(Math.abs(v.y), threshold, max) * Math.sign(v.y)
+  };
+};
+
+// src/utils/dom.ts
+var getDeepElement = (x, y) => {
+  let el = document.elementFromPoint(x, y);
+  while (el && el.shadowRoot) {
+    const nested = el.shadowRoot.elementFromPoint(x, y);
+    if (!nested || nested === el) break;
+    el = nested;
+  }
+  return el;
+};
+var getDeepActiveElement = () => {
+  let el = document.activeElement;
+  while (el && el.shadowRoot && el.shadowRoot.activeElement) {
+    el = el.shadowRoot.activeElement;
+  }
+  return el;
+};
+var focusElement = (el) => {
+  if (getDeepActiveElement() === el) return;
+  if (!el.hasAttribute("tabindex")) {
+    el.setAttribute("tabindex", "-1");
+  }
+  el.focus();
+};
+var dispatchKeyboardEvent = (type, payload) => {
+  const ev = new KeyboardEvent(type, {
+    ...payload,
+    which: payload.keyCode,
+    // Support for legacy Flash engines
+    bubbles: true,
+    cancelable: true,
+    view: window
+  });
+  window.dispatchEvent(ev);
+};
+var dispatchPointerEventAtPos = (type, x, y, opts = {}) => {
+  const target = getDeepElement(x, y);
+  if (!target) return;
+  const commonProps = {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    // Crucial for piercing Shadow DOM boundaries
+    clientX: x,
+    clientY: y,
+    view: window,
+    ...opts
+  };
+  if (type.startsWith("pointer")) {
+    target.dispatchEvent(
+      new PointerEvent(type, {
+        isPrimary: true,
+        pointerId: 1,
+        pointerType: "mouse",
+        // Emulate mouse behavior for Flash MouseOver/Down logic
+        ...commonProps
+      })
+    );
+    const mouseType = type.replace("pointer", "mouse");
+    target.dispatchEvent(new MouseEvent(mouseType, commonProps));
+  } else {
+    target.dispatchEvent(new MouseEvent(type, commonProps));
+  }
+};
+var getAnchorPosition = (rect, anchor) => {
+  const { left: l, top: t, width: w, height: h } = rect;
+  const map = {
+    "top-left": { x: l, y: t },
+    "top-center": { x: l + w / 2, y: t },
+    "top-right": { x: l + w, y: t },
+    "center-left": { x: l, y: t + h / 2 },
+    center: { x: l + w / 2, y: t + h / 2 },
+    "center-right": { x: l + w, y: t + h / 2 },
+    "bottom-left": { x: l, y: t + h },
+    "bottom-center": { x: l + w / 2, y: t + h },
+    "bottom-right": { x: l + w, y: t + h }
+  };
+  return map[anchor] || map["center"];
+};
+
+// src/utils/id.ts
+var generateUID = (prefix = "omnipad") => {
+  const stamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 6);
+  return `${prefix}-${stamp}-${random}`;
+};
+function isGlobalID(id) {
+  return id.startsWith("$");
+}
+
+// src/utils/layout.ts
+var resolveLayoutStyle = (layout) => {
+  if (!layout) return {};
+  const style = {};
+  style.position = "absolute";
+  const fields = ["left", "top", "right", "bottom", "width", "height"];
+  fields.forEach((field) => {
+    const val = layout[field];
+    if (val !== void 0) {
+      style[field] = typeof val === "number" ? `${val}px` : val;
+    }
+  });
+  if (layout.zIndex !== void 0) style.zIndex = layout.zIndex;
+  const anchorMap = {
+    "top-left": "translate(0, 0)",
+    "top-center": "translate(-50%, 0)",
+    "top-right": "translate(-100%, 0)",
+    "center-left": "translate(0, -50%)",
+    center: "translate(-50%, -50%)",
+    "center-right": "translate(-100%, -50%)",
+    "bottom-left": "translate(0, -100%)",
+    "bottom-center": "translate(-50%, -100%)",
+    "bottom-right": "translate(-100%, -100%)"
+  };
+  if (layout.anchor) {
+    style.transform = anchorMap[layout.anchor];
+  }
+  return style;
+};
+
+// src/utils/emitter.ts
+var SimpleEmitter = class {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Registers a callback function to be executed whenever data is emitted.
+   *
+   * @param fn - The callback function.
+   * @returns A function that, when called, unsubscribes the listener.
+   */
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  /**
+   * Broadcasts the provided data to all registered listeners.
+   * Each listener is executed within a try-catch block to ensure that
+   * an error in one subscriber doesn't prevent others from receiving the signal.
+   *
+   * @param data - The payload to be sent to all subscribers.
+   */
+  emit(data) {
+    this.listeners.forEach((fn) => {
+      try {
+        fn(data);
+      } catch (error) {
+        console.error("[OmniPad-Core] Emitter callback error:", error);
+      }
+    });
+  }
+  /**
+   * Removes all listeners and clears the subscription set.
+   * Essential for preventing memory leaks when an Entity is destroyed.
+   */
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/entities/BaseEntity.ts
+var BaseEntity = class {
+  constructor(uid, type, initialConfig, initialState) {
+    __publicField(this, "uid");
+    __publicField(this, "type");
+    __publicField(this, "config");
+    __publicField(this, "state");
+    __publicField(this, "rect", null);
+    // 内部状态发射器，负责处理状态订阅逻辑 / Internal emitter for state subscription logic
+    __publicField(this, "stateEmitter", new SimpleEmitter());
+    this.uid = uid;
+    this.type = type;
+    this.config = initialConfig;
+    this.state = initialState;
+  }
+  // --- IObservable Implementation ---
+  subscribe(cb) {
+    cb(this.state);
+    return this.stateEmitter.subscribe(cb);
+  }
+  // --- State Management ---
+  /**
+   * Updates the internal state and notifies all subscribers.
+   *
+   * @param partialState - Partial object containing updated state values.
+   */
+  setState(partialState) {
+    this.state = { ...this.state, ...partialState };
+    this.stateEmitter.emit(this.state);
+  }
+  // --- Lifecycle ---
+  destroy() {
+    this.reset();
+    this.stateEmitter.clear();
+    Registry.getInstance().unregister(this.uid);
+  }
+  updateRect(rect) {
+    this.rect = rect;
+  }
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    this.stateEmitter.emit(this.state);
+  }
+  getState() {
+    return this.state;
+  }
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/registry/index.ts
+var GLOBAL_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("omnipad.registry.instance");
+var Registry = class _Registry {
+  /**
+   * Private constructor to enforce singleton pattern.
+   */
+  constructor() {
+    /** Internal storage: Mapping of Entity UID to Entity Instance */
+    __publicField(this, "entities", /* @__PURE__ */ new Map());
+    if (import.meta.env?.DEV) {
+      console.log("[OmniPad-Core] Registry initialized.");
+    }
+  }
+  /**
+   * Retrieves the global instance of the Registry.
+   * Uses globalThis to ensure the instance is unique even if the library is loaded multiple times.
+   */
+  static getInstance() {
+    const globalObj = globalThis;
+    if (!globalObj[GLOBAL_REGISTRY_KEY]) {
+      globalObj[GLOBAL_REGISTRY_KEY] = new _Registry();
+    }
+    return globalObj[GLOBAL_REGISTRY_KEY];
+  }
+  register(entity) {
+    if (!entity.uid) {
+      console.warn("[OmniPad-Core] Registry: Attempted to register entity without UID.", entity);
+      return;
+    }
+    if (this.entities.has(entity.uid)) {
+    }
+    this.entities.set(entity.uid, entity);
+  }
+  unregister(uid) {
+    if (this.entities.has(uid)) {
+      this.entities.delete(uid);
+    }
+  }
+  getEntity(uid) {
+    return this.entities.get(uid);
+  }
+  getAllEntities() {
+    return Array.from(this.entities.values());
+  }
+  getEntitiesByRoot(rootUid) {
+    const all = this.getAllEntities();
+    if (!rootUid) return all;
+    const rootEntity = this.entities.get(rootUid);
+    if (!rootEntity) {
+      console.warn(`[OmniPad-Core] Registry: Root entity ${rootUid} not found.`);
+      return [];
+    }
+    const parentMap = /* @__PURE__ */ new Map();
+    all.forEach((entity) => {
+      if (entity instanceof BaseEntity) {
+        const config = entity.getConfig();
+        if (config.parentId) {
+          if (!parentMap.has(config.parentId)) {
+            parentMap.set(config.parentId, []);
+          }
+          parentMap.get(config.parentId).push(entity);
+        }
+      }
+    });
+    const result = [];
+    const queue = [rootUid];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (visited.has(currentId)) continue;
+      visited.add(currentId);
+      const entity = this.entities.get(currentId);
+      if (entity) {
+        result.push(entity);
+        const children = parentMap.get(currentId);
+        if (children) {
+          children.forEach((child) => queue.push(child.uid));
+        }
+      }
+    }
+    return result;
+  }
+  destroyByRoot(rootUid) {
+    const entities = this.getEntitiesByRoot(rootUid);
+    for (let i = entities.length - 1; i >= 0; i--) {
+      const entity = entities[i];
+      try {
+        entity.destroy();
+      } catch (error) {
+        console.error(`[OmniPad-Core] Error during destroyByRoot at ${entity.uid}:`, error);
+      }
+    }
+  }
+  clear() {
+    this.entities.clear();
+  }
+  resetAll() {
+    this.entities.forEach((entity) => {
+      if ("reset" in entity) {
+        entity.reset();
+      }
+    });
+  }
+  debugGetSnapshot() {
+    return new Map(this.entities);
+  }
+};
+
+// src/utils/profile.ts
+function parseProfileJson(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("[OmniPad-Validation] Profile must be a valid JSON object.");
+  }
+  if (!raw.rootId) {
+    throw new Error('[OmniPad-Validation] Missing "rootId" in profile.');
+  }
+  if (!Array.isArray(raw.items)) {
+    throw new Error('[OmniPad-Validation] "items" must be an array.');
+  }
+  const meta = {
+    name: raw.meta?.name || "Untitled Profile",
+    version: raw.meta?.version || "1.0.0",
+    author: raw.meta?.author || "Unknown"
+  };
+  const items = raw.items.map((item, index) => {
+    if (!item.id || !item.type) {
+      throw new Error(`[OmniPad-Validation] Item at index ${index} is missing "id" or "type".`);
+    }
+    return {
+      id: String(item.id),
+      type: String(item.type),
+      parentId: item.parentId ? String(item.parentId) : void 0,
+      // 确保 config 存在，业务参数平铺于此
+      config: item.config || {}
+    };
+  });
+  return {
+    meta,
+    rootId: String(raw.rootId),
+    items
+  };
+}
+function parseProfileTree(profile) {
+  const { items, rootId } = profile;
+  const cidToUidMap = /* @__PURE__ */ new Map();
+  const getUid = (cid, type = "node") => {
+    if (isGlobalID(cid)) return cid;
+    if (!cidToUidMap.has(cid)) {
+      cidToUidMap.set(cid, generateUID(type));
+    }
+    return cidToUidMap.get(cid);
+  };
+  items.forEach((item) => getUid(item.id, item.type));
+  const childrenMap = /* @__PURE__ */ new Map();
+  items.forEach((item) => {
+    if (item.parentId) {
+      if (!childrenMap.has(item.parentId)) {
+        childrenMap.set(item.parentId, []);
+      }
+      childrenMap.get(item.parentId).push(item);
+    }
+  });
+  const buildNode = (item) => {
+    const runtimeConfig = { ...item.config };
+    if (runtimeConfig?.targetStageId) {
+      runtimeConfig.targetStageId = getUid(runtimeConfig.targetStageId);
+    }
+    if (runtimeConfig?.dynamicWidgetId) {
+      runtimeConfig.dynamicWidgetId = getUid(runtimeConfig.dynamicWidgetId);
+    }
+    const rawChildren = childrenMap.get(item.id) || [];
+    const children = rawChildren.map((child) => buildNode(child));
+    return {
+      uid: getUid(item.id),
+      type: item.type,
+      config: runtimeConfig,
+      children
+    };
+  };
+  const rootItem = items.find((i) => i.id === rootId);
+  if (!rootItem) {
+    throw new Error(`[OmniPad-Core] Root item with ID "${rootId}" not found in profile.`);
+  }
+  return buildNode(rootItem);
+}
+function exportProfile(meta, rootUid) {
+  const registry = Registry.getInstance();
+  const allEntities = registry.getEntitiesByRoot(rootUid);
+  const eidToCidMap = /* @__PURE__ */ new Map();
+  let cidCounter = 0;
+  const getNewCid = (eid) => {
+    if (isGlobalID(eid)) return eid;
+    if (!eidToCidMap.has(eid)) {
+      eidToCidMap.set(eid, `node_${++cidCounter}`);
+    }
+    return eidToCidMap.get(eid);
+  };
+  const items = allEntities.map((entity) => {
+    const config = entity.getConfig();
+    const currentEid = entity.uid;
+    const processedConfig = { ...config };
+    if (processedConfig.targetStageId) {
+      processedConfig.targetStageId = getNewCid(processedConfig.targetStageId);
+    }
+    if (processedConfig.dynamicWidgetId) {
+      processedConfig.dynamicWidgetId = getNewCid(processedConfig.dynamicWidgetId);
+    }
+    const { id, type, parentId, ...cleanConfig } = processedConfig;
+    return {
+      id: getNewCid(currentEid),
+      type: entity.type,
+      // 如果存在父级，将其 UID 转换回本次导出的新 CID
+      parentId: config.parentId ? getNewCid(config.parentId) : void 0,
+      config: cleanConfig
+    };
+  });
+  return {
+    meta,
+    rootId: getNewCid(rootUid),
+    items
+  };
+}
+
+// src/imputManager/index.ts
+var INPUT_MANAGER_KEY = /* @__PURE__ */ Symbol.for("omnipad.input_manager.instance");
+var InputManager = class _InputManager {
+  constructor() {
+    /** Internal flag to prevent multiple event registrations */
+    __publicField(this, "_isListening", false);
+    /**
+     * Manually triggers a system-wide input reset via Registry.
+     */
+    __publicField(this, "handleGlobalReset", () => {
+      if (import.meta.env?.DEV) {
+        console.debug("[OmniPad-Core] Safety reset triggered by environment change.");
+      }
+      Registry.getInstance().resetAll();
+    });
+  }
+  /**
+   * Retrieves the global instance of the InputManager.
+   * Ensures uniqueness across multiple bundles or modules.
+   */
+  static getInstance() {
+    const globalObj = globalThis;
+    if (!globalObj[INPUT_MANAGER_KEY]) {
+      globalObj[INPUT_MANAGER_KEY] = new _InputManager();
+    }
+    return globalObj[INPUT_MANAGER_KEY];
+  }
+  /**
+   * Initializes global safety listeners.
+   * Should be called once at the root component lifecycle (e.g., VirtualLayer).
+   */
+  init() {
+    if (this._isListening) return;
+    window.addEventListener("resize", this.handleGlobalReset);
+    window.addEventListener("blur", this.handleGlobalReset);
+    this._isListening = true;
+    if (import.meta.env?.DEV) {
+      console.log("[OmniPad-Core] Global InputManager monitoring started.");
+    }
+  }
+  /**
+   * Toggle full-screen state of the page.
+   * @param element Target HTMLElement
+   */
+  async toggleFullscreen(element) {
+    const target = element || document.documentElement;
+    try {
+      if (!document.fullscreenElement) {
+        Registry.getInstance().resetAll();
+        await target.requestFullscreen();
+      } else {
+        Registry.getInstance().resetAll();
+        await document.exitFullscreen();
+      }
+    } catch (err) {
+      console.error(`[OmniPad-Core] Fullscreen toggle failed:`, err);
+    }
+  }
+  /**
+   * Full-screen status query provided to the UI layer.
+   */
+  isFullscreen() {
+    return !!document.fullscreenElement;
+  }
+  /**
+   * Detaches all global listeners.
+   */
+  destroy() {
+    window.removeEventListener("resize", this.handleGlobalReset);
+    window.removeEventListener("blur", this.handleGlobalReset);
+    this._isListening = false;
+  }
+};
+
+// src/entities/InputZoneCore.ts
+var INITIAL_STATE = {
+  isDynamicActive: false,
+  dynamicPointerId: null,
+  dynamicPosition: { x: 0, y: 0 }
+};
+var InputZoneCore = class extends BaseEntity {
+  constructor(uid, config) {
+    super(uid, TYPES.INPUT_ZONE, config, INITIAL_STATE);
+  }
+  onPointerDown(e) {
+    if (this.state.isDynamicActive) return;
+    if (e.target !== e.currentTarget) return;
+    if (e.cancelable) e.preventDefault();
+    const pos = this.calculateRelativePosition(e.clientX, e.clientY);
+    this.setState({
+      isDynamicActive: true,
+      dynamicPointerId: e.pointerId,
+      dynamicPosition: pos
+    });
+  }
+  onPointerMove(e) {
+    if (!this.state.isDynamicActive || e.pointerId !== this.state.dynamicPointerId) return;
+  }
+  onPointerUp(e) {
+    this.handleRelease(e);
+  }
+  onPointerCancel(e) {
+    this.handleRelease(e);
+  }
+  /**
+   * Internal helper to handle pointer release and cleanup.
+   */
+  handleRelease(e) {
+    if (e.pointerId === this.state.dynamicPointerId) {
+      try {
+        e.currentTarget.releasePointerCapture(e.pointerId);
+      } catch (err) {
+      }
+      this.setState({
+        isDynamicActive: false,
+        dynamicPointerId: null
+      });
+    }
+  }
+  // --- Helper Calculations ---
+  /**
+   * Converts viewport pixels to percentage coordinates relative to the zone.
+   */
+  calculateRelativePosition(clientX, clientY) {
+    if (!this.rect) return { x: 0, y: 0 };
+    return {
+      x: pxToPercent(clientX - this.rect.left, this.rect.width),
+      y: pxToPercent(clientY - this.rect.top, this.rect.height)
+    };
+  }
+  /**
+   * Whether the interceptor layer should be enabled.
+   */
+  get isInterceptorRequired() {
+    return !!(this.config.dynamicWidgetId || this.config.preventFocusLoss);
+  }
+  reset() {
+    this.setState({
+      isDynamicActive: false,
+      dynamicPointerId: null
+    });
+  }
+};
+
+// src/entities/KeyboardButtonCore.ts
+var INITIAL_STATE2 = {
+  isActive: false,
+  isPressed: false,
+  pointerId: null,
+  value: 0
+};
+var KeyboardButtonCore = class extends BaseEntity {
+  /**
+   * Creates an instance of KeyboardButtonCore.
+   *
+   * @param uid - The unique entity ID.
+   * @param config - The flat configuration object for the button.
+   */
+  constructor(uid, config) {
+    super(uid, TYPES.KEYBOARD_BUTTON, config, INITIAL_STATE2);
+  }
+  // --- IPointerHandler Implementation ---
+  onPointerDown(e) {
+    if (e.cancelable) e.preventDefault();
+    e.target.setPointerCapture(e.pointerId);
+    this.setState({
+      isActive: true,
+      isPressed: true,
+      pointerId: e.pointerId
+    });
+    this.sendInputSignal(ACTION_TYPES.KEYDOWN);
+  }
+  onPointerUp(e) {
+    if (e.cancelable) e.preventDefault();
+    this.handleRelease(e);
+  }
+  onPointerCancel(e) {
+    this.handleRelease(e);
+  }
+  onPointerMove(e) {
+    if (e.cancelable) e.preventDefault();
+  }
+  // --- Internal Logic ---
+  /**
+   * Common logic for releasing the button state.
+   *
+   * @param e - The pointer event that triggered the release.
+   */
+  handleRelease(e) {
+    if (this.state.pointerId !== e.pointerId) return;
+    if (e.target.hasPointerCapture(e.pointerId)) {
+      e.target.releasePointerCapture(e.pointerId);
+    }
+    this.setState(INITIAL_STATE2);
+    this.sendInputSignal(ACTION_TYPES.KEYUP);
+  }
+  /**
+   * Dispatches input signals to the registered target stage.
+   *
+   * @param type - The action type (keydown or keyup).
+   */
+  sendInputSignal(type) {
+    const targetId = this.config.targetStageId;
+    if (!targetId) return;
+    const target = Registry.getInstance().getEntity(targetId);
+    if (target && typeof target.handleSignal === "function") {
+      const signal = {
+        targetStageId: targetId,
+        type,
+        payload: {
+          key: this.config.mapping.key,
+          code: this.config.mapping.code,
+          keyCode: this.config.mapping.keyCode
+        }
+      };
+      target.handleSignal(signal);
+    } else {
+      if (import.meta.env?.DEV) {
+        console.warn(`[OmniPad-Core] Button ${this.uid} target not found: ${targetId}`);
+      }
+    }
+  }
+  // --- IResettable Implementation ---
+  reset() {
+    if (this.state.isPressed) {
+      this.sendInputSignal(ACTION_TYPES.KEYUP);
+    }
+    this.setState(INITIAL_STATE2);
+  }
+};
+
+// src/entities/RootLayerCore.ts
+var INITIAL_STATE3 = {
+  isHighlighted: false
+};
+var RootLayerCore = class extends BaseEntity {
+  constructor(uid, config) {
+    super(uid, TYPES.ROOT_LAYER, config, INITIAL_STATE3);
+  }
+  reset() {
+  }
+};
+
+// src/entities/TargetZoneCore.ts
+var INITIAL_STATE4 = {
+  position: { x: 50, y: 50 },
+  isVisible: false,
+  isPointerDown: false,
+  isFocusReturning: false
+};
+var TargetZoneCore = class extends BaseEntity {
+  constructor(uid, config) {
+    super(uid, TYPES.TARGET_ZONE, config, INITIAL_STATE4);
+    __publicField(this, "hideTimer", null);
+    __publicField(this, "focusFeedbackTimer", null);
+  }
+  // --- ISignalReceiver Implementation ---
+  handleSignal(signal) {
+    const { type, payload } = signal;
+    this.ensureFocus();
+    switch (type) {
+      case ACTION_TYPES.KEYDOWN:
+      case ACTION_TYPES.KEYUP:
+        dispatchKeyboardEvent(type, payload);
+        break;
+      case ACTION_TYPES.MOUSEMOVE:
+        if (payload.point) {
+          this.updateCursorPosition(payload.point);
+          if (this.config.cursorEnabled) this.showCursor();
+          this.executeMouseAction(ACTION_TYPES.POINTERMOVE, payload);
+        }
+        break;
+      case ACTION_TYPES.MOUSEDOWN:
+      case ACTION_TYPES.MOUSEUP:
+      case ACTION_TYPES.CLICK:
+        if (this.config.cursorEnabled) this.showCursor();
+        this.executeMouseAction(
+          type.startsWith(ACTION_TYPES.MOUSE) ? type.replace(ACTION_TYPES.MOUSE, ACTION_TYPES.POINTER) : type,
+          payload
+        );
+        break;
+    }
+  }
+  // --- Mouse & Pointer Simulation ---
+  /**
+   * Calculates pixel coordinates and dispatches simulated pointer events to the deepest element.
+   *
+   * @param pointerType - The specific pointer event type (e.g., pointermove, pointerdown).
+   * @param payload - Data containing point coordinates or button info.
+   */
+  executeMouseAction(pointerType, payload) {
+    if (!this.rect) return;
+    if (pointerType === ACTION_TYPES.POINTERDOWN) this.setState({ isPointerDown: true });
+    if (pointerType === ACTION_TYPES.POINTERUP) this.setState({ isPointerDown: false });
+    const target = payload.point || this.state.position;
+    const px = this.rect.left + percentToPx(target.x, this.rect.width);
+    const py = this.rect.top + percentToPx(target.y, this.rect.height);
+    dispatchPointerEventAtPos(pointerType, px, py, {
+      button: payload.button ?? 0,
+      buttons: this.state.isPointerDown ? 1 : 0
+    });
+  }
+  // --- Focus Management ---
+  /**
+   * Checks if the target element under the virtual cursor has focus, and reclaims it if lost.
+   */
+  ensureFocus() {
+    if (!this.rect) return;
+    const px = this.rect.left + percentToPx(this.state.position.x, this.rect.width);
+    const py = this.rect.top + percentToPx(this.state.position.y, this.rect.height);
+    const target = getDeepElement(px, py);
+    if (!target) return;
+    if (getDeepActiveElement() !== target) {
+      focusElement(target);
+      this.triggerFocusFeedback();
+    }
+  }
+  /**
+   * Activates a temporary visual feedback state to indicate a focus-reclaim event.
+   */
+  triggerFocusFeedback() {
+    this.setState({ isFocusReturning: true });
+    if (this.focusFeedbackTimer) clearTimeout(this.focusFeedbackTimer);
+    this.focusFeedbackTimer = setTimeout(() => this.setState({ isFocusReturning: false }), 500);
+  }
+  // --- Cursor State Helpers ---
+  /**
+   * Updates the internal virtual cursor coordinates.
+   */
+  updateCursorPosition(point) {
+    this.setState({ position: { ...point } });
+  }
+  /**
+   * Makes the virtual cursor visible and sets a timeout for auto-hiding.
+   */
+  showCursor() {
+    this.setState({ isVisible: true });
+    if (this.hideTimer) clearTimeout(this.hideTimer);
+    if (this.config.cursorAutoDelay && this.config.cursorAutoDelay > 0) {
+      this.hideTimer = setTimeout(
+        () => this.setState({ isVisible: false }),
+        this.config.cursorAutoDelay
+      );
+    }
+  }
+  // --- IResettable Implementation ---
+  reset() {
+    if (this.state.isPointerDown) {
+      this.executeMouseAction(ACTION_TYPES.POINTERUP, {});
+    }
+    if (this.hideTimer) clearTimeout(this.hideTimer);
+    if (this.focusFeedbackTimer) clearTimeout(this.focusFeedbackTimer);
+    this.setState({
+      isVisible: false,
+      isPointerDown: false,
+      isFocusReturning: false
+    });
+  }
+};
+
+// src/index.ts
+var OmniPad = {
+  Context: CONTEXT,
+  Keys: KEYS,
+  Types: TYPES
+};
+export {
+  ACTION_TYPES,
+  BaseEntity,
+  CONTEXT,
+  InputManager,
+  InputZoneCore,
+  KEYS,
+  KeyboardButtonCore,
+  OmniPad,
+  Registry,
+  RootLayerCore,
+  SimpleEmitter,
+  TYPES,
+  TargetZoneCore,
+  addVec,
+  applyAxialDeadzone,
+  applyRadialDeadzone,
+  clamp,
+  clampVector,
+  degToRad,
+  dispatchKeyboardEvent,
+  dispatchPointerEventAtPos,
+  exportProfile,
+  focusElement,
+  generateUID,
+  getAnchorPosition,
+  getAngle,
+  getDeadzoneScalar,
+  getDeepActiveElement,
+  getDeepElement,
+  getDistance,
+  isGlobalID,
+  isVec2Equal,
+  lerp,
+  lockTo4Directions,
+  lockTo8Directions,
+  normalizeVec,
+  parseProfileJson,
+  parseProfileTree,
+  percentToPx,
+  pxToPercent,
+  radToDeg,
+  radToVec,
+  remap,
+  resolveLayoutStyle,
+  roundTo,
+  scaleVec,
+  subVec
+};