@umicat/phaser-sdk 1.0.10 → 1.0.12

package/dist/editor/EditorBridge.d.ts

@@ -3,6 +3,21 @@ import { AssetRecord } from '../scene/types.js';
 import { TilemapEditOp } from '../protocol.js';
 export declare function setupEditorBridge(game: Phaser.Game): void;
 export declare function postSelectionRect(game: Phaser.Game): void;
+/**
+ * Compute the entity's DOM screen rect — viewport pixels relative to the
+ * iframe's top-left. The host adds the iframe's bounding rect to translate
+ * into page coords.
+ *
+ * Path: world coords → camera transform → canvas pixels → iframe pixels.
+ * Phaser's Scale.FIT may letterbox/pillarbox the canvas inside the iframe,
+ * so we factor in the canvas's parent offset too.
+ */
+export declare function computeScreenRect(game: Phaser.Game, go: Phaser.GameObjects.GameObject): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
 /**
  * FB.9a — return ALL entities at the given world coords, sorted by depth
  * DESC (topmost first). Used by EditorOverlayScene's Alt+click handler

package/dist/editor/EditorBridge.js

@@ -574,7 +574,7 @@ function doPostSelectionRect(game) {
  * Phaser's Scale.FIT may letterbox/pillarbox the canvas inside the iframe,
  * so we factor in the canvas's parent offset too.
  */
-function computeScreenRect(game, go) {
+export function computeScreenRect(game, go) {
     // Pull entity-local bounds — same logic the editor uses for hit-test.
     const hitW = go.getData('editorHitWidth');
     const hitH = go.getData('editorHitHeight');
@@ -1405,6 +1405,17 @@ function pickLoadUrl(asset) {
     const loadUrl = asset.loadUrl;
     return loadUrl || asset.path;
 }
+/**
+ * Atlas JSON URL for editor lazy-load. Mirrors `pickLoadUrl` for the companion
+ * atlas/ninepatch file: `atlasLoadUrl` (off-record, set by the host's Bg-image
+ * picker from `AssetSummary.atlasUrl`) loads the JSON from the CDN so a freshly
+ * generated + region-tagged asset renders LIVE — its bytes aren't in the
+ * workspace until save. Falls back to the workspace `atlasPath` for saved assets.
+ */
+function pickAtlasUrl(asset) {
+    const atlasLoadUrl = asset.atlasLoadUrl;
+    return atlasLoadUrl || asset.atlasPath;
+}
 function loadAssetIntoScene(scene, asset) {
     return new Promise((resolve, reject) => {
         if (scene.textures.exists(asset.textureKey)) {
@@ -1448,21 +1459,25 @@ function loadAssetIntoScene(scene, asset) {
                     scene.load.image(asset.textureKey, loadFrom);
                 }
                 break;
-            case 'atlas':
+            case 'atlas': {
+                // The companion JSON loads from `atlasLoadUrl` (CDN) when present so a
+                // freshly generated + 9-sliced asset renders live, not just the texture.
+                const atlasFrom = pickAtlasUrl(asset);
                 if (asset.atlasPath && asset.atlasFormat === 'xml') {
-                    scene.load.atlasXML(asset.textureKey, loadFrom, asset.atlasPath);
+                    scene.load.atlasXML(asset.textureKey, loadFrom, atlasFrom);
                 }
                 else if (asset.atlasPath) {
-                    scene.load.atlas(asset.textureKey, loadFrom, asset.atlasPath);
+                    scene.load.atlas(asset.textureKey, loadFrom, atlasFrom);
                     // Also fetch the raw JSON into the side-cache for per-region
                     // ninePatch lookups (slice 10). Phaser's atlas parser drops
                     // unknown per-frame fields, so we keep the original JSON around.
                     const sidecarKey = `umicat:atlas-ninepatch:${asset.textureKey}`;
                     if (!scene.cache.json.exists(sidecarKey)) {
-                        scene.load.json(sidecarKey, asset.atlasPath);
+                        scene.load.json(sidecarKey, atlasFrom);
                     }
                 }
                 break;
+            }
             case 'audio':
                 scene.load.audio(asset.textureKey, loadFrom);
                 break;

package/dist/editor/EditorOverlayScene.d.ts

@@ -84,6 +84,8 @@ export declare class EditorOverlayScene extends Phaser.Scene {
     private postDragEnd;
     private postShortcut;
     private applyPanZoom;
+    /** Last pointerdown's entity + time — used to detect a double-click (inline text edit). */
+    private lastDownInfo;
     private panActive;
     private spaceHeld;
     private panStartScreen;

package/dist/editor/EditorOverlayScene.js

@@ -4,7 +4,7 @@ import { findHudEntity, findHudRegistry, UMICAT_HUD_SCENE_KEY, } from '../scene/
 import { isPerFrameHitbox } from '../scene/types.js';
 import { getManifest } from '../scene/SceneLoader.js';
 import { getEditorState, startDrag, clearDrag, getDrag, getSelection, getEditorMode, getDebugOverlayState, getTilemapToolState, isTilemapPaintMode, beginTilemapStroke, beginAutotileStroke, appendTilemapStrokeCell, appendAutotileStrokeClick, endTilemapStroke, getTilemapStroke, beginTilemapRect, updateTilemapRect, endTilemapRect, getTilemapRect, getTilemapResize, beginTilemapResize, updateTilemapResize, endTilemapResize, getEntityResize, beginEntityResize, updateEntityResize, endEntityResize, } from './EditorState.js';
-import { applyTilemapOp, findTilemapLayerById, handleEditTilemap, postSelectionRect } from './EditorBridge.js';
+import { applyTilemapOp, computeScreenRect, findTilemapLayerById, handleEditTilemap, postSelectionRect } from './EditorBridge.js';
 import { applyAutotile, findTerrain, getAutotileKind } from '../scene/autotile.js';
 /**
  * Editor overlay — slice 2.
@@ -65,6 +65,8 @@ const ANCHOR_CROSS_LEN = 6;
 export class EditorOverlayScene extends Phaser.Scene {
     constructor() {
         super({ key: EDITOR_OVERLAY_KEY });
+        /** Last pointerdown's entity + time — used to detect a double-click (inline text edit). */
+        this.lastDownInfo = null;
         // P1 infinite canvas — input state. Pan can be triggered by middle-button
         // drag OR by space+left-drag. We accumulate a "pan active" flag so the
         // existing selection / drag-to-move handlers don't fire while panning.
@@ -289,6 +291,30 @@ export class EditorOverlayScene extends Phaser.Scene {
             this.postPick(null, modifiers);
             return;
         }
+        // Double-click a text-bearing HUD widget (icon-button label / text widget) →
+        // tell the host to open an inline text editor over it (Figma convention —
+        // beats hunting for the Inspector's Label field). The first click already
+        // selected it; the second opens the editor instead of starting a drag.
+        const dblKind = hit.getData('entityKind');
+        const downTime = pointer.downTime;
+        const isDoubleClick = this.lastDownInfo?.id === entityId && downTime - this.lastDownInfo.time < 350;
+        this.lastDownInfo = { id: entityId, time: downTime };
+        if (isDoubleClick &&
+            getEditorMode(this.game) === 'hud' &&
+            (dblKind === 'icon-button' || dblKind === 'text')) {
+            const rect = computeScreenRect(this.game, hit);
+            if (rect) {
+                const msg = {
+                    type: 'umicat:editor:editText',
+                    entityId,
+                    kind: dblKind,
+                    rect,
+                };
+                window.parent.postMessage(msg, '*');
+                event?.preventDefault?.();
+                return;
+            }
+        }
         // Surface the prefab id when the picked GameObject was spawned via
         // `spawnPrefab` (set on the data manager at spawn — see Prefabs.ts).
         // The host routes prefab-instance picks to the Prefab Inspector.

package/dist/protocol.d.ts

@@ -715,6 +715,26 @@ export interface EditorEntityResizedMessage {
         height: number;
     };
 }
+/**
+ * Double-click on a text-bearing HUD widget (icon-button label / text widget) —
+ * the host renders an inline `<input>` over the widget so the user edits the
+ * text directly on the canvas (Figma/Canva convention) instead of hunting for
+ * the Inspector field. `rect` is iframe-relative px (host adds the iframe offset
+ * to position the overlay). The host reads the CURRENT text from its scene state
+ * and commits the edit via the normal applyEdit/patch path.
+ */
+export interface EditorEditTextMessage {
+    type: 'umicat:editor:editText';
+    entityId: string;
+    /** Which HUD widget kind — tells the host which field to edit (label vs source). */
+    kind: 'icon-button' | 'text';
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
 /**
  * Editor keyboard shortcut intercepted inside the iframe (user clicked the
  * canvas, so focus is on the iframe and the host window doesn't see the

package/dist/scene/HudRuntime.js

@@ -428,7 +428,7 @@ function createIconButton(ctx, entity, pos) {
     }
     if (v.label) {
         const label = ctx.scene.add.text(0, 0, v.label, {
-            fontFamily: 'sans-serif',
+            fontFamily: v.fontFamily ?? 'sans-serif',
             fontSize: `${v.fontSize ?? 16}px`,
             color: v.textColor ?? '#ffffff',
         });

package/dist/scene/types.d.ts

@@ -1213,6 +1213,8 @@ export interface HudIconButtonEntity extends HudEntityBase {
     strokeWidth?: number;
     pressedFillColor?: string;
     textColor?: string;
+    /** Label font family (matches a loaded font; default `sans-serif`). */
+    fontFamily?: string;
     fontSize?: number;
 }
 export interface HudProgressBarEntity extends HudEntityBase {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umicat/phaser-sdk",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Umicat Phaser 3 SDK — game infrastructure for the Umicat platform",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",