@ethersphere/bee-js 13.0.0-upcoming.gcfb9756 → 13.0.0

package/dist/cjs/utils/type.js

@@ -69,8 +69,8 @@ function isTag(value) {
  * @throws TypeError if not valid
  */
 function assertData(value) {
-    if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
-        throw new TypeError('Data must be either string or Uint8Array!');
+    if (typeof value !== 'string' && !(value instanceof Uint8Array) && !(value instanceof Blob) && !isReadable(value)) {
+        throw new TypeError('Data must be either string, Uint8Array, Blob or Readable!');
     }
 }
 /**

package/dist/codemod/index.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let ts;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    ts = require('typescript');
+}
+catch {
+    console.error("This tool requires 'typescript' to be installed in your project.");
+    console.error('Run: npm install --save-dev typescript');
+    process.exit(1);
+}
+// TypeScript 7 replaced the classic Compiler API (ts.createProgram, ts.sys, etc.) this tool
+// is built on with a new, explicitly "unstable" native AST API with a different shape -
+// there's no ts.createProgram to fall back to, so fail clearly instead of crashing on it.
+if (typeof ts.createProgram !== 'function') {
+    console.error(`This tool needs TypeScript's classic Compiler API, removed in TypeScript 7.0 (found ${ts.version}).`);
+    console.error('Install a supported version: npm install --save-dev typescript@^5.9.0');
+    process.exit(1);
+}
+const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git']);
+function walkFiles(dir) {
+    const files = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name)) {
+                files.push(...walkFiles(path.join(dir, entry.name)));
+            }
+        }
+        else if (entry.isFile() && EXTENSIONS.some(ext => entry.name.endsWith(ext))) {
+            files.push(path.join(dir, entry.name));
+        }
+    }
+    return files;
+}
+function parseVersion(filename) {
+    const match = path.basename(filename).match(/^v?(\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+const args = process.argv.slice(2);
+const fromIdx = args.indexOf('--from');
+const fromVersion = fromIdx !== -1 ? parseVersion(args[fromIdx + 1]) : 0;
+const target = args.find((a, i) => !a.startsWith('--') && (fromIdx === -1 || i !== fromIdx + 1));
+if (!target) {
+    console.error('Usage: npx bee-js-codemod <path> [--from <version>]');
+    console.error('Example: npx bee-js-codemod ./src --from v12');
+    process.exit(1);
+}
+const transformsDir = path.join(__dirname, 'transforms');
+const transformFiles = fs
+    .readdirSync(transformsDir)
+    .filter(f => (f.endsWith('.ts') || f.endsWith('.js')) && !f.endsWith('.d.ts'))
+    .sort()
+    .filter(f => parseVersion(f) > fromVersion);
+if (transformFiles.length === 0) {
+    console.log('No transforms to apply.');
+    process.exit(0);
+}
+console.log(`Applying: ${transformFiles.join(', ')}\n`);
+const transforms = transformFiles.map(f => {
+    const modulePath = path.join(transformsDir, f.replace(/\.(ts|js)$/, ''));
+    return require(modulePath).transform;
+});
+const resolved = path.resolve(target);
+const stat = fs.statSync(resolved);
+const files = (stat.isDirectory() ? walkFiles(resolved) : [resolved]).map(f => path.resolve(f));
+const targetSet = new Set(files);
+// Load the target project's compiler options so imports and the bee-js types resolve; fall
+// back to permissive defaults when no tsconfig is found nearby.
+function loadCompilerOptions(from) {
+    const configPath = ts.findConfigFile(from, ts.sys.fileExists, 'tsconfig.json');
+    if (configPath) {
+        const read = ts.readConfigFile(configPath, ts.sys.readFile);
+        const parsed = ts.parseJsonConfigFileContent(read.config ?? {}, ts.sys, path.dirname(configPath));
+        return { ...parsed.options, noEmit: true, allowJs: true, checkJs: false };
+    }
+    return {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    };
+}
+const options = loadCompilerOptions(stat.isDirectory() ? resolved : path.dirname(resolved));
+const changedFiles = new Set();
+// Each transform version gets a freshly built program so it sees edits from the previous one.
+for (const transform of transforms) {
+    const program = ts.createProgram(files, options);
+    const checker = program.getTypeChecker();
+    for (const sourceFile of program.getSourceFiles()) {
+        const filePath = path.resolve(sourceFile.fileName);
+        if (!targetSet.has(filePath))
+            continue;
+        const result = transform(sourceFile, checker);
+        if (result !== null && result !== sourceFile.text) {
+            fs.writeFileSync(filePath, result, 'utf8');
+            console.log(`updated: ${filePath}`);
+            changedFiles.add(filePath);
+        }
+    }
+}
+console.log(`\n${changedFiles.size} file(s) updated, ${files.length - changedFiles.size} unchanged.`);