@naturalcycles/dev-lib 20.52.2 → 20.53.0

package/dist/bin/dev-lib.js

@@ -2,7 +2,7 @@ import { _by } from '@naturalcycles/js-lib/array/array.util.js';
 import { _assert } from '@naturalcycles/js-lib/error/assert.js';
 import { fs2 } from '@naturalcycles/nodejs-lib/fs2';
 import { runScript } from '@naturalcycles/nodejs-lib/runScript';
-import { buildCopy, buildProd, eslintAll, lintStagedCommand, runCheck, runOxfmt, runOxlint, runTest, stylelintAll, typecheckWithTS, typecheckWithTSC, typecheckWithTSGO, } from '../check.util.js';
+import { buildCopy, buildProd, eslintAll, lintStagedCommand, runCheck, runOxfmt, runOxlint, runTest, stylelintAll, runTypecheck, } from '../check.util.js';
 import { runCommitlint } from '../commitlint.command.js';
 import { releaseCommand } from '../release/release.command.js';
 const commands = [
@@ -15,23 +15,13 @@ const commands = [
     { name: 'bt', fn: bt, desc: 'Build & Test: run "typecheck" and then "test".' },
     {
         name: 'typecheck',
-        fn: typecheckWithTS,
-        desc: 'Run typecheck via tsgo (if available) or tsc',
-    },
-    {
-        name: 'typecheck-with-tsc',
-        fn: typecheckWithTSC,
-        desc: 'Run typecheck (tsc) in folders (src, scripts, e2e) if there is tsconfig.json present.',
-    },
-    {
-        name: 'typecheck-with-tsgo',
-        fn: typecheckWithTSGO,
-        desc: 'Run typecheck (tsgo) in folders (src, scripts, e2e) if there is tsconfig.json present.',
+        fn: runTypecheck,
+        desc: 'Run typecheck',
     },
     {
         name: 'build',
         fn: buildProd,
-        desc: 'Run "build-copy" then tsgo with --emit and --noCheck, using tsconfig.prod.json',
+        desc: 'Run "build-copy" then tsc with --emit and --noCheck, using tsconfig.prod.json',
     },
     {
         name: 'build-copy',
@@ -170,7 +160,7 @@ async function quickCheck() {
 async function bt() {
     // Still using ts, as oxlint is found to fail in certain cases
     // await typecheckWithOxlint()
-    await typecheckWithTS();
+    await runTypecheck();
     runTest();
 }
 // async function _typecheckWithOxlint(): Promise<void> {

package/dist/check.util.d.ts

@@ -9,13 +9,7 @@ export interface CheckOptions {
     stylelint?: boolean;
     oxfmt?: boolean;
     ktlint?: boolean;
-    /**
-     * true - run tsgo, otherwise tsc
-     * tsgo - run tsgo
-     * tsc - run tsc
-     * false - skip
-     */
-    typecheck?: boolean | 'tsc' | 'tsgo';
+    typecheck?: boolean;
     test?: boolean;
 }
 /**
@@ -53,22 +47,12 @@ export declare function lintStagedCommand(): Promise<void>;
 export declare function requireActionlintVersion(): void;
 export declare function getActionLintVersion(): SemVerString | undefined;
 export declare function buildProd(): void;
-/**
- * Uses tsgo if it's installed, otherwise tsc
- */
-export declare function typecheckWithTS(): Promise<void>;
-export declare function typecheckWithTSC(): Promise<void>;
-export declare function typecheckWithTSGO(): Promise<void>;
+export declare function runTypecheck(): Promise<void>;
 /**
  * Use 'src' to indicate root.
  */
 export declare function runTSCInFolders(dirs: string[], args?: string[], parallel?: boolean): Promise<void>;
-/**
- * Use 'src' to indicate root.
- */
-export declare function runTSGOInFolders(dirs: string[], args?: string[]): Promise<void>;
 export declare function runTSCProd(args?: string[]): void;
-export declare function runTSGOProd(args?: string[]): void;
 export declare function buildCopy(): void;
 interface RunTestOptions {
     integration?: boolean;

package/dist/check.util.js

@@ -88,18 +88,8 @@ export async function runCheck(opt = {}) {
     }
     if (typecheck) {
         s = Date.now();
-        if (typecheck === 'tsgo') {
-            await typecheckWithTSGO();
-            timings['tsgo'] = Date.now() - s;
-        }
-        else if (typecheck === 'tsc') {
-            await typecheckWithTSC();
-            timings['tsc'] = Date.now() - s;
-        }
-        else {
-            await typecheckWithTS();
-            timings['typecheck'] = Date.now() - s;
-        }
+        await runTypecheck();
+        timings['tsc'] = Date.now() - s;
     }
     if (test) {
         s = Date.now();
@@ -322,30 +312,11 @@ export function getActionLintVersion() {
 export function buildProd() {
     // fs2.emptyDir('./dist') // it doesn't delete the dir itself, to prevent IDE jumping
     buildCopy();
-    if (hasDependencyInNodeModules('@typescript/native-preview')) {
-        // now we trust tsgo to run prod builds
-        runTSGOProd();
-    }
-    else {
-        runTSCProd();
-    }
+    runTSCProd();
 }
-/**
- * Uses tsgo if it's installed, otherwise tsc
- */
-export async function typecheckWithTS() {
-    if (hasDependencyInNodeModules('@typescript/native-preview')) {
-        await typecheckWithTSGO();
-        return;
-    }
-    await typecheckWithTSC();
-}
-export async function typecheckWithTSC() {
+export async function runTypecheck() {
     await runTSCInFolders(['src', 'scripts', 'e2e'], ['--noEmit']);
 }
-export async function typecheckWithTSGO() {
-    await runTSGOInFolders(['src', 'scripts', 'e2e'], ['--noEmit', '--incremental', 'false']);
-}
 /**
  * Use 'src' to indicate root.
  */
@@ -381,34 +352,6 @@ async function runTSCInFolder(dir, args = []) {
         shell: false,
     });
 }
-/**
- * Use 'src' to indicate root.
- */
-export async function runTSGOInFolders(dirs, args = []) {
-    // Run sequential, since tsgo (unlike tsc) uses all cpu cores already
-    for (const dir of dirs) {
-        await runTSGOInFolder(dir, args);
-    }
-}
-/**
- * Pass 'src' to run in root.
- */
-async function runTSGOInFolder(dir, args = []) {
-    let configDir = dir;
-    if (dir === 'src') {
-        configDir = '';
-    }
-    const tsconfigPath = [configDir, 'tsconfig.json'].filter(Boolean).join('/');
-    if (!fs2.pathExists(tsconfigPath) || !fs2.pathExists(dir)) {
-        // console.log(`Skipping to run tsgo for ${tsconfigPath}, as it doesn't exist`)
-        return;
-    }
-    const tsgoPath = findPackageBinPath('@typescript/native-preview', 'tsgo');
-    await exec2.spawnAsync(tsgoPath, {
-        args: ['-P', tsconfigPath, ...args],
-        shell: false,
-    });
-}
 export function runTSCProd(args = []) {
     const tsconfigPath = [`./tsconfig.prod.json`].find(p => fs2.pathExists(p)) || 'tsconfig.json';
     const tscPath = findPackageBinPath('typescript', 'tsc');
@@ -417,14 +360,6 @@ export function runTSCProd(args = []) {
         shell: false,
     });
 }
-export function runTSGOProd(args = []) {
-    const tsconfigPath = [`./tsconfig.prod.json`].find(p => fs2.pathExists(p)) || 'tsconfig.json';
-    const tsgoPath = findPackageBinPath('@typescript/native-preview', 'tsgo');
-    exec2.spawn(tsgoPath, {
-        args: ['-P', tsconfigPath, '--noEmit', 'false', '--noCheck', '--incremental', 'false', ...args],
-        shell: false,
-    });
-}
 export function buildCopy() {
     const baseDir = 'src';
     const inputPatterns = [

package/dist/release/git.util.d.ts

@@ -8,14 +8,18 @@ export declare function getCurrentBranch(): string;
 /**
  * Make sure the full git history and all tags are available:
  * CI checkouts are often shallow and without tags, while release calculation is based on tags.
- * Tolerates fetch failures (e.g. offline local dry-run) with a warning.
+ *
+ * On a complete (non-shallow) clone a failed fetch is tolerated with a warning (e.g. offline
+ * local dry-run) - the local tags are complete enough. On a shallow clone a failed unshallow
+ * is fatal: a truncated history hides release tags and would make a released package look like
+ * a first release, publishing a wrong version.
  */
-export declare function ensureFullGitHistory(): void;
+export declare function ensureFullGitHistory(repo: RepoInfo): void;
 /**
  * Abort if someone pushed to the branch since this checkout - releasing from a stale HEAD
  * would compute wrong versions/notes. No-op if the branch has no remote counterpart.
  */
-export declare function checkHeadIsUpToDateWithRemote(branch: string): void;
+export declare function checkHeadIsUpToDateWithRemote(branch: string, repo: RepoInfo): void;
 /**
  * All git tags reachable from HEAD.
  * Reachability matters: on a prerelease branch this naturally excludes tags of other
@@ -29,7 +33,5 @@ export declare function getReachableTags(): string[];
 export declare function getCommitsSince(tag: string | undefined, relativeDir?: string): RawCommit[];
 /**
  * Create the release tag on HEAD and push it to origin.
- * Uses a token-authenticated url when GITHUB_TOKEN is available,
- * since CI checkouts don't persist git credentials.
  */
 export declare function createAndPushTag(tag: string, repo: RepoInfo): void;

package/dist/release/git.util.js

@@ -24,33 +24,52 @@ export function getCurrentBranch() {
 /**
  * Make sure the full git history and all tags are available:
  * CI checkouts are often shallow and without tags, while release calculation is based on tags.
- * Tolerates fetch failures (e.g. offline local dry-run) with a warning.
+ *
+ * On a complete (non-shallow) clone a failed fetch is tolerated with a warning (e.g. offline
+ * local dry-run) - the local tags are complete enough. On a shallow clone a failed unshallow
+ * is fatal: a truncated history hides release tags and would make a released package look like
+ * a first release, publishing a wrong version.
  */
-export function ensureFullGitHistory() {
-    try {
-        const shallow = exec2.exec('git rev-parse --is-shallow-repository').trim() === 'true';
-        if (shallow) {
-            exec2.exec('git fetch --unshallow --tags --quiet', { log: true });
+export function ensureFullGitHistory(repo) {
+    // Fetch from an authenticated url, not `origin`: private repos reject unauthenticated fetches,
+    // and CI checkouts don't persist git credentials (persist-credentials: false).
+    const remote = getAuthenticatedRemote(repo);
+    const shallow = exec2.exec('git rev-parse --is-shallow-repository').trim() === 'true';
+    if (shallow) {
+        console.log(dimGrey('git fetch --unshallow --tags'));
+        try {
+            exec2.exec(`git fetch --unshallow --tags --quiet "${remote}"`);
         }
-        else {
-            exec2.exec('git fetch --tags --quiet', { log: true });
+        catch {
+            // Sanitized: the original error contains the failed command incl. the token
+            throw new Error('git fetch --unshallow failed - refusing to release with a shallow git history, as version calculation depends on it');
         }
     }
-    catch (err) {
-        console.log(dimGrey(`git fetch failed, continuing with local tags/history: ${err}`));
+    else {
+        console.log(dimGrey('git fetch --tags'));
+        try {
+            exec2.exec(`git fetch --tags --quiet "${remote}"`);
+        }
+        catch {
+            console.log(dimGrey('git fetch --tags failed, continuing with local tags/history'));
+        }
     }
 }
 /**
  * Abort if someone pushed to the branch since this checkout - releasing from a stale HEAD
  * would compute wrong versions/notes. No-op if the branch has no remote counterpart.
  */
-export function checkHeadIsUpToDateWithRemote(branch) {
+export function checkHeadIsUpToDateWithRemote(branch, repo) {
+    const remote = getAuthenticatedRemote(repo);
     let remoteSha;
     try {
-        remoteSha = exec2.exec(`git ls-remote origin "refs/heads/${branch}"`).split('\t')[0]?.trim();
+        remoteSha = exec2
+            .exec(`git ls-remote "${remote}" "refs/heads/${branch}"`)
+            .split('\t')[0]
+            ?.trim();
     }
-    catch (err) {
-        console.log(dimGrey(`git ls-remote failed, skipping up-to-date check: ${err}`));
+    catch {
+        console.log(dimGrey('git ls-remote failed, skipping up-to-date check'));
         return;
     }
     if (!remoteSha)
@@ -91,20 +110,26 @@ export function getCommitsSince(tag, relativeDir) {
 }
 /**
  * Create the release tag on HEAD and push it to origin.
- * Uses a token-authenticated url when GITHUB_TOKEN is available,
- * since CI checkouts don't persist git credentials.
  */
 export function createAndPushTag(tag, repo) {
     exec2.exec(`git tag "${tag}"`);
-    const token = process.env['GITHUB_TOKEN'] || process.env['GH_TOKEN'];
-    const pushUrl = token
-        ? `https://x-access-token:${token}@github.com/${repo.owner}/${repo.repo}.git`
-        : 'origin';
     try {
-        exec2.exec(`git push "${pushUrl}" "refs/tags/${tag}"`);
+        exec2.exec(`git push "${getAuthenticatedRemote(repo)}" "refs/tags/${tag}"`);
     }
     catch {
         // Sanitized rethrow: the original error message contains the failed command incl. the token
         throw new Error(`Failed to push tag ${tag} to origin`);
     }
 }
+/**
+ * Token-authenticated remote url when GITHUB_TOKEN is available, `origin` otherwise.
+ * CI checkouts don't persist git credentials (persist-credentials: false), so all remote
+ * git operations (fetch, ls-remote, push) go through this.
+ * NEVER log commands containing this url, and sanitize their errors - they carry the token.
+ */
+function getAuthenticatedRemote(repo) {
+    const token = process.env['GITHUB_TOKEN'] || process.env['GH_TOKEN'];
+    return token
+        ? `https://x-access-token:${token}@github.com/${repo.owner}/${repo.repo}.git`
+        : 'origin';
+}

package/dist/release/release.command.js

@@ -50,9 +50,9 @@ export async function releaseCommand() {
     if (!dryRun) {
         _assert(token, 'GITHUB_TOKEN (or GH_TOKEN) is required to release, or use --dry-run');
     }
-    ensureFullGitHistory();
+    ensureFullGitHistory(repo);
     if (!dryRun) {
-        checkHeadIsUpToDateWithRemote(branch);
+        checkHeadIsUpToDateWithRemote(branch, repo);
     }
     const mode = resolveReleaseMode(cfg.mode);
     const packages = discoverReleasePackages(mode, argv.filter);

package/dist/release/version.util.js

@@ -49,9 +49,12 @@ export function getNextVersion(input) {
     const { prereleaseId } = channel;
     if (!lastRelease) {
         const { firstReleaseVersion } = input;
+        // 0.0.0 is the "version is managed by git tags" placeholder, never a real first release
         const first = (firstReleaseVersion &&
             !semver.prerelease(firstReleaseVersion) &&
-            semver.valid(firstReleaseVersion)) ||
+            semver.valid(firstReleaseVersion) &&
+            semver.gt(firstReleaseVersion, '0.0.0') &&
+            firstReleaseVersion) ||
             '1.0.0';
         return prereleaseId ? `${first}-${prereleaseId}.1` : first;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/dev-lib",
   "type": "module",
-  "version": "20.52.2",
+  "version": "20.53.0",
   "dependencies": {
     "prompts": "^2",
     "@naturalcycles/js-lib": "^15",
@@ -19,7 +19,7 @@
   },
   "peerDependencies": {
     "@eslint/js": "^10",
-    "typescript": "^7.0.1-rc",
+    "typescript": "^7",
     "eslint": "^10",
     "husky": "^9",
     "stylelint": "^17",
@@ -51,7 +51,7 @@
     "@types/picomatch": "^4",
     "@types/prompts": "^2",
     "@types/semver": "^7",
-    "typescript": "rc"
+    "typescript": "^7"
   },
   "exports": {
     "./cfg/": "./cfg/",