@sprucelabs/resolve-path-aliases 2.0.1 → 2.0.3

package/build/PathResolver.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logLive = exports.logStub = exports.PathResolver = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const globby_1 = __importDefault(require("globby"));
+const tsconfig_paths_1 = require("tsconfig-paths");
+const posixPath_1 = __importDefault(require("./posixPath"));
+class PathResolver {
+    static Class;
+    outResolver;
+    srcResolver;
+    globby;
+    totalMappedPaths = 0;
+    totalFilesWithMappedPaths = 0;
+    log = exports.logLive;
+    constructor(globbyUtil) {
+        this.globby = globbyUtil;
+    }
+    static Resolver(globbyUtil = globby_1.default) {
+        return new (this.Class ?? this)(globbyUtil);
+    }
+    buildResolvers(destination) {
+        const config = (0, tsconfig_paths_1.loadConfig)(destination);
+        if (config.resultType === 'failed') {
+            throw new Error(config.message);
+        }
+        const { paths, absoluteBaseUrl } = config;
+        const srcResolver = (0, tsconfig_paths_1.createMatchPath)(absoluteBaseUrl, paths);
+        const outResolver = this.buildOutResolver(config);
+        this.outResolver = outResolver;
+        this.srcResolver = srcResolver;
+    }
+    resolvePathAliases(destination, options = {}) {
+        this.buildResolvers(destination);
+        const { patterns = ['**/*.js'], absoluteOrRelative = 'relative', beVerbose: isVerbose = false, } = options;
+        this.log = isVerbose ? exports.logLive : exports.logStub;
+        this.totalMappedPaths = 0;
+        this.totalFilesWithMappedPaths = 0;
+        const files = this.findFiles(patterns, destination);
+        this.log.info(`Checking ${files.length} files for path aliases...`);
+        files.forEach((file) => this.replacePaths(file, absoluteOrRelative));
+        return {
+            totalMappedPaths: this.totalMappedPaths,
+            totalFilesWithMappedPaths: this.totalFilesWithMappedPaths,
+        };
+    }
+    replacePaths(file, absoluteOrRelative) {
+        const contents = fs_1.default.readFileSync(file).toString();
+        let { found, updated } = this.replaceHashPaths(contents, file, absoluteOrRelative);
+        if (found) {
+            this.totalFilesWithMappedPaths++;
+            fs_1.default.writeFileSync(file, updated);
+        }
+    }
+    replaceHashPaths(contents, filepath, absoluteOrRelative) {
+        const directoryPath = path_1.default.dirname(filepath);
+        let found = false;
+        const updated = `${contents}`.replace(/(['"]?).*?(from |import |import\(|require\()['"](#spruce\/(.*?))['"]/gi, 
+        //@ts-ignore
+        (possibleMatchWithQuote, _, requireOrImport, match) => {
+            if (possibleMatchWithQuote.trim().startsWith('"')) {
+                return;
+            }
+            found = true;
+            const search = match;
+            let resolved;
+            this.log.info('Found', search, 'in', filepath);
+            if (this.outResolver) {
+                resolved = this.outResolver(search, undefined, undefined, [
+                    '.ts',
+                    '.js',
+                ]);
+            }
+            if (!resolved && this.srcResolver) {
+                resolved = this.srcResolver(search, undefined, undefined, [
+                    '.ts',
+                    '.js',
+                ]);
+            }
+            if (!resolved) {
+                throw new Error(`Could not map ${search} in ${filepath}.`);
+            }
+            const relative = absoluteOrRelative === 'relative'
+                ? './' + path_1.default.relative(directoryPath, resolved)
+                : resolved;
+            const replaced = possibleMatchWithQuote.replace(search, (0, posixPath_1.default)(relative));
+            this.totalMappedPaths++;
+            return replaced;
+        });
+        return { found, updated };
+    }
+    findFiles(patterns, destination) {
+        return this.globby.sync(patterns.map((pattern) => (0, posixPath_1.default)(path_1.default.posix.join(destination, '/', pattern))), {
+            dot: true,
+        });
+    }
+    buildOutResolver(config) {
+        const fullTsConfig = JSON.parse(fs_1.default.readFileSync(config.configFileAbsolutePath).toString());
+        const { compilerOptions: { baseUrl, outDir }, } = fullTsConfig;
+        let outResolver;
+        if (outDir) {
+            const resolver = (0, tsconfig_paths_1.createMatchPath)(config.absoluteBaseUrl, config.paths);
+            outResolver = (requested, readJson, fileExists, extensions) => {
+                let resolved = resolver(requested, readJson, fileExists, extensions);
+                resolved = resolved?.replace(`${path_1.default.sep}${baseUrl}${path_1.default.sep}`, `${path_1.default.sep}${outDir}${path_1.default.sep}`);
+                return resolved;
+            };
+        }
+        return outResolver;
+    }
+}
+exports.PathResolver = PathResolver;
+exports.logStub = {
+    info: () => { },
+    warning: () => { },
+    error: () => { },
+};
+exports.logLive = {
+    info: (...message) => console.log(chalk_1.default.italic(...message)),
+    warning: (...message) => console.log(chalk_1.default.yellow(...message)),
+    error: (...message) => console.log(chalk_1.default.red(...message)),
+};

package/build/index.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePathAliases = void 0;
 const globby_1 = __importDefault(require("globby"));
-const PathResolve_1 = require("./PathResolve");
+const PathResolver_1 = require("./PathResolver");
 function resolvePathAliases(destination, options = {}, globUtil = globby_1.default) {
-    const resolver = PathResolve_1.PathResolve.Resolver(globUtil);
+    const resolver = PathResolver_1.PathResolver.Resolver(globUtil);
     return resolver.resolvePathAliases(destination, options);
 }
 exports.resolvePathAliases = resolvePathAliases;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sprucelabs/resolve-path-aliases",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Script that resolves paths from your tsconfig",
   "main": "build/index.js",
   "repository": "git@github.com:sprucelabsai-community/resolve-path-aliases.git",
@@ -20,7 +20,8 @@
   "files": [
     "build/index.js",
     "build/resolve-path-aliases.js",
-    "build/posixPath.js"
+    "build/posixPath.js",
+    "build/PathResolver.js"
   ],
   "scripts": {
     "build.ci": "yarn build.tsc && yarn copy-for-tests && yarn lint",