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-18 20:34:54 +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/MirroredEntity.js
+++ b/js/entity/MirroredEntity.js
@@ -1,36 +1,78 @@
-import AttributeInfo from "./AttributeInfo.js"
+import P from "parsernostrum"
+import IEntity from "./IEntity.js"

-/** @template {Attribute} T */
-export default class MirroredEntity {
+/** @template {typeof IEntity} T */
+export default class MirroredEntity extends IEntity {

-    static attributes = {
-        type: new AttributeInfo({
-            ignored: true,
-        }),
-        getter: new AttributeInfo({
-            ignored: true,
-        }),
-    }
+    /** @type {typeof IEntity} */
+    static type

-    /**
-     * @param {ConstructorType<T>} type
-     * @param {() => T} getter
-     */
-    constructor(type, getter = null) {
-        this.type = type
+    /** @param {() => InstanceType<T>} getter */
+    constructor(getter = null) {
+        super()
+        const self = /** @type {typeof MirroredEntity<T>} */(this.constructor)
+        getter ??= self.default !== undefined ? /** @type {MirroredEntity} */(self.default(self)).getter : getter
        this.getter = getter
    }

-    get() {
-        return this.getter()
+    static createGrammar(elementGrammar = this.type?.grammar ?? P.lazy(() => this.unknownEntityGrammar)) {
+        return this.type?.grammar.map(v => new this(() => v))
    }

-    /** @returns {AttributeConstructor<Attribute>} */
-    getTargetType() {
-        const result = this.type
-        if (result instanceof MirroredEntity) {
-            return result.getTargetType()
-        }
+
+    /**
+     * @template {typeof IEntity} T
+     * @this {T}
+     * @param {(type: T) => (InstanceType<T> | NullEntity)} value
+     * @returns {T}
+     */
+    // @ts-expect-error
+    static withDefault(value = type => new type(() => new (type.type)())) {
+        // @ts-expect-error
+        return super.withDefault(value)
+    }
+
+    /**
+     * @template {typeof IEntity} T
+     * @param {T} type
+     */
+    static of(type) {
+        const result = /** @type {{type: T, grammar: P<MirroredEntity<T>> } & typeof MirroredEntity<T>} */(
+            this.asUniqueClass()
+        )
+        result.type = type
+        result.grammar = result.createGrammar()
        return result
    }
+
+    doSerialize(
+        insideString = false,
+        indentation = "",
+        Self = /** @type {typeof MirroredEntity<T>} */(this.constructor),
+        printKey = Self.printKey,
+        keySeparator = Self.keySeparator,
+        attributeSeparator = Self.attributeSeparator,
+        wrap = Self.wrap,
+    ) {
+        const value = this.getter()
+        return value.serialize(insideString, indentation, Self.type, printKey, keySeparator, attributeSeparator, wrap)
+    }
+
+    /** @param {IEntity} other */
+    equals(other) {
+        if (other instanceof MirroredEntity) {
+            other = other.getter?.()
+        }
+        return this.getter?.().equals(other)
+    }
+
+    valueOf() {
+        this.valueOf = this.getter().valueOf.bind(this.getter())
+        return this.valueOf()
+    }
+
+    toString() {
+        this.toString = this.getter().toString.bind(this.getter())
+        return this.toString()
+    }
 }