@combos-fun/plugin-development-tool 0.0.13 → 0.0.15

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

@@ -1,5 +1,6 @@
-import { Component, System, OBSERVER_TYPE, GameObject, decorators } from '@combos-fun/engine';
 import { __decorate } from 'tslib';
+import { Component, System, OBSERVER_TYPE, GameObject, decorators } from '@combos-fun/engine';
+import { RendererSystem } from '@combos-fun/plugin-renderer';
 import { Graphics } from '@combos-fun/plugin-renderer-graphics';
 import { Event, HIT_AREA_TYPE } from '@combos-fun/plugin-renderer-event';
 
@@ -9,6 +10,10 @@ const COMBOS_DEVELOPMENT_TOOL_SET = 'combos-development-tool:set';
 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';
+/** Parent → iframe: apply a value to a component field (live preview). */
+const COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY = 'combos-development-tool:apply-property';
+/** iframe → parent: game scene bootstrap finished; parent may enable pick mode. */
+const COMBOS_DEVELOPMENT_TOOL_READY = 'combos-development-tool:ready';
 
 /**
  * Optional marker when using `CombosDevelopmentToolSystem` with `scope: 'tagged'`, or to attach
@@ -25,6 +30,243 @@ class CombosDevelopmentToolTarget extends Component {
     }
 }
 
+function isSceneSourceAnchor(v) {
+    return (!!v &&
+        typeof v === 'object' &&
+        typeof v.file === 'string');
+}
+
+const SKIP_KEYS = new Set([
+    'gameObject',
+    'name',
+    'started',
+    '__componentDefaultParams',
+    'destroyed',
+    'inScene',
+    'worldTransform',
+    'children',
+    '_parent',
+]);
+const COMPONENT_SKIP_KEYS = {
+    Physics: new Set([
+        'body',
+        'Body',
+        'PhysicsEngine',
+        'World',
+        'Constraint',
+        'mouseConstraint',
+        'bodyParams',
+    ]),
+    Event: new Set(['hitArea']),
+};
+function cloneJsonSafe(value, depth = 0) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (depth > 6)
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.map(item => cloneJsonSafe(item, depth + 1));
+    }
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (typeof v === 'function')
+                continue;
+            const cloned = cloneJsonSafe(v, depth + 1);
+            if (cloned !== undefined)
+                out[k] = cloned;
+        }
+        return out;
+    }
+    return undefined;
+}
+function serializeComponent(comp) {
+    const out = {};
+    const componentSkips = COMPONENT_SKIP_KEYS[comp.name];
+    for (const key of Object.keys(comp)) {
+        if (SKIP_KEYS.has(key) || key.startsWith('_'))
+            continue;
+        if (componentSkips?.has(key))
+            continue;
+        const value = comp[key];
+        if (typeof value === 'function')
+            continue;
+        const cloned = cloneJsonSafe(value);
+        if (cloned !== undefined)
+            out[key] = cloned;
+    }
+    return out;
+}
+function readSourceAnchor(go) {
+    const tag = go.getComponent(CombosDevelopmentToolTarget);
+    const raw = tag?.payload?.source;
+    if (!isSceneSourceAnchor(raw))
+        return undefined;
+    return {
+        file: raw.file,
+        anchor: raw.anchor ?? go.name,
+    };
+}
+function buildGameObjectSnapshot(go) {
+    const components = go.components
+        .filter(c => c.name !== 'CombosDevelopmentToolTarget')
+        .map(c => ({
+        componentName: c.name,
+        fields: serializeComponent(c),
+    }));
+    return {
+        id: go.id,
+        name: go.name,
+        components,
+        source: readSourceAnchor(go),
+    };
+}
+function applyPropertyValue(go, componentName, path, value) {
+    const comp = go.getComponent(componentName);
+    if (!comp || !path.length)
+        return false;
+    let target = comp;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (target[key] === undefined || target[key] === null) {
+            target[key] = {};
+        }
+        target = target[key];
+    }
+    target[path[path.length - 1]] = value;
+    return true;
+}
+function readPropertyValue(go, componentName, path) {
+    const comp = go.getComponent(componentName);
+    if (!comp || !path.length)
+        return undefined;
+    let target = comp;
+    for (const key of path) {
+        if (target === null || target === undefined || typeof target !== 'object') {
+            return undefined;
+        }
+        target = target[key];
+    }
+    return target;
+}
+
+const TRANSFORM_VECTOR_KEYS = new Set([
+    'position',
+    'size',
+    'origin',
+    'anchor',
+    'scale',
+    'skew',
+]);
+function asNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const next = Number(value);
+        return Number.isFinite(next) ? next : undefined;
+    }
+    return undefined;
+}
+function syncPhysicsBodyFromTransform(go) {
+    const physics = go.getComponent('Physics');
+    if (!physics?.body) {
+        return;
+    }
+    const { x, y } = go.transform.position;
+    if (physics.Body?.setPosition) {
+        physics.Body.setPosition(physics.body, { x, y });
+        return;
+    }
+    physics.body.position.x = x;
+    physics.body.position.y = y;
+}
+function syncMoverOriginFromTransform(go) {
+    const mover = go.getComponent('PlatformerMover');
+    if (!mover) {
+        return;
+    }
+    mover.originX = go.transform.position.x;
+    mover.originY = go.transform.position.y;
+}
+function applyTransformProperty(go, comp, path, value) {
+    const transform = go.transform ?? comp;
+    const transformRecord = transform;
+    if (path.length === 1 && path[0] === 'rotation') {
+        const next = asNumber(value);
+        if (next === undefined) {
+            return false;
+        }
+        transform.rotation = next;
+        return true;
+    }
+    if (path.length === 2 && TRANSFORM_VECTOR_KEYS.has(path[0])) {
+        const groupKey = path[0];
+        const leafKey = path[1];
+        const next = asNumber(value);
+        if (next === undefined) {
+            return false;
+        }
+        const group = transformRecord[groupKey];
+        if (!group || typeof group !== 'object') {
+            return false;
+        }
+        group[leafKey] = next;
+        if (groupKey === 'position') {
+            syncPhysicsBodyFromTransform(go);
+            syncMoverOriginFromTransform(go);
+        }
+        return true;
+    }
+    return false;
+}
+function applyTextProperty(_go, comp, path, value) {
+    const textComp = comp;
+    if (path.length === 1 && path[0] === 'text') {
+        textComp.text = String(value ?? '');
+        return true;
+    }
+    if (path.length === 2 && path[0] === 'style') {
+        const styleKey = path[1];
+        const nextStyle = { ...(textComp.style ?? {}), [styleKey]: value };
+        textComp.style = nextStyle;
+        return true;
+    }
+    return false;
+}
+function applySoundProperty(_go, comp, path, value) {
+    const soundComp = comp;
+    if ((path.length === 1 && path[0] === 'volume') ||
+        (path.length === 2 && path[0] === 'config' && path[1] === 'volume')) {
+        const next = asNumber(value);
+        if (next === undefined) {
+            return false;
+        }
+        soundComp.volume = next;
+        return true;
+    }
+    return false;
+}
+const APPLY_HOOKS = {
+    Transform: applyTransformProperty,
+    Text: applyTextProperty,
+    Sound: applySoundProperty,
+};
+function applyPropertyWithHooks(go, componentName, path, value) {
+    const comp = go.getComponent(componentName);
+    if (!comp || !path.length) {
+        return false;
+    }
+    const hook = APPLY_HOOKS[componentName];
+    if (hook?.(go, comp, path, value)) {
+        return true;
+    }
+    return applyPropertyValue(go, componentName, path, value);
+}
+
 const OUTLINE_GO_NAME = '__combosDevelopmentToolOutline';
 /**
  * **Defaults:** `scope: 'scene'`, **off** at start (no tap hijack until enabled).
@@ -48,6 +290,7 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         /** We added `Event` for hit-testing; remove on teardown when disabling / releaseTap. */
         this.injectedEvents = new Set();
         this.needsSceneRescan = false;
+        this.needsTaggedRescan = false;
         this.onWindowSet = (e) => {
             const d = e.detail;
             if (d && typeof d.enabled === 'boolean') {
@@ -64,6 +307,9 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
             else if (d.type === COMBOS_DEVELOPMENT_TOOL_REFRESH) {
                 this.requestSceneRescan();
             }
+            else if (d.type === COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY) {
+                this.handleApplyProperty(d);
+            }
         };
         this.onGameSet = (payload) => {
             if (payload && typeof payload.enabled === 'boolean') {
@@ -91,6 +337,9 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         if (this.enabled && this.scope === 'scene') {
             this.needsSceneRescan = true;
         }
+        else if (this.enabled && this.scope === 'tagged') {
+            this.needsTaggedRescan = true;
+        }
     }
     onDestroy() {
         if (typeof window !== 'undefined') {
@@ -110,22 +359,27 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         this.enabled = on;
         if (!on) {
             this.clearSelection();
-            if (this.scope === 'scene') {
-                this.detachAllTaps();
-            }
+            this.detachAllTaps();
         }
         else if (this.scope === 'scene') {
             this.needsSceneRescan = true;
         }
+        else {
+            this.needsTaggedRescan = true;
+        }
     }
     get isEnabled() {
         return this.enabled;
     }
     update(e) {
-        if (this.scope === 'scene' && this.enabled && this.needsSceneRescan) {
+        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();
+        }
         for (const go of [...this.tapOwners.values()]) {
             if (go.destroyed) {
                 this.releaseTap(go);
@@ -136,12 +390,12 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         const gfxComp = this.outlineGo.getComponent(Graphics);
         if (!gfxComp?.graphics)
             return;
-        const { width, height } = this.selected.transform.size;
+        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(0, 0, Math.max(1, width), Math.max(1, height));
+        g.rect(bounds.x, bounds.y, bounds.width, bounds.height);
         g.stroke({ width: 4, color: 0x55ffaa, alpha: pulse });
     }
     componentChanged(changed) {
@@ -162,9 +416,29 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
     }
     /** Re-bind scene taps when `scope === 'scene'` (e.g. after dynamic spawn). */
     requestSceneRescan() {
-        if (this.scope !== 'scene' || !this.enabled)
+        if (!this.enabled)
             return;
-        this.needsSceneRescan = true;
+        if (this.scope === 'scene') {
+            this.needsSceneRescan = true;
+        }
+        else {
+            this.needsTaggedRescan = true;
+        }
+    }
+    attachTaggedObjects() {
+        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)
+                continue;
+            if (!go.getComponent(CombosDevelopmentToolTarget))
+                continue;
+            this.ensureTap(go);
+        }
     }
     attachSceneTree() {
         this.detachAllTaps();
@@ -194,22 +468,85 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
     ensureTap(go) {
         let ev = go.getComponent(Event);
         if (!ev) {
-            const { width, height } = go.transform.size;
-            ev = go.addComponent(new Event({
-                hitArea: {
-                    type: HIT_AREA_TYPE.Rect,
-                    style: { x: 0, y: 0, width: width || 1, height: height || 1 },
-                },
-            }));
+            ev = go.addComponent(this.createInjectedEvent(go));
             this.injectedEvents.add(go.id);
         }
         if (this.tapHandlers.has(go.id))
             return;
-        const handler = () => this.onSelect(go);
+        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) {
+        const { width, height } = go.transform.size;
+        if (width > 0 && height > 0) {
+            return new Event({
+                hitArea: {
+                    type: HIT_AREA_TYPE.Rect,
+                    style: { x: 0, y: 0, width, height },
+                },
+            });
+        }
+        const bounds = this.resolveContainerLocalBounds(go);
+        if (bounds) {
+            return new Event({
+                hitArea: {
+                    type: HIT_AREA_TYPE.Rect,
+                    style: {
+                        x: bounds.x,
+                        y: bounds.y,
+                        width: bounds.width,
+                        height: bounds.height,
+                    },
+                },
+            });
+        }
+        // Let Pixi use natural rendered bounds instead of forcing a 1×1 hit area.
+        return new Event();
+    }
+    resolvePickBounds(go) {
+        const { width, height } = go.transform.size;
+        if (width > 0 && height > 0) {
+            return { x: 0, y: 0, width, height };
+        }
+        const fromContainer = this.resolveContainerLocalBounds(go);
+        if (fromContainer) {
+            return fromContainer;
+        }
+        return { x: 0, y: 0, width: 1, height: 1 };
+    }
+    resolveContainerLocalBounds(go) {
+        const container = this.getRendererContainer(go);
+        if (!container)
+            return null;
+        try {
+            const bounds = container.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;
+    }
+    getRendererContainer(go) {
+        const rendererSystem = this.game.getSystem(RendererSystem);
+        if (!rendererSystem?.containerManager)
+            return null;
+        try {
+            return rendererSystem.containerManager.getContainer(go.id);
+        }
+        catch {
+            return null;
+        }
+    }
     releaseTap(go) {
         const handler = this.tapHandlers.get(go.id);
         if (!handler)
@@ -239,7 +576,7 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
         go.addComponent(new Graphics());
         this.outlineGo = go;
     }
-    onSelect(go) {
+    onSelect(go, tap) {
         if (!this.enabled)
             return;
         this.ensureOutline();
@@ -250,11 +587,91 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
             this.outlineGo.remove();
         }
         go.addChild(this.outlineGo);
-        const payload = this.serializeGameObject(go);
+        const snapshot = buildGameObjectSnapshot(go);
+        const payload = {
+            type: COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED,
+            snapshot,
+            pointer: tap?.data?.position ?? null,
+        };
         if (typeof window !== 'undefined' && window.parent && window.parent !== window) {
             window.parent.postMessage(payload, this.postMessageOrigin);
         }
     }
+    findGameObjectById(id) {
+        const stack = [];
+        for (const tr of this.game.scene.transform.children) {
+            this.collectGameObjects(tr.gameObject, stack);
+        }
+        return stack.find(go => go.id === id) ?? null;
+    }
+    findGameObjectBySource(source) {
+        const stack = [];
+        for (const tr of this.game.scene.transform.children) {
+            this.collectGameObjects(tr.gameObject, stack);
+        }
+        const wantFile = source.file.trim();
+        const wantAnchor = (source.anchor ?? '').trim();
+        if (!wantAnchor) {
+            return null;
+        }
+        for (const go of stack) {
+            const anchor = readSourceAnchor(go);
+            if (!anchor || anchor.file !== wantFile) {
+                continue;
+            }
+            const resolvedAnchor = anchor.anchor ?? go.name;
+            if (resolvedAnchor === wantAnchor) {
+                return go;
+            }
+        }
+        return null;
+    }
+    resolveApplyTarget(payload) {
+        if (typeof payload.gameObjectId === 'number') {
+            const byId = this.findGameObjectById(payload.gameObjectId);
+            if (byId) {
+                return byId;
+            }
+        }
+        const file = payload.source?.file?.trim();
+        const anchor = payload.source?.anchor?.trim();
+        if (!file || !anchor) {
+            return null;
+        }
+        return this.findGameObjectBySource({ file, anchor });
+    }
+    handleApplyProperty(payload) {
+        const componentName = payload.componentName;
+        const path = payload.path;
+        const hasId = typeof payload.gameObjectId === 'number';
+        const hasSource = Boolean(payload.source?.file?.trim()) && Boolean(payload.source?.anchor?.trim());
+        if ((!hasId && !hasSource) ||
+            typeof componentName !== 'string' ||
+            !Array.isArray(path) ||
+            path.length === 0) {
+            return;
+        }
+        const go = this.resolveApplyTarget(payload);
+        if (!go)
+            return;
+        const applied = applyPropertyWithHooks(go, componentName, path, payload.value);
+        if (!applied)
+            return;
+        if (this.selected?.id === go.id) {
+            this.postSnapshotUpdate(go);
+        }
+    }
+    postSnapshotUpdate(go) {
+        const snapshot = buildGameObjectSnapshot(go);
+        if (typeof window !== 'undefined' && window.parent && window.parent !== window) {
+            window.parent.postMessage({
+                type: COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED,
+                snapshot,
+                pointer: null,
+                source: 'property-applied',
+            }, this.postMessageOrigin);
+        }
+    }
     clearSelection() {
         this.selected = null;
         if (this.outlineGo?.parent) {
@@ -265,29 +682,19 @@ let CombosDevelopmentToolSystem = class CombosDevelopmentToolSystem extends Syst
             gfx.graphics.clear();
         }
     }
-    serializeGameObject(go) {
-        const tag = go.getComponent(CombosDevelopmentToolTarget);
-        const pos = go.transform.position;
-        const size = go.transform.size;
-        return {
-            type: COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED,
-            gameObject: {
-                name: go.name,
-                id: go.id,
-                position: { x: pos.x, y: pos.y },
-                size: { width: size.width, height: size.height },
-                rotation: go.transform.rotation,
-                payload: tag?.payload ?? {},
-            },
-        };
-    }
 };
 CombosDevelopmentToolSystem = __decorate([
     decorators.componentObserver({
         CombosDevelopmentToolTarget: [],
     })
 ], CombosDevelopmentToolSystem);
-var CombosDevelopmentToolSystem_default = CombosDevelopmentToolSystem;
+var CombosDevelopmentToolSystem$1 = CombosDevelopmentToolSystem;
+
+/** Auto-generated by scripts/build-package.mjs — do not edit. */
+Object.assign(CombosDevelopmentToolSystem$1, {
+    packageName: "@combos-fun/plugin-development-tool",
+    packageVersion: "0.0.15",
+});
 
-export { COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED, COMBOS_DEVELOPMENT_TOOL_REFRESH, COMBOS_DEVELOPMENT_TOOL_SET, CombosDevelopmentToolSystem_default as CombosDevelopmentToolSystem, CombosDevelopmentToolTarget };
+export { COMBOS_DEVELOPMENT_TOOL_APPLY_PROPERTY, COMBOS_DEVELOPMENT_TOOL_GAMEOBJECT_SELECTED, COMBOS_DEVELOPMENT_TOOL_READY, COMBOS_DEVELOPMENT_TOOL_REFRESH, COMBOS_DEVELOPMENT_TOOL_SET, CombosDevelopmentToolSystem$1 as CombosDevelopmentToolSystem, CombosDevelopmentToolTarget, applyPropertyValue, applyPropertyWithHooks, buildGameObjectSnapshot, readPropertyValue, readSourceAnchor };
 //# sourceMappingURL=plugin-development-tool.esm.js.map