configorama 0.6.4 → 0.6.6

package/src/utils/resolveAlias.js

@@ -0,0 +1,152 @@
+const path = require('path')
+const fs = require('fs')
+const findUp = require('find-up')
+
+const DEBUG = false
+const DEBUG_LOG = (message) => {
+  if (DEBUG) {
+    DEBUG_LOG(message)
+  }
+}
+
+// Maximum number of parent directories to search through
+const MAX_PARENT_DIRS = 5
+
+/**
+ * Finds the nearest config file (tsconfig.json or jsconfig.json) in the directory tree
+ * @param {string} configDir - The directory to start searching from
+ * @returns {string|null} - Path to the config file or null if not found
+ */
+function findConfigFile(configDir) {
+  // Try tsconfig.json first
+  const tsconfigPath = findUp.sync('tsconfig.json', { 
+    cwd: configDir,
+    stopAt: path.resolve(configDir, Array(MAX_PARENT_DIRS).fill('..').join('/'))
+  })
+  if (tsconfigPath) {
+    return tsconfigPath
+  }
+
+  // Fall back to jsconfig.json
+  const jsconfigPath = findUp.sync('jsconfig.json', { 
+    cwd: configDir,
+    stopAt: path.resolve(configDir, Array(MAX_PARENT_DIRS).fill('..').join('/'))
+  })
+  if (jsconfigPath) {
+    return jsconfigPath
+  }
+
+  return null
+}
+
+/**
+ * Resolves path aliases using TypeScript/JavaScript path mappings from config files
+ * @param {string} filePath - The potentially aliased file path
+ * @param {string} configDir - The base directory to search for config files
+ * @returns {string} - The resolved file path
+ */
+function resolveAlias(filePath, configDir) {
+  try {
+    // Find and load config file
+    const configPath = findConfigFile(configDir)
+    if (!configPath) {
+      // console.warn(
+      //   `Warning: No tsconfig.json or jsconfig.json found in directory tree starting from ${configDir}`
+      // )
+      return filePath
+    }
+
+    // Read and parse config file
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    const { paths = {}, baseUrl = '.' } = config.compilerOptions || {}
+
+    // Extract the alias prefix and path
+    // Match any non-slash characters at the start of the path
+    const match = filePath.match(/^([^/]+)(\/.*)?$/)
+    if (!match) {
+      return filePath
+    }
+
+    const [, aliasPrefix, restPath = ''] = match
+
+    // Try exact match first (e.g. settings)
+    const exactKey = aliasPrefix
+    if (paths[exactKey]) {
+      const mappedPath = paths[exactKey][0]
+      const resolvedPath = path.resolve(path.dirname(configPath), baseUrl, mappedPath)
+      DEBUG_LOG(`Resolving exact alias ${filePath} to ${resolvedPath}`)
+      return resolvedPath
+    }
+
+    // Try wildcard match (e.g. alias/*)
+    const wildcardKey = `${aliasPrefix}/*`
+    if (paths[wildcardKey]) {
+      const mappedPath = paths[wildcardKey][0]
+      const basePath = path.resolve(path.dirname(configPath), baseUrl, mappedPath.replace('*', ''))
+      const relativeRest = restPath.replace(/^\//, '')
+      const resolvedPath = path.join(basePath, relativeRest)
+      DEBUG_LOG(`Resolving wildcard alias ${filePath} to ${resolvedPath}`)
+      return resolvedPath
+    }
+
+    // Try nested alias resolution
+    const nestedMatch = filePath.match(/^([^/]+\/[^/]+)(\/.*)?$/)
+    if (nestedMatch) {
+      const [, nestedPrefix, nestedRest = ''] = nestedMatch
+      const nestedKey = `${nestedPrefix}/*`
+      if (paths[nestedKey]) {
+        const mappedPath = paths[nestedKey][0]
+        const basePath = path.resolve(path.dirname(configPath), baseUrl, mappedPath.replace('*', ''))
+        const relativeRest = nestedRest.replace(/^\//, '')
+        const resolvedPath = path.join(basePath, relativeRest)
+        DEBUG_LOG(`Resolving nested alias ${filePath} to ${resolvedPath}`)
+        return resolvedPath
+      }
+    }
+
+    // Fall back to original path if no alias matched
+    // console.warn(`Warning: No alias mapping found for ${filePath}`)
+    return filePath
+
+  } catch (error) {
+    // If alias resolution fails, fall back to original path
+    console.warn(`Warning: Failed to resolve alias for "${filePath}":`, error.message)
+    return filePath
+  }
+}
+
+/**
+ * Gets all configured aliases from tsconfig.json or jsconfig.json
+ * @param {string} configDir - The base directory to search for config files
+ * @returns {Object} - Object containing alias names and their resolved paths
+ */
+function getAliases(configDir) {
+  try {
+    const configPath = findConfigFile(configDir)
+    if (!configPath) {
+      // console.warn(`Warning: No tsconfig.json or jsconfig.json found in directory tree starting from ${configDir}`)
+      return { names: [], lookup: [] }
+    }
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    const { paths = {}, baseUrl = '.' } = config.compilerOptions || {}
+
+    const names = Object.keys(paths).map(key => key.replace('/*', ''))
+    const lookup = Object.entries(paths).map(([key, [value]]) => {
+      const name = key.replace('/*', '')
+      const absPath = path.resolve(path.dirname(configPath), baseUrl, value.replace('/*', ''))
+      const relPath = path.relative(configDir, absPath)
+      return { name, absPath, relPath }
+    })
+
+    return { names, lookup }
+  } catch (error) {
+    console.warn(`Warning: Failed to get aliases:`, error.message)
+    return { names: [], lookup: [] }
+  }
+}
+
+module.exports = {
+  resolveAlias,
+  getAliases
+} 

package/src/utils/resolveAlias.test.js

@@ -0,0 +1,98 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const fs = require('fs')
+const findUp = require('find-up')
+const { resolveAlias, getAliases } = require('./resolveAlias')
+
+// Mock config content
+const mockConfig = {
+  compilerOptions: {
+    baseUrl: '.',
+    paths: {
+      '@components': ['src/components'],
+      '@utils/*': ['src/utils/*'],
+      '@shared/*': ['src/shared/*'],
+      '@nested/foo/*': ['src/nested/foo/*'],
+      '~zaz/*': ['src/zaz/*']
+    }
+  }
+}
+
+// Store original implementations
+const originalReadFileSync = fs.readFileSync
+const originalFindUpSync = findUp.sync
+
+// Mock implementations
+const mockFindUpSync = (filename) => {
+  if (filename === 'tsconfig.json') {
+    return '/project/tsconfig.json'
+  }
+  return null
+}
+
+const mockReadFileSync = () => JSON.stringify(mockConfig)
+
+test.before.each(() => {
+  // Reset mocks before each test
+  findUp.sync = mockFindUpSync
+  fs.readFileSync = mockReadFileSync
+})
+
+test.after(() => {
+  // Restore original implementations
+  fs.readFileSync = originalReadFileSync
+  findUp.sync = originalFindUpSync
+})
+
+test('resolveAlias - exact match', () => {
+  const result = resolveAlias('@components', '/project')
+  assert.is(result, path.resolve('/project', 'src/components'))
+})
+
+test('resolveAlias - wildcard match', () => {
+  const result = resolveAlias('@utils/helpers', '/project')
+  assert.is(result, path.resolve('/project', 'src/utils/helpers'))
+})
+
+test('resolveAlias - nested alias', () => {
+  const result = resolveAlias('@nested/foo/bar', '/project')
+  assert.is(result, path.resolve('/project', 'src/nested/foo/bar'))
+})
+
+test('resolveAlias - special character alias', () => {
+  const result = resolveAlias('~zaz/helpers', '/project')
+  assert.is(result, path.resolve('/project', 'src/zaz/helpers'))
+})
+
+test('resolveAlias - no config file found', () => {
+  findUp.sync = () => null
+  const result = resolveAlias('@components', '/project')
+  assert.is(result, '@components')
+})
+
+test('resolveAlias - no matching alias', () => {
+  const result = resolveAlias('unknown/path', '/project')
+  assert.is(result, 'unknown/path')
+})
+
+test('getAliases - returns correct alias information', () => {
+  const result = getAliases('/project')
+  assert.is(result.names.length, 5)
+  assert.is(result.lookup.length, 5)
+  
+  // Check if all expected aliases are present
+  const expectedNames = ['@components', '@utils', '@shared', '@nested/foo', '~zaz']
+  expectedNames.forEach(name => {
+    assert.ok(result.names.includes(name))
+  })
+})
+
+test('getAliases - no config file found', () => {
+  findUp.sync = () => null
+  const result = getAliases('/project')
+  assert.is(result.names.length, 0)
+  assert.is(result.lookup.length, 0)
+})
+
+test.run() 

package/src/utils/resolveAliasOld.js

@@ -0,0 +1,65 @@
+const path = require('path')
+const fs = require('fs')
+
+function resolveAlias(filePath, configDir) {
+  try {
+    // If no alias prefix, return original path
+    if (!filePath.startsWith('@')) {
+      return filePath
+    }
+
+    // Find tsconfig.json
+    const tsconfigPath = path.join(configDir, 'tsconfig.json')
+    if (!fs.existsSync(tsconfigPath)) {
+      console.warn(`Warning: No tsconfig.json found in ${configDir}`)
+      return filePath
+    }
+
+    // Read and parse tsconfig.json
+    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'))
+    const aliasMappings = tsconfig.compilerOptions?.paths || {}
+
+    // Extract the alias prefix and path
+    const match = filePath.match(/^(@[^/]+)(\/.*)$/)
+    if (!match) {
+      return filePath
+    }
+
+    const [, aliasPrefix, restPath] = match
+    const aliasKey = `${aliasPrefix}/*`
+
+    // Check if we have a mapping for this alias
+    if (aliasMappings[aliasKey]) {
+      // Get the mapped path and normalize it
+      const mappedPath = aliasMappings[aliasKey][0]
+      const basePath = path.resolve(configDir, mappedPath.replace('*', ''))
+      const relativeRest = restPath.replace(/^\//, '')
+      const resolvedPath = path.join(basePath, relativeRest)
+
+      // Log the resolution for debugging
+      console.log(`Resolving ${filePath} to ${resolvedPath}`)
+
+      return resolvedPath
+    }
+
+    // Try exact match without wildcard
+    const exactKey = aliasPrefix
+    if (aliasMappings[exactKey]) {
+      const mappedPath = aliasMappings[exactKey][0]
+      const resolvedPath = path.resolve(configDir, mappedPath)
+
+      console.log(`Resolving ${filePath} to ${resolvedPath}`)
+      return resolvedPath
+    }
+
+    // Fall back to original path if no alias matched
+    return filePath
+
+  } catch (error) {
+    // If alias resolution fails, fall back to original path
+    console.warn(`Warning: Failed to resolve alias for "${filePath}":`, error.message)
+    return filePath
+  }
+}
+
+module.exports = resolveAlias

package/src/utils/textUtils.js

@@ -4,7 +4,7 @@
  * @param {string} search - String to search for
  * @returns {string} Text after search string or empty string if not found
  */
-function getTextAfterOccurance(str, search) {
+function getTextAfterOccurrence(str, search) {
   const index = str.indexOf(search)
   if (index === -1) return ''
   return str.substring(index)
@@ -26,6 +26,6 @@ function findNestedVariable(split, originalSource) {
 }
 
 module.exports = {
-  getTextAfterOccurance,
+  getTextAfterOccurrence,
   findNestedVariable
 }