This commit discards Nikhil Saraf's older architecture based on the SolidJS
universal renderer, in favor of his newer approach that looks more like Threlte:

https://github.com/nksaraf/react-three-fiber/blob/chess-solid-three/solid-example/src/components/ModernPiece.tsx

This approach uses context to maintain the scene graph, thus avoiding the need
for the universal renderer, which adds build-time complexity and a layer (or two)
of abstraction.  It also uses a "T" proxy object to instantiate the three.js objects
and add them to the scene appropriately.

Issues:

The example seems to leave the canvas at some default size, rather than filling the
viewport.

This approach still has a dependency on "scheduler", an NPM package apparently
created as a reusable React internal package.  We might consider replacing that.

unclear why this is being done in the first place.

in core/events.ts the raycasting was checking for state.events.enabled, but this was being overwritten with events().

…lback>

remove artefact from original useRef

…leRefObject<DomEvent | null>

remove artefact from original useRef

circular dependency was causing type-errors

An endless effect was created by calling `props.onCreated` inside a useIsomorphicLayoutEffect.
In the original r3f-code it is an IsomorphicLayoutEffect with empty dependency-array, but using onMount did not render any image.

I believe we can actually just remove the effect all together, since it originally in r3f never wanted to be re-run anyway.

`core/renderer` was containing code from the deleted `core/reconcile.ts` and a lot of unused code that we deleted in an earlier commit.
The code responsible for rendering the THREE-scene was before this commit located in `solid/index.ts`.

This commit
- moves the types to three-types,
- the rendering-code to `solid/renderer.ts`,
- the empty `core/renderer.ts` is deleted and
- `solid/index.ts` is now only responsible for exporting.

I had updated `Instance` and `InstanceProps` in commit e0c058d when refactoring with the types of r3f v9 but they substantially changed the typings of Instance.

.prettierrc before commit was containing the following line
"plugins": ["prettier-plugin-tailwindcss"]
this was causing prettier to not work when the plugin was not present, causing formatting errors throughout the code.

I noticed we were using a different .prettierrc then r3f, this would cause unnecessary differences between the two codebases.
To unify the codestyle of both, I copy+pasted r3f's .prettierrc and ran `prettier --write ./src` from root

Our branch had custom typing of the jsx-nodes, but since then r3f implemented their own version of it, slightly more streamlined. To unify the codebases I replaced our typing with r3f's.

Before commit there were two applyProps-implementations, one custom made and one from the original r3f-file.

This commit adjusts the custom applyProps function by removing the call to `useThree` and replacing it with `getRootState()`. This way that function can also in the code before the Provider and we can remove r3f's implementation.

and re-written and moved the jsdoc comment for T

and remove `createRef`
(I don't really know what useHelper is supposed to be doing tbh)

…dex.ts

a bit of a subjective commit, but imo it reflects better the content and is a better parallel with r3f's `core/reconciler` what this file a replacement is off.

Instead of `createRenderEffect(() => applyProps(instanceProps))` we now do `createRenderEffect(mapArray(() => Object.keys(instanceProps), ...)`.
This way we don't have to loop and re-create effects every single time a prop changes.

We also check if a prop has a getter or is a function. If they aren't we only set the property, otherwise we wrap it in an effect.

use full names and use similar names as r3f
remove DEBUG-logs

r3f's code had a `store.subscribe(...)` in which they did a diff to check if they should update the camera. With solid we can just place them into a createEffect and let reactivity figure it out. Creates a flickering when resizing, idk if this is a regression or not.

Set cache to result instead of callback. In the original code the cache was set to the data and then directly afterwards to the async callback. onProgress is passed through.

and minor cleanup

I copied the contents of r3f's `packages/fiber/src` and used the vscode-extension `Diff Folders` to compare the two directories and made changes so that these two directories look more alike.

Maybe this could be a way forward: have a r3f-directory which contains a clone of `packages/fiber/src` and we manually update them.

r3f refactored their internal typings of Instance during pmndrs/react-three-fiber#2465
- before: Instance represented a THREE-object with additional parameters: __r3f: LocalState, children, remove, add and raycast
- now: Instance: LocalState with additional parameter: object, props and children
    - object: is the THREE-object with additional parameter __r3f ( = a circular reference back to this Instance)
    - props contains the props of the component, without children and ref
    - children contain all the children of the component (before children only contained the attached children)

if key is included in NEEDS_UPDATE
and it changed from falsey to truthy or vice versa.
NEEDS_UPDATE is possibly incomplete.

repo is now a pnpm workspace
- packages: `@solid-three/fiber` and `@solid-three/drei` (just an empty folder for now)
- apps: `@solid-three/playground`, we could add other apps later one if we want to

the react-three-fiber directory is now moved to `references` and another git-submodule has been added there: `@react-three/drei`

Noop displays a flaw in our current design:
```
const Noop = () => {
  const box = <T.Mesh>...</T.Mesh>
  return <></>
}
```
will add box to its parent context even if it's not returning the jsx.

a utility function to wrap children in context without having to use JSX.

see solidjs-community/solid-primitives#464

…text

Our previous architecture had a design flaw as described 023908c
```
const Noop = () => {
const box = <T.Mesh>...</T.Mesh>
return <></>
}
```
would add box to its parent, with or without returning the actual jsx.
This was due to the fact that parent-child relationships were established from the child to the parent with context through the `getParent()`-hook.

This commit changes the mechanism from child-to-parent to parent-to-child:
By walking the children from the parent and then attaching/connecting these childs, with a function called `parentChildren`.
This function is used when initializing scene too, the props.children are attached to the THREE.Scene with `parentChildren(() => instance, props)`

Since this would mean that props

Before `<T.Mesh/>` return `Accessor<Instance<THREE.Mesh>>` but I think for userland it would be handier if it returned `Accessor<THREE.Mesh>` instead.

That way you could do
```
const mesh = <T.Mesh />
useFrame(() => mesh().rotation.x += 0.1)
return mesh
```
if you don't mind the type-error of `mesh()`

this sub-module is a reference to `https://github.com/bigmistqke/drei`. Once there is some progress in drei-port we could move it to `solid-community` too.

utility-type-imports were causing issues when used in another directory inside the monorepo