Skip to content

The VS Code of video editing, built for agents.

TypeScript

Refactor BackgroundSettings component to utilize new trait system and improve background color management

konstantin-pauluse62a71b133f0
diff --git a/apps/web/src/components/sidebar-right/inspector/background.tsx b/apps/web/src/components/sidebar-right/inspector/background.tsx
index 705567ac..b4570b97 100644
--- a/apps/web/src/components/sidebar-right/inspector/background.tsx
+++ b/apps/web/src/components/sidebar-right/inspector/background.tsx
@@ -13,25 +13,23 @@ import { Icon } from "@/components/ui/icon";
import { PanelSection } from "@/components/ui/panel-section";
import { ColorOpacityPicker } from "@/components/ui/color-opacity-picker";
import { ColorOpacityRow } from "@/components/ui/color-opacity-row";
-import { useEngine } from "@/context/engine";
import { Button } from "@/components/ui/button";
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
import { createSignal } from "solid-js";
-import { DEFAULT_BACKGROUND, persistWorldState, useWorldState } from "@/components/engine";
+import { Background, DEFAULT_BACKGROUND } from "@diffusionstudio/runtime";
+import { useTrait, useWorld } from "@diffusionstudio/koota-solid";
export function BackgroundSettings() {
- const { world } = useEngine();
+ const world = useWorld();
const [isPickerOpen, setIsPickerOpen] = createSignal(false);
- const color = useWorldState(w => w.background, DEFAULT_BACKGROUND);
+ const background = useTrait(world, Background);
+ const color = () => background()?.value ?? DEFAULT_BACKGROUND;
let anchorRef: HTMLDivElement | undefined;
- const assignColor = (next: number) => {
- world.background = next;
- persistWorldState(world);
- };
+ const assignColor = (value: number) => world.set(Background, { value });
return (
<PanelSection title="Background" ref={anchorRef}>
@@ -69,8 +67,6 @@ export function BackgroundSettings() {
color={color()}
opacity={1}
onColorChange={assignColor}
- onBeginChange={(label) => world.history.startTransaction(label)}
- onEndChange={() => world.history.commitTransaction()}
withoutOpacity
/>
</FloatingInspectorContent>
diff --git a/packages/koota-solid/src/hooks/use-trait-effect.ts b/packages/koota-solid/src/hooks/use-trait-effect.ts
index bb6fc659..69bc5f25 100644
--- a/packages/koota-solid/src/hooks/use-trait-effect.ts
+++ b/packages/koota-solid/src/hooks/use-trait-effect.ts
@@ -1,9 +1,22 @@
import { $internal, type Entity, type RelationPair, type Trait, type TraitRecord, type World } from 'koota';
-import { createEffect, onCleanup, untrack } from 'solid-js';
+import { createEffect, onCleanup, untrack, type Accessor } from 'solid-js';
import { isWorld } from '../utils/is-world';
import { access, createStableTrait, type MaybeAccessor } from '../utils/reactive-args';
import { useWorld } from '../world/use-world';
+// See use-trait.ts: the union must be split across overloads, not baked
+// into a single MaybeAccessor<T | RelationPair<T>> parameter, or T fails to
+// infer from a plain trait argument and callback silently widens to any.
+export function useTraitEffect<T extends Trait>(
+ target: MaybeAccessor<Entity | World>,
+ trait: T | RelationPair<T>,
+ callback: (value: TraitRecord<T> | undefined) => void
+): void;
+export function useTraitEffect<T extends Trait>(
+ target: MaybeAccessor<Entity | World>,
+ trait: Accessor<T | RelationPair<T>>,
+ callback: (value: TraitRecord<T> | undefined) => void
+): void;
export function useTraitEffect<T extends Trait>(
target: MaybeAccessor<Entity | World>,
trait: MaybeAccessor<T | RelationPair<T>>,
diff --git a/packages/koota-solid/src/hooks/use-trait.ts b/packages/koota-solid/src/hooks/use-trait.ts
index 190ff00e..df702a62 100644
--- a/packages/koota-solid/src/hooks/use-trait.ts
+++ b/packages/koota-solid/src/hooks/use-trait.ts
@@ -4,6 +4,17 @@ import { isWorld } from '../utils/is-world';
import { access, createStableTrait, type MaybeAccessor } from '../utils/reactive-args';
import { useWorld } from '../world/use-world';
+// Overloads split the trait union so T infers from a plain trait argument;
+// a single MaybeAccessor<T | RelationPair<T>> parameter defeats inference
+// and silently widens the result to Accessor<any>.
+export function useTrait<T extends Trait>(
+ target: MaybeAccessor<Entity | World | undefined | null>,
+ trait: T | RelationPair<T>
+): Accessor<TraitRecord<T> | undefined>;
+export function useTrait<T extends Trait>(
+ target: MaybeAccessor<Entity | World | undefined | null>,
+ trait: Accessor<T | RelationPair<T>>
+): Accessor<TraitRecord<T> | undefined>;
export function useTrait<T extends Trait>(
target: MaybeAccessor<Entity | World | undefined | null>,
trait: MaybeAccessor<T | RelationPair<T>>