schematic-symbols 0.0.121 → 0.0.123

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "schematic-symbols",
   "main": "./dist/index.js",
-  "version": "0.0.121",
+  "version": "0.0.123",
   "type": "module",
   "files": [
-    "dist",
-    "index.ts",
-    "drawing",
-    "symbols"
+    "dist"
   ],
   "scripts": {
     "start": "bun run build && bun --hot run dev-server.ts",

package/drawing/arc.ts

@@ -1,31 +0,0 @@
-import type { Point } from "./types"
-
-export function approximateArc(
-  x1: number,
-  y1: number,
-  rx: number,
-  ry: number,
-  largeArcFlag: number,
-  sweepFlag: number,
-  x2: number,
-  y2: number,
-): Point[] {
-  // This is a simplified approximation. For a more accurate representation,
-  // you might want to use a dedicated SVG path library.
-  const steps = 40
-  const points: Point[] = []
-  for (let i = 1; i < steps; i++) {
-    const t = i / steps
-    const x = (1 - t) * x1 + t * x2
-    const y = (1 - t) * y1 + t * y2
-    // Apply a simple curve to make it non-linear, with reduced height and no center drop
-    const curveY =
-      0.03 *
-      Math.abs(Math.sin(t * Math.PI)) *
-      Math.min(rx, ry) *
-      (largeArcFlag ? 1 : -1) *
-      (sweepFlag ? -1 : 1)
-    points.push({ x, y: y + curveY })
-  }
-  return points
-}

package/drawing/arrow.ts

@@ -1,41 +0,0 @@
-import { Point, Primitive } from "drawing"
-import { path } from "./path"
-
-export const arrow = (
-  start: Point,
-  end: Point,
-  color: string = "black",
-  headSize: number = 10,
-): Primitive[] => {
-  // Calculate the angle and length of the arrow
-  const dx = end.x - start.x
-  const dy = end.y - start.y
-  const angle = Math.atan2(dy, dx)
-  const length = Math.sqrt(dx * dx + dy * dy)
-
-  // Calculate the points for the arrow head
-  const headAngle = Math.PI / 6 // 30 degrees
-  const headPoint1 = {
-    x: end.x - headSize * Math.cos(angle - headAngle),
-    y: end.y - headSize * Math.sin(angle - headAngle),
-  }
-  const headPoint2 = {
-    x: end.x - headSize * Math.cos(angle + headAngle),
-    y: end.y - headSize * Math.sin(angle + headAngle),
-  }
-
-  return [
-    // Arrow body
-    path({
-      points: [start, end],
-      color: color,
-      fill: false,
-    }),
-    // Arrow head
-    path({
-      points: [headPoint1, end, headPoint2],
-      color: color,
-      fill: true,
-    }),
-  ]
-}

package/drawing/box.ts

@@ -1,5 +0,0 @@
-import type { BoxPrimitive } from "drawing"
-
-export function box(options: Omit<BoxPrimitive, "type">): BoxPrimitive {
-  return { type: "box", ...options }
-}

package/drawing/circle.ts

@@ -1,7 +0,0 @@
-import type { CirclePrimitive } from "drawing"
-
-export function circle(
-  options: Omit<CirclePrimitive, "type">,
-): CirclePrimitive {
-  return { type: "circle", ...options }
-}

package/drawing/cubicBezierCurveArc.ts

@@ -1,28 +0,0 @@
-import type { Point } from "./types"
-
-export function approximateBezier(
-  p0: Point,
-  p1: Point,
-  p2: Point,
-  p3: Point,
-): Point[] {
-  const points: Point[] = []
-  const steps = 30
-  for (let t = 0; t <= 1; t += 1 / steps) {
-    const x =
-      Math.pow(1 - t, 3) * p0.x +
-      3 * Math.pow(1 - t, 2) * t * p1.x +
-      3 * (1 - t) * Math.pow(t, 2) * p2.x +
-      Math.pow(t, 3) * p3.x
-
-    const y =
-      Math.pow(1 - t, 3) * p0.y +
-      3 * Math.pow(1 - t, 2) * t * p1.y +
-      3 * (1 - t) * Math.pow(t, 2) * p2.y +
-      Math.pow(t, 3) * p3.y
-
-    points.push({ x, y })
-  }
-
-  return points
-}

package/drawing/defineSymbol.ts

@@ -1,16 +0,0 @@
-import type { SchSymbol } from "./types"
-import { getBoundsOfPrimitives } from "./utils/getBoundsOfPrimitives"
-
-export function defineSymbol(
-  symbol: Omit<SchSymbol, "size"> & Partial<Pick<SchSymbol, "size">>,
-): SchSymbol {
-  let size = symbol.size
-  if (!size) {
-    const bounds = getBoundsOfPrimitives(symbol.primitives)
-    size = {
-      width: bounds.maxX - bounds.minX,
-      height: bounds.maxY - bounds.minY,
-    }
-  }
-  return { ...symbol, size }
-}

package/drawing/getSvg.ts

@@ -1,199 +0,0 @@
-import { makeAnchorYUpPositive, makeYUpPositive } from "./utils/makeYUpPositive"
-import { mapColor } from "./mapColor"
-import { pathToSvgD } from "./pathToSvgD"
-import type { Point, Port, SchSymbol, TextPrimitive } from "./types"
-
-function createDiamondElement(
-  center: Point,
-  size = 0.05,
-  yUpPositive: boolean = true,
-): string {
-  const { x, y } = center
-  const halfSize = size / 2
-  return `<path d="M ${x} ${makeYUpPositive(y, yUpPositive) - halfSize} L ${x + halfSize} ${makeYUpPositive(y, yUpPositive)} L ${x} ${
-    makeYUpPositive(y, yUpPositive) + halfSize
-  } L ${x - halfSize} ${makeYUpPositive(y, yUpPositive)} Z" fill="green" />`
-}
-
-function createTextElement(
-  primitive: TextPrimitive,
-  { yUpPositive }: { yUpPositive?: boolean },
-): {
-  text: string
-  anchor: string
-} {
-  const { x, y, text, fontSize = 0.1, anchor } = primitive
-  let textAnchor: string
-  const dx = 0
-  let dy = 0
-
-  const capHeight = fontSize * 0.75
-
-  switch (anchor) {
-    case "top_left":
-      textAnchor = "start"
-      dy = fontSize
-      break
-    case "top_right":
-      textAnchor = "end"
-      dy = fontSize
-      break
-    case "bottom_left":
-      textAnchor = "start"
-      break
-    case "bottom_right":
-      textAnchor = "end"
-      break
-    case "center":
-      textAnchor = "middle"
-      dy = fontSize / 2
-      break
-    case "middle_top":
-      textAnchor = "middle"
-      dy = capHeight
-      break
-    case "middle_bottom":
-      textAnchor = "middle"
-      break
-    case "middle_left":
-      textAnchor = "start"
-      dy = capHeight / 2
-      break
-    case "middle_right":
-      textAnchor = "end"
-      dy = capHeight / 2
-      break
-  }
-
-  return {
-    text: `<text x="${x}" y="${makeYUpPositive(y, yUpPositive)}" dx="${dx}" dy="${dy}" text-anchor="${textAnchor}" style="font: ${
-      fontSize ?? 0.1
-    }px monospace; fill: ${mapColor("primary")}">${text}</text>`,
-    anchor: `<rect x="${x - 0.025 / 2}" y="${
-      makeYUpPositive(y, yUpPositive) - 0.025 / 2
-    }" width="0.025" height="0.025" fill="blue" />`,
-  }
-}
-
-function createPortElement(
-  port: Port,
-  { yUpPositive }: { yUpPositive?: boolean },
-): string {
-  const { x, y, labels } = port
-  const rectSize = 0.05
-  const labelFontSize = 0.08
-  const label = labels[0] || ""
-
-  return `
-    <rect x="${x - rectSize / 2}" y="${
-      makeYUpPositive(y, yUpPositive) - rectSize / 2
-    }" width="${rectSize}" height="${rectSize}" fill="red" />
-    <text x="${x - labelFontSize / 2}" y="${
-      makeYUpPositive(y, yUpPositive) + rectSize + labelFontSize / 2
-    }" text-anchor="middle" style="font: ${labelFontSize}px monospace; fill: #833;">${label}</text>
-  `
-}
-
-export function getInnerSvg(
-  symbol: SchSymbol,
-  options: { width?: number; height?: number; debug?: boolean } = {},
-): string {
-  const { debug = false } = options
-  const { primitives, size, ports } = symbol
-  const svgElements = primitives.map((primitive) => {
-    switch (primitive.type) {
-      case "path":
-        return `<path d="${pathToSvgD(primitive.points, {
-          closed: primitive.closed,
-          yUpPositive: true,
-        })}" fill="${
-          primitive.fill ? mapColor(primitive.color) : "none"
-        }" stroke="${mapColor(
-          primitive.color,
-        )}" stroke-width="0.02" stroke-linecap="round" stroke-linejoin="round" />`
-      case "text":
-        const textElements = createTextElement(primitive, { yUpPositive: true })
-        return textElements.text + (debug ? textElements.anchor : "")
-      case "circle":
-        return `<circle cx="${primitive.x}" cy="${makeYUpPositive(primitive.y, true)}" r="${
-          primitive.radius
-        }" fill="${primitive.fill ? mapColor(primitive.color) : "none"}" ${
-          !primitive.fill
-            ? `stroke="${mapColor(primitive.color)}" stroke-width="0.02"`
-            : ""
-        } />`
-      case "box":
-        return `<rect x="${primitive.x}" y="${makeYUpPositive(primitive.y)}" width="${
-          primitive.width
-        }" height="${primitive.height}" fill="${mapColor("primary")}" />`
-      default:
-        return ""
-    }
-  })
-
-  const portElements = ports
-    .map((p) => createPortElement(p, { yUpPositive: true }))
-    .join("\n    ")
-
-  const centerDiamond = createDiamondElement(symbol.center)
-
-  const debugElements = []
-  if (debug) {
-    const topLeft = {
-      x: symbol.center.x - size.width / 2,
-      y: symbol.center.y - size.height / 2,
-    }
-    debugElements.push(
-      `<text x="${topLeft.x}" y="${topLeft.y}" style="font: 0.05px monospace; fill: #833;">${size.width.toFixed(2)} x ${size.height.toFixed(2)}</text>`,
-    )
-
-    // Show all available port labels
-    ports.forEach((port, i) => {
-      if (port.labels.length > 1) {
-        const alternateLabels = port.labels.slice(1).join(", ")
-        debugElements.push(
-          `<text x="${topLeft.x}" y="${topLeft.y - (i + 1) * 0.05}" dy="-0.15" style="font: 0.05px monospace; fill: #833;">${port.labels[0]} [${alternateLabels}]</text>`,
-        )
-      }
-    })
-
-    debugElements.push(...debugElements)
-  }
-
-  return [
-    svgElements.join("\n    "),
-    portElements,
-    centerDiamond,
-    ...debugElements,
-  ].join("\n")
-}
-
-export function getSvg(
-  symbol: SchSymbol,
-  options: { width?: number; height?: number; debug?: boolean } = {},
-): string {
-  const { size } = symbol
-  const innerSvg = getInnerSvg(symbol, options)
-
-  // Use the center and the size to calculate the viewBox
-  const bufferMultiple = 1.2
-  const w = size.width * bufferMultiple
-  const h = size.height * bufferMultiple
-  const viewBox = {
-    x: symbol.center.x - w / 2,
-    y: makeYUpPositive(symbol.center.y, true) - h / 2,
-    width: w,
-    height: h,
-  }
-
-  if (options.width && !options.height) {
-    options.height = options.width! * (viewBox.height / viewBox.width)
-  } else if (!options.width && options.height) {
-    options.width = options.height! * (viewBox.width / viewBox.height)
-  } else if (!options.width && !options.height) {
-    options.width = viewBox.width
-    options.height = viewBox.height
-  }
-
-  return `<svg width="${options.width}" height="${options.height}" viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}" xmlns="http://www.w3.org/2000/svg">${innerSvg}</svg>`
-}

package/drawing/index.ts

@@ -1,10 +0,0 @@
-export * from "./types"
-export * from "./box"
-export * from "./arrow"
-export * from "./circle"
-export * from "./getSvg"
-export * from "./mapColor"
-export * from "./resizeSymbol"
-export * from "./pathToSvgD"
-export * from "./text"
-export * from "./svgPathToPoints"

package/drawing/mapColor.ts

@@ -1,10 +0,0 @@
-export const mapColor = (color: string) => {
-  switch (color) {
-    case "primary":
-      return "black"
-    case "secondary":
-      return "gray"
-    default:
-      return color
-  }
-}

package/drawing/modify-symbol/modify-symbol.ts

@@ -1,97 +0,0 @@
-import { NinePointAnchor, SchSymbol } from "drawing/types"
-import { rotateRightFacingSymbol } from "drawing/rotateSymbol"
-import { getBoundsOfPrimitives } from "drawing/utils/getBoundsOfPrimitives"
-
-interface ModifySymbolBuilder {
-  changeTextAnchor(
-    text: "{REF}" | "{VAL}" | string,
-    newAnchor: NinePointAnchor,
-  ): ModifySymbolBuilder
-  rotateRightFacingSymbol(
-    newOrientation: "up" | "down" | "left" | "right",
-  ): ModifySymbolBuilder
-  labelPort(currentLabel: string, newLabels: string[]): ModifySymbolBuilder
-  build(): SchSymbol
-}
-
-class SymbolModifier implements ModifySymbolBuilder {
-  private symbol: SchSymbol
-
-  constructor(symbol: SchSymbol) {
-    this.symbol = JSON.parse(JSON.stringify(symbol))
-    this.symbol.size = this.computeSize()
-  }
-
-  changeTextAnchor(
-    text: "{REF}" | "{VAL}" | string,
-    newAnchor: NinePointAnchor,
-  ): ModifySymbolBuilder {
-    this.symbol = {
-      ...this.symbol,
-      primitives: this.symbol.primitives.map((primitive) => {
-        if (primitive.type === "text" && primitive.text === text) {
-          return {
-            ...primitive,
-            anchor: newAnchor,
-          }
-        }
-        return primitive
-      }),
-    }
-    return this
-  }
-
-  labelPort(currentLabel: string, newLabels: string[]): ModifySymbolBuilder {
-    this.symbol = {
-      ...this.symbol,
-      ports: this.symbol.ports.map((port) => {
-        return port.labels.includes(currentLabel)
-          ? { ...port, labels: newLabels }
-          : port
-      }),
-    }
-    return this
-  }
-
-  rotateRightFacingSymbol(
-    newOrientation: "up" | "down" | "left" | "right",
-  ): ModifySymbolBuilder {
-    this.symbol = rotateRightFacingSymbol(this.symbol, {
-      newOrientation,
-    })
-    return this
-  }
-
-  computeSize(): { width: number; height: number } {
-    const bounds = getBoundsOfPrimitives(this.symbol.primitives)
-    return {
-      width: bounds.maxX - bounds.minX,
-      height: bounds.maxY - bounds.minY,
-    }
-  }
-
-  build(): SchSymbol {
-    return { ...this.symbol, size: this.computeSize() }
-  }
-}
-
-export const modifySymbol = (symbol: any): ModifySymbolBuilder => {
-  return new SymbolModifier({
-    ...symbol,
-    primitives: symbol.primitives ?? [
-      ...Object.values(symbol.paths ?? {}),
-      ...Object.values(symbol.texts ?? {}),
-      ...Object.values(symbol.circles ?? {}),
-      ...Object.values(symbol.rects ?? {}),
-    ],
-    ports:
-      symbol.ports ??
-      Object.entries(symbol.refblocks).flatMap(([key, refblock]) => {
-        return [{ ...(refblock as object), labels: [key] }]
-      }),
-    center: symbol.center ?? {
-      x: symbol.bounds.centerX,
-      y: symbol.bounds.centerY,
-    },
-  })
-}

package/drawing/ninePointAnchorToSvgAnchor.ts

@@ -1,11 +0,0 @@
-export const ninePointAnchorToSvgAnchor = {
-  top_left: "start",
-  top_right: "end",
-  bottom_left: "start",
-  bottom_right: "end",
-  center: "middle",
-  middle_top: "middle",
-  middle_bottom: "middle",
-  middle_left: "start",
-  middle_right: "end",
-}

package/drawing/path.ts

@@ -1,5 +0,0 @@
-import type { PathPrimitive } from "drawing"
-
-export function path(options: Omit<PathPrimitive, "type">): PathPrimitive {
-  return { type: "path", ...options }
-}

package/drawing/pathToSvgD.ts

@@ -1,22 +0,0 @@
-import type { Point } from "drawing"
-import { makeYUpPositive } from "./utils/makeYUpPositive"
-
-export function pathToSvgD(
-  points: Point[],
-  {
-    closed = false,
-    yUpPositive = true,
-  }: {
-    closed?: boolean
-    yUpPositive?: boolean
-  },
-): string {
-  const pathCommands = points
-    .map(
-      (point, index) =>
-        `${index === 0 ? "M" : "L"}${point.x},${makeYUpPositive(point.y, yUpPositive)}`,
-    )
-    .join(" ")
-
-  return closed ? `${pathCommands} Z` : pathCommands
-}

package/drawing/resizeSymbol.ts

@@ -1,67 +0,0 @@
-import type { SchSymbol } from "./types"
-
-export function resizeSymbol(
-  symbol: SchSymbol,
-  newSize: { width?: number; height?: number },
-): SchSymbol {
-  const { width: oldWidth, height: oldHeight } = symbol.size
-  let scaleX = 1,
-    scaleY = 1
-
-  if (newSize.width && newSize.height) {
-    scaleX = newSize.width / oldWidth
-    scaleY = newSize.height / oldHeight
-  } else if (newSize.width) {
-    scaleX = scaleY = newSize.width / oldWidth
-  } else if (newSize.height) {
-    scaleX = scaleY = newSize.height / oldHeight
-  }
-
-  const resizedPrimitives = symbol.primitives.map((primitive) => {
-    switch (primitive.type) {
-      case "path":
-        return {
-          ...primitive,
-          points: primitive.points.map((p) => ({
-            x: p.x * scaleX,
-            y: p.y * scaleY,
-          })),
-        }
-      case "text":
-      case "circle":
-        return {
-          ...primitive,
-          x: primitive.x * scaleX,
-          y: primitive.y * scaleY,
-        }
-      case "box":
-        return {
-          ...primitive,
-          x: primitive.x * scaleX,
-          y: primitive.y * scaleY,
-          width: primitive.width * scaleX,
-          height: primitive.height * scaleY,
-        }
-      default:
-        return primitive
-    }
-  })
-
-  return {
-    ...symbol,
-    primitives: resizedPrimitives,
-    center: {
-      x: symbol.center.x * scaleX,
-      y: symbol.center.y * scaleY,
-    },
-    ports: symbol.ports.map((port) => ({
-      ...port,
-      x: port.x * scaleX,
-      y: port.y * scaleY,
-    })),
-    size: {
-      width: oldWidth * scaleX,
-      height: oldHeight * scaleY,
-    },
-  }
-}