Fix Function reference

js/Utility.js

@@ -212,34 +212,6 @@ export default class Utility {
         return false
     }
 
-    /**
-     * @template {Attribute | AttributeTypeDescription} T
-     * @param {T} value
-     * @returns {AttributeConstructor<T>}
-     */
-    static getType(value) {
-        if (value === null) {
-            return null
-        }
-        if (value?.constructor === Object && /** @type {AttributeInformation} */(value)?.type instanceof Function) {
-            return /** @type {AttributeInformation} */(value).type
-        }
-        return /** @type {AttributeConstructor<any>} */(value?.constructor)
-    }
-
-    /**
-     * @template {Attribute} V
-     * @template {AttributeConstructor<V>} C
-     * @param {C} type
-     * @returns {value is InstanceType<C>}
-     */
-    static isValueOfType(value, type, acceptNull = false) {
-        if (type instanceof MirroredEntity) {
-            type = type.getTargetType()
-        }
-        return (acceptNull && value === null) || value instanceof type || value?.constructor === type
-    }
-
     /**
      * @param {Number} x
      * @param {Number} y

js/entity/AttributeInfo.js

@@ -1,117 +0,0 @@
-/**
- * @template T
- * @typedef {{
- *     type?: AttributeTypeDescription,
- *     default?: T,
- *     nullable?: Boolean,
- *     ignored?: Boolean,
- *     serialized?: Boolean,
- *     expected?: Boolean,
- *     inlined?: Boolean,
- *     quoted?: Boolean,
- *     silent?: Boolean,
- *     uninitialized?: Boolean,
- *     predicate?: (value: T) => Boolean,
- * }} AttributeInfoSource
- */
-
-/** @template T */
-export default class AttributeInfo {
-
-    /** @typedef {keyof AttributeInfo<number>} AttributeKey */
-
-    static #default = {
-        nullable: false,
-        ignored: false, // Never serialize or deserialize
-        serialized: false, // Value is written and read as string
-        expected: false, // Must be there
-        inlined: false, // The key is a subobject or array and printed as inlined (A.B=123, A(0)=123)
-        quoted: false, // Key is serialized with quotes
-        silent: false, // Do not serialize if default
-        uninitialized: false, // Do not initialize with default
-    }
-
-    /** @param {AttributeInfoSource<T>} source */
-    constructor(source) {
-        this.type = source.type ?? source.default?.constructor
-        this.default = source.default
-        this.nullable = source.nullable ?? source.default === null
-        this.ignored = source.ignored
-        this.serialized = source.serialized
-        this.expected = source.expected
-        this.inlined = source.inlined
-        this.quoted = source.quoted
-        this.silent = source.silent
-        this.uninitialized = source.uninitialized
-        this.predicate = source.predicate
-        if (this.type === Array && this.default instanceof Array && this.default.length > 0) {
-            this.type = this.default
-                .map(v => v.constructor)
-                .reduce((acc, cur) => acc.includes(cur) ? acc : (acc.push(cur), acc), [])
-        }
-    }
-
-    /**
-     * @template {AttributeTypeDescription} D
-     * @param {D} type
-     * @returns {AttributeInfo<DescribedType<type>>}
-     */
-    static createType(type) {
-        return new AttributeInfo({ type })
-    }
-
-    /** 
-     * @template V
-     * @param {V} value
-     */
-    static createValue(value) {
-        return new AttributeInfo({ default: value })
-    }
-
-    /**
-     * @param {IEntity | Object} source
-     * @param {String} attribute
-     * @param {AttributeKey} key
-     */
-    static hasAttribute(source, attribute, key, type = /** @type {EntityConstructor} */(source.constructor)) {
-        const entity = /** @type {IEntity} */(source)
-        const result = entity.attributes[attribute]?.[key]
-        return /** @type {result} */(
-            result
-            ?? type?.attributes?.[attribute]?.[key]
-            ?? AttributeInfo.#default[key]
-        )
-    }
-
-    /**
-     * @template {IEntity | Object} S
-     * @template {EntityConstructor} C
-     * @template {keyof C["attributes"]} A
-     * @template {keyof C["attributes"][attribute]} K
-     * @param {S} source
-     * @param {A} attribute
-     * @param {K} key
-     * @param {C} type
-     * @returns {C["attributes"][attribute][key]}
-     */
-    static getAttribute(source, attribute, key, type = /** @type {C} */(source.constructor)) {
-        let result = source["attributes"]?.[attribute]?.[key]
-        // Remember null is a valid asignment value for some attributes
-        if (result !== undefined) {
-            return result
-        }
-        result = /** @type {C["attributes"]} */(type?.attributes)?.[attribute]?.[key]
-        if (result !== undefined) {
-            return result
-        }
-        result = /** @type {C["attributes"][attribute]} */(AttributeInfo.#default)[key]
-        if (result !== undefined) {
-            return result
-        }
-    }
-
-    /** @param {AttributeKey} key */
-    get(key) {
-        return this[key] ?? AttributeInfo.#default[key]
-    }
-}

js/entity/FunctionReferenceEntity.js

@@ -14,7 +14,7 @@ export default class FunctionReferenceEntity extends IEntity {
         MemberGuid: GuidEntity,
     }
     /** @type {P<FunctionReferenceEntity>} */
-    static grammar = Grammar.createEntityGrammar(this)
+    static grammar = Grammar.createEntityGrammar(this, Grammar.commaSeparation, false, 0)
 
     constructor(values) {
         super(values)

js/entity/IEntity.js

@@ -7,7 +7,7 @@ export default class IEntity {
     /** @type {(v: String) => String} */
     static same = v => v
 
-    /** @type {(entity: Attribute, serialized: String) => String} */
+    /** @type {(entity: IEntity, serialized: String) => String} */
     static notWrapped = (entity, serialized) => serialized
 
     /** @type {(entity: IEntity, serialized: String) => String} */
@@ -92,21 +92,6 @@ export default class IEntity {
         return self.name
     }
 
-    /** @param {String} key */
-    showProperty(key) {
-        /** @type {IEntity} */
-        let value = this[key]
-        const Self = this.Self()
-        if (Self.silent && Self.default !== undefined) {
-            if (Self["#default"] === undefined) {
-                Self["#default"] = Self.default(Self)
-            }
-            const defaultValue = Self["#default"]
-            return !value.equals(defaultValue)
-        }
-        return true
-    }
-
     /**
      * @protected
      * @template {typeof IEntity} T
@@ -115,6 +100,7 @@ export default class IEntity {
      */
     static asUniqueClass() {
         if (this.name.length) {
+            // @ts-expect-error
             return class extends this { }
         }
         return this
@@ -199,6 +185,21 @@ export default class IEntity {
         return /** @type {T} */(this.constructor)
     }
 
+    /** @param {String} key */
+    showProperty(key) {
+        /** @type {IEntity} */
+        let value = this[key]
+        const Self = this.Self()
+        if (Self.silent && Self.default !== undefined) {
+            if (Self["#default"] === undefined) {
+                Self["#default"] = Self.default(Self)
+            }
+            const defaultValue = Self["#default"]
+            return !value.equals(defaultValue)
+        }
+        return true
+    }
+
     /**
      * 
      * @param {String} attribute
@@ -316,6 +317,6 @@ export default class IEntity {
         if (this instanceof IEntity && this.trailing && result.length) {
             result += Self.attributeSeparator
         }
-        return wrap(this, result)
+        return wrap(/** @type {IEntity} */(this), result)
     }
 }

js/entity/ObjectEntity.js

@@ -362,7 +362,7 @@ export default class ObjectEntity extends IEntity {
         }
         let inputIndex = 0
         let outputIndex = 0
-        this.CustomProperties?.forEach((pinEntity, i) => {
+        this.getCustomproperties().forEach((pinEntity, i) => {
             pinEntity.objectEntity = this
             pinEntity.pinIndex = pinEntity.isInput()
                 ? inputIndex++

js/serialization/Grammar.js

@@ -2,9 +2,7 @@ import Parsernostrum from "parsernostrum"
 import Configuration from "../Configuration.js"
 import Utility from "../Utility.js"
 import AlternativesEntity from "../entity/AlternativesEntity.js"
-import AttributeInfo from "../entity/AttributeInfo.js"
 import IEntity from "../entity/IEntity.js"
-import MirroredEntity from "../entity/MirroredEntity.js"
 
 export default class Grammar {
 
@@ -126,11 +124,11 @@ export default class Grammar {
      * @param {T} entityType
      * @return {Parsernostrum<InstanceType<T>>}
      */
-    static createEntityGrammar(entityType, entriesSeparator = this.commaSeparation, complete = false) {
+    static createEntityGrammar(entityType, entriesSeparator = this.commaSeparation, complete = false, minKeys = 1) {
         const lookbehind = entityType.lookbehind instanceof Array ? entityType.lookbehind.join("|") : entityType.lookbehind
         return Parsernostrum.seq(
             Parsernostrum.reg(new RegExp(String.raw`(${lookbehind})\s*\(\s*`), 1),
-            this.createAttributeGrammar(entityType).sepBy(entriesSeparator),
+            this.createAttributeGrammar(entityType).sepBy(entriesSeparator, minKeys),
             Parsernostrum.reg(/\s*(,\s*)?\)/, 1), // optional trailing comma
         )
             .map(([lookbehind, attributes, trailing]) => {