Still WIP

js/entity/FormatTextEntity.js

@@ -1,55 +1,38 @@
-import Parsernostrum from "parsernostrum"
-import Grammar from "../serialization/Grammar.js"
-import AttributeInfo from "./AttributeInfo.js"
+import P from "parsernostrum"
 import IEntity from "./IEntity.js"
 import InvariantTextEntity from "./InvariantTextEntity.js"
 import LocalizedTextEntity from "./LocalizedTextEntity.js"
-import Union from "./Union.js"
+import StringEntity from "./StringEntity.js"
 
 export default class FormatTextEntity extends IEntity {
 
-    static attributes = {
-        ...super.attributes,
-        value: new AttributeInfo({
-            type: [new Union(String, LocalizedTextEntity, InvariantTextEntity, FormatTextEntity)],
-            default: [],
-        }),
-        lookbehind: /** @type {AttributeInfo<Union<String[]>>} */(new AttributeInfo({
-            ...super.attributes.lookbehind,
-            default: new Union("LOCGEN_FORMAT_NAMED", "LOCGEN_FORMAT_ORDERED"),
-        })),
-    }
-    static grammar = this.createGrammar()
-
-    static createGrammar() {
-        return Parsernostrum.seq(
-            Parsernostrum.reg(
-                // Resulting regex: /(LOCGEN_FORMAT_NAMED|LOCGEN_FORMAT_ORDERED)\s*/
-                new RegExp(`(${this.attributes.lookbehind.default.values.reduce((acc, cur) => acc + "|" + cur)})\\s*`),
-                1
-            ),
-            Grammar.grammarFor(this.attributes.value)
-        )
-            .map(([lookbehind, values]) => {
-                const result = new this({
-                    value: values,
-                    lookbehind,
-                })
-                return result
-            })
-    }
+    static lookbehind = ["LOCGEN_FORMAT_NAMED", "LOCGEN_FORMAT_ORDERED"]
+    static grammar = P.seq(
+        // Resulting regex: /(LOCGEN_FORMAT_NAMED|LOCGEN_FORMAT_ORDERED)\s*/
+        P.reg(new RegExp(String.raw`(${this.lookbehind.reduce((acc, cur) => acc + "|" + cur)})\s*\(\s*)`), 1),
+        P.alt(
+            ...[StringEntity, LocalizedTextEntity, InvariantTextEntity, FormatTextEntity].map(type => type.grammar)
+        ).sepBy(P.reg(/\s*\,\s*/)),
+        P.reg(/\s*\)/)
+    )
+        .map(([lookbehind, values]) => {
+            const result = new this(values)
+            result.lookbehind = lookbehind
+            return result
+        })
 
+    /** @param {(StringEntity | LocalizedTextEntity | InvariantTextEntity | FormatTextEntity)[]} values */
     constructor(values) {
-        super(values)
-        /** @type {(String | LocalizedTextEntity | InvariantTextEntity | FormatTextEntity)[]} */ this.value
+        super()
+        this.values = values
     }
 
     toString() {
-        const pattern = this.value?.[0]?.toString() // The pattern is always the first element of the array
+        const pattern = this.values?.[0]?.toString() // The pattern is always the first element of the array
         if (!pattern) {
             return ""
         }
-        const values = this.value.slice(1).map(v => v.toString())
+        const values = this.values.slice(1).map(v => v.toString())
         return this.lookbehind == "LOCGEN_FORMAT_NAMED"
             ? pattern.replaceAll(/\{([a-zA-Z]\w*)\}/g, (substring, arg) => {
                 const argLocation = values.indexOf(arg) + 1