@pascal-app/editor 1.0.3 → 1.0.4

package/src/components/editor/quick-measurement-hud.tsx

@@ -6,11 +6,12 @@ import {
   selectQuickMeasurementHudEntry,
   useQuickMeasurementHud,
 } from '../../store/use-quick-measurement-hud'
+import { visibleScene } from '../../store/view-layout'
 import { QuickMeasurementCard } from './quick-measurement-card'
 
 export function QuickMeasurementHud() {
-  const viewMode = useEditor((state) => state.viewMode)
-  const entry = useQuickMeasurementHud((state) => selectQuickMeasurementHudEntry(state, viewMode))
+  const scene = useEditor(visibleScene)
+  const entry = useQuickMeasurementHud((state) => selectQuickMeasurementHudEntry(state, scene))
   const unit = useViewer((state) => state.unit)
   const metricNotation = useViewer((state) => state.metricNotation)
 

package/src/components/editor/registry-action-contributions.test.tsx

@@ -0,0 +1,63 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { type AnyNode, registerNode, useInteractive } from '@pascal-app/core'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MechanismButton, selectedMechanismNode } from './registry-action-contributions'
+
+const switchMechanism = {
+  has: (node: AnyNode) => (node as unknown as { joints: number }).joints > 0,
+  isOn: (node: AnyNode, state: ReturnType<typeof useInteractive.getState>) =>
+    Boolean(state.mechanisms[node.id]),
+  set: (node: AnyNode, on: boolean) => useInteractive.getState().setMechanism(node.id, on),
+}
+
+// A kind that only declares the capability: no action-menu contribution, no E action.
+function articulated(joints: number): AnyNode {
+  const kind = `test:mechanism-${crypto.randomUUID()}`
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    category: 'furnish',
+    defaults: () => ({}),
+    capabilities: { mechanism: switchMechanism },
+  } as never)
+  return { object: 'node', id: `${kind}_1`, type: kind, joints } as unknown as AnyNode
+}
+
+const byId = (...nodes: AnyNode[]) => Object.fromEntries(nodes.map((node) => [node.id, node]))
+
+afterEach(() => {
+  for (const id of Object.keys(useInteractive.getState().mechanisms))
+    useInteractive.getState().removeMechanism(id as never)
+})
+
+describe('mechanism action in the action menu', () => {
+  test('the only selected node gets Play when its kind declares a mechanism', () => {
+    const node = articulated(2)
+    expect(selectedMechanismNode([node.id], byId(node))).toBe(node)
+  })
+
+  test('no Play without moving parts, for a multi-selection, or without the capability', () => {
+    const still = articulated(0)
+    expect(selectedMechanismNode([still.id], byId(still))).toBeUndefined()
+
+    const node = articulated(2)
+    const other = { object: 'node', id: 'other_1', type: 'other' } as unknown as AnyNode
+    expect(selectedMechanismNode([node.id, other.id], byId(node, other))).toBeUndefined()
+    expect(selectedMechanismNode([other.id], byId(other))).toBeUndefined()
+  })
+
+  test('the button reads Play, then Stop while the mechanism runs', () => {
+    const node = articulated(1)
+    const idle = renderToStaticMarkup(
+      <MechanismButton mechanism={switchMechanism} node={node} running={false} />,
+    )
+    expect(idle).toContain('aria-label="Play"')
+    expect(idle).toContain('aria-pressed="false"')
+
+    const running = renderToStaticMarkup(
+      <MechanismButton mechanism={switchMechanism} node={node} running />,
+    )
+    expect(running).toContain('aria-label="Stop"')
+    expect(running).toContain('aria-pressed="true"')
+  })
+})

package/src/components/editor/registry-action-contributions.tsx

@@ -1,10 +1,21 @@
 'use client'
 
-import { type AnyNodeId, nodeRegistry, useScene } from '@pascal-app/core'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type MechanismCapability,
+  nodeMechanism,
+  nodeRegistry,
+  toggleMechanism,
+  useInteractive,
+  useScene,
+} from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import { DoorClosed, DoorOpen, PanelTopClose, PanelTopOpen, Play, Square } from 'lucide-react'
 import { type ComponentType, lazy, Suspense } from 'react'
 import { useShallow } from 'zustand/react/shallow'
 import { getFloorplanNodeExtension } from '../../lib/floorplan/floorplan-extension'
+import { ActionMenuButton } from './action-menu-button'
 
 type Loader = () => Promise<{ default: ComponentType }>
 const lazyCache = new WeakMap<Loader, ComponentType>()
@@ -19,6 +30,73 @@ function contribution(kind: string): ComponentType | null {
   return component
 }
 
+/** The node the action menu's Play/Stop runs: the only selected node, when its kind declares a mechanism. */
+export function selectedMechanismNode(
+  selectedIds: readonly string[],
+  nodes: Readonly<Record<string, AnyNode>>,
+): AnyNode | undefined {
+  const node = selectedIds.length === 1 ? nodes[selectedIds[0]!] : undefined
+  return nodeMechanism(node) ? node : undefined
+}
+
+function MechanismGlyph({
+  icon,
+  running,
+}: {
+  icon: MechanismCapability['icon']
+  running: boolean
+}) {
+  const Glyph =
+    icon === 'door'
+      ? running
+        ? DoorClosed
+        : DoorOpen
+      : icon === 'window'
+        ? running
+          ? PanelTopClose
+          : PanelTopOpen
+        : running
+          ? Square
+          : Play
+  return <Glyph className="h-4 w-4" />
+}
+
+export function MechanismButton({
+  node,
+  mechanism,
+  running,
+}: {
+  node: AnyNode
+  mechanism: MechanismCapability
+  running: boolean
+}) {
+  const label = mechanism.icon ? (running ? 'Close' : 'Open') : running ? 'Stop' : 'Play'
+  return (
+    <ActionMenuButton
+      keys={['E']}
+      label={label}
+      onClick={(event) => {
+        event.stopPropagation()
+        toggleMechanism(mechanism, node)
+      }}
+      pressed={running}
+    >
+      <MechanismGlyph icon={mechanism.icon} running={running} />
+    </ActionMenuButton>
+  )
+}
+
+/** Play/Stop for a single selected node whose kind declares `capabilities.mechanism`. */
+function MechanismAction() {
+  const selected = useViewer((s) => s.selection.selectedIds)
+  const node = useScene((s) => selectedMechanismNode(selected, s.nodes))
+  const mechanism = nodeMechanism(node)
+  const running = useInteractive((s) => (node && mechanism ? mechanism.isOn(node, s) : false))
+  return node && mechanism ? (
+    <MechanismButton mechanism={mechanism} node={node} running={running} />
+  ) : null
+}
+
 /**
  * The buttons kinds add to the action menu for selections holding them
  * (`extensions['pascal:editor/floorplan'].actionMenu.actions`), in 2D and 3D
@@ -40,6 +118,7 @@ export function RegistryActionContributions() {
   )
   return (
     <>
+      <MechanismAction />
       {kinds.map((kind) => {
         const Contribution = contribution(kind)
         return Contribution ? (