@skewedaspect/sage 0.9.6 → 0.10.0-beta.2

package/dist/classes/input/readers/keyboard.d.ts

@@ -1,56 +0,0 @@
-import { DeviceValueReader, InputState, KeyboardValueReaderDefinition } from "../../../interfaces/input.d.ts";
-/**
- * Types of keyboard input sources
- */
-export type KeyboardSourceType = 'key';
-/**
- * Options for configuring a keyboard value reader
- */
-export interface KeyboardReaderOptions {
-    /**
-     * Whether to use delta state instead of current state
-     * When true, the source will only return true on the initial key press
-     */
-    useDelta?: boolean;
-}
-/**
- * Reads values from keyboard input states
- */
-export declare class KeyboardValueReader implements DeviceValueReader {
-    /**
-     * Always 'key' for keyboard readers.
-     */
-    readonly sourceType: KeyboardSourceType;
-    /**
-     * The key code to monitor (e.g. "KeyA", "Space", "ArrowUp")
-     */
-    readonly sourceKey: string;
-    /**
-     * When true, reads from delta (only true on the frame the key was first pressed/released)
-     */
-    private readonly useDelta;
-    /**
-     * Creates a new KeyboardValueReader
-     *
-     * @param keyCode - KeyboardEvent.code value (e.g. "KeyA", "Space", "ArrowUp")
-     * @param options
-     */
-    constructor(keyCode: string, options?: KeyboardReaderOptions);
-    /**
-     * Gets the value of the key state. Returns undefined for non-keyboard input states.
-     *
-     * @param state
-     */
-    getValue(state: InputState): boolean | undefined;
-    /**
-     * Creates a KeyboardValueReader from a string representation
-     *
-     * @param sourceKey - KeyboardEvent.code value (e.g. "KeyA", "Space")
-     * @param options
-     */
-    static fromString(sourceKey: string, options?: KeyboardReaderOptions): KeyboardValueReader;
-    /**
-     * Returns a JSON-serializable representation of this keyboard value reader.
-     */
-    toJSON(): KeyboardValueReaderDefinition;
-}

package/dist/classes/input/readers/mouse.d.ts

@@ -1,41 +0,0 @@
-import { DeviceValueReader, InputState, MouseValueReaderDefinition } from "../../../interfaces/input.d.ts";
-/**
- * Types of mouse input sources
- */
-export type MouseSourceType = 'button' | 'position' | 'wheel';
-/**
- * Reads values from mouse input states
- */
-export declare class MouseValueReader implements DeviceValueReader {
-    /**
-     * Which category of mouse input: button press, cursor position, or scroll wheel.
-     */
-    readonly sourceType: MouseSourceType;
-    /**
-     * Identifies the input within the source type (e.g. "button-0", "absolute:x", "deltaY")
-     */
-    readonly sourceKey: string;
-    /**
-     * Creates a new MouseValueReader
-     *
-     * @param sourceType
-     * @param sourceKey - e.g. "button-0", "absolute:x", "deltaY"
-     */
-    constructor(sourceType: MouseSourceType, sourceKey: string);
-    /**
-     * Gets the value of the mouse input source. Returns undefined for non-mouse input states.
-     *
-     * @param state
-     */
-    getValue(state: InputState): boolean | number | undefined;
-    /**
-     * Creates a MouseValueReader from a colon-delimited string (e.g. "button:0", "position:absolute:x")
-     *
-     * @param sourceTypeString
-     */
-    static fromString(sourceTypeString: string): MouseValueReader;
-    /**
-     * Returns a JSON-serializable representation of this mouse value reader.
-     */
-    toJSON(): MouseValueReaderDefinition;
-}

package/dist/interfaces/action.d.ts

@@ -1,22 +0,0 @@
-/**
- * Digital action (boolean)
- */
-export interface DigitalAction {
-    type: 'digital';
-    name: string;
-    label?: string;
-}
-/**
- * Analog action (numeric)
- */
-export interface AnalogAction {
-    type: 'analog';
-    name: string;
-    label?: string;
-    minValue?: number;
-    maxValue?: number;
-}
-/**
- * Action types
- */
-export type Action = DigitalAction | AnalogAction;

package/dist/interfaces/binding.d.ts

@@ -1,123 +0,0 @@
-import { GameEventBus } from "../classes/eventBus.d.ts";
-import { DeviceType, DeviceValueReader, DeviceValueReaderDefinition, InputState } from "./input.d.ts";
-import { Action } from "./action.d.ts";
-/**
- * Types of bindings supported by the system
- */
-export type BindingType = 'trigger' | 'toggle' | 'value';
-/**
- * Array of all supported binding types for validation
- */
-export declare const bindingTypes: BindingType[];
-/**
- * Context for organizing bindings into groups that can be activated/deactivated together
- */
-export interface Context {
-    name: string;
-    /**
-     * Whether this context is exclusive (only one exclusive context can be active at a time)
-     */
-    exclusive: boolean;
-}
-/**
- * Input definition that combines device ID and reader configuration into a single object
- */
-export type InputDefinition = DeviceValueReaderDefinition & {
-    deviceID: string;
-};
-/**
- * Options for captureInput() — waits for the next intentional input and returns its descriptor.
- */
-export interface CaptureInputOptions {
-    /** Device types to listen for */
-    deviceTypes: DeviceType[];
-    /** Optional filter for source types (e.g. ['key', 'button', 'axis']) */
-    sourceTypes?: ('key' | 'button' | 'axis' | 'position' | 'wheel')[];
-    /** Optional AbortSignal for cancellation or timeout */
-    signal?: AbortSignal;
-}
-/**
- * Base interface for binding definitions with object-based sources
- */
-export interface BindingDefinitionBase {
-    type: BindingType;
-    /** Name of an already-registered action */
-    action: string;
-    input: InputDefinition;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-/**
- * Trigger binding definition
- */
-export interface TriggerBindingDefinition extends BindingDefinitionBase {
-    type: 'trigger';
-    options?: {
-        edgeMode?: 'rising' | 'falling' | 'both';
-        threshold?: number;
-        passthrough?: boolean;
-    };
-}
-/**
- * Toggle binding definition
- */
-export interface ToggleBindingDefinition extends BindingDefinitionBase {
-    type: 'toggle';
-    state?: boolean;
-    options?: {
-        invert?: boolean;
-        initialState?: boolean;
-        threshold?: number;
-        onValue?: boolean | number;
-        offValue?: boolean | number;
-    };
-}
-/**
- * Value binding definition
- */
-export interface ValueBindingDefinition extends BindingDefinitionBase {
-    type: 'value';
-    options?: {
-        scale?: number;
-        offset?: number;
-        min?: number;
-        max?: number;
-        invert?: boolean;
-        emitOnChange?: boolean;
-        deadzone?: number;
-    };
-}
-/**
- * Union type of all binding definitions
- */
-export type BindingDefinition = TriggerBindingDefinition | ToggleBindingDefinition | ValueBindingDefinition;
-/**
- * Base interface for all input bindings
- */
-export interface Binding {
-    readonly type: BindingType;
-    readonly action: Action;
-    readonly context?: string;
-    readonly deviceID: string;
-    readonly deviceType: DeviceType;
-    readonly reader: DeviceValueReader;
-    /**
-     * Process input state and potentially emit an action event
-     *
-     * @param state
-     * @param eventBus
-     */
-    process(state: InputState, eventBus: GameEventBus): void;
-    /**
-     * Reset edge-detection state for a context activation. When an input state is provided, the binding primes its
-     * internal state from the current physical input so that already-held inputs don't produce phantom edges. Without
-     * a state, resets to a clean baseline (false).
-     *
-     * @param state - Last known input state for this binding's device, if available
-     */
-    resetEdgeState(state?: InputState): void;
-    /**
-     * Convert the binding to a JSON-serializable object.
-     */
-    toJSON(): BindingDefinition;
-}

package/dist/interfaces/entity.d.ts

@@ -1,97 +0,0 @@
-import { GameEntityBehavior } from "../classes/entity.d.ts";
-import { Action } from "./action.d.ts";
-import { ColliderDebugConfig } from "../managers/colliderDebug.d.ts";
-export type GameEntityBehaviorConstructor<RequiredState extends object = object> = new () => GameEntityBehavior<RequiredState>;
-export interface GameEntityDefinition<State extends object = object> {
-    /** Unique type identifier for this entity definition. */
-    type: string;
-    /** Type string of a base definition to inherit from. Resolved at registration time. */
-    extends?: string;
-    /** Optional human-readable name for entities of this type. Can be overridden per-instance. */
-    name?: string;
-    /** Initial tags to apply to entities of this type. */
-    tags?: string[];
-    /** Actions that this entity type responds to. */
-    actions?: Action[];
-    /** Default state for entities of this type. */
-    defaultState: State;
-    /** Behaviors to attach to entities of this type. */
-    behaviors: GameEntityBehaviorConstructor[];
-    /**
-     * Visual representation configuration.
-     * If specified, a mesh will be automatically created when the entity spawns.
-     */
-    mesh?: {
-        /**
-         * Mesh source: primitive type or path to GLB file.
-         * Primitives: 'box', 'sphere', 'capsule', 'cylinder'
-         * GLB: '/assets/models/player.glb'
-         */
-        source: 'box' | 'sphere' | 'capsule' | 'cylinder' | string;
-        /** Scale multiplier for the mesh (default: 1) */
-        scale?: number | {
-            x: number;
-            y: number;
-            z: number;
-        };
-        /** If false, meshes spawn hidden (isVisible = false); they still collide and block raycasts. Default: true */
-        visible?: boolean;
-        /** Material configuration */
-        material?: {
-            /** Material type: 'standard' (default) or 'pbr' */
-            type?: 'standard' | 'pbr';
-            /** Diffuse/albedo color (RGB 0-1) */
-            color?: {
-                r: number;
-                g: number;
-                b: number;
-            };
-            /** Emissive color for glow effects (RGB 0-1) */
-            emissive?: {
-                r: number;
-                g: number;
-                b: number;
-            };
-            /** PBR: Metallic factor (0-1, default 0) */
-            metallic?: number;
-            /** PBR: Roughness factor (0-1, default 1) */
-            roughness?: number;
-        };
-        /** Primitive-specific parameters */
-        params?: {
-            size?: number;
-            width?: number;
-            height?: number;
-            depth?: number;
-            diameter?: number;
-            segments?: number;
-            radius?: number;
-        };
-    };
-    /** If true, entities of this type are recycled via an object pool instead of being destroyed. */
-    poolable?: boolean;
-    /** Number of entities to prewarm in the pool at registration time. Implies poolable. */
-    poolSize?: number;
-    /** Child entities to create and attach when this entity is created. */
-    children?: {
-        type: string;
-        name?: string;
-        initialState?: Record<string, unknown>;
-        position?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        rotation?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    }[];
-    /** Debug collider visualization config. Applied automatically during level loading. */
-    debugCollider?: ColliderDebugConfig;
-    onBeforeCreate?: (state: State) => Promise<State | undefined> | State | undefined;
-    onCreate?: (state: State) => Promise<State | undefined> | State | undefined;
-    onBeforeDestroy?: (state: State) => Promise<State | undefined> | State | undefined;
-    onDestroy?: (state: State) => Promise<void> | void;
-}

package/dist/interfaces/input.d.ts

@@ -1,180 +0,0 @@
-/**
- * Valid input device types
- */
-export declare const validDeviceTypes: readonly ["keyboard", "mouse", "gamepad"];
-export type DeviceType = typeof validDeviceTypes[number];
-/**
- * Base input device interface
- */
-export interface InputDevice {
-    id: string;
-    name: string;
-    type: DeviceType;
-    connected: boolean;
-}
-/**
- * Keyboard device information
- */
-export interface KeyboardDevice extends InputDevice {
-    type: 'keyboard';
-}
-/**
- * Mouse device information
- */
-export interface MouseDevice extends InputDevice {
-    type: 'mouse';
-}
-/**
- * Gamepad device information
- */
-export interface GamepadDevice extends InputDevice {
-    type: 'gamepad';
-    index: number;
-    mapping: string;
-    axes: number[];
-    buttons: GamepadButton[];
-}
-/**
- * Base interface for all input device states
- */
-export interface BaseInputState {
-    event?: Event;
-}
-/**
- * Button state interface (for both mouse and gamepad)
- */
-export interface ButtonState {
-    pressed: boolean;
-    touched?: boolean;
-    value?: number;
-}
-/**
- * Mouse position interface
- */
-export interface Position {
-    absolute: {
-        x: number;
-        y: number;
-    };
-    relative: {
-        x: number;
-        y: number;
-    };
-}
-/**
- * Unified keyboard input state with object literals instead of Maps
- */
-export interface KeyboardInputState extends BaseInputState {
-    type: 'keyboard';
-    keys: Record<string, boolean>;
-    delta: Record<string, boolean>;
-    event?: KeyboardEvent;
-}
-/**
- * Unified mouse input state with object literals instead of Maps
- */
-export interface MouseInputState extends BaseInputState {
-    type: 'mouse';
-    buttons: Record<string, ButtonState>;
-    axes: Record<string, number>;
-    position: Position;
-    wheel?: {
-        deltaX: number;
-        deltaY: number;
-        deltaZ: number;
-        deltaMode: number;
-    };
-    event?: MouseEvent | WheelEvent;
-}
-/**
- * Unified gamepad input state with object literals instead of Maps
- */
-export interface GamepadInputState extends BaseInputState {
-    type: 'gamepad';
-    buttons: Record<string, ButtonState>;
-    axes: Record<string, number>;
-    event?: GamepadEvent;
-}
-/**
- * Unified input state interface that can represent any input device
- */
-export type InputState = KeyboardInputState | MouseInputState | GamepadInputState;
-/**
- * Type guard to check if an input state is from a keyboard
- */
-export declare function isKeyboardState(state: InputState): state is KeyboardInputState;
-/**
- * Type guard to check if an input state is from a mouse
- */
-export declare function isMouseState(state: InputState): state is MouseInputState;
-/**
- * Type guard to check if an input state is from a gamepad
- */
-export declare function isGamepadState(state: InputState): state is GamepadInputState;
-/**
- * Base interface for serialized device value readers
- */
-export interface DeviceValueReaderDefinitionBase {
-    /** The device type: 'keyboard', 'mouse', or 'gamepad' */
-    type: DeviceType;
-    /** The input source category (e.g. 'key', 'button', 'axis', 'position', 'wheel') */
-    sourceType: string;
-    /** The specific input identifier (e.g. 'KeyA', 'button-0', 'axis-1', 'absolute:x') */
-    sourceKey: string;
-}
-/**
- * Keyboard value reader definition
- */
-export interface KeyboardValueReaderDefinition extends DeviceValueReaderDefinitionBase {
-    type: 'keyboard';
-    sourceType: 'key';
-    sourceKey: string;
-    options?: {
-        useDelta?: boolean;
-    };
-}
-/**
- * Mouse value reader definition
- */
-export interface MouseValueReaderDefinition extends DeviceValueReaderDefinitionBase {
-    type: 'mouse';
-    sourceType: string;
-    sourceKey: string;
-}
-/**
- * Gamepad value reader definition
- */
-export interface GamepadValueReaderDefinition extends DeviceValueReaderDefinitionBase {
-    type: 'gamepad';
-    sourceType: string;
-    sourceKey: string;
-    options?: {
-        useAnalogValue?: boolean;
-        deadzone?: number;
-        invert?: boolean;
-    };
-}
-/**
- * Union type of all device value reader definitions
- */
-export type DeviceValueReaderDefinition = KeyboardValueReaderDefinition | MouseValueReaderDefinition | GamepadValueReaderDefinition;
-/**
- * Interface for all device value readers
- * Unified interface for all types of input sources that can extract values from device states
- */
-export interface DeviceValueReader {
-    /** The input source category (e.g. 'key', 'button', 'axis', 'position', 'wheel') */
-    readonly sourceType: string;
-    /** The specific input identifier (e.g. 'KeyA', 'button-0', 'axis-1', 'absolute:x') */
-    readonly sourceKey: string;
-    /**
-     * Gets the value from an input state, or undefined if this reader doesn't apply to the given state type.
-     *
-     * @param state
-     */
-    getValue(state: InputState): boolean | number | undefined;
-    /**
-     * Convert the reader to a JSON-serializable object.
-     */
-    toJSON(): DeviceValueReaderDefinition;
-}