refactor: re-arrange source code files

src/edge/main.ts

@@ -12,7 +12,7 @@ import { Loader } from '../loader.js'
 import { Compiler } from '../compiler.js'
 import { Template } from '../template.js'
 import { Processor } from '../processor.js'
-import { EdgeRenderer } from '../renderer.js'
+import { EdgeRenderer } from './renderer.js'
 import type { TagContract, EdgeOptions, LoaderTemplate, LoaderContract } from '../types.js'
 
 /**

src/renderer.ts → src/edge/renderer.ts

@@ -9,9 +9,9 @@
 
 import lodash from '@poppinss/utils/lodash'
 
-import { Template } from './template.js'
-import { Processor } from './processor.js'
-import type { Compiler } from './compiler.js'
+import { Template } from '../template.js'
+import { Processor } from '../processor.js'
+import type { Compiler } from '../compiler.js'
 
 /**
  * Renders a given template with it's shared state

src/tags/component.ts

@@ -13,8 +13,7 @@ import type { TagToken } from 'edge-lexer/types'
 import { EdgeBuffer, expressions, Parser } from 'edge-parser'
 
 import type { TagContract } from '../types.js'
-import { StringifiedObject } from '../stringified_object.js'
-import { isSubsetOf, unallowedExpression, parseJsArg } from '../utils.js'
+import { isSubsetOf, unallowedExpression, parseJsArg, StringifiedObject } from '../utils.js'
 
 /**
  * A list of allowed expressions for the component name

src/template.ts

@@ -23,7 +23,7 @@ import { CompiledTemplate } from './types.js'
  * method ensures that underlying value is never
  * escaped.
  */
-export class SafeValue {
+class SafeValue {
   constructor(public value: any) {}
 }
 

src/utils.ts

@@ -135,3 +135,88 @@ export async function asyncEach(
     }
   }
 }
+
+/**
+ * This class generates a valid object as a string, which is written to the template
+ * output. The reason we need a string like object, since we don't want it's
+ * properties to be evaluated during the object creation, instead it must
+ * be evaluated when the compiled output is invoked.
+ */
+export class StringifiedObject {
+  #obj: string = ''
+
+  addSpread(key: string) {
+    this.#obj += this.#obj.length ? `, ${key}` : `${key}`
+  }
+
+  /**
+   * Add key/value pair to the object.
+   *
+   * ```js
+   * stringifiedObject.add('username', `'virk'`)
+   * ```
+   */
+  add(key: any, value: any, isComputed: boolean = false) {
+    key = isComputed ? `[${key}]` : key
+    this.#obj += this.#obj.length ? `, ${key}: ${value}` : `${key}: ${value}`
+  }
+
+  /**
+   * Returns the object alike string back.
+   *
+   * ```js
+   * stringifiedObject.flush()
+   *
+   * // returns
+   * `{ username: 'virk' }`
+   * ```
+   */
+  flush(): string {
+    const obj = `{ ${this.#obj} }`
+    this.#obj = ''
+    return obj
+  }
+
+  /**
+   * Parses an array of expressions to form an object. Each expression inside the array must
+   * be `ObjectExpression` or an `AssignmentExpression`, otherwise it will be ignored.
+   *
+   * ```js
+   * (title = 'hello')
+   * // returns { title: 'hello' }
+   *
+   * ({ title: 'hello' })
+   * // returns { title: 'hello' }
+   *
+   * ({ title: 'hello' }, username = 'virk')
+   * // returns { title: 'hello', username: 'virk' }
+   * ```
+   */
+  static fromAcornExpressions(expressions: any[], parser: Parser): string {
+    if (!Array.isArray(expressions)) {
+      throw new Error('"fromAcornExpressions" expects an array of acorn ast expressions')
+    }
+
+    const objectifyString = new this()
+
+    expressions.forEach((arg) => {
+      if (arg.type === 'ObjectExpression') {
+        arg.properties.forEach((prop: any) => {
+          if (prop.type === 'SpreadElement') {
+            objectifyString.addSpread(parser.utils.stringify(prop))
+          } else {
+            const key = parser.utils.stringify(prop.key)
+            const value = parser.utils.stringify(prop.value)
+            objectifyString.add(key, value, prop.computed)
+          }
+        })
+      }
+
+      if (arg.type === 'AssignmentExpression') {
+        objectifyString.add(arg.left.name, parser.utils.stringify(arg.right))
+      }
+    })
+
+    return objectifyString.flush()
+  }
+}

tests/stringified_object.spec.ts

@@ -9,7 +9,7 @@
 
 import { test } from '@japa/runner'
 import { Parser, Stack } from 'edge-parser'
-import { StringifiedObject } from '../src/stringified_object.js'
+import { StringifiedObject } from '../src/utils.js'
 
 /**
  * Sample loc