@regardio/dev 1.13.8 → 1.14.3

package/src/bin/flow/utils.test.ts

@@ -0,0 +1,178 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { bumpVersion, confirm, insertChangelog } from './utils.js';
+
+// ---------------------------------------------------------------------------
+// bumpVersion
+// ---------------------------------------------------------------------------
+
+describe('bumpVersion', () => {
+  it('bumps patch', () => {
+    expect(bumpVersion('1.2.3', 'patch')).toBe('1.2.4');
+  });
+
+  it('bumps minor and resets patch', () => {
+    expect(bumpVersion('1.2.3', 'minor')).toBe('1.3.0');
+  });
+
+  it('bumps major and resets minor + patch', () => {
+    expect(bumpVersion('1.2.3', 'major')).toBe('2.0.0');
+  });
+
+  it('handles zero components', () => {
+    expect(bumpVersion('0.0.0', 'patch')).toBe('0.0.1');
+    expect(bumpVersion('0.0.0', 'minor')).toBe('0.1.0');
+    expect(bumpVersion('0.0.0', 'major')).toBe('1.0.0');
+  });
+
+  it('defaults to patch for unknown bump type', () => {
+    expect(bumpVersion('1.2.3', 'unknown')).toBe('1.2.4');
+  });
+
+  it('throws for invalid semver', () => {
+    expect(() => bumpVersion('not-semver', 'patch')).toThrow('Invalid semver');
+    expect(() => bumpVersion('1.2', 'patch')).toThrow('Invalid semver');
+    expect(() => bumpVersion('1.2.x', 'patch')).toThrow('Invalid semver');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// insertChangelog
+// ---------------------------------------------------------------------------
+
+describe('insertChangelog', () => {
+  let tmpDir: string;
+  let changelogPath: string;
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `flow-utils-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+    changelogPath = join(tmpDir, 'CHANGELOG.md');
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { force: true, recursive: true });
+  });
+
+  it('creates a new file when none exists', () => {
+    insertChangelog(changelogPath, '## [1.0.0] - 2025-01-01\n\n- initial release\n');
+
+    expect(existsSync(changelogPath)).toBe(true);
+    const content = readFileSync(changelogPath, 'utf-8');
+    expect(content).toContain('# Changelog');
+    expect(content).toContain('## [1.0.0] - 2025-01-01');
+  });
+
+  it('inserts before the first existing ## section', () => {
+    writeFileSync(changelogPath, '# Changelog\n\n## [1.0.0] - 2025-01-01\n\n- old entry\n');
+
+    insertChangelog(changelogPath, '## [1.1.0] - 2025-02-01\n\n- new entry\n');
+
+    const content = readFileSync(changelogPath, 'utf-8');
+    const newIdx = content.indexOf('## [1.1.0]');
+    const oldIdx = content.indexOf('## [1.0.0]');
+    expect(newIdx).toBeLessThan(oldIdx);
+  });
+
+  it('appends when no ## section exists yet', () => {
+    writeFileSync(changelogPath, '# Changelog\n');
+
+    insertChangelog(changelogPath, '## [1.0.0] - 2025-01-01\n\n- initial\n');
+
+    const content = readFileSync(changelogPath, 'utf-8');
+    expect(content).toContain('## [1.0.0]');
+  });
+
+  it('preserves existing entries when inserting', () => {
+    writeFileSync(changelogPath, '# Changelog\n\n## [1.0.0] - 2025-01-01\n\n- old entry\n');
+
+    insertChangelog(changelogPath, '## [1.1.0] - 2025-02-01\n\n- new entry\n');
+
+    const content = readFileSync(changelogPath, 'utf-8');
+    expect(content).toContain('## [1.0.0]');
+    expect(content).toContain('- old entry');
+    expect(content).toContain('## [1.1.0]');
+    expect(content).toContain('- new entry');
+  });
+
+  it('appends when file exists but has no title line', () => {
+    writeFileSync(changelogPath, '## [1.0.0] - 2025-01-01\n\n- old entry\n');
+
+    insertChangelog(changelogPath, '## [1.1.0] - 2025-02-01\n\n- new entry\n');
+
+    const content = readFileSync(changelogPath, 'utf-8');
+    expect(content).toContain('## [1.0.0]');
+    expect(content).toContain('## [1.1.0]');
+  });
+
+  it('handles multiple existing entries in the correct order', () => {
+    writeFileSync(
+      changelogPath,
+      '# Changelog\n\n## [1.1.0] - 2025-02-01\n\n- second\n\n## [1.0.0] - 2025-01-01\n\n- first\n',
+    );
+
+    insertChangelog(changelogPath, '## [1.2.0] - 2025-03-01\n\n- third\n');
+
+    const content = readFileSync(changelogPath, 'utf-8');
+    const idx120 = content.indexOf('## [1.2.0]');
+    const idx110 = content.indexOf('## [1.1.0]');
+    const idx100 = content.indexOf('## [1.0.0]');
+    expect(idx120).toBeLessThan(idx110);
+    expect(idx110).toBeLessThan(idx100);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// confirm
+// ---------------------------------------------------------------------------
+
+describe('confirm', () => {
+  let tmpDir: string;
+  let inputFile: string;
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `confirm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+    inputFile = join(tmpDir, 'input');
+    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { force: true, recursive: true });
+    vi.restoreAllMocks();
+  });
+
+  it('returns true for "y"', () => {
+    writeFileSync(inputFile, 'y\n');
+    expect(confirm('Continue?', inputFile)).toBe(true);
+  });
+
+  it('returns true for "Y"', () => {
+    writeFileSync(inputFile, 'Y\n');
+    expect(confirm('Continue?', inputFile)).toBe(true);
+  });
+
+  it('returns false for "n"', () => {
+    writeFileSync(inputFile, 'n\n');
+    expect(confirm('Continue?', inputFile)).toBe(false);
+  });
+
+  it('returns false for empty input', () => {
+    writeFileSync(inputFile, '\n');
+    expect(confirm('Continue?', inputFile)).toBe(false);
+  });
+
+  it('returns false for any other input', () => {
+    writeFileSync(inputFile, 'yes\n');
+    expect(confirm('Continue?', inputFile)).toBe(false);
+  });
+
+  it('writes the prompt to stdout', () => {
+    writeFileSync(inputFile, 'y\n');
+    confirm('Ship it?', inputFile);
+    expect(process.stdout.write).toHaveBeenCalledWith('Ship it? (y/N) ');
+  });
+});

package/src/bin/flow/utils.ts

@@ -0,0 +1,109 @@
+/**
+ * Shared utilities for flow-release, flow-ship, and flow-hotfix.
+ *
+ * Git commands use execFileSync (not a shell string) so user-provided
+ * strings such as commit messages are never interpolated by the shell.
+ * pnpm script invocations use execSync via shell since script names are
+ * developer-controlled and pnpm itself is resolved through PATH.
+ */
+import { execFileSync, execSync } from 'node:child_process';
+import { closeSync, existsSync, openSync, readFileSync, readSync, writeFileSync } from 'node:fs';
+
+/**
+ * Run a git command with the given arguments.
+ * Output is inherited (visible to the user).
+ */
+export const git = (...args: string[]): void => {
+  console.log(`$ git ${args.join(' ')}`);
+  execFileSync('git', args, { stdio: 'inherit' });
+};
+
+/**
+ * Run a git command and return trimmed stdout.
+ * Stderr is suppressed; throws on non-zero exit.
+ */
+export const gitRead = (...args: string[]): string =>
+  execFileSync('git', args, { encoding: 'utf-8' }).trim();
+
+/**
+ * Run a pnpm script via the shell.
+ * Only pass developer-controlled script names — never user input.
+ */
+export const runScript = (script: string): void => {
+  console.log(`$ pnpm ${script}`);
+  execSync(`pnpm ${script}`, { stdio: 'inherit' });
+};
+
+/**
+ * Bump a semver string by the given increment type.
+ */
+export const bumpVersion = (current: string, bump: string): string => {
+  const parts = current.split('.').map(Number);
+  if (parts.length !== 3 || parts.some(Number.isNaN)) {
+    throw new Error(`Invalid semver: ${current}`);
+  }
+  const [major, minor, patch] = parts as [number, number, number];
+  if (bump === 'major') return `${major + 1}.0.0`;
+  if (bump === 'minor') return `${major}.${minor + 1}.0`;
+  return `${major}.${minor}.${patch + 1}`;
+};
+
+/**
+ * Insert a new changelog entry after the title line of CHANGELOG.md.
+ * Creates the file if it does not exist.
+ */
+export const insertChangelog = (changelogPath: string, entry: string): void => {
+  if (existsSync(changelogPath)) {
+    const existing = readFileSync(changelogPath, 'utf-8');
+    const insertAt = existing.indexOf('\n## ');
+    if (insertAt === -1) {
+      writeFileSync(changelogPath, `${existing.trimEnd()}\n\n${entry}`);
+    } else {
+      writeFileSync(
+        changelogPath,
+        `${existing.slice(0, insertAt)}\n\n${entry}${existing.slice(insertAt + 1)}`,
+      );
+    }
+  } else {
+    writeFileSync(changelogPath, `# Changelog\n\n${entry}`);
+  }
+};
+
+/**
+ * Run quality checks. Throws if any step fails.
+ */
+export const runQualityChecks = (): void => {
+  runScript('build');
+  runScript('typecheck');
+  runScript('report');
+};
+
+/**
+ * Check whether a branch exists locally or on origin.
+ * Requires a prior `git fetch` to have up-to-date remote refs.
+ */
+export const branchExists = (name: string): boolean =>
+  gitRead('branch', '--list', name) !== ''
+  || gitRead('branch', '--list', '--remotes', `origin/${name}`) !== '';
+
+/**
+ * Prompt the user for confirmation and return true only if they type "y" or "Y".
+ * Defaults to "no" on empty input, so pressing Enter alone aborts.
+ * The ttyPath parameter is injectable for testing.
+ */
+export const confirm = (prompt: string, ttyPath = '/dev/tty'): boolean => {
+  process.stdout.write(`${prompt} (y/N) `);
+  const buf = Buffer.alloc(1024);
+  let fd: number;
+  let shouldClose = false;
+  try {
+    fd = openSync(ttyPath, 'r');
+    shouldClose = true;
+  } catch {
+    fd = process.stdin.fd;
+  }
+  const bytesRead = readSync(fd, buf, 0, buf.length, null);
+  if (shouldClose) closeSync(fd);
+  const answer = buf.slice(0, bytesRead).toString().trim();
+  return answer === 'y' || answer === 'Y';
+};

package/src/bin/lint/package.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+
+import { reorderConditions } from './package.js';
+
+describe('lint-package', () => {
+  describe('reorderConditions', () => {
+    it('reorders types before default when default comes first', () => {
+      const input = {
+        './foo': {
+          default: './dist/foo.js',
+          types: './dist/foo.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+
+      expect(Object.keys(result['./foo'] as Record<string, unknown>)).toEqual(['types', 'default']);
+    });
+
+    it('does not modify when types already comes before default', () => {
+      const input = {
+        './foo': {
+          default: './dist/foo.js',
+          types: './dist/foo.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+
+      expect(Object.keys(result['./foo'] as Record<string, unknown>)).toEqual(['types', 'default']);
+    });
+
+    it('handles multiple exports with mixed order', () => {
+      const input = {
+        './a': { default: './dist/a.js', types: './dist/a.d.ts' },
+        './b': { default: './dist/b.js', types: './dist/b.d.ts' },
+      };
+
+      const result = reorderConditions(input);
+
+      expect(Object.keys(result['./a'] as Record<string, unknown>)[0]).toBe('types');
+      expect(Object.keys(result['./b'] as Record<string, unknown>)[0]).toBe('types');
+    });
+
+    it('preserves other keys after types', () => {
+      const input = {
+        './foo': {
+          default: './dist/foo.js',
+          import: './dist/foo.mjs',
+          require: './dist/foo.cjs',
+          types: './dist/foo.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+      const keys = Object.keys(result['./foo'] as Record<string, unknown>);
+
+      expect(keys[0]).toBe('types');
+      expect(keys.slice(1)).toEqual(['default', 'import', 'require']);
+    });
+
+    it('handles exports without types or default', () => {
+      const input = { './styles.css': './dist/styles.css' };
+
+      expect(reorderConditions(input)).toEqual(input);
+    });
+
+    it('handles deeply nested condition objects', () => {
+      const input = {
+        './foo': {
+          browser: { default: './dist/foo.browser.js', types: './dist/foo.browser.d.ts' },
+          node: { default: './dist/foo.node.js', types: './dist/foo.node.d.ts' },
+        },
+      };
+
+      const result = reorderConditions(input);
+      const foo = result['./foo'] as Record<string, Record<string, unknown>>;
+
+      expect(Object.keys(foo.node as object)[0]).toBe('types');
+      expect(Object.keys(foo.browser as object)[0]).toBe('types');
+    });
+  });
+});

package/src/bin/lint/package.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * Sorts package.json files using sort-package-json and fixes
+ * exports condition order (types must come before default for TypeScript).
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Recursively reorder exports condition objects so that `types` always
+ * appears before `default`. Returns a new object; does not mutate input.
+ */
+export function reorderConditions(obj: Record<string, unknown>): Record<string, unknown> {
+  if (typeof obj !== 'object' || obj === null) return obj;
+
+  const processed: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    processed[key] =
+      typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? reorderConditions(value as Record<string, unknown>)
+        : value;
+  }
+
+  if ('types' in processed && 'default' in processed) {
+    const keys = Object.keys(processed);
+    if (keys.indexOf('default') < keys.indexOf('types')) {
+      const reordered: Record<string, unknown> = { types: processed.types };
+      for (const key of keys) {
+        if (key !== 'types') reordered[key] = processed[key];
+      }
+      return reordered;
+    }
+  }
+
+  return processed;
+}
+
+/**
+ * Fix exports condition order in a package.json file.
+ * Returns true if the file needs changes (or was changed when fix=true).
+ */
+export function fixExportsOrder(filePath: string, fix: boolean): boolean {
+  const fullPath = resolve(process.cwd(), filePath);
+  if (!existsSync(fullPath)) return false;
+
+  const content = readFileSync(fullPath, 'utf-8');
+  const pkg = JSON.parse(content) as Record<string, unknown>;
+
+  if (!pkg.exports || typeof pkg.exports !== 'object') return false;
+
+  const fixed = reorderConditions(pkg.exports as Record<string, unknown>);
+  const changed = JSON.stringify(fixed) !== JSON.stringify(pkg.exports);
+
+  if (changed && fix) {
+    writeFileSync(fullPath, `${JSON.stringify({ ...pkg, exports: fixed }, null, 2)}\n`);
+  }
+
+  return changed;
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point — only runs when executed directly
+// ---------------------------------------------------------------------------
+if (fileURLToPath(import.meta.url) === resolve(process.argv[1] ?? '')) {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const devRoot = resolve(__dirname, '../../..');
+
+  const sortPkgBin = join(devRoot, 'node_modules/.bin/sort-package-json');
+  const sortPkgBinAlt = join(devRoot, 'node_modules/sort-package-json/cli.js');
+
+  let bin = '';
+  if (existsSync(sortPkgBin)) {
+    bin = sortPkgBin;
+  } else if (existsSync(sortPkgBinAlt)) {
+    bin = `node ${sortPkgBinAlt}`;
+  } else {
+    bin = 'npx sort-package-json';
+  }
+
+  const args = process.argv.slice(2);
+  const fixMode = args.includes('--fix');
+  const files = args.filter((arg) => arg !== '--fix');
+  const targets = files.length > 0 ? files : ['package.json'];
+
+  try {
+    const checkFlag = fixMode ? '' : '--check';
+    execSync(`${bin} ${checkFlag} ${targets.join(' ')}`.trim(), { stdio: 'inherit' });
+  } catch {
+    process.exit(1);
+  }
+
+  let hasExportsIssues = false;
+  for (const file of targets) {
+    const needsFix = fixExportsOrder(file, fixMode);
+    if (needsFix && !fixMode) {
+      console.error(
+        `${file}: exports condition order is incorrect (types must come before default)`,
+      );
+      hasExportsIssues = true;
+    }
+  }
+
+  if (hasExportsIssues) {
+    process.exit(1);
+  }
+}

package/src/templates/release.yml

@@ -2,21 +2,23 @@
 # Copy this file to .github/workflows/release.yml in your package
 #
 # Required setup:
-# 1. Create .changeset/config.json (see changeset-config.json template)
-# 2. Add "release": "flow-release" to package.json scripts
-# 3. First publish must be done locally (see docs/toolchain/changesets.md)
+# 1. Add "flow:release": "flow-release", "flow:ship": "flow-ship" to package.json scripts
+# 2. Create staging and production branches:
+#    git checkout -b staging && git push -u origin staging
+#    git checkout -b production && git push -u origin production
+# 3. First npm publish must be done locally:
+#    pnpm build && npm publish --access public
 #
 # Usage:
-# - Run `pnpm release patch|minor|major "message"` locally
-# - Push to main branch
-# - This workflow publishes to npm and creates a GitHub release
+# - Run `pnpm flow:release "message"` to deploy changes to staging
+# - Run `pnpm flow:ship patch|minor|major` to version, promote to production, and trigger this workflow
 
 name: Release
 
 on:
   push:
     branches:
-      - main
+      - production
 
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 
@@ -26,7 +28,6 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-      pull-requests: write
       id-token: write
     steps:
       - name: Checkout
@@ -52,14 +53,10 @@ jobs:
       - name: Build
         run: pnpm build
 
-      - name: Type check
-        run: pnpm typecheck
-
-      - name: Test with coverage
-        run: pnpm report
-
       - name: Publish to npm
         id: publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: |
           PACKAGE_NAME=$(node -p "require('./package.json').name")
           CURRENT_VERSION=$(node -p "require('./package.json').version")
@@ -71,7 +68,7 @@ jobs:
             echo "::error::Run: pnpm build && npm publish --access public"
             exit 1
           elif [ "$PUBLISHED_VERSION" != "$CURRENT_VERSION" ]; then
-            echo "Publishing $PACKAGE_NAME@$CURRENT_VERSION (npm has v$PUBLISHED_VERSION)"
+            echo "Publishing $PACKAGE_NAME@$CURRENT_VERSION (npm has $PUBLISHED_VERSION)"
             npm publish --access public --provenance
             echo "published=true" >> $GITHUB_OUTPUT
           else
@@ -79,13 +76,22 @@ jobs:
             echo "published=false" >> $GITHUB_OUTPUT
           fi
 
+      - name: Extract changelog entry
+        if: steps.publish.outputs.published == 'true'
+        id: changelog
+        run: |
+          # Extract the top section of CHANGELOG.md (from first ## heading to the next one)
+          ENTRY=$(awk '/^## /{found++} found==1{print} found==2{exit}' CHANGELOG.md)
+          echo "entry<<EOF" >> $GITHUB_OUTPUT
+          echo "$ENTRY" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
       - name: Create GitHub Release
         if: steps.publish.outputs.published == 'true'
         uses: softprops/action-gh-release@v2
         with:
           tag_name: v${{ steps.publish.outputs.current_version }}
           name: v${{ steps.publish.outputs.current_version }}
-          body_path: CHANGELOG.md
-          generate_release_notes: true
+          body: ${{ steps.changelog.outputs.entry }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/dist/bin/exec-clean.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=exec-clean.d.ts.map

package/dist/bin/exec-clean.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-clean.d.ts","sourceRoot":"","sources":["../../src/bin/exec-clean.ts"],"names":[],"mappings":""}

package/dist/bin/exec-clean.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-const require = createRequire(import.meta.url);
-const pkgPath = require.resolve('rimraf/package.json');
-const pkg = require(pkgPath);
-let binRel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.rimraf;
-if (!binRel) {
-    console.error('Unable to locate rimraf binary from package.json bin field');
-    process.exit(1);
-}
-if (binRel.startsWith('./'))
-    binRel = binRel.slice(2);
-const bin = path.join(path.dirname(pkgPath), binRel);
-const args = process.argv.slice(2);
-const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit' });
-child.on('exit', (code) => process.exit(code ?? 0));

package/dist/bin/exec-husky.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=exec-husky.d.ts.map

package/dist/bin/exec-husky.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-husky.d.ts","sourceRoot":"","sources":["../../src/bin/exec-husky.ts"],"names":[],"mappings":""}

package/dist/bin/exec-p.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=exec-p.d.ts.map

package/dist/bin/exec-p.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-p.d.ts","sourceRoot":"","sources":["../../src/bin/exec-p.ts"],"names":[],"mappings":""}

package/dist/bin/exec-s.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=exec-s.d.ts.map

package/dist/bin/exec-s.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-s.d.ts","sourceRoot":"","sources":["../../src/bin/exec-s.ts"],"names":[],"mappings":""}

package/dist/bin/exec-ts.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=exec-ts.d.ts.map

package/dist/bin/exec-ts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-ts.d.ts","sourceRoot":"","sources":["../../src/bin/exec-ts.ts"],"names":[],"mappings":""}

package/dist/bin/exec-ts.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-const args = process.argv.slice(2);
-if (args.length === 0) {
-    console.error('Usage: exec-ts <script.ts> [args...]');
-    process.exit(1);
-}
-const [scriptArg, ...rest] = args;
-const script = scriptArg ?? '';
-const require = createRequire(import.meta.url);
-const pkgPath = require.resolve('tsx/package.json');
-const pkg = require(pkgPath);
-const binRel = pkg.bin;
-const binPath = typeof binRel === 'string'
-    ? binRel
-    : typeof binRel === 'object' && binRel !== null && 'tsx' in binRel
-        ? binRel.tsx
-        : undefined;
-if (!binPath) {
-    console.error('Unable to locate tsx binary from package.json bin field');
-    process.exit(1);
-}
-const bin = path.join(path.dirname(pkgPath), binPath);
-const spawnOptions = { stdio: 'inherit' };
-const child = spawn(process.execPath, [bin, script, ...rest], spawnOptions);
-child.on('exit', (code) => process.exit(code ?? 0));

package/dist/bin/exec-tsc.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=exec-tsc.d.ts.map

package/dist/bin/exec-tsc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-tsc.d.ts","sourceRoot":"","sources":["../../src/bin/exec-tsc.ts"],"names":[],"mappings":""}

package/dist/bin/flow-changeset.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=flow-changeset.d.ts.map

package/dist/bin/flow-changeset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow-changeset.d.ts","sourceRoot":"","sources":["../../src/bin/flow-changeset.ts"],"names":[],"mappings":""}