like2d 2.11.0 → 2.12.0

package/dist/input/gamepad-mapping.d.ts

@@ -1,12 +1,9 @@
 /**
- * @module GamepadMapping
- *
  * A database, generated on module load,
  * which uses SDL's database to coerce
  * browser APIs into physical gamepad button
  * mappings.
  *
- *
  * Browser API shortcomings:
  *  - [No standard way of exposing vendor/product, Safari doesn't even do it.](https://github.com/w3c/gamepad/issues/199)
  *  - Vendor and product alone doesn't suffice for GUID -- Different controllers have the same, it's good-enough.
@@ -19,13 +16,14 @@
  */
 import type { Vector2 } from "../math";
 /**
+ * @private
  * ref: https://www.w3.org/TR/gamepad/#dfn-standard-gamepad
  * note: `num` is only the corresponding number on standard mapping above.
  *
  * The point of the mapping system is to apply that _or_ non-standard mappings,
  * Which are exceedingly common.
  */
-declare const buttonMap: readonly [{
+export declare const buttonMap: readonly [{
     readonly like: "BBottom";
     readonly num: number;
     readonly name: "Bottom Face Button";
@@ -101,8 +99,10 @@ export type StickAxisMapping = {
     index: number;
     invert: boolean;
 };
+/** @private Get an empty mapping for a gamepad. Good for binding from scratch. */
 export declare const defaultMapping: (stickCount: number) => GamepadMapping;
 export declare const standardButtonMapping: () => ButtonMapping;
+/** @private */
 export declare const allButtons: Set<string>;
 export declare const fullButtonName: Map<"BBottom" | "BRight" | "BLeft" | "BTop" | "L1" | "R1" | "L2" | "R2" | "MenuLeft" | "MenuRight" | "LeftStick" | "RightStick" | "Up" | "Down" | "Left" | "Right", "Bottom Face Button" | "Right Face Button" | "Left Face Button" | "Top Face Button" | "Left shoulder (front)" | "Right shoulder (front)" | "Left shoulder (rear)" | "Right shoulder (rear)" | "Left Menu Button" | "Right Menu Button" | "Left Stick Button" | "Right Stick Button" | "D-Pad Up" | "D-Pad Down" | "D-Pad Left" | "D-Pad right">;
 export declare const mapStick: (gp: Gamepad, mapping: StickMapping) => Vector2;

package/dist/input/gamepad-mapping.js

@@ -1,12 +1,9 @@
 /**
- * @module GamepadMapping
- *
  * A database, generated on module load,
  * which uses SDL's database to coerce
  * browser APIs into physical gamepad button
  * mappings.
  *
- *
  * Browser API shortcomings:
  *  - [No standard way of exposing vendor/product, Safari doesn't even do it.](https://github.com/w3c/gamepad/issues/199)
  *  - Vendor and product alone doesn't suffice for GUID -- Different controllers have the same, it's good-enough.
@@ -18,13 +15,14 @@
  *  - We go with best-match and always fall back on manual mapping.
  */
 /**
+ * @private
  * ref: https://www.w3.org/TR/gamepad/#dfn-standard-gamepad
  * note: `num` is only the corresponding number on standard mapping above.
  *
  * The point of the mapping system is to apply that _or_ non-standard mappings,
  * Which are exceedingly common.
  */
-const buttonMap = [
+export const buttonMap = [
     { like: "BBottom", num: 0, name: "Bottom Face Button" },
     { like: "BRight", num: 1, name: "Right Face Button" },
     { like: "BLeft", num: 2, name: "Left Face Button" },
@@ -49,6 +47,7 @@ const detectedOs = ((s) => [
     ["Win", "Windows"],
     ["Mac", "Mac OS X"],
 ].find(([ss]) => s.includes(ss))?.[1] ?? "Linux")(navigator.userAgent);
+/** @private Get an empty mapping for a gamepad. Good for binding from scratch. */
 export const defaultMapping = (stickCount) => ({
     buttons: {},
     sticks: Array(stickCount)
@@ -59,6 +58,8 @@ export const defaultMapping = (stickCount) => ({
     ]),
 });
 export const standardButtonMapping = () => Object.fromEntries(buttonMap.map(({ like, num }) => [num, like]));
+const numToName = standardButtonMapping();
+/** @private */
 export const allButtons = new Set(buttonMap.map(({ like }) => like));
 export const fullButtonName = new Map(buttonMap.map(({ like, name }) => [like, name]));
 export const mapStick = (gp, mapping) => {
@@ -70,7 +71,7 @@ const mappingDb = new Map(Object.entries(mappingDbRaw[detectedOs]).map(([k, v])
     Number(k),
     {
         ...v,
-        mapping: Object.fromEntries(Object.entries(v.mapping).map(([k, v]) => [Number(k), v])),
+        mapping: Object.fromEntries(Object.entries(v.mapping).map(([k, v]) => [Number(k), numToName[Number(v)]])),
     },
 ]));
 export function getSdlMapping(gamepad) {

package/dist/input/gamepad.d.ts

@@ -12,8 +12,18 @@ export type GamepadTarget = number | "any";
  *
  * If you're planning on supporting gamepads, please include a
  * way to generate {@link GamepadMapping} and set it with {@link Gamepad.setMapping}.
+ * Perhaps trigger it on {@link index.EventMap.gamepadconnected} events.
+ *
+ * If you don't want to make your own, take a look at {@link prefab-scenes.MapGamepad}
+ *
+ * ## When to use gamepad remapping
+ *
+ * For games with heavy and varied gamepad use, mapping buttons is essential.
+ *
+ * But if your game relies on a small set of logical actions like 'accept' or 'jump', don't hesitate to
+ * reach for {@link input} in order to map based on actions instead.
+ *
  *
- * If you don't want to make your own, take a look at `prefab-scenes/mapGamepad`.
  */
 export declare class Gamepad {
     private dispatch;

package/dist/input/gamepad.js

@@ -7,8 +7,18 @@ import { defaultMapping, fullButtonName, getSdlMapping, mapStick, standardButton
  *
  * If you're planning on supporting gamepads, please include a
  * way to generate {@link GamepadMapping} and set it with {@link Gamepad.setMapping}.
+ * Perhaps trigger it on {@link index.EventMap.gamepadconnected} events.
+ *
+ * If you don't want to make your own, take a look at {@link prefab-scenes.MapGamepad}
+ *
+ * ## When to use gamepad remapping
+ *
+ * For games with heavy and varied gamepad use, mapping buttons is essential.
+ *
+ * But if your game relies on a small set of logical actions like 'accept' or 'jump', don't hesitate to
+ * reach for {@link input} in order to map based on actions instead.
+ *
  *
- * If you don't want to make your own, take a look at `prefab-scenes/mapGamepad`.
  */
 export class Gamepad {
     constructor(props) {

package/dist/input/index.d.ts

@@ -1,6 +1,14 @@
-export type { Input, InputType, InputBinding, } from "./input";
-export type { GamepadTarget, Gamepad, } from "./gamepad";
-export type { LikeButton, GamepadMapping, StickMapping, StickAxisMapping, } from "./gamepad-mapping";
-export { defaultMapping, allButtons } from "./gamepad-mapping";
-export type { MouseSetMode, Mouse, } from "./mouse";
+/**
+ * Where {@link Keyboard}, {@link Mouse}, {@link Gamepad}, and actions in {@link Input} reside.
+ * @module input
+*/
+export type { Keyboard } from "./keyboard";
+export type { Mouse } from "./mouse";
+export type { Gamepad } from "./gamepad";
+export type { Input } from "./input";
+export type { MouseSetMode, MouseMode, MouseButton, } from "./mouse";
+export type { GamepadTarget, } from "./gamepad";
+export type { LikeButton, GamepadMapping, ButtonMapping, StickMapping, StickAxisMapping, } from "./gamepad-mapping";
+export type { InputType, InputBinding, } from "./input";
+export { defaultMapping, allButtons, buttonMap } from "./gamepad-mapping";
 //# sourceMappingURL=index.d.ts.map

package/dist/input/index.js

@@ -1 +1,5 @@
-export { defaultMapping, allButtons } from "./gamepad-mapping";
+/**
+ * Where {@link Keyboard}, {@link Mouse}, {@link Gamepad}, and actions in {@link Input} reside.
+ * @module input
+*/
+export { defaultMapping, allButtons, buttonMap } from "./gamepad-mapping";

package/dist/input/input.d.ts

@@ -1,8 +1,9 @@
 import type { Keyboard } from './keyboard';
-import type { Mouse } from './mouse';
+import type { Mouse, MouseButton } from './mouse';
 import { Gamepad, GamepadTarget } from './gamepad';
 import { LikeButton } from './gamepad-mapping';
-import { MouseButton, Dispatcher } from '../events';
+import { LikeActionEvent } from '../events';
+import { EngineProps } from '../engine';
 export type InputType = InputBinding['type'];
 export type InputBinding = {
     type: 'keyboard';
@@ -15,15 +16,64 @@ export type InputBinding = {
     gamepad: GamepadTarget;
     button: LikeButton;
 };
+/**
+ * Used to map inputs (from keyboard, mouse, or gamepad) into actions.
+ *
+ * {@link setAction} allows for set-and-forget mappings. Good for one-off games.
+ *
+ * Example:
+ * ```js
+ * // bind action jump
+ * like.load() {
+ *   like.input.setAction('jump', ['KeyX', 'Space', 'ButtonBottom'])
+ * }
+ *
+ * like.actionpressed(action) {
+ *   if (action == 'jump') {
+ *     player.tryJumping();
+ *   }
+ * }
+ * ```
+ *
+ * For more sophisticated games, see also:
+ *  - {@link appendToAction}
+ *  - {@link getActionMapping}
+ *
+ * These allow for programmatic binding based on events. For example:
+ * ```js
+ * let currentlyMapping = 'jump';
+ *
+ * // Watch for gamepad and keyboard events
+ * like.keypressed = (code) => {
+ *   if (currentlyMapping) {
+ *     like.input.appendToAction(currentlyMapping, code);
+ *   }
+ * }
+ * like.gamepadpressed = (name) => {
+ *   if (currentlyMapping) {
+ *     like.input.appendToAction(currentlyMapping, name);
+ *   }
+ * }
+ *
+ * // Print some info about the current mapping
+ * like.draw = () => {
+ *   if (currentlyMapping) {
+ *     myGame.statusLine =
+ *       `Mapped ${like.input.getActionMapping(currentlyMapping)} to ${currentlyMapping}`
+ *   }
+ * }
+ *
+ * ```
+*/
 export declare class Input {
-    private dispatch;
     private currState;
     private prevState;
     private actionTable;
     private keyboard;
     private mouse;
     private gamepad;
-    constructor(dispatch: Dispatcher<'actionpressed' | 'actionreleased'>, deps: {
+    private dispatch;
+    constructor(props: EngineProps<LikeActionEvent>, deps: {
         keyboard: Keyboard;
         mouse: Mouse;
         gamepad: Gamepad;
@@ -31,7 +81,7 @@ export declare class Input {
     /**
      * This is the easiest way to set-and-forget input => action mapping.
      *
-     * Or, it's a helper to remove actions -- `setAction(action)`
+     * Or, it's a helper to remove actions -- `setAction(action, [])`
      * will simply clear the action away.
      *
      * For input strings:
@@ -42,6 +92,7 @@ export declare class Input {
      *    - Numeric: `Digit0`, `Digit1`, ...
      *    - `ArrowLeft`, `ArrowRight`, `ArrowUp`, `ArrowDown`
      *    - `ShiftLeft`, `ShiftRight`
+     *    - `Space`
      *    - `Minus`
      *    - `Equal` (also has a plus sign)
      *    - `BracketLeft` and `BracketRight`
@@ -58,7 +109,7 @@ export declare class Input {
      * @param action
      * @param inputs
      */
-    setAction(action: string, inputs?: (string | InputBinding)[]): void;
+    setAction(action: string, inputs: (string | InputBinding)[]): void;
     /**
      * Map a single input onto an action.
      */
@@ -70,7 +121,7 @@ export declare class Input {
     isDown(action: string): boolean;
     justPressed(action: string): boolean;
     justReleased(action: string): boolean;
-    update(): void;
+    private update;
     private isBindingActive;
 }
 //# sourceMappingURL=input.d.ts.map

package/dist/input/input.js

@@ -1,12 +1,55 @@
 import { allButtons } from './gamepad-mapping';
+/**
+ * Used to map inputs (from keyboard, mouse, or gamepad) into actions.
+ *
+ * {@link setAction} allows for set-and-forget mappings. Good for one-off games.
+ *
+ * Example:
+ * ```js
+ * // bind action jump
+ * like.load() {
+ *   like.input.setAction('jump', ['KeyX', 'Space', 'ButtonBottom'])
+ * }
+ *
+ * like.actionpressed(action) {
+ *   if (action == 'jump') {
+ *     player.tryJumping();
+ *   }
+ * }
+ * ```
+ *
+ * For more sophisticated games, see also:
+ *  - {@link appendToAction}
+ *  - {@link getActionMapping}
+ *
+ * These allow for programmatic binding based on events. For example:
+ * ```js
+ * let currentlyMapping = 'jump';
+ *
+ * // Watch for gamepad and keyboard events
+ * like.keypressed = (code) => {
+ *   if (currentlyMapping) {
+ *     like.input.appendToAction(currentlyMapping, code);
+ *   }
+ * }
+ * like.gamepadpressed = (name) => {
+ *   if (currentlyMapping) {
+ *     like.input.appendToAction(currentlyMapping, name);
+ *   }
+ * }
+ *
+ * // Print some info about the current mapping
+ * like.draw = () => {
+ *   if (currentlyMapping) {
+ *     myGame.statusLine =
+ *       `Mapped ${like.input.getActionMapping(currentlyMapping)} to ${currentlyMapping}`
+ *   }
+ * }
+ *
+ * ```
+*/
 export class Input {
-    constructor(dispatch, deps) {
-        Object.defineProperty(this, "dispatch", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: dispatch
-        });
+    constructor(props, deps) {
         Object.defineProperty(this, "currState", {
             enumerable: true,
             configurable: true,
@@ -43,14 +86,24 @@ export class Input {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "dispatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.keyboard = deps.keyboard;
         this.mouse = deps.mouse;
         this.gamepad = deps.gamepad;
+        this.dispatch = props.dispatch;
+        props.canvas.addEventListener("like:update", () => this.update(), {
+            signal: props.abort,
+        });
     }
     /**
      * This is the easiest way to set-and-forget input => action mapping.
      *
-     * Or, it's a helper to remove actions -- `setAction(action)`
+     * Or, it's a helper to remove actions -- `setAction(action, [])`
      * will simply clear the action away.
      *
      * For input strings:
@@ -61,6 +114,7 @@ export class Input {
      *    - Numeric: `Digit0`, `Digit1`, ...
      *    - `ArrowLeft`, `ArrowRight`, `ArrowUp`, `ArrowDown`
      *    - `ShiftLeft`, `ShiftRight`
+     *    - `Space`
      *    - `Minus`
      *    - `Equal` (also has a plus sign)
      *    - `BracketLeft` and `BracketRight`
@@ -77,7 +131,7 @@ export class Input {
      * @param action
      * @param inputs
      */
-    setAction(action, inputs = []) {
+    setAction(action, inputs) {
         if (inputs.length) {
             this.actionTable[action] = inputs.map(parseInput);
         }

package/dist/input/keyboard.d.ts

@@ -1,15 +1,38 @@
 import { EngineProps } from "../engine";
-type KEvent = 'keypressed' | 'keyreleased';
+import { type LikeKeyboardEvent } from "../events";
+/**
+ * A basic wrapper around keyboard.
+ *
+ * Keyboard uses scancodes by default, which are based on physical key
+ * positions rather than the logical (letter) meaning of the key.
+ *
+ * ## When to use Keyboard
+ *
+ * Using keyboard directly is discouraged, but of course allowed.
+ * Take a look at the actions system in {@link input} for a better solution.
+ *
+ * Also where there's text input such as `enter your name`, use the key code.
+ * This allows the user to use their intended keyboard layout.
+ *
+ * ```
+ * like.keypressed = (_code, key) => {
+ *   name += key;
+ * }
+ * ```
+ *
+ * Even if your game is heavily keyboard-reliant (like nethack), it is best to avoid mapping directly.
+ * Referring to action `drink` instead of code `KeyD` is also more programmer-ergonomic.
+ *
+ */
 export declare class Keyboard {
     private pressedScancodes;
     private canvas;
     private dispatch;
-    constructor(props: EngineProps<KEvent>);
+    constructor(props: EngineProps<LikeKeyboardEvent>);
     private handleKeyDown;
     private handleKeyUp;
     private handleBlur;
     isDown(scancode: string): boolean;
     isAnyDown(...scancodes: string[]): boolean;
 }
-export {};
 //# sourceMappingURL=keyboard.d.ts.map

package/dist/input/keyboard.js

@@ -1,3 +1,27 @@
+/**
+ * A basic wrapper around keyboard.
+ *
+ * Keyboard uses scancodes by default, which are based on physical key
+ * positions rather than the logical (letter) meaning of the key.
+ *
+ * ## When to use Keyboard
+ *
+ * Using keyboard directly is discouraged, but of course allowed.
+ * Take a look at the actions system in {@link input} for a better solution.
+ *
+ * Also where there's text input such as `enter your name`, use the key code.
+ * This allows the user to use their intended keyboard layout.
+ *
+ * ```
+ * like.keypressed = (_code, key) => {
+ *   name += key;
+ * }
+ * ```
+ *
+ * Even if your game is heavily keyboard-reliant (like nethack), it is best to avoid mapping directly.
+ * Referring to action `drink` instead of code `KeyD` is also more programmer-ergonomic.
+ *
+ */
 export class Keyboard {
     constructor(props) {
         Object.defineProperty(this, "pressedScancodes", {

package/dist/input/mouse.d.ts

@@ -1,7 +1,8 @@
 import { type Vector2 } from '../math/vector2';
-import { type MouseButton, type LikeMouseEvent } from '../events';
+import { type LikeMouseEvent } from '../events';
 import { EngineProps } from '../engine';
-type MouseMode = {
+export type MouseButton = 'left' | 'middle' | 'right';
+export type MouseMode = {
     lock: false;
     visible: boolean;
     scrollBlock: boolean;
@@ -13,7 +14,35 @@ export type MouseSetMode = Partial<MouseMode> & {
     lock: boolean;
 };
 /**
- * Mouse input handling. Bound to canvas. Emits relative movement when pointer locked.
+ * LIKE's mouse wrapper.
+ *
+ * Mouse coordinates are scaled for convenience. For example call:
+ * ```
+ * like.canvas.setMode([240, 160])
+ * ```
+ * and your game will now be 240x160 pixels.
+ *
+ * Your mouse coords will stay within the rectangle `[0, 0]` and `[240, 160]`.
+ *
+ * If you intend to allow scrolling on your page while the mouse is above the game, use:
+ * ```
+ * like.mouse.setMode({ lock: false, scrollBlock: false })
+ * ```
+ *
+ * ### Capture
+ *
+ * Some games benefit from capture aka pointer lock. Call
+ * ```ts
+ * like.mouse.setMode({ lock: true, speed: 1 })
+ * ```
+ * to use capture, and now the mouse is locked to the game.
+ *
+ * When you enter capture, the mouse `pos` becomes virtual, bounded to canvas edges, plus controlled via the speed setting and teleport-able via {@link setCapturedPos}.
+ *
+ * When you exit capture, the mouse will be in the same spot the capture was started in.
+ *
+ * Note that your mode settings from non-capture mode are preserved in capture mode and vice-versa.
+ *
  */
 export declare class Mouse {
     private dispatch;
@@ -58,7 +87,7 @@ export declare class Mouse {
      * In locked mode, the cursor cannot escape the canvas.
      * It also becomes invisible.
      * However, it can move infinitely, sensitivity can be controlled,
-     * and the emulated cursor (in `pos` of {@link mousemoved}) can be freely repositioned.
+     * and the emulated cursor (in `pos` of {@link index.EventMap.mousemoved}) can be freely repositioned.
      *
      * ```ts
      * {
@@ -70,7 +99,7 @@ export declare class Mouse {
      * reset mode to default.
      *
      * ### Note on `pos` vs `delta`
-     * Event {@link mousemoved} passes both `pos` and `delta` args.
+     * Event {@link index.EventMap.mousemoved} passes both `pos` and `delta` args.
      *
      * Though the emulated cursor in locked mode
      * (locked mode doesn't natively track absolute position)
@@ -104,5 +133,4 @@ export declare class Mouse {
      */
     setRelativeMode?: never;
 }
-export {};
 //# sourceMappingURL=mouse.d.ts.map

package/dist/input/mouse.js

@@ -2,7 +2,35 @@ import { Vec2 } from '../math/vector2';
 const mouseButtons = ["left", "middle", "right"];
 const numToButton = (i) => mouseButtons[i];
 /**
- * Mouse input handling. Bound to canvas. Emits relative movement when pointer locked.
+ * LIKE's mouse wrapper.
+ *
+ * Mouse coordinates are scaled for convenience. For example call:
+ * ```
+ * like.canvas.setMode([240, 160])
+ * ```
+ * and your game will now be 240x160 pixels.
+ *
+ * Your mouse coords will stay within the rectangle `[0, 0]` and `[240, 160]`.
+ *
+ * If you intend to allow scrolling on your page while the mouse is above the game, use:
+ * ```
+ * like.mouse.setMode({ lock: false, scrollBlock: false })
+ * ```
+ *
+ * ### Capture
+ *
+ * Some games benefit from capture aka pointer lock. Call
+ * ```ts
+ * like.mouse.setMode({ lock: true, speed: 1 })
+ * ```
+ * to use capture, and now the mouse is locked to the game.
+ *
+ * When you enter capture, the mouse `pos` becomes virtual, bounded to canvas edges, plus controlled via the speed setting and teleport-able via {@link setCapturedPos}.
+ *
+ * When you exit capture, the mouse will be in the same spot the capture was started in.
+ *
+ * Note that your mode settings from non-capture mode are preserved in capture mode and vice-versa.
+ *
  */
 export class Mouse {
     constructor(props) {
@@ -161,7 +189,7 @@ export class Mouse {
      * In locked mode, the cursor cannot escape the canvas.
      * It also becomes invisible.
      * However, it can move infinitely, sensitivity can be controlled,
-     * and the emulated cursor (in `pos` of {@link mousemoved}) can be freely repositioned.
+     * and the emulated cursor (in `pos` of {@link index.EventMap.mousemoved}) can be freely repositioned.
      *
      * ```ts
      * {
@@ -173,7 +201,7 @@ export class Mouse {
      * reset mode to default.
      *
      * ### Note on `pos` vs `delta`
-     * Event {@link mousemoved} passes both `pos` and `delta` args.
+     * Event {@link index.EventMap.mousemoved} passes both `pos` and `delta` args.
      *
      * Though the emulated cursor in locked mode
      * (locked mode doesn't natively track absolute position)

package/dist/like.d.ts

@@ -1,7 +1,3 @@
-/**
- * @module like
- * @description A catalogue of subsystems
- */
 import type { Audio } from './audio/index';
 import type { Timer } from './timer/index';
 import type { Input } from './input/index';
@@ -12,9 +8,12 @@ import type { Canvas } from './graphics/canvas';
 import type { Graphics } from './graphics/index';
 import { EventMap, EventType, LikeEvent } from './events';
 import { Scene } from './scene';
+/** @private */
 export type TopLevelEventHandler = (event: LikeEvent) => void;
-type Callback<K extends EventType> = (...args: EventMap[K]) => void;
-type Callbacks = {
+/** @private */
+export type Callback<K extends EventType> = (...args: EventMap[K]) => void;
+/** @private */
+export type Callbacks = {
     [K in EventType]?: Callback<K>;
 };
 /**
@@ -54,21 +53,52 @@ export type Like = Callbacks & {
      */
     dispose(): void;
     /**
-     * A simple way to set the current scene, which acts like a pluggable
-     * set of callbacks.
+     * Push a scene to the scene stack.
+     *
+     * If the engine is running, this is the new running scene replacing the old one
+     * which can, in some cases, call out to the lower scene.
+     *
+     * @param overlay Set to true, and the current scene (before pushing) will stay loaded. Otherwise not.
+     */
+    pushScene(scene: Scene, overlay: boolean): void;
+    /**
+     * Pop the current scene off the stack.
+     *
+     * To clear the stack, just run:
+     * ```ts
+     * while (like.popScene());
+     * ```
+     */
+    popScene(): Scene | undefined;
+    /**
+     * Set the current scene at the top of the scene stack.
+     * If the stack is empty, push it onto the stack.
+     *
+     * Equivalent to `popScene` + `pushScene`.
+     *
+     * Use {@link popScene} to clear away the current scene,
+     * and to possibly revert to callback mode.
+     */
+    setScene(scene: Scene): void;
+    /**
+     * Get the current scene, or a specific index.
+     *
+     * Uses `Array.at` under the hood, so -1 is the
+     * top scene, -2 is the parent scene, etc.
      */
-    setScene(scene?: Scene): void;
+    getScene(index?: number): Scene | undefined;
     /**
      * LIKE's runtime is built around calling handleEvent.
      *
      * This function recieves all events. If set to undefined,
-     * `like.callOwnHandlers(ev)` is the default behavior.
+     * {@link callOwnHandlers} is the default behavior.
      *
      * Otherwise, you can really customize LIKE by setting this
      * to a custom handler.
      *
      * For example, the scene architecture is built around
-     * setting this function.
+     * setting this function. Setting it to a custom
+     * function will disable the scene system.
      */
     handleEvent?: TopLevelEventHandler;
     /**
@@ -78,5 +108,4 @@ export type Like = Callbacks & {
      */
     callOwnHandlers(event: LikeEvent): void;
 };
-export {};
 //# sourceMappingURL=like.d.ts.map

package/dist/like.js

@@ -1,5 +1 @@
-/**
- * @module like
- * @description A catalogue of subsystems
- */
 export {};