Refactoring entities (#23)

* Still WIP * WIP * ArrayEntity parsing fixed * Fix format text entity * Tests for various entity classes and update entity class implementations * More tests and fixed * More entities fixed * Simple entities serialization fixed * Entities tests fixed * Remove serialization bits * Fix Function reference * CustomProperties creating fixed * WIP * Better typing for grammars * Decoding code fixes * Fixing still * Several fixes * rename toString to serialize * Several fixes * More fixes * Moving more stuff out of Utility * Several fixes * Fixing Linear color entity print * Serialization fixes * Fix serialization * Method to compute grammar * Renaming fix * Fix array grammar and equality check * Fix inlined keys * Fix type * Several serialization fixes * Fix undefined dereference * Several fixes * More fixes and cleanup * Fix keys quoting mechanism * Fix natural number assignment * Fix Int64 toString() * Fix quoted keys for inlined arrays * Fix PG pins * Fix several test cases * Types fixes * New pin default value empty * Fix non existing DefaultValue for variadic nodes * Smaller fixes for crashes * Fix link color when attached to knot * Linking test and more reliability operations for adding pins * Improve issue 18 test * More tests and fixes * Fix enum pin entity * Remove failing test
2026-02-04 08:50:33 +08:00 · 2024-09-08 11:46:36 +02:00
parent 31a07b992d
commit 23ee628e28
129 changed files with 8888 additions and 8584 deletions
--- a/js/entity/ArrayEntity.js
+++ b/js/entity/ArrayEntity.js
@@ -0,0 +1,106 @@
+import P from "parsernostrum"
+import Grammar from "../serialization/Grammar.js"
+import IEntity from "./IEntity.js"
+
+/** @template {typeof IEntity} T */
+export default class ArrayEntity extends IEntity {
+
+    /** @type {typeof IEntity} */
+    static type
+    static grammar = this.createGrammar()
+
+    get length() {
+        return this.values.length
+    }
+
+    /** @param {(ExtractType<T>)[]} values */
+    constructor(values = []) {
+        super()
+        this.values = values
+    }
+
+    /** @returns {P<ArrayEntity<typeof IEntity>>} */
+    static createGrammar(elementGrammar = this.type?.grammar ?? P.lazy(() => this.unknownEntityGrammar)) {
+        return this.inlined
+            ? elementGrammar
+            : P.seq(
+                P.reg(/\(\s*/),
+                elementGrammar.sepBy(Grammar.commaSeparation).opt(),
+                P.reg(/\s*(,\s*)?\)/, 1),
+            ).map(([_0, values, trailing]) => {
+                values = values instanceof Array ? values : []
+                const result = new this(values)
+                result.trailing = trailing !== undefined
+                return result
+            }).label(`ArrayEntity of ${this.type?.className() ?? "unknown values"}`)
+    }
+
+    /**
+     * @template {typeof IEntity} T
+     * @this {T}
+     */
+    static flagInlined(value = true) {
+        const result = this.asUniqueClass()
+        result.inlined = value
+        result.grammar = /** @type {P<ArrayEntity>} */(result.createGrammar())
+        return result
+    }
+
+    /**
+     * @template {typeof IEntity} T
+     * @param {T} type
+     */
+    static of(type) {
+        const result = /** @type {{type: T, grammar: P<ArrayEntity<T>> } & typeof ArrayEntity<T>} */(
+            this.asUniqueClass()
+        )
+        result.type = type
+        result.grammar = /** @type {P<ArrayEntity>} */(result.createGrammar())
+        return result
+    }
+
+    doSerialize(
+        insideString = false,
+        indentation = "",
+        Self = /** @type {typeof ArrayEntity<T>} */(this.constructor),
+        printKey = Self.printKey,
+        keySeparator = Self.keySeparator,
+        attributeSeparator = Self.attributeSeparator,
+        wrap = Self.wrap,
+    ) {
+        if (Self.inlined) {
+            return super.serialize.bind(
+                this.values,
+                insideString,
+                indentation,
+                Self,
+                printKey,
+                keySeparator,
+                attributeSeparator,
+                wrap
+            )()
+        }
+        let result = this.values.map(v => v?.serialize(insideString)).join(Self.attributeSeparator)
+        if (this.trailing) {
+            result += Self.attributeSeparator
+        }
+        return `(${result})`
+    }
+
+    valueOf() {
+        return this.values
+    }
+
+    /** @param {IEntity} other */
+    equals(other) {
+        if (!(other instanceof ArrayEntity) || this.values.length !== other.values.length) {
+            return false
+        }
+        for (let i = 0; i < this.values.length; ++i) {
+            if (!this.values[i].equals(other.values[i])) {
+                return false
+            }
+        }
+        return true
+    }
+}