@pezkuwi/dev 0.84.2

package/scripts/polkadot-dev-circular.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// @ts-expect-error For scripts we don't include @types/* definitions
+import madge from 'madge';
+
+import { exitFatal, logBin } from './util.mjs';
+
+logBin('polkadot-dev-circular');
+
+const res = await madge('./', { fileExtensions: ['ts', 'tsx'] });
+
+/** @type {string[][]} */
+const circular = res.circular();
+
+if (!circular.length) {
+  process.stdout.write('No circular dependency found!\n');
+  process.exit(0);
+}
+
+const err = `Failed with ${circular.length} circular dependencies`;
+const all = circular
+  .map((files, idx) => `${(idx + 1).toString().padStart(4)}: ${files.join(' > ')}`)
+  .join('\n');
+
+process.stdout.write(`\n${err}:\n\n${all}\n\n`);
+
+exitFatal(err);

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

@@ -0,0 +1,61 @@
+#!/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 { logBin, PATHS_BUILD, rimrafSync } from './util.mjs';
+
+const PKGS = path.join(process.cwd(), 'packages');
+const DIRS = PATHS_BUILD.map((d) => `build${d}`);
+
+logBin('polkadot-dev-clean-build');
+
+/**
+ * @internal
+ *
+ * Retrieves all the files containing tsconfig.*.tsbuildinfo contained withing the directory
+ *
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function getPaths (dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(dir)
+    .reduce((all, p) => {
+      if (p.startsWith('tsconfig.') && p.endsWith('.tsbuildinfo')) {
+        all.push(path.join(dir, p));
+      }
+
+      return all;
+    }, DIRS.map((p) => path.join(dir, p)));
+}
+
+/**
+ * @internal
+ *
+ * Removes all the specified directories
+ *
+ * @param {string[]} dirs
+ */
+function cleanDirs (dirs) {
+  dirs.forEach((d) => rimrafSync(d));
+}
+
+cleanDirs(getPaths(process.cwd()));
+
+if (fs.existsSync(PKGS)) {
+  cleanDirs(getPaths(PKGS));
+  cleanDirs(
+    fs
+      .readdirSync(PKGS)
+      .map((f) => path.join(PKGS, f))
+      .filter((f) => fs.statSync(f).isDirectory())
+      .reduce((/** @type {string[]} */ res, d) => res.concat(getPaths(d)), [])
+  );
+}

package/scripts/polkadot-dev-contrib.mjs

@@ -0,0 +1,74 @@
+#!/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, mkdirpSync } from './util.mjs';
+
+const tmpDir = 'packages/build';
+const tmpFile = `${tmpDir}/CONTRIBUTORS`;
+
+logBin('polkadot-dev-contrib');
+
+mkdirpSync(tmpDir);
+execGit(`shortlog master -e -n -s > ${tmpFile}`);
+
+fs.writeFileSync(
+  'CONTRIBUTORS',
+  Object
+    .entries(
+      fs
+        .readFileSync(tmpFile, 'utf-8')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => !!l)
+        .reduce((/** @type {Record<string, { count: number; name: string; }>} */ all, line) => {
+          const [c, e] = line.split('\t');
+          const count = parseInt(c, 10);
+          const [name, rest] = e.split(' <');
+          const isExcluded = (
+            ['GitHub', 'Travis CI'].some((n) => name.startsWith(n)) ||
+            ['>', 'action@github.com>'].some((e) => rest === e) ||
+            [name, rest].some((n) => n.includes('[bot]'))
+          );
+
+          if (!isExcluded) {
+            let [email] = rest.split('>');
+
+            if (!all[email]) {
+              email = Object.keys(all).find((k) =>
+                name.includes(' ') &&
+                all[k].name === name
+              ) || email;
+            }
+
+            if (all[email]) {
+              all[email].count += count;
+            } else {
+              all[email] = { count, name };
+            }
+          }
+
+          return all;
+        }, {})
+    )
+    .sort((a, b) => {
+      const diff = b[1].count - a[1].count;
+
+      return diff === 0
+        ? a[1].name.localeCompare(b[1].name)
+        : diff;
+    })
+    .map(([email, { count, name }], i) => {
+      execGit(`log master -1 --author=${email} > ${tmpFile}-${i}`);
+
+      const commit = fs
+        .readFileSync(`${tmpFile}-${i}`, 'utf-8')
+        .split('\n')[4]
+        .trim();
+
+      return `${`${count}`.padStart(8)}\t${name.padEnd(30)}\t${commit}`;
+    })
+    .join('\n')
+);

package/scripts/polkadot-dev-copy-dir.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { copyDirSync, exitFatal, logBin } from './util.mjs';
+
+const argv = process.argv.slice(2);
+const args = [];
+let cd = '';
+let flatten = false;
+
+for (let i = 0; i < argv.length; i++) {
+  switch (argv[i]) {
+    case '--cd':
+      cd = argv[++i];
+      break;
+    case '--flatten':
+      flatten = true;
+      break;
+    default:
+      args.push(argv[i]);
+      break;
+  }
+}
+
+const sources = args.slice(0, args.length - 1);
+const dest = args[args.length - 1];
+
+logBin('polkadot-dev-copy-dir');
+
+if (!sources || !dest) {
+  exitFatal('Expected at least one <source>... and one <destination> argument');
+}
+
+sources.forEach((src) =>
+  copyDirSync(
+    cd
+      ? `${cd}/${src}`
+      : src,
+    cd
+      ? `${cd}/${dest}${flatten ? '' : `/${src}`}`
+      : `${dest}${flatten ? '' : `/${src}`}`
+  )
+);

package/scripts/polkadot-dev-copy-to.mjs

@@ -0,0 +1,53 @@
+#!/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, execPm, exitFatal, logBin, mkdirpSync, rimrafSync } from './util.mjs';
+
+const args = process.argv.slice(2);
+
+logBin('polkadot-dev-copy-to');
+
+if (args.length !== 1) {
+  exitFatal('Expected one <destination> argument');
+}
+
+const dest = path.join(process.cwd(), '..', args[0], 'node_modules');
+
+if (!fs.existsSync(dest)) {
+  exitFatal('Destination node_modules folder does not exist');
+}
+
+// build to ensure we actually have latest
+execPm('build');
+
+// map across what is available and copy it
+fs
+  .readdirSync('packages')
+  .map((dir) => {
+    const pkgPath = path.join(process.cwd(), 'packages', dir);
+
+    return [pkgPath, path.join(pkgPath, 'package.json')];
+  })
+  .filter(([, jsonPath]) => fs.existsSync(jsonPath))
+  .map(([pkgPath, json]) => [JSON.parse(fs.readFileSync(json, 'utf8')).name, pkgPath])
+  .forEach(([name, pkgPath]) => {
+    console.log(`*** Copying ${name} to ${dest}`);
+
+    const outDest = path.join(dest, name);
+
+    // remove the destination
+    rimrafSync(outDest);
+
+    // create the root
+    mkdirpSync(outDest);
+
+    // copy the build output
+    copyDirSync(path.join(pkgPath, 'build'), outDest);
+
+    // copy node_modules, as available
+    copyDirSync(path.join(pkgPath, 'node_modules'), path.join(outDest, 'node_modules'));
+  });

package/scripts/polkadot-dev-deno-map.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs';
+
+import { DENO_POL_PRE } from './util.mjs';
+
+const [e, i] = fs
+  .readdirSync('packages')
+  .filter((p) => fs.existsSync(`packages/${p}/src/mod.ts`))
+  .sort()
+  .reduce((/** @type {[string[], Record<String, string>]} */ [e, i], p) => {
+    e.push(`export * as ${p.replace(/-/g, '_')} from '${DENO_POL_PRE}/${p}/mod.ts';`);
+    i[`${DENO_POL_PRE}/${p}/`] = `./packages/${p}/build-deno/`;
+
+    return [e, i];
+  }, [[], {}]);
+
+if (!fs.existsSync('mod.ts')) {
+  fs.writeFileSync('mod.ts', `// Copyright 2017-${new Date().getFullYear()} @polkadot/dev authors & contributors\n// SPDX-License-Identifier: Apache-2.0\n\n// auto-generated via polkadot-dev-deno-map, do not edit\n\n// This is a Deno file, so we can allow .ts imports
+  /* eslint-disable import/extensions */\n\n${e.join('\n')}\n`);
+}
+
+if (fs.existsSync('import_map.in.json')) {
+  const o = JSON.parse(fs.readFileSync('import_map.in.json', 'utf-8'));
+
+  Object
+    .entries(o.imports)
+    .forEach(([k, v]) => {
+      i[k] = v;
+    });
+}
+
+fs.writeFileSync('import_map.json', JSON.stringify({ imports: i }, null, 2));

package/scripts/polkadot-dev-run-lint.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import process from 'node:process';
+import yargs from 'yargs';
+
+import { __dirname, execPm, GITHUB_REPO, logBin } from './util.mjs';
+
+const TS_CONFIG_BUILD = true;
+
+logBin('polkadot-dev-run-lint');
+
+// Since yargs can also be a promise, we just relax the type here completely
+const argv = await yargs(process.argv.slice(2))
+  .options({
+    'skip-eslint': {
+      description: 'Skips running eslint',
+      type: 'boolean'
+    },
+    'skip-tsc': {
+      description: 'Skips running tsc',
+      type: 'boolean'
+    }
+  })
+  .strict()
+  .argv;
+
+if (!argv['skip-eslint']) {
+  // We don't want to run with fix on CI
+  const extra = GITHUB_REPO
+    ? ''
+    : '--fix';
+
+  execPm(`polkadot-exec-eslint ${extra} ${process.cwd()}`);
+}
+
+if (!argv['skip-tsc']) {
+  execPm(`polkadot-exec-tsc --noEmit --emitDeclarationOnly false --pretty${TS_CONFIG_BUILD ? ' --project tsconfig.build.json' : ''}`);
+}

package/scripts/polkadot-dev-run-node-ts.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { execNodeTs, logBin } from './util.mjs';
+
+logBin('polkadot-run-node-ts');
+
+execNodeTs(process.argv.slice(2).join(' '));

package/scripts/polkadot-dev-run-test.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import process from 'node:process';
+
+import { execNodeTs, exitFatal, exitFatalEngine, importPath, logBin, readdirSync } from './util.mjs';
+
+// A & B are just helpers here and in the errors below
+const EXT_A = ['spec', 'test'];
+const EXT_B = ['ts', 'tsx', 'js', 'jsx', 'cjs', 'mjs'];
+
+// The actual extensions we are looking for
+const EXTS = EXT_A.reduce((/** @type {string[]} */ exts, s) => exts.concat(...EXT_B.map((e) => `.${s}.${e}`)), []);
+
+logBin('polkadot-dev-run-test');
+
+exitFatalEngine();
+
+const cmd = [];
+const nodeFlags = [];
+const filters = [];
+
+/** @type {Record<string, string[]>} */
+const filtersExcl = {};
+/** @type {Record<string, string[]>} */
+const filtersIncl = {};
+
+const args = process.argv.slice(2);
+let testEnv = 'node';
+let isDev = false;
+
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    // when running inside a dev environment, specifically @polkadot/dev
+    case '--dev-build':
+      isDev = true;
+      break;
+
+    // environment, not passed-through
+    case '--env':
+      if (!['browser', 'node'].includes(args[++i])) {
+        throw new Error(`Invalid --env ${args[i]}, expected 'browser' or 'node'`);
+      }
+
+      testEnv = args[i];
+      break;
+
+    // internal flags with no params
+    case '--bail':
+    case '--console':
+      cmd.push(args[i]);
+      break;
+
+    // internal flags, with params
+    case '--logfile':
+      cmd.push(args[i]);
+      cmd.push(args[++i]);
+      break;
+
+    // node flags that could have additional params
+    case '--import':
+    case '--loader':
+    case '--require':
+      nodeFlags.push(args[i]);
+      nodeFlags.push(args[++i]);
+      break;
+
+    // any other non-flag arguments are passed-through
+    default:
+      if (args[i].startsWith('-')) {
+        throw new Error(`Unknown flag ${args[i]} found`);
+      }
+
+      filters.push(args[i]);
+
+      if (args[i].startsWith('^')) {
+        const key = args[i].slice(1);
+
+        if (filtersIncl[key]) {
+          delete filtersIncl[key];
+        } else {
+          filtersExcl[key] = key.split(/[\\/]/);
+        }
+      } else {
+        const key = args[i];
+
+        if (filtersExcl[key]) {
+          delete filtersExcl[key];
+        } else {
+          filtersIncl[key] = key.split(/[\\/]/);
+        }
+      }
+
+      break;
+  }
+}
+
+/**
+ * @param {string[]} parts
+ * @param {Record<string, string[]>} filters
+ * @returns {boolean}
+ */
+function applyFilters (parts, filters) {
+  return Object
+    .values(filters)
+    .some((filter) =>
+      parts
+        .map((_, i) => i)
+        .filter((i) =>
+          filter[0].startsWith(':')
+            ? parts[i].includes(filter[0].slice(1))
+            : filter.length === 1
+              ? parts[i].startsWith(filter[0])
+              : parts[i] === filter[0]
+        )
+        .some((start) =>
+          filter.every((f, i) =>
+            parts[start + i] && (
+              f.startsWith(':')
+                ? parts[start + i].includes(f.slice(1))
+                : i === (filter.length - 1)
+                  ? parts[start + i].startsWith(f)
+                  : parts[start + i] === f
+            )
+          )
+        )
+    );
+}
+
+const files = readdirSync('packages', EXTS).filter((file) => {
+  const parts = file.split(/[\\/]/);
+  let isIncluded = true;
+
+  if (Object.keys(filtersIncl).length) {
+    isIncluded = applyFilters(parts, filtersIncl);
+  }
+
+  if (isIncluded && Object.keys(filtersExcl).length) {
+    isIncluded = !applyFilters(parts, filtersExcl);
+  }
+
+  return isIncluded;
+});
+
+if (files.length === 0) {
+  exitFatal(`No files matching *.{${EXT_A.join(', ')}}.{${EXT_B.join(', ')}} found${filters.length ? ` (filtering on ${filters.join(', ')})` : ''}`);
+}
+
+try {
+  const allFlags = `${importPath('@polkadot/dev/scripts/polkadot-exec-node-test.mjs')} ${[...cmd, ...files].join(' ')}`;
+
+  nodeFlags.push('--require');
+  nodeFlags.push(
+    isDev
+      ? `./packages/dev-test/build/cjs/${testEnv}.js`
+      : `@polkadot/dev-test/${testEnv}`
+  );
+
+  execNodeTs(allFlags, nodeFlags, false, isDev ? './packages/dev-ts/build/testCached.js' : '@polkadot/dev-ts/testCached');
+} catch {
+  process.exit(1);
+}

package/scripts/polkadot-dev-version.mjs

@@ -0,0 +1,143 @@
+#!/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 yargs from 'yargs';
+
+import { execPm, exitFatal, logBin } from './util.mjs';
+
+/** @typedef {{ dependencies?: Record<string, string>; devDependencies?: Record<string, string>; peerDependencies?: Record<string, string>; optionalDependencies?: Record<string, string>; resolutions?: Record<string, string>; name?: string; stableVersion?: string; version: string; }} PkgJson */
+
+const TYPES = ['major', 'minor', 'patch', 'pre'];
+
+const [type] = (
+  await yargs(process.argv.slice(2))
+    .demandCommand(1)
+    .argv
+)._;
+
+if (typeof type !== 'string' || !TYPES.includes(type)) {
+  exitFatal(`Invalid version bump "${type}", expected one of ${TYPES.join(', ')}`);
+}
+
+/**
+ * @param {Record<string, string>} dependencies
+ * @param {string[]} others
+ * @param {string} version
+ * @returns {Record<string, string>}
+ */
+function updateDependencies (dependencies, others, version) {
+  return Object
+    .entries(dependencies)
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .reduce((/** @type {Record<string, string>} */ result, [key, value]) => {
+      result[key] = others.includes(key) && value !== '*'
+        ? value.startsWith('^')
+          ? `^${version}`
+          : version
+        : value;
+
+      return result;
+    }, {});
+}
+
+/**
+ * @returns {[string, PkgJson]}
+ */
+function readCurrentPkgJson () {
+  const rootPath = path.join(process.cwd(), 'package.json');
+  const rootJson = JSON.parse(fs.readFileSync(rootPath, 'utf8'));
+
+  return [rootPath, rootJson];
+}
+
+/**
+ * @param {string} path
+ * @param {unknown} json
+ */
+function writePkgJson (path, json) {
+  fs.writeFileSync(path, `${JSON.stringify(json, null, 2)}\n`);
+}
+
+/**
+ *
+ * @param {string} version
+ * @param {string[]} others
+ * @param {string} pkgPath
+ * @param {Record<String, any>} json
+ */
+function updatePackage (version, others, pkgPath, json) {
+  const updated = Object
+    .keys(json)
+    .reduce((/** @type {Record<String, unknown>} */ result, key) => {
+      if (key === 'version') {
+        result[key] = version;
+      } else if (['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies', 'resolutions'].includes(key)) {
+        result[key] = updateDependencies(json[key], others, version);
+      } else if (key !== 'stableVersion') {
+        result[key] = json[key];
+      }
+
+      return result;
+    }, {});
+
+  writePkgJson(pkgPath, updated);
+}
+
+function removeX () {
+  const [rootPath, json] = readCurrentPkgJson();
+
+  if (!json.version?.endsWith('-x')) {
+    return false;
+  }
+
+  json.version = json.version.replace('-x', '');
+  writePkgJson(rootPath, json);
+
+  return true;
+}
+
+function addX () {
+  const [rootPath, json] = readCurrentPkgJson();
+
+  if (json.version.endsWith('-x')) {
+    return false;
+  }
+
+  json.version = json.version + '-x';
+  writePkgJson(rootPath, json);
+
+  return true;
+}
+
+logBin('polkadot-dev-version');
+
+const isX = removeX();
+
+execPm(`version ${type === 'pre' ? 'prerelease' : type}`);
+
+if (isX && type === 'pre') {
+  addX();
+}
+
+const [rootPath, rootJson] = readCurrentPkgJson();
+
+updatePackage(rootJson.version, [], rootPath, rootJson);
+
+// yarn workspaces does an OOM, manual looping takes ages
+if (fs.existsSync('packages')) {
+  const packages = fs
+    .readdirSync('packages')
+    .map((dir) => path.join(process.cwd(), 'packages', dir, 'package.json'))
+    .filter((pkgPath) => fs.existsSync(pkgPath))
+    .map((pkgPath) => [pkgPath, JSON.parse(fs.readFileSync(pkgPath, 'utf8'))]);
+  const others = packages.map(([, json]) => json.name);
+
+  packages.forEach(([pkgPath, json]) => {
+    updatePackage(rootJson.version, others, pkgPath, json);
+  });
+}
+
+execPm('install');

package/scripts/polkadot-dev-yarn-only.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import process from 'node:process';
+
+import { exitFatalYarn } from './util.mjs';
+
+exitFatalYarn();
+
+process.exit(0);

package/scripts/polkadot-exec-eslint.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { importRelative } from './util.mjs';
+
+await importRelative('eslint', 'eslint/bin/eslint.js');

package/scripts/polkadot-exec-ghpages.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { importRelative } from './util.mjs';
+
+const ghp = await importRelative('gh-pages', 'gh-pages/bin/gh-pages.js');
+
+await ghp.default(process.argv);
+
+console.log('Published');