@tscircuit/fake-snippets 0.0.120 → 0.0.122

package/src/hooks/use-package-details-form.ts

@@ -1,146 +0,0 @@
-import { useState, useEffect, useMemo } from "react"
-
-const isValidUrl = (url: string): boolean => {
-  if (!url) return true
-  try {
-    new URL(url)
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-interface PackageDetailsForm {
-  description: string
-  website: string
-  license: string | null
-  visibility: string
-  defaultView: string
-  githubRepoFullName: string | null
-  unscopedPackageName: string
-  allowPrPreviews?: boolean
-}
-
-interface UsePackageDetailsFormProps {
-  initialDescription: string
-  initialWebsite: string
-  initialLicense: string | null
-  initialVisibility: string
-  initialDefaultView: string
-  initialUnscopedPackageName: string
-  initialGithubRepoFullName: string | null
-  isDialogOpen: boolean
-  initialAllowPrPreviews?: boolean
-}
-
-export const usePackageDetailsForm = ({
-  initialDescription,
-  initialWebsite,
-  initialLicense,
-  initialVisibility,
-  initialDefaultView,
-  initialUnscopedPackageName,
-  initialGithubRepoFullName,
-  isDialogOpen,
-  initialAllowPrPreviews,
-}: UsePackageDetailsFormProps) => {
-  const [formData, setFormData] = useState<PackageDetailsForm>({
-    description: initialDescription,
-    website: initialWebsite,
-    license: initialLicense || null,
-    visibility: initialVisibility,
-    defaultView: initialDefaultView,
-    githubRepoFullName: initialGithubRepoFullName,
-    unscopedPackageName: initialUnscopedPackageName,
-  })
-  const [websiteError, setWebsiteError] = useState<string | null>(null)
-
-  useEffect(() => {
-    if (isDialogOpen) {
-      setFormData({
-        description: initialDescription,
-        website: initialWebsite,
-        license: initialLicense || null,
-        visibility: initialVisibility,
-        githubRepoFullName: initialGithubRepoFullName,
-        defaultView: initialDefaultView,
-        unscopedPackageName: initialUnscopedPackageName,
-        allowPrPreviews: initialAllowPrPreviews,
-      })
-      setWebsiteError(null)
-    }
-  }, [
-    isDialogOpen,
-    initialDescription,
-    initialWebsite,
-    initialLicense,
-    initialVisibility,
-    initialDefaultView,
-    initialUnscopedPackageName,
-  ])
-
-  useEffect(() => {
-    if (formData.website && !isValidUrl(formData.website)) {
-      setWebsiteError("Please enter a valid URL (e.g., https://tscircuit.com)")
-    } else {
-      setWebsiteError(null)
-    }
-  }, [formData.website])
-
-  const hasLicenseChanged = useMemo(
-    () => formData.license !== initialLicense,
-    [formData.license, initialLicense],
-  )
-
-  const hasVisibilityChanged = useMemo(
-    () => formData.visibility !== initialVisibility,
-    [formData.visibility, initialVisibility],
-  )
-
-  const hasDefaultViewChanged = useMemo(
-    () => formData.defaultView !== initialDefaultView,
-    [formData.defaultView, initialDefaultView],
-  )
-
-  const hasAllowPrPreviewsChanged = useMemo(
-    () => formData.allowPrPreviews !== initialAllowPrPreviews,
-    [formData.allowPrPreviews, initialAllowPrPreviews],
-  )
-
-  const hasChanges = useMemo(
-    () =>
-      formData.description !== initialDescription ||
-      formData.website !== initialWebsite ||
-      formData.license !== initialLicense ||
-      formData.visibility !== initialVisibility ||
-      formData.defaultView !== initialDefaultView ||
-      formData.githubRepoFullName !== initialGithubRepoFullName ||
-      formData.unscopedPackageName !== initialUnscopedPackageName ||
-      formData.allowPrPreviews !== initialAllowPrPreviews,
-    [
-      formData,
-      initialDescription,
-      initialWebsite,
-      initialLicense,
-      initialVisibility,
-      initialDefaultView,
-      initialGithubRepoFullName,
-      initialUnscopedPackageName,
-      initialAllowPrPreviews,
-    ],
-  )
-
-  const isFormValid = useMemo(() => !websiteError, [websiteError])
-
-  return {
-    formData,
-    setFormData,
-    websiteError,
-    hasLicenseChanged,
-    hasVisibilityChanged,
-    hasDefaultViewChanged,
-    hasAllowPrPreviewsChanged,
-    hasChanges,
-    isFormValid,
-  }
-}

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

@@ -1,122 +0,0 @@
-import { PackageFile } from "fake-snippets-api/lib/db/schema"
-import { useQuery, UseQueryOptions } from "react-query"
-import { useAxios } from "./use-axios"
-
-type PackageFileQuery =
-  | {
-      package_file_id: string
-    }
-  | {
-      package_release_id: string
-      file_path: string
-    }
-  | {
-      package_id: string
-      version?: string
-      file_path: string
-    }
-  | {
-      package_name: string
-      version?: string
-      file_path: string
-    }
-  | {
-      package_name_with_version: string
-      file_path: string
-    }
-
-export const usePackageFile = (
-  query: PackageFileQuery | null,
-  opts?: UseQueryOptions,
-) => {
-  const axios = useAxios()
-
-  return useQuery<PackageFile, Error & { status: number }>(
-    ["packageFile", query],
-    async () => {
-      if (!query) return
-
-      const { data } = await axios.get("/package_files/get", {
-        params: query,
-      })
-
-      if (!data.package_file) {
-        throw new Error("Package file not found")
-      }
-
-      return data.package_file
-    },
-    {
-      retry: false,
-      enabled: Boolean(query),
-      refetchOnWindowFocus: false,
-      ...(opts as any),
-    },
-  )
-}
-
-// Convenience hooks for common use cases
-export const usePackageFileById = (packageFileId: string | null) => {
-  return usePackageFile(
-    packageFileId ? { package_file_id: packageFileId } : null,
-  )
-}
-
-export const usePackageFileByPath = (
-  packageNameWithVersion: string | null,
-  filePath: string | null,
-) => {
-  return usePackageFile(
-    packageNameWithVersion && filePath
-      ? {
-          package_name_with_version: packageNameWithVersion,
-          file_path: filePath,
-        }
-      : null,
-  )
-}
-
-export const usePackageFileByRelease = (
-  packageReleaseId: string | null,
-  filePath: string | null,
-) => {
-  return usePackageFile(
-    packageReleaseId && filePath
-      ? {
-          package_release_id: packageReleaseId,
-          file_path: filePath,
-        }
-      : null,
-  )
-}
-
-// Hook to list all files for a package release
-export const usePackageFiles = (packageReleaseId?: string | null) => {
-  const axios = useAxios()
-
-  return useQuery<PackageFile[], Error & { status: number }>(
-    ["packageFiles", packageReleaseId],
-    async () => {
-      if (!packageReleaseId) return []
-
-      try {
-        const { data } = await axios.get("/package_files/list", {
-          params: { package_release_id: packageReleaseId },
-        })
-
-        if (!data.package_files) {
-          return []
-        }
-
-        return data.package_files
-      } catch (error) {
-        throw error
-      }
-    },
-    {
-      enabled: Boolean(packageReleaseId),
-      refetchOnWindowFocus: false,
-      staleTime: 0,
-    },
-  )
-}

package/src/hooks/use-package-release-by-id-or-version.ts

@@ -1,45 +0,0 @@
-import { usePackageRelease } from "./use-package-release"
-import { isUuid } from "@/lib/utils/isUuid"
-
-export const usePackageReleaseByIdOrVersion = (
-  releaseIdOrVersion: string | null,
-  packageName?: string | null,
-  options?: {
-    include_logs?: boolean
-    include_ai_review?: boolean
-    refetchInterval?:
-      | number
-      | false
-      | ((
-          data:
-            | import("fake-snippets-api/lib/db/schema").PackageRelease
-            | undefined,
-        ) => number | false)
-  },
-) => {
-  const isReleaseIdUuid = releaseIdOrVersion
-    ? isUuid(releaseIdOrVersion)
-    : false
-
-  let query: Parameters<typeof usePackageRelease>[0] = null
-
-  if (isReleaseIdUuid) {
-    query = releaseIdOrVersion
-      ? { package_release_id: releaseIdOrVersion }
-      : null
-  } else if (packageName && releaseIdOrVersion) {
-    query = {
-      package_name_with_version: `${packageName}@${releaseIdOrVersion}`,
-    }
-  }
-
-  if (query && options?.include_logs !== undefined) {
-    query.include_logs = options.include_logs
-  }
-
-  if (query && options?.include_ai_review !== undefined) {
-    query.include_ai_review = options.include_ai_review
-  }
-
-  return usePackageRelease(query, { refetchInterval: options?.refetchInterval })
-}

package/src/hooks/use-package-release-images.ts

@@ -1,105 +0,0 @@
-import { useMemo, useCallback } from "react"
-import { useQueries } from "react-query"
-import { useAxios } from "./use-axios"
-import { useParams } from "wouter"
-import { useApiBaseUrl } from "./use-packages-base-api-url"
-
-interface UsePackageReleaseImagesProps {
-  packageReleaseId?: string | null
-  availableFilePaths?: string[] | undefined
-}
-
-interface ViewConfig {
-  id: string
-  label: string
-  backgroundClass: string
-}
-
-const VIEWS: ViewConfig[] = [
-  {
-    id: "3d",
-    label: "3D",
-    backgroundClass: "bg-gray-100",
-  },
-  {
-    id: "pcb",
-    label: "PCB",
-    backgroundClass: "bg-black",
-  },
-  {
-    id: "schematic",
-    label: "Schematic",
-    backgroundClass: "bg-[#F5F1ED]",
-  },
-]
-
-export function usePackageReleaseImages({
-  packageReleaseId,
-}: UsePackageReleaseImagesProps) {
-  const apiurl = useApiBaseUrl()
-  const axios = useAxios()
-  const { author, packageName } = useParams()
-
-  const createQueryFn = useCallback(
-    (viewId: string) => async () => {
-      if (!packageReleaseId || !author || !packageName) return null
-
-      const imageUrl = `${apiurl}/packages/images/${author}/${packageName}/${viewId}.png?package_release_id=${packageReleaseId}`
-
-      try {
-        const response = await axios.head(imageUrl)
-        return response.status === 200 ? imageUrl : null
-      } catch {
-        return null
-      }
-    },
-    [packageReleaseId, author, packageName, apiurl, axios],
-  )
-
-  const queryConfigs = useMemo(
-    () =>
-      VIEWS.map((view) => ({
-        queryKey: [
-          "packageReleaseImage",
-          packageReleaseId,
-          view.id,
-          author,
-          packageName,
-        ],
-        queryFn: createQueryFn(view.id),
-        enabled: Boolean(packageReleaseId && author && packageName),
-        retry: false,
-        refetchOnWindowFocus: false,
-        refetchOnMount: false,
-        refetchOnReconnect: false,
-        staleTime: Infinity,
-        cacheTime: Infinity,
-      })),
-    [packageReleaseId, author, packageName, createQueryFn],
-  )
-
-  const queries = useQueries(queryConfigs)
-
-  const availableViews = useMemo(() => {
-    const result = []
-
-    for (let i = 0; i < VIEWS.length; i++) {
-      const view = VIEWS[i]
-      const query = queries[i]
-
-      if (query.isLoading || query.data) {
-        result.push({
-          id: view.id,
-          label: view.label,
-          imageUrl: query.data || "",
-          isLoading: query.isLoading,
-          backgroundClass: view.backgroundClass,
-        })
-      }
-    }
-
-    return result
-  }, [queries])
-
-  return { availableViews }
-}

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

@@ -1,124 +0,0 @@
-import type { PackageRelease } from "fake-snippets-api/lib/db/schema"
-import { type UseQueryOptions, useQuery } from "react-query"
-import { useAxios } from "./use-axios"
-
-type PackageReleaseQuery = (
-  | {
-      package_release_id: string
-    }
-  | {
-      package_name_with_version: string
-    }
-  | {
-      package_name: string
-      is_latest: boolean
-    }
-  | {
-      package_id: string
-      is_latest: boolean
-    }
-) & {
-  include_logs?: boolean | null | undefined
-  include_ai_review?: boolean | null | undefined
-}
-
-export const usePackageRelease = (
-  query: PackageReleaseQuery | null,
-  options?: {
-    refetchInterval?:
-      | number
-      | false
-      | ((data: PackageRelease | undefined) => number | false)
-  },
-) => {
-  const axios = useAxios()
-
-  return useQuery<PackageRelease, Error & { status: number }>(
-    ["packageRelease", query],
-    async () => {
-      if (!query) return
-
-      const { data } = await axios.post("/package_releases/get", query, {
-        params: {
-          include_logs: Boolean(query.include_logs),
-          include_ai_review: Boolean(query.include_ai_review),
-        },
-      })
-
-      if (!data.package_release) {
-        throw new Error("Package release not found")
-      }
-
-      return data.package_release
-    },
-    {
-      retry: false,
-      enabled: Boolean(query),
-      refetchInterval: options?.refetchInterval,
-      refetchOnWindowFocus: false,
-    },
-  )
-}
-
-// Convenience hooks for common use cases
-export const usePackageReleaseById = (packageReleaseId?: string | null) => {
-  return usePackageRelease(
-    packageReleaseId ? { package_release_id: packageReleaseId } : null,
-  )
-}
-
-export const usePackageReleaseByNameAndVersion = (
-  packageNameWithVersion: string | null,
-) => {
-  return usePackageRelease(
-    packageNameWithVersion
-      ? { package_name_with_version: packageNameWithVersion }
-      : null,
-  )
-}
-
-export const useLatestPackageRelease = (
-  packageId?: string | null,
-  packageName?: string | null,
-) => {
-  // Prioritize packageName if both are provided
-  const query = packageName
-    ? { package_name: packageName, is_latest: true }
-    : packageId
-      ? { package_id: packageId, is_latest: true }
-      : null
-
-  return usePackageRelease(query)
-}
-
-export const usePackageReleasesByPackageId = (packageId: string | null) => {
-  const axios = useAxios()
-
-  return useQuery<PackageRelease[], Error & { status: number }>(
-    ["packageReleases", packageId],
-    async () => {
-      if (!packageId) {
-        throw new Error("package_id is required")
-      }
-
-      const { data } = await axios.post<{ package_releases: PackageRelease[] }>(
-        "/package_releases/list",
-        {
-          package_id: packageId,
-        },
-      )
-
-      if (!data.package_releases) {
-        return []
-      }
-
-      return data.package_releases
-    },
-    {
-      enabled: Boolean(packageId),
-      retry: false,
-      refetchOnWindowFocus: false,
-      staleTime: 0,
-    },
-  )
-}

package/src/hooks/use-package-stars.ts

@@ -1,163 +0,0 @@
-import { useMutation, useQuery, useQueryClient } from "react-query"
-import { useAxios } from "./use-axios"
-import { usePackageByName } from "./use-package-by-package-name"
-import { usePackageById } from "./use-package-by-package-id"
-
-type PackageStarQuery = { package_id: string } | { name: string }
-
-interface PackageStarResponse {
-  is_starred: boolean
-  star_count: number
-}
-
-export const usePackageStars = (query: PackageStarQuery | null) => {
-  const packageName = query && "name" in query ? query.name : null
-  const packageId = query && "package_id" in query ? query.package_id : null
-  const packageQuery = packageName
-    ? usePackageByName(packageName)
-    : usePackageById(packageId)
-
-  return useQuery<PackageStarResponse, Error & { status: number }>(
-    ["packageStars", query],
-    async () => {
-      if (!query) {
-        throw new Error("Query is required")
-      }
-      return {
-        is_starred: packageQuery.data?.is_starred ?? false,
-        star_count: packageQuery.data?.star_count ?? 0,
-      }
-    },
-    {
-      retry: false,
-      enabled: Boolean(query) && packageQuery.isSuccess,
-    },
-  )
-}
-
-export const usePackageStarMutation = (query: PackageStarQuery) => {
-  const axios = useAxios()
-  const queryClient = useQueryClient()
-
-  const addStar = useMutation<
-    any,
-    Error,
-    void,
-    { previousStars?: PackageStarResponse }
-  >(
-    async () => {
-      const { data } = await axios.post("/packages/add_star", query)
-      return data
-    },
-    {
-      onMutate: async () => {
-        await queryClient.cancelQueries(["packageStars", query])
-        const previousStars = queryClient.getQueryData<PackageStarResponse>([
-          "packageStars",
-          query,
-        ])
-        const optimistic: PackageStarResponse = {
-          is_starred: true,
-          star_count: (previousStars?.star_count ?? 0) + 1,
-        }
-        queryClient.setQueryData(["packageStars", query], optimistic)
-        return { previousStars }
-      },
-      onError: (_error, _vars, context) => {
-        if (context?.previousStars) {
-          queryClient.setQueryData(
-            ["packageStars", query],
-            context.previousStars,
-          )
-        }
-      },
-      onSettled: () => {
-        queryClient.invalidateQueries(["packageStars", query])
-      },
-    },
-  )
-
-  const removeStar = useMutation<
-    any,
-    Error,
-    void,
-    { previousStars?: PackageStarResponse }
-  >(
-    async () => {
-      const { data } = await axios.post("/packages/remove_star", query)
-      return data
-    },
-    {
-      onMutate: async () => {
-        await queryClient.cancelQueries(["packageStars", query])
-        const previousStars = queryClient.getQueryData<PackageStarResponse>([
-          "packageStars",
-          query,
-        ])
-        const optimistic: PackageStarResponse = {
-          is_starred: false,
-          star_count: Math.max(0, (previousStars?.star_count ?? 1) - 1),
-        }
-        queryClient.setQueryData(["packageStars", query], optimistic)
-        return { previousStars }
-      },
-      onError: (_error, _vars, context) => {
-        if (context?.previousStars) {
-          queryClient.setQueryData(
-            ["packageStars", query],
-            context.previousStars,
-          )
-        }
-      },
-      onSettled: () => {
-        queryClient.invalidateQueries(["packageStars", query])
-      },
-    },
-  )
-
-  return {
-    addStar,
-    removeStar,
-  }
-}
-
-// Convenience hooks for common use cases
-export const usePackageStarsById = (packageId: string | null) => {
-  return usePackageStars(packageId ? { package_id: packageId } : null)
-}
-
-export const usePackageStarsByName = (packageName: string | null) => {
-  return usePackageStars(packageName ? { name: packageName } : null)
-}
-
-export const usePackageStarMutationById = (packageId: string) => {
-  return usePackageStarMutation({ package_id: packageId })
-}
-
-export const usePackageStarMutationByName = (packageName: string) => {
-  return usePackageStarMutation({ name: packageName })
-}
-
-// High-level hook that exposes current star state and a single toggle action
-export const usePackageStarring = (query: PackageStarQuery | null) => {
-  const starsQuery = usePackageStars(query)
-  const mutations = usePackageStarMutation(query ?? { name: "" })
-
-  const toggleStar = async () => {
-    if (!query) return
-    const currentlyStarred = starsQuery.data?.is_starred ?? false
-    if (currentlyStarred) await mutations.removeStar.mutateAsync()
-    else await mutations.addStar.mutateAsync()
-  }
-
-  return {
-    isStarred: starsQuery.data?.is_starred ?? false,
-    starCount: starsQuery.data?.star_count ?? 0,
-    isPending: mutations.addStar.isLoading || mutations.removeStar.isLoading,
-    toggleStar,
-  }
-}
-
-export const usePackageStarringByName = (packageName: string | null) => {
-  return usePackageStarring(packageName ? { name: packageName } : null)
-}