zile 0.0.0 → 0.0.1

package/package.json

@@ -1,4 +1,60 @@
 {
   "name": "zile",
-  "version": "0.0.0"
-}
+  "type": "module",
+  "version": "0.0.1",
+  "license": "MIT",
+  "bin": {
+    "zile": "./dist/Cli.js"
+  },
+  "scripts": {
+    "build": "bun src/Cli.ts",
+    "changeset:publish": "bun run build && changeset publish",
+    "changeset:version": "changeset version",
+    "check": "biome check --fix --unsafe",
+    "check:types": "tsc -b",
+    "test": "vitest --watch=false"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/index.js",
+  "packageManager": "bun@1.3",
+  "dependencies": {
+    "cac": "6.7.14",
+    "tsconfck": "3.1.6"
+  },
+  "peerDependencies": {
+    "@typescript/native-preview": ">=7.0.0",
+    "typescript": ">=5"
+  },
+  "peerDependenciesMeta": {
+    "@typescript/native-preview": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.2",
+    "@biomejs/biome": "^2.2.5",
+    "@changesets/changelog-github": "^0.5.0",
+    "@changesets/cli": "^2.27.7",
+    "@types/node": "^24.7.1",
+    "publint": "0.3.14",
+    "type-fest": "^5.0.1",
+    "vitest": "^3.2.4"
+  },
+  "repository": "wevm/zile",
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  }
+}

package/src/Cli.test.ts

@@ -0,0 +1,81 @@
+import { spawn } from 'node:child_process'
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import { setupRepos, tree } from '../test/utils.js'
+
+const repos = () =>
+  setupRepos().then(({ repos }) => repos.filter(({ relative }) => !relative.includes('invalid-')))
+
+describe.each(await repos())('$relative: Cli.run', ({ cwd }) => {
+  test('default', async () => {
+    if (cwd.includes('error-')) return
+
+    const result = spawn(
+      'bun',
+      ['./Cli.ts', '--cwd', cwd, '--includes', '**,!**/error-*,!**/node_modules/**'],
+      { cwd: import.meta.dirname },
+    )
+
+    const promise = Promise.withResolvers<void>()
+    result.on('close', (code) =>
+      code === 0
+        ? promise.resolve()
+        : promise.reject(new Error(`Child process exited with code ${code}`)),
+    )
+    await promise.promise
+
+    const packageJsonString = await fs.readFile(path.resolve(cwd, 'package.json'), 'utf-8')
+    const packageJson = JSON.parse(packageJsonString)
+    expect([packageJsonString, await tree(cwd)].join('\n\n')).toMatchSnapshot('output')
+    expect(await fs.readFile(path.resolve(cwd, packageJson.main), 'utf-8')).toMatchSnapshot('main')
+    expect(await fs.readFile(path.resolve(cwd, packageJson.types), 'utf-8')).toMatchSnapshot(
+      'types',
+    )
+  })
+
+  test('link', async () => {
+    if (cwd.includes('error-')) return
+
+    const result = spawn(
+      'bun',
+      ['./Cli.ts', 'dev', '--cwd', cwd, '--includes', '**,!**/error-*,!**/node_modules/**'],
+      { cwd: import.meta.dirname },
+    )
+
+    const promise = Promise.withResolvers<void>()
+    result.on('close', (code) =>
+      code === 0
+        ? promise.resolve()
+        : promise.reject(new Error(`Child process exited with code ${code}`)),
+    )
+    await promise.promise
+
+    const packageJsonString = await fs.readFile(path.resolve(cwd, 'package.json'), 'utf-8')
+    const packageJson = JSON.parse(packageJsonString)
+    expect([packageJsonString, await tree(cwd)].join('\n\n')).toMatchSnapshot('output')
+
+    // Verify symlinks exist (check exports field for actual symlink locations)
+    const rootExport = packageJson.exports?.['.']
+    const defaultPath =
+      typeof rootExport === 'string'
+        ? rootExport
+        : typeof rootExport === 'object' && rootExport
+          ? rootExport.default
+          : null
+    const typesPath = typeof rootExport === 'object' && rootExport ? rootExport.types : null
+
+    if (defaultPath) {
+      const mainStats = await fs.lstat(path.resolve(cwd, defaultPath))
+      expect(mainStats.isSymbolicLink()).toBe(true)
+      const mainTarget = await fs.readlink(path.resolve(cwd, defaultPath))
+      expect(mainTarget).toMatchSnapshot('main-target')
+    }
+
+    if (typesPath) {
+      const typesStats = await fs.lstat(path.resolve(cwd, typesPath))
+      expect(typesStats.isSymbolicLink()).toBe(true)
+      const typesTarget = await fs.readlink(path.resolve(cwd, typesPath))
+      expect(typesTarget).toMatchSnapshot('types-target')
+    }
+  })
+})

package/src/Cli.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+import { cac } from 'cac'
+import * as commands from './internal/cli/commands.js'
+import pkgJson from './internal/package.json' with { type: 'json' }
+
+/**
+ * Runs the CLI with the given arguments.
+ *
+ * @param options - Options for running the CLI
+ * @returns Promise that resolves when the CLI completes
+ */
+export async function run(options: run.Options): Promise<void> {
+  const { args } = options
+
+  const cli = cac(pkgJson.name)
+  cli.version(pkgJson.version)
+
+  commands.build(cli.command('[root]', ''))
+  commands.build(cli.command('build', 'Build package'))
+  commands.build(cli.command('dev', 'Resolve package exports to source for development'), {
+    link: true,
+  })
+
+  cli.help()
+  cli.parse(args)
+}
+
+export declare namespace run {
+  type Options = {
+    /** Command-line arguments to parse */
+    args: string[]
+  }
+}
+
+// Run the CLI if this module is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run({ args: process.argv }).catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })
+}

package/src/Package.test.ts

@@ -0,0 +1,102 @@
+import * as fs from 'node:fs/promises'
+import path from 'node:path'
+import { checkOutput, setupRepos, tree } from '../test/utils.js'
+import * as Package from './Package.js'
+
+const repos = () =>
+  setupRepos().then(({ repos }) => repos.filter(({ relative }) => !relative.includes('invalid-')))
+
+describe.each(await repos())('$relative: Package.build', ({ cwd }) => {
+  test('default', async () => {
+    if (cwd.includes('error-')) {
+      await expect(Package.build({ cwd })).rejects.toMatchSnapshot('error')
+      return
+    }
+
+    {
+      const result = await Package.build({
+        cwd,
+      })
+      expect(result).toMatchSnapshot('result')
+    }
+
+    {
+      const result = await checkOutput({ cwd })
+      expect(result).toMatchSnapshot('check')
+    }
+
+    const packageJsonString = await fs.readFile(path.resolve(cwd, 'package.json'), 'utf-8')
+    const packageJson = JSON.parse(packageJsonString)
+    expect([packageJsonString, await tree(cwd)].join('\n\n')).toMatchSnapshot('output')
+    expect(await fs.readFile(path.resolve(cwd, packageJson.main), 'utf-8')).toMatchSnapshot('main')
+    expect(await fs.readFile(path.resolve(cwd, packageJson.types), 'utf-8')).toMatchSnapshot(
+      'types',
+    )
+  })
+
+  test('link', async () => {
+    if (cwd.includes('error-')) return
+
+    const result = await Package.build({
+      cwd,
+      link: true,
+    })
+    expect(result).toMatchSnapshot('result')
+
+    const packageJsonString = await fs.readFile(path.resolve(cwd, 'package.json'), 'utf-8')
+    const packageJson = JSON.parse(packageJsonString)
+    expect([packageJsonString, await tree(cwd)].join('\n\n')).toMatchSnapshot('output')
+
+    // Verify symlinks exist (check exports field for actual symlink locations)
+    const rootExport = packageJson.exports?.['.']
+    const defaultPath =
+      typeof rootExport === 'string'
+        ? rootExport
+        : typeof rootExport === 'object' && rootExport
+          ? rootExport.default
+          : null
+    const typesPath = typeof rootExport === 'object' && rootExport ? rootExport.types : null
+
+    if (defaultPath) {
+      const mainStats = await fs.lstat(path.resolve(cwd, defaultPath))
+      expect(mainStats.isSymbolicLink()).toBe(true)
+      const mainTarget = await fs.readlink(path.resolve(cwd, defaultPath))
+      expect(mainTarget).toMatchSnapshot('main-target')
+    }
+
+    if (typesPath) {
+      const typesStats = await fs.lstat(path.resolve(cwd, typesPath))
+      expect(typesStats.isSymbolicLink()).toBe(true)
+      const typesTarget = await fs.readlink(path.resolve(cwd, typesPath))
+      expect(typesTarget).toMatchSnapshot('types-target')
+    }
+  })
+})
+
+describe('Package.getSourceDir', () => {
+  test('common', async () => {
+    {
+      const result = Package.getSourceDir({
+        entries: [
+          path.resolve(process.cwd(), 'src/index.ts'),
+          path.resolve(process.cwd(), 'src/foo.ts'),
+          path.resolve(process.cwd(), 'src/nested/dir/index.ts'),
+          path.resolve(process.cwd(), 'src/nested/dir/bar.ts'),
+        ],
+      })
+      expect(result).toBe(path.resolve(process.cwd(), 'src'))
+    }
+
+    {
+      const result = Package.getSourceDir({
+        entries: [
+          path.resolve(process.cwd(), 'src/index.ts'),
+          path.resolve(process.cwd(), 'foo.ts'),
+          path.resolve(process.cwd(), 'bar/nested/dir/index.ts'),
+          path.resolve(process.cwd(), 'src/nested/dir/bar.ts'),
+        ],
+      })
+      expect(result).toBe(process.cwd())
+    }
+  })
+})