@rpgjs/client 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/services/actionInput.d.ts

@@ -0,0 +1,14 @@
+import { Direction, RpgActionInput, RpgActionName } from '@rpgjs/common';
+export type KeyboardActionDataResolver<TClient = any, TSprite = any> = (client: TClient, sprite: TSprite) => any;
+export interface KeyboardActionConfig<TClient = any, TSprite = any> {
+    bind: any;
+    action?: RpgActionName;
+    data?: any | KeyboardActionDataResolver<TClient, TSprite>;
+}
+export declare function normalizeActionInput(action: RpgActionName, data?: any): RpgActionInput;
+export declare function normalizeActionInput(action: RpgActionInput): RpgActionInput;
+export declare function isKeyboardActionConfig(value: any): value is KeyboardActionConfig;
+export declare function getKeyboardControlBind(control: any): any;
+export declare function keyboardEventMatchesBind(event: KeyboardEvent, bind: any): boolean;
+export declare function resolveKeyboardActionInput(control: any, client: any, sprite: any, defaultAction?: RpgActionName): RpgActionInput;
+export declare function resolveKeyboardDirectionInput(event: KeyboardEvent, keyboardControls: any): Direction | undefined;

package/dist/services/actionInput.js

@@ -0,0 +1,59 @@
+import { Direction } from "@rpgjs/common";
+//#region src/services/actionInput.ts
+function normalizeActionInput(action, data) {
+	if (typeof action === "object") return action;
+	return data === void 0 ? { action } : {
+		action,
+		data
+	};
+}
+function isKeyboardActionConfig(value) {
+	return value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "bind");
+}
+function getKeyboardControlBind(control) {
+	return isKeyboardActionConfig(control) ? control.bind : control;
+}
+var KEY_CODE_NAMES = {
+	32: "space",
+	27: "escape",
+	37: "left",
+	38: "up",
+	39: "right",
+	40: "down"
+};
+var normalizeKeyboardName = (value) => {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.toLowerCase();
+	if (normalized === " " || normalized === "spacebar" || normalized === "space") return "space";
+	if (normalized.startsWith("arrow")) return normalized.slice(5);
+	return normalized;
+};
+function keyboardEventMatchesBind(event, bind) {
+	if (Array.isArray(bind)) return bind.some((item) => keyboardEventMatchesBind(event, item));
+	if (typeof bind === "number") return event.keyCode === bind;
+	const expected = normalizeKeyboardName(bind);
+	if (!expected) return false;
+	return normalizeKeyboardName(event.key) === expected || normalizeKeyboardName(event.code) === expected || KEY_CODE_NAMES[event.keyCode] === expected;
+}
+function resolveKeyboardActionInput(control, client, sprite, defaultAction = "action") {
+	if (!isKeyboardActionConfig(control)) return { action: defaultAction };
+	const action = control.action ?? defaultAction;
+	const data = typeof control.data === "function" ? control.data(client, sprite) : control.data;
+	return data === void 0 ? { action } : {
+		action,
+		data
+	};
+}
+function resolveKeyboardDirectionInput(event, keyboardControls) {
+	const directions = [
+		[keyboardControls?.up, Direction.Up],
+		[keyboardControls?.down, Direction.Down],
+		[keyboardControls?.left, Direction.Left],
+		[keyboardControls?.right, Direction.Right]
+	];
+	for (const [control, direction] of directions) if (keyboardEventMatchesBind(event, getKeyboardControlBind(control))) return direction;
+}
+//#endregion
+export { getKeyboardControlBind, isKeyboardActionConfig, keyboardEventMatchesBind, normalizeActionInput, resolveKeyboardActionInput, resolveKeyboardDirectionInput };
+
+//# sourceMappingURL=actionInput.js.map

package/dist/services/actionInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionInput.js","names":[],"sources":["../../src/services/actionInput.ts"],"sourcesContent":["import { Direction, type RpgActionInput, type RpgActionName } from \"@rpgjs/common\";\n\nexport type KeyboardActionDataResolver<TClient = any, TSprite = any> = (\n  client: TClient,\n  sprite: TSprite,\n) => any;\n\nexport interface KeyboardActionConfig<TClient = any, TSprite = any> {\n  bind: any;\n  action?: RpgActionName;\n  data?: any | KeyboardActionDataResolver<TClient, TSprite>;\n}\n\nexport function normalizeActionInput(action: RpgActionName, data?: any): RpgActionInput;\nexport function normalizeActionInput(action: RpgActionInput): RpgActionInput;\nexport function normalizeActionInput(action: RpgActionName | RpgActionInput, data?: any): RpgActionInput {\n  if (typeof action === \"object\") {\n    return action;\n  }\n  return data === undefined\n    ? { action }\n    : { action, data };\n}\n\nexport function isKeyboardActionConfig(value: any): value is KeyboardActionConfig {\n  return value !== null\n    && typeof value === \"object\"\n    && Object.prototype.hasOwnProperty.call(value, \"bind\");\n}\n\nexport function getKeyboardControlBind(control: any): any {\n  return isKeyboardActionConfig(control) ? control.bind : control;\n}\n\nconst KEY_CODE_NAMES: Record<number, string> = {\n  32: \"space\",\n  27: \"escape\",\n  37: \"left\",\n  38: \"up\",\n  39: \"right\",\n  40: \"down\",\n};\n\nconst normalizeKeyboardName = (value: unknown): string | undefined => {\n  if (typeof value !== \"string\") return undefined;\n  const normalized = value.toLowerCase();\n  if (\n    normalized === \" \" ||\n    normalized === \"spacebar\" ||\n    normalized === \"space\"\n  ) {\n    return \"space\";\n  }\n  if (normalized.startsWith(\"arrow\")) {\n    return normalized.slice(\"arrow\".length);\n  }\n  return normalized;\n};\n\nexport function keyboardEventMatchesBind(\n  event: KeyboardEvent,\n  bind: any\n): boolean {\n  if (Array.isArray(bind)) {\n    return bind.some(item => keyboardEventMatchesBind(event, item));\n  }\n\n  if (typeof bind === \"number\") {\n    return event.keyCode === bind;\n  }\n\n  const expected = normalizeKeyboardName(bind);\n  if (!expected) return false;\n\n  return (\n    normalizeKeyboardName(event.key) === expected ||\n    normalizeKeyboardName(event.code) === expected ||\n    KEY_CODE_NAMES[event.keyCode] === expected\n  );\n}\n\nexport function resolveKeyboardActionInput(\n  control: any,\n  client: any,\n  sprite: any,\n  defaultAction: RpgActionName = \"action\",\n): RpgActionInput {\n  if (!isKeyboardActionConfig(control)) {\n    return { action: defaultAction };\n  }\n\n  const action = control.action ?? defaultAction;\n  const data = typeof control.data === \"function\"\n    ? control.data(client, sprite)\n    : control.data;\n\n  return data === undefined\n    ? { action }\n    : { action, data };\n}\n\nexport function resolveKeyboardDirectionInput(\n  event: KeyboardEvent,\n  keyboardControls: any\n): Direction | undefined {\n  const directions: Array<[any, Direction]> = [\n    [keyboardControls?.up, Direction.Up],\n    [keyboardControls?.down, Direction.Down],\n    [keyboardControls?.left, Direction.Left],\n    [keyboardControls?.right, Direction.Right],\n  ];\n\n  for (const [control, direction] of directions) {\n    if (keyboardEventMatchesBind(event, getKeyboardControlBind(control))) {\n      return direction;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":";;AAeA,SAAgB,qBAAqB,QAAwC,MAA4B;CACvG,IAAI,OAAO,WAAW,UACpB,OAAO;CAET,OAAO,SAAS,KAAA,IACZ,EAAE,OAAO,IACT;EAAE;EAAQ;CAAK;AACrB;AAEA,SAAgB,uBAAuB,OAA2C;CAChF,OAAO,UAAU,QACZ,OAAO,UAAU,YACjB,OAAO,UAAU,eAAe,KAAK,OAAO,MAAM;AACzD;AAEA,SAAgB,uBAAuB,SAAmB;CACxD,OAAO,uBAAuB,OAAO,IAAI,QAAQ,OAAO;AAC1D;AAEA,IAAM,iBAAyC;CAC7C,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;AACN;AAEA,IAAM,yBAAyB,UAAuC;CACpE,IAAI,OAAO,UAAU,UAAU,OAAO,KAAA;CACtC,MAAM,aAAa,MAAM,YAAY;CACrC,IACE,eAAe,OACf,eAAe,cACf,eAAe,SAEf,OAAO;CAET,IAAI,WAAW,WAAW,OAAO,GAC/B,OAAO,WAAW,MAAM,CAAc;CAExC,OAAO;AACT;AAEA,SAAgB,yBACd,OACA,MACS;CACT,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,KAAK,MAAK,SAAQ,yBAAyB,OAAO,IAAI,CAAC;CAGhE,IAAI,OAAO,SAAS,UAClB,OAAO,MAAM,YAAY;CAG3B,MAAM,WAAW,sBAAsB,IAAI;CAC3C,IAAI,CAAC,UAAU,OAAO;CAEtB,OACE,sBAAsB,MAAM,GAAG,MAAM,YACrC,sBAAsB,MAAM,IAAI,MAAM,YACtC,eAAe,MAAM,aAAa;AAEtC;AAEA,SAAgB,2BACd,SACA,QACA,QACA,gBAA+B,UACf;CAChB,IAAI,CAAC,uBAAuB,OAAO,GACjC,OAAO,EAAE,QAAQ,cAAc;CAGjC,MAAM,SAAS,QAAQ,UAAU;CACjC,MAAM,OAAO,OAAO,QAAQ,SAAS,aACjC,QAAQ,KAAK,QAAQ,MAAM,IAC3B,QAAQ;CAEZ,OAAO,SAAS,KAAA,IACZ,EAAE,OAAO,IACT;EAAE;EAAQ;CAAK;AACrB;AAEA,SAAgB,8BACd,OACA,kBACuB;CACvB,MAAM,aAAsC;EAC1C,CAAC,kBAAkB,IAAI,UAAU,EAAE;EACnC,CAAC,kBAAkB,MAAM,UAAU,IAAI;EACvC,CAAC,kBAAkB,MAAM,UAAU,IAAI;EACvC,CAAC,kBAAkB,OAAO,UAAU,KAAK;CAC3C;CAEA,KAAK,MAAM,CAAC,SAAS,cAAc,YACjC,IAAI,yBAAyB,OAAO,uBAAuB,OAAO,CAAC,GACjE,OAAO;AAKb"}

package/dist/services/actionInput.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/interactions.d.ts

@@ -0,0 +1,159 @@
+import { RpgActionInput, RpgActionName } from '@rpgjs/common';
+import { RpgClientEngine } from '../RpgClientEngine';
+export type RpgInteractionEventName = "pointerenter" | "pointerleave" | "pointerover" | "pointerout" | "pointerdown" | "pointerup" | "pointermove" | "click" | "dragstart" | "dragmove" | "drop" | "cancel";
+export type RpgInteractionPosition = {
+    x: number;
+    y: number;
+};
+export type RpgInteractionBounds = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+    contains(point: RpgInteractionPosition | null | undefined): boolean;
+};
+export type RpgInteractionBoundsSet = {
+    bounds?: RpgInteractionBounds;
+    hitbox?: RpgInteractionBounds;
+    graphic?: RpgInteractionBounds;
+    [key: string]: RpgInteractionBounds | undefined;
+};
+export type RpgInteractionTile = {
+    x: number;
+    y: number;
+    worldX: number;
+    worldY: number;
+    width: number;
+    height: number;
+};
+export type RpgInteractionState = {
+    hovered: boolean;
+    pressed: boolean;
+    selected: boolean;
+    dragging: boolean;
+    data: Record<string, any>;
+    overlays: Record<string, RpgInteractionOverlay>;
+};
+export type RpgInteractionOverlay = {
+    component: any;
+    props?: Record<string, any>;
+};
+export type RpgInteractionMatcher = string | ((ctx: RpgInteractionMatcherContext) => boolean);
+export type RpgInteractionMatcherContext = {
+    client: RpgClientEngine;
+    target: any;
+    sprite: any;
+};
+export type RpgInteractionHandler = (ctx: RpgInteractionContext) => void;
+export type RpgInteractionBehavior = {
+    component?: any;
+    props?: Record<string, any> | ((ctx: RpgInteractionContext) => Record<string, any>);
+    dependencies?: any[] | ((ctx: RpgInteractionContext) => any[]);
+    cursor?: string | ((ctx: RpgInteractionContext) => string | undefined);
+    hitTest?: (ctx: RpgInteractionContext) => boolean;
+    pointerenter?: RpgInteractionHandler;
+    pointerleave?: RpgInteractionHandler;
+    pointerover?: RpgInteractionHandler;
+    pointerout?: RpgInteractionHandler;
+    pointerdown?: RpgInteractionHandler;
+    pointerup?: RpgInteractionHandler;
+    pointermove?: RpgInteractionHandler;
+    click?: RpgInteractionHandler;
+    dragstart?: RpgInteractionHandler;
+    dragmove?: RpgInteractionHandler;
+    drop?: RpgInteractionHandler;
+    cancel?: RpgInteractionHandler;
+};
+export type RpgInteractionComponentEntry = {
+    component: any;
+    props: Record<string, any>;
+    dependencies: any[];
+};
+export type RpgInteractionContext = {
+    client: RpgClientEngine;
+    target: any;
+    sprite: any;
+    event?: any;
+    behavior: RpgInteractionBehavior;
+    behaviorId: string;
+    pointer: {
+        screen(): RpgInteractionPosition | null;
+        world(): RpgInteractionPosition | null;
+        tile(): RpgInteractionTile | null;
+    };
+    bounds(kind?: string): RpgInteractionBounds;
+    state: {
+        value(): RpgInteractionState;
+        get<T = any>(key: string): T | undefined;
+        set(key: string, value: any): void;
+        patch(patch: Partial<Omit<RpgInteractionState, "data" | "overlays">>): void;
+    };
+    overlay: {
+        render(component: any, props?: Record<string, any>): void;
+        update(props?: Record<string, any>): void;
+        clear(): void;
+    };
+    select(selected?: boolean): void;
+    action(action: RpgActionName, data?: any): void;
+    action(input: RpgActionInput): void;
+    cancel(): void;
+};
+type InteractionEventInput = {
+    event?: any;
+    bounds?: RpgInteractionBoundsSet;
+};
+export declare class RpgClientInteractions {
+    private client;
+    private registrations;
+    private states;
+    private activeDrag?;
+    private nextId;
+    constructor(client: RpgClientEngine);
+    use(matcher: RpgInteractionMatcher, behavior: RpgInteractionBehavior | any): () => void;
+    getState(sprite: any): RpgInteractionState;
+    getRenderedComponents(sprite: any, bounds?: RpgInteractionBoundsSet): RpgInteractionComponentEntry[];
+    cursorFor(sprite: any, bounds?: RpgInteractionBoundsSet): string | undefined;
+    handle(sprite: any, type: RpgInteractionEventName, input?: InteractionEventInput): void;
+    handlePointerMove(event?: any): void;
+    handlePointerUp(event?: any): void;
+    cancelDrag(event?: any): void;
+    private getMatches;
+    private matches;
+    private createContext;
+    private callHandler;
+    private passesHitTest;
+    private isDraggable;
+    private defaultComponentProps;
+    private resolveProps;
+    private resolveDependencies;
+    private getSpriteId;
+    private patchState;
+    private patchStateData;
+    private patchOverlay;
+    private updateOverlay;
+    private clearOverlay;
+    private getPointerTile;
+}
+export declare function hoverPopover(component: any, props?: Record<string, any>): RpgInteractionBehavior;
+export declare function selectable(options?: {
+    cursor?: string;
+    onSelect?: RpgInteractionHandler;
+}): RpgInteractionBehavior;
+export declare function draggable(options?: {
+    cursor?: string;
+    start?: RpgInteractionHandler;
+    move?: RpgInteractionHandler;
+    drop?: RpgInteractionHandler;
+    cancel?: RpgInteractionHandler;
+}): RpgInteractionBehavior;
+export declare function dragToTile(options: {
+    action?: RpgActionName;
+    data?: (ctx: RpgInteractionContext) => any;
+    onDrop?: RpgInteractionHandler;
+    cursor?: string;
+}): RpgInteractionBehavior;
+export {};

package/dist/services/interactions.js

@@ -0,0 +1,460 @@
+import { signal } from "canvasengine";
+//#region src/services/interactions.ts
+var DEFAULT_STATE = {
+	hovered: false,
+	pressed: false,
+	selected: false,
+	dragging: false,
+	data: {},
+	overlays: {}
+};
+function readValue(value) {
+	return typeof value === "function" ? value() : value;
+}
+function createBounds(value) {
+	const left = Number(value?.left ?? value?.x ?? 0);
+	const top = Number(value?.top ?? value?.y ?? 0);
+	const width = Number(value?.width ?? value?.w ?? 0);
+	const height = Number(value?.height ?? value?.h ?? 0);
+	const right = Number(value?.right ?? left + width);
+	const bottom = Number(value?.bottom ?? top + height);
+	const resolvedWidth = Number.isFinite(width) && width > 0 ? width : Math.max(0, right - left);
+	const resolvedHeight = Number.isFinite(height) && height > 0 ? height : Math.max(0, bottom - top);
+	return {
+		left,
+		top,
+		right,
+		bottom,
+		width: resolvedWidth,
+		height: resolvedHeight,
+		centerX: Number(value?.centerX ?? left + resolvedWidth / 2),
+		centerY: Number(value?.centerY ?? top + resolvedHeight / 2),
+		contains(point) {
+			if (!point) return false;
+			return point.x >= left && point.x <= right && point.y >= top && point.y <= bottom;
+		}
+	};
+}
+function normalizeBounds(bounds) {
+	if (!bounds) return {};
+	return Object.entries(bounds).reduce((next, [key, value]) => {
+		if (value) next[key] = createBounds(value);
+		return next;
+	}, {});
+}
+function readNumber(value, fallback = 0) {
+	const resolved = readValue(value);
+	const number = Number(resolved);
+	return Number.isFinite(number) ? number : fallback;
+}
+function offsetBounds(bounds, x, y) {
+	return createBounds({
+		left: bounds.left + x,
+		top: bounds.top + y,
+		right: bounds.right + x,
+		bottom: bounds.bottom + y,
+		width: bounds.width,
+		height: bounds.height,
+		centerX: bounds.centerX + x,
+		centerY: bounds.centerY + y
+	});
+}
+function toWorldBounds(sprite, bounds) {
+	const x = readNumber(sprite?.x);
+	const y = readNumber(sprite?.y);
+	return Object.entries(bounds).reduce((next, [key, value]) => {
+		if (value) next[key] = offsetBounds(value, x, y);
+		return next;
+	}, {});
+}
+function normalizeBehavior(behavior) {
+	if (typeof behavior === "function") return { component: behavior };
+	return behavior ?? {};
+}
+var RpgClientInteractions = class {
+	constructor(client) {
+		this.client = client;
+		this.registrations = signal([]);
+		this.states = signal({});
+		this.nextId = 0;
+	}
+	use(matcher, behavior) {
+		const registration = {
+			id: `interaction:${++this.nextId}`,
+			matcher,
+			behavior: normalizeBehavior(behavior)
+		};
+		this.registrations.update((registrations) => [...registrations, registration]);
+		return () => {
+			this.registrations.update((registrations) => registrations.filter((entry) => entry.id !== registration.id));
+		};
+	}
+	getState(sprite) {
+		const id = this.getSpriteId(sprite);
+		return {
+			...DEFAULT_STATE,
+			...id ? this.states()[id] : void 0,
+			data: id ? { ...this.states()[id]?.data ?? {} } : {},
+			overlays: id ? { ...this.states()[id]?.overlays ?? {} } : {}
+		};
+	}
+	getRenderedComponents(sprite, bounds) {
+		const normalizedBounds = normalizeBounds(bounds);
+		const matched = this.getMatches(sprite);
+		const state = this.getState(sprite);
+		const entries = [];
+		matched.forEach((registration) => {
+			if (!registration.behavior.component) return;
+			const ctx = this.createContext(sprite, registration, { bounds: normalizedBounds });
+			entries.push({
+				component: registration.behavior.component,
+				props: {
+					...this.defaultComponentProps(sprite, state, normalizedBounds),
+					...this.resolveProps(registration.behavior.props, ctx)
+				},
+				dependencies: this.resolveDependencies(registration.behavior.dependencies, ctx)
+			});
+		});
+		Object.entries(state.overlays).forEach(([id, overlay]) => {
+			entries.push({
+				component: overlay.component,
+				props: {
+					...this.defaultComponentProps(sprite, state, normalizedBounds),
+					...overlay.props ?? {},
+					overlayId: id
+				},
+				dependencies: []
+			});
+		});
+		return entries;
+	}
+	cursorFor(sprite, bounds) {
+		this.states();
+		for (const registration of this.getMatches(sprite)) {
+			const cursor = registration.behavior.cursor;
+			if (!cursor) continue;
+			const ctx = this.createContext(sprite, registration, { bounds: normalizeBounds(bounds) });
+			if (!this.passesHitTest(registration.behavior, ctx, "pointermove")) continue;
+			const resolved = typeof cursor === "function" ? cursor(ctx) : cursor;
+			if (resolved) return resolved;
+		}
+	}
+	handle(sprite, type, input = {}) {
+		const matches = this.getMatches(sprite);
+		const bounds = normalizeBounds(input.bounds);
+		const entries = matches.map((registration) => ({
+			registration,
+			ctx: this.createContext(sprite, registration, {
+				event: input.event,
+				bounds
+			})
+		})).filter(({ registration, ctx }) => this.passesHitTest(registration.behavior, ctx, type));
+		if (type === "pointerover" || type === "pointerenter") {
+			if (entries.length > 0) this.patchState(sprite, { hovered: true });
+		}
+		if (type === "pointerout" || type === "pointerleave") {
+			if (matches.length > 0) this.patchState(sprite, {
+				hovered: false,
+				pressed: false
+			});
+		}
+		if (type === "pointerdown") {
+			if (entries.length > 0) this.patchState(sprite, { pressed: true });
+		}
+		if (type === "pointermove" && matches.length > 0) this.patchState(sprite, { hovered: entries.length > 0 });
+		if (type === "pointerup") {
+			if (matches.length > 0) this.patchState(sprite, { pressed: false });
+		}
+		entries.forEach(({ registration, ctx }) => {
+			this.callHandler(registration.behavior, type, ctx);
+			if (type === "pointerdown" && this.isDraggable(registration.behavior)) {
+				this.activeDrag = {
+					sprite,
+					behavior: registration.behavior,
+					behaviorId: registration.id,
+					bounds,
+					cancelled: false
+				};
+				this.patchState(sprite, { dragging: true });
+				this.callHandler(registration.behavior, "dragstart", ctx);
+			}
+		});
+	}
+	handlePointerMove(event) {
+		if (!this.activeDrag) return;
+		const drag = this.activeDrag;
+		const registration = {
+			id: drag.behaviorId,
+			matcher: "*",
+			behavior: drag.behavior
+		};
+		const ctx = this.createContext(drag.sprite, registration, {
+			event,
+			bounds: drag.bounds
+		});
+		this.callHandler(drag.behavior, "dragmove", ctx);
+	}
+	handlePointerUp(event) {
+		if (!this.activeDrag) return;
+		const drag = this.activeDrag;
+		this.activeDrag = void 0;
+		this.patchState(drag.sprite, {
+			dragging: false,
+			pressed: false
+		});
+		const registration = {
+			id: drag.behaviorId,
+			matcher: "*",
+			behavior: drag.behavior
+		};
+		const ctx = this.createContext(drag.sprite, registration, {
+			event,
+			bounds: drag.bounds
+		});
+		this.callHandler(drag.behavior, drag.cancelled ? "cancel" : "drop", ctx);
+	}
+	cancelDrag(event) {
+		if (!this.activeDrag) return;
+		this.activeDrag.cancelled = true;
+		this.handlePointerUp(event);
+	}
+	getMatches(sprite) {
+		return this.registrations().filter((registration) => this.matches(registration.matcher, sprite));
+	}
+	matches(matcher, sprite) {
+		if (typeof matcher === "function") return !!matcher({
+			client: this.client,
+			target: sprite,
+			sprite
+		});
+		if (matcher === "*") return true;
+		return [
+			readValue(sprite?.id),
+			readValue(sprite?.name),
+			readValue(sprite?._name),
+			readValue(sprite?.type),
+			readValue(sprite?._type),
+			sprite?.constructor?.name
+		].filter(Boolean).includes(matcher);
+	}
+	createContext(sprite, registration, input = {}) {
+		const bounds = toWorldBounds(sprite, normalizeBounds(input.bounds));
+		return {
+			client: this.client,
+			target: sprite,
+			sprite,
+			event: input.event,
+			behavior: registration.behavior,
+			behaviorId: registration.id,
+			pointer: {
+				screen: () => this.client.pointer.screen(),
+				world: () => this.client.pointer.world(),
+				tile: () => this.getPointerTile()
+			},
+			bounds: (kind = "bounds") => bounds[kind] ?? bounds.graphic ?? bounds.hitbox ?? bounds.bounds ?? createBounds({}),
+			state: {
+				value: () => this.getState(sprite),
+				get: (key) => this.getState(sprite).data[key],
+				set: (key, value) => this.patchStateData(sprite, { [key]: value }),
+				patch: (patch) => this.patchState(sprite, patch)
+			},
+			overlay: {
+				render: (component, props) => this.patchOverlay(sprite, registration.id, {
+					component,
+					props
+				}),
+				update: (props) => this.updateOverlay(sprite, registration.id, props),
+				clear: () => this.clearOverlay(sprite, registration.id)
+			},
+			select: (selected = true) => this.patchState(sprite, { selected }),
+			action: (action, data) => this.client.processAction(action, data),
+			cancel: () => {
+				const activeDrag = this.activeDrag;
+				if (activeDrag && activeDrag.sprite === sprite) activeDrag.cancelled = true;
+			}
+		};
+	}
+	callHandler(behavior, type, ctx) {
+		const handler = behavior[type];
+		handler?.(ctx);
+		if (type === "pointerover") behavior.pointerenter?.(ctx);
+		if (type === "pointerout") behavior.pointerleave?.(ctx);
+	}
+	passesHitTest(behavior, ctx, type) {
+		if (!behavior.hitTest) return true;
+		if (type === "pointerout" || type === "pointerleave" || type === "cancel" || type === "drop") return true;
+		return behavior.hitTest(ctx);
+	}
+	isDraggable(behavior) {
+		return !!(behavior.dragstart || behavior.dragmove || behavior.drop || behavior.cancel);
+	}
+	defaultComponentProps(sprite, state, bounds) {
+		return {
+			target: sprite,
+			sprite,
+			state,
+			bounds: bounds.bounds ?? bounds.graphic ?? bounds.hitbox ?? createBounds({}),
+			hitboxBounds: bounds.hitbox,
+			graphicBounds: bounds.graphic,
+			pointer: this.client.pointer,
+			client: this.client
+		};
+	}
+	resolveProps(props, ctx) {
+		if (!props) return {};
+		return typeof props === "function" ? props(ctx) : props;
+	}
+	resolveDependencies(dependencies, ctx) {
+		if (!dependencies) return [];
+		return typeof dependencies === "function" ? dependencies(ctx) : dependencies;
+	}
+	getSpriteId(sprite) {
+		const id = readValue(sprite?.id);
+		return id == null ? void 0 : String(id);
+	}
+	patchState(sprite, patch) {
+		const id = this.getSpriteId(sprite);
+		if (!id) return;
+		this.states.update((states) => ({
+			...states,
+			[id]: {
+				...DEFAULT_STATE,
+				...states[id] ?? {},
+				...patch,
+				data: states[id]?.data ?? {},
+				overlays: states[id]?.overlays ?? {}
+			}
+		}));
+	}
+	patchStateData(sprite, patch) {
+		const id = this.getSpriteId(sprite);
+		if (!id) return;
+		const current = this.getState(sprite);
+		this.states.update((states) => ({
+			...states,
+			[id]: {
+				...current,
+				data: {
+					...current.data,
+					...patch
+				}
+			}
+		}));
+	}
+	patchOverlay(sprite, id, overlay) {
+		const spriteId = this.getSpriteId(sprite);
+		if (!spriteId) return;
+		const current = this.getState(sprite);
+		this.states.update((states) => ({
+			...states,
+			[spriteId]: {
+				...current,
+				overlays: {
+					...current.overlays,
+					[id]: overlay
+				}
+			}
+		}));
+	}
+	updateOverlay(sprite, id, props) {
+		const overlay = this.getState(sprite).overlays[id];
+		if (!overlay) return;
+		this.patchOverlay(sprite, id, {
+			...overlay,
+			props: {
+				...overlay.props ?? {},
+				...props ?? {}
+			}
+		});
+	}
+	clearOverlay(sprite, id) {
+		const spriteId = this.getSpriteId(sprite);
+		if (!spriteId) return;
+		const current = this.getState(sprite);
+		const { [id]: _removed, ...overlays } = current.overlays;
+		this.states.update((states) => ({
+			...states,
+			[spriteId]: {
+				...current,
+				overlays
+			}
+		}));
+	}
+	getPointerTile() {
+		const world = this.client.pointer.world();
+		if (!world) return null;
+		const map = this.client.sceneMap;
+		const width = Number(map?.tileWidth ?? 32);
+		const height = Number(map?.tileHeight ?? 32);
+		const tileX = Math.floor(world.x / width);
+		const tileY = Math.floor(world.y / height);
+		return {
+			x: tileX,
+			y: tileY,
+			worldX: tileX * width,
+			worldY: tileY * height,
+			width,
+			height
+		};
+	}
+};
+function hoverPopover(component, props) {
+	return {
+		component,
+		props,
+		cursor: "pointer"
+	};
+}
+function selectable(options = {}) {
+	return {
+		cursor: options.cursor ?? "pointer",
+		click(ctx) {
+			ctx.select();
+			options.onSelect?.(ctx);
+		}
+	};
+}
+function draggable(options = {}) {
+	return {
+		cursor: options.cursor ?? "grab",
+		dragstart(ctx) {
+			ctx.state.patch({ dragging: true });
+			options.start?.(ctx);
+		},
+		dragmove: options.move,
+		drop(ctx) {
+			ctx.state.patch({
+				dragging: false,
+				pressed: false
+			});
+			options.drop?.(ctx);
+		},
+		cancel(ctx) {
+			ctx.state.patch({
+				dragging: false,
+				pressed: false
+			});
+			options.cancel?.(ctx);
+		}
+	};
+}
+function dragToTile(options) {
+	return draggable({
+		cursor: options.cursor,
+		drop(ctx) {
+			if (options.onDrop) {
+				options.onDrop(ctx);
+				return;
+			}
+			if (!options.action) return;
+			ctx.action(options.action, options.data ? options.data(ctx) : {
+				eventId: ctx.target.id,
+				position: ctx.pointer.tile()
+			});
+		}
+	});
+}
+//#endregion
+export { RpgClientInteractions, dragToTile, draggable, hoverPopover, selectable };
+
+//# sourceMappingURL=interactions.js.map