@threlte/rapier 3.0.0-next.9 → 3.1.0

package/README.md

@@ -35,14 +35,7 @@ This is a great way to implement key features of games or simulators, such as co
 
 ### Installation
 
-For a quick interactive setup of a fresh Threlte project, run:
-
-```sh
-npm create threlte my-project
-```
-and select the `@threlte/rapier` option.
-
-Alternatively you can check out the full [installation instructions](https://threlte.xyz/docs/learn/getting-started/installation).
+Check out the [installation instructions](https://threlte.xyz/docs/learn/getting-started/installation).
 
 ### Support
 

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

@@ -1,34 +1,3 @@
-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> {}
+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,22 @@
+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 @@
+import {} from 'svelte';

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,20 @@
+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 @@
+import {} from 'svelte';

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,18 @@
-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
+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 @@
+import {} from 'svelte';

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,3 @@
-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> {}
+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,3 @@
-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> {}
+import type { RigidBodyProps } from './types';
+declare const RigidBody: import("svelte").Component<RigidBodyProps, {}, "rigidBody">;
+export default RigidBody;