configorama 0.6.9 → 0.6.10

package/src/utils/splitByComma.js

@@ -13,6 +13,7 @@ const stringRefSyntax = stringResolver.match
 
 // https://regex101.com/r/4uPmpt/1
 const commasOutsideOfParens = /(?!<(?:\(|\[)[^)\]]+),(?![^(\[]+(?:\)|\]))/
+const PLACEHOLDER_REGEX = /__PLACEHOLDER_(\d+)__/g
 // const commasOutOfParens = /(?!(?:\()[^)\]]+),(?![^(\[]+(?:\)))/g
 function splitByComma(string, regexPattern) {
   // Handle empty or undefined input
@@ -96,7 +97,7 @@ function splitByComma(string, regexPattern) {
   
   // Restore placeholders in the result
   return result.map(item => {
-    return item.replace(/__PLACEHOLDER_(\d+)__/g, (match, index) => {
+    return item.replace(PLACEHOLDER_REGEX, (match, index) => {
       return placeholders[parseInt(index)]
     })
   })

package/src/utils/splitCsv.js

@@ -8,16 +8,16 @@ function splitCsv(str, splitter) {
   const splitSyntax = splitter || ','
   // Split at comma SPACE ", "
   return str.split(splitSyntax).reduce(
-    (accum, curr) => {
-      if (accum.isConcatting) {
-        accum.soFar[accum.soFar.length - 1] += ',' + curr
+    (acc, curr) => {
+      if (acc.isConcatting) {
+        acc.soFar[acc.soFar.length - 1] += ',' + curr
       } else {
-        accum.soFar.push(curr)
+        acc.soFar.push(curr)
       }
       if (curr.split('"').length % 2 == 0) {
-        accum.isConcatting = !accum.isConcatting
+        acc.isConcatting = !acc.isConcatting
       }
-      return accum
+      return acc
     },
     {
       soFar: [],

package/src/utils/resolveAliasOld.js

@@ -1,65 +0,0 @@
-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/x.js

@@ -1,173 +0,0 @@
-process.env.foo = 'foo'
-process.env.opt_stage = 'stage'
-process.env.opt_stageOne = 'stageOne'
-process.env.opt_stageTwo = 'stageTwo'
-
-function getResolvers() {
-  return {
-    'file': async function fileResolver(arg) {
-      return 'filevalue'
-    },
-    'env:': async function envResolver(key) {
-      return process.env[key]
-    },
-    'opt:': async function optResolver(key) {
-      return process.env[`opt_${key}`] || null
-    }
-  }
-}
-
-async function resolveVariables(variableArray) {
-  // Sort by resolveOrder to ensure inner variables are resolved first
-  const sortedArray = [...variableArray].sort((a, b) => a.resolveOrder - b.resolveOrder)
-  const resolvedValues = {}
-  const resolvers = getResolvers()
-  
-  for (const item of sortedArray) {
-    let resolvedValue = null
-    
-    if (item.hasFallback) {
-      // Try to resolve the primary value
-      const resolver = resolvers[item.varType]
-      const primaryKey = item.valueBeforeFallback.replace(`${item.varType}`, '')
-      resolvedValue = await resolver(primaryKey)
-      
-      // If primary value is null, try fallbacks in order
-      if (resolvedValue === null) {
-        for (const fallback of item.fallbackValues) {
-          if (fallback.isVariable) {
-            // This is a reference to another variable that should be already resolved
-            const placeholderMatch = fallback.variable.match(/__VAR_(\d+)__/)
-            if (placeholderMatch) {
-              resolvedValue = resolvedValues[`__VAR_${placeholderMatch[1]}__`]
-              if (resolvedValue !== null) break
-            } else {
-              // It's a direct variable reference
-              const varType = fallback.variable.split(':')[0] + ':'
-              const varKey = fallback.variable.replace(`${varType}`, '')
-              resolvedValue = await resolvers[varType](varKey)
-              if (resolvedValue !== null) break
-            }
-          } else {
-            // It's a literal value
-            resolvedValue = fallback.variable.replace(/"/g, '')
-            break
-          }
-        }
-      }
-    } else if (item.varType.startsWith('file')) {
-      // Handle file type specially as it requires the resolved path
-      let filePath = item.varString
-      for (const [placeholder, value] of Object.entries(resolvedValues)) {
-        filePath = filePath.replace(placeholder, value)
-      }
-      resolvedValue = await resolvers['file'](filePath)
-    } else {
-      // Simple variable resolution
-      const resolver = resolvers[item.varType]
-      const key = item.variable.replace(`${item.varType}`, '')
-      resolvedValue = await resolver(key)
-    }
-    
-    resolvedValues[item.placeholder] = resolvedValue
-  }
-  
-  return resolvedValues
-}
-
-
-const array = [
-  {
-    location: 'xyz',
-    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
-    fullMatch: '${env:foo}',
-    variable: 'env:foo',
-    varString: 'env:foo',
-    resolveOrder: 1,
-    start: 45,
-    end: 55,
-    placeholder: '__VAR_0__',
-    varType: 'env:'
-  },
-  {
-    location: 'xyz',
-    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
-    fullMatch: '${opt:stageOne, ${env:foo}}',
-    variable: 'opt:stageOne, ${env:foo}',
-    varString: 'opt:stageOne, __VAR_0__',
-    resolveOrder: 2,
-    start: 29,
-    end: 55,
-    placeholder: '__VAR_1__',
-    varType: 'opt:',
-    hasFallback: true,
-    valueBeforeFallback: 'opt:stageOne',
-    fallbackValues: [
-      {
-        isVariable: true,
-        variable: 'env:foo',
-        fullMatch: '${env:foo}'
-      }
-    ]
-  },
-  {
-    location: 'xyz',
-    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
-    fullMatch: '${opt:stageTwo}',
-    variable: 'opt:stageTwo',
-    varString: 'opt:stageTwo',
-    resolveOrder: 3,
-    start: 40,
-    end: 55,
-    placeholder: '__VAR_2__',
-    varType: 'opt:'
-  },
-  {
-    location: 'xyz',
-    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
-    fullMatch: '${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }',
-    variable: 'opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three"',
-    varString: 'opt:stage, __VAR_1__, __VAR_2__, "three"',
-    resolveOrder: 4,
-    start: 16,
-    end: 60,
-    placeholder: '__VAR_3__',
-    varType: 'opt:',
-    hasFallback: true,
-    valueBeforeFallback: 'opt:stage',
-    fallbackValues: [
-      {
-        isVariable: true,
-        variable: 'opt:stageOne, ${env:foo}',
-        fullMatch: '${opt:stageOne, ${env:foo}}'
-      },
-      {
-        isVariable: true,
-        variable: 'opt:stageTwo',
-        fullMatch: '${opt:stageTwo}'
-      },
-      { isVariable: false, variable: '"three"', fullMatch: '"three"' }
-    ]
-  },
-  {
-    location: 'xyz',
-    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
-    fullMatch: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
-    variable: 'file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)',
-    varString: 'file(./config.__VAR_3__.json)',
-    resolveOrder: 5,
-    start: 0,
-    end: 32,
-    placeholder: '__VAR_4__',
-    varType: 'file(./config.__VAR_3__.json)'
-  }
-]
-
-
-resolveVariables(array)
-.then((res) => {
-  console.log('res', res)
-})
-.catch((err) => {
-  console.log('err', err)
-})