@tscircuit/cli 0.1.22 → 0.1.24

package/example-dir/snippet2-large-led-matrix.tsx

@@ -104,7 +104,7 @@ export default () => {
         ySpacing: 5,
         offsetX: 3 - 122,
         offsetY: -32 / 2 - 7.5,
-      }).map(({ center, index, row, col }) => {
+      }).map(({ center, index }) => {
         const ledName = `LED${index + 1}`
         const prevLedName = index > 0 ? `LED${index}` : null
         const capName = `C_${ledName}`

package/example-dir/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "ESNext",
+    "jsx": "react-jsx",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true
+  }
+}

package/example-dir/types.d.ts

@@ -9,3 +9,23 @@ declare module "@tsci/seveibar.push-button" {
 declare module "@tsci/seveibar.smd-usb-c" {
   export function useUsbC(name: string): any
 }
+
+declare module "@tsci/seveibar.PICO_W" {
+  export function usePICO_W(name: string): any
+}
+
+declare module "@tsci/seveibar.HS91L02W2C01" {
+  export function useHS91L02W2C01(name: string): any
+}
+
+declare module "@tsci/seveibar.WS2812B_2020" {
+  interface WS2812B_2020Props {
+    schX: number
+    schY: number
+    name: string
+    pcbX: number
+    pcbY: number
+  }
+
+  export const WS2812B_2020: React.FC<WS2812B_2020Props>
+}

package/lib/file-server/FileServerRoutes.ts

@@ -1,4 +1,6 @@
-export interface FileServerRoutes {
+import { EventsRoutes } from "lib/server/EventsRoutes"
+
+export interface FileServerRoutes extends EventsRoutes {
   "api/files/get": {
     GET: {
       searchParams: {

package/lib/server/EventsRoutes.ts

@@ -0,0 +1,32 @@
+export interface EventsRoutes {
+  "api/events/create": {
+    POST: {
+      requestJson: {
+        event_type: string
+      }
+      responseJson: {
+        event: {
+          event_id: string
+          event_type: string
+        }
+      }
+    }
+  }
+  "api/events/list": {
+    GET: {
+      responseJson: {
+        event_list: Array<{
+          event_id: string
+          event_type:
+            | "FILE_UPDATED"
+            | "FAILED_TO_SAVE_SNIPPET"
+            | "SNIPPET_SAVED"
+            | "REQUEST_TO_SAVE_SNIPPET"
+          file_path: string
+          created_at: string
+          initiator?: string
+        }>
+      }
+    }
+  }
+}

package/lib/shared/push-snippet.ts

@@ -0,0 +1,198 @@
+import { cliConfig } from "lib/cli-config"
+import { getKy } from "lib/registry-api/get-ky"
+import * as fs from "node:fs"
+import * as path from "node:path"
+import semver from "semver"
+
+type PushOptions = {
+  filePath?: string
+  onExit?: (code: number) => void
+  onError?: (message: string) => void
+  onSuccess?: (message: string) => void
+}
+
+export const pushSnippet = async ({
+  filePath,
+  onExit = (code) => process.exit(code),
+  onError = (message) => console.error(message),
+  onSuccess = (message) => console.log(message),
+}: PushOptions) => {
+  const sessionToken = cliConfig.get("sessionToken")
+  if (!sessionToken) {
+    onError("You need to log in to save snippet.")
+    return onExit(1)
+  }
+
+  let snippetFilePath: string | null = null
+  if (filePath) {
+    snippetFilePath = path.resolve(filePath)
+  } else {
+    const defaultEntrypoint = path.resolve("index.tsx")
+    if (fs.existsSync(defaultEntrypoint)) {
+      snippetFilePath = defaultEntrypoint
+      onSuccess("No file provided. Using 'index.tsx' as the entrypoint.")
+    } else {
+      onError(
+        "No entrypoint found. Run 'tsci init' to bootstrap a basic project.",
+      )
+      return onExit(1)
+    }
+  }
+
+  const packageJsonPath = path.resolve(
+    path.join(path.dirname(snippetFilePath), "package.json"),
+  )
+  let packageJson: { name?: string; author?: string; version?: string } = {}
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString())
+    } catch {
+      onError("Invalid package.json provided")
+      return onExit(1)
+    }
+  }
+
+  if (!fs.existsSync(snippetFilePath)) {
+    onError(`File not found: ${snippetFilePath}`)
+    return onExit(1)
+  }
+
+  const ky = getKy()
+  const packageName = (
+    packageJson.name ?? path.parse(snippetFilePath).name
+  ).replace(/^@/, "")
+  const packageAuthor =
+    packageJson.author?.split(" ")[0] ?? cliConfig.get("githubUsername")
+  const packageIdentifier = `${packageAuthor}/${packageName}`
+
+  let packageVersion =
+    packageJson.version ??
+    (await ky
+      .post<{
+        error?: { error_code: string }
+        package_releases?: { version: string; is_latest: boolean }[]
+      }>("package_releases/list", {
+        json: { package_name: packageIdentifier },
+      })
+      .json()
+      .then(
+        (response) =>
+          response.package_releases?.[response.package_releases.length - 1]
+            ?.version,
+      )
+      .catch((error) => {
+        onError("Failed to retrieve latest package version:" + error)
+        return onExit(1)
+      }))
+
+  if (!packageVersion) {
+    onError("Failed to retrieve package version.")
+    return onExit(1)
+  }
+
+  const updatePackageJsonVersion = (newVersion?: string) => {
+    if (packageJson.version) {
+      try {
+        packageJson.version = newVersion ?? `${packageVersion}`
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+      } catch (error) {
+        onError("Failed to update package.json version:" + error)
+      }
+    }
+  }
+
+  const doesPackageExist = await ky
+    .post<{ error?: { error_code: string } }>("packages/get", {
+      json: { name: packageIdentifier },
+      throwHttpErrors: false,
+    })
+    .json()
+    .then((response) => !(response.error?.error_code === "package_not_found"))
+
+  if (!doesPackageExist) {
+    await ky
+      .post("packages/create", {
+        json: { name: packageIdentifier },
+        headers: { Authorization: `Bearer ${sessionToken}` },
+      })
+      .catch((error) => {
+        onError("Error creating package:" + error)
+        return onExit(1)
+      })
+  }
+
+  const doesReleaseExist = await ky
+    .post<{
+      error?: { error_code: string }
+      package_release?: { version: string }
+    }>("package_releases/get", {
+      json: {
+        package_name_with_version: `${packageIdentifier}@${packageVersion}`,
+      },
+      throwHttpErrors: false,
+    })
+    .json()
+    .then((response) => {
+      if (response.package_release?.version) {
+        packageVersion = response.package_release.version
+        updatePackageJsonVersion(response.package_release.version)
+        return true
+      }
+      return !(response.error?.error_code === "package_release_not_found")
+    })
+
+  if (doesReleaseExist) {
+    const bumpedVersion = semver.inc(packageVersion, "patch")!
+    onSuccess(
+      `Incrementing Package Version ${packageVersion} -> ${bumpedVersion}`,
+    )
+    packageVersion = bumpedVersion
+    updatePackageJsonVersion(packageVersion)
+  }
+
+  await ky
+    .post("package_releases/create", {
+      json: {
+        package_name_with_version: `${packageIdentifier}@${packageVersion}`,
+      },
+      throwHttpErrors: false,
+    })
+    .catch((error) => {
+      onError("Error creating release:" + error)
+      return onExit(1)
+    })
+
+  onSuccess("\n")
+
+  const directoryFiles = fs.readdirSync(path.dirname(snippetFilePath))
+  for (const file of directoryFiles) {
+    const fileExtension = path.extname(file).replace(".", "")
+    if (!["json", "tsx", "ts"].includes(fileExtension)) continue
+    const fileContent =
+      fs
+        .readFileSync(path.join(path.dirname(snippetFilePath), file))
+        .toString() ?? ""
+    await ky
+      .post("package_files/create", {
+        json: {
+          file_path: file,
+          content_text: fileContent,
+          package_name_with_version: `${packageIdentifier}@${packageVersion}`,
+        },
+        throwHttpErrors: false,
+      })
+      .then(() => {
+        onSuccess(`Uploaded file ${file} to the registry.`)
+      })
+      .catch((error) => {
+        onError(`Error uploading file ${file}:` + error)
+      })
+  }
+
+  onSuccess(
+    [
+      `\n🎉 Successfully pushed package ${packageIdentifier}@${packageVersion} to the registry!${Bun.color("blue", "ansi")}`,
+      `https://tscircuit.com/${packageIdentifier} \x1b[0m`,
+    ].join(" "),
+  )
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/cli",
   "main": "dist/main.js",
   "type": "module",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "bin": {
     "tsci": "./dist/main.js"
   },
@@ -20,7 +20,7 @@
     "@tscircuit/fake-snippets": "^0.0.5",
     "@types/bun": "^1.1.15",
     "@types/configstore": "^6.0.2",
-    "@types/react": "^19.0.1",
+    "@types/react": "^19.0.8",
     "@types/semver": "^7.5.8",
     "get-port": "^7.1.0",
     "tempy": "^3.1.0",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@tscircuit/file-server": "^0.0.13",
     "@tscircuit/runframe": "^0.0.47",
-    "chokidar": "^4.0.1",
+    "chokidar": "4.0.1",
     "commander": "^12.1.0",
     "configstore": "^7.0.0",
     "cosmiconfig": "^9.0.0",

package/tests/cli/init/init.test.ts

@@ -0,0 +1,34 @@
+import { getCliTestFixture } from "../../fixtures/get-cli-test-fixture"
+import { test, expect } from "bun:test"
+import { join } from "node:path"
+import { execSync } from "node:child_process"
+
+test("init command installs @types/react and passes type-checking", async () => {
+  const { tmpDir, runCommand } = await getCliTestFixture()
+
+  const { stdout } = await runCommand("tsci init")
+  console.log(stdout)
+
+  const pkgJsonPath = join(tmpDir, "package.json")
+  const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text())
+  expect(pkgJson.devDependencies["@types/react"]).toBeDefined()
+  expect(pkgJson.devDependencies["@tscircuit/core"]).toBeDefined()
+
+  const npmrcPath = join(tmpDir, ".npmrc")
+  const npmrcContent = await Bun.file(npmrcPath).text()
+  expect(npmrcContent).toContain("@tsci:registry=https://npm.tscircuit.com")
+
+  const tsconfigPath = join(tmpDir, "tsconfig.json")
+  const tsconfigExists = await Bun.file(tsconfigPath).exists()
+  expect(tsconfigExists).toBeTrue()
+
+  try {
+    const typeCheckResult = execSync("npx tsc --noEmit", {
+      cwd: tmpDir,
+      stdio: "pipe",
+    })
+    console.log(typeCheckResult.toString())
+  } catch (error) {
+    throw new Error("Type-checking failed")
+  }
+})

package/tests/test5-dev-server-save-snippet.test.ts

@@ -0,0 +1,90 @@
+import { test, expect, afterAll } from "bun:test"
+import { DevServer } from "cli/dev/DevServer"
+import { getTestFixture } from "tests/fixtures/get-test-fixture"
+import { EventsWatcher } from "lib/server/EventsWatcher"
+import { getTestSnippetsServer } from "./fixtures/get-test-server"
+import { cliConfig } from "lib/cli-config"
+
+test("test saveSnippet via REQUEST_TO_SAVE_SNIPPET event with CLI token setup", async () => {
+  afterAll(() => {
+    eventManager.stop()
+    devServer.stop()
+  })
+
+  // Start snippets server
+  await getTestSnippetsServer()
+
+  // Set up a temporary directory with a sample snippet file
+  const { tempDirPath, devServerPort, devServerUrl } = await getTestFixture({
+    vfs: {
+      "snippet.tsx": `
+          export const MyCircuit = () => (
+            <board width="10mm" height="10mm">
+              <chip name="U1" footprint="soic8" />
+            </board>
+          )
+        `,
+      "manual-edits.json": "{}",
+      "package.json": JSON.stringify({
+        version: "0.0.1",
+        name: "snippet",
+        author: "test-author",
+      }),
+    },
+  })
+
+  // Create and start the DevServer instance
+  const devServer = new DevServer({
+    port: devServerPort,
+    componentFilePath: `${tempDirPath}/snippet.tsx`,
+  })
+  await devServer.start()
+
+  // Start the EventsWatcher to listen for events
+  const eventManager = new EventsWatcher(devServerUrl)
+  await eventManager.start()
+
+  // Emit the REQUEST_TO_SAVE_SNIPPET event
+  devServer.fsKy.post("api/events/create", {
+    json: { event_type: "REQUEST_TO_SAVE_SNIPPET" },
+  })
+
+  // Promises to wait for specific events using Promise.withResolvers()
+  const {
+    promise: requestToSaveSnippetPromise,
+    resolve: resolveRequestToSaveSnippet,
+  } = Promise.withResolvers<void>()
+  eventManager.on("REQUEST_TO_SAVE_SNIPPET", async () => {
+    resolveRequestToSaveSnippet()
+  })
+
+  const sessionToken = cliConfig.get("sessionToken")
+  cliConfig.delete("sessionToken")
+
+  const { promise: snippetSavedPromise, resolve: resolveSnippetSaved } =
+    Promise.withResolvers<void>()
+  eventManager.on("SNIPPET_SAVED", () => {
+    resolveSnippetSaved()
+  })
+
+  const {
+    promise: snippetSaveFailedPromise,
+    resolve: resolveSnippetSaveFailed,
+  } = Promise.withResolvers<void>()
+  eventManager.on("FAILED_TO_SAVE_SNIPPET", () => {
+    resolveSnippetSaveFailed()
+    cliConfig.set("sessionToken", sessionToken)
+    devServer.fsKy.post("api/events/create", {
+      json: { event_type: "REQUEST_TO_SAVE_SNIPPET" },
+    })
+  })
+
+  // Wait for the REQUEST_TO_SAVE_SNIPPET event to be detected
+  expect(requestToSaveSnippetPromise).resolves.toBeUndefined()
+
+  // Wait for the FAILED_TO_SAVE_SNIPPET event to be detected
+  expect(snippetSaveFailedPromise).resolves.toBeUndefined()
+
+  // Wait for the SNIPPET_SAVED event to be detected
+  expect(snippetSavedPromise).resolves.toBeUndefined()
+}, 20_000)