@pezkuwi/dev 0.84.2

package/scripts/polkadot-ci-ghact-build.mjs

@@ -0,0 +1,540 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import yargs from 'yargs';
+
+import { copyDirSync, copyFileSync, denoCreateDir, execGit, execPm, execSync, exitFatal, GITHUB_REPO, GITHUB_TOKEN_URL, gitSetup, logBin, mkdirpSync, rimrafSync, topoSort } from './util.mjs';
+
+/** @typedef {Record<string, any>} ChangelogMap */
+
+logBin('polkadot-ci-ghact-build');
+
+const DENO_REPO = 'polkadot-js/build-deno.land';
+const BUND_REPO = 'polkadot-js/build-bundle';
+
+const repo = `${GITHUB_TOKEN_URL}/${GITHUB_REPO}.git`;
+const denoRepo = `${GITHUB_TOKEN_URL}/${DENO_REPO}.git`;
+const bundRepo = `${GITHUB_TOKEN_URL}/${BUND_REPO}.git`;
+const bundClone = 'build-bundle-clone';
+const denoClone = 'build-deno-clone';
+
+let withDeno = false;
+let withBund = false;
+let withNpm = false;
+
+/** @type {string[]} */
+const shouldDeno = [];
+/** @type {string[]} */
+const shouldBund = [];
+
+const argv = await yargs(process.argv.slice(2))
+  .options({
+    'skip-beta': {
+      description: 'Do not increment as beta',
+      type: 'boolean'
+    }
+  })
+  .strict()
+  .argv;
+
+/**
+ * Removes a specific file, returning true if found, false otherwise
+ *
+ * @param {string} file
+ * @returns {boolean}
+ */
+function rmFile (file) {
+  if (fs.existsSync(file)) {
+    rimrafSync(file);
+
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Retrieves the path of the root package.json
+ *
+ * @returns {string}
+ */
+function npmGetJsonPath () {
+  return path.resolve(process.cwd(), 'package.json');
+}
+
+/**
+ * Retrieves the contents of the root package.json
+ *
+ * @returns {{ name: string; version: string; versions?: { npm?: string; git?: string } }}
+ */
+function npmGetJson () {
+  return JSON.parse(
+    fs.readFileSync(npmGetJsonPath(), 'utf8')
+  );
+}
+
+/**
+ * Writes the contents of the root package.json
+ *
+ * @param {any} json
+ */
+function npmSetJson (json) {
+  fs.writeFileSync(npmGetJsonPath(), `${JSON.stringify(json, null, 2)}\n`);
+}
+
+/**
+ * Retrieved the current version included in package.json
+ *
+ * @returns {string}
+ */
+function npmGetVersion () {
+  return npmGetJson().version;
+}
+
+/**
+ * Sets the current to have an -x version specifier (aka beta)
+ */
+function npmAddVersionX () {
+  const json = npmGetJson();
+
+  if (!json.version.endsWith('-x')) {
+    json.version = json.version + '-x';
+    npmSetJson(json);
+  }
+}
+
+/**
+ * Removes the current -x version specifier (aka beta)
+ */
+function npmDelVersionX () {
+  const json = npmGetJson();
+
+  if (json.version.endsWith('-x')) {
+    json.version = json.version.replace('-x', '');
+    npmSetJson(json);
+  }
+}
+
+/**
+ * Sets the {versions: { npm, git } } fields in package.json
+ */
+function npmSetVersionFields () {
+  const json = npmGetJson();
+
+  if (!json.versions) {
+    json.versions = {};
+  }
+
+  json.versions.git = json.version;
+
+  if (!json.version.endsWith('-x')) {
+    json.versions.npm = json.version;
+  }
+
+  npmSetJson(json);
+  rmFile('.123current');
+}
+
+/**
+ * Sets the npm token in the home directory
+ */
+function npmSetup () {
+  const registry = 'registry.npmjs.org';
+
+  fs.writeFileSync(path.join(os.homedir(), '.npmrc'), `//${registry}/:_authToken=${process.env['NPM_TOKEN']}`);
+}
+
+/**
+ * Publishes the current package
+ *
+ * @returns {void}
+ */
+function npmPublish () {
+  if (fs.existsSync('.skip-npm') || !withNpm) {
+    return;
+  }
+
+  ['LICENSE', 'package.json']
+    .filter((file) => !fs.existsSync(path.join(process.cwd(), 'build', file)))
+    .forEach((file) => copyFileSync(file, 'build'));
+
+  process.chdir('build');
+
+  const tag = npmGetVersion().includes('-') ? '--tag beta' : '';
+  let count = 1;
+
+  while (true) {
+    try {
+      execSync(`npm publish --quiet --access public ${tag}`);
+
+      break;
+    } catch {
+      if (count < 5) {
+        const end = Date.now() + 15000;
+
+        console.error(`Publish failed on attempt ${count}/5. Retrying in 15s`);
+        count++;
+
+        while (Date.now() < end) {
+          // just spin our wheels
+        }
+      }
+    }
+  }
+
+  process.chdir('..');
+}
+
+/**
+ * Creates a map of changelog entries
+ *
+ * @param {string[][]} parts
+ * @param {ChangelogMap} result
+ * @returns {ChangelogMap}
+ */
+function createChangelogMap (parts, result = {}) {
+  for (let i = 0, count = parts.length; i < count; i++) {
+    const [n, ...e] = parts[i];
+
+    if (!result[n]) {
+      if (e.length) {
+        result[n] = createChangelogMap([e]);
+      } else {
+        result[n] = { '': {} };
+      }
+    } else {
+      if (e.length) {
+        createChangelogMap([e], result[n]);
+      } else {
+        result[n][''] = {};
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Creates an array of changelog entries
+ *
+ * @param {ChangelogMap} map
+ * @returns {string[]}
+ */
+function createChangelogArr (map) {
+  const result = [];
+  const entries = Object.entries(map);
+
+  for (let i = 0, count = entries.length; i < count; i++) {
+    const [name, imap] = entries[i];
+
+    if (name) {
+      if (imap['']) {
+        result.push(name);
+      }
+
+      const inner = createChangelogArr(imap);
+
+      if (inner.length === 1) {
+        result.push(`${name}-${inner[0]}`);
+      } else if (inner.length) {
+        result.push(`${name}-{${inner.join(', ')}}`);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Adds changelog entries
+ *
+ * @param {string[]} changelog
+ * @returns {string}
+ */
+function addChangelog (changelog) {
+  const [version, ...names] = changelog;
+  const entry = `${
+    createChangelogArr(
+      createChangelogMap(
+        names
+          .sort()
+          .map((n) => n.split('-'))
+      )
+    ).join(', ')
+  } ${version}`;
+  const newInfo = `## master\n\n- ${entry}\n`;
+
+  if (!fs.existsSync('CHANGELOG.md')) {
+    fs.writeFileSync('CHANGELOG.md', `# CHANGELOG\n\n${newInfo}`);
+  } else {
+    const md = fs.readFileSync('CHANGELOG.md', 'utf-8');
+
+    fs.writeFileSync('CHANGELOG.md', md.includes('## master\n\n')
+      ? md.replace('## master\n\n', newInfo)
+      : md.replace('# CHANGELOG\n\n', `# CHANGELOG\n\n${newInfo}\n`)
+    );
+  }
+
+  return entry;
+}
+
+/**
+ *
+ * @param {string} repo
+ * @param {string} clone
+ * @param {string[]} names
+ */
+function commitClone (repo, clone, names) {
+  if (names.length) {
+    process.chdir(clone);
+
+    const entry = addChangelog(names);
+
+    gitSetup();
+    execGit('add --all .');
+    execGit(`commit --no-status --quiet -m "${entry}"`);
+    execGit(`push ${repo}`, true);
+
+    process.chdir('..');
+  }
+}
+
+/**
+ * Publishes a specific package to polkadot-js bundles
+ *
+ * @returns {void}
+ */
+function bundlePublishPkg () {
+  const { name, version } = npmGetJson();
+  const dirName = name.split('/')[1];
+  const bundName = `bundle-polkadot-${dirName}.js`;
+  const srcPath = path.join('build', bundName);
+  const dstDir = path.join('../..', bundClone);
+
+  if (!fs.existsSync(srcPath)) {
+    return;
+  }
+
+  console.log(`\n *** bundle ${name}`);
+
+  if (shouldBund.length === 0) {
+    shouldBund.push(version);
+  }
+
+  shouldBund.push(dirName);
+
+  rimrafSync(path.join(dstDir, bundName));
+  copyFileSync(srcPath, dstDir);
+}
+
+/**
+ * Publishes all packages to polkadot-js bundles
+ *
+ * @returns {void}
+ */
+function bundlePublish () {
+  const { version } = npmGetJson();
+
+  if (!withBund && version.includes('-')) {
+    return;
+  }
+
+  execGit(`clone ${bundRepo} ${bundClone}`, true);
+
+  loopFunc(bundlePublishPkg);
+
+  commitClone(bundRepo, bundClone, shouldBund);
+}
+
+/**
+ * Publishes a specific package to Deno
+ *
+ * @returns {void}
+ */
+function denoPublishPkg () {
+  const { name, version } = npmGetJson();
+
+  if (fs.existsSync('.skip-deno') || !fs.existsSync('build-deno')) {
+    return;
+  }
+
+  console.log(`\n *** deno ${name}`);
+
+  const dirName = denoCreateDir(name);
+  const denoPath = `../../${denoClone}/${dirName}`;
+
+  if (shouldDeno.length === 0) {
+    shouldDeno.push(version);
+  }
+
+  shouldDeno.push(dirName);
+
+  rimrafSync(denoPath);
+  mkdirpSync(denoPath);
+
+  copyDirSync('build-deno', denoPath);
+}
+
+/**
+ * Publishes all packages to Deno
+ *
+ * @returns {void}
+ */
+function denoPublish () {
+  const { version } = npmGetJson();
+
+  if (!withDeno && version.includes('-')) {
+    return;
+  }
+
+  execGit(`clone ${denoRepo} ${denoClone}`, true);
+
+  loopFunc(denoPublishPkg);
+
+  commitClone(denoRepo, denoClone, shouldDeno);
+}
+
+/**
+ * Retrieves flags based on current specifications
+ */
+function getFlags () {
+  withDeno = rmFile('.123deno');
+  withBund = rmFile('.123bundle');
+  withNpm = rmFile('.123npm');
+}
+
+/**
+ * Bumps the current version, also applying to all sub-packages
+ */
+function verBump () {
+  const { version: currentVersion, versions } = npmGetJson();
+  const [version, tag] = currentVersion.split('-');
+  const [,, patch] = version.split('.');
+  const lastVersion = versions?.npm || currentVersion;
+
+  if (argv['skip-beta'] || patch === '0') {
+    // don't allow beta versions
+    execPm('polkadot-dev-version patch');
+    withNpm = true;
+  } else if (tag || currentVersion === lastVersion) {
+    // if we don't want to publish, add an X before passing
+    if (!withNpm) {
+      npmAddVersionX();
+    } else {
+      npmDelVersionX();
+    }
+
+    // beta version, just continue the stream of betas
+    execPm('polkadot-dev-version pre');
+  } else {
+    // manually set, got for publish
+    withNpm = true;
+  }
+
+  // always ensure we have made some changes, so we can commit
+  npmSetVersionFields();
+  rmFile('.123trigger');
+
+  execPm('polkadot-dev-contrib');
+  execGit('add --all .');
+}
+
+/**
+ * Commits and pushes the current version on git
+ */
+function gitPush () {
+  const version = npmGetVersion();
+  let doGHRelease = false;
+
+  if (process.env['GH_RELEASE_GITHUB_API_TOKEN']) {
+    const changes = fs.readFileSync('CHANGELOG.md', 'utf8');
+
+    if (changes.includes(`## ${version}`)) {
+      doGHRelease = true;
+    } else if (version.endsWith('.1')) {
+      exitFatal(`Unable to release, no CHANGELOG entry for ${version}`);
+    }
+  }
+
+  execGit('add --all .');
+
+  if (fs.existsSync('docs/README.md')) {
+    execGit('add --all -f docs');
+  }
+
+  // add the skip checks for GitHub ...
+  execGit(`commit --no-status --quiet -m "[CI Skip] ${version.includes('-x') ? 'bump' : 'release'}/${version.includes('-') ? 'beta' : 'stable'} ${version}
+
+
+skip-checks: true"`);
+
+  // Make sure the release commit is on top of the latest master
+  execGit(`pull --rebase ${repo} master`);
+
+  // Now push normally
+  execGit(`push ${repo} HEAD:${process.env['GITHUB_REF']}`, true);
+
+  if (doGHRelease) {
+    const files = process.env['GH_RELEASE_FILES']
+      ? `--assets ${process.env['GH_RELEASE_FILES']}`
+      : '';
+
+    execPm(`polkadot-exec-ghrelease --draft ${files} --yes`);
+  }
+}
+
+/**
+ * Loops through the packages/* (or root), executing the supplied
+ * function for each package found
+ *
+ * @param {() => unknown} fn
+ */
+function loopFunc (fn) {
+  if (fs.existsSync('packages')) {
+    const dirs = fs
+      .readdirSync('packages')
+      .filter((dir) => {
+        const pkgDir = path.join(process.cwd(), 'packages', dir);
+
+        return fs.statSync(pkgDir).isDirectory() &&
+          fs.existsSync(path.join(pkgDir, 'package.json')) &&
+          fs.existsSync(path.join(pkgDir, 'build'));
+      });
+
+    topoSort(dirs)
+      .forEach((dir) => {
+        process.chdir(path.join('packages', dir));
+        fn();
+        process.chdir('../..');
+      });
+  } else {
+    fn();
+  }
+}
+
+// first do infrastructure setup
+gitSetup();
+npmSetup();
+
+// get flags immediate, then adjust
+getFlags();
+verBump();
+
+// perform the actual CI build
+execPm('polkadot-dev-clean-build');
+execPm('lint');
+execPm('test');
+execPm('build');
+
+// publish to all GH repos
+gitPush();
+denoPublish();
+bundlePublish();
+
+// publish to npm
+loopFunc(npmPublish);

package/scripts/polkadot-ci-ghact-docs.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { execPm, GITHUB_REPO, GITHUB_TOKEN_URL, gitSetup, logBin } from './util.mjs';
+
+const repo = `${GITHUB_TOKEN_URL}/${GITHUB_REPO}.git`;
+
+logBin('polkadot-ci-ghact-docs');
+
+gitSetup();
+
+execPm('run docs');
+execPm(`polkadot-exec-ghpages --dotfiles --repo ${repo} --dist ${process.env['GH_PAGES_SRC']} --dest .`, true);

package/scripts/polkadot-ci-ghpages-force.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+
+import { execGit, logBin } from './util.mjs';
+
+logBin('polkadot-ci-ghpages-force');
+
+// ensure we are on master
+execGit('checkout master');
+
+// checkout latest
+execGit('fetch');
+execGit('checkout gh-pages');
+execGit('pull');
+execGit('checkout --orphan gh-pages-temp');
+
+// ignore relevant files
+fs.writeFileSync('.gitignore', `
+.github/
+.vscode/
+.yarn/
+build/
+coverage/
+node_modules/
+packages/
+test/
+NOTES.md
+`);
+
+// add
+execGit('add -A');
+execGit('commit -am "refresh history"');
+
+// danger, force new
+execGit('branch -D gh-pages');
+execGit('branch -m gh-pages');
+execGit('push -f origin gh-pages');
+
+// switch to master
+execGit('checkout master');

package/scripts/polkadot-dev-build-docs.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { copyDirSync, logBin, rimrafSync } from './util.mjs';
+
+logBin('polkadot-dev-build-docs');
+
+let docRoot = path.join(process.cwd(), 'docs');
+
+if (fs.existsSync(docRoot)) {
+  docRoot = path.join(process.cwd(), 'build-docs');
+
+  rimrafSync(docRoot);
+  copyDirSync(path.join(process.cwd(), 'docs'), docRoot);
+}