excalibur 0.33.0-alpha.26 → 0.33.0-alpha.262

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "site/vendor/docusaurus-plugin-typedoc-api"]
+	path = site/vendor/docusaurus-plugin-typedoc-api
+	url = https://github.com/excaliburjs/docusaurus-plugin-typedoc-api.git

package/.nvmrc

@@ -1 +1 @@
-24.11.0
+24.16.0

package/CHANGELOG.md

@@ -7,27 +7,198 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Breaking Changes
 
--
+- Behavior change - Excalibur screen space is now consistently rooted at the top-left of the safe content area (`Screen.contentArea`) across the whole API. Previously the clipping display modes (`FitScreenAndFill`, `FitContainerAndFill`, `FitScreenAndZoom`, `FitContainerAndZoom`) disagreed about where screen space started: `CoordPlane.Screen` entities and pointer events were rooted at the content area's corner, but `Screen.worldToScreenCoordinates` returned raw canvas/resolution coordinates and `Screen.contentArea.left/top` carried the canvas-space inset. Every API now shares the single content-area-rooted definition, which fixes several pointer, transition, and `unsafeArea` bugs in the clipping display modes, but is a breaking change for code that relied on the old canvas-rooted values:
+  - `Screen.worldToScreenCoordinates(point)` now returns coordinates rooted at the content area (previously the raw camera projection in canvas/resolution coordinates). `Screen.screenToWorldCoordinates` is the exact inverse, as before.
+  - `Screen.contentArea` is now always rooted at `(0, 0)`, and `Screen.unsafeArea.topLeft` is negative by the clip amount. The canvas-space inset that `contentArea.left/top` used to carry is available from the new `Screen.contentAreaOffset`.
+  - Display modes that never clip (`Fixed`, `FitScreen`, `FillScreen`, `FitContainer`, `FillContainer`) have a `(0, 0)` offset and are unaffected.
+
+  If you need the old canvas-rooted values, for example to position an HTML overlay over the canvas, shim them by adding `Screen.contentAreaOffset` back:
+
+  ```typescript
+  // Before: worldToScreenCoordinates returned canvas coordinates
+  const canvasPos = engine.screen.worldToScreenCoordinates(actor.pos).add(engine.screen.contentAreaOffset);
+
+  // Before: contentArea.topLeft was the safe area corner in canvas coordinates
+  const safeAreaCorner = engine.screen.contentAreaOffset.clone();
+  ```
+- Behavior change - `rotateBy({angleRadiansOffset, duration})` with no `rotationType` now rotates by exactly the signed offset provided, preserving full and multiple turns, instead of taking the shortest path to the canonicalized target orientation. Offsets larger than `Math.PI` now travel in the direction of their sign (previously they rotated the shorter way around), and `2 * Math.PI` performs a full revolution (previously a no-op). Pass an explicit `rotationType` to keep path-based behavior
+- Behavior change - TileMap now uses 'separate' as the `compositeStrategy` as a better default. Commonly TileMap is used to build levels, so this default aligns with the common use.
+- Removed old legacy `ex.EasingFunctions` in favor of the [0, 1] common easing functions 
+- Removed EaseTo/EaseBy/actor.actions.(easeTo|easeBy) Action in favor of MoveTo/MoveBy/actor.actions.(moveTo|moveBy) Action with easing support
+- Removed `body.sleeping` in favor of `isSleeping`
+- Removed `entity.active` in favor of `isActive`
+- Removed `actor.getGlobalPos()` in favor of `actor.globalPos` getter/setter
+- Removed `actor.getGlobalRotation()` in favor of `actor.globalRotation` getter/setter
+- Removed `actor.getGlobalScale()` in favor of `actor.globalScale` getter/setter
+- Removed `BoundingBox.draw` in favor of `BoundingBox.debug`
+- Removed typo in `engine.isFullScreen` now `engine.isFullscreen`
+- Removed unused `tag-query.ts`
+- Removed `world.queryTags`, `world.query(...)` can query tags
+- Removed `Animation.durationPerFrameMs` in favor of `Animation.durationPerFrame`
+- Removed `Vector.size` in favor of `Vector.magnitude`
+- Behavior change - Font/Text now render more accurately and faster be using less texture space, this unfortunately is a breaking change becuase text will render slightly different.
+- Breaking change - `Material.update()` now passes a `MaterialContext` to its callback instead of the composite `Shader`. The context carries the material's declarative `uniforms` dictionary (the recommended way to change values — they reach the composite shader and are forwarded to every pipeline pass), plus `shaders`/`shadersByName` for direct access to every compiled shader the material drives. Update code like `material.update(shader => shader.trySetUniformFloatVector('iMouse', pos))` to `material.update(context => context.uniforms.iMouse = pos)`
+- Build: Docusaurus now throws the build on broken markdown links, broken anchors, and broken markdown images instead of warning. Any custom docs/blog content must have valid internal links, anchors, and images.
+- Build: The engine `tsconfig.json` now uses `module: "esnext"` with `moduleResolution: "bundler"` (previously `module: "es2015"` / `moduleResolution: "node"`), and `downlevelIteration` has been removed. The per-package `tsconfig.json` overrides in `director`, `entity-component-system`, `graphics`, and `resources` have been removed in favor of the single engine `tsconfig.json`. Consumers importing source directly may need bundler-compatible tooling.
+- Build: TypeDoc runner has been replaced by `site/scripts/gen-typedoc-api.mjs`.
 
 ### Deprecated
 
-- 
+- `ex.Pool` renamed to `ex.ArenaPool`
 
 ### Added
 
--
+- Added an optional `System.dispose(world, scene)` lifecycle hook, called by the `SystemManager` when a system is removed after having been initialized — use it to release resources the system provisioned in `initialize` (entities it added, observable subscriptions, etc.). The `LightingSystem` uses it to remove its provisioned overlay and unsubscribe its component queries when lighting is disabled at runtime
+- Added multipass **shader pipelines** for composing shader effects that need more than one pass (blur, bloom, glow), built on an explicit source→destination dataflow with no hidden bind state:
+  - New `ex.Framebuffer` and `ex.MultisampleFramebuffer` primitives that are both a render destination and a texture source (`framebuffer.texture`, `framebuffer.glFramebuffer`, `framebuffer.texelSize`), with `resize()`, `clear()`, and `dispose()`. These replace the internal (never exported) `RenderTarget`/`RenderSource` classes inside the WebGL context. Reading a `MultisampleFramebuffer.texture` resolves the MSAA samples automatically.
+  - New `ex.ShaderPass`: applies a fragment shader to an image, framebuffer, or texture and produces a new image — the building block for custom effects. `pass.draw(source, destination)` for the simple case, or `pass.draw({ sources: { u_smaller: quarterResolution, u_larger: halfResolution }, destination, uniforms })` for multiple named sampler sources and per-draw uniforms. Convention uniforms are provided (`u_image`, `u_resolution`, `u_texelSize`, `u_time_ms`, `u_elapsed_ms`) and fragments are authored with the `glsl` tag's straight-alpha conventions.
+  - New `ex.ShaderPipeline` linear chain (`source → pass0 → pass1 → ... → destination`) with per-pass `scale` for downsample/upsample and `u_original` bound for composite passes. Any object implementing `ex.ShaderPipelineLike` (`process(source, destination)`) can be used instead for custom non-linear graphs.
+  - `ex.Material` can now run multipass pipelines, with `MaterialOptions` typed as a union so only valid combinations compile:
+    - `fragmentSource` only — single-pass custom shading of the graphic, exactly as before
+    - `passes` only — run a multipass effect (fragment strings, `ShaderPass`es, or an effect object like `BloomEffect`) on the graphic offscreen; a default passthrough composite draws the result
+    - `passes` + `fragmentSource` — the fragment shader becomes the **final composite**: it draws the pipeline's output (bound as `u_graphic`) on screen, which is where screen-space work like `u_screen_texture` belongs
+    - `padding` (with `passes`) — extra transparent source pixels around the graphic so blur/glow halos are not clipped to the quad
+    - the material's custom `uniforms` and built-ins (`u_opacity`, `u_color`, `u_graphic_resolution`, `u_size`) are forwarded to every pass
+  - `ex.PostProcessor` is now built around a single `process(source, destination)` hook (`initialize` is optional, so `ShaderPipelineLike` effect objects can be added with `addPostProcessor` directly); the legacy `getShader`/`getLayout` single-pass path still works but is deprecated for removal in v1. `ex.ShaderPipelinePostProcessor` builds a fullscreen post processor from `passes` (mirroring `Material`: a list of fragment sources/`ShaderPass`es, or a `ShaderPipelineLike` effect), chaining with other post processors in order. `ColorBlindnessPostProcessor` is now implemented on `ShaderPass` internally.
+  - New built-in effects usable per-graphic or fullscreen, each a `ShaderPipelineLike` object with live-tunable settings:
+    - `ex.BlurEffect({ graphicsContext, scale, strength })` — separable gaussian blur, animate `blur.strength` any time
+    - `ex.GlowEffect({ graphicsContext, color, scale, strength, intensity })` — outer glow: the graphic's silhouette is tinted, blurred, and composited back under the original (pair with `Material` `padding` so the halo has room); `color`/`strength`/`intensity` are live properties
+    - `ex.BloomEffect({ graphicsContext, threshold, intensity, levels })` — progressive downsample/upsample ladder bloom implemented as a custom pass graph, with live-tunable `threshold`/`intensity`
+    - The underlying pass factories `ex.createBlurPasses(...)`/`ex.createGlowPasses(...)` are also exported for splicing into custom pass chains
+
+  ```typescript
+  const blur = new ex.BlurEffect({ graphicsContext, strength: 2 });
+  actor.graphics.material = new ex.Material({
+    graphicsContext,
+    passes: blur,
+    padding: 16 // blur can bleed 16px outside the sprite without clipping
+  });
+  blur.strength = 4; // live-tunable any time
+
+  // fullscreen: effects can be added as post processors directly
+  game.graphicsContext.addPostProcessor(new ex.BloomEffect({ graphicsContext, threshold: 0.6 }));
+  ```
+
+- Added an opt-in 2D lighting simulation, enabled with the new `lighting: true` engine option (default `false`). When enabled every scene gets a `FlickerSystem` and `LightingSystem` that render darkness veils, point/cone lights with flicker, and occluder shadows via the new `DarknessComponent`, `PointLightComponent`, `ConeLightComponent`, and `LightOccluderComponent` components. The overlay is rasterized with the 2D Canvas API and re-uploaded to the GPU every frame, which carries a performance penalty — this is why the feature is off by default. The systems can also be added manually to individual scenes with `scene.world.add(new ex.LightingSystem())` without enabling the engine option.
+
+  ```typescript
+  const game = new ex.Engine({ lighting: true });
+  const lamp = new ex.Actor({ pos: ex.vec(100, 100) });
+  lamp.addComponent(new ex.PointLightComponent({ color: ex.Color.fromRGB(255, 200, 80), radius: 200 }));
+  ```
+
+  Pass a `LightingConfig` object instead of `true` to tune the simulation's defaults — including the ambient brightness floor/color assumed everywhere a scene has no explicit `DarknessComponent` override:
+
+  ```typescript
+  const game = new ex.Engine({
+    lighting: {
+      enabled: true,
+      zIndex: 100, // z-index of the lighting overlay
+      cullPadding: 64, // world-pixel padding around the camera frustum when culling lights/occluders
+      ambientIntensity: 0.1, // ambient brightness floor (0.0 to 1.0)
+      ambientColor: ex.Color.fromRGB(60, 60, 200), // tints the darkness veil toward this color
+      tintAlphaFactor: 0.35, // fraction of a light's intensity used for its colored tint
+      shadowNearOpacity: 0.92, // occluder shadow opacity at the occluder's edge
+      shadowMidOpacity: 0.6 // occluder shadow opacity at 40% of the shadow's reach
+    }
+  });
+  ```
+
+  Any entity with a collider-like shape can cast a dynamic shadow by adding a `LightOccluderComponent`:
+
+  ```typescript
+  const crate = new ex.Actor({ pos: ex.vec(300, 200), width: 40, height: 40 });
+  crate.addComponent(new ex.LightOccluderComponent({ shape: { kind: 'box', width: 40, height: 40 } }));
+  ```
+- Materials are now enumerable for debugging and tooling (like the Excalibur Dev Tools browser extension): every `Material` has a unique `material.id` and public `material.vertexSource`/`material.fragmentSource` getters, and is automatically registered with its context, retrievable via `game.graphicsContext.materials`. The registry holds materials weakly so it does not prevent garbage collection.
+- Added the `ex.glsl` tagged template literal for authoring `Material` fragment shaders. It lights up GLSL syntax highlighting, adds the `#version`/`precision` boilerplate, injects the `pixel_texture()` pixel art filter on demand, and handles alpha premultiplication automatically.
+
+  Excalibur's pipeline is premultiplied end to end, which makes hand written shaders easy to get subtly wrong in both directions: introducing your own alpha without premultiplying blends too bright, and premultiplying a `texture()` sample that is already premultiplied darkens antialiased edges. Shaders written with the tag instead get a straight (un-premultiplied) alpha authoring space, so ordinary alpha math just works:
+
+  ```typescript
+  const material = game.graphicsContext.createMaterial({
+    name: 'fade',
+    fragmentSource: ex.glsl`
+      in vec2 v_uv;
+      uniform sampler2D u_graphic;
+      out vec4 fragColor;
+
+      void main() {
+        vec4 color = texture(u_graphic, v_uv);
+        color.a *= 0.5; // no manual premultiply needed
+        fragColor = color;
+      }`
+  });
+  ```
+
+  Sample non-color data with `ex_texture_raw(tex, uv)` to bypass the conversion, or add `#pragma excalibur premultiply(off)` to opt a shader out entirely.
+
+- Added new lerp modes for color which can be chosen by aptional parameter in `Color.lerp` or by calling different methods:
+  ```typescript
+  Color.lerp(colorA, colorB, t); // 'hsl' by default
+  // eqivalent to: 
+  Color.lerpHSL(colorA, colorB, t);
+  
+  Color.lerp(colorA, colorB, t, 'rgb');
+  // eqivalent to: 
+  Color.lerpRGB(colorA, colorB, t);
+  
+  Color.lerp(colorA, colorB, t, 'lrgb');
+  // equivalent to:
+  Color.lerpLRGB(colorA, colorB, t);
+  ```
+- Added `Color.fromFloatArray([0.0, 0.0, 0.0, 1.0])` and `Color.toFloatArray()`
+- Sound objects can be created from `Blob`s:
+  ```typescript
+  const sound = await Sound.fromBlob(instanceOfBlob)
+  sound.play()
+  ```
+- Docs: The API documentation pipeline has been rebuilt around a vendored fork of `docusaurus-plugin-typedoc-api` (added as a git submodule under `site/vendor/docusaurus-plugin-typedoc-api`). The new `site/scripts/gen-typedoc-api.mjs` generates TypeDoc output and an `api-symbol-index.json` consumed by the docs site.
+  ```bash
+  # in site/
+  npm run build:docusaurus-plugin-typedoc-api  # build the vendored plugin
+  npm run api:generate                         # run typedoc + normalize
+  ```
+- Docs: New `remark-api-symbol-links` plugin (`site/plugins/remark-api-symbol-links.mjs`) resolves `[[Symbol]]` markdown links to the generated TypeDoc API pages using the symbol index, replacing the external `remark-typedoc-symbol-links` package.
 
 ### Fixed
 
--
+- Fixed issue where `rotateBy({…})` would not rotate at all for a full-turn offset (`2 * Math.PI` normalized to a zero-length rotation) and would rotate the wrong way for offsets larger than `Math.PI`. When no `rotationType` is provided, `rotateBy` now rotates by exactly the signed offset given, preserving full and multiple turns; when a `rotationType` is provided, the offset determines the target orientation and the type picks the travel path as before. Also fixed an angular velocity spike of ±2π on frames where a multi-turn rotation wrapped past the canonical angle range
+- Fixed issue where a pointer's normalized id could change mid-contact. `PointerEventReceiver` normalized native pointer ids by sorting all active native ids and using the array index, so an already-tracked pointer (e.g. a touch in a multi-touch gesture) was silently re-assigned a different id when another pointer went down or up, routing its subsequent events to the wrong `PointerAbstraction`. Normalized ids are now stable for the lifetime of the contact; the smallest freed id is reused for new contacts (so a lone new touch always lands back on `pointers.primary`); cancelled contacts (`pointercancel`/`touchcancel`) free their id and clear their down state instead of leaking; and the mouse keeps its id reserved after mouse-up since it persists as a hover pointer
+- Fixed issue where a cancelled pointer (`pointercancel`/`touchcancel`) left entities in a phantom hover/drag state. Entities now receive `pointerleave` (and `pointerdragend`/`pointerdragleave` when the cancelled contact was dragging) before `pointercancel`, mirroring the pointer-up flow and the browser's own post-cancel event order, since the browser never sends another move/up event for a cancelled pointer
+- Fixed issue where the post processor `u_time_ms` uniform accumulated elapsed time once per post processor per update, advancing N times too fast with N post processors installed
+- Fixed issue where Local-space particles could be double-returned to the object pool, causing the same Particle instance to be active in two slots simultaneously
+- Fixed issue where window resize events were handled twice when using window-based display modes (FitScreen, FitScreenAndFill, FitScreenAndZoom, FillScreen), causing double resolution/viewport computation and double canvas size writes
+- Fixed Matrix and AffineMatrix scale/rotation decomposition bug where getScaleX/getScaleY used wrong basis components for non-uniform scale combined with rotation, causing swapped scale values and corrupt transforms. Also fixed setRotation and setScaleX/setScaleY to operate on correct column basis vectors.
+- Fixed issue where `Resource.load()` would hang forever on network errors (DNS failure, CORS block, offline), deadlocking the loader and all scene navigation. The promise now rejects with a `ResourceLoadingError` containing the resource path and a descriptive message
+- Fixed issue where `ImageSource.load()` would hang forever below 100% with nothing logged when a response could not be decoded as an image, for example a corrupt image, or a `200 OK` that returned HTML/error content with a content type other than `text/html`. The `HTMLImageElement.onerror` is now handled so `ImageSource.load()` and `ImageSource.ready` reject with an error that is also logged to the console, which lets the `Loader` fail fast instead of deadlocking. `ImageSource.fromHtmlCanvasElement()` no longer hangs when a canvas cannot be turned into a blob, and blob object urls from failed decodes are now released
+- Fixed issue where `Gif.isLoaded()` always returned `true` because it checked `!!this.data` on an empty array, causing Gifs to be silently skipped by the loader and never parsed
+- Fixed issue where `scaleTo({…})` and `scaleBy({…})` actions would cause entities to keep scaling indefinitely after the action completed, due to a copy-paste bug that zeroed `angularVelocity` instead of `scaleFactor`
+- Fixed issue where `scaleTo({…})` and `scaleBy({…})` actions used a live reference to the entity's scale vector as the interpolation start point, causing the easing curve to be corrupted if the entity's scale changed during the action
+- Fixed issue where the first action in a sequence would not execute after calling `clearActions()` mid-execution. All action types now properly reset their initialization state when stopped, resolving issue #3468
+- Performance: Font/Text now use smaller texture sizes, improving performance on Safari especially when rendering text
+- Fixed `Color.screen()` blend mode bug where both operands were incorrectly using the parameter color instead of `this` and the parameter
+- Fixed `Color.toRGBA()` logic error in alpha check condition (`||` changed to `&&`)
+- Fixed `Color.toHSLA()` to output valid CSS format with degrees for hue and percentages for saturation/lightness
+- Fixed `Color.toHex()` to properly clamp RGB values to 0-255 range
+- Docs: Fixed broken internal links, anchors, and `[[Symbol]]` references across the docs and blog (e.g. `#sprites` → `/docs/sprites`, `#ExcaliburGraphicsContext` → `/docs/graphics-context`), and replaced invalid `[[Actor.update]]` symbol links with plain `Actor.update` references where the member is not part of the public API surface
+- Docs: Fixed incorrect JSDoc `@param`/`@returns` tags and removed dead commented-out code blocks in engine source (e.g. `CollisionSolver`, `BoundingBox.draw`) that produced invalid TypeDoc output
+- Fixed `BoundingBox.intersect()` return type to be explicitly `Vector | null` (callers already null-checked, but the type was not reflected)
 
 ### Updates
 
--
+- Deps: Upgraded to TypeScript 6.0.3 (from 5.6.3) and typescript-eslint 8.63.0 (from 8.38.0); engine source updated for TS6 strictness (non-null assertions, `null` → `undefined` defaults, optional fields)
+- Deps: Upgraded to Docusaurus 3.10.1 (from 3.5.2) across the docs site, including `@docusaurus/*` packages, theme/preset packages, and the mdx-loader
+- Deps: Upgraded to TypeDoc 0.28.19 (vendored plugin) and removed the top-level `typedoc` devDependency / `overrides`
+- Deps: Upgraded Vitest 4.1.8 → 4.1.10 and Vite 8.0.16 → 8.1.4; browser API is now enabled with `allowWrite`/`allowExec` in the unit config, and the Vitest API host was changed from `0.0.0.0` to `127.0.0.1`
+- Deps: Upgraded `coveralls-next` 6.0.1 → 6.0.2
+- Deps: Removed unused `@types/marked` devDependency and `wallaby.js` test runner config
+- CI: API doc generation now runs as part of `npm run all:ci` (via `npm run apidocs` → `site/scripts/gen-typedoc-api.mjs`); the dedicated `typedoc` CI job in the build workflow has been removed
+- CI: The `eslint` config dropped the obsolete `parserOptions.project` overrides now that typescript-eslint handles project context differently
 
 ### Changed
 
-- 
+- API documentation are now generated into the Docusaurus build directory (`site/generated/`, gitignored) and copied into `.docusaurus/generated/` during `site` build, instead of the legacy `docs/api/` output location
 
 <!--------------------------------- DO NOT EDIT BELOW THIS LINE --------------------------------->
 <!--------------------------------- DO NOT EDIT BELOW THIS LINE --------------------------------->
@@ -1308,11 +1479,18 @@ const hits = engine.currentScene.physics.rayCast(
 
 ### Updates
 
-- 
+- Deps: Upgraded to TypeScript 6.0.3 (from 5.6.3) and typescript-eslint 8.63.0 (from 8.38.0); engine source updated for TS6 strictness (non-null assertions, `null` → `undefined` defaults, optional fields)
+- Deps: Upgraded to Docusaurus 3.10.1 (from 3.5.2) across the docs site, including `@docusaurus/*` packages, theme/preset packages, and the mdx-loader
+- Deps: Upgraded to TypeDoc 0.28.19 (vendored plugin) and removed the top-level `typedoc` devDependency / `overrides`
+- Deps: Upgraded Vitest 4.1.8 → 4.1.10 and Vite 8.0.16 → 8.1.4; browser API is now enabled with `allowWrite`/`allowExec` in the unit config, and the Vitest API host was changed from `0.0.0.0` to `127.0.0.1`
+- Deps: Upgraded `coveralls-next` 6.0.1 → 6.0.2
+- Deps: Removed unused `@types/marked` devDependency and `wallaby.js` test runner config
+- CI: API doc generation now runs as part of `npm run all:ci` (via `npm run apidocs` → `site/scripts/gen-typedoc-api.mjs`); the dedicated `typedoc` CI job in the build workflow has been removed
+- CI: The `eslint` config dropped the obsolete `parserOptions.project` overrides now that typescript-eslint handles project context differently
 
 ### Changed
 
-- 
+- API documentation are now generated into the Docusaurus build directory (`site/generated/`, gitignored) and copied into `.docusaurus/generated/` during `site` build, instead of the legacy `docs/api/` output location
 
 ## [v0.28.2]
 

package/build/{dist → esm}/actions/action/move-by.d.ts

@@ -1,12 +1,11 @@
 import type { Entity } from '../../entity-component-system/entity';
 import type { Easing } from '../../math';
 import { Vector } from '../../math/vector';
-import type { EasingFunction } from '../../util/easing-functions';
 import type { Action } from '../action';
 export interface MoveByOptions {
     offset: Vector;
     duration: number;
-    easing?: Easing | EasingFunction;
+    easing?: Easing;
 }
 /**
  *
@@ -24,9 +23,7 @@ export declare class MoveByWithOptions implements Action {
     private _stopped;
     private _motion;
     private _offset;
-    private _legacyEasing;
     private _easing;
-    private _useLegacyEasing;
     constructor(entity: Entity, options: MoveByOptions);
     update(elapsed: number): void;
     isComplete(entity: Entity): boolean;

package/build/{dist → esm}/actions/action/move-to.d.ts

@@ -1,12 +1,11 @@
 import type { Entity } from '../../entity-component-system/entity';
 import type { Easing } from '../../math';
 import { Vector } from '../../math/vector';
-import type { EasingFunction } from '../../util/easing-functions';
 import type { Action } from '../action';
 export interface MoveToOptions {
     pos: Vector;
     duration: number;
-    easing?: Easing | EasingFunction;
+    easing?: Easing;
 }
 /**
  *
@@ -24,8 +23,6 @@ export declare class MoveToWithOptions implements Action {
     private _stopped;
     private _motion;
     private _easing;
-    private _legacyEasing;
-    private _useLegacyEasing;
     constructor(entity: Entity, options: MoveToOptions);
     update(elapsed: number): void;
     isComplete(entity: Entity): boolean;

package/build/{dist → esm}/actions/action/rotate-by.d.ts

@@ -11,7 +11,12 @@ export interface RotateByOptions {
      */
     duration: number;
     /**
-     * Optionally provide type of rotation, default is RotationType.ShortestPath
+     * Optionally provide type of rotation. When omitted the entity rotates by exactly the
+     * signed offset provided, preserving full turns (an offset of 2 PI performs a full revolution).
+     * When provided, the offset determines the target orientation and the rotation type picks
+     * the travel path to it. Non-zero full-turn multiples of 2 PI travel one full revolution in
+     * the requested direction for Clockwise, CounterClockwise, and LongestPath, while
+     * ShortestPath will not move.
      */
     rotationType?: RotationType;
 }
@@ -30,8 +35,9 @@ export declare class RotateByWithOptions implements Action {
     private _motion;
     private _offset;
     private _startAngle;
-    private _rotationType;
-    private _endAngle;
+    private _rotationType?;
+    private _travel;
+    private _currentAngle;
     constructor(entity: Entity, options: RotateByOptions);
     update(elapsed: number): void;
     isComplete(): boolean;

package/build/{dist → esm}/actions/action-context.d.ts

@@ -1,4 +1,3 @@
-import type { EasingFunction } from '../util/easing-functions';
 import { ActionQueue } from './action-queue';
 import type { MoveByOptions } from './action/move-by';
 import type { MoveToOptions } from './action/move-to';
@@ -42,48 +41,9 @@ export declare class ActionContext {
      * @param options
      */
     curveTo(options: CurveToOptions): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param pos       The x,y vector location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(pos: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param x         The x location to move the actor to
-     * @param y         The y location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(x: number, y: number, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor by a specified vector offset relative to the current position given
-     * a duration and a {@apilink EasingFunction}. This method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param offset Vector offset relative to the current position
-     * @param duration The duration in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveBy({offset: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offset: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor by a specified x and y offset relative to the current position given
-     * a duration and a {@apilink EasingFunction}. This method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param offset Vector offset relative to the current position
-     * @param duration The duration in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveBy({offset: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offsetX: number, offsetY: number, duration: number, easingFcn?: EasingFunction): ActionContext;
     /**
      * Moves an actor to a specified {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveTo(options: MoveToOptions): ActionContext;
@@ -106,10 +66,17 @@ export declare class ActionContext {
     moveTo(x: number, y: number, speed: number): ActionContext;
     /**
      * Moves an actor by a specified offset {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveBy(options: MoveByOptions): ActionContext;
+    /**
+     * This method will move an actor by the specified x offset and y offset from its current position, at a certain speed.
+     * This method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param offset  The Vector offset to apply to this actor
+     * @param speed  The speed in pixels per second the actor should move
+     */
+    moveBy(offset: Vector, speed: number): ActionContext;
     /**
      * This method will move an actor by the specified x offset and y offset from its current position, at a certain speed.
      * This method is part of the actor 'Action' fluent API allowing action chaining.
@@ -117,7 +84,6 @@ export declare class ActionContext {
      * @param yOffset     The y location to move the actor to
      * @param speed  The speed in pixels per second the actor should move
      */
-    moveBy(offset: Vector, speed: number): ActionContext;
     moveBy(xOffset: number, yOffset: number, speed: number): ActionContext;
     /**
      * Rotates an actor to a specified angle over a duration in milliseconds,

package/build/{dist → esm}/actions/actions-component.d.ts

@@ -5,7 +5,6 @@ import type { Actor } from '../actor';
 import { MotionComponent } from '../entity-component-system/components/motion-component';
 import { TransformComponent } from '../entity-component-system/components/transform-component';
 import type { Vector, RotationType } from '../math';
-import type { EasingFunction } from '../util/easing-functions';
 import type { ActionQueue } from './action-queue';
 import type { Action } from './action';
 import type { Color } from '../color';
@@ -16,6 +15,7 @@ import type { MoveByOptions, RotateByOptions, RotateToOptions, ScaleByOptions, S
 export interface ActionContextMethods extends Pick<ActionContext, keyof ActionContext> {
 }
 export declare class ActionsComponent extends Component implements ActionContextMethods {
+    private static _NAME;
     dependencies: (typeof TransformComponent | typeof MotionComponent)[];
     private _ctx;
     onAdd(entity: Entity): void;
@@ -52,47 +52,9 @@ export declare class ActionsComponent extends Component implements ActionContext
      * @param options
      */
     curveTo(options: CurveToOptions): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param pos       The x,y vector location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunctions} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(pos: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param x         The x location to move the actor to
-     * @param y         The y location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunctions} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(x: number, y: number, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     *
-     * @param offset
-     * @param duration
-     * @param easingFcn
-     * @deprecated use new moveBy({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offset: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     *
-     * @param offsetX
-     * @param offsetY
-     * @param duration
-     * @param easingFcn
-     * @deprecated use new moveBy({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offsetX: number, offsetY: number, duration: number, easingFcn?: EasingFunction): ActionContext;
     /**
      * Moves an actor to a specified {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveTo(options: MoveToOptions): ActionContext;
@@ -115,7 +77,7 @@ export declare class ActionsComponent extends Component implements ActionContext
     moveTo(x: number, y: number, speed: number): ActionContext;
     /**
      * Moves an actor by a specified offset {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveBy(options: MoveByOptions): ActionContext;

package/build/{dist → esm}/actions/index.d.ts

@@ -8,8 +8,6 @@ export * from './action/repeat';
 export * from './action/repeat-forever';
 export * from './action/blink';
 export * from './action/die';
-export * from './action/ease-to';
-export * from './action/ease-by';
 export * from './action/fade';
 export * from './action/follow';
 export * from './action/meet';