schematic-symbols 0.0.121 → 0.0.123

package/drawing/rotateSymbol.ts

@@ -1,324 +0,0 @@
-import { rotate, applyToPoint, transform, scale } from "transformation-matrix"
-import type {
-  SchSymbol,
-  Primitive,
-  Point,
-  Port,
-  NinePointAnchor,
-} from "./types"
-import { getBoundsOfPrimitives } from "./utils/getBoundsOfPrimitives"
-
-// Update rotateAnchor to handle all anchor rotations based on orientation
-const rotateRightFacingAnchor = (
-  anchor: NinePointAnchor,
-  newOrientation: "up" | "down" | "left" | "right" = "right",
-): NinePointAnchor => {
-  switch (newOrientation) {
-    case "down":
-      switch (anchor) {
-        case "middle_top":
-          return "middle_right"
-        case "middle_bottom":
-          return "middle_left"
-        case "middle_left":
-          return "middle_bottom"
-        case "middle_right":
-          return "middle_top"
-      }
-      break
-    case "up":
-      switch (anchor) {
-        case "middle_top":
-          return "middle_left"
-        case "middle_bottom":
-          return "middle_right"
-        case "middle_left":
-          return "middle_top"
-        case "middle_right":
-          return "middle_bottom"
-      }
-      break
-    case "left":
-      switch (anchor) {
-        case "middle_top":
-          return "middle_bottom"
-        case "middle_bottom":
-          return "middle_top"
-        case "middle_left":
-          return "middle_right"
-        case "middle_right":
-          return "middle_left"
-      }
-      break
-    case "right":
-      return anchor // No change if orientation is "right"
-  }
-  return anchor
-}
-
-export const flipSymbolOverXAxis = (
-  symbol: SchSymbol,
-  overrides?: Partial<SchSymbol>,
-): SchSymbol => {
-  const { primitives, center, ports, size } = symbol
-  const transformMatrix = transform({
-    a: 1,
-    b: 0,
-    c: 0,
-    d: -1,
-    e: 0,
-    f: 2 * center.y,
-  })
-
-  const flippedPrimitives = primitives.map((primitive): Primitive => {
-    primitive = { ...primitive }
-    switch (primitive.type) {
-      case "path":
-        return {
-          ...primitive,
-          points: primitive.points.map(
-            (point) => applyToPoint(transformMatrix, point) as Point,
-          ),
-        }
-      case "text":
-        const flippedPoint = applyToPoint(transformMatrix, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-
-        // Flip text anchors vertically
-        const anchorMap: Record<NinePointAnchor, NinePointAnchor> = {
-          top_left: "bottom_left",
-          top_right: "bottom_right",
-          bottom_left: "top_left",
-          bottom_right: "top_right",
-          center: "center",
-          middle_top: "middle_bottom",
-          middle_bottom: "middle_top",
-          middle_left: "middle_left",
-          middle_right: "middle_right",
-        }
-
-        return {
-          ...primitive,
-          x: flippedPoint.x,
-          y: flippedPoint.y,
-          anchor: anchorMap[primitive.anchor],
-        }
-      case "circle":
-      case "box":
-        const flippedCenter = applyToPoint(transformMatrix, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-        return {
-          ...primitive,
-          x: flippedCenter.x,
-          y: flippedCenter.y,
-        }
-    }
-  })
-
-  const flippedPorts = ports.map(
-    (port): Port => ({
-      ...port,
-      ...(applyToPoint(transformMatrix, port) as Point),
-    }),
-  )
-
-  return {
-    primitives: flippedPrimitives,
-    center,
-    ports: flippedPorts,
-    size,
-    ...overrides,
-  }
-}
-
-export const flipSymbolOverYAxis = (
-  symbol: SchSymbol,
-  overrides?: Partial<SchSymbol>,
-): SchSymbol => {
-  const { primitives, center, ports, size } = symbol
-  const transformMatrix = transform({
-    a: -1,
-    b: 0,
-    c: 0,
-    d: 1,
-    e: 0,
-    f: 2 * center.x,
-  })
-
-  const flippedPrimitives = primitives.map((primitive): Primitive => {
-    primitive = { ...primitive }
-    switch (primitive.type) {
-      case "path":
-        return {
-          ...primitive,
-          points: primitive.points.map(
-            (point) => applyToPoint(transformMatrix, point) as Point,
-          ),
-        }
-      case "text":
-        const flippedPoint = applyToPoint(transformMatrix, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-
-        // Flip text anchors horizontally
-        const anchorMap: Record<NinePointAnchor, NinePointAnchor> = {
-          top_left: "top_right",
-          top_right: "top_left",
-          bottom_left: "bottom_right",
-          bottom_right: "bottom_left",
-          center: "center",
-          middle_top: "middle_top",
-          middle_bottom: "middle_bottom",
-          middle_left: "middle_right",
-          middle_right: "middle_left",
-        }
-
-        return {
-          ...primitive,
-          x: flippedPoint.x,
-          y: flippedPoint.y,
-          anchor: anchorMap[primitive.anchor],
-        }
-      case "circle":
-      case "box":
-        const flippedCenter = applyToPoint(transformMatrix, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-        return {
-          ...primitive,
-          x: flippedCenter.x,
-          y: flippedCenter.y,
-        }
-    }
-  })
-
-  const flippedPorts = ports.map(
-    (port): Port => ({
-      ...port,
-      ...(applyToPoint(transformMatrix, port) as Point),
-    }),
-  )
-
-  return {
-    primitives: flippedPrimitives,
-    center,
-    ports: flippedPorts,
-    size,
-    ...overrides,
-  }
-}
-
-export const rotateRightFacingSymbol = (
-  symbol: SchSymbol,
-  opts: {
-    newOrientation?: "up" | "down" | "left" | "right"
-    overrides?: Partial<SchSymbol>
-  },
-): SchSymbol => {
-  const { newOrientation, overrides } = opts
-  // Assuming the default orientation is "right"
-  const angleMap = {
-    up: Math.PI / 2,
-    right: 0,
-    down: -Math.PI / 2,
-    left: -Math.PI,
-  }
-
-  const transform = rotate(
-    newOrientation ? angleMap[newOrientation] : Math.PI / 2,
-    symbol.center.x,
-    symbol.center.y,
-  )
-
-  const { primitives, center, size, ports } = symbol
-
-  const rotatedPrimitives = primitives.map((primitive): Primitive => {
-    primitive = { ...primitive }
-    switch (primitive.type) {
-      case "path":
-        return {
-          ...primitive,
-          points: primitive.points.map(
-            (point) => applyToPoint(transform, point) as Point,
-          ),
-        }
-      case "text":
-        const rotatedPoint = applyToPoint(transform, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-
-        primitive.anchor = rotateRightFacingAnchor(
-          primitive.anchor,
-          newOrientation ?? "right",
-        )
-
-        return {
-          ...primitive,
-          x: rotatedPoint.x,
-          y: rotatedPoint.y,
-        }
-      case "circle":
-        const rotatedCenter = applyToPoint(transform, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-        return {
-          ...primitive,
-          x: rotatedCenter.x,
-          y: rotatedCenter.y,
-        }
-      case "box":
-        const rotatedCorner = applyToPoint(transform, {
-          x: primitive.x,
-          y: primitive.y,
-        }) as Point
-        return {
-          ...primitive,
-          x: rotatedCorner.x,
-          y: rotatedCorner.y,
-          width: primitive.height,
-          height: primitive.width,
-        }
-    }
-  })
-
-  const rotatedPorts = ports.map(
-    (port): Port => ({
-      ...port,
-      ...(applyToPoint(transform, port) as Point),
-    }),
-  )
-
-  const bounds = getBoundsOfPrimitives(rotatedPrimitives)
-
-  return {
-    primitives: rotatedPrimitives,
-    center,
-    ports: rotatedPorts,
-    size: {
-      width: bounds.maxX - bounds.minX,
-      height: bounds.maxY - bounds.minY,
-    },
-    ...overrides,
-  }
-}
-
-/**
- * @deprecated use rotateRightFacingSymbol instead
- */
-export const rotateSymbol = (
-  symbol: SchSymbol,
-  orientation: "up" | "down" | "left" | "right" = "down",
-  overrides: Partial<SchSymbol> = {},
-): SchSymbol =>
-  rotateRightFacingSymbol(symbol, {
-    newOrientation: orientation,
-    overrides,
-  })

package/drawing/svgPathToPoints.ts

@@ -1,109 +0,0 @@
-import type { Point } from "./types"
-import { approximateArc } from "./arc"
-import { approximateBezier } from "./cubicBezierCurveArc"
-
-export function svgPathToPoints(pathString: string): Point[] {
-  const points: Point[] = []
-  const commands =
-    pathString.match(/[MmLlHhVvCcSsQqTtAaZz][^MmLlHhVvCcSsQqTtAaZz]*/g) || []
-  let currentX = 0
-  let currentY = 0
-
-  function addPoint(x: number, y: number) {
-    points.push({ x, y })
-    currentX = x
-    currentY = y
-  }
-
-  for (const command of commands) {
-    const type = command[0]
-    const args = command
-      .slice(1)
-      .trim()
-      .split(/[\s,]+/)
-      .map(Number.parseFloat)
-
-    switch (type.toUpperCase()) {
-      case "M":
-        addPoint(args[0], args[1])
-        break
-      case "L":
-        addPoint(args[0], args[1])
-        break
-      case "H":
-        addPoint(args[0], currentY)
-        break
-      case "V":
-        addPoint(currentX, args[0])
-        break
-      case "C": {
-        const [x1, y1, x2, y2, x, y] = args
-
-        // Approximate the cubic Bézier curve
-        const bezierPoints = approximateBezier(
-          { x: currentX, y: currentY }, // Start point
-          { x: x1, y: y1 }, // Control point 1
-          { x: x2, y: y2 }, // Control point 2
-          { x, y }, // End point
-        )
-
-        points.push(...bezierPoints)
-        addPoint(x, y) // Update the current position
-        break
-      }
-      case "Q":
-        // For Q command, we add both the control point and the end point
-        points.push({ x: args[0], y: args[1] }) // Control point
-        addPoint(args[2], args[3]) // End point
-        break
-      case "Z":
-        // Close path - no new point
-        break
-      case "A":
-        // For A command, we add the end point and intermediate points to approximate the arc
-        const [rx, ry, xAxisRotation, largeArcFlag, sweepFlag, x, y] = args
-        const arcPoints = approximateArc(
-          currentX,
-          currentY,
-          rx,
-          ry,
-          largeArcFlag,
-          sweepFlag,
-          x,
-          y,
-        )
-        arcPoints.forEach((point) => points.push(point))
-        addPoint(x, y)
-        break
-      // Add cases for other commands (S, T) if needed
-      default:
-        console.warn(`Unsupported SVG command: ${type}`)
-    }
-
-    // Handle relative commands
-    if (type === type.toLowerCase() && type !== "z" && type !== "a") {
-      if (type === "c") {
-        // For relative c, adjust both control points and end point
-        points[points.length - 3].x += currentX
-        points[points.length - 3].y += currentY
-        points[points.length - 2].x += currentX
-        points[points.length - 2].y += currentY
-        points[points.length - 1].x += currentX
-        points[points.length - 1].y += currentY
-      } else if (type === "q") {
-        // For relative q, adjust both control point and end point
-        points[points.length - 2].x += currentX
-        points[points.length - 2].y += currentY
-        points[points.length - 1].x += currentX
-        points[points.length - 1].y += currentY
-      } else {
-        points[points.length - 1].x += currentX
-        points[points.length - 1].y += currentY
-      }
-      currentX = points[points.length - 1].x
-      currentY = points[points.length - 1].y
-    }
-  }
-
-  return points
-}

package/drawing/text.ts

@@ -1,8 +0,0 @@
-import type { TextPrimitive } from "drawing"
-
-export function text(
-  text: string,
-  options: Omit<TextPrimitive, "type" | "text">,
-): TextPrimitive {
-  return { type: "text", text, ...options }
-}

package/drawing/typeguards.ts

@@ -1,155 +0,0 @@
-import {
-  PathPrimitive,
-  TextPrimitive,
-  CirclePrimitive,
-  BoxPrimitive,
-  Primitive,
-  NinePointAnchor,
-  Point,
-  SchSymbol,
-  Port,
-  SvgData,
-  Bounds,
-} from "./types"
-
-// Basic types
-function isPoint(value: any): value is Point {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof value.x === "number" &&
-    typeof value.y === "number"
-  )
-}
-
-export function isNinePointAnchor(value: any): value is NinePointAnchor {
-  return [
-    "top_left",
-    "top_right",
-    "bottom_left",
-    "bottom_right",
-    "center",
-    "middle_top",
-    "middle_bottom",
-    "middle_left",
-    "middle_right",
-  ].includes(value)
-}
-
-// Primitive types
-export function isPathPrimitive(value: any): value is PathPrimitive {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    value.type === "path" &&
-    Array.isArray(value.points) &&
-    value.points.every(isPoint) &&
-    typeof value.color === "string"
-  )
-}
-
-export function isTextPrimitive(value: any): value is TextPrimitive {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    value.type === "text" &&
-    typeof value.text === "string" &&
-    typeof value.x === "number" &&
-    typeof value.y === "number" &&
-    isNinePointAnchor(value.anchor)
-  )
-}
-
-export function isCirclePrimitive(value: any): value is CirclePrimitive {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    value.type === "circle" &&
-    typeof value.x === "number" &&
-    typeof value.y === "number" &&
-    typeof value.radius === "number" &&
-    typeof value.fill === "boolean" &&
-    typeof value.color === "string"
-  )
-}
-
-export function isBoxPrimitive(value: any): value is BoxPrimitive {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    value.type === "box" &&
-    typeof value.x === "number" &&
-    typeof value.y === "number" &&
-    typeof value.width === "number" &&
-    typeof value.height === "number" &&
-    isNinePointAnchor(value.anchor)
-  )
-}
-
-export function isPrimitive(value: any): value is Primitive {
-  return (
-    isPathPrimitive(value) ||
-    isTextPrimitive(value) ||
-    isCirclePrimitive(value) ||
-    isBoxPrimitive(value)
-  )
-}
-
-// Complex types
-export function isPort(value: any): value is Port {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof value.x === "number" &&
-    typeof value.y === "number" &&
-    Array.isArray(value.labels) &&
-    value.labels.every((label: any) => typeof label === "string")
-  )
-}
-
-export function isSchSymbol(value: any): value is SchSymbol {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    Array.isArray(value.primitives) &&
-    value.primitives.every(isPrimitive) &&
-    isPoint(value.center) &&
-    Array.isArray(value.ports) &&
-    value.ports.every(isPort) &&
-    typeof value.size === "object" &&
-    value.size !== null &&
-    typeof value.size.width === "number" &&
-    typeof value.size.height === "number"
-  )
-}
-
-export function isBounds(value: any): value is Bounds {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof value.minX === "number" &&
-    typeof value.maxX === "number" &&
-    typeof value.minY === "number" &&
-    typeof value.maxY === "number" &&
-    typeof value.width === "number" &&
-    typeof value.height === "number" &&
-    typeof value.centerX === "number" &&
-    typeof value.centerY === "number"
-  )
-}
-
-export function isSvgData(value: any): value is SvgData {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof value.paths === "object" &&
-    Object.values(value.paths).every(isPathPrimitive) &&
-    typeof value.texts === "object" &&
-    Object.values(value.texts).every(isTextPrimitive) &&
-    typeof value.refblocks === "object" &&
-    Object.values(value.refblocks).every(isPoint) &&
-    isBounds(value.bounds) &&
-    typeof value.circles === "object" &&
-    Object.values(value.circles).every(isCirclePrimitive)
-  )
-}

package/drawing/types.ts

@@ -1,93 +0,0 @@
-export interface Point {
-  x: number
-  y: number
-}
-
-export interface Port {
-  x: number
-  y: number
-  labels: string[]
-}
-
-export interface PathPrimitive {
-  type: "path"
-  fill?: boolean
-  points: Point[]
-  color: string
-  closed?: boolean
-}
-
-export interface TextPrimitive {
-  type: "text"
-  text: string
-  fontSize?: number
-  x: number
-  y: number
-  anchor: NinePointAnchor
-}
-
-export interface CirclePrimitive {
-  type: "circle"
-  x: number
-  y: number
-  radius: number
-  fill: boolean
-  color: string
-}
-
-export interface BoxPrimitive {
-  type: "box"
-  x: number
-  y: number
-  width: number
-  height: number
-  anchor: string
-}
-
-export type Primitive =
-  | PathPrimitive
-  | TextPrimitive
-  | CirclePrimitive
-  | BoxPrimitive
-
-export interface SchSymbol {
-  primitives: Primitive[]
-  center: Point
-  ports: Port[]
-  size: {
-    width: number
-    height: number
-  }
-}
-
-export type Bounds = {
-  minX: number
-  maxX: number
-  minY: number
-  maxY: number
-  width: number
-  height: number
-  centerX: number
-  centerY: number
-}
-
-export interface SvgData {
-  paths: Record<string, PathPrimitive>
-  texts: Record<string, TextPrimitive>
-  refblocks: Record<string, Point>
-  bounds: Bounds
-  circles: Record<string, CirclePrimitive>
-}
-
-export type SvgAnchor = "start" | "middle" | "end"
-
-export type NinePointAnchor =
-  | "top_left"
-  | "top_right"
-  | "bottom_left"
-  | "bottom_right"
-  | "center"
-  | "middle_top"
-  | "middle_bottom"
-  | "middle_left"
-  | "middle_right"