@pascal-app/editor 1.0.7 → 1.1.0

package/src/lib/door-interaction.ts

@@ -1,102 +0,0 @@
-import {
-  type AnyNodeId,
-  type DoorInteractiveState,
-  isOperationDoorType,
-  useInteractive,
-  useScene,
-} from '@pascal-app/core'
-
-export const DOOR_SWING_OPEN_ANGLE = Math.PI / 2
-export const DOOR_TOGGLE_ANIMATION_MS = 520
-
-export { isOperationDoorType }
-
-type DoorOpenAnimationOptions = {
-  persist?: boolean
-}
-
-export function getDisplayedDoorValue(
-  doorId: AnyNodeId,
-  field: keyof DoorInteractiveState,
-  nodeValue: number | undefined,
-) {
-  const interactive = useInteractive.getState()
-  const runtimeValue = interactive.doors[doorId]?.[field]
-  if (runtimeValue !== undefined) return runtimeValue
-
-  const queuedValue = interactive.doorAnimations[doorId]?.from
-  if (queuedValue !== undefined) return queuedValue
-
-  return nodeValue ?? 0
-}
-
-function startDoorOpenAnimation(
-  doorId: AnyNodeId,
-  field: keyof DoorInteractiveState,
-  from: number,
-  to: number,
-  options?: DoorOpenAnimationOptions,
-) {
-  useInteractive.getState().startDoorAnimation(doorId, {
-    field,
-    from,
-    to,
-    startedAt: null,
-    durationMs: DOOR_TOGGLE_ANIMATION_MS,
-    persist: options?.persist ?? true,
-  })
-}
-
-export function toggleDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions) {
-  const node = useScene.getState().nodes[doorId]
-  if (node?.type !== 'door' || node.openingKind === 'opening') return
-
-  if (isOperationDoorType(node.doorType)) {
-    const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState)
-    startDoorOpenAnimation(
-      doorId,
-      'operationState',
-      currentOpenAmount,
-      currentOpenAmount >= 0.5 ? 0 : 1,
-      options,
-    )
-    return
-  }
-
-  const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
-  startDoorOpenAnimation(
-    doorId,
-    'swingAngle',
-    currentSwingAngle,
-    currentSwingAngle >= DOOR_SWING_OPEN_ANGLE / 2 ? 0 : DOOR_SWING_OPEN_ANGLE,
-    options,
-  )
-}
-
-export function closeDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions) {
-  const node = useScene.getState().nodes[doorId]
-  if (node?.type !== 'door' || node.openingKind === 'opening') return
-
-  if (isOperationDoorType(node.doorType)) {
-    const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState)
-    startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, 0, options)
-    return
-  }
-
-  const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
-  startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, 0, options)
-}
-
-export function openDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions) {
-  const node = useScene.getState().nodes[doorId]
-  if (node?.type !== 'door' || node.openingKind === 'opening') return
-
-  if (isOperationDoorType(node.doorType)) {
-    const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState)
-    startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, 1, options)
-    return
-  }
-
-  const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
-  startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, DOOR_SWING_OPEN_ANGLE, options)
-}

package/src/lib/measurement-label.ts

@@ -1,68 +0,0 @@
-import { type MeasurementPoint, measurementCentroid, measurementNormal } from '@pascal-app/core'
-import { ShapeUtils, Vector2, Vector3 } from 'three'
-
-type MeasurementPolygonProjection = {
-  contour: Vector2[]
-  triangles: number[][]
-}
-
-function projectMeasurementPolygon(
-  points: readonly MeasurementPoint[],
-): MeasurementPolygonProjection | null {
-  const normalValue = measurementNormal(points)
-  const originValue = points[0]
-  if (!(normalValue && originValue)) return null
-
-  const normal = new Vector3(...normalValue)
-  const reference = Math.abs(normal.y) < 0.9 ? new Vector3(0, 1, 0) : new Vector3(1, 0, 0)
-  const tangent = new Vector3().crossVectors(reference, normal).normalize()
-  const bitangent = new Vector3().crossVectors(normal, tangent).normalize()
-  const origin = new Vector3(...originValue)
-  const contour = points.map((point) => {
-    const relative = new Vector3(...point).sub(origin)
-    return new Vector2(relative.dot(tangent), relative.dot(bitangent))
-  })
-
-  return { contour, triangles: ShapeUtils.triangulateShape(contour, []) }
-}
-
-export function triangulateMeasurementPolygon(points: readonly MeasurementPoint[]): number[][] {
-  return projectMeasurementPolygon(points)?.triangles ?? []
-}
-
-export function measurementPolygonLabelAnchor(
-  points: readonly MeasurementPoint[],
-): MeasurementPoint | null {
-  const projection = projectMeasurementPolygon(points)
-  if (!projection || projection.triangles.length === 0) return measurementCentroid(points)
-
-  let largestTriangle: number[] | null = null
-  let largestArea = Number.NEGATIVE_INFINITY
-  for (const triangle of projection.triangles) {
-    const [firstIndex, secondIndex, thirdIndex] = triangle
-    const first = firstIndex === undefined ? null : projection.contour[firstIndex]
-    const second = secondIndex === undefined ? null : projection.contour[secondIndex]
-    const third = thirdIndex === undefined ? null : projection.contour[thirdIndex]
-    if (!(first && second && third)) continue
-    const area = Math.abs(
-      (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x),
-    )
-    if (area > largestArea) {
-      largestArea = area
-      largestTriangle = triangle
-    }
-  }
-
-  if (!largestTriangle) return measurementCentroid(points)
-  const [firstIndex, secondIndex, thirdIndex] = largestTriangle
-  const first = firstIndex === undefined ? null : points[firstIndex]
-  const second = secondIndex === undefined ? null : points[secondIndex]
-  const third = thirdIndex === undefined ? null : points[thirdIndex]
-  if (!(first && second && third)) return measurementCentroid(points)
-
-  return [
-    (first[0] + second[0] + third[0]) / 3,
-    (first[1] + second[1] + third[1]) / 3,
-    (first[2] + second[2] + third[2]) / 3,
-  ]
-}

package/src/lib/window-interaction.ts

@@ -1,142 +0,0 @@
-import {
-  type AnyNodeId,
-  type InteractiveState,
-  useInteractive,
-  useScene,
-  type WindowInteractiveState,
-} from '@pascal-app/core'
-
-export const WINDOW_TOGGLE_ANIMATION_MS = 520
-
-export type WindowOpenAnimationOptions = {
-  persist?: boolean
-}
-
-export function isOperableWindowType(windowType: string | undefined) {
-  return (
-    windowType === 'sliding' ||
-    windowType === 'casement' ||
-    windowType === 'awning' ||
-    windowType === 'hopper' ||
-    windowType === 'tilt-turn' ||
-    windowType === 'single-hung' ||
-    windowType === 'double-hung' ||
-    windowType === 'louvered'
-  )
-}
-
-export function getDisplayedWindowValue(
-  windowId: AnyNodeId,
-  nodeValue: number | undefined,
-  field: keyof WindowInteractiveState = 'operationState',
-  interactive: InteractiveState = useInteractive.getState(),
-) {
-  const runtimeValue = interactive.windows[windowId]?.[field]
-  if (runtimeValue !== undefined) return runtimeValue
-
-  const queuedValue = interactive.windowAnimations[windowId]?.[field]?.from
-  if (queuedValue !== undefined) return queuedValue
-
-  return nodeValue ?? 0
-}
-
-function startWindowOpenAnimation(
-  windowId: AnyNodeId,
-  field: keyof WindowInteractiveState,
-  from: number,
-  to: number,
-  options?: WindowOpenAnimationOptions,
-) {
-  useInteractive.getState().startWindowAnimation(windowId, {
-    field,
-    from,
-    to,
-    startedAt: null,
-    durationMs: WINDOW_TOGGLE_ANIMATION_MS,
-    persist: options?.persist ?? true,
-  })
-}
-
-export function toggleWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
-  const node = useScene.getState().nodes[windowId]
-  if (
-    node?.type !== 'window' ||
-    node.openingKind === 'opening' ||
-    !isOperableWindowType(node.windowType)
-  ) {
-    return
-  }
-
-  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
-  startWindowOpenAnimation(
-    windowId,
-    'operationState',
-    currentOpenAmount,
-    currentOpenAmount >= 0.5 ? 0 : 1,
-    options,
-  )
-}
-
-export function closeWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
-  const node = useScene.getState().nodes[windowId]
-  if (
-    node?.type !== 'window' ||
-    node.openingKind === 'opening' ||
-    !isOperableWindowType(node.windowType)
-  ) {
-    return
-  }
-
-  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
-  startWindowOpenAnimation(windowId, 'operationState', currentOpenAmount, 0, options)
-}
-
-export function openWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
-  const node = useScene.getState().nodes[windowId]
-  if (
-    node?.type !== 'window' ||
-    node.openingKind === 'opening' ||
-    !isOperableWindowType(node.windowType)
-  ) {
-    return
-  }
-
-  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
-  startWindowOpenAnimation(windowId, 'operationState', currentOpenAmount, 1, options)
-}
-
-export type WindowShutterField = 'shutterOpen' | 'rollerShutterOpen'
-
-export function getDisplayedWindowShutterValue(
-  windowId: AnyNodeId,
-  field: WindowShutterField,
-  nodeValue: number | undefined,
-  state: InteractiveState = useInteractive.getState(),
-): number {
-  return getDisplayedWindowValue(windowId, nodeValue ?? 1, field, state)
-}
-
-/** Preview both shutter styles together, independently of the sash. */
-export function setWindowShuttersOpenState(
-  windowId: AnyNodeId,
-  on: boolean,
-  options?: WindowOpenAnimationOptions,
-): void {
-  const node = useScene.getState().nodes[windowId]
-  if (node?.type !== 'window' || node.source) return
-  const fields: WindowShutterField[] = []
-  if (node.shutters && node.shutters !== 'none') fields.push('shutterOpen')
-  if (node.rollerShutter === 'box' || node.rollerShutter === 'concealed')
-    fields.push('rollerShutterOpen')
-  if (!fields.length) return
-  useInteractive.getState().setMechanismPart(windowId, 'shutters', on)
-  for (const field of fields) {
-    startWindowOpenAnimation(
-      windowId,
-      field,
-      getDisplayedWindowShutterValue(windowId, field, node[field]),
-      on ? 1 : 0,
-      options,
-    )
-  }
-}