@tscircuit/fake-snippets 0.0.1

package/playwright-tests/manual-edits.spec.ts

@@ -0,0 +1,89 @@
+import { test, expect } from "@playwright/test"
+
+test.skip("Manual edits test", async ({ page }) => {
+  test.setTimeout(60000) // Extend timeout for the test
+
+  await page.goto("http://127.0.0.1:5177/editor?snippet_id=snippet_3")
+  // await page.waitForLoadState("networkidle")
+
+  const loginButton = page.getByRole("button", { name: "Log in" })
+  // await loginButton.waitFor({ state: "visible" })
+  await loginButton.click()
+
+  const editorTextbox = page.getByRole("textbox").first()
+  // await editorTextbox.waitFor({ state: "visible" })
+  await editorTextbox.click()
+
+  await page.keyboard.press("Control+A")
+  await page.keyboard.press("Backspace")
+
+  const indexCode = `import { A555Timer } from "@tsci/seveibar.a555timer"
+  import manualEdits from "./manual-edits.json"
+
+  export default () => (
+    <board width="10mm" height="10mm" manualEdits={manualEdits}>
+      <A555Timer name="U1" />
+    </board>
+  )`
+
+  await editorTextbox.fill(indexCode)
+
+  const combobox = page.getByRole("combobox")
+  await combobox.click()
+
+  const fileOption = page.getByText("manual-edits.json", { exact: true })
+  // await fileOption.waitFor({ state: "visible" })
+  await fileOption.click()
+
+  await page.getByRole("textbox").first().click()
+  await page.keyboard.press("Control+A")
+  await page.keyboard.press("Backspace")
+
+  const pcbPlacementsData = `{
+    "pcb_placements": [
+      {
+        "selector": "U1",
+        "center": {
+          "x": -26.03275345576554,
+          "y": 23.735745797903878
+        },
+        "relative_to": "group_center",
+        "_edit_event_id": "0.5072961258141278"
+      }
+    ],
+    "edit_events": [],
+    "manual_trace_hints": []
+  }
+`
+
+  await page.keyboard.type(pcbPlacementsData)
+
+  const runButton = page.getByRole("button", { name: "Run", exact: true })
+  // await runButton.waitFor({ state: "visible" })
+  await runButton.click()
+
+  const saveButton = page.getByRole("button", { name: "Save" })
+  // await saveButton.waitFor({ state: "visible", timeout: 20000 }) // Extend timeout for Save button
+  await saveButton.click()
+
+  await page.waitForTimeout(1000)
+
+  await expect(page).toHaveScreenshot("editor-manual-edits.png")
+
+  await page.goto("http://127.0.0.1:5177/testuser/my-test-board", {
+    waitUntil: "domcontentloaded",
+  })
+
+  await page.waitForLoadState("networkidle")
+
+  const filesLink = page.getByRole("link", { name: "Files" })
+  // await filesLink.waitFor({ state: "visible" })
+  await filesLink.click()
+  await page.getByLabel("Files").click()
+
+  const fileLink = page.getByText("manual-edits.json", { exact: true })
+  // await fileLink.waitFor({ state: "visible" })
+  await fileLink.click()
+
+  await expect(page).toHaveScreenshot("manual-edits-view.png")
+})

package/playwright-tests/preview-page.spec.ts

@@ -0,0 +1,14 @@
+import { expect, test } from "@playwright/test"
+
+test(`preview-snippet Page`, async ({ page }) => {
+  await page.goto("http://127.0.0.1:5177/preview?snippet_id=snippet_5&view=pcb")
+  await page.waitForTimeout(5000)
+  await expect(page).toHaveScreenshot(`preview-snippet-pcb.png`)
+
+  await page.goto(
+    "http://127.0.0.1:5177/preview?snippet_id=snippet_5&view=schematic",
+  )
+  // Wait for schematic viewer to load
+  await page.waitForTimeout(5000)
+  await expect(page).toHaveScreenshot(`preview-snippet-schematic.png`)
+})

package/playwright-tests/quickstart-page.spec.ts

@@ -0,0 +1,10 @@
+import { test, expect } from "@playwright/test"
+import { viewports } from "./viewports"
+
+for (const [size, viewport] of Object.entries(viewports)) {
+  test(`Quickstart-Page on ${size} screen`, async ({ page }) => {
+    await page.setViewportSize(viewport)
+    await page.goto("http://127.0.0.1:5177/quickstart")
+    await expect(page).toHaveScreenshot(`Quickstart-Page${size}.png`)
+  })
+}

package/playwright-tests/search-links.spec.ts

@@ -0,0 +1,21 @@
+import { test, expect } from "@playwright/test"
+
+test("Search links open correctly", async ({ page }) => {
+  await page.goto("http://127.0.0.1:5177/dashboard")
+
+  await page.getByPlaceholder("Search").click()
+  await page.getByPlaceholder("Search").fill("sev")
+  await page.getByRole("link", { name: "seveibar/a555timer A simple" }).click()
+
+  await page.waitForTimeout(500)
+
+  // Check for specific text that should be present
+  await expect(page).toHaveScreenshot("search-links.png")
+
+  await page.getByPlaceholder("Search").click()
+  await page.getByPlaceholder("Search").fill("my")
+
+  await page.getByRole("link", { name: "testuser/my-test-board" }).click()
+
+  await expect(page).toHaveURL(/.*testuser\/my-test-board/)
+})

package/playwright-tests/search.spec.ts

@@ -0,0 +1,27 @@
+import { test, expect } from "@playwright/test"
+import { viewports } from "./viewports"
+
+for (const [size, viewport] of Object.entries(viewports)) {
+  test(`search test for ${size} viewport`, async ({ page }) => {
+    await page.setViewportSize(viewport)
+    await page.goto("http://127.0.0.1:5177/dashboard")
+
+    const searchInput = page.getByRole("searchbox", { name: "Search" }).first()
+
+    if (size !== "lg") {
+      const menuButton = page.locator("button.md\\:hidden")
+      await menuButton.click()
+      await page.waitForTimeout(500)
+    }
+
+    await searchInput.fill("seve")
+
+    // Wait for search response
+    await page.waitForResponse(
+      (response) =>
+        response.url().includes("/search") && response.status() === 200,
+    )
+
+    await expect(page).toHaveScreenshot(`search-${size}.png`)
+  })
+}

package/playwright-tests/star.spec.ts

@@ -0,0 +1,40 @@
+import { test, expect } from "@playwright/test"
+
+test.beforeEach(async ({ page }) => {
+  await page.goto("http://127.0.0.1:5177/testuser/my-test-board")
+  await page.getByRole("button", { name: "Log in" }).click()
+})
+
+test("test for starring a repo", async ({ page }) => {
+  // Check for initial page content
+  await expect(page.getByText("testuser/my-test-boardBOARD")).toBeVisible()
+  const starButton = page.getByRole("button", { name: "Star" })
+  await expect(starButton).toBeVisible()
+
+  // Add starr
+  await starButton.click()
+  await page.waitForTimeout(2000) // Allow time for the action to complete
+
+  // Verify star action
+  await expect(page.locator("ol")).toBeVisible()
+  // await page.getByText('You\'ve starred this snippet').click();
+
+  // Take a screenshot
+  await expect(page).toHaveScreenshot("star-button.png")
+})
+
+test("test for removing a star from a repo", async ({ page }) => {
+  // Ensure repo is starred before test
+  const starredButton = page.getByRole("button", { name: "Starred" })
+  await expect(starredButton).toBeVisible()
+
+  // Remove star
+  await starredButton.click()
+
+  // Verify destar action
+  const starButton = page.getByRole("button", { name: "Star" })
+  await expect(starButton).toBeVisible()
+
+  // Take a screenshot
+  await expect(page).toHaveScreenshot("remove-star-button.png")
+})

package/playwright-tests/update-description.spec.ts

@@ -0,0 +1,18 @@
+import { test, expect } from "@playwright/test"
+
+test("test", async ({ page }) => {
+  await page.goto("http://localhost:5177/editor?snippet_id=snippet_3")
+  await page.getByRole("button", { name: "Log in" }).click()
+  await page.locator(".lucide-ellipsis-vertical").click()
+  await page.waitForTimeout(5000)
+  await page.getByRole("menuitem", { name: "Edit Description" }).click()
+  await page.getByPlaceholder("Enter new description").press("End")
+  await page
+    .getByPlaceholder("Enter new description")
+    .fill("Check out this new description")
+  await page.getByRole("button", { name: "Update" }).click()
+  await page.locator(".lucide-ellipsis-vertical").click()
+  await page.waitForTimeout(5000)
+  await page.getByRole("menuitem", { name: "Edit Description" }).click()
+  await expect(page).toHaveScreenshot("update-description.png")
+})

package/playwright-tests/view-snippet.spec.ts

@@ -0,0 +1,35 @@
+import { test, expect } from "@playwright/test"
+import { viewports } from "./viewports"
+
+for (const [size, viewport] of Object.entries(viewports)) {
+  test(`view-snippet Page on ${size} screen`, async ({ page }) => {
+    await page.setViewportSize(viewport)
+
+    // Wait for network requests during navigation
+    await Promise.all([
+      // page.waitForLoadState("networkidle"),
+      page.goto("http://127.0.0.1:5177/testuser/my-test-board"),
+    ])
+
+    // Wait for run button to be visible and clickable
+    const runButton = await page.waitForSelector(".run-button", {
+      state: "visible",
+    })
+    await expect(page).toHaveScreenshot(`view-snippet-before-${size}.png`)
+
+    // Click and wait for any network requests or animations to complete
+    await Promise.all([runButton.click()])
+
+    // Wait for PCB tab to be fully loaded and any animations to complete
+    await page.waitForTimeout(1000) // Reduced timeout, just for animations
+    await expect(page).toHaveScreenshot(`view-snippet-after-${size}.png`)
+
+    if (size !== "xs") {
+      // Wait for Files tab to be visible and clickable
+      const filesTab = await page.waitForSelector('span:has-text("Files")', {
+        state: "visible",
+      })
+      await filesTab.click()
+    }
+  })
+}

package/playwright-tests/viewports.ts

@@ -0,0 +1,5 @@
+export const viewports = {
+  xs: { width: 375, height: 667 },
+  md: { width: 765, height: 1024 },
+  lg: { width: 1280, height: 800 },
+}

package/playwright.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from "@playwright/test"
+
+export default defineConfig({
+  // Run your local dev server before starting the tests
+  retries: process.env.CI ? 2 : 1,
+  webServer: {
+    command: "npm run start:playwright-server",
+    url: "http://127.0.0.1:5177",
+    reuseExistingServer: !process.env.CI,
+    stdout: "pipe",
+    stderr: "pipe",
+    timeout: 30000,
+  },
+  workers: 2,
+  testDir: "playwright-tests",
+  snapshotPathTemplate: "playwright-tests/snapshots/{testFilePath}-{arg}{ext}",
+  testMatch: /.*\.spec\.ts/,
+  expect: {
+    toHaveScreenshot: {
+      // Increase the maximum allowed difference in pixels
+      maxDiffPixelRatio: 0.2,
+      // Increase the threshold for considering pixels different
+      threshold: 0.2,
+      animations: "disabled",
+    },
+  },
+})

package/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

package/public/robots.txt

@@ -0,0 +1,9 @@
+# Allow all crawlers
+User-agent: *
+Allow: /
+
+# Sitemaps
+Sitemap: https://tscircuit.com/sitemap.xml
+
+# Crawl-delay
+Crawl-delay: 10

package/renovate.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["config:base"],
+  "packageRules": [
+    {
+      "packagePatterns": ["*"],
+      "excludePackagePatterns": [
+        "@tscircuit/*",
+        "circuit-to-svg",
+        "jscad-electronics",
+        "circuit-json",
+        "dsn-converter",
+        "circuit-json-to-readable-netlist"
+      ],
+      "enabled": false
+    },
+    {
+      "matchUpdateTypes": ["major", "minor", "patch"],
+      "automerge": true,
+      "groupName": "dependency updates",
+      "groupSlug": "all-updates"
+    }
+  ]
+}

package/scripts/generate-image-sizes.ts

@@ -0,0 +1,58 @@
+import sharp from "sharp"
+import path from "path"
+import fs from "fs"
+
+const WIDTHS = [400, 600, 800, 1000, 1200, 1600, 2000]
+const INPUT_DIR = "src/assets/originals"
+const OUTPUT_DIR = "public/assets"
+
+async function generateImageSizes() {
+  console.log("one")
+  if (!fs.existsSync(INPUT_DIR)) {
+    fs.mkdirSync(INPUT_DIR, { recursive: true })
+  }
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true })
+  }
+
+  const files = fs.readdirSync(INPUT_DIR)
+
+  for (const file of files) {
+    if (file.startsWith(".")) continue
+
+    const filePath = path.join(INPUT_DIR, file)
+    const fileNameWithoutExt = path.parse(file).name
+    const outputDirForFile = path.join(OUTPUT_DIR)
+
+    if (!fs.existsSync(outputDirForFile)) {
+      fs.mkdirSync(outputDirForFile, { recursive: true })
+    }
+
+    for (const width of WIDTHS) {
+      const extension = path.extname(file)
+      const outputPath = path.join(
+        outputDirForFile,
+        `${fileNameWithoutExt}-${width}w${extension}`,
+      )
+
+      try {
+        await sharp(filePath)
+          .resize(width, null, {
+            withoutEnlargement: true,
+            fit: "inside",
+          })
+          .webp({
+            quality: 80,
+            effort: 6,
+          })
+          .toFile(outputPath)
+
+        console.log(`Generated ${outputPath}`)
+      } catch (error) {
+        console.error(`Error processing ${filePath} at width ${width}:`, error)
+      }
+    }
+  }
+}
+
+generateImageSizes().catch(console.error)

package/scripts/generate-sitemap.ts

@@ -0,0 +1,103 @@
+import { SitemapStream, streamToPromise } from "sitemap"
+import { Readable } from "stream"
+import fs from "fs"
+import path from "path"
+
+const staticRoutes = [
+  { url: "/", changefreq: "weekly", priority: 1.0 },
+  { url: "/editor", changefreq: "weekly", priority: 0.9 },
+  { url: "/playground", changefreq: "weekly", priority: 0.9 },
+  { url: "/quickstart", changefreq: "monthly", priority: 0.8 },
+  { url: "/dashboard", changefreq: "weekly", priority: 0.7 },
+  { url: "/newest", changefreq: "daily", priority: 0.8 },
+  { url: "/search", changefreq: "weekly", priority: 0.7 },
+  { url: "/settings", changefreq: "monthly", priority: 0.6 },
+  { url: "/community/join-redirect", changefreq: "monthly", priority: 0.6 },
+  { url: "/legal/terms-of-service", changefreq: "yearly", priority: 0.3 },
+  { url: "/legal/privacy-policy", changefreq: "yearly", priority: 0.3 },
+]
+
+async function fetchTrendingSnippets() {
+  try {
+    const response = await fetch(
+      "https://registry-api.tscircuit.com/snippets/list_trending",
+      {
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+        },
+      },
+    )
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const text = await response.text()
+    try {
+      const data = JSON.parse(text)
+      return data.snippets || []
+    } catch (parseError) {
+      console.error("JSON Parse Error:", parseError)
+      console.error("Raw response:", text)
+      return []
+    }
+  } catch (error) {
+    console.error("Error fetching trending snippets:", error)
+    return []
+  }
+}
+
+async function generateSitemap() {
+  try {
+    const stream = new SitemapStream({
+      hostname: "https://tscircuit.com",
+      xmlns: {
+        news: false,
+        xhtml: false,
+        image: false,
+        video: false,
+      },
+    })
+
+    const trendingSnippets = await fetchTrendingSnippets()
+
+    const links = [
+      ...staticRoutes,
+      ...trendingSnippets.map((snippet: any) => ({
+        url: `/${snippet.owner_name}/${snippet.unscoped_name}`,
+        changefreq: "weekly",
+        priority: 0.7,
+        lastmod: new Date(
+          snippet.updated_at || snippet.created_at,
+        ).toISOString(),
+      })),
+    ]
+
+    const sitemap = await streamToPromise(Readable.from(links).pipe(stream))
+
+    const formattedXml = sitemap
+      .toString()
+      .replace(/></g, ">\n<")
+      .split("\n")
+      .map((line) => line.trim())
+      .map((line, i) => {
+        if (i === 0) return line
+        if (line.startsWith("</")) return "  " + line
+        if (line.startsWith("<urlset")) return line
+        if (line.startsWith("</urlset>")) return line
+        if (line.startsWith("<url>")) return "  " + line
+        if (line.startsWith("</url>")) return "  " + line
+        return "    " + line
+      })
+      .join("\n")
+
+    const outputPath = path.join(process.cwd(), "public", "sitemap.xml")
+    fs.writeFileSync(outputPath, formattedXml, "utf-8")
+
+    console.log("Sitemap generated successfully at", outputPath)
+  } catch (error) {
+    console.error("Error generating sitemap:", error)
+    process.exit(1)
+  }
+}
+
+generateSitemap().catch(console.error)