@tscircuit/fake-snippets 0.0.121 → 0.0.123

package/src/lib/ts-lib-cache.ts

@@ -1,162 +0,0 @@
-import {
-  createDefaultMapFromCDN,
-  knownLibFilesForCompilerOptions,
-} from "@typescript/vfs"
-import { get, set } from "idb-keyval"
-import { compressToUTF16, decompressFromUTF16 } from "lz-string"
-import ts from "typescript"
-
-const TS_LIB_VERSION = "5.6.3"
-const CACHE_PREFIX = `ts-lib-${TS_LIB_VERSION}-`
-const CACHE_TTL = 7 * 24 * 60 * 60 * 1000 // 7 days
-
-export async function loadDefaultLibMap(): Promise<Map<string, string>> {
-  const fsMap = new Map<string, string>()
-  const libs = knownLibFilesForCompilerOptions(
-    { target: ts.ScriptTarget.ES2022 },
-    ts,
-  )
-  const missing: string[] = []
-
-  for (const lib of libs) {
-    const cacheKey = CACHE_PREFIX + lib
-    const cached = await get(cacheKey)
-    if (
-      cached &&
-      typeof cached === "object" &&
-      "compressedFileContent" in cached &&
-      "timestamp" in cached
-    ) {
-      const { compressedFileContent, timestamp } = cached as {
-        compressedFileContent: string
-        timestamp: number
-      }
-      if (Date.now() - timestamp < CACHE_TTL) {
-        fsMap.set("/" + lib, decompressFromUTF16(compressedFileContent))
-      } else {
-        missing.push(lib)
-      }
-    } else {
-      missing.push(lib)
-    }
-  }
-
-  if (missing.length > 0) {
-    const fetched = await createDefaultMapFromCDN(
-      { target: ts.ScriptTarget.ES2022 },
-      TS_LIB_VERSION,
-      true,
-      ts,
-      { compressToUTF16, decompressFromUTF16 } as any,
-    )
-    for (const [filename, content] of fetched) {
-      fsMap.set(filename, content)
-      const cacheKey = CACHE_PREFIX + filename.replace(/^\//, "")
-      const compressed = compressToUTF16(content)
-      await set(cacheKey, {
-        compressedFileContent: compressed,
-        timestamp: Date.now(),
-      }).catch(() => {})
-    }
-  }
-
-  return fsMap
-}
-
-export async function fetchWithPackageCaching(
-  input: RequestInfo | URL,
-  init?: RequestInit,
-): Promise<Response> {
-  const url = typeof input === "string" ? input : input.toString()
-
-  // Only cache GET requests for packages
-  if (init?.method && init.method !== "GET") {
-    return fetch(input, init)
-  }
-
-  // Check if this should be cached
-  const shouldCache =
-    url.includes("jsdelivr.net") ||
-    url.includes("unpkg.com") ||
-    url.includes("@types/") ||
-    url.includes("@tsci/")
-
-  if (!shouldCache) {
-    return fetch(input, init)
-  }
-
-  const cacheKey = `package-cache-${url}`
-
-  // Check cache
-  const cached = await get(cacheKey).catch(() => null)
-  if (
-    cached &&
-    typeof cached === "object" &&
-    "compressedFileContent" in cached &&
-    "timestamp" in cached
-  ) {
-    const { compressedFileContent, timestamp } = cached as {
-      compressedFileContent: string
-      timestamp: number
-    }
-    if (Date.now() - timestamp < CACHE_TTL) {
-      return new Response(decompressFromUTF16(compressedFileContent), {
-        status: 200,
-        statusText: "OK",
-      })
-    }
-  }
-
-  // Handle @tsci packages
-  let fetchUrl = url
-  if (
-    url.includes("@tsci/") &&
-    (url.includes("jsdelivr.net") || url.includes("data.jsdelivr.com"))
-  ) {
-    let packagePath = ""
-    if (url.includes("jsdelivr.net")) {
-      packagePath = url.replace("https://cdn.jsdelivr.net/npm/@tsci/", "")
-    } else if (url.includes("/v1/package/resolve/npm/@tsci/")) {
-      const resolveIndex = url.indexOf("/v1/package/resolve/npm/@tsci/")
-      packagePath = url.substring(
-        resolveIndex + "/v1/package/resolve/npm/@tsci/".length,
-      )
-    } else if (url.includes("/v1/package/npm/@tsci/")) {
-      const npmIndex = url.indexOf("/v1/package/npm/@tsci/")
-      packagePath = url.substring(npmIndex + "/v1/package/npm/@tsci/".length)
-    }
-
-    if (packagePath) {
-      // Convert dots to slashes in the package name part (like original logic)
-      const parts = packagePath.split("/")
-      if (parts.length > 0) {
-        parts[0] = parts[0].replace(/\./, "/")
-      }
-      const transformedPackagePath = parts.join("/")
-
-      const apiUrl = import.meta.env.VITE_SNIPPETS_API_URL ?? "/api"
-      const isResolve = url.includes("/resolve/")
-      fetchUrl = `${apiUrl}/snippets/download?jsdelivr_resolve=${isResolve}&jsdelivr_path=${encodeURIComponent(
-        transformedPackagePath,
-      )}`
-    }
-  }
-
-  // Fetch and cache
-  const response = await fetch(fetchUrl, init)
-  if (response.ok) {
-    const text = await response.text()
-    const compressed = compressToUTF16(text)
-    await set(cacheKey, {
-      compressedFileContent: compressed,
-      timestamp: Date.now(),
-    }).catch(() => {})
-    return new Response(text, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers,
-    })
-  }
-
-  return response
-}

package/src/lib/types.ts

@@ -1,31 +0,0 @@
-import { Object3D, Object3DEventMap } from "three"
-
-declare global {
-  interface Window {
-    TSCIRCUIT_REGISTRY_API_BASE_URL: string
-    TSCIRCUIT_REGISTRY_TOKEN: string | null
-    TSCIRCUIT_STRIPE_CHECKOUT_BASE_URL: string
-    TSCIRCUIT_3D_OBJECT_REF: Object3D<Object3DEventMap> | undefined
-    __DEBUG_CODE_EDITOR_FS_MAP: Map<string, string>
-    prettier: {
-      format: (code: string, options: any) => string
-    }
-    prettierPlugins: any
-    /** Timestamp in milliseconds of when the application was first loaded */
-    __APP_LOADED_AT?: number
-  }
-}
-
-export interface PackageInfo {
-  name: string
-  unscoped_name: string
-  owner_github_username: string
-  star_count: string
-  description: string
-  ai_description: string
-  ai_usage_instructions: string
-  creator_account_id?: string
-  owner_org_id?: string
-  package_id: string
-  latest_package_release_id: string
-}

package/src/lib/utils/checkIfManualEditsImported.ts

@@ -1,20 +0,0 @@
-import { findTargetFile } from "./findTargetFile"
-
-export const checkIfManualEditsImported = (
-  files: Record<string, string>,
-  file: string = "index.tsx",
-) => {
-  if (!files[file]) return false
-  const targetFile = findTargetFile({
-    files: Object.keys(files).map((f) => ({ path: f, content: files[f] })),
-    filePathFromUrl: null,
-  })
-  if (targetFile && file !== targetFile.path) {
-    return false
-  }
-  if (!file.endsWith(".tsx") && !file.endsWith(".ts")) return false
-  const importRegex =
-    /import\s+(?:\*\s+as\s+)?([a-zA-Z_$][\w$]*)\s+from\s+["'](?:\.\/)?manual-edits\.json["'];?/
-  const hasManualEditsImported = importRegex.test(files[file])
-  return !!files["manual-edits.json"]?.trim() && !hasManualEditsImported
-}

package/src/lib/utils/findTargetFile.ts

@@ -1,97 +0,0 @@
-import { isHiddenFile } from "@/components/ViewPackagePage/utils/is-hidden-file"
-import { PackageFile } from "@/types/package"
-import { isComponentExported } from "./isComponentExported"
-
-export const findMainEntrypointFileFromTscircuitConfig = (
-  files: PackageFile[],
-): PackageFile | null => {
-  const configFile = files.find((file) => file.path === "tscircuit.config.json")
-
-  if (configFile) {
-    try {
-      const config = JSON.parse(configFile.content)
-
-      if (config && typeof config.mainEntrypoint === "string") {
-        const mainComponentPath = config.mainEntrypoint
-
-        const normalizedPath = mainComponentPath.startsWith("./")
-          ? mainComponentPath.substring(2)
-          : mainComponentPath
-
-        return files.find((file) => file.path === normalizedPath) ?? null
-      }
-    } catch {}
-  }
-
-  return null
-}
-
-export const findTargetFile = ({
-  files,
-  filePathFromUrl,
-  fallbackToAnyFile = true,
-}: {
-  files: PackageFile[]
-  filePathFromUrl: string | null
-  fallbackToAnyFile?: boolean
-}): PackageFile | null => {
-  if (files.length === 0) {
-    return null
-  }
-
-  let targetFile: PackageFile | undefined | null = null
-  if (!filePathFromUrl) {
-    files = files.filter((x) => !isHiddenFile(x.path))
-  }
-
-  if (filePathFromUrl) {
-    const file = files.find((file) => file.path === filePathFromUrl)?.path
-    if (
-      file &&
-      !file.endsWith(".ts") &&
-      !file.endsWith(".tsx") &&
-      fallbackToAnyFile
-    ) {
-      targetFile = files.find((file) => file.path === filePathFromUrl) ?? null
-    } else {
-      const _isComponentExported = isComponentExported(
-        files.find((file) => file.path === filePathFromUrl)?.content || "",
-      )
-      if (_isComponentExported) {
-        targetFile = files.find((file) => file.path === filePathFromUrl) ?? null
-      }
-    }
-  }
-
-  if (!targetFile) {
-    targetFile = findMainEntrypointFileFromTscircuitConfig(files)
-  }
-  if (!targetFile) {
-    targetFile =
-      files.find(
-        (file) => file.path === "index.tsx" || file.path === "index.ts",
-      ) ?? null
-  }
-
-  if (!targetFile) {
-    targetFile =
-      files.find((file) => file.path.endsWith(".circuit.tsx")) ?? null
-  }
-
-  if (!targetFile) {
-    targetFile =
-      files.find(
-        (file) => file.path === "main.tsx" || file.path === "main.ts",
-      ) ?? null
-  }
-
-  if (!targetFile) {
-    targetFile = files.find((file) => file.path.endsWith(".tsx")) ?? null
-  }
-
-  if (!targetFile && files[0] && fallbackToAnyFile) {
-    targetFile = files[0]
-  }
-
-  return targetFile
-}

package/src/lib/utils/formatTimeAgo.ts

@@ -1,10 +0,0 @@
-export const formatTimeAgo = (dateString: string) => {
-  const date = new Date(dateString)
-  const now = new Date()
-  const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000)
-
-  if (diffInSeconds < 60) return "just now"
-  if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`
-  if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`
-  return `${Math.floor(diffInSeconds / 86400)}d ago`
-}

package/src/lib/utils/getPackagePreviewImageUrl.ts

@@ -1,15 +0,0 @@
-import { Package } from "fake-snippets-api/lib/db/schema"
-
-export const getPackagePreviewImageUrl = (
-  pkg: Package,
-  view: "pcb" | "schematic" | "3d" = "pcb",
-) => {
-  switch (view) {
-    case "schematic":
-      return pkg.latest_sch_preview_image_url
-    case "3d":
-      return pkg.latest_cad_preview_image_url
-    default:
-      return pkg.latest_pcb_preview_image_url
-  }
-}

package/src/lib/utils/index.ts

@@ -1,6 +0,0 @@
-import { clsx, type ClassValue } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}

package/src/lib/utils/isComponentExported.ts

@@ -1,10 +0,0 @@
-export const isComponentExported = (code: string) => {
-  return (
-    /export function\s+\w+/.test(code) ||
-    /export const\s+\w+\s*=/.test(code) ||
-    /export default\s+\w+/.test(code) ||
-    /export default\s+function\s*(\w*)\s*\(/.test(code) ||
-    /export default\s*\(\s*\)\s*=>/.test(code) ||
-    /export default\s*\(.*?\)\s*=>/.test(code)
-  )
-}

package/src/lib/utils/isUuid.ts

@@ -1,5 +0,0 @@
-export function isUuid(value: string): boolean {
-  const uuidRegex =
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-  return uuidRegex.test(value) || value.startsWith("package_release_")
-}

package/src/lib/utils/isValidFileName.ts

@@ -1,17 +0,0 @@
-export const isValidFileName = (name: string) => {
-  const invalidChars = /[<>:"\\|?*]/
-
-  if (name.length === 0) return false
-  if (invalidChars.test(name)) return false
-
-  const pathParts = name.split("/")
-
-  for (const part of pathParts) {
-    if (part === "") continue
-    if (part === "." || part === "..") return false
-    if (part.startsWith(" ") || part.endsWith(" ")) return false
-    if (part.includes("\\")) return false
-  }
-
-  return true
-}

package/src/lib/utils/load-prettier.ts

@@ -1,23 +0,0 @@
-export async function loadPrettier() {
-  if (window.prettier) return
-
-  await Promise.all([
-    loadScript("https://cdn.jsdelivr.net/npm/prettier@2.8.8/standalone.js"),
-    loadScript(
-      "https://cdn.jsdelivr.net/npm/prettier@2.8.8/parser-typescript.js",
-    ),
-    loadScript(
-      "https://cdn.jsdelivr.net/npm/prettier@2.8.8/parser-markdown.js",
-    ),
-  ])
-}
-
-function loadScript(src: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const script = document.createElement("script")
-    script.src = src
-    script.onload = () => resolve()
-    script.onerror = reject
-    document.head.appendChild(script)
-  })
-}

package/src/lib/utils/member-role.tsx

@@ -1,61 +0,0 @@
-import { PublicOrgSchema } from "fake-snippets-api/lib/db/schema"
-import { Crown, Shield, User } from "lucide-react"
-
-export type MemberRole = "owner" | "manager" | "member"
-
-export const getRoleName = (role: MemberRole) => {
-  return role.charAt(0).toUpperCase() + role.slice(1)
-}
-
-export const getMemberRole = (
-  organization: PublicOrgSchema,
-  accountId: string,
-): MemberRole => {
-  const isOwner =
-    String(accountId).trim() === String(organization.owner_account_id).trim()
-  const isManager = Object.values(organization.user_permissions ?? {}).some(
-    Boolean,
-  )
-  if (isOwner) {
-    return "owner"
-  }
-  if (isManager) {
-    return "manager"
-  }
-  return "member"
-}
-
-export const getRoleIcon = (role: MemberRole) => {
-  switch (role) {
-    case "owner":
-      return <Crown className="size-3" />
-    case "manager":
-      return <Shield className="size-3" />
-    case "member":
-      return <User className="size-3" />
-    default:
-      return <User className="size-3" />
-  }
-}
-
-export const getRoleColor = (role: MemberRole) => {
-  switch (role) {
-    case "owner":
-      return "bg-amber-100 text-amber-800 border-amber-200"
-    case "manager":
-      return "bg-blue-50 text-blue-700 border border-blue-200"
-    default:
-      return "bg-gray-100 text-gray-800 border-gray-200"
-  }
-}
-
-export const getRoleDescription = (role: MemberRole) => {
-  switch (role) {
-    case "owner":
-      return "Full access to organization settings"
-    case "manager":
-      return "Limited administrative privileges"
-    case "member":
-      return "Standard member access"
-  }
-}

package/src/lib/utils/package-utils.ts

@@ -1,7 +0,0 @@
-export const DEFAULT_CODE = `
-export default () => (
-  <board width="10mm" height="10mm">
-    {/* write your code here! */}
-  </board>
-)
-`.trim()

package/src/lib/utils/parseJsonOrNull.ts

@@ -1,8 +0,0 @@
-export const parseJsonOrNull = (string: string | null): any => {
-  if (!string) return null
-  try {
-    return JSON.parse(string)
-  } catch {
-    return null
-  }
-}

package/src/lib/utils/pcbManualEditEventHandler.ts

@@ -1,156 +0,0 @@
-import type { ManualTraceHint } from "@tscircuit/layout"
-import { getManualTraceHintFromEvent } from "@tscircuit/layout"
-import type { EditEvent } from "@tscircuit/manual-edit-events"
-import type {
-  AnyCircuitElement,
-  PcbComponent,
-  SourceComponentBase,
-} from "circuit-json"
-
-export interface PCBPlacement {
-  selector: string
-  center: { x: number; y: number }
-  relative_to: "group_center"
-  _edit_event_id?: string
-}
-
-export interface ManualEditState {
-  pcb_placements: PCBPlacement[]
-  edit_events: EditEvent[]
-  manual_trace_hints: ManualTraceHint[]
-}
-
-export const createInitialManualEditState = (): ManualEditState => ({
-  pcb_placements: [],
-  edit_events: [],
-  manual_trace_hints: [],
-})
-
-export const applyPcbEditEvents = ({
-  editEvents,
-  circuitJson,
-  manualEditsFileContent,
-}: {
-  editEvents: EditEvent[]
-  circuitJson: AnyCircuitElement[]
-  manualEditsFileContent?: string
-}): ManualEditState => {
-  try {
-    // Ensure we have a valid state to work with
-    const validatedManualEdits = ensureValidState(manualEditsFileContent)
-
-    // Create a new state object with properly initialized arrays
-    const newManualEditState: ManualEditState = {
-      pcb_placements: [...validatedManualEdits.pcb_placements],
-      edit_events: [...validatedManualEdits.edit_events],
-      manual_trace_hints: [...validatedManualEdits.manual_trace_hints],
-    }
-
-    // Create a set of handled event IDs
-    const handledEventIds = new Set<string>()
-
-    // Add existing event IDs to the set
-    newManualEditState.pcb_placements.forEach((placement) => {
-      if (placement._edit_event_id) {
-        handledEventIds.add(placement._edit_event_id)
-      }
-    })
-
-    newManualEditState.edit_events.forEach((event) => {
-      if (event.edit_event_id) {
-        handledEventIds.add(event.edit_event_id)
-      }
-    })
-
-    // Process new edit events
-    for (const editEvent of editEvents) {
-      if (
-        (editEvent.in_progress && !editEvent.edit_event_id) ||
-        handledEventIds.has(editEvent.edit_event_id)
-      )
-        continue
-
-      if (
-        editEvent.pcb_edit_event_type === "edit_component_location" &&
-        editEvent.pcb_component_id
-      ) {
-        // Find the component in the circuitJson
-        const pcbComponent = circuitJson.find(
-          (item: AnyCircuitElement) =>
-            item.type === "pcb_component" &&
-            item.pcb_component_id === editEvent.pcb_component_id,
-        ) as PcbComponent
-
-        if (!pcbComponent?.pcb_component_id) continue
-
-        const nameofComponent = circuitJson.find(
-          (item: AnyCircuitElement) =>
-            item.type === "source_component" &&
-            item.source_component_id === pcbComponent.source_component_id,
-        ) as SourceComponentBase
-
-        // Update or add placement
-        const existingPlacementIndex =
-          newManualEditState.pcb_placements.findIndex(
-            (p) => p.selector === nameofComponent.name,
-          )
-
-        const newPlacement: PCBPlacement = {
-          selector: nameofComponent.name,
-          center: editEvent.new_center,
-          relative_to: "group_center",
-          _edit_event_id: editEvent.edit_event_id,
-        }
-
-        if (existingPlacementIndex !== -1) {
-          // Update existing placement
-          newManualEditState.pcb_placements[existingPlacementIndex] =
-            newPlacement
-        } else {
-          // Add new placement
-          newManualEditState.pcb_placements.push(newPlacement)
-        }
-      } else if (editEvent.pcb_edit_event_type === "edit_trace_hint") {
-        const newTraceHint = getManualTraceHintFromEvent(circuitJson, editEvent)
-        if (newTraceHint) {
-          newManualEditState.manual_trace_hints = [
-            ...newManualEditState.manual_trace_hints.filter(
-              (th) => th.pcb_port_selector !== newTraceHint.pcb_port_selector,
-            ),
-            newTraceHint,
-          ]
-        }
-      } else {
-        // Add any other type of event to edit_events array
-        newManualEditState.edit_events.push(editEvent)
-      }
-
-      handledEventIds.add(editEvent.edit_event_id)
-    }
-
-    return newManualEditState
-  } catch (error) {
-    console.error("Error handling edit events:", error)
-    // Return a fresh state if there's an error
-    return createInitialManualEditState()
-  }
-}
-
-// Helper function to ensure we have a valid state
-const ensureValidState = (manualEditsFileContent?: string): ManualEditState => {
-  if (!manualEditsFileContent) return createInitialManualEditState()
-
-  const manualEditState = JSON.parse(manualEditsFileContent)
-
-  return {
-    pcb_placements: Array.isArray(manualEditState.pcb_placements)
-      ? manualEditState.pcb_placements
-      : [],
-    edit_events: Array.isArray(manualEditState.edit_events)
-      ? manualEditState.edit_events
-      : [],
-    manual_trace_hints: Array.isArray(manualEditState.manual_trace_hints)
-      ? manualEditState.manual_trace_hints
-      : [],
-  }
-}

package/src/lib/utils/resolveRelativePath.ts

@@ -1,40 +0,0 @@
-/**
- * Resolves a relative file path to an absolute path based on the current file
- */
-export const resolveRelativePath = (
-  relativePath: string,
-  currentFilePath: string,
-): string => {
-  if (!currentFilePath) return relativePath
-
-  const currentDir = currentFilePath.includes("/")
-    ? currentFilePath.substring(0, currentFilePath.lastIndexOf("/"))
-    : ""
-
-  if (relativePath.startsWith("./")) {
-    return currentDir
-      ? `${currentDir}/${relativePath.slice(2)}`
-      : relativePath.slice(2)
-  }
-
-  if (relativePath.startsWith("../")) {
-    const parts = currentDir.split("/").filter((p) => p !== "")
-    const relativeParts = relativePath.split("/").filter((p) => p !== "")
-
-    let upCount = 0
-    for (const part of relativeParts) {
-      if (part === "..") {
-        upCount++
-      } else {
-        break
-      }
-    }
-
-    const resultParts = parts.slice(0, Math.max(0, parts.length - upCount))
-    const remainingParts = relativeParts.slice(upCount)
-
-    return [...resultParts, ...remainingParts].join("/")
-  }
-
-  return relativePath
-}