feat: split variables with quotes support

Author: yyxi

package.json

@@ -10,6 +10,7 @@
   "dependencies": {
     "arg": "^5.0.2",
     "lodash-es": "^4.17.21",
+    "split-string": "^6.1.0",
     "string-width": "^7.2.0",
     "wrap-ansi": "^9.0.0"
   },

pnpm-lock.yaml

@@ -56,13 +56,17 @@ export const composeFactory =
   <T extends Command>(command: T, _settings: Partial<Settings> = {}) => {
     assert.command(command)
 
-    const settings: Settings = defaults({ ..._settings }, { help: true, split: ':' })
+    // TODO: validate settings
+    const settings: Settings = defaults({ ..._settings }, {
+      // help: true,
+      quotes: ['"', "'"],
+      separator: ':',
+    } satisfies Settings)
 
     const intents = listIntent(extract(command))
 
     return async (userContext = {}): Promise<void> => {
       // TODO: assert user context
-
       const context = defaultContext(presetContext, userContext)
 
       try {

src/compose/compose-factory.ts

@@ -30,7 +30,7 @@ export const usageInputChoice = (
             choices.length === 1
               ? choices[0]
               : `(${join(
-                  map(choices, (choice) => `${properties.settings.split}${choice}`),
+                  map(choices, (choice) => `${properties.settings.separator}${choice}`),
                   HELP_SIGN_OR,
                 )})`
           }${repeat ? `${HELP_SIGN_REPEAT}` : ''}`,

src/help/inputs/input-choice.ts

@@ -26,7 +26,7 @@ export const usageInputString = (
         ? undefined
         : `${enclose(variables)}=${
             repeat
-              ? `<string>[${properties.settings.split}<string>]${HELP_SIGN_REPEAT}`
+              ? `<string>[${properties.settings.separator}<string>]${HELP_SIGN_REPEAT}`
               : '<string>'
           }`,
   }

src/help/inputs/input-string.ts

@@ -76,6 +76,25 @@ describe('input/string/reducer', () => {
     })
   })
 
+  it('...', async () => {
+    const { cmd, spy } = withRepeat()
+
+    await cmd({ argv: [], env: {} })
+
+    assert.deepEqual(spy.mock.calls[0][0], {
+      string: ['picture'],
+    })
+
+    await cmd({
+      argv: ['--str', '!', '--str', 'ABC'],
+      env: { STRING: '"Hello:Hello":"World"' },
+    })
+
+    assert.deepEqual(spy.mock.calls[1][0], {
+      string: ['!', 'ABC', 'Hello:Hello', 'World'],
+    })
+  })
+
   it('...', async () => {
     const { cmd, spy } = withoutRepeat()
 

src/input/string/reducer.spec.ts

@@ -1,5 +1,3 @@
-/* eslint-disable typescript/no-unsafe-function-type */
-
 import type { FluentInterface, Model, SYMBOL_LOG, SYMBOL_STATE } from '@escapace/fluent'
 import type $ from '@escapace/typelevel'
 import type { InputBoolean } from './input/boolean/types'
@@ -97,9 +95,8 @@ export type UnionMerge<T extends object> =
     : never
 
 export interface Settings {
-  // TODO: custom help function
-  help: boolean | Function
-  split: string
+  quotes: string[]
+  separator: string
 }
 
 interface Console {

src/types.ts

@@ -1,4 +1,5 @@
-import { flatMap, map, split } from 'lodash-es'
+import { map } from 'lodash-es'
+import split from 'split-string'
 import type { InputChoiceProperties } from '../input/choice/types'
 import type { InputStringProperties } from '../input/string/types'
 import {
@@ -7,15 +8,54 @@ import {
   type GenericVariable,
   InputType,
   type NormalizedStringValue,
+  type Settings,
 } from '../types'
+import { trimWhitespace, unquote } from './unquote'
+
+function trimArrayWhitespace(array: string[]): string[] {
+  // Remove excess whitespace and newline strings from the beginning
+  while (array.length > 0 && /^\p{Z}*$/u.test(array[0])) {
+    array.shift()
+  }
+
+  // Remove excess whitespace and newline strings from the end
+  while (array.length > 0 && /^\p{Z}*$/u.test(array[array.length - 1])) {
+    array.pop()
+  }
+
+  return array
+}
+
+const normalizeVariableString = (
+  value: string,
+  options: {
+    repeat: boolean
+  } & Pick<Settings, 'quotes' | 'separator'>,
+): string[] => {
+  const lines = trimArrayWhitespace(value.split(/\r?\n/))
+
+  if (lines.length > 1) {
+    return [lines.join('\n')]
+  }
+
+  const string = lines[0] ?? ''
+
+  if (!options.repeat) {
+    return [unquote(trimWhitespace(string), options.quotes)]
+  }
+
+  return split(string, { quotes: options.quotes, separator: options.separator }).map((value) =>
+    unquote(value, options.quotes),
+  )
+}
 
 export function normalizeString(
   previousValues: DeNormalizedStringValue[],
   properties: InputChoiceProperties | InputStringProperties,
 ): NormalizedStringValue[] {
   const { repeat } = properties.model.state
 
-  return flatMap(previousValues, (previousValue) => {
+  return map(previousValues, (previousValue) => {
     if (previousValue.type === InputType.Option) {
       return repeat
         ? map(
@@ -27,15 +67,18 @@ export function normalizeString(
           )
         : (previousValue as GenericOption<string>)
     } /* (previousValue.type === InputType.Variable) */ else {
-      return repeat
-        ? map(
-            split(previousValue.value, properties.settings.split),
-            (value): GenericVariable<string> => ({
-              ...previousValue,
-              value,
-            }),
-          )
-        : previousValue
+      const asd: Array<GenericVariable<string>> = normalizeVariableString(previousValue.value, {
+        quotes: properties.settings.quotes,
+        repeat,
+        separator: properties.settings.separator,
+      }).map(
+        (value): GenericVariable<string> => ({
+          ...previousValue,
+          value,
+        }),
+      )
+
+      return asd
     }
-  })
+  }).flat()
 }

src/utilities/normalize.ts

@@ -0,0 +1,40 @@
+import assert from 'node:assert'
+import { describe, it } from 'vitest'
+import { unquote } from './unquote'
+
+describe('unquote', () => {
+  it('should remove matching quotes from a string', () => {
+    const quotes = ['"', "'"]
+    const input = '\'"hello"\''
+    const result = unquote(input, quotes)
+    assert.strictEqual(result, 'hello')
+  })
+
+  it('should handle nested quotes correctly', () => {
+    const quotes = ['"', "'"]
+    const input = '"\'hello\'"'
+    const result = unquote(input, quotes)
+    assert.strictEqual(result, 'hello')
+  })
+
+  it('should ignore leading and trailing whitespace', () => {
+    const quotes = ['"', "'"]
+    const input = "  ' hello '  "
+    const result = unquote(input, quotes)
+    assert.strictEqual(result, 'hello')
+  })
+
+  it('should return the input string if no quotes match', () => {
+    const quotes = ['"', "'"]
+    const input = 'no quotes'
+    const result = unquote(input, quotes)
+    assert.strictEqual(result, 'no quotes')
+  })
+
+  it('should handle empty strings gracefully', () => {
+    const quotes = ['"', "'"]
+    const input = ''
+    const result = unquote(input, quotes)
+    assert.strictEqual(result, '')
+  })
+})

src/utilities/unquote.spec.ts

@@ -0,0 +1,12 @@
+export const trimWhitespace = (value: string): string => value.replace(/^\p{Z}+|\p{Z}+$/gu, '')
+
+export function unquote(input: string, quotes: string[]): string {
+  let result = trimWhitespace(input)
+
+  // eslint-disable-next-line typescript/no-loop-func
+  while (quotes.some((quote) => result.startsWith(quote) && result.endsWith(quote))) {
+    result = trimWhitespace(result.slice(1, -1))
+  }
+
+  return result
+}