chore(cannon): pass linting

Author: nartc

libs/cannon/.eslintrc.json

@@ -6,22 +6,9 @@
 			"files": ["*.ts"],
 			"extends": ["plugin:@nx/angular", "plugin:@angular-eslint/template/process-inline-templates"],
 			"rules": {
-				"@angular-eslint/directive-selector": [
-					"error",
-					{
-						"type": "attribute",
-						"prefix": "lib",
-						"style": "camelCase"
-					}
-				],
-				"@angular-eslint/component-selector": [
-					"error",
-					{
-						"type": "element",
-						"prefix": "lib",
-						"style": "kebab-case"
-					}
-				]
+				"@angular-eslint/directive-class-suffix": "off",
+				"@angular-eslint/component-class-suffix": "off",
+        "@typescript-eslint/no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }]
 			}
 		},
 		{
@@ -33,7 +20,17 @@
 			"files": ["*.json"],
 			"parser": "jsonc-eslint-parser",
 			"rules": {
-				"@nx/dependency-checks": "error"
+				"@nx/dependency-checks": ["error", {
+          "ignoredDependencies": [
+            "angular-three",
+            "ngxtension",
+            "@analogjs/vite-plugin-angular",
+            "@nx/vite",
+            "vite",
+            "@angular/common",
+            "tslib"
+          ]
+        }]
 			}
 		}
 	]

libs/cannon/body/src/lib/body.ts

@@ -58,7 +58,7 @@ function injectBody<TShape extends BodyShapeType, TObject extends Object3D>(
 			if (!_body) return null;
 			const { worker, ...rest } = physics.api;
 			if (!worker()) return null;
-			return makeBodyApi(_body, worker(), physics.api);
+			return makeBodyApi(_body, worker(), rest);
 		});
 
 		afterNextRender(() => {
@@ -109,7 +109,12 @@ function injectBody<TShape extends BodyShapeType, TObject extends Object3D>(
 				// Register on mount, unregister on unmount
 				currentWorker.addBodies({
 					props: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => {
-						return { onCollide: Boolean(onCollide), ...serializableProps };
+						return {
+							onCollide: Boolean(onCollide),
+							onCollideBegin: Boolean(onCollideBegin),
+							onCollideEnd: Boolean(onCollideEnd),
+							...serializableProps,
+						};
 					}),
 					type,
 					uuid,

libs/cannon/body/src/lib/utils.ts

@@ -84,7 +84,7 @@ export function setupCollision(
 export function makeBodyApi(
 	body: Object3D,
 	worker: CannonWorkerAPI,
-	{ subscriptions, scaleOverrides }: NgtcPhysicsApi,
+	{ subscriptions, scaleOverrides }: Pick<NgtcPhysicsApi, 'subscriptions' | 'scaleOverrides'>,
 ) {
 	const makeAtomic = <T extends AtomicName>(type: T, index?: number) => {
 		const op: SetOpName<T> = `set${capitalize(type)}`;
@@ -221,10 +221,10 @@ export function makeBodyApi(
 }
 
 export const defaultTransformArgs = {
-	Plane: (args: PlaneProps['args']) => [],
+	Plane: (_: PlaneProps['args']) => [],
 	Box: (args: BoxProps['args'] = [1, 1, 1]) => args,
 	Trimesh: (args: TrimeshArgs) => args,
-	Cylinder: (args: CylinderArgs = []) => [],
+	Cylinder: (_: CylinderArgs = []) => [],
 	Heightfield: (args: HeightfieldArgs) => args,
 	ConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius]: ConvexPolyhedronArgs = []) => [
 		vertices && vertices.map(makeTriplet),
@@ -233,7 +233,7 @@ export const defaultTransformArgs = {
 		axes && axes.map(makeTriplet),
 		boundingSphereRadius,
 	],
-	Particle: (args: ParticleProps['args']) => [],
+	Particle: (_: ParticleProps['args']) => [],
 	Sphere: (args: SphereArgs = [1]) => {
 		if (!Array.isArray(args)) throw new Error('Sphere body args must be an array');
 		return [args[0]];

libs/cannon/constraint/src/lib/constraint.ts

@@ -70,7 +70,11 @@ function injectConstraint<
 	type: TConstraint,
 	bodyA: ElementRef<A> | A | Signal<ElementRef<A> | A | undefined>,
 	bodyB: ElementRef<B> | B | Signal<ElementRef<B> | B | undefined>,
-	{ injector, options = {} as any, disableOnStart = false }: NgtcConstraintOptions<TConstraint> = {},
+	{
+		injector,
+		options = {} as NgtcConstraintOptionsMap[TConstraint],
+		disableOnStart = false,
+	}: NgtcConstraintOptions<TConstraint> = {},
 ) {
 	return assertInjector(injectConstraint, injector, () => {
 		const physics = inject(NgtcPhysics, { optional: true });

libs/cannon/src/lib/physics.ts

@@ -33,6 +33,19 @@ import { injectAutoEffect } from 'ngxtension/auto-effect';
 import { mergeInputs } from 'ngxtension/inject-inputs';
 import { InstancedMesh, Matrix4, Object3D, Quaternion, QuaternionTuple, Vector3 } from 'three';
 
+export interface NgtcCannonWorkerEvents {
+	collide: WorkerCollideEvent;
+	collideBegin: WorkerCollideBeginEvent;
+	collideEnd: WorkerCollideEndEvent;
+	frame: WorkerFrameMessage;
+	rayhit: WorkerRayhitEvent;
+}
+
+export interface NgtcCannonWorker extends CannonWorkerAPI {
+	on: <K extends keyof NgtcCannonWorkerEvents>(event: K, cb: (data: NgtcCannonWorkerEvents[K]['data']) => void) => void;
+	removeAllListeners: () => void;
+}
+
 const v = new Vector3();
 const s = new Vector3(1, 1, 1);
 const q = new Quaternion();
@@ -122,7 +135,8 @@ export class NgtcPhysics {
 	options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
 
 	private invalidate = this.store.select('invalidate');
-	private worker = signal<CannonWorkerAPI>(null!);
+	// @ts-expect-error - worker is not nullable, and we don't want to use ! operator
+	private worker = signal<CannonWorkerAPI>(null);
 
 	api: NgtcPhysicsApi = {
 		bodies: {},
@@ -155,11 +169,8 @@ export class NgtcPhysics {
 	}
 
 	private connectWorker() {
-		this.autoEffect((injector) => {
-			const worker = this.worker() as CannonWorkerAPI & {
-				on: (event: string, cb: (...args: any[]) => void) => void;
-				removeAllListeners: () => void;
-			};
+		this.autoEffect(() => {
+			const worker = this.worker() as NgtcCannonWorker;
 			if (!worker) return;
 
 			worker.connect();
@@ -183,7 +194,7 @@ export class NgtcPhysics {
 
 		this.autoEffect(() => {
 			const [worker, value] = [untracked(this.worker), computedValue()];
-			// @ts-expect-error
+			// @ts-expect-error - we know key is a valid key of CannonWorkerAPI
 			worker[key] = value;
 		});
 	}
@@ -193,9 +204,9 @@ export class NgtcPhysics {
 		injectBeforeRender(
 			({ delta }) => {
 				const [{ isPaused, maxSubSteps, stepSize }, worker] = [this.options(), this.worker()];
-				if (isPaused || !worker) return;
+				if (isPaused || !worker || stepSize == null) return;
 				timeSinceLastCalled += delta;
-				worker.step({ maxSubSteps, stepSize: stepSize!, timeSinceLastCalled });
+				worker.step({ maxSubSteps, stepSize, timeSinceLastCalled });
 				timeSinceLastCalled = 0;
 			},
 			{ injector: this.injector },