@pascal-app/editor 1.1.0 → 1.1.1

package/src/components/editor-2d/renderers/floorplan-label-angle.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  resolveFloorplanAnnotationLabelTransform,
-  resolveFloorplanAnnotationUpdate,
-  resolveFloorplanLabelAngle,
-  shouldUpdateFloorplanLabelRotation,
-  updateSvgFloorplanLabelOrientations,
-} from './floorplan-label-angle'
-
-describe('resolveFloorplanLabelAngle', () => {
-  test('keeps segment labels readable while preserving their screen direction', () => {
-    expect(resolveFloorplanLabelAngle(0, 0)).toBe(0)
-    expect(resolveFloorplanLabelAngle(Math.PI, 0)).toBe(0)
-    expect(resolveFloorplanLabelAngle(Math.PI / 2, 90)).toBe(-90)
-  })
-
-  test('counter-rotates aggregate labels to remain horizontal', () => {
-    expect(resolveFloorplanLabelAngle(0, 90, true)).toBe(-90)
-    expect(resolveFloorplanLabelAngle(Math.PI / 3, -35, true)).toBe(35)
-  })
-
-  test('ignores sub-degree rotation changes for annotation layout', () => {
-    expect(shouldUpdateFloorplanLabelRotation(30, 30.9)).toBe(false)
-    expect(shouldUpdateFloorplanLabelRotation(30, 31)).toBe(true)
-    expect(shouldUpdateFloorplanLabelRotation(359.5, 0.25)).toBe(false)
-  })
-
-  test('updates only label orientation while preserving its layout shift', () => {
-    expect(
-      resolveFloorplanAnnotationLabelTransform({
-        afterRotation: 'translate(0 -0.2)',
-        angleRadians: 0,
-        beforeRotation: 'translate(4 6)',
-        layoutDx: 0.5,
-        layoutDy: -0.25,
-        sceneRotationDeg: 90,
-        screenUpright: true,
-      }),
-    ).toEqual({
-      defaultTransform: 'translate(4 6) rotate(-90) translate(0 -0.2)',
-      transform: 'translate(4 6) rotate(-90) translate(0 -0.2) translate(0.5 -0.25)',
-    })
-  })
-
-  test('keeps a rotation-only update out of the full collision layout path', () => {
-    expect(
-      resolveFloorplanAnnotationUpdate({
-        layoutInputsChanged: false,
-        nextRotationDeg: 45,
-        previousRotationDeg: 30,
-      }),
-    ).toEqual({
-      resolveCollisions: false,
-      updateLabelPresentation: true,
-    })
-  })
-
-  test('runs collision layout when floor-plan scene inputs change', () => {
-    expect(
-      resolveFloorplanAnnotationUpdate({
-        layoutInputsChanged: true,
-        nextRotationDeg: 30,
-        previousRotationDeg: 30,
-      }),
-    ).toEqual({
-      resolveCollisions: true,
-      updateLabelPresentation: true,
-    })
-  })
-
-  test('updates captured label references without rediscovering the DOM', () => {
-    const attributes = new Map<string, string>([['transform', 'translate(4 6) rotate(0)']])
-    const label = {
-      dataset: {
-        floorplanAnnotationAngleRadians: '0',
-        floorplanAnnotationLayoutDx: '0.5',
-        floorplanAnnotationLayoutDy: '-0.25',
-        floorplanAnnotationScreenUpright: 'true',
-        floorplanAnnotationTransformAfterRotation: '',
-        floorplanAnnotationTransformBeforeRotation: 'translate(4 6)',
-      },
-      getAttribute: (name: string) => attributes.get(name) ?? null,
-      setAttribute: (name: string, value: string) => attributes.set(name, value),
-    } as unknown as SVGGElement
-
-    expect(updateSvgFloorplanLabelOrientations([label], 90)).toBe(1)
-    expect(attributes.get('transform')).toBe('translate(4 6) rotate(-90) translate(0.5 -0.25)')
-  })
-})

package/src/components/editor-2d/renderers/floorplan-label-angle.ts

@@ -1,106 +0,0 @@
-export function resolveFloorplanLabelAngle(
-  angleRadians: number,
-  sceneRotationDeg: number,
-  screenUpright = false,
-): number {
-  if (screenUpright) return -sceneRotationDeg
-
-  let localAngleDeg = (angleRadians * 180) / Math.PI
-  let screenAngleDeg = localAngleDeg + sceneRotationDeg
-  screenAngleDeg = ((((screenAngleDeg + 180) % 360) + 360) % 360) - 180
-  if (screenAngleDeg > 90) localAngleDeg -= 180
-  else if (screenAngleDeg <= -90) localAngleDeg += 180
-  return ((((localAngleDeg + 180) % 360) + 360) % 360) - 180
-}
-
-export function shouldUpdateFloorplanLabelRotation(
-  previousRotationDeg: number | null,
-  nextRotationDeg: number,
-  minimumDeltaDeg = 1,
-): boolean {
-  if (previousRotationDeg === null) return true
-  const deltaDeg = ((((nextRotationDeg - previousRotationDeg + 180) % 360) + 360) % 360) - 180
-  return Math.abs(deltaDeg) >= minimumDeltaDeg
-}
-
-export function resolveFloorplanAnnotationUpdate({
-  layoutInputsChanged,
-  previousRotationDeg,
-  nextRotationDeg,
-}: {
-  layoutInputsChanged: boolean
-  previousRotationDeg: number | null
-  nextRotationDeg: number
-}): {
-  resolveCollisions: boolean
-  updateLabelPresentation: boolean
-} {
-  return {
-    resolveCollisions: layoutInputsChanged,
-    updateLabelPresentation:
-      layoutInputsChanged ||
-      shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg),
-  }
-}
-
-export function resolveFloorplanAnnotationLabelTransform({
-  angleRadians,
-  sceneRotationDeg,
-  screenUpright,
-  beforeRotation,
-  afterRotation,
-  layoutDx = 0,
-  layoutDy = 0,
-}: {
-  angleRadians: number
-  sceneRotationDeg: number
-  screenUpright: boolean
-  beforeRotation: string
-  afterRotation: string
-  layoutDx?: number
-  layoutDy?: number
-}): {
-  defaultTransform: string
-  transform: string
-} {
-  const degrees = resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright)
-  const defaultTransform = [beforeRotation, `rotate(${degrees})`, afterRotation]
-    .filter(Boolean)
-    .join(' ')
-  return {
-    defaultTransform,
-    transform:
-      layoutDx === 0 && layoutDy === 0
-        ? defaultTransform
-        : `${defaultTransform} translate(${layoutDx} ${layoutDy})`,
-  }
-}
-
-export function updateSvgFloorplanLabelOrientations(
-  labels: Iterable<SVGGElement>,
-  sceneRotationDeg: number,
-): number {
-  let updated = 0
-
-  for (const label of labels) {
-    const angleRadians = Number(label.dataset.floorplanAnnotationAngleRadians)
-    if (!Number.isFinite(angleRadians)) continue
-
-    const { defaultTransform, transform } = resolveFloorplanAnnotationLabelTransform({
-      angleRadians,
-      sceneRotationDeg,
-      screenUpright: label.dataset.floorplanAnnotationScreenUpright === 'true',
-      beforeRotation: label.dataset.floorplanAnnotationTransformBeforeRotation ?? '',
-      afterRotation: label.dataset.floorplanAnnotationTransformAfterRotation ?? '',
-      layoutDx: Number(label.dataset.floorplanAnnotationLayoutDx ?? 0),
-      layoutDy: Number(label.dataset.floorplanAnnotationLayoutDy ?? 0),
-    })
-    if (label.getAttribute('transform') === transform) continue
-
-    label.dataset.floorplanAnnotationDefaultTransform = defaultTransform
-    label.setAttribute('transform', transform)
-    updated += 1
-  }
-
-  return updated
-}

package/src/components/editor-2d/svg-paths.ts

@@ -1,124 +0,0 @@
-'use client'
-
-import type { Point2D } from '@pascal-app/core'
-
-function toSvgX(value: number) {
-  return value
-}
-
-function toSvgY(value: number) {
-  return value
-}
-
-function toSvgPoint(point: Point2D) {
-  return {
-    x: toSvgX(point.x),
-    y: toSvgY(point.y),
-  }
-}
-
-export function formatPolygonPath(points: Point2D[], holes: Point2D[][] = []) {
-  const formatSubpath = (subpathPoints: Point2D[]) => {
-    const [firstPoint, ...restPoints] = subpathPoints
-    if (!firstPoint) {
-      return null
-    }
-
-    const firstSvgPoint = toSvgPoint(firstPoint)
-
-    return [
-      `M ${firstSvgPoint.x} ${firstSvgPoint.y}`,
-      ...restPoints.map((point) => {
-        const svgPoint = toSvgPoint(point)
-        return `L ${svgPoint.x} ${svgPoint.y}`
-      }),
-      'Z',
-    ].join(' ')
-  }
-
-  return [points, ...holes].map(formatSubpath).filter(Boolean).join(' ')
-}
-
-export function buildSvgPolylinePath(points: Point2D[]) {
-  if (points.length < 2) {
-    return null
-  }
-
-  return points
-    .map((point, index) => {
-      const svgPoint = toSvgPoint(point)
-      return `${index === 0 ? 'M' : 'L'} ${svgPoint.x} ${svgPoint.y}`
-    })
-    .join(' ')
-}
-
-export function getArcPlanPoint(center: Point2D, radius: number, angle: number): Point2D {
-  return {
-    x: center.x + Math.cos(angle) * radius,
-    y: center.y + Math.sin(angle) * radius,
-  }
-}
-
-export function buildSvgArcPath(
-  center: Point2D,
-  radius: number,
-  startAngle: number,
-  endAngle: number,
-) {
-  const start = getArcPlanPoint(center, radius, startAngle)
-  return `M ${toSvgX(start.x)} ${toSvgY(start.y)} ${svgArcCommands(center, radius, startAngle, endAngle)}`
-}
-
-export function buildSvgAnnularSectorPath(
-  center: Point2D,
-  innerRadius: number,
-  outerRadius: number,
-  startAngle: number,
-  endAngle: number,
-) {
-  const outerStart = getArcPlanPoint(center, outerRadius, startAngle)
-  const innerEnd = getArcPlanPoint(center, innerRadius, endAngle)
-  return [
-    `M ${toSvgX(outerStart.x)} ${toSvgY(outerStart.y)}`,
-    svgArcCommands(center, outerRadius, startAngle, endAngle),
-    `L ${toSvgX(innerEnd.x)} ${toSvgY(innerEnd.y)}`,
-    svgArcCommands(center, innerRadius, endAngle, startAngle),
-    'Z',
-  ].join(' ')
-}
-
-function svgArcCommands(center: Point2D, radius: number, startAngle: number, endAngle: number) {
-  const delta = endAngle - startAngle
-  const count = Math.max(1, Math.ceil(Math.abs(delta) / Math.PI))
-  return Array.from({ length: count }, (_, index) => {
-    const end = getArcPlanPoint(center, radius, startAngle + (delta * (index + 1)) / count)
-    return `A ${radius} ${radius} 0 0 ${delta >= 0 ? 1 : 0} ${toSvgX(end.x)} ${toSvgY(end.y)}`
-  }).join(' ')
-}
-
-export function formatSvgPolygonPoints(points: Point2D[]) {
-  return points.map((point) => `${toSvgX(point.x)},${toSvgY(point.y)}`).join(' ')
-}
-
-/**
- * Three points defining an arrow head — tip + two trailing barbs.
- * Returned as plain `Point2D` objects so consumers can either feed them
- * straight into `formatSvgPolygonPoints` (for SVG `points=""`) or push
- * them onto a `FloorplanGeometry.polygon.points` array. Mixing both
- * downstream paths through a string-returning helper was awkward — see
- * `nodes/src/stair/floorplan.ts` which needs the points as objects.
- */
-export function buildSvgArrowHeadPoints(point: Point2D, angle: number, size: number): Point2D[] {
-  const left = {
-    x: point.x - size * Math.cos(angle - Math.PI / 6),
-    y: point.y - size * Math.sin(angle - Math.PI / 6),
-  }
-  const right = {
-    x: point.x - size * Math.cos(angle + Math.PI / 6),
-    y: point.y - size * Math.sin(angle + Math.PI / 6),
-  }
-
-  return [point, left, right]
-}
-
-export { toSvgPoint, toSvgX, toSvgY }

package/src/components/ui/action-menu/action-button.tsx

@@ -1,89 +0,0 @@
-import * as React from 'react'
-import { Button } from './../../../components/ui/primitives/button'
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from './../../../components/ui/primitives/tooltip'
-import { triggerSFX } from './../../../lib/sfx-bus'
-import { cn } from './../../../lib/utils'
-import { useActionMenuPopupSide } from './placement'
-
-interface ActionButtonProps extends React.ComponentProps<typeof Button> {
-  label: string
-  shortcut?: string
-  isActive?: boolean
-  tooltipContent?: React.ReactNode
-  tooltipSide?: 'top' | 'right' | 'bottom' | 'left'
-  /** The tooltip portals to `<body>`, so a button in a themed scope passes the scope here. */
-  tooltipClassName?: string
-}
-
-export const ActionButton = React.forwardRef<HTMLButtonElement, ActionButtonProps>(
-  (
-    {
-      className,
-      children,
-      label,
-      shortcut,
-      isActive,
-      tooltipContent,
-      tooltipSide,
-      tooltipClassName,
-      onClick,
-      onMouseEnter,
-      ...props
-    },
-    ref,
-  ) => {
-    const popupSide = useActionMenuPopupSide()
-    return (
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <Button
-            // These are toggles, not commands: the armed/unarmed state has to be
-            // readable without decoding the active-state styling.
-            aria-pressed={isActive}
-            // Icon-only: the tooltip text is the button's name.
-            aria-label={label}
-            className={cn('relative h-11 w-11 transition-all', className)}
-            onClick={(event) => {
-              triggerSFX('sfx:menu-click')
-              onClick?.(event)
-            }}
-            onMouseEnter={(event) => {
-              triggerSFX('sfx:menu-hover')
-              onMouseEnter?.(event)
-            }}
-            ref={ref}
-            {...props}
-          >
-            <div
-              className={cn(
-                'flex h-full w-full items-center justify-center transition-transform',
-                shortcut && '-translate-x-0.5 -translate-y-0.5',
-              )}
-            >
-              {children}
-            </div>
-            {shortcut && (
-              <div className="absolute right-1 bottom-1 rounded border border-border/40 bg-background/40 px-1 py-[2px] backdrop-blur-md">
-                <span className="block font-medium font-mono text-[9px] text-muted-foreground/70 leading-none">
-                  {shortcut}
-                </span>
-              </div>
-            )}
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent className={tooltipClassName} side={tooltipSide ?? popupSide}>
-          {tooltipContent || (
-            <p>
-              {label} {shortcut && `(${shortcut})`}
-            </p>
-          )}
-        </TooltipContent>
-      </Tooltip>
-    )
-  },
-)
-ActionButton.displayName = 'ActionButton'

package/src/components/ui/action-menu/follow-pascal-toggle.tsx

@@ -1,42 +0,0 @@
-'use client'
-
-import { usePascalI18n } from '@pascal-app/core'
-import { Video } from 'lucide-react'
-import { cn } from '../../../lib/utils'
-import useFollowPascal from '../../../store/use-follow-pascal'
-import { ActionButton } from './action-button'
-
-/** The toolbar's switch for Follow Pascal: the camera follows what the agent builds. */
-export function FollowPascalToggle({
-  className,
-  tooltipClassName,
-}: {
-  className?: string
-  tooltipClassName?: string
-}) {
-  const i18n = usePascalI18n()
-  const on = useFollowPascal((state) => state.on)
-  const setOn = useFollowPascal((state) => state.setOn)
-  return (
-    <ActionButton
-      aria-pressed={on}
-      className={cn(
-        on
-          ? 'bg-violet-500/20 text-violet-600 dark:text-violet-300 dark:hover:text-accent-foreground'
-          : 'hover:bg-black/4 hover:text-violet-600 dark:hover:text-violet-300',
-        className,
-      )}
-      label={
-        on
-          ? i18n._({ id: 'editor.actionMenu.followPascalToggle.on', message: 'Follow Pascal: On' })
-          : i18n._({ id: 'editor.actionMenu.followPascalToggle.off', message: 'Follow Pascal: Off' })
-      }
-      onClick={() => setOn(!on)}
-      size="icon"
-      tooltipClassName={tooltipClassName}
-      variant="ghost"
-    >
-      <Video className="h-6 w-6" />
-    </ActionButton>
-  )
-}

package/src/components/ui/primitives/button.tsx

@@ -1,69 +0,0 @@
-import { Slot } from '@radix-ui/react-slot'
-import { cva, type VariantProps } from 'class-variance-authority'
-import type * as React from 'react'
-
-import { cn } from '../../../lib/utils'
-
-const buttonVariants = cva(
-  "inline-flex shrink-0 items-center justify-center gap-2 whitespace-nowrap rounded-md font-barlow font-medium text-sm outline-none transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0",
-  {
-    variants: {
-      variant: {
-        default: 'bg-primary text-primary-foreground hover:bg-primary/90',
-        destructive:
-          'bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:bg-destructive/60 dark:focus-visible:ring-destructive/40',
-        outline:
-          'border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50',
-        secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
-        ghost: 'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
-        link: 'text-primary underline-offset-4 hover:underline',
-      },
-      size: {
-        default: 'h-9 px-4 py-2 has-[>svg]:px-3',
-        sm: 'h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5',
-        lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
-        icon: 'size-9',
-        'icon-sm': 'size-8',
-        'icon-lg': 'size-10',
-      },
-    },
-    defaultVariants: {
-      variant: 'default',
-      size: 'default',
-    },
-  },
-)
-
-function Button({
-  className,
-  variant,
-  size,
-  asChild = false,
-  ref,
-  ...props
-}: React.ComponentProps<'button'> &
-  VariantProps<typeof buttonVariants> & {
-    asChild?: boolean
-  }) {
-  if (asChild) {
-    return (
-      <Slot
-        className={cn(buttonVariants({ variant, size, className }))}
-        data-slot="button"
-        ref={ref as never}
-        {...props}
-      />
-    )
-  }
-
-  return (
-    <button
-      className={cn(buttonVariants({ variant, size, className }))}
-      data-slot="button"
-      ref={ref}
-      {...props}
-    />
-  )
-}
-
-export { Button, buttonVariants }