dsh-plugin-vrmpet3d 0.0.0-stage → 0.1.0

package/lib/client.menu.js

@@ -0,0 +1,501 @@
+// dsh-plugin-vrmpet3d — generated by scripts/client-chunks.mjs; do not edit.
+//
+// This is lib/menu.js verbatim, plus the DSH client module
+// registration that makes it deliverable: only client.<name>.js files are served
+// to the browser, so the source cannot be loaded under its own name.
+//
+// Edit lib/menu.js, not this file. Then run:
+//   node scripts/client-chunks.mjs
+/**
+ * THE right-click menu, for both pets.
+ *
+ * It replaces the two settings panels. The app's pet and the floating window each grew a panel — same
+ * product, two control sets, so "where do I turn physics off" depended on which pet you were looking at —
+ * and the panels were then unified into one shared file, which was the wrong unification: a pet is not a
+ * settings dialog, and every setting in those panels already has a home in the two settings pages
+ * (模型参数 and 通用设置). What a pet owes a right-click is a SHORT list of things that are about the pet:
+ * put its view and its size back, open one of the two settings pages, hand it to the other surface, close
+ * it, and restart or quit the app it lives in.
+ *
+ * So this file is that list, in ONE place, because the two surfaces' menus differ by exactly one row:
+ * the in-app pet offers 切换回窗口外 and the window offers 切换回窗口内. Everything else — the eight entries,
+ * their order, their words in both languages, what "disabled" means — is defined here, and a surface only
+ * says which way its switch goes and what each id DOES.
+ *
+ * The module owns the MARKUP and the BEHAVIOUR (open, hover, keyboard, close on an outside press or
+ * Escape); the surface owns WHERE it goes. That split is deliberate and it is what the old panel got
+ * wrong: the panel owned its geometry (a fixed 240 px box anchored beside the pet), which the floating
+ * window then had to fight — the window IS the pet's box, so a menu placed outside it was clipped unless
+ * the page both measured it and grew the window. A menu with no geometry of its own can be placed in
+ * frame coordinates by the page that knows the frame.
+ */
+(function () {
+  'use strict';
+
+  /**
+   * The entries, in the order they are shown.
+   *
+   * `id` is what a surface switches on and what the tests assert, so the ORDER lives here and nowhere
+   * else: a menu whose entries drifted apart between the two pets would be the same debt as two panels.
+   *
+   * 重启 DeepSeek Harness and 退出 DeepSeek Harness were the last two entries until 2026-10-12, when the
+   * operator had them removed ("内置宠物和外置宠物都去掉关闭和重启dsh的功能和项目"). Nothing else in the product
+   * called `/vrmpet3d/harness`, so the route went with them.
+   *
+   * `surface` is the one entry a surface may NOT SHOW (see the `showSurface` option): the floating window's own
+   * 关闭独立宠物 does exactly what its 切换回窗口内 did, and the operator removed the duplicate on 2026-10-12
+   * (「外置桌宠的'切换回窗口内'选项现在和'关闭独立宠物'功能重复了，移除'切换回窗口内'选项」). The entry stays in this
+   * list because the APP's pet still needs it — 切换回窗口外 is the only way out of DSH — so the order and the id
+   * are still one definition; only the row's PRESENCE differs per surface.
+   */
+  var ITEMS = [
+    'resetView',
+    'resetSize',
+    'globalSettings',
+    /**
+     * 切换模型 — the model picker's own page (`/vrmpet3d/picker`), added 2026-10-13.
+     *
+     * The operator asked for it in BOTH pets' menus with the content of the guide's 偏好模型 step
+     * (「在内置和外置桌宠右键菜单增加一个'切换模型'面板，面板中和初次安装向导模型页完全一样」). It sits beside
+     * 当前模型参数设置 rather than inside it: that page configures the model ON SCREEN, while this one decides
+     * WHICH model that is — and picking one there changes what every other page is about.
+     */
+    'switchModel',
+    /**
+     * 跳支舞 — a random clip out of the dance folder, played once (operator, 2026-10-14).
+     *
+     * Beside the model rows rather than inside a page: it is something to DO to the pet in front of you, and it is the one row
+     * whose effect ends by itself (the clip finishes, or the user double-clicks the pet, or work starts).
+     */
+    'dance',
+    /**
+     * 重载模型 — refresh the model on screen without touching anything else (operator, 2026-10-14: 「给内置和外置宠物的右键菜单
+     * 新增“重载模型”的选项，用来刷新模型」).
+     *
+     * It sits beside 切换模型 rather than inside a settings page because it is a gesture about the pet in front of you: a
+     * model whose file was re-exported on disk, or a scene that has drifted (a bad clip, a chain left stretched), is fixed
+     * by re-reading it. The surfaces do the work — this file only names the row.
+     */
+    'reloadModel',
+    'modelSettings',
+    'surface',
+    'gravity',
+    'closePet',
+  ];
+
+  /**
+   * The rows that are SWITCHES rather than actions, and therefore carry a check mark and `aria-checked`.
+   *
+   * 重力 is the only one: the entry both reports the state and flips it, and a switch that cannot show which
+   * way it is thrown is the bug this list exists to prevent.
+   */
+  var TOGGLES = ['gravity'];
+
+  /**
+   * The words, in both languages.
+   *
+   * Here rather than in each surface's own `STRINGS`: the menu is the same object on both surfaces, and a
+   * label that had to be kept in two files is exactly how the two panels drifted. A surface picks the
+   * language and the rows that differ (`surfaceWindow`/`surfaceApp` and `closePetWindow`/`closePetApp`).
+   *
+   * `surfaceApp` (切换回窗口内 / Move back inside the app) currently has NO caller: the window is the only
+   * surface that would hand the pet back, and its switch row is gone. It is kept deliberately — the row is
+   * defined per DIRECTION, and the next reader who asks "can this hand the pet back at all?" gets the answer
+   * from the table rather than from the absence of one. The alternative (deleting the direction) would make
+   * `toSurface` a constant with one possible value, which reads as a bug rather than as a decision.
+   */
+  var LABELS = {
+    en: {
+      resetView: 'Reset view',
+      resetSize: 'Reset size',
+      globalSettings: 'General settings',
+      switchModel: 'Switch model',
+    reloadModel: 'Reload model',
+    dance: 'Dance for me',
+      modelSettings: "This model's parameters",
+      surfaceWindow: 'Move to the floating window',
+      surfaceApp: 'Move back inside the app',
+      surfaceOff: 'disabled while debug mode is on',
+      gravity: 'Gravity',
+      /**
+       * Why the 重力 row is off, as its tooltip — the same courtesy the disabled 切换 row gets. A switch with
+       * no explanation reads as a pet that has stopped working.
+       */
+      gravityOff: 'Off: no throwing and no falling — put the pet down anywhere',
+      /**
+       * 关闭宠物, in the two meanings it has on the two surfaces (operator, 2026-10-12).
+       *
+       * The app's pet is HIDDEN — it stays gone until 显示宠物 is pressed — while the floating window's pet is
+       * handed BACK inside the app, which is the only thing "closing" that window can mean: the window is the
+       * pet's box, so a window with no pet in it is nothing.
+       */
+      closePetApp: 'Hide pet',
+      closePetWindow: 'Close the floating pet',
+      title: 'Pet menu',
+    },
+    zh: {
+      resetView: '重置视角',
+      resetSize: '重置大小',
+      globalSettings: '通用设置',
+      switchModel: '切换模型',
+    reloadModel: '重载模型',
+    dance: '跳支舞',
+      modelSettings: '当前模型参数设置',
+      surfaceWindow: '切换回窗口外',
+      surfaceApp: '切换回窗口内',
+      surfaceOff: '调试模式下不生效',
+      gravity: '重力',
+      gravityOff: '已关闭：不抛掷、不下坠，可以随意摆放',
+      closePetApp: '隐藏宠物',
+      closePetWindow: '关闭独立宠物',
+      title: '桌宠菜单',
+    },
+  };
+
+  /** The words for one language, defaulting to Chinese — the operator's own language. */
+  function strings(language) {
+    return LABELS[language === 'en' ? 'en' : 'zh'];
+  }
+
+  /**
+   * The menu's own styles.
+   *
+   * Self-contained and namespaced under `.vrmpet3d-menu`, like the panel's were, so a surface can use it
+   * without adopting the other surface's stylesheet. `position:fixed` is not decoration: both surfaces
+   * place the menu in VIEWPORT coordinates — the app overlay in DSH's frame, the window in its own box —
+   * and an absolutely positioned menu would drift with a scrolled document.
+   */
+  var STYLE = [
+    '.vrmpet3d-menu{position:fixed;z-index:40;box-sizing:border-box;min-width:168px;max-width:320px;padding:5px;',
+    '  border-radius:9px;font:13px/1.5 "Segoe UI",system-ui,-apple-system,"Microsoft YaHei",sans-serif;',
+    '  background:light-dark(#f9fafb,#353638);color:light-dark(#111827,#e5e7eb);',
+    '  border:1px solid light-dark(#0000001a,#ffffff1f);box-shadow:0 10px 30px #0003;',
+    '  pointer-events:auto;user-select:none;-webkit-user-select:none;cursor:default}',
+    '.vrmpet3d-menu[hidden]{display:none}',
+    '.vrmpet3d-menu-item{display:block;width:100%;box-sizing:border-box;text-align:left;font:inherit;cursor:pointer;',
+    '  color:inherit;background:none;border:0;border-radius:6px;padding:5px 9px;white-space:nowrap}',
+    '.vrmpet3d-menu-item:hover:not([disabled]),.vrmpet3d-menu-item:focus-visible:not([disabled]){',
+    '  background:light-dark(#00000014,#ffffff1f);outline:none}',
+    '.vrmpet3d-menu-item[disabled]{opacity:.45;cursor:default}',
+    /**
+     * A SWITCH row's mark, as a `::before` pseudo-element rather than a child node.
+     *
+     * The label is the button's `textContent` — the probe reads it, and so does a screen reader — so a mark
+     * added as a child would become part of the entry's own name. The slot is reserved in BOTH states so the
+     * labels stay aligned whether the switch is on or off.
+     */
+    '.vrmpet3d-menu-item[data-toggle]::before{content:"";display:inline-block;width:1.15em}',
+    '.vrmpet3d-menu-item[data-toggle][data-checked="true"]::before{content:"\\2713"}',
+  ].join('\n');
+
+  /**
+   * Put the menu's stylesheet into a document, once.
+   *
+   * The module has no document of its own (a surface mounts pages the suite creates), so whoever owns the
+   * document asks for it. Idempotent by id, because both pets can be on one page.
+   */
+  function injectStyle(doc, id) {
+    if (!doc || !doc.head || typeof doc.createElement !== 'function') return null;
+    var key = id || 'vrmpet3d-menu-style';
+    if (typeof doc.getElementById === 'function' && doc.getElementById(key)) return doc.getElementById(key);
+    var style = doc.createElement('style');
+    style.id = key;
+    style.textContent = STYLE;
+    doc.head.appendChild(style);
+    return style;
+  }
+
+  function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+  }
+
+  /**
+   * Build the menu.
+   *
+   * @param {object} options
+   *   document        the document to build in and to listen on
+   *   container       where to append it; defaults to `document.body`
+   *   language        'zh' or 'en' (anything else is Chinese)
+   *   toSurface       'window' or 'app' — which way the 切换 row goes and which words 关闭宠物 uses; the two
+   *                   rows that differ between the two pets
+   *   showSurface     false omits the 切换 row entirely. Only the floating window passes it, because its own
+   *                   关闭独立宠物 IS that action (operator, 2026-10-12: they were duplicates). The app's pet
+   *                   has nowhere else to go, so its row stays.
+   *   surfaceAllowed  false disables that row (the DEBUG mode: both pets are already on screen, so
+   *                   "switch to the other surface" has no meaning — the operator's 非debug模式生效)
+   *   onChoose        called with the item's id, after the menu closes
+   *   onOpen/onClose  notified around the open state, so a surface can re-measure or report its rect
+   * @returns {{element: Element, open: Function, place: Function, close: Function, isOpen: Function,
+   *            size: Function, setSurface: Function, setSurfaceAllowed: Function, setChecked: Function,
+   *            items: Function, destroy: Function, strings: object}}
+   */
+  function createMenu(options) {
+    var doc = options.document;
+    var text = strings(options.language);
+    var container = options.container || doc.body;
+    var onChoose = typeof options.onChoose === 'function' ? options.onChoose : function () {};
+    var toSurface = options.toSurface === 'app' ? 'app' : 'window';
+    var surfaceAllowed = options.surfaceAllowed !== false;
+    /** Whether this surface offers the 切换 row at all. See the `showSurface` option. */
+    var showSurface = options.showSurface !== false;
+
+    var element = doc.createElement('div');
+    element.className = 'vrmpet3d-menu';
+    element.setAttribute('role', 'menu');
+    element.setAttribute('aria-label', text.title);
+    element.hidden = true;
+    container.appendChild(element);
+
+    /** The item nodes currently built, in order. */
+    var nodes = [];
+    /** The label each node carries, so a surface can be asked what it is showing. */
+    var built = [];
+    /**
+     * Which way the SWITCH rows are thrown, per id, as the surface last said.
+     *
+     * A surface sets this at OPEN time (`setChecked`), like `setSurfaceAllowed`: the menu is rebuilt on every
+     * open, and the state it must show is the surface's own preference rather than anything this module could
+     * remember. `false` is the default, so a switch a surface never mentions renders as off rather than as an
+     * unmarked button nobody can read.
+     */
+    var checkedState = {};
+
+    /** The label for one id, from the state this menu was built with. */
+    function labelFor(id) {
+      if (id === 'surface') return toSurface === 'app' ? text.surfaceApp : text.surfaceWindow;
+      if (id === 'closePet') return toSurface === 'app' ? text.closePetWindow : text.closePetApp;
+      return text[id] || id;
+    }
+
+    /** Rebuild the items. Cheap, and it is what keeps the disabled and checked rows honest on every open. */
+    function render() {
+      while (element.firstChild) element.removeChild(element.firstChild);
+      nodes = [];
+      built = [];
+      ITEMS.forEach(function (id) {
+        // The 切换 row is the one entry a surface may omit — the window's 关闭独立宠物 already does its job.
+        if (id === 'surface' && !showSurface) return;
+        var disabled = id === 'surface' && surfaceAllowed !== true;
+        var toggle = TOGGLES.indexOf(id) !== -1;
+        var checked = toggle && checkedState[id] === true;
+        var item = doc.createElement('button');
+        item.type = 'button';
+        item.className = 'vrmpet3d-menu-item';
+        // A switch says so in its ROLE: `menuitemcheckbox` is what makes a screen reader announce the state
+        // rather than read `aria-checked` on a row that claims to be an ordinary action.
+        item.setAttribute('role', toggle ? 'menuitemcheckbox' : 'menuitem');
+        item.setAttribute('data-item', id);
+        var label = labelFor(id);
+        item.textContent = label;
+        if (toggle) {
+          item.setAttribute('data-toggle', 'true');
+          item.setAttribute('data-checked', checked ? 'true' : 'false');
+          item.setAttribute('aria-checked', checked ? 'true' : 'false');
+        }
+        if (disabled) {
+          item.disabled = true;
+          item.setAttribute('aria-disabled', 'true');
+          /**
+           * Why the row is greyed, in words: a disabled control with no explanation is a bug report
+           * waiting to happen ("the switch does nothing"). The reason is the operator's own qualifier —
+           * 非debug模式生效 — spelled out for the mode that turns it off.
+           */
+          item.title = text.surfaceOff;
+        } else {
+          if (toggle && !checked) item.title = text.gravityOff;
+          item.addEventListener('click', function (event) {
+            if (event && event.preventDefault) event.preventDefault();
+            choose(id);
+          });
+        }
+        element.appendChild(item);
+        nodes.push(item);
+        built.push({ id: id, label: label, disabled: disabled, checked: checked });
+      });
+    }
+
+    /**
+     * The document-level guards, live only while the menu is open.
+     *
+     * An outside press closes it in the CAPTURE phase, so a control underneath does not also act on the
+     * click that dismissed the menu — the same rule a native context menu follows.
+     *
+     * The press that OPENED it must not close it, and that is why the guards are bound a TASK LATE (see
+     * `scheduleBind`) rather than during the opening dispatch. This was a timestamp comparison until
+     * 2026-10-12 — `event.timeStamp <= openedAt`, with `openedAt` from `performance.now()` — and it was
+     * fragile in exactly the way a clock comparison is: `timeStamp` is COARSENED (Chrome rounds it to
+     * 100 µs), so two events in the same instant can carry an equal stamp and a genuine outside press
+     * could be mistaken for the opening one, while a probe that dispatched a press a few microseconds
+     * after `open()` could be read as the opening press and pass or fail on rounding alone. Deferring the
+     * bind asks the question structurally instead: while the opening press is still dispatching, the
+     * listener does not exist yet.
+     */
+    function onDocPointerDown(event) {
+      if (event && event.target && element.contains(event.target)) return;
+      close();
+    }
+    function onKeyDown(event) {
+      if (!event) return;
+      if (event.key === 'Escape') {
+        if (event.preventDefault) event.preventDefault();
+        close();
+        return;
+      }
+      if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+        if (event.preventDefault) event.preventDefault();
+        focusStep(event.key === 'ArrowDown' ? 1 : -1);
+      }
+    }
+    function onBlur() { close(); }
+
+    /** Move the focus to the next enabled item, wrapping. */
+    function focusStep(direction) {
+      var enabled = [];
+      for (var i = 0; i < nodes.length; i += 1) if (!nodes[i].disabled) enabled.push(nodes[i]);
+      if (!enabled.length) return;
+      var at = enabled.indexOf(doc.activeElement);
+      var next = at < 0
+        ? (direction > 0 ? 0 : enabled.length - 1)
+        : (at + direction + enabled.length) % enabled.length;
+      try { enabled[next].focus(); } catch (error) { /* a non-focusable window: pointer only */ }
+    }
+
+    var listenersBound = false;
+    function bind(active) {
+      if (!doc || typeof doc.addEventListener !== 'function') return;
+      if (active === listenersBound) return;
+      listenersBound = active;
+      var method = active ? 'addEventListener' : 'removeEventListener';
+      doc[method]('pointerdown', onDocPointerDown, true);
+      doc[method]('mousedown', onDocPointerDown, true);
+      doc[method]('keydown', onKeyDown);
+      var view = doc.defaultView;
+      if (view && typeof view[method] === 'function') view[method]('blur', onBlur);
+    }
+
+    /**
+     * Bind the guards on the NEXT task, and never during the dispatch that opened the menu.
+     *
+     * This is the whole of "the opening press cannot close it". Tasks are ordered, so the timer queued
+     * here runs before any later input event: the user's next press still closes the menu, while a press
+     * from the very interaction that opened it is already gone by the time the listener exists. A window
+     * with no timers (a bare test document) binds immediately — there is no dispatch in flight to protect.
+     */
+    var bindTimer = 0;
+    function scheduleBind() {
+      cancelBind();
+      var view = doc && doc.defaultView;
+      if (!view || typeof view.setTimeout !== 'function') { bind(true); return; }
+      bindTimer = view.setTimeout(function () {
+        bindTimer = 0;
+        bind(true);
+      }, 0);
+    }
+    function cancelBind() {
+      if (!bindTimer) return;
+      var view = doc && doc.defaultView;
+      if (view && typeof view.clearTimeout === 'function') view.clearTimeout(bindTimer);
+      bindTimer = 0;
+    }
+
+    /**
+     * Show the menu, at the origin the surface placed it at last (or 0,0).
+     *
+     * Deliberately NOT positioned here: the surface measures it and then places it, because only the
+     * surface knows what coordinate space the menu has to fit in. The element is measured hidden-visible
+     * (`visibility`, not `display`), so the first paint is already at the final position instead of
+     * flashing once at the top-left corner.
+     */
+    function open() {
+      render();
+      element.style.visibility = 'hidden';
+      element.hidden = false;
+      scheduleBind();
+      if (typeof options.onOpen === 'function') options.onOpen();
+      return size();
+    }
+
+    /** The menu's measured size, for a surface that has to fit it into a frame. */
+    function size() {
+      return {
+        width: element.offsetWidth || 0,
+        height: element.offsetHeight || 0,
+      };
+    }
+
+    /** Put the menu's top-left at a VIEWPORT coordinate, and make it visible. */
+    function place(left, top) {
+      element.style.left = Math.round(left) + 'px';
+      element.style.top = Math.round(top) + 'px';
+      element.style.visibility = '';
+    }
+
+    function close() {
+      // Even when the menu is already away: a pending guard-bind has to be called off, or a closed menu
+      // would put document listeners up on the next task that nothing owns any more.
+      cancelBind();
+      if (element.hidden) return;
+      element.hidden = true;
+      bind(false);
+      if (typeof options.onClose === 'function') options.onClose();
+    }
+
+    function choose(id) {
+      close();
+      onChoose(id);
+    }
+
+    return {
+      element: element,
+      open: open,
+      place: place,
+      close: close,
+      isOpen: function () { return element.hidden !== true; },
+      size: size,
+      /** Point the 切换 row the other way; the next open rebuilds the labels. */
+      setSurface: function (next) { toSurface = next === 'app' ? 'app' : 'window'; },
+      /** Whether that row may be used at all (false in debug mode). */
+      setSurfaceAllowed: function (allowed) { surfaceAllowed = allowed !== false; },
+      /**
+       * Which way a SWITCH row is thrown, read at OPEN time by the surface that owns the preference.
+       *
+       * Per id rather than one flag, because the surfaces do NOT share these: 重力 is independent on the two
+       * pets (operator, 2026-10-12), and one boolean here would be the very coupling that request rules out.
+       */
+      setChecked: function (id, value) { checkedState[id] = value === true; },
+      /** What the menu is showing, for a probe: `[{id, label, disabled, checked}]`. */
+      items: function () { return built.slice(); },
+      destroy: function () {
+        cancelBind();
+        bind(false);
+        if (element.parentNode) element.parentNode.removeChild(element);
+      },
+      strings: text,
+    };
+  }
+
+  var api = {
+    createMenu: createMenu,
+    injectStyle: injectStyle,
+    MENU_STYLE: STYLE,
+    MENU_ITEMS: ITEMS,
+    MENU_LABELS: LABELS,
+    strings: strings,
+    clamp: clamp,
+  };
+  if (typeof globalThis !== 'undefined') globalThis.__VRMPET3D_MENU__ = api;
+})();
+
+// --- DSH client module registration (appended by scripts/client-chunks.mjs) ---
+// The id is the full module-table key. The loader reads it unconditionally,
+// so it cannot be omitted, and adding a `chunk` field as well would append the
+// file name a second time.
+if (typeof window !== 'undefined' && window.__ModuleLoader__ &&
+    typeof window.__ModuleLoader__.load === 'function') {
+  window.__ModuleLoader__.load({
+    id: 'dsh-plugin-vrmpet3d/client.menu.js',
+    factory: function () {
+      return globalThis.__VRMPET3D_MENU__;
+    }
+  });
+}