@combos-fun/plugin-development-tool 0.0.19 → 0.0.21

package/combos-plugin.json

@@ -16,6 +16,7 @@
     "CombosDevelopmentToolTarget",
     "COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED",
     "COMBOS_DEVELOPMENT_TOOL_REFRESH",
-    "COMBOS_DEVELOPMENT_TOOL_SET"
+    "COMBOS_DEVELOPMENT_TOOL_SET",
+    "COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS"
   ]
 }

package/dist/plugin-development-tool.cjs.js

@@ -8,7 +8,9 @@ var pluginRendererEvent = require('@combos-fun/plugin-renderer-event');
 
 /** Toggle development-tool selection / parent postMessage. Payload: `{ enabled: boolean }`. */
 const COMBOS_DEVELOPMENT_TOOL_SET = 'combos-development-tool:set';
-/** Re-scan the scene tree (only when `CombosDevelopmentToolSystem` uses `scope: 'scene'`). */
+/** iframe → parent: `setEnabled` finished (pick attach after enable, or restore after disable). Payload: `{ enabled: boolean }`. */
+const COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS = 'combos-development-tool:set-success';
+/** Re-scan the scene tree while the development tool is enabled. */
 const COMBOS_DEVELOPMENT_TOOL_REFRESH = 'combos-development-tool:refresh';
 /** Emitted to `window.parent` when an object is selected while the tool is on. */
 const COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED = 'combos-development-tool:gameobject-selected';
@@ -18,8 +20,9 @@ const COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY = 'combos-development-tool:apply-pr
 const COMBOS_DEVELOPMENT_TOOL_READY = 'combos-development-tool:ready';
 
 /**
- * Optional marker when using `CombosDevelopmentToolSystem` with `scope: 'tagged'`, or to attach
- * extra `payload` on specific objects while using `scope: 'scene'` (serialization reads it if present).
+ * Marks a `GameObject` as selectable in editor pick mode. While the development tool is enabled,
+ * only nodes carrying this component receive a pick `Event`; all other game `Event` components
+ * are removed and cached until disable.
  */
 class CombosDevelopmentToolTarget extends engine.Component {
     constructor() {
@@ -272,31 +275,33 @@ function applyPropertyWithHooks(go, componentName, path, value) {
 
 const OUTLINE_GO_NAME = '__combosDevelopmentToolOutline';
 /**
- * **Defaults:** `scope: 'scene'`, **off** at start (no tap hijack until enabled).
- * While enabled, game `Event` `tap` listeners are removed and restored on disable.
+ * **Off** at start. While enabled:
+ * - strips `Event` from every scene `GameObject` (cached for restore on disable);
+ * - attaches pick `Event` + outline only on nodes with {@link CombosDevelopmentToolTarget}.
+ *
  * Turn on/off via:
  * - `window.dispatchEvent(new CustomEvent(COMBOS_DEVELOPMENT_TOOL_SET, { detail: { enabled: true } }))`
  * - `window.postMessage({ type: COMBOS_DEVELOPMENT_TOOL_SET, enabled: true }, targetOrigin)` (e.g. from parent iframe)
  * - `game.emit(COMBOS_DEVELOPMENT_TOOL_SET, { enabled: true })` or `getSystem(CombosDevelopmentToolSystem).setEnabled(true)`
  *
- * With `scope: 'scene'`, while enabled: `game.emit(COMBOS_DEVELOPMENT_TOOL_REFRESH)`, `window` event `combos-development-tool:refresh`, or `postMessage({ type: 'combos-development-tool:refresh' })` to re-bind after adding/removing objects.
+ * While enabled: `game.emit(COMBOS_DEVELOPMENT_TOOL_REFRESH)`, `window` event `combos-development-tool:refresh`,
+ * or `postMessage({ type: 'combos-development-tool:refresh' })` to re-bind after adding/removing objects.
  */
 let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends engine.System {
     constructor() {
         super(...arguments);
         this.postMessageOrigin = '*';
-        this.scope = 'scene';
         this.enabled = false;
         this.outlineGo = null;
         this.selected = null;
         this.tapHandlers = new Map();
         this.tapOwners = new Map();
-        /** Game `tap` listeners removed while enabled; restored on disable. */
-        this.savedTapListeners = new Map();
-        /** We added `Event` for hit-testing; remove on teardown when disabling / releaseTap. */
-        this.injectedEvents = new Set();
-        this.needsSceneRescan = false;
-        this.needsTaggedRescan = false;
+        /** Game `Event` components removed while enabled; restored on disable. */
+        this.cachedGameEvents = new Map();
+        /** Pick `Event` injected for {@link CombosDevelopmentToolTarget} nodes. */
+        this.pickEvents = new Set();
+        this.needsRescan = false;
+        this.lastOutlineBounds = null;
         this.onWindowSet = (e) => {
             const d = e.detail;
             if (d && typeof d.enabled === 'boolean') {
@@ -332,7 +337,6 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
     static { this.systemName = 'CombosDevelopmentToolSystem'; }
     init(params) {
         this.postMessageOrigin = params?.postMessageOrigin ?? '*';
-        this.scope = params?.scope ?? 'scene';
         if (typeof window !== 'undefined') {
             window.addEventListener(COMBOS_DEVELOPMENT_TOOL_SET, this.onWindowSet);
             window.addEventListener(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onWindowRefresh);
@@ -340,11 +344,8 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
         }
         this.game.on(COMBOS_DEVELOPMENT_TOOL_SET, this.onGameSet);
         this.game.on(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onGameRefresh);
-        if (this.enabled && this.scope === 'scene') {
-            this.needsSceneRescan = true;
-        }
-        else if (this.enabled && this.scope === 'tagged') {
-            this.needsTaggedRescan = true;
+        if (this.enabled) {
+            this.needsRescan = true;
         }
     }
     onDestroy() {
@@ -355,7 +356,8 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
         }
         this.game.off(COMBOS_DEVELOPMENT_TOOL_SET, this.onGameSet);
         this.game.off(COMBOS_DEVELOPMENT_TOOL_REFRESH, this.onGameRefresh);
-        this.detachAllTaps();
+        this.detachAllPicks();
+        this.restoreCachedGameEvents();
         this.clearSelection();
     }
     /** Programmatic toggle (same effect as events). */
@@ -365,99 +367,72 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
         this.enabled = on;
         if (!on) {
             this.clearSelection();
-            this.detachAllTaps();
-        }
-        else if (this.scope === 'scene') {
-            this.needsSceneRescan = true;
+            this.detachAllPicks();
+            this.restoreCachedGameEvents();
+            this.postSetSuccess(false);
         }
         else {
-            this.needsTaggedRescan = true;
+            this.needsRescan = true;
         }
     }
     get isEnabled() {
         return this.enabled;
     }
     update(e) {
-        if (this.enabled && this.needsSceneRescan && this.scope === 'scene') {
-            this.needsSceneRescan = false;
-            this.attachSceneTree();
-        }
-        if (this.enabled && this.needsTaggedRescan && this.scope === 'tagged') {
-            this.needsTaggedRescan = false;
-            this.attachTaggedObjects();
+        if (this.enabled && this.needsRescan) {
+            this.needsRescan = false;
+            this.attachEditMode();
+            this.postSetSuccess(true);
         }
         for (const go of [...this.tapOwners.values()]) {
             if (go.destroyed) {
-                this.releaseTap(go);
+                this.releasePick(go);
             }
         }
         if (!this.enabled || !this.selected || !this.outlineGo)
             return;
-        const gfxComp = this.outlineGo.getComponent(pluginRendererGraphics.Graphics);
-        if (!gfxComp?.graphics)
-            return;
-        const bounds = this.resolvePickBounds(this.selected);
-        const g = gfxComp.graphics;
-        g.clear();
-        const t = typeof performance !== 'undefined' ? performance.now() : e.time;
-        const pulse = 0.35 + 0.65 * (0.5 + 0.5 * Math.sin(t * 0.012));
-        g.rect(bounds.x, bounds.y, bounds.width, bounds.height);
-        g.stroke({ width: 4, color: 0x55ffaa, alpha: pulse });
+        this.updateSelectionOutline();
     }
     componentChanged(changed) {
-        if (this.scope === 'scene')
+        if (!this.enabled)
             return;
         const { type, gameObject, componentName } = changed;
         if (!gameObject || componentName !== 'CombosDevelopmentToolTarget')
             return;
         if (type === engine.OBSERVER_TYPE.ADD) {
-            this.ensureTap(gameObject);
+            this.stripGameEvent(gameObject);
+            this.ensurePick(gameObject);
         }
         else if (type === engine.OBSERVER_TYPE.REMOVE) {
-            this.releaseTap(gameObject);
+            this.releasePick(gameObject);
             if (this.selected === gameObject) {
                 this.clearSelection();
             }
         }
     }
-    /** Re-bind scene taps when `scope === 'scene'` (e.g. after dynamic spawn). */
+    /** Re-bind pick targets after dynamic scene changes while enabled. */
     requestSceneRescan() {
         if (!this.enabled)
             return;
-        if (this.scope === 'scene') {
-            this.needsSceneRescan = true;
-        }
-        else {
-            this.needsTaggedRescan = true;
-        }
+        this.needsRescan = true;
     }
-    attachTaggedObjects() {
+    attachEditMode() {
+        this.detachAllPicks();
         const list = [];
         for (const tr of this.game.scene.transform.children) {
             this.collectGameObjects(tr.gameObject, list);
         }
         for (const go of list) {
-            if (go.name === OUTLINE_GO_NAME)
-                continue;
-            if (go === this.outlineGo)
+            if (this.isIgnoredPickGo(go))
                 continue;
-            if (!go.getComponent(CombosDevelopmentToolTarget))
-                continue;
-            this.ensureTap(go);
-        }
-    }
-    attachSceneTree() {
-        this.detachAllTaps(false);
-        const list = [];
-        for (const tr of this.game.scene.transform.children) {
-            this.collectGameObjects(tr.gameObject, list);
+            this.stripGameEvent(go);
         }
         for (const go of list) {
-            if (go.name === OUTLINE_GO_NAME)
+            if (this.isIgnoredPickGo(go))
                 continue;
-            if (go === this.outlineGo)
+            if (!go.getComponent(CombosDevelopmentToolTarget))
                 continue;
-            this.ensureTap(go);
+            this.ensurePick(go);
         }
     }
     collectGameObjects(go, out) {
@@ -466,30 +441,58 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
             this.collectGameObjects(tr.gameObject, out);
         }
     }
-    detachAllTaps(restore = true) {
-        for (const go of [...this.tapOwners.values()]) {
-            this.releaseTap(go, restore);
+    isIgnoredPickGo(go) {
+        return go.name === OUTLINE_GO_NAME || go === this.outlineGo;
+    }
+    stripGameEvent(go) {
+        if (this.cachedGameEvents.has(go.id))
+            return;
+        const ev = go.getComponent(pluginRendererEvent.Event);
+        if (!ev)
+            return;
+        try {
+            const removed = go.removeComponent(pluginRendererEvent.Event);
+            this.cachedGameEvents.set(go.id, removed);
+        }
+        catch {
+            /* ignore */
         }
     }
-    ensureTap(go) {
-        let ev = go.getComponent(pluginRendererEvent.Event);
-        if (!ev) {
-            ev = go.addComponent(this.createInjectedEvent(go));
-            this.injectedEvents.add(go.id);
+    restoreCachedGameEvents() {
+        for (const [id, event] of [...this.cachedGameEvents.entries()]) {
+            const go = this.findGameObjectById(id);
+            if (!go || go.destroyed || go.getComponent(pluginRendererEvent.Event)) {
+                this.cachedGameEvents.delete(id);
+                continue;
+            }
+            try {
+                go.addComponent(event);
+            }
+            catch {
+                /* ignore */
+            }
+            this.cachedGameEvents.delete(id);
         }
+    }
+    detachAllPicks() {
+        for (const go of [...this.tapOwners.values()]) {
+            this.releasePick(go);
+        }
+    }
+    ensurePick(go) {
         if (this.tapHandlers.has(go.id))
             return;
-        if (!this.savedTapListeners.has(go.id)) {
-            const existing = ev.listeners('tap');
-            this.savedTapListeners.set(go.id, [...existing]);
+        let ev = go.getComponent(pluginRendererEvent.Event);
+        if (!ev) {
+            ev = go.addComponent(this.createPickEvent(go));
+            this.pickEvents.add(go.id);
         }
-        ev.removeAllListeners('tap');
         const handler = payload => this.onSelect(go, payload);
         this.tapHandlers.set(go.id, handler);
         this.tapOwners.set(go.id, go);
         ev.on('tap', handler);
     }
-    createInjectedEvent(go) {
+    createPickEvent(go) {
         const bounds = this.resolvePickBounds(go);
         if (bounds.width > 0 && bounds.height > 0) {
             return new pluginRendererEvent.Event({
@@ -504,13 +507,14 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
                 },
             });
         }
-        // Let Pixi use natural rendered bounds instead of forcing a 1×1 hit area.
         return new pluginRendererEvent.Event();
     }
     resolvePickBounds(go) {
-        // Graphics draws in arbitrary local coordinates (often centered at 0,0).
-        // transform.size is a layout box from (0,0) and must not override Pixi bounds.
         if (this.shouldPreferRenderedBounds(go)) {
+            const fromOwnGraphics = this.resolveOwnGraphicsLocalBounds(go);
+            if (fromOwnGraphics) {
+                return fromOwnGraphics;
+            }
             const fromGraphics = this.resolveContainerLocalBounds(go);
             if (fromGraphics) {
                 return fromGraphics;
@@ -529,10 +533,37 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
     shouldPreferRenderedBounds(go) {
         return go.getComponent(pluginRendererGraphics.Graphics) != null;
     }
+    /** Bounds of this GO's own Graphics only — excludes child GOs such as the selection outline. */
+    resolveOwnGraphicsLocalBounds(go) {
+        const gfx = go.getComponent(pluginRendererGraphics.Graphics);
+        if (!gfx?.graphics)
+            return null;
+        try {
+            const bounds = gfx.graphics.getLocalBounds();
+            if (bounds.width > 0 && bounds.height > 0) {
+                return {
+                    x: bounds.x,
+                    y: bounds.y,
+                    width: bounds.width,
+                    height: bounds.height,
+                };
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        return null;
+    }
     resolveContainerLocalBounds(go) {
         const container = this.getRendererContainer(go);
         if (!container)
             return null;
+        const outlineContainer = this.getOutlineContainerIfChildOf(go);
+        let outlineDetached = false;
+        if (outlineContainer?.parent === container) {
+            container.removeChild(outlineContainer);
+            outlineDetached = true;
+        }
         try {
             const bounds = container.getLocalBounds();
             if (bounds.width > 0 && bounds.height > 0) {
@@ -547,8 +578,20 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
         catch {
             /* ignore */
         }
+        finally {
+            if (outlineDetached && outlineContainer) {
+                container.addChild(outlineContainer);
+            }
+        }
         return null;
     }
+    /** Outline is parented under the selected GO; exclude it when measuring content bounds. */
+    getOutlineContainerIfChildOf(go) {
+        if (!this.outlineGo || this.outlineGo.parent !== go) {
+            return null;
+        }
+        return this.getRendererContainer(this.outlineGo);
+    }
     getRendererContainer(go) {
         const rendererSystem = this.game.getSystem(pluginRenderer.RendererSystem);
         if (!rendererSystem?.containerManager)
@@ -560,7 +603,7 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
             return null;
         }
     }
-    releaseTap(go, restore = true) {
+    releasePick(go) {
         const handler = this.tapHandlers.get(go.id);
         if (!handler)
             return;
@@ -568,25 +611,26 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
         ev?.off('tap', handler);
         this.tapHandlers.delete(go.id);
         this.tapOwners.delete(go.id);
-        if (restore) {
-            const saved = this.savedTapListeners.get(go.id);
-            if (saved && saved.length > 0 && ev) {
-                for (const fn of saved) {
-                    ev.on('tap', fn);
-                }
+        if (this.pickEvents.has(go.id)) {
+            try {
+                go.removeComponent(pluginRendererEvent.Event);
             }
-            this.savedTapListeners.delete(go.id);
-            if (this.injectedEvents.has(go.id)) {
-                try {
-                    go.removeComponent(pluginRendererEvent.Event);
-                }
-                catch {
-                    /* ignore */
-                }
-                this.injectedEvents.delete(go.id);
+            catch {
+                /* ignore */
             }
+            this.pickEvents.delete(go.id);
         }
     }
+    postSetSuccess(enabled) {
+        const payload = {
+            type: COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS,
+            enabled,
+        };
+        if (typeof window !== 'undefined' && window.parent && window.parent !== window) {
+            window.parent.postMessage(payload, this.postMessageOrigin);
+        }
+        this.game.emit(COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS, { enabled });
+    }
     ensureOutline() {
         if (this.outlineGo)
             return;
@@ -610,6 +654,8 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
             this.outlineGo.remove();
         }
         go.addChild(this.outlineGo);
+        this.invalidateOutlineBounds();
+        this.updateSelectionOutline();
         const snapshot = buildGameObjectSnapshot(go);
         const payload = {
             type: COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED,
@@ -681,6 +727,8 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
         if (!applied)
             return;
         if (this.selected?.id === go.id) {
+            this.invalidateOutlineBounds();
+            this.updateSelectionOutline();
             this.postSnapshotUpdate(go);
         }
     }
@@ -697,6 +745,7 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
     }
     clearSelection() {
         this.selected = null;
+        this.invalidateOutlineBounds();
         if (this.outlineGo?.parent) {
             this.outlineGo.remove();
         }
@@ -705,6 +754,33 @@ let CombosDevelopmentToolSystem$1 = class CombosDevelopmentToolSystem extends en
             gfx.graphics.clear();
         }
     }
+    /** Redraw the green outline only when content bounds change (movement follows via child transform). */
+    updateSelectionOutline() {
+        if (!this.enabled || !this.selected || !this.outlineGo)
+            return;
+        const gfxComp = this.outlineGo.getComponent(pluginRendererGraphics.Graphics);
+        if (!gfxComp?.graphics)
+            return;
+        const bounds = this.resolvePickBounds(this.selected);
+        if (this.lastOutlineBounds && this.pickBoundsEqual(this.lastOutlineBounds, bounds)) {
+            return;
+        }
+        this.lastOutlineBounds = bounds;
+        const g = gfxComp.graphics;
+        g.clear();
+        g.rect(bounds.x, bounds.y, bounds.width, bounds.height);
+        g.stroke({ width: 4, color: 0x55ffaa, alpha: 1 });
+    }
+    invalidateOutlineBounds() {
+        this.lastOutlineBounds = null;
+    }
+    pickBoundsEqual(a, b) {
+        const eps = 0.01;
+        return (Math.abs(a.x - b.x) < eps &&
+            Math.abs(a.y - b.y) < eps &&
+            Math.abs(a.width - b.width) < eps &&
+            Math.abs(a.height - b.height) < eps);
+    }
 };
 CombosDevelopmentToolSystem$1 = tslib.__decorate([
     engine.decorators.componentObserver({
@@ -716,7 +792,7 @@ var CombosDevelopmentToolSystem = CombosDevelopmentToolSystem$1;
 /** Auto-generated by scripts/build-package.mjs — do not edit. */
 Object.assign(CombosDevelopmentToolSystem, {
     packageName: "@combos-fun/plugin-development-tool",
-    packageVersion: "0.0.19",
+    packageVersion: "0.0.20",
 });
 
 exports.COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY = COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY;
@@ -724,6 +800,7 @@ exports.COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED = COMBOS_DEVELOPMENT_TOOL_GA
 exports.COMBOS_DEVELOPMENT_TOOL_READY = COMBOS_DEVELOPMENT_TOOL_READY;
 exports.COMBOS_DEVELOPMENT_TOOL_REFRESH = COMBOS_DEVELOPMENT_TOOL_REFRESH;
 exports.COMBOS_DEVELOPMENT_TOOL_SET = COMBOS_DEVELOPMENT_TOOL_SET;
+exports.COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS = COMBOS_DEVELOPMENT_TOOL_SET_SUCCESS;
 exports.CombosDevelopmentToolSystem = CombosDevelopmentToolSystem;
 exports.CombosDevelopmentToolTarget = CombosDevelopmentToolTarget;
 exports.applyPropertyValue = applyPropertyValue;