more permissive input type

README.md

···
 
 ## Input Format
 
+> **Disclaimer:**
+> The exported `TreeInput` type (`Array<string | TreeInput>`) is intentionally flexible to support dynamic and programmatic tree construction. However, TypeScript cannot enforce at the type level that the first element is a string. This requirement is checked at runtime by the `treeify` function, which will throw an error if the first element is not a string. Please ensure your input arrays follow this convention.
+
 The `treeify` function accepts arrays with the following structure:
 
 1. First element must be a string (the root node)

src/index.ts

···
 /**
- * Represents a node in the tree structure.
- * Can be either a string (a leaf node) or an array of TreeNodes (a branch with children).
+ * The strict tree input format. Must start with a string.
+ * This type is exported for testing purposes and advanced usage.
  */
-type TreeNode = string | TreeNode[]
+export type TreeInput = Array<string | TreeInput>
 
 /**
- * The strict tree input format. Must start with a string.
- * This type is exported for testing purposes and advanced usage.
+ * Represents a node in the tree structure.
+ * Can be either a string (a leaf node) or an array of TreeNodes (a branch with children).
  */
-export type TreeInput = [string, ...Array<string | TreeNode[]>] | string[]
+type TreeNode = string | TreeNode[]
 
 /**
  * Flexible input type that accepts any array.
···
  */
 type FlexibleTreeInput = readonly (string | unknown[])[]
 
-type TreeChars = {
+/**
+ * ASCII characters used to render the tree.
+ */
+export type TreeChars = {
   branch: string
   lastBranch: string
   pipe: string
   space: string
 }
 
-/**
- * @description ASCII characters used to render the tree.
- */
 const DEFAULT_CHARS: TreeChars = {
   branch: '├─ ',
   lastBranch: '└─ ',

src/types.test.ts

···
 import type { TreeInput } from './index.js'
 
 describe('treeify types', () => {
-  test('input with values', () => {
+  test('input values', () => {
     const inputWithValues: TreeInput = ['root', ['child1', 'child2', 'child3']]
     let result = treeify(inputWithValues)
     assert.ok(result)
 
-    const inputWithoutValues: TreeInput = []
-    result = treeify(inputWithoutValues)
+    const emptyInput: TreeInput = []
+    result = treeify(emptyInput)
     assert.equal(result, '') // empty string
 
+    const inputBuildUp: TreeInput = []
+    inputBuildUp.push('root')
+    inputBuildUp.push(['child1', 'child2', 'child3'])
+    inputBuildUp.push('root2', ['cousin1', 'cousin2', 'cousin3'])
+    result = treeify(inputBuildUp)
+    assert.ok(result)
+
     // @ts-expect-error
     const inputWithoutRootString: TreeInput = [{ bad: 'root' }, 'root2']
     assert.throws(() => treeify(inputWithoutRootString), {
       message: 'First element must be a string',
     })
 
+    const inputWithRootStringAndInvalidValues: TreeInput = ['root']
     // @ts-expect-error
-    const inputWithRootStringAndInvalidValues: TreeInput = [
-      'root',
-      1,
-      {},
-      ['child1', 'child2', 'child3'],
-    ]
+    inputWithRootStringAndInvalidValues.push(1)
+    // @ts-expect-error
+    inputWithRootStringAndInvalidValues.push({}, [], Number.POSITIVE_INFINITY)
     result = treeify(inputWithRootStringAndInvalidValues)
     assert.ok(result) // non-strings are ignored
+  })
+
+  test('generated inputs', () => {
+    function generateInput(): TreeInput {
+      const out: TreeInput = []
+      out.push('root')
+      out.push(['child1', 'child2', 'child3'])
+      return out
+    }
+
+    const input: TreeInput = ['root', generateInput()]
+    input.push(generateInput())
+
+    assert.ok(treeify(input))
   })
 })