@threlte/rapier 3.0.0-next.14 → 3.0.0-next.15

package/dist/components/Attractor/Attractor.svelte.d.ts

@@ -1,34 +1,4 @@
-import { Props } from '@threlte/core'
-import { SvelteComponent } from 'svelte'
-import type { Group } from 'three'
-import type { GravityType } from '../../types/types'
-
-type AttractorProps = Props<Group> & {
-  /**
-   * The strength factor applied to the impulse affecting rigid-bodies within range. For newtonian
-   * calculations, strength is treated as m1 mass.
-   * Default: 1.0
-   */
-  strength?: number
-  /**
-   * The radius for the Attractor's sphere of influence within which rigid-bodies will be affected.
-   * Default: 10.0
-   */
-  range?: number
-  /**
-   * The method of calculating gravity on rigid bodies within range.
-   * 'static' = the same force (strength) is applied on bodies within range, regardless of distance
-   * 'linear' = force is calculated as strength * distance / range (force decreases the farther a body is from the attractor position)
-   * 'newtonian' = force is calculated as gravitationalConstant * mass1 * mass2 / Math.pow(distance, 2)
-   * Default: 'static'
-   */
-  gravityType?: GravityType
-  /**
-   * The gravitational constant used to calculate force in newtonian calculations. Most people probably won't use this,
-   * but it provides an option for more realistic physics simulations.
-   * Default: 6.673e-11
-   */
-  gravitationalConstant?: number
-}
-
-export default class Attractor extends SvelteComponent<AttractorProps> {}
+/// <reference types="svelte" />
+import type { AttractorProps } from './types';
+declare const Attractor: import("svelte").Component<AttractorProps, {}, "ref">;
+export default Attractor;

package/dist/components/Attractor/types.d.ts

@@ -0,0 +1,30 @@
+import type { Props } from '@threlte/core';
+import type { Group } from 'three';
+import type { GravityType } from '../../types/types';
+export type AttractorProps = Props<Group> & {
+    /**
+     * The strength factor applied to the impulse affecting rigid-bodies within range. For newtonian
+     * calculations, strength is treated as m1 mass.
+     * Default: 1.0
+     */
+    strength?: number;
+    /**
+     * The radius for the Attractor's sphere of influence within which rigid-bodies will be affected.
+     * Default: 10.0
+     */
+    range?: number;
+    /**
+     * The method of calculating gravity on rigid bodies within range.
+     * 'static' = the same force (strength) is applied on bodies within range, regardless of distance
+     * 'linear' = force is calculated as strength * distance / range (force decreases the farther a body is from the attractor position)
+     * 'newtonian' = force is calculated as gravitationalConstant * mass1 * mass2 / Math.pow(distance, 2)
+     * Default: 'static'
+     */
+    gravityType?: GravityType;
+    /**
+     * The gravitational constant used to calculate force in newtonian calculations. Most people probably won't use this,
+     * but it provides an option for more realistic physics simulations.
+     * Default: 6.673e-11
+     */
+    gravitationalConstant?: number;
+};

package/dist/components/Attractor/types.js

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

package/dist/components/Colliders/{AutoColliders.svelte → AutoColliders/AutoColliders.svelte}

@@ -1,16 +1,19 @@
-<script lang="ts">import { ActiveCollisionTypes, CoefficientCombineRule } from '@dimforge/rapier3d-compat';
+<script
+  lang="ts"
+  generics="TMassDef extends MassDef"
+>import { ActiveCollisionTypes, CoefficientCombineRule } from '@dimforge/rapier3d-compat';
 import { createParentObject3DContext, useParentObject3D, watch } from '@threlte/core';
 import { onDestroy, onMount } from 'svelte';
 import { Group } from 'three';
-import { useCollisionGroups } from '../../hooks/useCollisionGroups';
-import { useRapier } from '../../hooks/useRapier';
-import { useRigidBody } from '../../hooks/useRigidBody';
-import { applyColliderActiveEvents } from '../../lib/applyColliderActiveEvents';
-import { createCollidersFromChildren } from '../../lib/createCollidersFromChildren';
-import { eulerToQuaternion } from '../../lib/eulerToQuaternion';
-import { useParentRigidbodyObject } from '../../lib/rigidBodyObjectContext';
-import { useCreateEvent } from '../../lib/useCreateEvent';
-let { shape = 'convexHull', restitution, restitutionCombineRule, friction, frictionCombineRule, sensor, contactForceEventThreshold, density, mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame, refresh = $bindable(() => create()), colliders = $bindable(), oncreate, oncollisionenter, oncollisionexit, oncontact, onsensorenter, onsensorexit, children } = $props();
+import { useCollisionGroups } from '../../../hooks/useCollisionGroups';
+import { useRapier } from '../../../hooks/useRapier';
+import { useRigidBody } from '../../../hooks/useRigidBody';
+import { applyColliderActiveEvents } from '../../../lib/applyColliderActiveEvents';
+import { createCollidersFromChildren } from '../../../lib/createCollidersFromChildren';
+import { eulerToQuaternion } from '../../../lib/eulerToQuaternion';
+import { useParentRigidbodyObject } from '../../../lib/rigidBodyObjectContext';
+import { useCreateEvent } from '../../../lib/useCreateEvent';
+let { shape = 'convexHull', restitution, restitutionCombineRule, friction, frictionCombineRule, sensor, contactForceEventThreshold, density, mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame, colliders = $bindable(), oncreate, oncollisionenter, oncollisionexit, oncontact, onsensorenter, onsensorexit, children } = $props();
 const group = new Group();
 const { updateRef } = useCreateEvent(oncreate);
 const rigidBody = useRigidBody();
@@ -63,6 +66,10 @@ const create = () => {
     });
     updateRef(colliders);
 };
+/**
+ * Refresh the colliders.
+ */
+export const refresh = () => create();
 onMount(() => {
     create();
 });

package/dist/components/Colliders/AutoColliders/AutoColliders.svelte.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="svelte" />
+import type { AutoCollidersProps, MassDef } from './types';
+declare class __sveltets_Render<TMassDef extends MassDef> {
+    props(): AutoCollidersProps<TMassDef>;
+    events(): {};
+    slots(): {};
+    bindings(): "colliders";
+    exports(): {
+        /**
+           * Refresh the colliders.
+           */ refresh: () => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <TMassDef extends MassDef>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TMassDef>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TMassDef>['props']>, ReturnType<__sveltets_Render<TMassDef>['events']>, ReturnType<__sveltets_Render<TMassDef>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TMassDef>['bindings']>;
+    } & ReturnType<__sveltets_Render<TMassDef>['exports']>;
+    <TMassDef extends MassDef>(internal: unknown, props: ReturnType<__sveltets_Render<TMassDef>['props']> & {}): ReturnType<__sveltets_Render<TMassDef>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const AutoColliders: $$IsomorphicComponent;
+type AutoColliders<TMassDef extends MassDef> = InstanceType<typeof AutoColliders<TMassDef>>;
+export default AutoColliders;

package/dist/components/Colliders/AutoColliders/types.d.ts

@@ -0,0 +1,74 @@
+import type { CoefficientCombineRule, Collider } from '@dimforge/rapier3d-compat';
+import { type Snippet } from 'svelte';
+import type { Euler, Vector3 } from 'three';
+import type { AutoCollidersShapes, ColliderEvents, CreateEvent } from '../../../types/types';
+type BaseProps = {
+    /**
+     * The shape of the collider.
+     */
+    shape?: AutoCollidersShapes;
+    /** The restitution coefficient of this collider. */
+    restitution?: number;
+    /** he rule used to combine the restitution coefficients of two colliders involved in a contact. */
+    restitutionCombineRule?: CoefficientCombineRule;
+    /** The friction coefficient of this collider. */
+    friction?: number;
+    /** The rule used to combine the friction coefficients of two colliders involved in a contact. */
+    frictionCombineRule?: CoefficientCombineRule;
+    /** Whether this collider is a sensor. A sensor collider does not generate
+     * contacts. They only generate intersection events when one sensor collider
+     * and another collider start/stop touching. Sensor colliders are generally
+     * used to detect when something enters an area. Note that, for symmetry with
+     * non-sensor colliders, sensors do contribute to the mass of a rigid-body
+     * they are attached to.
+     */
+    sensor?: boolean;
+    colliders?: Collider[];
+    /** The total force magnitude beyond which a contact force event can be emitted. */
+    contactForceEventThreshold?: number;
+};
+type Density = {
+    /** The density of this collider. */
+    density: number;
+    mass?: never;
+    centerOfMass?: never;
+    principalAngularInertia?: never;
+    angularInertiaLocalFrame?: never;
+};
+type Mass = {
+    /** The mass of this collider. */
+    mass: number;
+    density?: never;
+    centerOfMass?: never;
+    principalAngularInertia?: never;
+    angularInertiaLocalFrame?: never;
+};
+type MassProperties = {
+    /** The mass of this collider. */
+    mass: number;
+    /** The center of mass of this collider. */
+    centerOfMass: Parameters<Vector3['set']>;
+    /** The principal angular inertia of this collider. */
+    principalAngularInertia: Parameters<Vector3['set']>;
+    /** The angular inertia local frame of this collider. */
+    angularInertiaLocalFrame: Parameters<Euler['set']>;
+    density?: never;
+};
+type NoMassProperties = {
+    density?: never;
+    mass?: never;
+    centerOfMass?: never;
+    principalAngularInertia?: never;
+    angularInertiaLocalFrame?: never;
+};
+export type MassDef = Density | Mass | MassProperties | NoMassProperties;
+type MassProps<TMassDef extends MassDef> = TMassDef extends Density ? Density : TMassDef extends MassProperties ? MassProperties : TMassDef extends Mass ? Mass : NoMassProperties;
+export type AutoCollidersProps<TMassDef extends MassDef> = CreateEvent<Collider[]> & ColliderEvents & BaseProps & MassProps<TMassDef> & {
+    children?: Snippet<[
+        {
+            colliders: Collider[];
+            refresh: () => void;
+        }
+    ]>;
+};
+export {};

package/dist/components/Colliders/AutoColliders/types.js

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

package/dist/components/Colliders/{Collider.svelte → Collider/Collider.svelte}

@@ -1,22 +1,20 @@
-<script lang="ts">import { ActiveCollisionTypes, CoefficientCombineRule, Collider, ColliderDesc } from '@dimforge/rapier3d-compat';
+<script
+  lang="ts"
+  generics="TShape extends Shape, TMassDef extends MassDef"
+>import { ActiveCollisionTypes, CoefficientCombineRule, ColliderDesc } from '@dimforge/rapier3d-compat';
 import { createParentObject3DContext, useParentObject3D, useTask, watch } from '@threlte/core';
 import { onDestroy, onMount, tick } from 'svelte';
 import { Object3D, Quaternion, Vector3 } from 'three';
-import { useCollisionGroups } from '../../hooks/useCollisionGroups';
-import { useRapier } from '../../hooks/useRapier';
-import { useRigidBody } from '../../hooks/useRigidBody';
-import { applyColliderActiveEvents } from '../../lib/applyColliderActiveEvents';
-import { eulerToQuaternion } from '../../lib/eulerToQuaternion';
-import { getWorldPosition, getWorldQuaternion } from '../../lib/getWorldTransforms';
-import { useParentRigidbodyObject } from '../../lib/rigidBodyObjectContext';
-import { scaleColliderArgs } from '../../lib/scaleColliderArgs';
-import { useCreateEvent } from '../../lib/useCreateEvent';
-let { shape, args, type, restitution, restitutionCombineRule, friction, frictionCombineRule, sensor, contactForceEventThreshold, density, mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame, collider = $bindable(), refresh = $bindable(() => {
-    if (!collider)
-        return;
-    collider.setTranslation(getWorldPosition(object));
-    collider.setRotation(getWorldQuaternion(object));
-}), oncreate, oncollisionenter, oncollisionexit, oncontact, onsensorenter, onsensorexit, children } = $props();
+import { useCollisionGroups } from '../../../hooks/useCollisionGroups';
+import { useRapier } from '../../../hooks/useRapier';
+import { useRigidBody } from '../../../hooks/useRigidBody';
+import { applyColliderActiveEvents } from '../../../lib/applyColliderActiveEvents';
+import { eulerToQuaternion } from '../../../lib/eulerToQuaternion';
+import { getWorldPosition, getWorldQuaternion } from '../../../lib/getWorldTransforms';
+import { useParentRigidbodyObject } from '../../../lib/rigidBodyObjectContext';
+import { scaleColliderArgs } from '../../../lib/scaleColliderArgs';
+import { useCreateEvent } from '../../../lib/useCreateEvent';
+let { shape, args, type, restitution, restitutionCombineRule, friction, frictionCombineRule, sensor, contactForceEventThreshold, density, mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame, collider = $bindable(), oncreate, oncollisionenter, oncollisionexit, oncontact, onsensorenter, onsensorexit, children } = $props();
 const object = new Object3D();
 const { updateRef } = useCreateEvent(oncreate);
 const rigidBody = useRigidBody();
@@ -108,6 +106,12 @@ $effect.pre(() => {
         applyColliderActiveEvents(collider, events, rigidBody?.userData?.events);
     }
 });
+export const refresh = () => {
+    if (!collider)
+        return;
+    collider.setTranslation(getWorldPosition(object));
+    collider.setRotation(getWorldQuaternion(object));
+};
 /**
  * If the Collider isAttached (i.e. NOT child of a RigidBody), update the
  * transforms on every frame.

package/dist/components/Colliders/Collider/Collider.svelte.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="svelte" />
+import type { ColliderProps, MassDef, Shape } from './types';
+declare class __sveltets_Render<TShape extends Shape, TMassDef extends MassDef> {
+    props(): ColliderProps<TShape, TMassDef>;
+    events(): {};
+    slots(): {};
+    bindings(): "collider";
+    exports(): {
+        refresh: () => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <TShape extends Shape, TMassDef extends MassDef>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TShape, TMassDef>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TShape, TMassDef>['props']>, ReturnType<__sveltets_Render<TShape, TMassDef>['events']>, ReturnType<__sveltets_Render<TShape, TMassDef>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TShape, TMassDef>['bindings']>;
+    } & ReturnType<__sveltets_Render<TShape, TMassDef>['exports']>;
+    <TShape extends Shape, TMassDef extends MassDef>(internal: unknown, props: ReturnType<__sveltets_Render<TShape, TMassDef>['props']> & {}): ReturnType<__sveltets_Render<TShape, TMassDef>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const Collider: $$IsomorphicComponent;
+type Collider<TShape extends Shape, TMassDef extends MassDef> = InstanceType<typeof Collider<TShape, TMassDef>>;
+export default Collider;

package/dist/components/Colliders/Collider/types.d.ts

@@ -0,0 +1,83 @@
+import type { CoefficientCombineRule, Collider, ColliderDesc, Collider as RapierCollider } from '@dimforge/rapier3d-compat';
+import { type Snippet } from 'svelte';
+import type { Euler, Vector3 } from 'three';
+import type { ColliderEvents, CreateEvent } from '../../../types/types';
+type Type = 'static' | 'dynamic';
+type BaseProps = {
+    /**
+     * If a collider is *not* attached to a RigidBody and its type is `static`,
+     * its transform is only applied once on initialization. If the transform
+     * should be updated every frame, set the type to `dynamic`.
+     */
+    type?: Type;
+    /** The restitution coefficient of this collider. */
+    restitution?: number;
+    /** he rule used to combine the restitution coefficients of two colliders involved in a contact. */
+    restitutionCombineRule?: CoefficientCombineRule;
+    /** The friction coefficient of this collider. */
+    friction?: number;
+    /** The rule used to combine the friction coefficients of two colliders involved in a contact. */
+    frictionCombineRule?: CoefficientCombineRule;
+    /** Whether this collider is a sensor. A sensor collider does not generate
+     * contacts. They only generate intersection events when one sensor collider
+     * and another collider start/stop touching. Sensor colliders are generally
+     * used to detect when something enters an area. Note that, for symmetry with
+     * non-sensor colliders, sensors do contribute to the mass of a rigid-body
+     * they are attached to.
+     */
+    sensor?: boolean;
+    collider?: RapierCollider;
+    /** The total force magnitude beyond which a contact force event can be emitted. */
+    contactForceEventThreshold?: number;
+};
+/**
+ * The shape of the collider.
+ */
+export type Shape = 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh';
+type Args<TShape extends Shape> = Parameters<(typeof ColliderDesc)[TShape]>;
+type ShapeProps<TShape extends Shape> = {
+    shape: TShape;
+    args: Args<TShape>;
+};
+type Density = {
+    /** The density of this collider. */
+    density: number;
+    mass?: never;
+    centerOfMass?: never;
+    principalAngularInertia?: never;
+    angularInertiaLocalFrame?: never;
+};
+type Mass = {
+    /** The mass of this collider. */
+    mass: number;
+    density?: never;
+    centerOfMass?: never;
+    principalAngularInertia?: never;
+    angularInertiaLocalFrame?: never;
+};
+type MassProperties = {
+    /** The mass of this collider. */
+    mass: number;
+    /** The center of mass of this collider. */
+    centerOfMass: Parameters<Vector3['set']>;
+    /** The principal angular inertia of this collider. */
+    principalAngularInertia: Parameters<Vector3['set']>;
+    /** The angular inertia local frame of this collider. */
+    angularInertiaLocalFrame: Parameters<Euler['set']>;
+    density?: never;
+};
+type NoMassProperties = {
+    density?: never;
+    mass?: never;
+    centerOfMass?: never;
+    principalAngularInertia?: never;
+    angularInertiaLocalFrame?: never;
+};
+export type MassDef = Density | Mass | MassProperties | NoMassProperties;
+type MassProps<TMassDef extends MassDef> = TMassDef extends Density ? Density : TMassDef extends MassProperties ? MassProperties : TMassDef extends Mass ? Mass : NoMassProperties;
+export type ColliderProps<TShape extends Shape, TMassDef extends MassDef> = CreateEvent<Collider> & ColliderEvents & BaseProps & ShapeProps<TShape> & MassProps<TMassDef> & {
+    children?: Snippet<[{
+        collider?: RapierCollider;
+    }]>;
+};
+export {};

package/dist/components/Colliders/Collider/types.js

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

package/dist/components/CollisionGroups/CollisionGroups.svelte

@@ -1,4 +1,7 @@
-<script lang="ts">import { setContext } from 'svelte';
+<script
+  lang="ts"
+  generics="TGroupsDef extends GroupsDef"
+>import { setContext } from 'svelte';
 import { writable } from 'svelte/store';
 import { computeBitMask } from '../../lib/computeBitMask';
 let { groups, filter, memberships, children } = $props();

package/dist/components/CollisionGroups/CollisionGroups.svelte.d.ts

@@ -1,35 +1,19 @@
-import { SvelteComponent, type Snippet } from 'svelte'
-
-type N = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15
-
-export type Groups = N[]
-
-export type MembershipsAndFilter = N[]
-
-type GroupsProps = {
-  groups: N[]
-
-  filter?: never
-  memberships?: never
-
-  children?: Snippet
+/// <reference types="svelte" />
+import type { CollisionGroupsProps, GroupsDef } from './types';
+declare class __sveltets_Render<TGroupsDef extends GroupsDef> {
+    props(): CollisionGroupsProps<TGroupsDef>;
+    events(): {};
+    slots(): {};
+    bindings(): "";
+    exports(): {};
 }
-
-type MembershipsAndFilterProps = {
-  filter: N[]
-  memberships: N[]
-
-  groups?: never
-
-  children?: Snippet
+interface $$IsomorphicComponent {
+    new <TGroupsDef extends GroupsDef>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TGroupsDef>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TGroupsDef>['props']>, ReturnType<__sveltets_Render<TGroupsDef>['events']>, ReturnType<__sveltets_Render<TGroupsDef>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TGroupsDef>['bindings']>;
+    } & ReturnType<__sveltets_Render<TGroupsDef>['exports']>;
+    <TGroupsDef extends GroupsDef>(internal: unknown, props: ReturnType<__sveltets_Render<TGroupsDef>['props']> & {}): ReturnType<__sveltets_Render<TGroupsDef>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
-
-type GroupsDef = GroupsProps | MembershipsAndFilterProps
-
-export type CollisionGroupsProps<TGroupsDef extends GroupsDef> = TGroupsDef extends GroupsProps
-  ? GroupsProps
-  : MembershipsAndFilterProps
-
-export default class CollisionGroups<TGroupsDef extends GroupsDef> extends SvelteComponent<
-  CollisionGroupsProps<TGroupsDef>
-> {}
+declare const CollisionGroups: $$IsomorphicComponent;
+type CollisionGroups<TGroupsDef extends GroupsDef> = InstanceType<typeof CollisionGroups<TGroupsDef>>;
+export default CollisionGroups;

package/dist/components/CollisionGroups/types.d.ts

@@ -0,0 +1,19 @@
+import { type Snippet } from 'svelte';
+type N = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+export type Groups = N[];
+export type MembershipsAndFilter = N[];
+type GroupsProps = {
+    groups: N[];
+    filter?: never;
+    memberships?: never;
+    children?: Snippet;
+};
+type MembershipsAndFilterProps = {
+    filter: N[];
+    memberships: N[];
+    groups?: never;
+    children?: Snippet;
+};
+export type GroupsDef = GroupsProps | MembershipsAndFilterProps;
+export type CollisionGroupsProps<TGroupsDef extends GroupsDef> = TGroupsDef extends GroupsProps ? GroupsProps : MembershipsAndFilterProps;
+export {};

package/dist/components/CollisionGroups/types.js

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

package/dist/components/Debug/Debug.svelte

@@ -1,8 +1,8 @@
 <script lang="ts">import { T, useTask } from '@threlte/core';
 import { onDestroy } from 'svelte';
-import { BufferAttribute, BufferGeometry } from 'three';
+import { BufferAttribute, BufferGeometry, LineSegments } from 'three';
 import { useRapier } from '../../hooks/useRapier';
-let { ref = $bindable(), ...props } = $props();
+let { ref = $bindable(new LineSegments()), ...props } = $props();
 const { world, debug } = useRapier();
 const geometry = new BufferGeometry();
 debug.set(true);
@@ -18,12 +18,12 @@ onDestroy(() => {
 });
 </script>
 
-<T.LineSegments
-  bind:ref
+<T
+  is={ref}
   frustumCulled={false}
   renderOrder={Infinity}
   {...props}
 >
   <T is={geometry} />
   <T.LineBasicMaterial vertexColors />
-</T.LineSegments>
+</T>

package/dist/components/Debug/Debug.svelte.d.ts

@@ -1,7 +1,4 @@
-import type { Props } from '@threlte/core'
-import { SvelteComponent } from 'svelte'
-import type { LineSegments } from 'three'
-
-export type DebugProps = Props<LineSegments>
-
-export default class Debug extends SvelteComponent<DebugProps> {}
+/// <reference types="svelte" />
+import type { DebugProps } from './types';
+declare const Debug: import("svelte").Component<DebugProps, {}, "ref">;
+export default Debug;

package/dist/components/Debug/types.d.ts

@@ -0,0 +1,3 @@
+import type { Props } from '@threlte/core';
+import type { LineSegments } from 'three';
+export type DebugProps = Props<LineSegments>;

package/dist/components/Debug/types.js

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

package/dist/components/RigidBody/RigidBody.svelte.d.ts

@@ -1,102 +1,4 @@
-import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type { Euler, Vector3 } from 'three'
-import type { RigidBodyTypeString } from '../../lib/parseRigidBodyType'
-import type { RigidBodyEvents } from '../../types/types'
-
-export type Boolean3Array = [x: boolean, y: boolean, z: boolean]
-
-export type RigidBodyProps = {
-  rigidBody?: RapierRigidBody | undefined
-
-  /**
-   * Specify the type of this rigid body
-   */
-  type?: RigidBodyTypeString
-
-  /** Whether or not this body can sleep.
-   * default: true
-   */
-  canSleep?: boolean
-
-  /** The linear velocity of this body.
-   * default: zero velocity
-   */
-  linearVelocity?: Parameters<Vector3['set']>
-
-  /** The angular velocity of this body.
-   * Default: zero velocity.
-   */
-  angularVelocity?: Parameters<Euler['set']>
-
-  /**
-   * The scaling factor applied to the gravity affecting the rigid-body.
-   * Default: 1.0
-   */
-  gravityScale?: number
-
-  /**
-   * Whether or not Continous Collision Detection is enabled for this rigid-body.
-   * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#continuous-collision-detection
-   * @default false
-   */
-  ccd?: boolean
-
-  /**
-   * Locks all rotations that would have resulted from forces on the created rigid-body.
-   */
-  lockRotations?: boolean
-
-  /**
-   * Locks all translations that would have resulted from forces on the created rigid-body.
-   */
-  lockTranslations?: boolean
-
-  /**
-   * Allow rotation of this rigid-body only along specific axes.
-   */
-  enabledRotations?: Boolean3Array
-
-  /**
-   * Allow translations of this rigid-body only along specific axes.
-   */
-  enabledTranslations?: Boolean3Array
-
-  /**
-   * Dominance is a non-realistic, but sometimes useful, feature.
-   * It can be used to make one rigid-body immune to forces
-   * originating from contacts with some other bodies.
-   *
-   * Number in the range -127 to 127, default is 0
-   */
-  dominance?: number
-
-  /**
-   * Damping lets you slow down a rigid-body automatically. This can be used to
-   * achieve a wide variety of effects like fake air friction. Larger values of
-   * damping coefficients lead to a stronger slow-downs. Their default
-   * values are 0.0 (no damping at all).
-   */
-  linearDamping?: number
-
-  /**
-   * Damping lets you slow down a rigid-body automatically. This can be used to
-   * achieve a wide variety of effects like fake air friction. Larger values of
-   * damping coefficients lead to a stronger slow-downs. Their default
-   * values are 0.0 (no damping at all).
-   */
-  angularDamping?: number
-
-  /**
-   * Set the rigidBody as enabled or disabled.
-   */
-  enabled?: boolean
-  /**
-   * An arbitrary user-defined object associated with this rigid-body.
-   */
-  userData?: Record<string, any>
-
-  children?: Snippet<[{ rigidBody: RapierRigidBody }]>
-}
-
-export default class RigidBody extends SvelteComponent<RigidBodyProps & RigidBodyEvents> {}
+/// <reference types="svelte" />
+import type { RigidBodyProps } from './types';
+declare const RigidBody: import("svelte").Component<RigidBodyProps, {}, "rigidBody">;
+export default RigidBody;

package/dist/components/RigidBody/types.d.ts

@@ -0,0 +1,85 @@
+import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
+import { type Snippet } from 'svelte';
+import type { Euler, Vector3 } from 'three';
+import type { RigidBodyTypeString } from '../../lib/parseRigidBodyType';
+import type { CreateEvent, RigidBodyEvents } from '../../types/types';
+export type Boolean3Array = [x: boolean, y: boolean, z: boolean];
+export type RigidBodyProps = CreateEvent<RapierRigidBody> & RigidBodyEvents & {
+    rigidBody?: RapierRigidBody | undefined;
+    /**
+     * Specify the type of this rigid body
+     */
+    type?: RigidBodyTypeString;
+    /** Whether or not this body can sleep.
+     * default: true
+     */
+    canSleep?: boolean;
+    /** The linear velocity of this body.
+     * default: zero velocity
+     */
+    linearVelocity?: Parameters<Vector3['set']>;
+    /** The angular velocity of this body.
+     * Default: zero velocity.
+     */
+    angularVelocity?: Parameters<Euler['set']>;
+    /**
+     * The scaling factor applied to the gravity affecting the rigid-body.
+     * Default: 1.0
+     */
+    gravityScale?: number;
+    /**
+     * Whether or not Continous Collision Detection is enabled for this rigid-body.
+     * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#continuous-collision-detection
+     * @default false
+     */
+    ccd?: boolean;
+    /**
+     * Locks all rotations that would have resulted from forces on the created rigid-body.
+     */
+    lockRotations?: boolean;
+    /**
+     * Locks all translations that would have resulted from forces on the created rigid-body.
+     */
+    lockTranslations?: boolean;
+    /**
+     * Allow rotation of this rigid-body only along specific axes.
+     */
+    enabledRotations?: Boolean3Array;
+    /**
+     * Allow translations of this rigid-body only along specific axes.
+     */
+    enabledTranslations?: Boolean3Array;
+    /**
+     * Dominance is a non-realistic, but sometimes useful, feature.
+     * It can be used to make one rigid-body immune to forces
+     * originating from contacts with some other bodies.
+     *
+     * Number in the range -127 to 127, default is 0
+     */
+    dominance?: number;
+    /**
+     * Damping lets you slow down a rigid-body automatically. This can be used to
+     * achieve a wide variety of effects like fake air friction. Larger values of
+     * damping coefficients lead to a stronger slow-downs. Their default
+     * values are 0.0 (no damping at all).
+     */
+    linearDamping?: number;
+    /**
+     * Damping lets you slow down a rigid-body automatically. This can be used to
+     * achieve a wide variety of effects like fake air friction. Larger values of
+     * damping coefficients lead to a stronger slow-downs. Their default
+     * values are 0.0 (no damping at all).
+     */
+    angularDamping?: number;
+    /**
+     * Set the rigidBody as enabled or disabled.
+     */
+    enabled?: boolean;
+    /**
+     * An arbitrary user-defined object associated with this rigid-body.
+     */
+    userData?: Record<string, any>;
+    children?: Snippet<[{
+        rigidBody: RapierRigidBody;
+    }]>;
+};

package/dist/components/RigidBody/types.js

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

package/dist/components/World/InnerWorld.svelte.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="svelte" />
-import type { WorldProps } from './World.svelte';
+import type { WorldProps } from './types';
 declare const InnerWorld: import("svelte").Component<WorldProps, {}, "">;
 export default InnerWorld;

package/dist/components/World/World.svelte.d.ts

@@ -1,49 +1,4 @@
-import type {
-  RawBroadPhase,
-  RawCCDSolver,
-  RawColliderSet,
-  RawDebugRenderPipeline,
-  RawImpulseJointSet,
-  RawIntegrationParameters,
-  RawIslandManager,
-  RawMultibodyJointSet,
-  RawNarrowPhase,
-  RawPhysicsPipeline,
-  RawQueryPipeline,
-  RawRigidBodySet,
-  RawSerializationPipeline
-} from '@dimforge/rapier3d-compat/raw'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type { Vector3 } from 'three'
-import type { Key, Stage } from '@threlte/core'
-
-export type WorldProps = {
-  framerate?: number | 'varying'
-  autoStart?: boolean
-  gravity?: Parameters<Vector3['set']>
-  rawIntegrationParameters?: RawIntegrationParameters
-  rawIslands?: RawIslandManager
-  rawBroadPhase?: RawBroadPhase
-  rawNarrowPhase?: RawNarrowPhase
-  rawBodies?: RawRigidBodySet
-  rawColliders?: RawColliderSet
-  rawImpulseJoints?: RawImpulseJointSet
-  rawMultibodyJoints?: RawMultibodyJointSet
-  rawCCDSolver?: RawCCDSolver
-  rawQueryPipeline?: RawQueryPipeline
-  rawPhysicsPipeline?: RawPhysicsPipeline
-  rawSerializationPipeline?: RawSerializationPipeline
-  rawDebugRenderPipeline?: RawDebugRenderPipeline
-  simulationStageOptions?: {
-    before?: (Key | Stage) | (Key | Stage)[]
-    after?: (Key | Stage) | (Key | Stage)[]
-  }
-  synchronizationStageOptions?: {
-    before?: (Key | Stage) | (Key | Stage)[]
-    after?: (Key | Stage) | (Key | Stage)[]
-  }
-  children?: Snippet
-  fallback?: Snippet<[error: any]>
-}
-
-export default class World extends SvelteComponent<WorldProps> {}
+/// <reference types="svelte" />
+import type { WorldProps } from './types';
+declare const World: import("svelte").Component<WorldProps, {}, "">;
+export default World;

package/dist/components/World/types.d.ts

@@ -0,0 +1,32 @@
+import type { RawBroadPhase, RawCCDSolver, RawColliderSet, RawDebugRenderPipeline, RawImpulseJointSet, RawIntegrationParameters, RawIslandManager, RawMultibodyJointSet, RawNarrowPhase, RawPhysicsPipeline, RawQueryPipeline, RawRigidBodySet, RawSerializationPipeline } from '@dimforge/rapier3d-compat/raw';
+import type { Key, Stage } from '@threlte/core';
+import { type Snippet } from 'svelte';
+import type { Vector3 } from 'three';
+export type WorldProps = {
+    framerate?: number | 'varying';
+    autoStart?: boolean;
+    gravity?: Parameters<Vector3['set']>;
+    rawIntegrationParameters?: RawIntegrationParameters;
+    rawIslands?: RawIslandManager;
+    rawBroadPhase?: RawBroadPhase;
+    rawNarrowPhase?: RawNarrowPhase;
+    rawBodies?: RawRigidBodySet;
+    rawColliders?: RawColliderSet;
+    rawImpulseJoints?: RawImpulseJointSet;
+    rawMultibodyJoints?: RawMultibodyJointSet;
+    rawCCDSolver?: RawCCDSolver;
+    rawQueryPipeline?: RawQueryPipeline;
+    rawPhysicsPipeline?: RawPhysicsPipeline;
+    rawSerializationPipeline?: RawSerializationPipeline;
+    rawDebugRenderPipeline?: RawDebugRenderPipeline;
+    simulationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+    synchronizationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+    children?: Snippet;
+    fallback?: Snippet<[error: any]>;
+};

package/dist/components/World/types.js

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

package/dist/index.d.ts

@@ -9,10 +9,9 @@ export { useJoint } from './hooks/useJoint';
 export { default as World } from './components/World/World.svelte';
 export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';
 export { default as Debug } from './components/Debug/Debug.svelte';
-export { default as Collider } from './components/Colliders/Collider.svelte';
-export { default as AutoColliders } from './components/Colliders/AutoColliders.svelte';
+export { default as Collider } from './components/Colliders/Collider/Collider.svelte';
+export { default as AutoColliders } from './components/Colliders/AutoColliders/AutoColliders.svelte';
 export { default as CollisionGroups } from './components/CollisionGroups/CollisionGroups.svelte';
 export { default as Attractor } from './components/Attractor/Attractor.svelte';
 export { computeBitMask } from './lib/computeBitMask';
-export { default as BasicPlayerController } from './recipes/BasicPlayerController.svelte';
-export type { CollisionGroupsBitMask, AutoCollidersShapes, ColliderEventDispatcher, ColliderShapes, RapierContext, RigidBodyEventDispatcher, CollisionEnterEvent, CollisionExitEvent, SensorEnterEvent, SensorExitEvent, ContactEvent, GravityType } from './types/types';
+export type { CollisionGroupsBitMask, AutoCollidersShapes, ColliderShapes, RapierContext, CollisionEnterEvent, CollisionExitEvent, SensorEnterEvent, SensorExitEvent, ContactEvent, GravityType, CreateEvent, Framerate } from './types/types';

package/dist/index.js

@@ -12,11 +12,9 @@ export { useJoint } from './hooks/useJoint';
 export { default as World } from './components/World/World.svelte';
 export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';
 export { default as Debug } from './components/Debug/Debug.svelte';
-export { default as Collider } from './components/Colliders/Collider.svelte';
-export { default as AutoColliders } from './components/Colliders/AutoColliders.svelte';
+export { default as Collider } from './components/Colliders/Collider/Collider.svelte';
+export { default as AutoColliders } from './components/Colliders/AutoColliders/AutoColliders.svelte';
 export { default as CollisionGroups } from './components/CollisionGroups/CollisionGroups.svelte';
 export { default as Attractor } from './components/Attractor/Attractor.svelte';
 // lib
 export { computeBitMask } from './lib/computeBitMask';
-// recipes
-export { default as BasicPlayerController } from './recipes/BasicPlayerController.svelte';

package/dist/lib/useCreateEvent.d.ts

@@ -1,4 +1,4 @@
-import type { ColliderEvents } from '../types/types';
-export declare const useCreateEvent: <T>(oncreate?: ColliderEvents['oncreate']) => {
+import type { CreateEvent } from '../types/types';
+export declare const useCreateEvent: <T>(oncreate?: CreateEvent<T>['oncreate']) => {
     updateRef: (newRef: T) => void;
 };

package/dist/lib/useCreateEvent.js

@@ -7,13 +7,11 @@ export const useCreateEvent = (oncreate) => {
         cleanupFunctions.forEach((cleanup) => cleanup());
         // clear the cleanup functions array
         cleanupFunctions.length = 0;
-        const cleanup = (callback) => {
-            // add cleanup function to array
-            cleanupFunctions.push(callback);
-        };
         if (ref === undefined)
             return;
-        oncreate?.({ ref, cleanup });
+        const cleanup = oncreate?.(ref);
+        if (cleanup)
+            cleanupFunctions.push(cleanup);
     };
     const updateRef = (newRef) => {
         ref = newRef;

package/dist/types/types.d.ts

@@ -6,11 +6,10 @@ import type { Readable, Writable } from 'svelte/store';
 import type { Object3D } from 'three';
 export type ColliderShapes = 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh';
 export type AutoCollidersShapes = 'cuboid' | 'ball' | 'trimesh' | 'convexHull' | 'capsule';
+export type CreateEvent<T> = {
+    oncreate?: (ref: T) => void | (() => void);
+};
 export type ColliderEvents = {
-    oncreate?: (event: {
-        ref: Collider;
-        cleanup: (callback: () => void) => void;
-    }) => void;
     oncollisionenter?: (event: {
         targetCollider: Collider;
         targetRigidBody: RigidBody | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threlte/rapier",
-  "version": "3.0.0-next.14",
+  "version": "3.0.0-next.15",
   "author": "Grischa Erbe <hello@legrisch.com> (https://legrisch.com)",
   "license": "MIT",
   "description": "Components and hooks to use the Rapier physics engine in Threlte",

package/dist/components/Colliders/AutoColliders.svelte.d.ts

@@ -1,84 +0,0 @@
-import type { CoefficientCombineRule, Collider } from '@dimforge/rapier3d-compat'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type { Euler, Vector3 } from 'three'
-import type { AutoCollidersShapes, ColliderEvents } from '../../types/types'
-
-// ------------------ BASE ------------------
-
-type BaseProps = {
-  shape?: AutoCollidersShapes
-  restitution?: number
-  restitutionCombineRule?: CoefficientCombineRule
-  friction?: number
-  frictionCombineRule?: CoefficientCombineRule
-  sensor?: boolean
-  colliders?: Collider[]
-  contactForceEventThreshold?: number
-
-  refresh?: () => void
-
-  oncreate?: () => void
-}
-
-// ------------------ MASS ------------------
-
-type Density = {
-  density: number
-
-  mass?: never
-  centerOfMass?: never
-  principalAngularInertia?: never
-  angularInertiaLocalFrame?: never
-}
-
-type Mass = {
-  mass: number
-  density?: never
-  centerOfMass?: never
-  principalAngularInertia?: never
-  angularInertiaLocalFrame?: never
-}
-
-type MassProperties = {
-  mass: number
-  centerOfMass: Parameters<Vector3['set']>
-  principalAngularInertia: Parameters<Vector3['set']>
-  angularInertiaLocalFrame: Parameters<Euler['set']>
-  density?: never
-}
-
-type NoMassProperties = {
-  density?: never
-  mass?: never
-  centerOfMass?: never
-  principalAngularInertia?: never
-  angularInertiaLocalFrame?: never
-}
-
-export type MassDef = Density | Mass | MassProperties | NoMassProperties
-
-type MassProps<TMassDef extends MassDef> = TMassDef extends Density
-  ? Density
-  : TMassDef extends MassProperties
-    ? MassProperties
-    : TMassDef extends Mass
-      ? Mass
-      : NoMassProperties
-
-// ------------------ COLLIDER ------------------
-
-export type AutoCollidersProps<TMassDef extends MassDef> = BaseProps &
-  MassProps<TMassDef> & {
-    children?: Snippet<
-      [
-        {
-          colliders: Collider[]
-          refresh: () => void
-        }
-      ]
-    >
-  }
-
-export default class AutoColliders<TMassDef extends MassDef> extends SvelteComponent<
-  AutoCollidersProps<TMassDef>
-> {}

package/dist/components/Colliders/Collider.svelte.d.ts

@@ -1,109 +0,0 @@
-import type {
-  CoefficientCombineRule,
-  Collider as RapierCollider,
-  ColliderDesc
-} from '@dimforge/rapier3d-compat'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type { Euler, Vector3 } from 'three'
-import type { ColliderEvents } from '../../types/types'
-
-// ------------------ BASE ------------------
-
-type Type = 'static' | 'dynamic'
-
-type BaseProps = {
-  type?: Type
-  restitution?: number
-  restitutionCombineRule?: CoefficientCombineRule
-  friction?: number
-  frictionCombineRule?: CoefficientCombineRule
-  sensor?: boolean
-  collider?: RapierCollider
-  contactForceEventThreshold?: number
-  refresh?: () => void
-}
-
-// ------------------ SHAPE ------------------
-
-export type Shape =
-  | 'ball'
-  | 'capsule'
-  | 'segment'
-  | 'triangle'
-  | 'roundTriangle'
-  | 'polyline'
-  | 'trimesh'
-  | 'cuboid'
-  | 'roundCuboid'
-  | 'heightfield'
-  | 'cylinder'
-  | 'roundCylinder'
-  | 'cone'
-  | 'roundCone'
-  | 'convexHull'
-  | 'convexMesh'
-  | 'roundConvexHull'
-  | 'roundConvexMesh'
-
-type Args<TShape extends Shape> = Parameters<(typeof ColliderDesc)[TShape]>
-
-type ShapeProps<TShape extends Shape> = {
-  shape: TShape
-  args: Args<TShape>
-}
-
-// ------------------ MASS ------------------
-
-type Density = {
-  density: number
-  mass?: never
-  centerOfMass?: never
-  principalAngularInertia?: never
-  angularInertiaLocalFrame?: never
-}
-type Mass = {
-  mass: number
-  density?: never
-  centerOfMass?: never
-  principalAngularInertia?: never
-  angularInertiaLocalFrame?: never
-}
-type MassProperties = {
-  mass: number
-  centerOfMass: Parameters<Vector3['set']>
-  principalAngularInertia: Parameters<Vector3['set']>
-  angularInertiaLocalFrame: Parameters<Euler['set']>
-  density?: never
-}
-
-type NoMassProperties = {
-  density?: never
-  mass?: never
-  centerOfMass?: never
-  principalAngularInertia?: never
-  angularInertiaLocalFrame?: never
-}
-
-export type MassDef = Density | Mass | MassProperties | NoMassProperties
-
-type MassProps<TMassDef extends MassDef> = TMassDef extends Density
-  ? Density
-  : TMassDef extends MassProperties
-    ? MassProperties
-    : TMassDef extends Mass
-      ? Mass
-      : NoMassProperties
-
-// ------------------ COLLIDER ------------------
-
-export type ColliderProps<TShape extends Shape, TMassDef extends MassDef> = BaseProps &
-  ColliderEvents &
-  ShapeProps<TShape> &
-  MassProps<TMassDef> & {
-    children?: Snippet<[{ collider?: RapierCollider }]>
-  }
-
-export default class Collider<
-  TShape extends Shape,
-  TMassDef extends MassDef
-> extends SvelteComponent<ColliderProps<TShape, TMassDef>> {}

package/dist/recipes/BasicPlayerController.svelte

@@ -1,142 +0,0 @@
-<script lang="ts">import { T, useTask } from '@threlte/core';
-import { Vector2, Vector3 } from 'three';
-import Collider from '../components/Colliders/Collider.svelte';
-import CollisionGroups from '../components/CollisionGroups/CollisionGroups.svelte';
-import RigidBody from '../components/RigidBody/RigidBody.svelte';
-export let position = undefined;
-export let height = 1.7;
-export let radius = 0.3;
-export let speed = 1;
-export let jumpStrength = 3;
-export let playerCollisionGroups = [0];
-export let groundCollisionGroups = [15];
-export let ongroundenter = undefined;
-export let ongroundexit = undefined;
-let rigidBody;
-const keys = {
-    up: false,
-    down: false,
-    left: false,
-    right: false
-};
-const t = new Vector3();
-const t2 = new Vector2();
-let grounded = false;
-let groundsSensored = 0;
-$: {
-    if (groundsSensored === 0)
-        grounded = false;
-    else
-        grounded = true;
-}
-$: grounded ? ongroundenter?.() : ongroundexit?.();
-const { start } = useTask(() => {
-    t.set(0, 0, 0);
-    if (keys.down)
-        t.x += 1;
-    if (keys.up)
-        t.x -= 1;
-    if (keys.left)
-        t.z += 1;
-    if (keys.right)
-        t.z -= 1;
-    const l = t.length();
-    const xzLength = t2.set(t.x, t.z).length();
-    if (l > 0)
-        t.divideScalar(l).multiplyScalar(speed);
-    if (xzLength > 0) {
-        rigidBody.resetForces(true);
-        rigidBody.resetTorques(true);
-    }
-    const linVel = rigidBody.linvel();
-    t.y = linVel.y;
-    rigidBody.setLinvel(t, true);
-});
-$: if (rigidBody)
-    start();
-const onKeyDown = (e) => {
-    switch (e.key.toLowerCase()) {
-        case 's':
-        case 'arrowdown':
-            keys.down = true;
-            break;
-        case 'w':
-        case 'arrowup':
-            keys.up = true;
-            break;
-        case 'a':
-        case 'arrowleft':
-            keys.left = true;
-            break;
-        case 'd':
-        case 'arrowright':
-            keys.right = true;
-            break;
-        case ' ':
-            if (!rigidBody || !grounded)
-                break;
-            rigidBody.applyImpulse({ x: 0, y: jumpStrength, z: 0 }, true);
-        default:
-            break;
-    }
-};
-const onKeyUp = (e) => {
-    switch (e.key.toLowerCase()) {
-        case 's':
-        case 'arrowdown':
-            keys.down = false;
-            break;
-        case 'w':
-        case 'arrowup':
-            keys.up = false;
-            break;
-        case 'a':
-        case 'arrowleft':
-            keys.left = false;
-            break;
-        case 'd':
-        case 'arrowright':
-            keys.right = false;
-            break;
-        default:
-            break;
-    }
-};
-</script>
-
-<svelte:window
-  on:keydown|preventDefault={onKeyDown}
-  on:keyup|preventDefault={onKeyUp}
-/>
-
-<T.Group {position}>
-  <RigidBody
-    dominance={127}
-    enabledRotations={[false, false, false]}
-    bind:rigidBody
-    type={'dynamic'}
-  >
-    <CollisionGroups groups={playerCollisionGroups}>
-      <Collider
-        shape={'capsule'}
-        args={[height / 2 - radius, radius]}
-      />
-    </CollisionGroups>
-
-    <CollisionGroups groups={groundCollisionGroups}>
-      <T.Group position={[0, -height / 2 + radius, 0]}>
-        <Collider
-          sensor
-          onsensorenter={() => (groundsSensored += 1)}
-          onsensorexit={() => (groundsSensored -= 1)}
-          shape={'ball'}
-          args={[radius * 1.2]}
-        />
-      </T.Group>
-    </CollisionGroups>
-
-    <T.Group position.y={-height / 2}>
-      <slot />
-    </T.Group>
-  </RigidBody>
-</T.Group>

package/dist/recipes/BasicPlayerController.svelte.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="svelte" />
-import { Vector3 } from 'three';
-import type { CollisionGroupsBitMask } from '../types/types';
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
-    default: any;
-} ? Props extends Record<string, never> ? any : {
-    children?: any;
-} : {});
-declare const BasicPlayerController: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
-    position?: Parameters<Vector3['set']> | undefined;
-    height?: number | undefined;
-    radius?: number | undefined;
-    speed?: number | undefined;
-    jumpStrength?: number | undefined;
-    playerCollisionGroups?: CollisionGroupsBitMask | undefined;
-    groundCollisionGroups?: CollisionGroupsBitMask | undefined;
-    ongroundenter?: (() => void) | undefined;
-    ongroundexit?: (() => void) | undefined;
-}, {
-    default: {};
-}>, {
-    [evt: string]: CustomEvent<any>;
-}, {
-    default: {};
-}, {}, string>;
-type BasicPlayerController = InstanceType<typeof BasicPlayerController>;
-export default BasicPlayerController;