@phaserjs/phaser-editor-layout 1.0.0

package/dist/phaser-editor-layout.js

@@ -0,0 +1,424 @@
+"use strict";
+var PhaserEditorLayout = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // phaser-global:phaser
+  var require_phaser = __commonJS({
+    "phaser-global:phaser"(exports, module) {
+      module.exports = globalThis.Phaser;
+    }
+  });
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    LAYOUT_UPDATE_EVENT: () => LAYOUT_UPDATE_EVENT,
+    LayoutPlugin: () => LayoutPlugin,
+    LayoutZone: () => LayoutZone
+  });
+
+  // src/LayoutPlugin.ts
+  var import_phaser2 = __toESM(require_phaser(), 1);
+
+  // src/LayoutZone.ts
+  var import_phaser = __toESM(require_phaser(), 1);
+  var LayoutZone = class {
+    constructor(scene, provider, marginTop = 0, marginRight = 0, marginBottom = 0, marginLeft = 0) {
+      this.scene = scene;
+      this.provider = provider;
+      this.base = { marginTop, marginRight, marginBottom, marginLeft };
+      this.portrait = {};
+      this.landscape = {};
+    }
+    /** Effective value of one margin side under the active variant. */
+    _margin(side) {
+      const variant = this.provider.variant;
+      if (variant !== "base") {
+        const override = this[variant][side];
+        if (override !== void 0) {
+          return override;
+        }
+      }
+      return this.base[side];
+    }
+    /**
+     * The effective rectangle at the current screen size and active variant. Pass an
+     * `out` rectangle to avoid allocations.
+     */
+    getRect(out) {
+      var _a;
+      const size = (_a = this.provider.designSize) != null ? _a : this.scene.scale.gameSize;
+      const x = this._margin("marginLeft");
+      const y = this._margin("marginTop");
+      const width = size.width - x - this._margin("marginRight");
+      const height = size.height - y - this._margin("marginBottom");
+      if (out) {
+        out.setTo(x, y, width, height);
+        return out;
+      }
+      return new import_phaser.default.Geom.Rectangle(x, y, width, height);
+    }
+  };
+
+  // src/LayoutPlugin.ts
+  var LAYOUT_UPDATE_EVENT = "layoutupdate";
+  var LayoutPlugin = class extends import_phaser2.default.Plugins.ScenePlugin {
+    constructor(scene, pluginManager, pluginKey) {
+      super(scene, pluginManager, pluginKey);
+      /**
+       * The active layout variant. `"base"` applies only the baseline; `"portrait"` /
+       * `"landscape"` apply their overrides on top of base. Defaults to `"base"`. Change
+       * it with {@link setVariant} (manual) or {@link autoVariant} (orientation-driven).
+       */
+      this.variant = "base";
+      // When true, the active variant follows the screen orientation on every resize.
+      this._auto = false;
+      // Injected design size, or null to use the live scene size (scale.gameSize).
+      this._designSize = null;
+      this._scene = scene;
+      this._objects = /* @__PURE__ */ new Set();
+      this.events = new import_phaser2.default.Events.EventEmitter();
+      this.safeArea = new LayoutZone(scene, this);
+      this.screen = new LayoutZone(scene, this);
+      this._rect = new import_phaser2.default.Geom.Rectangle();
+      this._mat = new import_phaser2.default.GameObjects.Components.TransformMatrix();
+      this._p1 = new import_phaser2.default.Math.Vector2();
+      this._p2 = new import_phaser2.default.Math.Vector2();
+    }
+    boot() {
+      const events = this._scene.sys.events;
+      events.on(import_phaser2.default.Scenes.Events.CREATE, this.refresh, this);
+      events.on(import_phaser2.default.Scenes.Events.SHUTDOWN, this.shutdown, this);
+      events.once(import_phaser2.default.Scenes.Events.DESTROY, this.destroy, this);
+      this._scene.scale.on(import_phaser2.default.Scale.Events.RESIZE, this._onResize, this);
+    }
+    // ----- design size -----
+    /**
+     * The injected design size, or `null` when resolution follows the live scene size
+     * (`scale.gameSize`). Read by zones (the plugin is their {@link LayoutZone} provider).
+     */
+    get designSize() {
+      return this._designSize;
+    }
+    /**
+     * Resolve against a fixed design size (e.g. 1080×1920) instead of the live canvas
+     * size, then re-resolve. Hosts that author/preview layouts at a target resolution
+     * (the editor) use this; games typically leave it unset and follow `scale.gameSize`.
+     */
+    setDesignSize(width, height) {
+      this._designSize = { width, height };
+      this.refresh();
+    }
+    /** Clear the injected design size and fall back to the live scene size, then re-resolve. */
+    clearDesignSize() {
+      this._designSize = null;
+      this.refresh();
+    }
+    /** The effective size used for resolution: the injected design size, or the live game size. */
+    _size() {
+      var _a;
+      return (_a = this._designSize) != null ? _a : this._scene.scale.gameSize;
+    }
+    // ----- variants -----
+    /** The screen's current orientation, derived from the effective design size. */
+    get orientation() {
+      const size = this._size();
+      return size.height > size.width ? "portrait" : "landscape";
+    }
+    /**
+     * Manually set the active variant and re-resolve. Turns off orientation
+     * auto-detection (see {@link autoVariant}).
+     */
+    setVariant(variant) {
+      this._auto = false;
+      this.variant = variant;
+      this.refresh();
+    }
+    /**
+     * Enable (or disable) orientation-driven variant selection. When enabled, the active
+     * variant follows {@link orientation} (`"portrait"` / `"landscape"`) on every resize.
+     * Disabling resets the variant to `"base"`.
+     */
+    autoVariant(enabled = true) {
+      this._auto = enabled;
+      this.variant = enabled ? this.orientation : "base";
+      this.refresh();
+    }
+    _onResize() {
+      if (this._auto) {
+        this.variant = this.orientation;
+      }
+      this.refresh();
+    }
+    // ----- objects -----
+    /**
+     * Enable layout for an object: attaches a default {@link AnchorLayoutData} as
+     * `obj.layoutData` (if it does not have one yet), registers the object for
+     * re-resolution, and returns the data so it can be configured.
+     *
+     * The `base` defaults are inert: `targetType: "screen"`, both anchors `"none"` and
+     * zero offsets, so the object does not move until you choose anchors. `portrait` and
+     * `landscape` start empty (they inherit `base`).
+     */
+    add(obj) {
+      let data = obj.layoutData;
+      if (!data) {
+        data = {
+          enabled: true,
+          base: {
+            targetType: "screen",
+            horizontalAnchor: "none",
+            horizontalOffset: 0,
+            verticalAnchor: "none",
+            verticalOffset: 0
+          },
+          portrait: {},
+          landscape: {}
+        };
+        obj.layoutData = data;
+      }
+      this._objects.add(obj);
+      obj.once(import_phaser2.default.GameObjects.Events.DESTROY, this._onObjectDestroy, this);
+      return data;
+    }
+    /** Stop laying out an object and remove its `layoutData`. */
+    remove(obj) {
+      this._objects.delete(obj);
+      obj.off(import_phaser2.default.GameObjects.Events.DESTROY, this._onObjectDestroy, this);
+      obj.layoutData = void 0;
+    }
+    _onObjectDestroy(obj) {
+      this._objects.delete(obj);
+    }
+    // ----- zones -----
+    /**
+     * Create a screen-relative zone. A factory only — the returned zone is not stored
+     * by the plugin; hold the reference and assign it to `data.targetZone`.
+     */
+    createZone(marginTop = 0, marginRight = 0, marginBottom = 0, marginLeft = 0) {
+      return new LayoutZone(this._scene, this, marginTop, marginRight, marginBottom, marginLeft);
+    }
+    // ----- resolution -----
+    /**
+     * Re-resolve every enabled object now. The plugin also runs this automatically on
+     * `scale` `resize` and once after the scene is created, so explicit calls are only
+     * needed after mutating layout data (or the `safeArea` margins) at run time.
+     *
+     * Objects are resolved parent → child so a child anchored to its parent's bounds
+     * sees the parent's already-resolved rect.
+     */
+    refresh() {
+      const list = [];
+      for (const obj of this._objects) {
+        const data = obj.layoutData;
+        if (data && data.enabled) {
+          list.push(obj);
+        }
+      }
+      list.sort((a, b) => this._depth(a) - this._depth(b));
+      for (const obj of list) {
+        this._resolve(obj);
+      }
+      this.events.emit(LAYOUT_UPDATE_EVENT);
+    }
+    /**
+     * Resolve a specific list of objects once, against the current variant / design size /
+     * zones, **without** registering them for future passes (no {@link add}, no re-resolve
+     * on resize). Hosts that drive resolution themselves — e.g. the editor's live preview —
+     * set each object's `layoutData`, call this, then read back the resolved `x`/`y`.
+     *
+     * Objects are still resolved parent → child, and any object whose `layoutData` is
+     * missing or disabled is skipped.
+     */
+    resolveList(objects) {
+      const list = objects.filter((obj) => obj.layoutData && obj.layoutData.enabled);
+      list.sort((a, b) => this._depth(a) - this._depth(b));
+      for (const obj of list) {
+        this._resolve(obj);
+      }
+      this.events.emit(LAYOUT_UPDATE_EVENT);
+    }
+    _depth(obj) {
+      let depth = 0;
+      let parent = obj.parentContainer;
+      while (parent) {
+        depth++;
+        parent = parent.parentContainer;
+      }
+      return depth;
+    }
+    _resolve(obj) {
+      const go = obj;
+      const data = obj.layoutData;
+      const originX = typeof go.originX === "number" ? go.originX : 0;
+      const originY = typeof go.originY === "number" ? go.originY : 0;
+      const eff = this._effective(data);
+      if (eff.targetType === "parent") {
+        this._resolveAgainstParent(go, eff, originX, originY);
+        return;
+      }
+      this._resolveAgainstZone(go, eff, originX, originY);
+    }
+    /** Merge the active variant's overrides over `base` into concrete anchor properties. */
+    _effective(data) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      const base = data.base;
+      const over = this.variant === "base" ? void 0 : data[this.variant];
+      return {
+        targetType: (_b = (_a = over == null ? void 0 : over.targetType) != null ? _a : base.targetType) != null ? _b : "screen",
+        targetZone: (_c = over == null ? void 0 : over.targetZone) != null ? _c : base.targetZone,
+        horizontalAnchor: (_e = (_d = over == null ? void 0 : over.horizontalAnchor) != null ? _d : base.horizontalAnchor) != null ? _e : "none",
+        horizontalOffset: (_g = (_f = over == null ? void 0 : over.horizontalOffset) != null ? _f : base.horizontalOffset) != null ? _g : 0,
+        verticalAnchor: (_i = (_h = over == null ? void 0 : over.verticalAnchor) != null ? _h : base.verticalAnchor) != null ? _i : "none",
+        verticalOffset: (_k = (_j = over == null ? void 0 : over.verticalOffset) != null ? _j : base.verticalOffset) != null ? _k : 0
+      };
+    }
+    /** The zone a non-parent target resolves against. */
+    _zoneFor(eff) {
+      var _a;
+      switch (eff.targetType) {
+        case "safeArea":
+          return this.safeArea;
+        case "custom":
+          return (_a = eff.targetZone) != null ? _a : this.screen;
+        default:
+          return this.screen;
+      }
+    }
+    /** Resolve against a zone's world rect, converting to parent-local space if nested. */
+    _resolveAgainstZone(go, eff, originX, originY) {
+      var _a;
+      const zone = this._zoneFor(eff);
+      const t = zone.getRect(this._rect);
+      const w = this._sizeX(go);
+      const h = this._sizeY(go);
+      const parent = (_a = go.parentContainer) != null ? _a : null;
+      if (parent) {
+        const m = parent.getWorldTransformMatrix(this._mat);
+        const cur = m.transformPoint(go.x, go.y, this._p1);
+        const wx = this._axis(eff.horizontalAnchor, cur.x, t.left, t.right, eff.horizontalOffset, w, originX);
+        const wy = this._axis(eff.verticalAnchor, cur.y, t.top, t.bottom, eff.verticalOffset, h, originY);
+        const local = m.applyInverse(wx, wy, this._p2);
+        go.x = local.x;
+        go.y = local.y;
+        return;
+      }
+      go.x = this._axis(eff.horizontalAnchor, go.x, t.left, t.right, eff.horizontalOffset, w, originX);
+      go.y = this._axis(eff.verticalAnchor, go.y, t.top, t.bottom, eff.verticalOffset, h, originY);
+    }
+    /** Resolve against the object's parent container bounds (local space), or the screen. */
+    _resolveAgainstParent(go, eff, originX, originY) {
+      var _a;
+      const parent = (_a = go.parentContainer) != null ? _a : null;
+      if (parent) {
+        const right = parent.width || 0;
+        const bottom = parent.height || 0;
+        const w2 = (go.width || 0) * (typeof go.scaleX === "number" ? go.scaleX : 1);
+        const h2 = (go.height || 0) * (typeof go.scaleY === "number" ? go.scaleY : 1);
+        go.x = this._axis(eff.horizontalAnchor, go.x, 0, right, eff.horizontalOffset, w2, originX);
+        go.y = this._axis(eff.verticalAnchor, go.y, 0, bottom, eff.verticalOffset, h2, originY);
+        return;
+      }
+      const size = this._size();
+      const w = this._sizeX(go);
+      const h = this._sizeY(go);
+      go.x = this._axis(eff.horizontalAnchor, go.x, 0, size.width, eff.horizontalOffset, w, originX);
+      go.y = this._axis(eff.verticalAnchor, go.y, 0, size.height, eff.verticalOffset, h, originY);
+    }
+    /**
+     * Resolve one axis. Aligns the object's edge/center to the target edge/center,
+     * accounting for the object's origin so `"left"`/`"top"` align the left/top edge,
+     * `"center"` the center, and `"right"`/`"bottom"` the right/bottom edge.
+     *
+     * Reduces to the documented `t.left + offset + size / 2` form for centered-origin
+     * objects (`origin = 0.5`).
+     */
+    _axis(anchor, current, min, max, offset, size, origin) {
+      switch (anchor) {
+        case "left":
+        case "top":
+          return min + offset + origin * size;
+        case "right":
+        case "bottom":
+          return max + offset - (1 - origin) * size;
+        case "center":
+          return (min + max) / 2 + offset + (origin - 0.5) * size;
+        default:
+          return current;
+      }
+    }
+    _sizeX(go) {
+      if (typeof go.displayWidth === "number") {
+        return go.displayWidth;
+      }
+      return typeof go.width === "number" ? go.width : 0;
+    }
+    _sizeY(go) {
+      if (typeof go.displayHeight === "number") {
+        return go.displayHeight;
+      }
+      return typeof go.height === "number" ? go.height : 0;
+    }
+    // ----- event delegates -----
+    on(event, fn, context) {
+      this.events.on(event, fn, context);
+      return this;
+    }
+    once(event, fn, context) {
+      this.events.once(event, fn, context);
+      return this;
+    }
+    off(event, fn, context, once) {
+      this.events.off(event, fn, context, once);
+      return this;
+    }
+    // ----- lifecycle -----
+    shutdown() {
+      const events = this._scene.sys.events;
+      events.off(import_phaser2.default.Scenes.Events.CREATE, this.refresh, this);
+      events.off(import_phaser2.default.Scenes.Events.SHUTDOWN, this.shutdown, this);
+      this._scene.scale.off(import_phaser2.default.Scale.Events.RESIZE, this._onResize, this);
+      this._objects.clear();
+    }
+    destroy() {
+      this.shutdown();
+      this.events.destroy();
+      super.destroy();
+    }
+  };
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=phaser-editor-layout.js.map

package/dist/phaser-editor-layout.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["phaser-global:phaser", "../src/index.ts", "../src/LayoutPlugin.ts", "../src/LayoutZone.ts"],
+  "sourcesContent": ["module.exports = globalThis.Phaser;", "export { LayoutPlugin, LAYOUT_UPDATE_EVENT } from \"./LayoutPlugin\";\nexport { LayoutZone } from \"./LayoutZone\";\nexport type { ZoneMargins, VariantProvider } from \"./LayoutZone\";\nexport type { AnchorLayoutData, AnchorProps, HAnchor, VAnchor, TargetType, VariantName } from \"./types\";\n\n// Side-effect import so the `Phaser.Scene.layout` / `GameObject.layoutData` global\n// augmentations are always part of the public type surface.\nimport \"./types\";\n", "import Phaser from \"phaser\";\nimport { LayoutZone } from \"./LayoutZone\";\nimport type { AnchorLayoutData, HAnchor, TargetType, VAnchor, VariantName } from \"./types\";\n\n/** Event fired by the plugin after each resolution pass. */\nexport const LAYOUT_UPDATE_EVENT = \"layoutupdate\";\n\n/** Fully resolved anchor properties for the active variant (base + overrides). */\ninterface ResolvedAnchor {\n    targetType: TargetType;\n    targetZone?: LayoutZone;\n    horizontalAnchor: HAnchor;\n    horizontalOffset: number;\n    verticalAnchor: VAnchor;\n    verticalOffset: number;\n}\n\n/**\n * Scene plugin that resolves responsive anchors and zones at run time.\n *\n * Reached as `this.layout` (like `this.physics`) once registered with\n * `mapping: \"layout\"`. Per-object layout state lives on the object as\n * `obj.layoutData`; the plugin keeps the set of enabled objects so it can\n * re-resolve them when the screen changes.\n *\n * Register it in the game config:\n *\n * ```ts\n * plugins: {\n *     scene: [\n *         { key: \"LayoutPlugin\", plugin: LayoutPlugin, mapping: \"layout\" }\n *     ]\n * }\n * ```\n */\nexport class LayoutPlugin extends Phaser.Plugins.ScenePlugin {\n\n    /** Screen inset by the device safe-area insets. The host sets `safeArea.margin*`. */\n    readonly safeArea: LayoutZone;\n\n    /** The full screen bounds (0,0 .. width,height). */\n    readonly screen: LayoutZone;\n\n    /**\n     * Event emitter that fires {@link LAYOUT_UPDATE_EVENT} after each resolution pass.\n     * Use `this.layout.events.on(\"layoutupdate\", ...)` \u2014 or the `on`/`once`/`off`\n     * delegates on the plugin itself.\n     */\n    readonly events: Phaser.Events.EventEmitter;\n\n    /**\n     * The active layout variant. `\"base\"` applies only the baseline; `\"portrait\"` /\n     * `\"landscape\"` apply their overrides on top of base. Defaults to `\"base\"`. Change\n     * it with {@link setVariant} (manual) or {@link autoVariant} (orientation-driven).\n     */\n    variant: VariantName = \"base\";\n\n    // Non-null scene reference captured at construction. `ScenePlugin.scene` /\n    // `ScenePlugin.systems` are typed as nullable; this avoids guarding every use.\n    private readonly _scene: Phaser.Scene;\n\n    // When true, the active variant follows the screen orientation on every resize.\n    private _auto = false;\n\n    // Injected design size, or null to use the live scene size (scale.gameSize).\n    private _designSize: { width: number; height: number } | null = null;\n\n    private readonly _objects: Set<Phaser.GameObjects.GameObject>;\n\n    // Scratch values reused across a pass to avoid allocations.\n    private readonly _rect: Phaser.Geom.Rectangle;\n    private readonly _mat: Phaser.GameObjects.Components.TransformMatrix;\n    private readonly _p1: Phaser.Math.Vector2;\n    private readonly _p2: Phaser.Math.Vector2;\n\n    constructor(\n        scene: Phaser.Scene,\n        pluginManager: Phaser.Plugins.PluginManager,\n        pluginKey: string\n    ) {\n        super(scene, pluginManager, pluginKey);\n\n        this._scene = scene;\n        this._objects = new Set();\n        this.events = new Phaser.Events.EventEmitter();\n\n        this.safeArea = new LayoutZone(scene, this);\n        this.screen = new LayoutZone(scene, this);\n\n        this._rect = new Phaser.Geom.Rectangle();\n        this._mat = new Phaser.GameObjects.Components.TransformMatrix();\n        this._p1 = new Phaser.Math.Vector2();\n        this._p2 = new Phaser.Math.Vector2();\n    }\n\n    boot(): void {\n\n        const events = this._scene.sys.events;\n\n        events.on(Phaser.Scenes.Events.CREATE, this.refresh, this);\n        events.on(Phaser.Scenes.Events.SHUTDOWN, this.shutdown, this);\n        events.once(Phaser.Scenes.Events.DESTROY, this.destroy, this);\n\n        this._scene.scale.on(Phaser.Scale.Events.RESIZE, this._onResize, this);\n    }\n\n    // ----- design size -----\n\n    /**\n     * The injected design size, or `null` when resolution follows the live scene size\n     * (`scale.gameSize`). Read by zones (the plugin is their {@link LayoutZone} provider).\n     */\n    get designSize(): { width: number; height: number } | null {\n\n        return this._designSize;\n    }\n\n    /**\n     * Resolve against a fixed design size (e.g. 1080\u00D71920) instead of the live canvas\n     * size, then re-resolve. Hosts that author/preview layouts at a target resolution\n     * (the editor) use this; games typically leave it unset and follow `scale.gameSize`.\n     */\n    setDesignSize(width: number, height: number): void {\n\n        this._designSize = { width, height };\n        this.refresh();\n    }\n\n    /** Clear the injected design size and fall back to the live scene size, then re-resolve. */\n    clearDesignSize(): void {\n\n        this._designSize = null;\n        this.refresh();\n    }\n\n    /** The effective size used for resolution: the injected design size, or the live game size. */\n    private _size(): { width: number; height: number } {\n\n        return this._designSize ?? this._scene.scale.gameSize;\n    }\n\n    // ----- variants -----\n\n    /** The screen's current orientation, derived from the effective design size. */\n    get orientation(): \"portrait\" | \"landscape\" {\n\n        const size = this._size();\n\n        return size.height > size.width ? \"portrait\" : \"landscape\";\n    }\n\n    /**\n     * Manually set the active variant and re-resolve. Turns off orientation\n     * auto-detection (see {@link autoVariant}).\n     */\n    setVariant(variant: VariantName): void {\n\n        this._auto = false;\n        this.variant = variant;\n        this.refresh();\n    }\n\n    /**\n     * Enable (or disable) orientation-driven variant selection. When enabled, the active\n     * variant follows {@link orientation} (`\"portrait\"` / `\"landscape\"`) on every resize.\n     * Disabling resets the variant to `\"base\"`.\n     */\n    autoVariant(enabled = true): void {\n\n        this._auto = enabled;\n        this.variant = enabled ? this.orientation : \"base\";\n        this.refresh();\n    }\n\n    private _onResize(): void {\n\n        if (this._auto) {\n\n            this.variant = this.orientation;\n        }\n\n        this.refresh();\n    }\n\n    // ----- objects -----\n\n    /**\n     * Enable layout for an object: attaches a default {@link AnchorLayoutData} as\n     * `obj.layoutData` (if it does not have one yet), registers the object for\n     * re-resolution, and returns the data so it can be configured.\n     *\n     * The `base` defaults are inert: `targetType: \"screen\"`, both anchors `\"none\"` and\n     * zero offsets, so the object does not move until you choose anchors. `portrait` and\n     * `landscape` start empty (they inherit `base`).\n     */\n    add<T extends Phaser.GameObjects.GameObject>(obj: T): AnchorLayoutData {\n\n        let data = obj.layoutData;\n\n        if (!data) {\n\n            data = {\n                enabled: true,\n                base: {\n                    targetType: \"screen\",\n                    horizontalAnchor: \"none\",\n                    horizontalOffset: 0,\n                    verticalAnchor: \"none\",\n                    verticalOffset: 0,\n                },\n                portrait: {},\n                landscape: {},\n            };\n\n            obj.layoutData = data;\n        }\n\n        this._objects.add(obj);\n\n        obj.once(Phaser.GameObjects.Events.DESTROY, this._onObjectDestroy, this);\n\n        return data;\n    }\n\n    /** Stop laying out an object and remove its `layoutData`. */\n    remove(obj: Phaser.GameObjects.GameObject): void {\n\n        this._objects.delete(obj);\n\n        obj.off(Phaser.GameObjects.Events.DESTROY, this._onObjectDestroy, this);\n\n        obj.layoutData = undefined;\n    }\n\n    private _onObjectDestroy(obj: Phaser.GameObjects.GameObject): void {\n\n        this._objects.delete(obj);\n    }\n\n    // ----- zones -----\n\n    /**\n     * Create a screen-relative zone. A factory only \u2014 the returned zone is not stored\n     * by the plugin; hold the reference and assign it to `data.targetZone`.\n     */\n    createZone(\n        marginTop = 0,\n        marginRight = 0,\n        marginBottom = 0,\n        marginLeft = 0\n    ): LayoutZone {\n\n        return new LayoutZone(this._scene, this, marginTop, marginRight, marginBottom, marginLeft);\n    }\n\n    // ----- resolution -----\n\n    /**\n     * Re-resolve every enabled object now. The plugin also runs this automatically on\n     * `scale` `resize` and once after the scene is created, so explicit calls are only\n     * needed after mutating layout data (or the `safeArea` margins) at run time.\n     *\n     * Objects are resolved parent \u2192 child so a child anchored to its parent's bounds\n     * sees the parent's already-resolved rect.\n     */\n    refresh(): void {\n\n        const list: Phaser.GameObjects.GameObject[] = [];\n\n        for (const obj of this._objects) {\n\n            const data = obj.layoutData;\n\n            if (data && data.enabled) {\n\n                list.push(obj);\n            }\n        }\n\n        list.sort((a, b) => this._depth(a) - this._depth(b));\n\n        for (const obj of list) {\n\n            this._resolve(obj);\n        }\n\n        this.events.emit(LAYOUT_UPDATE_EVENT);\n    }\n\n    /**\n     * Resolve a specific list of objects once, against the current variant / design size /\n     * zones, **without** registering them for future passes (no {@link add}, no re-resolve\n     * on resize). Hosts that drive resolution themselves \u2014 e.g. the editor's live preview \u2014\n     * set each object's `layoutData`, call this, then read back the resolved `x`/`y`.\n     *\n     * Objects are still resolved parent \u2192 child, and any object whose `layoutData` is\n     * missing or disabled is skipped.\n     */\n    resolveList(objects: Phaser.GameObjects.GameObject[]): void {\n\n        const list = objects.filter(obj => obj.layoutData && obj.layoutData.enabled);\n\n        list.sort((a, b) => this._depth(a) - this._depth(b));\n\n        for (const obj of list) {\n\n            this._resolve(obj);\n        }\n\n        this.events.emit(LAYOUT_UPDATE_EVENT);\n    }\n\n    private _depth(obj: Phaser.GameObjects.GameObject): number {\n\n        let depth = 0;\n        let parent = obj.parentContainer;\n\n        while (parent) {\n\n            depth++;\n            parent = parent.parentContainer;\n        }\n\n        return depth;\n    }\n\n    private _resolve(obj: Phaser.GameObjects.GameObject): void {\n\n        // `x`, `y`, `displayWidth`, origin, etc. live on transform/size/origin\n        // components, not on the GameObject base type.\n        const go = obj as any;\n        const data = obj.layoutData as AnchorLayoutData;\n\n        const originX = typeof go.originX === \"number\" ? go.originX : 0;\n        const originY = typeof go.originY === \"number\" ? go.originY : 0;\n\n        const eff = this._effective(data);\n\n        if (eff.targetType === \"parent\") {\n\n            this._resolveAgainstParent(go, eff, originX, originY);\n\n            return;\n        }\n\n        this._resolveAgainstZone(go, eff, originX, originY);\n    }\n\n    /** Merge the active variant's overrides over `base` into concrete anchor properties. */\n    private _effective(data: AnchorLayoutData): ResolvedAnchor {\n\n        const base = data.base;\n        const over = this.variant === \"base\" ? undefined : data[this.variant];\n\n        return {\n            targetType: over?.targetType ?? base.targetType ?? \"screen\",\n            targetZone: over?.targetZone ?? base.targetZone,\n            horizontalAnchor: over?.horizontalAnchor ?? base.horizontalAnchor ?? \"none\",\n            horizontalOffset: over?.horizontalOffset ?? base.horizontalOffset ?? 0,\n            verticalAnchor: over?.verticalAnchor ?? base.verticalAnchor ?? \"none\",\n            verticalOffset: over?.verticalOffset ?? base.verticalOffset ?? 0,\n        };\n    }\n\n    /** The zone a non-parent target resolves against. */\n    private _zoneFor(eff: ResolvedAnchor): LayoutZone {\n\n        switch (eff.targetType) {\n\n            case \"safeArea\":\n                return this.safeArea;\n\n            case \"custom\":\n                return eff.targetZone ?? this.screen;\n\n            default: // \"screen\"\n                return this.screen;\n        }\n    }\n\n    /** Resolve against a zone's world rect, converting to parent-local space if nested. */\n    private _resolveAgainstZone(\n        go: any,\n        eff: ResolvedAnchor,\n        originX: number,\n        originY: number\n    ): void {\n\n        const zone = this._zoneFor(eff);\n        const t = zone.getRect(this._rect);\n\n        const w = this._sizeX(go);\n        const h = this._sizeY(go);\n\n        const parent: Phaser.GameObjects.Container | null = go.parentContainer ?? null;\n\n        if (parent) {\n\n            // Work in world space, then convert the result into the parent's local space.\n            const m = parent.getWorldTransformMatrix(this._mat);\n            const cur = m.transformPoint(go.x, go.y, this._p1) as Phaser.Math.Vector2;\n\n            const wx = this._axis(eff.horizontalAnchor, cur.x, t.left, t.right, eff.horizontalOffset, w, originX);\n            const wy = this._axis(eff.verticalAnchor, cur.y, t.top, t.bottom, eff.verticalOffset, h, originY);\n\n            const local = m.applyInverse(wx, wy, this._p2) as Phaser.Math.Vector2;\n\n            go.x = local.x;\n            go.y = local.y;\n\n            return;\n        }\n\n        go.x = this._axis(eff.horizontalAnchor, go.x, t.left, t.right, eff.horizontalOffset, w, originX);\n        go.y = this._axis(eff.verticalAnchor, go.y, t.top, t.bottom, eff.verticalOffset, h, originY);\n    }\n\n    /** Resolve against the object's parent container bounds (local space), or the screen. */\n    private _resolveAgainstParent(\n        go: any,\n        eff: ResolvedAnchor,\n        originX: number,\n        originY: number\n    ): void {\n\n        const parent: Phaser.GameObjects.Container | null = go.parentContainer ?? null;\n\n        if (parent) {\n\n            // Children live in the parent's unscaled local space, with (0,0) at the\n            // container origin. Use the container's explicit size as the rect, and the\n            // child's local (unscaled-by-parent) size for edge alignment.\n            const right = (parent as any).width || 0;\n            const bottom = (parent as any).height || 0;\n\n            const w = (go.width || 0) * (typeof go.scaleX === \"number\" ? go.scaleX : 1);\n            const h = (go.height || 0) * (typeof go.scaleY === \"number\" ? go.scaleY : 1);\n\n            go.x = this._axis(eff.horizontalAnchor, go.x, 0, right, eff.horizontalOffset, w, originX);\n            go.y = this._axis(eff.verticalAnchor, go.y, 0, bottom, eff.verticalOffset, h, originY);\n\n            return;\n        }\n\n        // No parent container: fall back to the screen rect, in world space.\n        const size = this._size();\n        const w = this._sizeX(go);\n        const h = this._sizeY(go);\n\n        go.x = this._axis(eff.horizontalAnchor, go.x, 0, size.width, eff.horizontalOffset, w, originX);\n        go.y = this._axis(eff.verticalAnchor, go.y, 0, size.height, eff.verticalOffset, h, originY);\n    }\n\n    /**\n     * Resolve one axis. Aligns the object's edge/center to the target edge/center,\n     * accounting for the object's origin so `\"left\"`/`\"top\"` align the left/top edge,\n     * `\"center\"` the center, and `\"right\"`/`\"bottom\"` the right/bottom edge.\n     *\n     * Reduces to the documented `t.left + offset + size / 2` form for centered-origin\n     * objects (`origin = 0.5`).\n     */\n    private _axis(\n        anchor: string,\n        current: number,\n        min: number,\n        max: number,\n        offset: number,\n        size: number,\n        origin: number\n    ): number {\n\n        switch (anchor) {\n\n            case \"left\":\n            case \"top\":\n                return min + offset + origin * size;\n\n            case \"right\":\n            case \"bottom\":\n                return max + offset - (1 - origin) * size;\n\n            case \"center\":\n                return (min + max) / 2 + offset + (origin - 0.5) * size;\n\n            default: // \"none\"\n                return current;\n        }\n    }\n\n    private _sizeX(go: any): number {\n\n        if (typeof go.displayWidth === \"number\") {\n\n            return go.displayWidth;\n        }\n\n        return typeof go.width === \"number\" ? go.width : 0;\n    }\n\n    private _sizeY(go: any): number {\n\n        if (typeof go.displayHeight === \"number\") {\n\n            return go.displayHeight;\n        }\n\n        return typeof go.height === \"number\" ? go.height : 0;\n    }\n\n    // ----- event delegates -----\n\n    on(event: string | symbol, fn: (...args: any[]) => void, context?: any): this {\n\n        this.events.on(event, fn, context);\n\n        return this;\n    }\n\n    once(event: string | symbol, fn: (...args: any[]) => void, context?: any): this {\n\n        this.events.once(event, fn, context);\n\n        return this;\n    }\n\n    off(event: string | symbol, fn?: (...args: any[]) => void, context?: any, once?: boolean): this {\n\n        this.events.off(event, fn, context, once);\n\n        return this;\n    }\n\n    // ----- lifecycle -----\n\n    shutdown(): void {\n\n        const events = this._scene.sys.events;\n\n        events.off(Phaser.Scenes.Events.CREATE, this.refresh, this);\n        events.off(Phaser.Scenes.Events.SHUTDOWN, this.shutdown, this);\n\n        this._scene.scale.off(Phaser.Scale.Events.RESIZE, this._onResize, this);\n\n        this._objects.clear();\n    }\n\n    destroy(): void {\n\n        this.shutdown();\n\n        this.events.destroy();\n\n        super.destroy();\n    }\n}\n", "import Phaser from \"phaser\";\nimport type { VariantName } from \"./types\";\n\n/** The four screen-edge insets that define a zone, in scene/world pixels. */\nexport interface ZoneMargins {\n    marginTop: number;\n    marginRight: number;\n    marginBottom: number;\n    marginLeft: number;\n}\n\n/** Minimal view of the plugin that supplies the active variant and design size. */\nexport interface VariantProvider {\n    readonly variant: VariantName;\n\n    /**\n     * The design size the zones inset from, or `null` to use the live scene size\n     * (`scene.scale.gameSize`). A host (e.g. the editor) can inject a fixed design size\n     * to resolve against a target resolution instead of the current canvas size.\n     */\n    readonly designSize: { width: number; height: number } | null;\n}\n\n/**\n * A screen-relative rectangle defined by an inset (margin) from each screen edge.\n *\n * Margins are split into variants: `base` is the baseline (all four sides), and\n * `portrait` / `landscape` are partial overrides \u2014 any side left unset inherits from\n * `base`. The active variant follows the plugin (see {@link VariantProvider}), so a\n * zone's rect can differ per orientation.\n *\n * The rect is computed **lazily** via {@link LayoutZone.getRect} from the current screen\n * size and the effective margins, so the plugin never has to store or iterate zones.\n *\n * The built-in `safeArea` zone is just a `LayoutZone` whose margins are the\n * device-provided insets (notch / home indicator); `screen` is a `LayoutZone` with all\n * margins at 0.\n */\nexport class LayoutZone {\n\n    /** Baseline margins (all four sides). */\n    base: ZoneMargins;\n\n    /** Margin overrides applied when the active variant is `\"portrait\"`. */\n    portrait: Partial<ZoneMargins>;\n\n    /** Margin overrides applied when the active variant is `\"landscape\"`. */\n    landscape: Partial<ZoneMargins>;\n\n    private readonly scene: Phaser.Scene;\n    private readonly provider: VariantProvider;\n\n    constructor(\n        scene: Phaser.Scene,\n        provider: VariantProvider,\n        marginTop = 0,\n        marginRight = 0,\n        marginBottom = 0,\n        marginLeft = 0\n    ) {\n        this.scene = scene;\n        this.provider = provider;\n        this.base = { marginTop, marginRight, marginBottom, marginLeft };\n        this.portrait = {};\n        this.landscape = {};\n    }\n\n    /** Effective value of one margin side under the active variant. */\n    private _margin(side: keyof ZoneMargins): number {\n\n        const variant = this.provider.variant;\n\n        if (variant !== \"base\") {\n\n            const override = (this[variant] as Partial<ZoneMargins>)[side];\n\n            if (override !== undefined) {\n\n                return override;\n            }\n        }\n\n        return this.base[side];\n    }\n\n    /**\n     * The effective rectangle at the current screen size and active variant. Pass an\n     * `out` rectangle to avoid allocations.\n     */\n    getRect(out?: Phaser.Geom.Rectangle): Phaser.Geom.Rectangle {\n\n        const size = this.provider.designSize ?? this.scene.scale.gameSize;\n\n        const x = this._margin(\"marginLeft\");\n        const y = this._margin(\"marginTop\");\n        const width = size.width - x - this._margin(\"marginRight\");\n        const height = size.height - y - this._margin(\"marginBottom\");\n\n        if (out) {\n\n            out.setTo(x, y, width, height);\n\n            return out;\n        }\n\n        return new Phaser.Geom.Rectangle(x, y, width, height);\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["import_phaser", "Phaser", "Phaser", "w", "h"]
+}

package/dist/phaser-editor-layout.min.js

@@ -0,0 +1 @@
+"use strict";var PhaserEditorLayout=(()=>{var w=Object.create;var f=Object.defineProperty;var S=Object.getOwnPropertyDescriptor;var E=Object.getOwnPropertyNames;var j=Object.getPrototypeOf,G=Object.prototype.hasOwnProperty;var D=(o,s)=>()=>{try{return s||o((s={exports:{}}).exports,s),s.exports}catch(e){throw s=0,e}},R=(o,s)=>{for(var e in s)f(o,e,{get:s[e],enumerable:!0})},z=(o,s,e,t)=>{if(s&&typeof s=="object"||typeof s=="function")for(let r of E(s))!G.call(o,r)&&r!==e&&f(o,r,{get:()=>s[r],enumerable:!(t=S(s,r))||t.enumerable});return o};var P=(o,s,e)=>(e=o!=null?w(j(o)):{},z(s||!o||!o.__esModule?f(e,"default",{value:o,enumerable:!0}):e,o)),Z=o=>z(f({},"__esModule",{value:!0}),o);var O=D((M,x)=>{x.exports=globalThis.Phaser});var V={};R(V,{LAYOUT_UPDATE_EVENT:()=>_,LayoutPlugin:()=>g,LayoutZone:()=>m});var h=P(O(),1);var T=P(O(),1),m=class{constructor(s,e,t=0,r=0,n=0,i=0){this.scene=s,this.provider=e,this.base={marginTop:t,marginRight:r,marginBottom:n,marginLeft:i},this.portrait={},this.landscape={}}_margin(s){let e=this.provider.variant;if(e!=="base"){let t=this[e][s];if(t!==void 0)return t}return this.base[s]}getRect(s){var a;let e=(a=this.provider.designSize)!=null?a:this.scene.scale.gameSize,t=this._margin("marginLeft"),r=this._margin("marginTop"),n=e.width-t-this._margin("marginRight"),i=e.height-r-this._margin("marginBottom");return s?(s.setTo(t,r,n,i),s):new T.default.Geom.Rectangle(t,r,n,i)}};var _="layoutupdate",g=class extends h.default.Plugins.ScenePlugin{constructor(e,t,r){super(e,t,r);this.variant="base";this._auto=!1;this._designSize=null;this._scene=e,this._objects=new Set,this.events=new h.default.Events.EventEmitter,this.safeArea=new m(e,this),this.screen=new m(e,this),this._rect=new h.default.Geom.Rectangle,this._mat=new h.default.GameObjects.Components.TransformMatrix,this._p1=new h.default.Math.Vector2,this._p2=new h.default.Math.Vector2}boot(){let e=this._scene.sys.events;e.on(h.default.Scenes.Events.CREATE,this.refresh,this),e.on(h.default.Scenes.Events.SHUTDOWN,this.shutdown,this),e.once(h.default.Scenes.Events.DESTROY,this.destroy,this),this._scene.scale.on(h.default.Scale.Events.RESIZE,this._onResize,this)}get designSize(){return this._designSize}setDesignSize(e,t){this._designSize={width:e,height:t},this.refresh()}clearDesignSize(){this._designSize=null,this.refresh()}_size(){var e;return(e=this._designSize)!=null?e:this._scene.scale.gameSize}get orientation(){let e=this._size();return e.height>e.width?"portrait":"landscape"}setVariant(e){this._auto=!1,this.variant=e,this.refresh()}autoVariant(e=!0){this._auto=e,this.variant=e?this.orientation:"base",this.refresh()}_onResize(){this._auto&&(this.variant=this.orientation),this.refresh()}add(e){let t=e.layoutData;return t||(t={enabled:!0,base:{targetType:"screen",horizontalAnchor:"none",horizontalOffset:0,verticalAnchor:"none",verticalOffset:0},portrait:{},landscape:{}},e.layoutData=t),this._objects.add(e),e.once(h.default.GameObjects.Events.DESTROY,this._onObjectDestroy,this),t}remove(e){this._objects.delete(e),e.off(h.default.GameObjects.Events.DESTROY,this._onObjectDestroy,this),e.layoutData=void 0}_onObjectDestroy(e){this._objects.delete(e)}createZone(e=0,t=0,r=0,n=0){return new m(this._scene,this,e,t,r,n)}refresh(){let e=[];for(let t of this._objects){let r=t.layoutData;r&&r.enabled&&e.push(t)}e.sort((t,r)=>this._depth(t)-this._depth(r));for(let t of e)this._resolve(t);this.events.emit(_)}resolveList(e){let t=e.filter(r=>r.layoutData&&r.layoutData.enabled);t.sort((r,n)=>this._depth(r)-this._depth(n));for(let r of t)this._resolve(r);this.events.emit(_)}_depth(e){let t=0,r=e.parentContainer;for(;r;)t++,r=r.parentContainer;return t}_resolve(e){let t=e,r=e.layoutData,n=typeof t.originX=="number"?t.originX:0,i=typeof t.originY=="number"?t.originY:0,a=this._effective(r);if(a.targetType==="parent"){this._resolveAgainstParent(t,a,n,i);return}this._resolveAgainstZone(t,a,n,i)}_effective(e){var n,i,a,c,u,l,p,d,v,y,b;let t=e.base,r=this.variant==="base"?void 0:e[this.variant];return{targetType:(i=(n=r==null?void 0:r.targetType)!=null?n:t.targetType)!=null?i:"screen",targetZone:(a=r==null?void 0:r.targetZone)!=null?a:t.targetZone,horizontalAnchor:(u=(c=r==null?void 0:r.horizontalAnchor)!=null?c:t.horizontalAnchor)!=null?u:"none",horizontalOffset:(p=(l=r==null?void 0:r.horizontalOffset)!=null?l:t.horizontalOffset)!=null?p:0,verticalAnchor:(v=(d=r==null?void 0:r.verticalAnchor)!=null?d:t.verticalAnchor)!=null?v:"none",verticalOffset:(b=(y=r==null?void 0:r.verticalOffset)!=null?y:t.verticalOffset)!=null?b:0}}_zoneFor(e){var t;switch(e.targetType){case"safeArea":return this.safeArea;case"custom":return(t=e.targetZone)!=null?t:this.screen;default:return this.screen}}_resolveAgainstZone(e,t,r,n){var p;let a=this._zoneFor(t).getRect(this._rect),c=this._sizeX(e),u=this._sizeY(e),l=(p=e.parentContainer)!=null?p:null;if(l){let d=l.getWorldTransformMatrix(this._mat),v=d.transformPoint(e.x,e.y,this._p1),y=this._axis(t.horizontalAnchor,v.x,a.left,a.right,t.horizontalOffset,c,r),b=this._axis(t.verticalAnchor,v.y,a.top,a.bottom,t.verticalOffset,u,n),A=d.applyInverse(y,b,this._p2);e.x=A.x,e.y=A.y;return}e.x=this._axis(t.horizontalAnchor,e.x,a.left,a.right,t.horizontalOffset,c,r),e.y=this._axis(t.verticalAnchor,e.y,a.top,a.bottom,t.verticalOffset,u,n)}_resolveAgainstParent(e,t,r,n){var l;let i=(l=e.parentContainer)!=null?l:null;if(i){let p=i.width||0,d=i.height||0,v=(e.width||0)*(typeof e.scaleX=="number"?e.scaleX:1),y=(e.height||0)*(typeof e.scaleY=="number"?e.scaleY:1);e.x=this._axis(t.horizontalAnchor,e.x,0,p,t.horizontalOffset,v,r),e.y=this._axis(t.verticalAnchor,e.y,0,d,t.verticalOffset,y,n);return}let a=this._size(),c=this._sizeX(e),u=this._sizeY(e);e.x=this._axis(t.horizontalAnchor,e.x,0,a.width,t.horizontalOffset,c,r),e.y=this._axis(t.verticalAnchor,e.y,0,a.height,t.verticalOffset,u,n)}_axis(e,t,r,n,i,a,c){switch(e){case"left":case"top":return r+i+c*a;case"right":case"bottom":return n+i-(1-c)*a;case"center":return(r+n)/2+i+(c-.5)*a;default:return t}}_sizeX(e){return typeof e.displayWidth=="number"?e.displayWidth:typeof e.width=="number"?e.width:0}_sizeY(e){return typeof e.displayHeight=="number"?e.displayHeight:typeof e.height=="number"?e.height:0}on(e,t,r){return this.events.on(e,t,r),this}once(e,t,r){return this.events.once(e,t,r),this}off(e,t,r,n){return this.events.off(e,t,r,n),this}shutdown(){let e=this._scene.sys.events;e.off(h.default.Scenes.Events.CREATE,this.refresh,this),e.off(h.default.Scenes.Events.SHUTDOWN,this.shutdown,this),this._scene.scale.off(h.default.Scale.Events.RESIZE,this._onResize,this),this._objects.clear()}destroy(){this.shutdown(),this.events.destroy(),super.destroy()}};return Z(V);})();

package/dist/types.d.ts

@@ -0,0 +1,79 @@
+import type { LayoutZone } from "./LayoutZone";
+import type { LayoutPlugin } from "./LayoutPlugin";
+/** Horizontal anchor edge. `"none"` leaves that axis as the raw `x`. */
+export type HAnchor = "left" | "center" | "right" | "none";
+/** Vertical anchor edge. `"none"` leaves that axis as the raw `y`. */
+export type VAnchor = "top" | "center" | "bottom" | "none";
+/**
+ * What an object anchors to:
+ * - `"screen"`   — the full screen bounds (the built-in `screen` zone).
+ * - `"safeArea"` — the device safe area (the built-in `safeArea` zone).
+ * - `"parent"`   — the object's own parent container bounds (per-object, not a shared zone).
+ * - `"custom"`   — a user-defined zone, referenced by `targetZone`.
+ *
+ * The built-in targets (`"screen"` / `"safeArea"`) name their zone directly, so only
+ * `"custom"` needs a `targetZone` reference.
+ */
+export type TargetType = "screen" | "safeArea" | "parent" | "custom";
+/**
+ * Layout variants. `"base"` is the always-applied baseline; `"portrait"` / `"landscape"`
+ * are overrides selected by orientation. See {@link LayoutPlugin.variant}.
+ */
+export type VariantName = "base" | "portrait" | "landscape";
+/**
+ * The anchor properties for one variant. On `base` these hold the full baseline; on
+ * `portrait` / `landscape` only the fields that differ are set — unset fields inherit
+ * from `base`.
+ */
+export interface AnchorProps {
+    targetType?: TargetType;
+    /** The zone to anchor to when `targetType === "custom"` (a zone object, never an id). */
+    targetZone?: LayoutZone;
+    horizontalAnchor?: HAnchor;
+    horizontalOffset?: number;
+    verticalAnchor?: VAnchor;
+    verticalOffset?: number;
+}
+/**
+ * Per-object layout state. Created by `this.layout.add(obj)` and stored as
+ * `obj.layoutData`. Mutate its fields directly; changes apply on the next layout pass
+ * (a `scale` `resize`) or when `this.layout.refresh()` is called.
+ *
+ * The anchor properties are split into variants: set `base` for the default layout and
+ * `portrait` / `landscape` for orientation-specific overrides. The resolver uses
+ * `active[prop] ?? base[prop]`, where the active variant follows
+ * {@link LayoutPlugin.variant}.
+ *
+ * ```ts
+ * data.base.targetType = "safeArea";
+ * data.base.horizontalAnchor = "center";
+ * data.portrait.verticalAnchor = "bottom";
+ * data.landscape.horizontalAnchor = "right";
+ * ```
+ */
+export interface AnchorLayoutData {
+    /**
+     * When false, the object keeps its raw x/y and is skipped by the resolver — this
+     * is the "Absolute" mode (no anchoring) for that object.
+     */
+    enabled: boolean;
+    /** Baseline anchor properties; the resolver falls back here for unset variant fields. */
+    base: AnchorProps;
+    /** Overrides applied when the active variant is `"portrait"`. */
+    portrait: AnchorProps;
+    /** Overrides applied when the active variant is `"landscape"`. */
+    landscape: AnchorProps;
+}
+declare global {
+    namespace Phaser {
+        interface Scene {
+            layout: LayoutPlugin;
+        }
+        namespace GameObjects {
+            interface GameObject {
+                layoutData?: AnchorLayoutData;
+            }
+        }
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,wEAAwE;AACxE,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAE3D,sEAAsE;AACtE,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,yFAAyF;IACzF,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,gBAAgB;IAE7B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB,yFAAyF;IACzF,IAAI,EAAE,WAAW,CAAC;IAElB,iEAAiE;IACjE,QAAQ,EAAE,WAAW,CAAC;IAEtB,kEAAkE;IAClE,SAAS,EAAE,WAAW,CAAC;CAC1B;AAED,OAAO,CAAC,MAAM,CAAC;IAGX,UAAU,MAAM,CAAC;QAIb,UAAU,KAAK;YACX,MAAM,EAAE,YAAY,CAAC;SACxB;QAGD,UAAU,WAAW,CAAC;YAIlB,UAAU,UAAU;gBAChB,UAAU,CAAC,EAAE,gBAAgB,CAAC;aACjC;SACJ;KACJ;CACJ"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}