awakecoding
diff --git a/‎.github/workflows/ci.yml‎
Lines changed: 3 additions & 0 deletions b/‎.github/workflows/ci.yml‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎integrations/package.json‎
Lines changed: 10 additions & 0 deletions b/‎integrations/package.json‎
Lines changed: 10 additions & 0 deletions
diff --git a/‎integrations/utils.ts‎
Lines changed: 295 additions & 0 deletions b/‎integrations/utils.ts‎
Lines changed: 295 additions & 0 deletions
@@ -68,6 +68,9 @@ jobs:
       - name: Test
         run: pnpm run test
 
+      - name: Integration Tests
+        run: pnpm run test:integrations
+
       - name: Install Playwright Browsers
         run: npx playwright install --with-deps
 
 
@@ -0,0 +1,10 @@
+{
+  "name": "internal-integrations",
+  "version": "0.0.0",
+  "private": true,
+  "devDependencies": {
+    "dedent": "1.5.3",
+    "fast-glob": "^3.3.2",
+    "kill-port": "^2.0.1"
+  }
+}
@@ -0,0 +1,295 @@
+import dedent from 'dedent'
+import fastGlob from 'fast-glob'
+import killPort from 'kill-port'
+import { execSync, spawn } from 'node:child_process'
+import fs from 'node:fs/promises'
+import net from 'node:net'
+import { homedir, platform, tmpdir } from 'node:os'
+import path from 'node:path'
+import { test as defaultTest } from 'vitest'
+
+export let css = dedent
+export let html = dedent
+export let ts = dedent
+export let json = dedent
+
+const REPO_ROOT = path.join(__dirname, '..')
+
+interface SpawnedProcess {
+  dispose: () => void
+  onStdout: (predicate: (message: string) => boolean) => Promise<void>
+  onStderr: (predicate: (message: string) => boolean) => Promise<void>
+}
+
+interface TestConfig {
+  fs: {
+    [filePath: string]: string
+  }
+}
+interface TestContext {
+  exec(command: string): Promise<string>
+  spawn(command: string): Promise<SpawnedProcess>
+  getFreePort(): Promise<number>
+  fs: {
+    write(filePath: string, content: string): Promise<void>
+    glob(pattern: string): Promise<[string, string][]>
+  }
+}
+type TestCallback = (context: TestContext) => Promise<void> | void
+
+type SpawnActor = { predicate: (message: string) => boolean; resolve: () => void }
+
+export function test(
+  name: string,
+  config: TestConfig,
+  testCallback: TestCallback,
+  { only = false } = {},
+) {
+  return (only ? defaultTest.only : defaultTest)(name, { timeout: 30000 }, async (options) => {
+    let root = await fs.mkdtemp(
+      // On Windows CI, tmpdir returns a path containing a weird RUNNER~1 folder
+      // that apparently causes the vite builds to not work.
+      path.join(
+        process.env.CI && platform() === 'win32' ? homedir() : tmpdir(),
+        'tailwind-integrations',
+      ),
+    )
+
+    async function write(filename: string, content: string): Promise<void> {
+      let full = path.join(root, filename)
+
+      if (filename.endsWith('package.json')) {
+        content = overwriteVersionsInPackageJson(content)
+      }
+
+      // Ensure that files written on Windows use \r\n line ending
+      if (platform() === 'win32') {
+        content = content.replace(/\n/g, '\r\n')
+      }
+
+      let dir = path.dirname(full)
+      await fs.mkdir(dir, { recursive: true })
+      await fs.writeFile(full, content)
+    }
+
+    for (let [filename, content] of Object.entries(config.fs)) {
+      await write(filename, content)
+    }
+
+    try {
+      execSync('pnpm install', { cwd: root })
+    } catch (error: any) {
+      console.error(error.stdout.toString())
+      console.error(error.stderr.toString())
+      throw error
+    }
+
+    let disposables: (() => Promise<void>)[] = []
+    async function dispose() {
+      await Promise.all(disposables.map((dispose) => dispose()))
+      await fs.rm(root, { recursive: true, maxRetries: 3, force: true })
+    }
+    options.onTestFinished(dispose)
+
+    let context = {
+      async exec(command: string) {
+        return execSync(command, { cwd: root }).toString()
+      },
+      async spawn(command: string) {
+        let resolveDisposal: (() => void) | undefined
+        let rejectDisposal: ((error: Error) => void) | undefined
+        let disposePromise = new Promise<void>((resolve, reject) => {
+          resolveDisposal = resolve
+          rejectDisposal = reject
+        })
+
+        let child = spawn(command, {
+          cwd: root,
+          shell: true,
+          env: {
+            ...process.env,
+          },
+        })
+
+        function dispose() {
+          child.kill()
+
+          let timer = setTimeout(
+            () => rejectDisposal?.(new Error(`spawned process (${command}) did not exit in time`)),
+            1000,
+          )
+          disposePromise.finally(() => clearTimeout(timer))
+          return disposePromise
+        }
+        disposables.push(dispose)
+        function onExit() {
+          resolveDisposal?.()
+        }
+
+        let stdoutMessages: string[] = []
+        let stderrMessages: string[] = []
+
+        let stdoutActors: SpawnActor[] = []
+        let stderrActors: SpawnActor[] = []
+
+        function notifyNext(actors: SpawnActor[], messages: string[]) {
+          if (actors.length <= 0) return
+          let [next] = actors
+
+          for (let [idx, message] of messages.entries()) {
+            if (next.predicate(message)) {
+              messages.splice(0, idx + 1)
+              let actorIdx = actors.indexOf(next)
+              actors.splice(actorIdx, 1)
+              next.resolve()
+              break
+            }
+          }
+        }
+
+        child.stdout.on('data', (result) => {
+          stdoutMessages.push(result.toString())
+          notifyNext(stdoutActors, stdoutMessages)
+        })
+        child.stderr.on('data', (result) => {
+          stderrMessages.push(result.toString())
+          notifyNext(stderrActors, stderrMessages)
+        })
+        child.on('exit', onExit)
+        child.on('error', (error) => {
+          if (error.name !== 'AbortError') {
+            throw error
+          }
+        })
+
+        options.onTestFailed(() => {
+          stdoutMessages.map((message) => console.log(message))
+          stderrMessages.map((message) => console.error(message))
+        })
+
+        return {
+          dispose,
+          onStdout(predicate: (message: string) => boolean) {
+            return new Promise<void>((resolve) => {
+              stdoutActors.push({ predicate, resolve })
+              notifyNext(stdoutActors, stdoutMessages)
+            })
+          },
+          onStderr(predicate: (message: string) => boolean) {
+            return new Promise<void>((resolve) => {
+              stderrActors.push({ predicate, resolve })
+              notifyNext(stderrActors, stderrMessages)
+            })
+          },
+        }
+      },
+      async getFreePort(): Promise<number> {
+        return new Promise((resolve, reject) => {
+          let server = net.createServer()
+          server.listen(0, () => {
+            let address = server.address()
+            let port = address === null || typeof address === 'string' ? null : address.port
+
+            server.close(() => {
+              if (port === null) {
+                reject(new Error(`Failed to get a free port: address is ${address}`))
+              } else {
+                disposables.push(async () => {
+                  // Wait for 10ms in case the process was just killed
+                  await new Promise((resolve) => setTimeout(resolve, 10))
+
+                  // kill-port uses `lsof` on macOS which is expensive and can
+                  // block for multiple seconds. In order to avoid that for a
+                  // server that is no longer running, we check if the port is
+                  // still in use first.
+                  let isPortTaken = await testIfPortTaken(port)
+                  if (!isPortTaken) {
+                    return
+                  }
+
+                  await killPort(port)
+                })
+                resolve(port)
+              }
+            })
+          })
+        })
+      },
+      fs: {
+        write,
+        async glob(pattern: string) {
+          let files = await fastGlob(pattern, { cwd: root })
+          return Promise.all(
+            files.map(async (file) => {
+              let content = await fs.readFile(path.join(root, file), 'utf8')
+              return [file, content]
+            }),
+          )
+        },
+      },
+    } satisfies TestContext
+
+    await testCallback(context)
+  })
+}
+test.only = (name: string, config: TestConfig, testCallback: TestCallback) => {
+  return test(name, config, testCallback, { only: true })
+}
+
+// Maps package names to their tarball filenames. See scripts/pack-packages.ts
+// for more details.
+function pkgToFilename(name: string) {
+  return `${name.replace('@', '').replace('/', '-')}.tgz`
+}
+
+function overwriteVersionsInPackageJson(content: string): string {
+  let json = JSON.parse(content)
+
+  // Resolve all workspace:^ versions to local tarballs
+  ;['dependencies', 'devDependencies', 'peerDependencies'].forEach((key) => {
+    let dependencies = json[key] || {}
+    for (let dependency in dependencies) {
+      if (dependencies[dependency] === 'workspace:^') {
+        dependencies[dependency] = resolveVersion(dependency)
+      }
+    }
+  })
+
+  // Inject transitive dependency overwrite. This is necessary because
+  // @tailwindcss/vite internally depends on a specific version of
+  // @tailwindcss/oxide and we instead want to resolve it to the locally built
+  // version.
+  json.pnpm ||= {}
+  json.pnpm.overrides ||= {}
+  json.pnpm.overrides['@tailwindcss/oxide'] = resolveVersion('@tailwindcss/oxide')
+
+  return JSON.stringify(json, null, 2)
+}
+
+function resolveVersion(dependency: string) {
+  let tarball = path.join(REPO_ROOT, 'dist', pkgToFilename(dependency))
+  return `file:${tarball}`
+}
+
+export function stripTailwindComment(content: string) {
+  return content.replace(/\/\*! tailwindcss .*? \*\//g, '').trim()
+}
+
+function testIfPortTaken(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    let client = new net.Socket()
+    client.once('connect', () => {
+      resolve(true)
+      client.end()
+    })
+    client.once('error', (error: any) => {
+      if (error.code !== 'ECONNREFUSED') {
+        resolve(true)
+      } else {
+        resolve(false)
+      }
+      client.end()
+    })
+    client.connect({ port: port, host: 'localhost' })
+  })
+}