@tscircuit/fake-snippets 0.0.120 → 0.0.122

package/fake-snippets-api/routes/api/snippets/download.ts

@@ -1,162 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "none",
-  queryParams: z.object({
-    jsdelivr_resolve: z
-      .enum(["true", "false"])
-      .optional()
-      .transform((v) => v === "true"),
-    jsdelivr_path: z.string(),
-  }),
-  jsonResponse: z.any(),
-})(async (req, ctx) => {
-  const { jsdelivr_path, jsdelivr_resolve } = req.query
-
-  // Parse the file path
-  const [owner, packageWithVersion, ...rest] = jsdelivr_path.split("/")
-  const [packageName, version] = packageWithVersion.split("@")
-  const fileName = rest.join("/")
-
-  // Find the snippet
-  const _package = ctx.db.packages.find(
-    (s) => s.owner_github_username === owner && s.unscoped_name === packageName,
-  )
-
-  const packageRelease = ctx.db.packageReleases.find(
-    (p) => p.package_id === _package?.package_id,
-  )
-
-  const packageFiles = ctx.db.packageFiles.filter(
-    (p) => p.package_release_id === packageRelease?.package_release_id,
-  )
-
-  if (!_package) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: "Snippet not found",
-    })
-  }
-
-  if (!fileName && !jsdelivr_resolve) {
-    return new Response(
-      JSON.stringify({
-        tags: {
-          latest: "0.0.1",
-        },
-        versions: ["0.0.1"],
-      }),
-      {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      },
-    )
-  } else if (!fileName && jsdelivr_resolve) {
-    return new Response(
-      JSON.stringify({
-        version: "0.0.1",
-      }),
-      {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      },
-    )
-  }
-
-  // If no fileName is provided, return the directory listing
-  if (!fileName || fileName === "flat") {
-    const files = [
-      {
-        type: "file",
-        name: "index.ts",
-        hash: "placeholder_hash",
-        time: packageRelease?.created_at,
-        size: packageFiles.find((f) => f.file_path === "index.ts")?.content_text
-          ?.length,
-      },
-      {
-        type: "file",
-        name: "index.d.ts",
-        hash: "placeholder_hash",
-        time: packageRelease?.created_at,
-        size: packageFiles.find((f) => f.file_path === "index.d.ts")
-          ?.content_text?.length,
-      },
-      {
-        type: "file",
-        name: "package.json",
-        hash: "placeholder_hash",
-        time: packageRelease?.created_at,
-        size: JSON.stringify({
-          name: `@tsci/${owner}.${packageName}`,
-          version: version || "0.0.1",
-          main: "index.ts",
-          types: "index.d.ts",
-        }).length,
-      },
-    ]
-
-    const response = {
-      default: "/index.ts",
-      files:
-        fileName === "flat"
-          ? files.map((f) => ({
-              name: `/${f.name}`,
-              hash: f.hash,
-              time: f.time,
-              size: f.size,
-            }))
-          : [
-              {
-                type: "directory",
-                name: ".",
-                files: files,
-              },
-            ],
-    }
-
-    return new Response(JSON.stringify(response, null, 2), {
-      status: 200,
-      headers: { "Content-Type": "application/json" },
-    })
-  }
-
-  // Handle file downloads
-  let content: string
-  switch (fileName) {
-    case "index.ts":
-      content =
-        packageFiles.find((f) => f.file_path === "index.tsx")?.content_text ||
-        ""
-      break
-    case "index.d.ts":
-      content =
-        packageFiles.find((f) => f.file_path === "/dist/index.d.ts")
-          ?.content_text || ""
-      break
-    case "package.json":
-      content = JSON.stringify(
-        {
-          name: `@tsci/${owner}.${packageName}`,
-          version: version || "0.0.1",
-          main: "index.ts",
-          types: "index.d.ts",
-        },
-        null,
-        2,
-      )
-      break
-    default:
-      return ctx.error(404, {
-        error_code: "file_not_found",
-        message: "Requested file not found",
-      })
-  }
-
-  return new Response(content, {
-    status: 200,
-    headers: { "Content-Type": "text/plain" },
-  })
-})

package/fake-snippets-api/routes/api/snippets/generate_from_jlcpcb.ts

@@ -1,48 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { snippetSchema } from "fake-snippets-api/lib/db/schema"
-import { fetchEasyEDAComponent, convertRawEasyEdaToTs } from "easyeda"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    jlcpcb_part_number: z.string(),
-  }),
-  jsonResponse: z.object({
-    snippet: snippetSchema,
-  }),
-})(async (req, ctx) => {
-  const { jlcpcb_part_number } = req.jsonBody
-
-  try {
-    // Fetch the EasyEDA component data
-    const rawEasyJson = await fetchEasyEDAComponent(jlcpcb_part_number)
-
-    // Convert to TypeScript React component
-    const tsxComponent = await convertRawEasyEdaToTs(rawEasyJson)
-
-    // Create a new snippet
-    const newSnippet = {
-      name: `${ctx.auth.github_username}/${jlcpcb_part_number}`,
-      unscoped_name: jlcpcb_part_number,
-      owner_name: ctx.auth.github_username,
-      code: tsxComponent,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-      snippet_type: "package",
-      description: `Generated from JLCPCB part number ${jlcpcb_part_number}`,
-    }
-
-    const createdPackage = ctx.db.addSnippet(newSnippet as any)
-
-    return ctx.json({
-      snippet: createdPackage as any,
-    })
-  } catch (error: any) {
-    return ctx.error(500, {
-      error_code: "jlcpcb_generation_failed",
-      message: `Failed to generate package from JLCPCB part: ${error.message}`,
-    })
-  }
-})

package/fake-snippets-api/routes/api/snippets/get.ts

@@ -1,83 +0,0 @@
-import { snippetSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  auth: "optional_session",
-  commonParams: z.object({
-    snippet_id: z.string().optional(),
-    name: z.string().optional(),
-    owner_name: z.string().optional(),
-    unscoped_name: z.string().optional(),
-  }),
-  jsonBody: z.any().optional(),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    snippet: snippetSchema,
-  }),
-})(async (req, ctx) => {
-  const { snippet_id, name, owner_name, unscoped_name } = req.commonParams
-
-  // First try to find by snippet_id
-  if (snippet_id) {
-    const foundSnippet = ctx.db.getSnippetById(snippet_id, ctx.auth)
-    if (foundSnippet) {
-      if (ctx.auth) {
-        foundSnippet.is_starred = ctx.db.hasStarred(
-          ctx.auth.account_id,
-          foundSnippet.snippet_id,
-        )
-      }
-      return ctx.json({
-        ok: true,
-        snippet: foundSnippet,
-      })
-    }
-  }
-
-  // If not found by ID, try to find by other parameters
-  const foundPackage = ctx.db.packages.find((pkg) => {
-    if (!pkg.is_snippet) return false
-    if (name && pkg.name.toLowerCase() !== name.toLowerCase()) return false
-    if (
-      owner_name &&
-      pkg.owner_github_username?.toLowerCase() !== owner_name.toLowerCase()
-    )
-      return false
-    if (
-      unscoped_name &&
-      pkg.unscoped_name.toLowerCase() !== unscoped_name.toLowerCase()
-    )
-      return false
-    return true
-  })
-
-  if (!foundPackage) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: `Snippet not found (searched using ${JSON.stringify(req.commonParams)})`,
-    })
-  }
-
-  // Convert package to snippet format
-  const snippet = ctx.db.getSnippetById(foundPackage.package_id)
-  if (!snippet) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: `Snippet not found (searched using ${JSON.stringify(req.commonParams)})`,
-    })
-  }
-
-  if (ctx.auth) {
-    snippet.is_starred = ctx.db.hasStarred(
-      ctx.auth.account_id,
-      snippet.snippet_id,
-    )
-  }
-
-  return ctx.json({
-    ok: true,
-    snippet,
-  })
-})

package/fake-snippets-api/routes/api/snippets/get_image.ts

@@ -1,65 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import {
-  convertCircuitJsonToSchematicSvg,
-  convertCircuitJsonToPcbSvg,
-} from "circuit-to-svg"
-import { AnyCircuitElement } from "circuit-json"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "none",
-  queryParams: z.object({
-    snippetId: z.string(),
-    image_of: z.enum(["schematic", "pcb"]),
-    format: z.enum(["svg"]),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    svg: z.string(),
-  }),
-})(async (req, ctx) => {
-  const { snippetId, image_of, format } = req.query
-
-  const snippet = ctx.db.getSnippetById(snippetId)
-
-  // check if the snippet exists
-  if (!snippet) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: "Snippet not found",
-    })
-  }
-
-  // Check if the format is valid
-  if (format !== "svg") {
-    return ctx.error(400, {
-      error_code: "invalid_format",
-      message: "Format must be 'svg'",
-    })
-  }
-
-  if (image_of === "schematic") {
-    const circuitJson = snippet.circuit_json as AnyCircuitElement[]
-    const svg = convertCircuitJsonToSchematicSvg(circuitJson)
-    return ctx.json({
-      ok: true,
-      svg,
-    })
-  }
-
-  if (image_of === "pcb") {
-    const svg = convertCircuitJsonToPcbSvg(
-      snippet.circuit_json as AnyCircuitElement[],
-    )
-    return ctx.json({
-      ok: true,
-      svg,
-    })
-  }
-
-  return ctx.error(400, {
-    error_code: "INVALID_REQUEST_TYPE",
-    message: "Request type must be either 'schematic' or 'pcb'",
-  })
-})

package/fake-snippets-api/routes/api/snippets/images/[author]/[snippet_name]/[typeFormat].ts

@@ -1,80 +0,0 @@
-import { AnyCircuitElement } from "circuit-json"
-import {
-  convertCircuitJsonToAssemblySvg,
-  convertCircuitJsonToPcbSvg,
-  convertCircuitJsonToSchematicSvg,
-} from "circuit-to-svg"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "none",
-  routeParams: z.object({
-    author: z.string(),
-    snippet_name: z.string(),
-    typeFormat: z.string(),
-  }),
-  rawResponse: true,
-})(async (req, ctx) => {
-  const { author, snippet_name, typeFormat } = req.routeParams
-
-  // Get the snippet
-  const name = author + "/" + snippet_name
-  const snippet = ctx.db.getSnippetByAuthorAndName(author, name)
-
-  // If snippet is not found, return 404
-  if (!snippet) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: "Snippet not found",
-    })
-  }
-
-  // Check if the format is valid
-  const format = typeFormat.split(".")[1]
-  if (format !== "svg") {
-    return ctx.error(400, {
-      error_code: "invalid_format",
-      message: "Format must be 'svg'",
-    })
-  }
-
-  // Check if the type is valid
-  const type = typeFormat.split(".")[0]
-  const typesValid = ["schematic", "pcb", "assembly"]
-  if (!typesValid.includes(type)) {
-    return ctx.error(400, {
-      error_code: "invalid_type",
-      message: `Type must be '${typesValid.join("' or '")}'`,
-    })
-  }
-
-  // Convert circuit json to svg
-  let svg: string
-  if (type === "schematic") {
-    svg = convertCircuitJsonToSchematicSvg(
-      snippet.circuit_json as AnyCircuitElement[],
-    )
-  } else if (type === "pcb") {
-    svg = convertCircuitJsonToPcbSvg(
-      snippet.circuit_json as AnyCircuitElement[],
-    )
-  } else if (type === "assembly") {
-    svg = convertCircuitJsonToAssemblySvg(
-      snippet.circuit_json as AnyCircuitElement[],
-    )
-  } else {
-    return ctx.error(500, {
-      error_code: "unknown_error",
-      message: "Unknown error",
-    })
-  }
-
-  return new Response(svg, {
-    headers: {
-      "Content-Type": "image/svg+xml",
-      "Cache-Control": "public, max-age=31536000",
-    },
-  })
-})

package/fake-snippets-api/routes/api/snippets/list.ts

@@ -1,151 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { snippetSchema, type Account } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  auth: "optional_session",
-  commonParams: z.object({
-    owner_name: z.string().optional(),
-    unscoped_name: z.string().optional(),
-    starred_by: z.string().optional(),
-  }),
-  jsonBody: z.any().optional(),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    snippets: z.array(snippetSchema),
-  }),
-})(async (req, ctx) => {
-  const { owner_name, unscoped_name, starred_by } = req.commonParams
-  let starredByAccount: Account | null = null
-  // Get all packages that are snippets
-  let packages = ctx.db.packages.filter((pkg) => pkg.is_snippet === true)
-
-  // Filter by owner_name if provided
-  if (owner_name) {
-    packages = packages.filter(
-      (pkg) =>
-        pkg.owner_github_username?.toLowerCase() === owner_name.toLowerCase(),
-    )
-  }
-
-  // Filter by unscoped_name if provided
-  if (unscoped_name) {
-    packages = packages.filter(
-      (pkg) => pkg.unscoped_name.toLowerCase() === unscoped_name.toLowerCase(),
-    )
-  }
-
-  // Filter by starred_by if provided
-  if (starred_by) {
-    starredByAccount =
-      ctx.db.accounts.find(
-        (acc) => acc.github_username.toLowerCase() === starred_by.toLowerCase(),
-      ) || null
-
-    if (starredByAccount) {
-      const accountPackages = ctx.db.accountPackages.filter(
-        (ap) => ap.account_id === starredByAccount?.account_id && ap.is_starred,
-      )
-
-      const starTimestamps = new Map(
-        accountPackages.map((ap) => [ap.package_id, ap.updated_at]),
-      )
-
-      // Filter packages to only include starred ones
-      packages = packages.filter((pkg) => starTimestamps.has(pkg.package_id))
-    } else {
-      packages = []
-    }
-  }
-
-  // Convert packages to snippets
-  const snippets = packages.map((pkg) => {
-    const packageRelease = ctx.db.getPackageReleaseById(
-      pkg.latest_package_release_id || "",
-    )
-
-    let starTimestamp
-    if (starred_by && starredByAccount) {
-      const accountPackage = ctx.db.accountPackages.find(
-        (ap) =>
-          ap.account_id === starredByAccount.account_id &&
-          ap.package_id === pkg.package_id &&
-          ap.is_starred,
-      )
-      starTimestamp = accountPackage?.updated_at
-    }
-
-    if (!packageRelease) {
-      return {
-        snippet_id: pkg.package_id,
-        package_release_id: pkg.latest_package_release_id || "",
-        unscoped_name: pkg.unscoped_name,
-        name: pkg.name,
-        owner_name: pkg.owner_github_username || "",
-        description: pkg.description || "",
-        snippet_type: pkg.snippet_type || "board",
-        code: "",
-        dts: "",
-        compiled_js: "",
-        created_at: pkg.created_at,
-        updated_at: pkg.updated_at,
-        starred_at: starTimestamp, // Add star timestamp
-        star_count: ctx.db.getStarCount(pkg.package_id),
-        is_starred: ctx.auth
-          ? ctx.db.hasStarred(ctx.auth.account_id, pkg.package_id)
-          : false,
-        version: pkg.latest_version || "0.0.1",
-        is_private: pkg.is_private || false,
-        is_public: pkg.is_public || true,
-        is_unlisted: pkg.is_unlisted || false,
-      }
-    }
-
-    const packageFiles = ctx.db.getPackageFilesByReleaseId(
-      packageRelease.package_release_id,
-    )
-    const codeFile = packageFiles.find(
-      (file: { file_path: string }) =>
-        file.file_path === "index.ts" || file.file_path === "index.tsx",
-    )
-
-    const snippet = {
-      snippet_id: pkg.package_id,
-      package_release_id: pkg.latest_package_release_id || "",
-      unscoped_name: pkg.unscoped_name,
-      name: pkg.name,
-      owner_name: pkg.owner_github_username || "",
-      description: pkg.description || "",
-      snippet_type: pkg.snippet_type || "board",
-      code: codeFile?.content_text || "",
-      dts:
-        packageFiles.find(
-          (file: { file_path: string }) =>
-            file.file_path === "/dist/index.d.ts",
-        )?.content_text || "",
-      compiled_js:
-        packageFiles.find(
-          (file: { file_path: string }) => file.file_path === "/dist/index.js",
-        )?.content_text || "",
-      created_at: pkg.created_at,
-      updated_at: pkg.updated_at,
-      starred_at: starTimestamp, // Add star timestamp
-      star_count: ctx.db.getStarCount(pkg.package_id),
-      is_starred: ctx.auth
-        ? ctx.db.hasStarred(ctx.auth.account_id, pkg.package_id)
-        : false,
-      version: pkg.latest_version || "0.0.1",
-      is_private: pkg.is_private || false,
-      is_public: pkg.is_public || true,
-      is_unlisted: pkg.is_unlisted || false,
-    }
-
-    return snippet
-  })
-
-  return ctx.json({
-    ok: true,
-    snippets,
-  })
-})

package/fake-snippets-api/routes/api/snippets/list_latest.ts

@@ -1,13 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { snippetSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  jsonResponse: z.object({
-    snippets: z.array(snippetSchema),
-  }),
-})(async (req, ctx) => {
-  const latestSnippets = ctx.db.getLatestSnippets(20)
-  return ctx.json({ snippets: latestSnippets })
-})

package/fake-snippets-api/routes/api/snippets/list_trending.ts

@@ -1,38 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { snippetSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "none",
-  jsonResponse: z.object({
-    snippets: z.array(snippetSchema),
-  }),
-  queryParams: z.object({
-    time_period: z.enum(["7days", "30days", "all"]).optional().default("all"),
-    tag: z.string().optional(),
-  }),
-})(async (req, ctx) => {
-  const { time_period, tag } = req.query
-
-  let sinceDate = new Date()
-  if (time_period === "7days") {
-    sinceDate.setDate(sinceDate.getDate() - 7)
-  } else if (time_period === "30days") {
-    sinceDate.setDate(sinceDate.getDate() - 30)
-  } else {
-    sinceDate = new Date(0) // For "all", use earliest possible date
-  }
-
-  const trendingSnippets = ctx.db.getTrendingSnippets(
-    20,
-    sinceDate.toISOString(),
-  )
-
-  // Filter by tag if provided
-  const filteredSnippets = tag
-    ? trendingSnippets.filter((snippet) => snippet.snippet_type === tag)
-    : trendingSnippets
-
-  return ctx.json({ snippets: filteredSnippets })
-})

package/fake-snippets-api/routes/api/snippets/remove_star.ts

@@ -1,42 +0,0 @@
-import { accountSnippetSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    snippet_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    is_starred: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  const { snippet_id } = req.jsonBody
-
-  // Check if snippet exists
-  const snippet = ctx.db.getSnippetById(snippet_id)
-  if (!snippet) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: "Snippet not found",
-    })
-  }
-
-  // check if not already starred
-  if (!ctx.db.hasStarred(ctx.auth.account_id, snippet_id)) {
-    return ctx.error(400, {
-      error_code: "not_starred",
-      message: "You have not starred this snippet",
-    })
-  }
-
-  // Remove star
-  ctx.db.removeStar(ctx.auth.account_id, snippet_id)
-
-  return ctx.json({
-    ok: true,
-    is_starred: false,
-  })
-})