configorama 0.6.12 → 0.6.13

package/src/utils/strings/splitCsv.test.js

@@ -0,0 +1,96 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { splitCsv } = require('./splitCsv')
+
+// Tests for default comma splitting (uses splitByComma internally)
+test('splitCsv - should split simple comma-separated values', () => {
+  const result = splitCsv('first,second,third')
+  assert.equal(result, ['first', 'second', 'third'])
+})
+
+test('splitCsv - should handle spaces around commas', () => {
+  const result = splitCsv('first, second, third')
+  assert.equal(result, ['first', 'second', 'third'])
+})
+
+test('splitCsv - should preserve quoted strings with commas', () => {
+  const result = splitCsv("'string, with comma', normal")
+  assert.equal(result, ["'string, with comma'", 'normal'])
+})
+
+test('splitCsv - should handle double quotes', () => {
+  const result = splitCsv('"quoted, value", normal')
+  assert.equal(result, ['"quoted, value"', 'normal'])
+})
+
+test('splitCsv - should handle parentheses (function calls)', () => {
+  const result = splitCsv('func(arg1, arg2), other')
+  assert.equal(result, ['func(arg1, arg2)', 'other'])
+})
+
+test('splitCsv - should handle square brackets (arrays)', () => {
+  const result = splitCsv('[item1, item2], other')
+  assert.equal(result, ['[item1, item2]', 'other'])
+})
+
+test('splitCsv - should return array with single element when no commas', () => {
+  const result = splitCsv('singleValue')
+  assert.equal(result, ['singleValue'])
+})
+
+test('splitCsv - should handle empty string', () => {
+  const result = splitCsv('')
+  assert.equal(result, [''])
+})
+
+// Tests for custom splitter (uses original simple implementation)
+test('splitCsv - should use custom splitter', () => {
+  const result = splitCsv('first|second|third', '|')
+  assert.equal(result, ['first', 'second', 'third'])
+})
+
+test('splitCsv - should preserve quoted content with custom splitter', () => {
+  const result = splitCsv('first|"quoted|content"|third', '|')
+  assert.equal(result, ['first', '"quoted|content"', 'third'])
+})
+
+test('splitCsv - should handle semicolon splitter', () => {
+  const result = splitCsv('a;b;c', ';')
+  assert.equal(result, ['a', 'b', 'c'])
+})
+
+test('splitCsv - custom splitter with quotes preserving internal splitters', () => {
+  const result = splitCsv('"has;semicolon";normal', ';')
+  assert.equal(result, ['"has;semicolon"', 'normal'])
+})
+
+// Edge cases
+test('splitCsv - should handle mixed quotes and brackets', () => {
+  const result = splitCsv('[array], "string", func(a, b)')
+  assert.equal(result, ['[array]', '"string"', 'func(a, b)'])
+})
+
+test('splitCsv - should handle deeply nested structures', () => {
+  const result = splitCsv('func(obj[0, 1], "str, comma"), other')
+  assert.equal(result, ['func(obj[0, 1], "str, comma")', 'other'])
+})
+
+test('splitCsv - should handle serverless variable syntax', () => {
+  const result = splitCsv('opt:stage, ${opt:stageOne}')
+  // Default behavior splits inside ${}, but splitByComma handles this better
+  // This test just verifies it doesn't crash
+  assert.ok(Array.isArray(result))
+})
+
+test('splitCsv - should preserve whitespace in quoted strings', () => {
+  const result = splitCsv('"  spaces  ", normal')
+  assert.equal(result, ['"  spaces  "', 'normal'])
+})
+
+test('splitCsv - should handle consecutive commas with custom splitter', () => {
+  const result = splitCsv('a||c', '|')
+  assert.equal(result, ['a', '', 'c'])
+})
+
+// Run all tests
+test.run()

package/src/utils/strings/textUtils.test.js

@@ -0,0 +1,86 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { getTextAfterOccurrence, findNestedVariable } = require('./textUtils')
+
+// Tests for getTextAfterOccurrence
+test('getTextAfterOccurrence - should return text after first occurrence', () => {
+  const result = getTextAfterOccurrence('hello world, hello again', 'world')
+  assert.equal(result, 'world, hello again')
+})
+
+test('getTextAfterOccurrence - should return empty string when search not found', () => {
+  const result = getTextAfterOccurrence('hello world', 'xyz')
+  assert.equal(result, '')
+})
+
+test('getTextAfterOccurrence - should handle search at start of string', () => {
+  const result = getTextAfterOccurrence('start of text', 'start')
+  assert.equal(result, 'start of text')
+})
+
+test('getTextAfterOccurrence - should handle search at end of string', () => {
+  const result = getTextAfterOccurrence('end of text', 'text')
+  assert.equal(result, 'text')
+})
+
+test('getTextAfterOccurrence - should handle empty search string', () => {
+  const result = getTextAfterOccurrence('hello', '')
+  assert.equal(result, 'hello')
+})
+
+test('getTextAfterOccurrence - should return empty for empty source string', () => {
+  const result = getTextAfterOccurrence('', 'search')
+  assert.equal(result, '')
+})
+
+// Tests for findNestedVariable
+test('findNestedVariable - should find variable in original source', () => {
+  const split = ['env:VAR', 'default']
+  const originalSource = 'value is ${env:VAR}'
+  const result = findNestedVariable(split, originalSource)
+  assert.equal(result, 'env:VAR')
+})
+
+test('findNestedVariable - should return undefined when not found', () => {
+  const split = ['env:VAR', 'default']
+  const originalSource = 'no variables here'
+  const result = findNestedVariable(split, originalSource)
+  assert.equal(result, undefined)
+})
+
+test('findNestedVariable - should find first matching variable', () => {
+  const split = ['env:ONE', 'env:TWO']
+  const originalSource = '${env:TWO} and ${env:ONE}'
+  const result = findNestedVariable(split, originalSource)
+  assert.equal(result, 'env:ONE')
+})
+
+test('findNestedVariable - should handle non-string source', () => {
+  const split = ['env:VAR']
+  const originalSource = null
+  const result = findNestedVariable(split, originalSource)
+  assert.equal(result, undefined)
+})
+
+test('findNestedVariable - should handle undefined source', () => {
+  const split = ['env:VAR']
+  const result = findNestedVariable(split, undefined)
+  assert.equal(result, undefined)
+})
+
+test('findNestedVariable - should handle empty split array', () => {
+  const split = []
+  const originalSource = '${env:VAR}'
+  const result = findNestedVariable(split, originalSource)
+  assert.equal(result, undefined)
+})
+
+test('findNestedVariable - should match exact variable syntax', () => {
+  const split = ['env:VAR']
+  const originalSource = 'env:VAR without braces'
+  const result = findNestedVariable(split, originalSource)
+  assert.equal(result, undefined)
+})
+
+// Run all tests
+test.run()

package/src/utils/{configWizard.js → ui/configWizard.js}

@@ -5,6 +5,36 @@ const dotProp = require('dot-prop')
 const fs = require('fs')
 const path = require('path')
 
+const INVISIBLE_SPACE = '\u2800\u2800\u2800'
+
+/**
+ * Prefixes each line of multiline text with INVISIBLE_SPACE repeated a specified number of times
+ * @param {number} count - Number of times to repeat INVISIBLE_SPACE for prefix
+ * @param {string} text - Multiline text to prefix
+ * @returns {string} Text with each line prefixed with INVISIBLE_SPACE
+ */
+function prefixMultilineText(count, text) {
+  if (!text) return text
+  const prefix = INVISIBLE_SPACE.repeat(count)
+  return text.split('\n').map(line => `${prefix}${line}`).join('\n')
+}
+
+/**
+ * Formats multiline text for wizard display with leading pipe and invisible space indentation
+ * @param {number} indentCount - Number of times to repeat INVISIBLE_SPACE for indentation
+ * @param {string} text - Multiline text to format
+ * @param {boolean} addLeadingEmptyLine - Whether to add empty line with pipe before first line (default: true)
+ * @returns {string} Formatted text with pipe prefix and indentation
+ */
+function formatWizardMultilineText(indentCount, text, addLeadingEmptyLine = true) {
+  if (!text) return text
+  const indent = INVISIBLE_SPACE.repeat(indentCount)
+  const lines = text.split('\n')
+  const formattedLines = lines.map(line => `${chalk.gray('│')}${indent}${line}`)
+  const leadingLine = addLeadingEmptyLine ? `${chalk.gray('│')}\n` : '\n'
+  return leadingLine + formattedLines.join('\n') + `\n${chalk.gray('│')}`
+}
+
 /**
  * Groups variables by type for wizard flow
  * @param {object} uniqueVariables - The uniqueVariables from enriched metadata
@@ -16,13 +46,14 @@ function groupVariablesByType(uniqueVariables, originalConfig = {}) {
     options: [],
     env: [],
     self: [],
+    dotProp: [],
   }
 
   // Track variables we've already added to avoid duplicates
   const addedVars = new Set()
 
   for (const [varKey, varData] of Object.entries(uniqueVariables)) {
-    const { variable, variableType, isRequired, defaultValue, defaultValueSrc, occurrences, innerVariables, hasValue } = varData
+    const { variable, variableType, isRequired, defaultValue, defaultValueSrc, occurrences, innerVariables, hasValue, resolvedValue } = varData
 
     // Handle top-level variables (not file/text types)
     if (variableType !== 'file' && variableType !== 'text') {
@@ -92,6 +123,7 @@ function groupVariablesByType(uniqueVariables, originalConfig = {}) {
           isRequired: hasRequiredOccurrence,
           defaultValue: availableDefault,
           hasFallback: !!availableDefault,
+          resolvedValue,
           occurrences: occurrences || [],
         }
 
@@ -101,6 +133,8 @@ function groupVariablesByType(uniqueVariables, originalConfig = {}) {
           grouped.env.push(varInfo)
         } else if (variableType === 'self') {
           grouped.self.push(varInfo)
+        } else if (variableType === 'dot.prop') {
+          grouped.dotProp.push(varInfo)
         }
       }
     }
@@ -286,6 +320,29 @@ function getHelpText(varData) {
   return null
 }
 
+/**
+ * Extracts allowed values from description text like "Deployment stage (dev, staging, production)"
+ * @param {object} varData - Variable data with descriptions array or occurrences
+ * @returns {string[]|null} Array of allowed values or null if not found
+ */
+function getAllowedValues(varData) {
+  const helpText = getHelpText(varData)
+  if (!helpText) return null
+
+  // Match pattern like (value1, value2, value3) at end of description
+  const match = helpText.match(/\(([^)]+)\)\s*$/)
+  if (!match) return null
+
+  const valuesStr = match[1]
+  const values = valuesStr.split(',').map(v => v.trim()).filter(Boolean)
+
+  // Only treat as allowed values if we have 2+ options and they look like simple values
+  if (values.length < 2) return null
+  if (values.some(v => v.includes(' ') && !v.match(/^['"].*['"]$/))) return null
+
+  return values
+}
+
 /**
  * Creates a human-readable prompt message
  * @param {object} varInfo - Variable info
@@ -301,6 +358,8 @@ function createPromptMessage(varInfo) {
     typeLabel = 'Env'
   } else if (variableType === 'self') {
     typeLabel = 'Config'
+  } else if (variableType === 'dot.prop') {
+    typeLabel = 'Config'
   } else {
     typeLabel = 'Value'
   }
@@ -338,8 +397,8 @@ function createPromptMessage(varInfo) {
 
       // Strip help() filter from the displayed value
       if (originalValue && typeof originalValue === 'string') {
-        // Remove | help('...') including nested parens
-        originalValue = originalValue.replace(/\s*\|\s*help\([^)]*(?:\([^)]*\))?[^)]*\)/g, '')
+        // Remove | help('...') or | help("...") - match quoted string inside help()
+        originalValue = originalValue.replace(/\s*\|\s*help\(('[^']*'|"[^"]*")\)/g, '')
       }
 
       if (keyPath && originalValue) {
@@ -360,8 +419,13 @@ function createPromptMessage(varInfo) {
 
     if (parsedOccurrences.length > 0) {
       // Get the variable reference syntax
-      const varPrefix = variableType === 'options' ? 'opt' : variableType === 'env' ? 'env' : 'self'
-      const varSyntax = `\${${varPrefix}:${cleanName}}`
+      let varSyntax
+      if (variableType === 'dot.prop') {
+        varSyntax = `\${${cleanName}}`
+      } else {
+        const varPrefix = variableType === 'options' ? 'opt' : variableType === 'env' ? 'env' : 'self'
+        varSyntax = `\${${varPrefix}:${cleanName}}`
+      }
 
       // Show variable syntax and count (only if no descriptions, otherwise it's redundant)
       if (descriptions.length === 0) {
@@ -371,16 +435,17 @@ function createPromptMessage(varInfo) {
       // Find longest key for alignment
       const maxKeyLength = Math.max(...parsedOccurrences.map(o => o.key.length))
 
+      // Count unique descriptions
+      const uniqueDescriptions = new Set(parsedOccurrences.map(o => o.description).filter(Boolean))
+
       // List all occurrences with bullets and aligned values (using invisible unicode for indentation)
-      const indent = '\u2800\u2800\u2800' // Braille blank pattern (invisible but not stripped)
-      const usageList = parsedOccurrences.map(({ key, value, description }, index) => {
+      const usageLines = parsedOccurrences.map(({ key, value, description }) => {
         const padding = ' '.repeat(maxKeyLength - key.length)
-        const leadingEmptyLine = index === 0 ? '│\n' : ''
-        // Only show inline description if there are multiple occurrences (otherwise it's redundant with header)
-        const descComment = description && parsedOccurrences.length > 1 ? ` - # ${description}` : ''
-        return value ? `${leadingEmptyLine}│${indent}- ${key}:${padding}    ${value}${descComment}` : `${leadingEmptyLine}│${indent}• ${key}${descComment}`
+        // Only show inline description if there are multiple unique descriptions
+        const descComment = description && uniqueDescriptions.size > 1 ? ` - # ${description}` : ''
+        return value ? `- ${key}:${padding}    ${value}${descComment}` : `• ${key}${descComment}`
       })
-      contextHint += '\n' + usageList.join('\n') + '\n│'
+      contextHint += '\n' + formatWizardMultilineText(1, usageLines.join('\n'))
     }
   }
 
@@ -408,7 +473,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
   }
 
   const grouped = groupVariablesByType(uniqueVariables, originalConfig)
-  const totalVars = grouped.options.length + grouped.env.length + grouped.self.length
+  const totalVars = grouped.options.length + grouped.env.length + grouped.self.length + grouped.dotProp.length
 
   if (totalVars === 0) {
     p.intro(chalk.cyan('Configuration Wizard'))
@@ -425,26 +490,94 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
     options: {},
     env: {},
     self: {},
+    dotProp: {},
   }
 
   // Prompt for options (CLI flags)
   if (grouped.options.length > 0) {
-    const flagsList = grouped.options.map(v => {
-      const varSyntax = `\${opt:${v.cleanName}}`
-      return `  - ${varSyntax}`
-    }).join('\n')
-    const noteContent = `Found ${grouped.options.length} CLI flag(s)\n${flagsList}`
+    const flagsList = grouped.options.map(v => `\${opt:${v.cleanName}}`)
+    const flagsDisplay = flagsList.length < 5
+      ? flagsList.join(', ')
+      : flagsList.map(f => ` - ${f}`).join('\n')
+    const addNewLine = flagsList.length > 5 ? '\n' : ' - '
+    const noteContent = `Found ${grouped.options.length} CLI flag(s)${addNewLine}${flagsDisplay}`
     p.note(noteContent, 'CLI Flags')
 
     for (const varInfo of grouped.options) {
       const message = createPromptMessage(varInfo)
       const isSensitive = isSensitiveVariable(varInfo.cleanName)
+      const expectedType = getExpectedType(varInfo.occurrences)
+      const allowedValues = getAllowedValues(varInfo)
+
+      let value
+      if (allowedValues && !isSensitive) {
+        // Use select picker for enumerated values
+        const options = allowedValues.map(v => ({ value: v, label: v }))
+        value = await p.select({
+          message,
+          options,
+          initialValue: varInfo.defaultValue || allowedValues[0]
+        })
+      } else {
+        const promptFn = isSensitive ? p.password : p.text
+        const placeholder = varInfo.hasFallback
+          ? `  ${varInfo.defaultValue} `
+          : `Enter value for --${varInfo.cleanName}`
+
+        value = await promptFn({
+          message,
+          placeholder,
+          validate: (val) => {
+            // Only required if no fallback exists
+            if (!val && varInfo.isRequired && !varInfo.hasFallback) {
+              return 'This value is required'
+            }
+            // Type validation
+            const typeError = validateType(val, expectedType)
+            if (typeError) return typeError
+          }
+        })
+      }
+
+      if (p.isCancel(value)) {
+        p.cancel('Setup cancelled')
+        process.exit(0)
+      }
+
+      userInputs.options[varInfo.cleanName] = value || varInfo.defaultValue
+    }
+  }
+
+  // Prompt for environment variables
+  if (grouped.env.length > 0) {
+    const envList = grouped.env.map(v => {
+      const varSyntax = `\${env:${v.cleanName}}`
+      return `  - ${varSyntax}`
+    }).join('\n')
+    const noteContent = `Found ${grouped.env.length} environment variable(s)\n${envList}`
+    p.note(noteContent, 'Environment Variables')
+
+    for (const varInfo of grouped.env) {
+      let message = createPromptMessage(varInfo)
+      const isSensitive = isSensitiveVariable(varInfo.cleanName)
       const promptFn = isSensitive ? p.password : p.text
       const expectedType = getExpectedType(varInfo.occurrences)
 
-      const placeholder = varInfo.hasFallback
-        ? `${varInfo.defaultValue} (default)`
-        : `Enter value for --${varInfo.cleanName}`
+      let placeholder
+      if (varInfo.resolvedValue !== undefined) {
+        if (isSensitive) {
+          // For sensitive vars, show hint in message since password prompts don't show placeholders
+          message += formatWizardMultilineText(1, chalk.green(`Notice: process.env.${varInfo.cleanName} set\nPress enter to use current value OR input a new value below`), false)
+          // placeholder doesn't work with password prompts
+          placeholder = ' enter to use current value or input a new value'
+        } else {
+          placeholder = `${varInfo.resolvedValue} (current env value)`
+        }
+      } else if (varInfo.hasFallback) {
+        placeholder = `${varInfo.defaultValue} (default)`
+      } else {
+        placeholder = `Enter environment variable for ${varInfo.cleanName}`
+      }
 
       const value = await promptFn({
         message,
@@ -465,20 +598,20 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
         process.exit(0)
       }
 
-      userInputs.options[varInfo.cleanName] = value || varInfo.defaultValue
+      userInputs.env[varInfo.cleanName] = value || varInfo.resolvedValue || varInfo.defaultValue
     }
   }
 
-  // Prompt for environment variables
-  if (grouped.env.length > 0) {
-    const envList = grouped.env.map(v => {
-      const varSyntax = `\${env:${v.cleanName}}`
+  // Prompt for self references (if any need values)
+  if (grouped.self.length > 0) {
+    const selfList = grouped.self.map(v => {
+      const varSyntax = `\${self:${v.cleanName}}`
       return `  - ${varSyntax}`
     }).join('\n')
-    const noteContent = `Found ${grouped.env.length} environment variable(s)\n${envList}`
-    p.note(noteContent, 'Environment Variables')
+    const noteContent = `Found ${grouped.self.length} config reference(s)\n${selfList}`
+    p.note(noteContent, 'Config References')
 
-    for (const varInfo of grouped.env) {
+    for (const varInfo of grouped.self) {
       const message = createPromptMessage(varInfo)
       const isSensitive = isSensitiveVariable(varInfo.cleanName)
       const promptFn = isSensitive ? p.password : p.text
@@ -486,7 +619,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
 
       const placeholder = varInfo.hasFallback
         ? `${varInfo.defaultValue} (default)`
-        : `Enter environment variable for ${varInfo.cleanName}`
+        : `Enter value for ${varInfo.cleanName}`
 
       const value = await promptFn({
         message,
@@ -507,20 +640,20 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
         process.exit(0)
       }
 
-      userInputs.env[varInfo.cleanName] = value || varInfo.defaultValue
+      userInputs.self[varInfo.cleanName] = value || varInfo.defaultValue
     }
   }
 
-  // Prompt for self references (if any need values)
-  if (grouped.self.length > 0) {
-    const selfList = grouped.self.map(v => {
-      const varSyntax = `\${self:${v.cleanName}}`
+  // Prompt for config dot.prop references
+  if (grouped.dotProp.length > 0) {
+    const configList = grouped.dotProp.map(v => {
+      const varSyntax = `\${${v.cleanName}}`
       return `  - ${varSyntax}`
     }).join('\n')
-    const noteContent = `Found ${grouped.self.length} config reference(s)\n${selfList}`
+    const noteContent = `Found ${grouped.dotProp.length} config reference(s)\n${configList}`
     p.note(noteContent, 'Config References')
 
-    for (const varInfo of grouped.self) {
+    for (const varInfo of grouped.dotProp) {
       const message = createPromptMessage(varInfo)
       const isSensitive = isSensitiveVariable(varInfo.cleanName)
       const promptFn = isSensitive ? p.password : p.text
@@ -549,7 +682,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
         process.exit(0)
       }
 
-      userInputs.self[varInfo.cleanName] = value || varInfo.defaultValue
+      userInputs.dotProp[varInfo.cleanName] = value || varInfo.defaultValue
     }
   }
 
@@ -565,6 +698,9 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
   if (Object.keys(userInputs.self).length === 0) {
     delete userInputs.self
   }
+  if (Object.keys(userInputs.dotProp).length === 0) {
+    delete userInputs.dotProp
+  }
 
   return userInputs
 }
@@ -576,5 +712,8 @@ module.exports = {
   createPromptMessage,
   getExpectedType,
   getHelpText,
+  getAllowedValues,
   validateType,
+  prefixMultilineText,
+  formatWizardMultilineText,
 }

package/src/utils/{createEditorLink.js → ui/createEditorLink.js}

@@ -7,7 +7,7 @@ const chalk = require('./chalk')
  * @param {number} line - Line number (default: 1)
  * @param {number} column - Column number (default: 1)
  * @param {string} customDisplay - Custom display text (default: filename:line)
- * @param {string} color - Chalk color for the link (default: 'cyanBright')
+ * @param {string|false} color - Chalk color for the link (default: 'cyanBright'), or false to skip coloring
  * @returns {string} The hyperlink string
  */
 function createEditorLink(filePath, line = 1, column = 1, customDisplay = null, color = 'cyanBright') {
@@ -15,7 +15,16 @@ function createEditorLink(filePath, line = 1, column = 1, customDisplay = null,
   const url = `cursor://file${absolutePath}:${line}:${column}`
   const display = customDisplay ? customDisplay: `${path.basename(filePath)}:${line}`
   
-  return `\x1b]8;;${url}\x1b\\${chalk[color](display)}\x1b]8;;\x1b\\`
+  let displayText = display
+  if (color !== false) {
+    if (typeof color === 'string' && color.startsWith('#')) {
+      displayText = chalk.hex(color)(display)
+    } else {
+      displayText = chalk[color](display)
+    }
+  }
+  
+  return `\x1b]8;;${url}\x1b\\${displayText}\x1b]8;;\x1b\\`
 }
 
 module.exports = {

package/src/utils/{logs.js → ui/logs.js}

@@ -1,14 +1,14 @@
-const { makeHeader } = require('@davidwells/box-logger')
+const { makeHeader, logHeader : logHeaderBox } = require('@davidwells/box-logger')
 
 function logHeader(message) {
-  console.log(makeHeader({
+  logHeaderBox({
     content: message, 
     rightBorder: true, 
     minWidth: 80, 
     textStyle: 'bold',
     borderStyle: 'bold',
     borderColor: 'cyanBright',
-  }))
+  })
 }
 
 module.exports = {

package/src/utils/validation/isValidValue.test.js

@@ -0,0 +1,64 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { isValidValue } = require('./warnIfNotFound')
+
+test('isValidValue - should return true for non-empty string', () => {
+  assert.is(isValidValue('hello'), true)
+})
+
+test('isValidValue - should return true for number', () => {
+  assert.is(isValidValue(42), true)
+  assert.is(isValidValue(0), true)
+})
+
+test('isValidValue - should return true for boolean', () => {
+  assert.is(isValidValue(true), true)
+  assert.is(isValidValue(false), true)
+})
+
+test('isValidValue - should return true for non-empty object', () => {
+  assert.is(isValidValue({ key: 'value' }), true)
+})
+
+test('isValidValue - should return true for non-empty array', () => {
+  assert.is(isValidValue([1, 2, 3]), true)
+})
+
+test.skip('isValidValue - should return false for null', () => {
+  assert.is(isValidValue(null), false)
+})
+
+test('isValidValue - should return false for undefined', () => {
+  assert.is(isValidValue(undefined), false)
+})
+
+test('isValidValue - should return false for empty object', () => {
+  assert.is(isValidValue({}), false)
+})
+
+test('isValidValue - should return false for empty array', () => {
+  assert.is(isValidValue([]), false)
+})
+
+test('isValidValue - should return false for object with __internal_only_flag', () => {
+  assert.is(isValidValue({ __internal_only_flag: true, data: 'value' }), false)
+})
+
+test('isValidValue - should return false for object with __internal_metadata', () => {
+  assert.is(isValidValue({ __internal_metadata: {}, data: 'value' }), false)
+})
+
+test('isValidValue - should return true for empty string', () => {
+  assert.is(isValidValue(''), true)
+})
+
+test.skip('isValidValue - should return true for date object', () => {
+  assert.is(isValidValue(new Date()), true)
+})
+
+test('isValidValue - should return true for function', () => {
+  assert.is(isValidValue(() => {}), true)
+})
+
+// Run all tests
+test.run()