@tscircuit/fake-snippets 0.0.120 → 0.0.122

package/src/hooks/use-ai-review.ts

@@ -1,31 +0,0 @@
-import type { AiReview } from "fake-snippets-api/lib/db/schema"
-import { useQuery } from "react-query"
-import { useAxios } from "./use-axios"
-
-export const useAiReview = (
-  aiReviewId: string | null,
-  options?: {
-    refetchInterval?:
-      | number
-      | false
-      | ((data: AiReview | undefined) => number | false)
-  },
-) => {
-  const axios = useAxios()
-
-  return useQuery<AiReview, Error & { status: number }>(
-    ["aiReview", aiReviewId],
-    async () => {
-      if (!aiReviewId) throw new Error("aiReviewId is required")
-      const { data } = await axios.get("/ai_reviews/get", {
-        params: { ai_review_id: aiReviewId },
-      })
-      return data.ai_review as AiReview
-    },
-    {
-      enabled: Boolean(aiReviewId),
-      refetchInterval: options?.refetchInterval,
-      refetchOnWindowFocus: false,
-    },
-  )
-}

package/src/hooks/use-axios.ts

@@ -1,20 +0,0 @@
-import axios from "redaxios"
-import { useMemo } from "react"
-import { useGlobalStore } from "./use-global-store"
-import { useApiBaseUrl } from "./use-packages-base-api-url"
-
-export const useAxios = () => {
-  const snippetsBaseApiUrl = useApiBaseUrl()
-  const session = useGlobalStore((s) => s.session)
-  return useMemo(() => {
-    const instance = axios.create({
-      baseURL: snippetsBaseApiUrl,
-      headers: session
-        ? {
-            Authorization: `Bearer ${session?.token}`,
-          }
-        : {},
-    })
-    return instance
-  }, [session?.token])
-}

package/src/hooks/use-code-completion-ai-api.ts

@@ -1,11 +0,0 @@
-import { useMemo } from "react"
-
-export const useCodeCompletionApi = () => {
-  const openrouterApiKey = useMemo(() => {
-    return {
-      apiKey: import.meta.env.VITE_OPENROUTER_API_KEY,
-    }
-  }, [])
-
-  return openrouterApiKey
-}

package/src/hooks/use-copy-to-clipboard.ts

@@ -1,26 +0,0 @@
-import { useToast } from "@/hooks/use-toast"
-import { useCallback } from "react"
-
-export const useCopyToClipboard = () => {
-  const { toast } = useToast()
-
-  const copyToClipboard = useCallback(
-    async (text: string) => {
-      try {
-        await navigator.clipboard.writeText(text)
-        toast({
-          title: "Copied to clipboard!",
-          description: "The text has been copied successfully.",
-        })
-      } catch (error) {
-        toast({
-          title: "Failed to copy",
-          description: "There was an error copying the text.",
-        })
-      }
-    },
-    [toast],
-  )
-
-  return { copyToClipboard }
-}

package/src/hooks/use-create-datasheet.ts

@@ -1,30 +0,0 @@
-import { useMutation, useQueryClient } from "react-query"
-import { useAxios } from "@/hooks/use-axios"
-import type { Datasheet } from "fake-snippets-api/lib/db/schema"
-
-export const useCreateDatasheet = ({
-  onSuccess,
-}: { onSuccess?: (datasheet: Datasheet) => void } = {}) => {
-  const axios = useAxios()
-  const queryClient = useQueryClient()
-
-  return useMutation(
-    ["createDatasheet"],
-    async ({ chip_name }: { chip_name: string }) => {
-      const { data } = await axios.post("/datasheets/create", { chip_name })
-      await axios.get("/_fake/run_async_tasks")
-      return data.datasheet as Datasheet
-    },
-    {
-      onSuccess: (datasheet, variables) => {
-        if (variables?.chip_name) {
-          queryClient.invalidateQueries(["datasheet", variables.chip_name])
-        }
-        onSuccess?.(datasheet)
-      },
-      onError: (error: any) => {
-        console.error("Error creating datasheet:", error)
-      },
-    },
-  )
-}

package/src/hooks/use-create-org-mutation.ts

@@ -1,38 +0,0 @@
-import { useMutation } from "react-query"
-import { useAxios } from "./use-axios"
-import { useGlobalStore } from "./use-global-store"
-import type { PublicOrgSchema } from "fake-snippets-api/lib/db/schema"
-
-export const useCreateOrgMutation = ({
-  onSuccess,
-}: { onSuccess?: (org: PublicOrgSchema) => void } = {}) => {
-  const axios = useAxios()
-  const session = useGlobalStore((s) => s.session)
-
-  return useMutation(
-    ["createOrg"],
-    async ({ name }: { name: string }) => {
-      if (!session) throw new Error("No session")
-
-      const {
-        data: { org: newOrg },
-      } = await axios.post("/orgs/create", {
-        name,
-      })
-
-      if (!newOrg) {
-        throw new Error("Failed to create organization")
-      }
-
-      return newOrg
-    },
-    {
-      onSuccess: (org: PublicOrgSchema) => {
-        onSuccess?.(org)
-      },
-      onError: (error: any) => {
-        console.error("Error creating organization:", error)
-      },
-    },
-  )
-}

package/src/hooks/use-create-package-files-mutation.ts

@@ -1,76 +0,0 @@
-import type { PackageFile } from "fake-snippets-api/lib/db/schema"
-import { useMutation } from "react-query"
-import { useAxios } from "./use-axios"
-
-export const useCreatePackageFilesMutation = ({
-  onSuccess,
-}: { onSuccess?: (packageFile: PackageFile) => void } = {}) => {
-  const axios = useAxios()
-
-  return useMutation(
-    ["createPackageFiles"],
-    async ({
-      file_path,
-      content_text,
-      content_base64,
-      content_mimetype,
-      package_release_id,
-      package_name_with_version,
-      is_release_tarball = false,
-      npm_pack_output,
-    }: {
-      file_path: string
-      content_text?: string
-      content_base64?: string
-      content_mimetype?: string
-      package_release_id?: string
-      package_name_with_version?: string
-      is_release_tarball?: boolean
-      npm_pack_output?: any
-    }) => {
-      // Validate that either content_text or content_base64 is provided, but not both
-      if (
-        (!content_text && !content_base64) ||
-        (content_text && content_base64)
-      ) {
-        throw new Error(
-          "Must provide either content_text or content_base64, but not both",
-        )
-      }
-
-      // Validate that either package_release_id or package_name_with_version is provided
-      if (!package_release_id && !package_name_with_version) {
-        throw new Error(
-          "Must provide either package_release_id or package_name_with_version",
-        )
-      }
-
-      const {
-        data: { package_file: newPackageFile },
-      } = await axios.post("/package_files/create", {
-        file_path,
-        content_text,
-        content_base64,
-        content_mimetype,
-        package_release_id,
-        package_name_with_version,
-        is_release_tarball,
-        npm_pack_output,
-      })
-
-      if (!newPackageFile) {
-        throw new Error("Failed to create package file")
-      }
-
-      return newPackageFile
-    },
-    {
-      onSuccess: (packageFile: PackageFile) => {
-        onSuccess?.(packageFile)
-      },
-      onError: (error: any) => {
-        console.error("Error creating package file:", error)
-      },
-    },
-  )
-}

package/src/hooks/use-create-package-mutation.ts

@@ -1,54 +0,0 @@
-import type { Package } from "fake-snippets-api/lib/db/schema"
-import { useMutation } from "react-query"
-import { useAxios } from "./use-axios"
-import { useGlobalStore } from "./use-global-store"
-
-export const useCreatePackageMutation = ({
-  onSuccess,
-}: { onSuccess?: (pkg: Package) => void } = {}) => {
-  const axios = useAxios()
-  const session = useGlobalStore((s) => s.session)
-
-  return useMutation(
-    ["createPackage"],
-    async ({
-      name,
-      description,
-      is_private,
-      is_unlisted,
-      org_id,
-    }: {
-      name?: string
-      description?: string
-      is_private?: boolean
-      is_unlisted?: boolean
-      org_id?: string
-    }) => {
-      if (!session) throw new Error("No session")
-
-      const {
-        data: { package: newPackage },
-      } = await axios.post("/packages/create", {
-        name,
-        description,
-        is_private,
-        is_unlisted,
-        org_id,
-      })
-
-      if (!newPackage) {
-        throw new Error("Failed to create package")
-      }
-
-      return newPackage
-    },
-    {
-      onSuccess: (pkg: Package) => {
-        onSuccess?.(pkg)
-      },
-      onError: (error: any) => {
-        console.error("Error creating package:", error)
-      },
-    },
-  )
-}

package/src/hooks/use-create-package-release-mutation.ts

@@ -1,107 +0,0 @@
-import type { PackageRelease } from "fake-snippets-api/lib/db/schema"
-import { useMutation } from "react-query"
-import { useAxios } from "./use-axios"
-
-export const useCreatePackageReleaseMutation = ({
-  onSuccess,
-}: { onSuccess?: (packageRelease: PackageRelease) => void } = {}) => {
-  const axios = useAxios()
-
-  return useMutation(
-    ["createPackageRelease"],
-    async ({
-      package_id,
-      version,
-      is_latest = true,
-      commit_sha,
-      package_name_with_version,
-    }: {
-      package_id?: string
-      version?: string
-      is_latest?: boolean
-      commit_sha?: string
-      package_name_with_version?: string
-    }) => {
-      // Validate that either package_id + version or package_name_with_version is provided
-      if (!package_name_with_version && (!package_id || !version)) {
-        throw new Error(
-          "Must provide either package_id + version or package_name_with_version",
-        )
-      }
-
-      let resolvedVersion = version
-      let resolvedPkgName = package_name_with_version
-
-      // Parse version from package_name_with_version if needed
-      if (package_name_with_version && !version) {
-        const [pkgName, parsedVersion] = package_name_with_version.split("@")
-        resolvedVersion = parsedVersion
-        resolvedPkgName = pkgName
-      } else if (package_name_with_version) {
-        const [pkgName] = package_name_with_version.split("@")
-        resolvedPkgName = pkgName
-      }
-
-      // Default version to 0.0.1 when it contains no digits
-      if (!resolvedVersion || !/[0-9]/.test(resolvedVersion)) {
-        resolvedVersion = "0.0.1"
-      }
-
-      const normalizedPackageNameWithVersion =
-        resolvedPkgName && `${resolvedPkgName}@${resolvedVersion}`
-
-      try {
-        const {
-          data: { package_release: newPackageRelease },
-        } = await axios.post("/package_releases/create", {
-          package_id,
-          version: resolvedVersion,
-          is_latest,
-          commit_sha,
-          package_name_with_version: normalizedPackageNameWithVersion,
-        })
-
-        if (!newPackageRelease) {
-          throw new Error("Failed to create package release")
-        }
-
-        return newPackageRelease
-      } catch (error: any) {
-        if (
-          error.status === 400 &&
-          error.data?.error?.error_code === "version_already_exists" &&
-          normalizedPackageNameWithVersion
-        ) {
-          // Update the existing release with the provided data
-          await axios.post("/package_releases/update", {
-            package_name_with_version: normalizedPackageNameWithVersion,
-            is_latest,
-            commit_sha,
-          })
-
-          const {
-            data: { package_release },
-          } = await axios.post("/package_releases/get", {
-            package_name_with_version: normalizedPackageNameWithVersion,
-          })
-
-          if (!package_release) {
-            throw new Error("Failed to update package release")
-          }
-
-          return package_release as PackageRelease
-        }
-
-        throw error
-      }
-    },
-    {
-      onSuccess: (packageRelease: PackageRelease) => {
-        onSuccess?.(packageRelease)
-      },
-      onError: (error: any) => {
-        console.error("Error creating package release:", error)
-      },
-    },
-  )
-}

package/src/hooks/use-create-release-dialog.ts

@@ -1,160 +0,0 @@
-import { useState } from "react"
-import { useCreatePackageReleaseMutation } from "./use-create-package-release-mutation"
-import { useGlobalStore } from "./use-global-store"
-import { useUpdatePackageFilesMutation } from "./useUpdatePackageFilesMutation"
-import type { PackageFile } from "@/types/package"
-import type { Package } from "fake-snippets-api/lib/db/schema"
-import { useToast } from "./use-toast"
-
-interface UseCreateReleaseDialogProps {
-  packageId?: string
-  packageName?: string
-  currentVersion?: string
-  onSuccess?: (release: any) => void
-  files?: PackageFile[]
-  currentPackage?: Package
-  packageFilesMeta?: {
-    created_at: string
-    file_path: string
-    package_file_id: string
-    package_release_id: string
-  }[]
-}
-
-export const useCreateReleaseDialog = ({
-  packageId,
-  packageName,
-  currentVersion,
-  onSuccess,
-  files = [],
-  currentPackage,
-  packageFilesMeta = [],
-}: UseCreateReleaseDialogProps) => {
-  const { toast } = useToast()
-  const [isOpen, setIsOpen] = useState(false)
-  const [version, setVersion] = useState("")
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-
-  const suggestedNextVersion = currentVersion
-    ? (() => {
-        const parts = currentVersion.split(".")
-        if (parts.length === 3) {
-          const [major, minor, patch] = parts.map(Number)
-          if (!isNaN(major) && !isNaN(minor) && !isNaN(patch)) {
-            return `${major}.${minor}.${patch + 1}`
-          }
-        }
-        return undefined
-      })()
-    : undefined
-
-  const { mutateAsync: createRelease } = useCreatePackageReleaseMutation({
-    onSuccess: () => {
-      toast({
-        title: "Package release created",
-        description: "Your package release has been created successfully.",
-      })
-    },
-  })
-  const session = useGlobalStore((s) => s.session)
-
-  const updatePackageFilesMutation = useUpdatePackageFilesMutation({
-    currentPackage,
-    localFiles: files,
-    initialFiles: [],
-    packageFilesMeta,
-  })
-
-  const open = () => {
-    setIsOpen(true)
-    setError(null)
-    // Auto-fill with suggested next version
-    const nextVersion = suggestedNextVersion || "0.0.1"
-    setVersion(nextVersion)
-  }
-
-  const close = () => {
-    setIsOpen(false)
-    setError(null)
-    setVersion("")
-  }
-
-  const handleCreateRelease = async () => {
-    if (!version.trim()) {
-      setError("Version is required")
-      return
-    }
-
-    if (!packageId && !packageName) {
-      setError("Package information is missing")
-      return
-    }
-
-    if (!session) {
-      setError("You must be logged in to create a release")
-      return
-    }
-
-    setIsLoading(true)
-    setError(null)
-
-    try {
-      const releaseData: any = {
-        version: version.trim(),
-        is_latest: true,
-      }
-
-      if (packageId) {
-        releaseData.package_id = packageId
-      } else if (packageName) {
-        releaseData.package_name = packageName
-      }
-
-      const result = await createRelease(releaseData)
-
-      if (files.length > 0 && currentPackage) {
-        try {
-          await updatePackageFilesMutation.mutateAsync({
-            package_name_with_version: `${currentPackage.name}@${version.trim()}`,
-            ...currentPackage,
-          })
-        } catch (fileError: any) {
-          console.error("Error uploading files:", fileError)
-          toast({
-            title: "Error",
-            description: "Failed to upload some files to the release",
-          })
-        }
-      }
-
-      onSuccess?.(result)
-      close()
-    } catch (err: any) {
-      const errorMessage =
-        err?.response?.data?.error?.message ||
-        err?.message ||
-        "Failed to create release"
-      setError(errorMessage)
-      toast({
-        title: "Error",
-        description: errorMessage,
-      })
-    } finally {
-      setIsLoading(false)
-    }
-  }
-
-  return {
-    isOpen,
-    openDialog: open,
-    closeDialog: close,
-    version,
-    setVersion,
-    currentVersion,
-    suggestedNextVersion,
-    isLoading: isLoading || updatePackageFilesMutation.isLoading,
-    error,
-    handleCreateRelease,
-  }
-}

package/src/hooks/use-create-snippet-mutation.ts

@@ -1,65 +0,0 @@
-import { getSnippetTemplate } from "@/lib/get-snippet-template"
-import { Snippet } from "fake-snippets-api/lib/db/schema"
-import { useMutation } from "react-query"
-import { useAxios } from "./use-axios"
-import { useGlobalStore } from "./use-global-store"
-import { useUrlParams } from "./use-url-params"
-
-export const useCreateSnippetMutation = ({
-  onSuccess,
-}: { onSuccess?: (snippet: Snippet) => void } = {}) => {
-  const urlParams = useUrlParams()
-  const templateName = urlParams.template
-  const axios = useAxios()
-  const session = useGlobalStore((s) => s.session)
-  return useMutation(
-    ["createSnippet"],
-    async ({
-      code,
-      circuit_json,
-      manual_edits_json_content,
-      is_private,
-    }: {
-      code?: string
-      circuit_json?: any[]
-      manual_edits_json_content?: string
-      is_private?: boolean
-    } = {}) => {
-      if (!session) throw new Error("No session")
-      const template =
-        typeof code === "string"
-          ? {
-              code,
-              type:
-                urlParams.type ||
-                (code.includes("<board") ? "board" : "package"),
-            }
-          : getSnippetTemplate(templateName)
-      const {
-        data: { snippet },
-      } = await axios.post("/snippets/create", {
-        code: template.code,
-        snippet_type: template.type ?? "board",
-        manual_edits_json_content,
-        owner_name: session?.github_username,
-        circuit_json,
-        is_private,
-      })
-      return snippet
-    },
-    {
-      onSuccess: (snippet: any) => {
-        const url = new URL(window.location.href)
-        url.searchParams.set("snippet_id", snippet.snippet_id)
-        url.searchParams.delete("template")
-        url.searchParams.delete("should_create_snippet")
-        window.history.pushState({}, "", url.toString())
-        onSuccess?.(snippet)
-        window.dispatchEvent(new Event("popstate"))
-      },
-      onError: (error: any) => {
-        console.error("Error creating snippet:", error)
-      },
-    },
-  )
-}

package/src/hooks/use-current-package-id.ts

@@ -1,16 +0,0 @@
-import { useCurrentPackageInfo } from "./use-current-package-info"
-
-export const useCurrentPackageId = (): {
-  packageId: string | null
-  isLoading: boolean
-  error: (Error & { status: number }) | null
-} => {
-  const { packageInfo, isLoading, error } = useCurrentPackageInfo()
-  const packageId = packageInfo?.package_id ?? null
-
-  return {
-    packageId,
-    isLoading,
-    error,
-  }
-}

package/src/hooks/use-current-package-info.ts

@@ -1,32 +0,0 @@
-import { useParams } from "wouter"
-import { usePackageById } from "./use-package-by-package-id"
-import { usePackageByName } from "./use-package-by-package-name"
-import { useUrlParams } from "./use-url-params"
-import type { Package } from "fake-snippets-api/lib/db/schema"
-
-export const useCurrentPackageInfo = (): {
-  packageInfo: Package | undefined
-  isLoading: boolean
-  error: (Error & { status: number }) | null
-  refetch: () => Promise<unknown>
-} => {
-  const urlParams = useUrlParams()
-  const packageIdFromQuery = urlParams.package_id ?? null
-
-  const { author, packageName } = useParams()
-  const packageSlug = author && packageName ? `${author}/${packageName}` : null
-
-  const queryById = usePackageById(packageIdFromQuery)
-  const queryByName = usePackageByName(packageSlug)
-
-  const data = queryById.data ?? queryByName.data
-  const isLoading = queryById.isLoading || queryByName.isLoading
-  const error =
-    (queryById.error as (Error & { status: number }) | null) ??
-    (queryByName.error as (Error & { status: number }) | null) ??
-    null
-
-  const refetch = packageIdFromQuery ? queryById.refetch : queryByName.refetch
-
-  return { packageInfo: data, isLoading, error, refetch }
-}