npm package diff

Package: @forge/bundler

Versions: 6.1.4-next.6 - 6.1.4-next.7

File: package/out/metadata.js

Index: package/out/metadata.js
===================================================================
--- package/out/metadata.js
+++ package/out/metadata.js
@@ -7,88 +7,101 @@
 const parser = tslib_1.__importStar(require("@babel/parser"));
 const traverse_1 = tslib_1.__importDefault(require("@babel/traverse"));
 const text_1 = require("./text");
 const types_1 = require("./types");
-async function getMetadata(logger, files) {
-    const metadata = (0, types_1.emptyMetadata)();
-    const packageJson = await warnIfFailed(logger, async () => {
+class MetadataCollector {
+    logger;
+    metadata = (0, types_1.emptyMetadata)();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async processPackageJson() {
         try {
             await (0, promises_1.access)('package.json');
         }
         catch {
             return undefined;
         }
         const packageFile = await (0, promises_1.readFile)('package.json', 'utf8');
-        return JSON.parse(packageFile);
-    });
-    if (packageJson?.type === 'module') {
-        metadata.esm = true;
+        const packageJson = JSON.parse(packageFile);
+        if (packageJson.type === 'module') {
+            this.metadata.esm = true;
+        }
     }
-    await Promise.all(files.map((filePath) => warnIfFailed(logger, async () => processFile(metadata, filePath))));
-    return metadata;
-}
-exports.getMetadata = getMetadata;
-function packageFromImport(name) {
-    const parts = name.split('/');
-    if (parts.length === 0 || parts[0] === '') {
-        return '';
+    static packageFromImport(name) {
+        const parts = name.split('/');
+        if (parts.length === 0 || parts[0] === '') {
+            return '';
+        }
+        if (parts[0].startsWith('@')) {
+            return `${parts[0]}/${parts[1]}`;
+        }
+        if (parts[0].startsWith('node:')) {
+            return parts[0].substring(5);
+        }
+        return parts[0];
     }
-    if (parts[0].startsWith('@')) {
-        return `${parts[0]}/${parts[1]}`;
+    async processSourceFile(filePath) {
+        const ext = path_1.default.extname(filePath);
+        if (ext.match(/^\.[cm]?jsx?$/)) {
+            this.metadata.jsFiles++;
+        }
+        else if (ext.match(/^\.[cm]?tsx?$/)) {
+            this.metadata.tsFiles++;
+        }
+        else if (ext === '.json') {
+            return;
+        }
+        const source = await (0, promises_1.readFile)(filePath, 'utf8');
+        const ast = parser.parse(source, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx']
+        });
+        (0, traverse_1.default)(ast, {
+            ImportDeclaration: ({ node }) => this.processImport(node)
+        });
     }
-    if (parts[0].startsWith('node:')) {
-        return parts[0].substring(5);
-    }
-    return parts[0];
-}
-async function processFile(metadata, filePath) {
-    const ext = path_1.default.extname(filePath);
-    if (ext.match(/^\.[cm]?jsx?$/)) {
-        metadata.jsFiles++;
-    }
-    else if (ext.match(/^\.[cm]?tsx?$/)) {
-        metadata.tsFiles++;
-    }
-    else if (ext === '.json') {
-        return;
-    }
-    const source = await (0, promises_1.readFile)(filePath, 'utf8');
-    const ast = parser.parse(source, {
-        sourceType: 'module',
-        plugins: ['typescript', 'jsx']
-    });
-    (0, traverse_1.default)(ast, {
-        ImportDeclaration: ({ node }) => {
-            const packageName = packageFromImport(node.source.value);
-            metadata.dependencies.add(packageName);
-            if (packageName.startsWith('@forge/')) {
-                for (const specifier of node.specifiers) {
-                    let member;
-                    switch (specifier.type) {
-                        case 'ImportDefaultSpecifier':
-                        case 'ImportNamespaceSpecifier':
-                            member = '*';
-                            break;
-                        case 'ImportSpecifier':
-                            switch (specifier.imported.type) {
-                                case 'Identifier':
-                                    member = specifier.imported.name;
-                                    break;
-                                case 'StringLiteral':
-                                    member = specifier.imported.value;
-                                    break;
-                            }
-                    }
-                    metadata.sdkImports.add(`${packageName}.${member}`);
+    processImport(node) {
+        const packageName = MetadataCollector.packageFromImport(node.source.value);
+        this.metadata.dependencies.add(packageName);
+        if (packageName.startsWith('@forge/')) {
+            for (const specifier of node.specifiers) {
+                let member;
+                switch (specifier.type) {
+                    case 'ImportDefaultSpecifier':
+                    case 'ImportNamespaceSpecifier':
+                        member = '*';
+                        break;
+                    case 'ImportSpecifier':
+                        switch (specifier.imported.type) {
+                            case 'Identifier':
+                                member = specifier.imported.name;
+                                break;
+                            case 'StringLiteral':
+                                member = specifier.imported.value;
+                                break;
+                        }
                 }
+                this.metadata.sdkImports.add(`${packageName}.${member}`);
             }
         }
-    });
-}
-async function warnIfFailed(logger, action) {
-    try {
-        return await action();
     }
-    catch (error) {
-        logger.warn(text_1.Text.metadataFailed(error));
+    async collect({ files }) {
+        await this.warnIfFailed(() => this.processPackageJson());
+        await Promise.all(files.map((filePath) => this.warnIfFailed(() => this.processSourceFile(filePath))));
+        return this.metadata;
     }
+    async warnIfFailed(action) {
+        try {
+            return await action();
+        }
+        catch (error) {
+            this.logger.debug(text_1.Text.metadataFailed(error));
+            this.metadata.errors++;
+        }
+    }
 }
+async function getMetadata(logger, files) {
+    const collector = new MetadataCollector(logger);
+    return collector.collect({ files });
+}
+exports.getMetadata = getMetadata;