@tscircuit/fake-snippets 0.0.121 → 0.0.123

package/src/components/ui/tree-view.tsx

@@ -1,563 +0,0 @@
-import React from "react"
-import * as AccordionPrimitive from "@radix-ui/react-accordion"
-import { ChevronRight } from "lucide-react"
-import { cva } from "class-variance-authority"
-import { cn } from "@/lib/utils"
-import { Input } from "@/components/ui/input"
-
-const treeVariants = cva(
-  "group hover:before:opacity-100 before:absolute before:rounded-lg before:left-0 before:w-full before:opacity-0 before:bg-slate-100/70 before:h-[2rem] before:-z-10' dark:before:bg-slate-800/70",
-)
-
-const selectedTreeVariants = cva(
-  "before:opacity-100 before:bg-slate-100/70 text-accent-foreground dark:before:bg-slate-800/70",
-)
-
-const dragOverVariants = cva(
-  "before:opacity-100 before:bg-slate-900/20 text-primary-foreground' dark:before:bg-slate-50/20",
-)
-
-interface TreeDataItem {
-  id: string
-  name: React.ReactNode
-  icon?: any
-  selectedIcon?: any
-  openIcon?: any
-  children?: TreeDataItem[]
-  actions?: React.ReactNode
-  onClick?: () => void
-  draggable?: boolean
-  droppable?: boolean
-  isRenaming?: boolean
-  onRename?: (newName: string) => void
-  onCancelRename?: () => void
-}
-
-type TreeProps = React.HTMLAttributes<HTMLDivElement> & {
-  data: TreeDataItem[] | TreeDataItem
-  initialSelectedItemId?: string
-  onSelectChange?: (item: TreeDataItem | undefined) => void
-  expandAll?: boolean
-  defaultNodeIcon?: any
-  defaultLeafIcon?: any
-  selectedItemId: string
-  setSelectedItemId: (id: string | undefined) => void
-  onDocumentDrag?: (sourceItem: TreeDataItem, targetItem: TreeDataItem) => void
-}
-
-const TreeView = React.forwardRef<HTMLDivElement, TreeProps>(
-  (
-    {
-      data,
-      initialSelectedItemId,
-      onSelectChange,
-      expandAll,
-      defaultLeafIcon,
-      defaultNodeIcon,
-      className,
-      onDocumentDrag,
-      selectedItemId,
-      setSelectedItemId,
-      ...props
-    },
-    ref,
-  ) => {
-    React.useEffect(() => {
-      setSelectedItemId(initialSelectedItemId)
-    }, [initialSelectedItemId])
-
-    const [draggedItem, setDraggedItem] = React.useState<TreeDataItem | null>(
-      null,
-    )
-
-    const handleSelectChange = React.useCallback(
-      (item: TreeDataItem | undefined) => {
-        setSelectedItemId(item?.id)
-        if (onSelectChange) {
-          onSelectChange(item)
-        }
-      },
-      [onSelectChange],
-    )
-
-    const handleDragStart = React.useCallback((item: TreeDataItem) => {
-      setDraggedItem(item)
-    }, [])
-
-    const handleDrop = React.useCallback(
-      (targetItem: TreeDataItem) => {
-        if (draggedItem && onDocumentDrag && draggedItem.id !== targetItem.id) {
-          onDocumentDrag(draggedItem, targetItem)
-        }
-        setDraggedItem(null)
-      },
-      [draggedItem, onDocumentDrag],
-    )
-
-    const expandedItemIds = React.useMemo(() => {
-      if (!initialSelectedItemId) {
-        return [] as string[]
-      }
-
-      const ids: string[] = []
-
-      function walkTreeItems(
-        items: TreeDataItem[] | TreeDataItem,
-        targetId: string,
-      ) {
-        if (items instanceof Array) {
-          for (let i = 0; i < items.length; i++) {
-            ids.push(items[i]!.id)
-            if (walkTreeItems(items[i]!, targetId) && !expandAll) {
-              return true
-            }
-            if (!expandAll) ids.pop()
-          }
-        } else if (!expandAll && items.id === targetId) {
-          return true
-        } else if (items.children) {
-          return walkTreeItems(items.children, targetId)
-        }
-      }
-
-      walkTreeItems(data, initialSelectedItemId)
-      return ids
-    }, [data, expandAll, initialSelectedItemId])
-
-    return (
-      <div className={cn("overflow-hidden relative p-2", className)}>
-        <TreeItem
-          data={data}
-          ref={ref}
-          setSelectedItemId={setSelectedItemId}
-          selectedItemId={selectedItemId}
-          handleSelectChange={handleSelectChange}
-          expandedItemIds={expandedItemIds}
-          defaultLeafIcon={defaultLeafIcon}
-          defaultNodeIcon={defaultNodeIcon}
-          handleDragStart={handleDragStart}
-          handleDrop={handleDrop}
-          draggedItem={draggedItem}
-          {...props}
-        />
-        <div
-          className="w-full h-[48px]"
-          onDrop={(e) => {
-            handleDrop({ id: "", name: "parent_div" })
-          }}
-        ></div>
-      </div>
-    )
-  },
-)
-TreeView.displayName = "TreeView"
-
-type TreeItemProps = TreeProps & {
-  selectedItemId?: string
-  handleSelectChange: (item: TreeDataItem | undefined) => void
-  expandedItemIds: string[]
-  defaultNodeIcon?: any
-  defaultLeafIcon?: any
-  handleDragStart?: (item: TreeDataItem) => void
-  handleDrop?: (item: TreeDataItem) => void
-  setSelectedItemId: (id: string | undefined) => void
-  draggedItem: TreeDataItem | null
-}
-
-const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
-  (
-    {
-      className,
-      data,
-      selectedItemId,
-      handleSelectChange,
-      setSelectedItemId,
-      expandedItemIds,
-      defaultNodeIcon,
-      defaultLeafIcon,
-      handleDragStart,
-      handleDrop,
-      draggedItem,
-      ...props
-    },
-    ref,
-  ) => {
-    if (!(data instanceof Array)) {
-      data = [data]
-    }
-
-    const sortedData = [...data].sort((a, b) => {
-      const aIsFolder = !!a.children
-      const bIsFolder = !!b.children
-
-      if (aIsFolder && !bIsFolder) return -1
-      if (!aIsFolder && bIsFolder) return 1
-      return 0
-    })
-
-    return (
-      <div ref={ref} role="tree" className={className} {...props}>
-        <ul>
-          {sortedData.map((item) => (
-            <li key={item.id}>
-              {item.children ? (
-                <TreeNode
-                  item={item}
-                  setSelectedItemId={setSelectedItemId}
-                  selectedItemId={selectedItemId}
-                  expandedItemIds={expandedItemIds}
-                  handleSelectChange={handleSelectChange}
-                  defaultNodeIcon={defaultNodeIcon}
-                  defaultLeafIcon={defaultLeafIcon}
-                  handleDragStart={handleDragStart}
-                  handleDrop={handleDrop}
-                  draggedItem={draggedItem}
-                />
-              ) : (
-                <TreeLeaf
-                  item={item}
-                  selectedItemId={selectedItemId}
-                  handleSelectChange={handleSelectChange}
-                  defaultLeafIcon={defaultLeafIcon}
-                  handleDragStart={handleDragStart}
-                  handleDrop={handleDrop}
-                  draggedItem={draggedItem}
-                />
-              )}
-            </li>
-          ))}
-        </ul>
-      </div>
-    )
-  },
-)
-TreeItem.displayName = "TreeItem"
-
-const TreeNode = ({
-  item,
-  handleSelectChange,
-  expandedItemIds,
-  selectedItemId,
-  defaultNodeIcon,
-  defaultLeafIcon,
-  handleDragStart,
-  setSelectedItemId,
-  handleDrop,
-  draggedItem,
-}: {
-  item: TreeDataItem
-  handleSelectChange: (item: TreeDataItem | undefined) => void
-  expandedItemIds: string[]
-  selectedItemId: string
-  setSelectedItemId: (id: string | undefined) => void
-  defaultNodeIcon?: any
-  defaultLeafIcon?: any
-  handleDragStart?: (item: TreeDataItem) => void
-  handleDrop?: (item: TreeDataItem) => void
-  draggedItem: TreeDataItem | null
-}) => {
-  const [value, setValue] = React.useState(
-    expandedItemIds.includes(item.id) ? [item.id] : [],
-  )
-  const [isDragOver, setIsDragOver] = React.useState(false)
-
-  const onDragStart = (e: React.DragEvent) => {
-    if (!item.draggable) {
-      e.preventDefault()
-      return
-    }
-    e.dataTransfer.setData("text/plain", item.id)
-    handleDragStart?.(item)
-  }
-
-  const onDragOver = (e: React.DragEvent) => {
-    if (item.droppable !== false && draggedItem && draggedItem.id !== item.id) {
-      e.preventDefault()
-      setIsDragOver(true)
-    }
-  }
-
-  const onDragLeave = () => {
-    setIsDragOver(false)
-  }
-
-  const onDrop = (e: React.DragEvent) => {
-    e.preventDefault()
-    setIsDragOver(false)
-    handleDrop?.(item)
-  }
-
-  return (
-    <AccordionPrimitive.Root
-      type="multiple"
-      value={value}
-      onValueChange={(s) => setValue(s)}
-    >
-      <AccordionPrimitive.Item value={item.id}>
-        <AccordionTrigger
-          className={cn(
-            treeVariants(),
-            selectedItemId === item.id && selectedTreeVariants(),
-            isDragOver && dragOverVariants(),
-          )}
-          onClick={() => {
-            handleSelectChange(item)
-            item.onClick?.()
-          }}
-          draggable={!!item.draggable}
-          onDragStart={onDragStart}
-          onDragOver={onDragOver}
-          onDragLeave={onDragLeave}
-          onDrop={onDrop}
-        >
-          <TreeIcon
-            item={item}
-            isSelected={selectedItemId === item.id}
-            isOpen={value.includes(item.id)}
-            default={defaultNodeIcon}
-          />
-          <span className="text-sm truncate">{item.name}</span>
-          <div
-            className="flex items-center"
-            onClick={(e) => e.stopPropagation()}
-          >
-            <TreeActions isSelected={true}>{item.actions}</TreeActions>
-          </div>
-        </AccordionTrigger>
-        <AccordionContent className="ml-4 pl-1 border-l">
-          <TreeItem
-            data={item.children ? item.children : item}
-            selectedItemId={selectedItemId}
-            setSelectedItemId={setSelectedItemId}
-            handleSelectChange={handleSelectChange}
-            expandedItemIds={expandedItemIds}
-            defaultLeafIcon={defaultLeafIcon}
-            defaultNodeIcon={defaultNodeIcon}
-            handleDragStart={handleDragStart}
-            handleDrop={handleDrop}
-            draggedItem={draggedItem}
-          />
-        </AccordionContent>
-      </AccordionPrimitive.Item>
-    </AccordionPrimitive.Root>
-  )
-}
-
-const TreeLeaf = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement> & {
-    item: TreeDataItem
-    selectedItemId?: string
-    handleSelectChange: (item: TreeDataItem | undefined) => void
-    defaultLeafIcon?: any
-    handleDragStart?: (item: TreeDataItem) => void
-    handleDrop?: (item: TreeDataItem) => void
-    draggedItem: TreeDataItem | null
-  }
->(
-  (
-    {
-      className,
-      item,
-      selectedItemId,
-      handleSelectChange,
-      defaultLeafIcon,
-      handleDragStart,
-      handleDrop,
-      draggedItem,
-      ...props
-    },
-    ref,
-  ) => {
-    const [isDragOver, setIsDragOver] = React.useState(false)
-
-    const onDragStart = (e: React.DragEvent) => {
-      if (!item.draggable) {
-        e.preventDefault()
-        return
-      }
-      e.dataTransfer.setData("text/plain", item.id)
-      handleDragStart?.(item)
-    }
-
-    const onDragOver = (e: React.DragEvent) => {
-      if (
-        item.droppable !== false &&
-        draggedItem &&
-        draggedItem.id !== item.id
-      ) {
-        e.preventDefault()
-        setIsDragOver(true)
-      }
-    }
-
-    const onDragLeave = () => {
-      setIsDragOver(false)
-    }
-
-    const onDrop = (e: React.DragEvent) => {
-      e.preventDefault()
-      setIsDragOver(false)
-      handleDrop?.(item)
-    }
-
-    return (
-      <div
-        ref={ref}
-        className={cn(
-          "ml-[2px] flex text-left items-center py-2 cursor-pointer before:right-1",
-          treeVariants(),
-          className,
-          selectedItemId === item.id && selectedTreeVariants(),
-          isDragOver && dragOverVariants(),
-        )}
-        onClick={() => {
-          handleSelectChange(item)
-          item.onClick?.()
-        }}
-        draggable={!!item.draggable}
-        onDragStart={onDragStart}
-        onDragOver={onDragOver}
-        onDragLeave={onDragLeave}
-        onDrop={onDrop}
-        {...props}
-      >
-        <TreeIcon
-          item={item}
-          isSelected={selectedItemId === item.id}
-          default={defaultLeafIcon}
-        />
-        {item.isRenaming ? (
-          <Input
-            style={{
-              zIndex: 50,
-            }}
-            defaultValue={item.name as string}
-            onKeyDown={(e) => {
-              if (e.key === "Enter") {
-                e.preventDefault()
-                const value = e.currentTarget.value.trim()
-                if (value && value !== item.name) {
-                  item.onRename?.(value)
-                } else {
-                  item.onCancelRename?.()
-                }
-              } else if (e.key === "Escape") {
-                e.preventDefault()
-                item.onCancelRename?.()
-              }
-            }}
-            spellCheck={false}
-            autoComplete="off"
-            onBlur={(e) => {
-              const value = e.currentTarget.value.trim()
-              if (value && value !== item.name) {
-                item.onRename?.(value)
-              } else {
-                item.onCancelRename?.()
-              }
-            }}
-            autoFocus
-            onClick={(e) => e.stopPropagation()}
-            className="h-6 px-2 py-0 text-sm flex-1 mr-8 bg-white border border-blue-500 rounded-sm focus:outline-none focus:ring-1 focus:ring-blue-500 focus:border-blue-500 shadow-sm"
-            onFocus={(e) => {
-              e.currentTarget.select()
-              // Select filename without extension
-              const filename = e.currentTarget.value
-              const lastDotIndex = filename.lastIndexOf(".")
-              if (lastDotIndex > 0) {
-                e.currentTarget.setSelectionRange(0, lastDotIndex)
-              }
-            }}
-          />
-        ) : (
-          <span className="text-sm truncate">{item.name}</span>
-        )}
-        <div className="flex items-center" onClick={(e) => e.stopPropagation()}>
-          <TreeActions isSelected={true}>{item.actions}</TreeActions>
-        </div>
-      </div>
-    )
-  },
-)
-TreeLeaf.displayName = "TreeLeaf"
-
-const AccordionTrigger = React.forwardRef<
-  React.ElementRef<typeof AccordionPrimitive.Trigger>,
-  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>
->(({ className, children, ...props }, ref) => (
-  <AccordionPrimitive.Header>
-    <AccordionPrimitive.Trigger
-      ref={ref}
-      className={cn(
-        "flex flex-1 w-full items-center py-2 transition-all first:[&[data-state=open]>svg]:rotate-90",
-        className,
-      )}
-      {...props}
-    >
-      <ChevronRight className="h-4 w-4 shrink-0 transition-transform duration-200 text-slate-900/50 mr-1 dark:text-slate-50/50" />
-      {children}
-    </AccordionPrimitive.Trigger>
-  </AccordionPrimitive.Header>
-))
-AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName
-
-const AccordionContent = React.forwardRef<
-  React.ElementRef<typeof AccordionPrimitive.Content>,
-  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>
->(({ className, children, ...props }, ref) => (
-  <AccordionPrimitive.Content
-    ref={ref}
-    className={cn(
-      "overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down",
-      className,
-    )}
-    {...props}
-  >
-    <div className="pb-1 pt-0">{children}</div>
-  </AccordionPrimitive.Content>
-))
-AccordionContent.displayName = AccordionPrimitive.Content.displayName
-
-const TreeIcon = ({
-  item,
-  isOpen,
-  isSelected,
-  default: defaultIcon,
-}: {
-  item: TreeDataItem
-  isOpen?: boolean
-  isSelected?: boolean
-  default?: any
-}) => {
-  let Icon = defaultIcon
-  if (isSelected && item.selectedIcon) {
-    Icon = item.selectedIcon
-  } else if (isOpen && item.openIcon) {
-    Icon = item.openIcon
-  } else if (item.icon) {
-    Icon = item.icon
-  }
-  return Icon ? <Icon className="h-4 w-4 shrink-0 mr-2" /> : <></>
-}
-
-const TreeActions = ({
-  children,
-  isSelected,
-}: {
-  children: React.ReactNode
-  isSelected: boolean
-}) => {
-  return (
-    <div
-      className={cn(
-        isSelected ? "block" : "hidden",
-        "absolute right-3 group-hover:block",
-      )}
-    >
-      {children}
-    </div>
-  )
-}
-
-export { TreeView, type TreeDataItem }

package/src/entry-server.tsx

@@ -1,12 +0,0 @@
-import React from "react"
-import ReactDOMServer from "react-dom/server"
-import App from "./App"
-
-export function render() {
-  const html = ReactDOMServer.renderToString(
-    <React.StrictMode>
-      <App />
-    </React.StrictMode>,
-  )
-  return { html }
-}

package/src/hooks/use-account-balance.ts

@@ -1,25 +0,0 @@
-import { useQuery } from "react-query"
-import { useAxios } from "./use-axios"
-import { useGlobalStore } from "./use-global-store"
-
-interface AccountBalance {
-  monthly_ai_budget_used_usd: number
-}
-
-export const useAccountBalance = () => {
-  const axios = useAxios()
-  const isLoggedIn = useGlobalStore((s) => Boolean(s.session))
-
-  return useQuery<AccountBalance, Error>(
-    "accountBalance",
-    async () => {
-      const { data } = await axios.get("/accounts/get_account_balance")
-      return data.account_balance
-    },
-    {
-      // refetchInterval: 60000, // Refetch every minute
-      enabled: isLoggedIn,
-      refetchOnWindowFocus: false,
-    },
-  )
-}

package/src/hooks/use-add-org-member-mutation.ts

@@ -1,51 +0,0 @@
-import { useMutation, useQueryClient } from "react-query"
-import { useAxios } from "@/hooks/use-axios"
-import { useGlobalStore } from "@/hooks/use-global-store"
-
-export const useAddOrgMemberMutation = ({
-  onSuccess,
-  onError,
-}: { onSuccess?: () => void; onError?: (error: any) => void } = {}) => {
-  const axios = useAxios()
-  const session = useGlobalStore((s) => s.session)
-  const queryClient = useQueryClient()
-
-  return useMutation(
-    ["addOrgMember"],
-    async ({
-      orgId,
-      accountId,
-      githubUsername,
-    }: {
-      orgId: string
-      accountId?: string
-      githubUsername?: string
-    }) => {
-      if (!session) throw new Error("No session")
-
-      const payload: any = {
-        org_id: orgId,
-      }
-
-      if (accountId) {
-        payload.account_id = accountId
-      }
-
-      if (githubUsername) {
-        payload.github_username = githubUsername
-      }
-
-      await axios.post("/orgs/add_member", payload)
-    },
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries(["orgs", "members"])
-        onSuccess?.()
-      },
-      onError: (error: any) => {
-        console.error("Error adding organization member:", error)
-        onError?.(error)
-      },
-    },
-  )
-}

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

@@ -1,35 +0,0 @@
-import { Anthropic } from "@anthropic-ai/sdk"
-import { useMemo } from "react"
-import { useGlobalStore } from "./use-global-store"
-
-export const useAiApi = ({
-  streaming = false,
-}: { streaming?: boolean } = {}) => {
-  const sessionToken = useGlobalStore((state) => state.session?.token)
-  const anthropic = useMemo(() => {
-    if (import.meta.env.VITE_USE_DIRECT_AI_REQUESTS === "true") {
-      console.warn(
-        "Direct AI requests are enabled. Do not use this in production.",
-      )
-    }
-    return new Anthropic(
-      import.meta.env.VITE_USE_DIRECT_AI_REQUESTS === "true"
-        ? {
-            apiKey: import.meta.env.VITE_ANTHROPIC_API_KEY,
-            dangerouslyAllowBrowser: true,
-          }
-        : {
-            apiKey: "{REPLACE_ON_SERVER}",
-            baseURL: import.meta.env.VITE_SNIPPETS_API_URL
-              ? `${import.meta.env.VITE_SNIPPETS_API_URL}/anthropic`
-              : "/api/anthropic",
-            defaultHeaders: {
-              Authorization: `Bearer ${sessionToken}`,
-            },
-            dangerouslyAllowBrowser: true,
-          },
-    )
-  }, [])
-
-  return anthropic
-}