three-gamepad-controls 0.10.6 → 0.11.0

package/dist/gamepad-transform-controls.js

@@ -203,6 +203,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#pressedButtons.clear();
 		super.onGamepadDisconnected(gamepad);
 	}
+	/**
+	* Applies mode, space, and axis button transitions from the current frame.
+	*
+	* @param startedButtons - Button indices that transitioned to pressed.
+	*/
 	#handleModeAndAxisButtons(startedButtons) {
 		const { buttonTranslate, buttonRotate, buttonScale, buttonToggleSpace, buttonAxisX, buttonAxisY, buttonAxisZ, buttonAxisComposite, buttonAxisPrevious, buttonAxisNext } = this.#options;
 		if (startedButtons.has(buttonTranslate)) this.#setMode("translate");
@@ -216,30 +221,57 @@ var GamepadTransformControls = class extends GamepadControls {
 		if (startedButtons.has(buttonAxisPrevious)) this.#cycleAxis(-1);
 		if (startedButtons.has(buttonAxisNext)) this.#cycleAxis(1);
 	}
+	/**
+	* Switches TransformControls mode and refreshes the active axis.
+	*
+	* @param mode - TransformControls mode to activate.
+	*/
 	#setMode(mode) {
 		if (this.#controls.mode === mode) return;
 		this.#endTransform(false);
 		this.#controls.setMode(mode);
 		this.#ensureValidAxis();
 	}
+	/**
+	* Toggles TransformControls between local and world transform space.
+	*/
 	#toggleSpace() {
 		const nextSpace = this.#controls.space === "world" ? "local" : "world";
 		this.#endTransform(false);
 		this.#controls.setSpace(nextSpace);
 	}
+	/**
+	* Selects an explicit axis when it is valid for the current mode.
+	*
+	* @param axis - Axis requested by the gamepad button mapping.
+	*/
 	#selectAxis(axis) {
 		if (!this.#isAxisAllowed(this.#controls.mode, axis)) return;
 		this.#endTransform(false);
 		this.#activeAxisByMode[this.#controls.mode] = axis;
 		this.#ensureValidAxis();
 	}
+	/**
+	* Cycles through composite axes available in the current mode.
+	*/
 	#cycleCompositeAxis() {
-		const validAxes = COMPOSITE_AXES[this.#controls.mode].filter((axis) => this.#isAxisVisible(axis));
+		const validAxes = this.#getVisibleAxes(COMPOSITE_AXES[this.#controls.mode]);
 		this.#cycleThroughAxes(validAxes, 1);
 	}
+	/**
+	* Cycles through all valid axes for the current mode.
+	*
+	* @param direction - `1` for next axis, `-1` for previous axis.
+	*/
 	#cycleAxis(direction) {
 		this.#cycleThroughAxes(this.#getValidAxes(this.#controls.mode), direction);
 	}
+	/**
+	* Moves the active axis through a candidate axis list.
+	*
+	* @param axes - Candidate axes to cycle through.
+	* @param direction - `1` for next axis, `-1` for previous axis.
+	*/
 	#cycleThroughAxes(axes, direction) {
 		if (axes.length === 0) {
 			this.#setActiveAxis(null);
@@ -252,6 +284,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#activeAxisByMode[this.#controls.mode] = axes[nextIndex] ?? null;
 		this.#ensureValidAxis();
 	}
+	/**
+	* Ensures the highlighted TransformControls axis is valid and visible.
+	*
+	* @returns The active valid axis, or `null` when no axis is available.
+	*/
 	#ensureValidAxis() {
 		const mode = this.#controls.mode;
 		const current = this.#activeAxisByMode[mode];
@@ -261,16 +298,51 @@ var GamepadTransformControls = class extends GamepadControls {
 		if (this.#controls.axis !== nextAxis) this.#controls.axis = nextAxis;
 		return nextAxis;
 	}
+	/**
+	* Updates both the remembered axis for the current mode and the control axis.
+	*
+	* @param axis - Axis to activate, or `null` to clear selection.
+	*/
 	#setActiveAxis(axis) {
 		this.#activeAxisByMode[this.#controls.mode] = axis;
 		if (this.#controls.axis !== axis) this.#controls.axis = axis;
 	}
+	/**
+	* Returns all visible axes supported by a TransformControls mode.
+	*
+	* @param mode - Mode whose axes should be inspected.
+	* @returns Visible axes for the mode.
+	*/
 	#getValidAxes(mode) {
-		return MODE_AXES[mode].filter((axis) => this.#isAxisVisible(axis));
+		return this.#getVisibleAxes(MODE_AXES[mode]);
+	}
+	/**
+	* Filters a list of axes to those enabled by TransformControls visibility flags.
+	*
+	* @param axes - Axes to inspect.
+	* @returns Axes whose component visibility flags are enabled.
+	*/
+	#getVisibleAxes(axes) {
+		const visibleAxes = [];
+		for (const axis of axes) if (this.#isAxisVisible(axis)) visibleAxes.push(axis);
+		return visibleAxes;
 	}
+	/**
+	* Checks whether an axis can be used in a mode and is currently visible.
+	*
+	* @param mode - TransformControls mode to validate against.
+	* @param axis - Axis to validate.
+	* @returns `true` when the axis is supported and visible.
+	*/
 	#isAxisAllowed(mode, axis) {
 		return MODE_AXES[mode].includes(axis) && this.#isAxisVisible(axis);
 	}
+	/**
+	* Reads TransformControls visibility flags for an axis or plane.
+	*
+	* @param axis - Axis whose visibility should be checked.
+	* @returns `true` when all components required by the axis are visible.
+	*/
 	#isAxisVisible(axis) {
 		const controls = this.#controls;
 		switch (axis) {
@@ -285,6 +357,11 @@ var GamepadTransformControls = class extends GamepadControls {
 			case "E": return true;
 		}
 	}
+	/**
+	* Starts a TransformControls drag interaction for the active object and axis.
+	*
+	* @returns `true` when a transform interaction was started.
+	*/
 	#startTransform() {
 		const controls = this.#controls;
 		const object = controls.object;
@@ -298,6 +375,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		});
 		return true;
 	}
+	/**
+	* Ends an active TransformControls drag interaction.
+	*
+	* @param clearAxis - Whether to clear the highlighted axis after ending.
+	*/
 	#endTransform(clearAxis) {
 		const controls = this.#controls;
 		if (this.#isTransforming) {
@@ -310,6 +392,9 @@ var GamepadTransformControls = class extends GamepadControls {
 		}
 		if (clearAxis) this.#setActiveAxis(null);
 	}
+	/**
+	* Resets the active object to TransformControls' captured drag start state.
+	*/
 	#resetActiveTransform() {
 		const object = this.#controls.object;
 		if (!this.#isTransforming || object === void 0) return;
@@ -320,6 +405,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#freeRotationX = 0;
 		this.#freeRotationY = 0;
 	}
+	/**
+	* Captures object and control state needed to apply gamepad transforms.
+	*
+	* @param object - Object attached to TransformControls.
+	*/
 	#captureTransformStart(object) {
 		object.updateWorldMatrix(true, false);
 		object.parent?.updateWorldMatrix(true, false);
@@ -339,6 +429,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#freeRotationX = 0;
 		this.#freeRotationY = 0;
 	}
+	/**
+	* Captures the attached object's parent world transform for local conversions.
+	*
+	* @param object - Object attached to TransformControls.
+	*/
 	#captureParentTransform(object) {
 		if (object.parent === null) {
 			this.#parentPosition.set(0, 0, 0);
@@ -351,6 +446,14 @@ var GamepadTransformControls = class extends GamepadControls {
 		object.parent.matrixWorld.decompose(this.#parentPosition, this.#parentQuaternion, this.#parentScale);
 		this.#parentQuaternionInv.copy(this.#parentQuaternion).invert();
 	}
+	/**
+	* Dispatches the current stick input to the active TransformControls mode.
+	*
+	* @param deltaTime - Seconds since the last frame.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @returns `true` when the attached object changed.
+	*/
 	#applyCurrentTransform(deltaTime, transformX, transformY) {
 		switch (this.#controls.mode) {
 			case "translate": return this.#applyTranslate(deltaTime, transformX, transformY);
@@ -358,6 +461,14 @@ var GamepadTransformControls = class extends GamepadControls {
 			case "scale": return this.#applyScale(deltaTime, transformX, transformY);
 		}
 	}
+	/**
+	* Applies translation in the selected axis, plane, or screen-facing plane.
+	*
+	* @param deltaTime - Seconds since the last frame.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @returns `true` when the attached object moved.
+	*/
 	#applyTranslate(deltaTime, transformX, transformY) {
 		const controls = this.#controls;
 		const object = controls.object;
@@ -377,6 +488,15 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#applyAccumulatedPosition(object, axis, scale);
 		return true;
 	}
+	/**
+	* Accumulates a world-space translation delta along selected axis letters.
+	*
+	* @param axis - Transform axis or plane currently selected.
+	* @param space - Transform space used to resolve axis directions.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @param distance - World-space distance scale for the frame.
+	*/
 	#addAxisTranslation(axis, space, transformX, transformY, distance) {
 		for (const letter of [
 			"X",
@@ -388,6 +508,13 @@ var GamepadTransformControls = class extends GamepadControls {
 			this.#worldDelta.addScaledVector(this.#axisWorld, this.#getProjectedAxisInput(this.#axisWorld, transformX, transformY, this.#getDominantInput(transformX, -transformY)) * distance);
 		}
 	}
+	/**
+	* Applies accumulated translation with snapping and bounds.
+	*
+	* @param object - Object attached to TransformControls.
+	* @param axis - Transform axis or plane currently selected.
+	* @param space - Transform space used for snapping.
+	*/
 	#applyAccumulatedPosition(object, axis, space) {
 		this.#snappedPosition.copy(this.#accumulatedPosition);
 		if (this.#controls.translationSnap !== null) this.#snapPosition(object, axis, space, this.#controls.translationSnap);
@@ -397,6 +524,14 @@ var GamepadTransformControls = class extends GamepadControls {
 		object.position.copy(this.#snappedPosition);
 		object.updateMatrixWorld();
 	}
+	/**
+	* Snaps the pending position in world or local transform space.
+	*
+	* @param object - Object attached to TransformControls.
+	* @param axis - Axis letters that should be snapped.
+	* @param space - Transform space used for snapping.
+	* @param snap - Snap interval.
+	*/
 	#snapPosition(object, axis, space, snap) {
 		if (snap <= 0) return;
 		if (space === "world") {
@@ -418,6 +553,14 @@ var GamepadTransformControls = class extends GamepadControls {
 		]) if (axis.includes(letter)) this.#setVectorComponent(this.#snappedPosition, letter, this.#snapValue(this.#getVectorComponent(this.#snappedPosition, letter), snap));
 		this.#snappedPosition.applyQuaternion(this.#quaternionStart);
 	}
+	/**
+	* Applies rotation for the selected axis or free-rotation mode.
+	*
+	* @param deltaTime - Seconds since the last frame.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @returns `true` when the attached object rotated.
+	*/
 	#applyRotate(deltaTime, transformX, transformY) {
 		const controls = this.#controls;
 		const object = controls.object;
@@ -450,11 +593,23 @@ var GamepadTransformControls = class extends GamepadControls {
 		object.updateMatrixWorld();
 		return true;
 	}
+	/**
+	* Applies a rotation around a world-space axis while preserving local parent space.
+	*
+	* @param object - Object attached to TransformControls.
+	* @param worldAxis - World-space axis to rotate around.
+	* @param angle - Rotation amount in radians from the drag start.
+	*/
 	#applyWorldRotation(object, worldAxis, angle) {
 		this.#axisLocal.copy(worldAxis).applyQuaternion(this.#parentQuaternionInv).normalize();
 		this.#rotationQuaternion.setFromAxisAngle(this.#axisLocal, angle);
 		object.quaternion.copy(this.#rotationQuaternion).multiply(this.#quaternionStart).normalize();
 	}
+	/**
+	* Applies screen-relative free rotation from accumulated stick input.
+	*
+	* @param object - Object attached to TransformControls.
+	*/
 	#applyFreeRotation(object) {
 		const angleX = this.#snapRotation(this.#freeRotationX);
 		const angleY = this.#snapRotation(this.#freeRotationY);
@@ -467,6 +622,14 @@ var GamepadTransformControls = class extends GamepadControls {
 		object.quaternion.copy(this.#rotationQuaternion2).multiply(this.#rotationQuaternion).multiply(this.#quaternionStart).normalize();
 		object.updateMatrixWorld();
 	}
+	/**
+	* Applies scale along the selected axis or uniformly across all axes.
+	*
+	* @param deltaTime - Seconds since the last frame.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @returns `true` when the attached object scaled.
+	*/
 	#applyScale(deltaTime, transformX, transformY) {
 		const controls = this.#controls;
 		const object = controls.object;
@@ -489,11 +652,24 @@ var GamepadTransformControls = class extends GamepadControls {
 		object.updateMatrixWorld();
 		return true;
 	}
+	/**
+	* Projects stick input onto the selected scale axis.
+	*
+	* @param axis - Transform axis or plane currently selected.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @returns Signed scale input for the current frame.
+	*/
 	#getProjectedScaleInput(axis, transformX, transformY) {
 		if (axis !== "X" && axis !== "Y" && axis !== "Z") return this.#getDominantInput(transformX, -transformY);
 		this.#getTransformAxisWorld(axis, "local", this.#axisWorld);
 		return this.#getProjectedAxisInput(this.#axisWorld, transformX, transformY, this.#getDominantInput(transformX, -transformY));
 	}
+	/**
+	* Refreshes camera vectors, object world position, and viewport scale.
+	*
+	* @param object - Object attached to TransformControls.
+	*/
 	#updateCameraState(object) {
 		const camera = this.#controls.camera;
 		camera.updateMatrixWorld();
@@ -506,6 +682,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#eye.copy(this.#cameraWorldPosition).sub(this.#worldPosition).normalize();
 		this.#updateViewSizeAtObjectDepth(camera);
 	}
+	/**
+	* Computes world-space viewport size at the attached object's depth.
+	*
+	* @param camera - TransformControls camera.
+	*/
 	#updateViewSizeAtObjectDepth(camera) {
 		if (this.#isOrthographicCamera(camera)) {
 			this.#viewSize.set(Math.abs(camera.right - camera.left) / camera.zoom, Math.abs(camera.top - camera.bottom) / camera.zoom);
@@ -519,16 +700,41 @@ var GamepadTransformControls = class extends GamepadControls {
 		}
 		this.#viewSize.set(1, 1);
 	}
+	/**
+	* Resolves a transform axis letter to a normalized world-space direction.
+	*
+	* @param axis - Axis letter to resolve.
+	* @param space - Transform space used to orient the axis.
+	* @param target - Vector that receives the axis direction.
+	* @returns The normalized target vector.
+	*/
 	#getTransformAxisWorld(axis, space, target) {
 		this.#setUnitAxis(axis, target);
 		if (space === "local") target.applyQuaternion(this.#worldQuaternionStart);
 		return target.normalize();
 	}
+	/**
+	* Projects stick input onto the screen-space tangent of a rotation axis.
+	*
+	* @param axisWorld - Rotation axis in world space.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @returns Signed rotation input for the current frame.
+	*/
 	#getRotationAxisInput(axisWorld, transformX, transformY) {
 		this.#axisWorld2.crossVectors(axisWorld, this.#eye);
 		if (this.#axisWorld2.lengthSq() < PROJECTED_AXIS_EPSILON) return this.#getDominantInput(transformX, -transformY);
 		return this.#getProjectedAxisInput(this.#axisWorld2.normalize(), transformX, transformY, this.#getDominantInput(transformX, -transformY));
 	}
+	/**
+	* Projects two-axis stick input onto a world axis as seen by the camera.
+	*
+	* @param axisWorld - World-space axis to project onto the screen.
+	* @param transformX - Horizontal transform input after dead zone processing.
+	* @param transformY - Vertical transform input after dead zone processing.
+	* @param fallback - Value to use when the axis has no stable screen projection.
+	* @returns Signed input along the projected axis.
+	*/
 	#getProjectedAxisInput(axisWorld, transformX, transformY, fallback) {
 		const screenX = axisWorld.dot(this.#cameraRight);
 		const screenY = -axisWorld.dot(this.#cameraUp);
@@ -536,11 +742,24 @@ var GamepadTransformControls = class extends GamepadControls {
 		if (length < PROJECTED_AXIS_EPSILON) return fallback;
 		return (transformX * screenX + transformY * screenY) / length;
 	}
+	/**
+	* Converts a world-space movement delta into the object's parent-local space.
+	*
+	* @param worldDelta - World-space delta to convert.
+	* @param target - Vector that receives the local delta.
+	* @returns The target vector containing the local delta.
+	*/
 	#worldDeltaToLocalDelta(worldDelta, target) {
 		target.copy(worldDelta).applyQuaternion(this.#parentQuaternionInv);
 		this.#divideByParentScale(target);
 		return target;
 	}
+	/**
+	* Converts a local position to world space into the reusable world position.
+	*
+	* @param object - Object whose parent space contains the local position.
+	* @param localPosition - Local position to convert.
+	*/
 	#localPositionToWorld(object, localPosition) {
 		if (object.parent === null) {
 			this.#worldPosition.copy(localPosition);
@@ -549,6 +768,12 @@ var GamepadTransformControls = class extends GamepadControls {
 		object.parent.updateWorldMatrix(true, false);
 		this.#worldPosition.copy(localPosition).applyMatrix4(object.parent.matrixWorld);
 	}
+	/**
+	* Converts a world position to object parent-local space into snapped position.
+	*
+	* @param object - Object whose parent space should receive the result.
+	* @param worldPosition - World-space position to convert.
+	*/
 	#worldPositionToLocal(object, worldPosition) {
 		if (object.parent === null) {
 			this.#snappedPosition.copy(worldPosition);
@@ -558,11 +783,23 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#parentInverse.copy(object.parent.matrixWorld).invert();
 		this.#snappedPosition.copy(worldPosition).applyMatrix4(this.#parentInverse);
 	}
+	/**
+	* Removes captured parent scale from a local-space delta.
+	*
+	* @param target - Vector to adjust in place.
+	*/
 	#divideByParentScale(target) {
 		target.x = this.#parentScale.x === 0 ? 0 : target.x / this.#parentScale.x;
 		target.y = this.#parentScale.y === 0 ? 0 : target.y / this.#parentScale.y;
 		target.z = this.#parentScale.z === 0 ? 0 : target.z / this.#parentScale.z;
 	}
+	/**
+	* Writes a unit axis vector into a target vector.
+	*
+	* @param axis - Axis letter to write.
+	* @param target - Vector that receives the unit axis.
+	* @returns The target vector.
+	*/
 	#setUnitAxis(axis, target) {
 		switch (axis) {
 			case "X": return target.set(1, 0, 0);
@@ -570,6 +807,13 @@ var GamepadTransformControls = class extends GamepadControls {
 			case "Z": return target.set(0, 0, 1);
 		}
 	}
+	/**
+	* Reads one component from a vector by axis letter.
+	*
+	* @param vector - Vector to inspect.
+	* @param axis - Component axis to read.
+	* @returns The selected component value.
+	*/
 	#getVectorComponent(vector, axis) {
 		switch (axis) {
 			case "X": return vector.x;
@@ -577,6 +821,13 @@ var GamepadTransformControls = class extends GamepadControls {
 			case "Z": return vector.z;
 		}
 	}
+	/**
+	* Writes one component on a vector by axis letter.
+	*
+	* @param vector - Vector to modify.
+	* @param axis - Component axis to write.
+	* @param value - Component value to assign.
+	*/
 	#setVectorComponent(vector, axis, value) {
 		switch (axis) {
 			case "X":
@@ -590,19 +841,52 @@ var GamepadTransformControls = class extends GamepadControls {
 				return;
 		}
 	}
+	/**
+	* Applies TransformControls rotation snapping to an angle.
+	*
+	* @param value - Angle in radians.
+	* @returns Snapped angle, or the original angle when snapping is disabled.
+	*/
 	#snapRotation(value) {
 		const snap = this.#controls.rotationSnap;
 		return snap === null || snap <= 0 ? value : this.#snapValue(value, snap);
 	}
+	/**
+	* Snaps a numeric value to the nearest interval.
+	*
+	* @param value - Value to snap.
+	* @param snap - Snap interval.
+	* @returns Value rounded to the nearest snap interval.
+	*/
 	#snapValue(value, snap) {
 		return Math.round(value / snap) * snap;
 	}
+	/**
+	* Snaps a scale component while avoiding zero scale.
+	*
+	* @param value - Scale component to snap.
+	* @param snap - Snap interval.
+	* @returns Snapped scale component.
+	*/
 	#snapScale(value, snap) {
 		return this.#snapValue(value, snap) || snap;
 	}
+	/**
+	* Chooses the larger-magnitude stick component for ambiguous transforms.
+	*
+	* @param inputX - Horizontal input component.
+	* @param inputY - Vertical input component.
+	* @returns The input component with the larger absolute magnitude.
+	*/
 	#getDominantInput(inputX, inputY) {
 		return Math.abs(inputX) >= Math.abs(inputY) ? inputX : inputY;
 	}
+	/**
+	* Tracks pressed buttons and returns those newly pressed this frame.
+	*
+	* @param gamepad - Fresh gamepad snapshot to read from.
+	* @returns Button indices that transitioned to pressed.
+	*/
 	#getStartedButtons(gamepad) {
 		const startedButtons = /* @__PURE__ */ new Set();
 		for (let index = 0; index < gamepad.buttons.length; index += 1) {
@@ -615,9 +899,21 @@ var GamepadTransformControls = class extends GamepadControls {
 		}
 		return startedButtons;
 	}
+	/**
+	* Narrows a Three.js camera to `PerspectiveCamera`.
+	*
+	* @param camera - Camera to inspect.
+	* @returns `true` when the camera is perspective.
+	*/
 	#isPerspectiveCamera(camera) {
 		return camera.isPerspectiveCamera === true;
 	}
+	/**
+	* Narrows a Three.js camera to `OrthographicCamera`.
+	*
+	* @param camera - Camera to inspect.
+	* @returns `true` when the camera is orthographic.
+	*/
 	#isOrthographicCamera(camera) {
 		return camera.isOrthographicCamera === true;
 	}

package/dist/index.d.ts

@@ -4,9 +4,10 @@ import { GamepadArcballControls, GamepadArcballControlsOptions } from "./gamepad
 import { GamepadDragControls, GamepadDragControlsOptions } from "./gamepad-drag-controls.js";
 import { GamepadFirstPersonControls, GamepadFirstPersonControlsOptions } from "./gamepad-first-person-controls.js";
 import { GamepadFlyControls, GamepadFlyControlsOptions } from "./gamepad-fly-controls.js";
+import { GamepadAxisOptions, GamepadInput, GamepadInputEventMap, GamepadInputOptions, GamepadStick } from "./gamepad-input.js";
 import { GamepadOrbitControls, GamepadOrbitControlsOptions } from "./gamepad-orbit-controls.js";
 import { GamepadMapControls } from "./gamepad-map-controls.js";
 import { GamepadPointerLockControls, GamepadPointerLockControlsOptions } from "./gamepad-pointer-lock-controls.js";
 import { GamepadTrackballControls, GamepadTrackballControlsOptions } from "./gamepad-trackball-controls.js";
 import { GamepadTransformControls, GamepadTransformControlsOptions } from "./gamepad-transform-controls.js";
-export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadArcballControlsOptions, GamepadAxisKey, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, GamepadControls, GamepadControlsEventMap, GamepadDragControls, GamepadDragControlsOptions, GamepadFirstPersonControls, GamepadFirstPersonControlsOptions, GamepadFlyControls, GamepadFlyControlsOptions, GamepadMapControls, GamepadOrbitControls, GamepadOrbitControlsOptions, GamepadPointerLockControls, GamepadPointerLockControlsOptions, GamepadTrackballControls, GamepadTrackballControlsOptions, GamepadTransformControls, GamepadTransformControlsOptions };
+export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadArcballControlsOptions, GamepadAxisKey, GamepadAxisOptions, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, GamepadControls, GamepadControlsEventMap, GamepadDragControls, GamepadDragControlsOptions, GamepadFirstPersonControls, GamepadFirstPersonControlsOptions, GamepadFlyControls, GamepadFlyControlsOptions, GamepadInput, GamepadInputEventMap, GamepadInputOptions, GamepadMapControls, GamepadOrbitControls, GamepadOrbitControlsOptions, GamepadPointerLockControls, GamepadPointerLockControlsOptions, GamepadStick, GamepadTrackballControls, GamepadTrackballControlsOptions, GamepadTransformControls, GamepadTransformControlsOptions };

package/dist/index.js

@@ -4,9 +4,10 @@ import { GamepadArcballControls } from "./gamepad-arcball-controls.js";
 import { GamepadDragControls } from "./gamepad-drag-controls.js";
 import { GamepadFirstPersonControls } from "./gamepad-first-person-controls.js";
 import { GamepadFlyControls } from "./gamepad-fly-controls.js";
+import { GamepadInput } from "./gamepad-input.js";
 import { GamepadOrbitControls } from "./gamepad-orbit-controls.js";
 import { GamepadMapControls } from "./gamepad-map-controls.js";
 import { GamepadPointerLockControls } from "./gamepad-pointer-lock-controls.js";
 import { GamepadTrackballControls } from "./gamepad-trackball-controls.js";
 import { GamepadTransformControls } from "./gamepad-transform-controls.js";
-export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadControls, GamepadDragControls, GamepadFirstPersonControls, GamepadFlyControls, GamepadMapControls, GamepadOrbitControls, GamepadPointerLockControls, GamepadTrackballControls, GamepadTransformControls };
+export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadControls, GamepadDragControls, GamepadFirstPersonControls, GamepadFlyControls, GamepadInput, GamepadMapControls, GamepadOrbitControls, GamepadPointerLockControls, GamepadTrackballControls, GamepadTransformControls };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "three-gamepad-controls",
   "description": "Gamepad support for Three.js controls.",
-  "version": "0.10.6",
+  "version": "0.11.0",
   "homepage": "https://github.com/luckasnix/three-gamepad-controls#readme",
   "author": {
     "name": "Kasnix",