@lionweb/class-core 0.8.0-beta.3 → 0.8.0-beta.5

package/src/serializer.ts

@@ -23,13 +23,14 @@ import {
     Containment,
     Enumeration,
     Feature,
-    nodeSerializer,
+    isUnresolvedReference,
     PrimitiveType,
     Property,
     PropertyValueSerializer,
     Reader,
     Reference,
-    unresolved
+    ResolveInfoDeducer,
+    serializerWith
 } from "@lionweb/core"
 
 import { INodeBase, LionCore_builtinsBase } from "./index.js"
@@ -52,6 +53,31 @@ export const getFeatureValue = (node: INodeBase, feature: Feature) => {
     throw new Error(`unhandled Feature sub type ${feature.constructor.name}`)
 };
 
+/**
+ * A {@link ResolveInfoDeducer} that works on {@link INodeBase}s.
+ * *Note*: the {@link Reference} passed is not taken into account (yet).
+ */
+const nodeBaseResolveInfoDeducer: ResolveInfoDeducer<INodeBase> = (node, _reference) => {
+    // TODO  put innards in separate function
+    if ("name" in node) {
+        // evaluating `node.name` might cause an error through FeatureValueManager.throwOnReadOfUnset:
+        try {
+            const value = node.name;
+            return typeof value === "string" ? value : undefined;
+        } catch (_) {
+            return undefined;
+        }
+    }
+    const allSupertypes = allSuperTypesOf(node.classifier);
+    if (allSupertypes.indexOf(builtinClassifiers.inamed) > -1) {
+        return node.getPropertyValueManager(builtinFeatures.inamed_name).getDirectly() as (string | undefined);
+    }
+    if (allSupertypes.indexOf(LionCore_builtinsBase.INSTANCE.INamed) > -1) {
+        return node.getPropertyValueManager(LionCore_builtinsBase.INSTANCE.INamed_name).getDirectly() as (string | undefined);
+    }
+    return undefined;
+};
+
 /**
  * A {@link Reader} that works on/for {@link INodeBase}s specifically.
  * **Note** that this function is for internal use only!
@@ -62,31 +88,13 @@ export const nodeBaseReader: Reader<INodeBase> = {
     enumerationLiteralFrom: (encoding, enumeration) => {
         return enumeration.literals.find((literal) => literal.key === encoding)!;
     },
-    resolveInfoFor: (node: INodeBase) => {
-        if ("name" in node) {
-            // evaluating `node.name` might cause an error through FeatureValueManager.throwOnReadOfUnset:
-            try {
-                const value = node.name;
-                return typeof value === "string" ? value : undefined;
-            } catch (_) {
-                return undefined;
-            }
-        }
-        const allSupertypes = allSuperTypesOf(node.classifier);
-        if (allSupertypes.indexOf(builtinClassifiers.inamed) > -1) {
-            return node.getPropertyValueManager(builtinFeatures.inamed_name).getDirectly() as (string | undefined);
-        }
-        if (allSupertypes.indexOf(LionCore_builtinsBase.INSTANCE.INamed) > -1) {
-            return node.getPropertyValueManager(LionCore_builtinsBase.INSTANCE.INamed_name).getDirectly() as (string | undefined);
-        }
-        return undefined;
-    }
+    resolveInfoFor: nodeBaseResolveInfoDeducer
 };
 
 /**
  * @return a serialization of the given nodes (of type {@link INodeBase}) as a {@link LionWebJsonChunk}.
  */
-export const serializeNodeBases = nodeSerializer(nodeBaseReader, { serializeEmptyFeatures: false });
+export const serializeNodeBases = serializerWith({ reader: nodeBaseReader, serializeEmptyFeatures: false });
 
 
 /**
@@ -99,7 +107,7 @@ type PropertyValueSerializerConfiguration = Partial<{
 
 /**
  * @return a {@link PropertyValueSerializer} that uses the given {@link PropertyValueSerializer `primitiveValueSerializer`} *solely* for serializing values of primitively-typed properties,
- * and serializes {@link unresolved} and enumeration-typed properties the same way as {@link serializeNodeBases}.
+ * and serializes properties whose types are enumerations or unresolved the same way as {@link serializeNodeBases}.
  * Unrecoverable issues are passed to the optional `reportIssue` argument, and
  */
 export const propertyValueSerializerWith = (configuration?: PropertyValueSerializerConfiguration) => {
@@ -108,7 +116,7 @@ export const propertyValueSerializerWith = (configuration?: PropertyValueSeriali
     return {
         serializeValue: (value: unknown, property: Property) => {
             const { type } = property
-            if (type === unresolved) {
+            if (isUnresolvedReference(type)) {
                 reportIssue(`can't serialize value of property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}") having unresolved type: ${value}`)
                 return null
             }

package/src/textualizer.ts

@@ -15,7 +15,16 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { allFeaturesOf, Containment, Feature, Property, Reference, unresolved } from "@lionweb/core"
+import {
+    allFeaturesOf,
+    Containment,
+    Feature,
+    isUnresolvedReference,
+    Link,
+    Property,
+    Reference,
+    UnresolvedReference
+} from "@lionweb/core"
 import { asString, indentWith, Template } from "littoral-templates"
 
 import { INodeBase } from "./base-types.js"
@@ -27,18 +36,21 @@ const prependWith = (template: Template, prefix: string): Template =>
     prefix + asString(template)
 
 
-type INodeBaseOrNotThere = INodeBase | typeof unresolved | undefined
+type INodeBaseOrNotThere = INodeBase | UnresolvedReference | undefined
 
 const asINodeBases = (value: INodeBaseOrNotThere | INodeBaseOrNotThere[]): INodeBase[] => {
     const isINodeBase = (value: INodeBaseOrNotThere): value is INodeBase =>
-        !(value === unresolved || value === undefined)
+        !(value === undefined || isUnresolvedReference(value))
 
     if (Array.isArray(value)) {
         return value
             .filter((subValue) => isINodeBase(subValue))
             .map((subValue) => subValue as INodeBase)
     }
-    return isINodeBase(value) ? [value] : []
+    if (isINodeBase(value)) {
+        return [value]
+    }
+    return []
 }
 
 
@@ -64,11 +76,12 @@ export const asTreeTextWith = (identificationFor: (node: INodeBase) => string):
                 })()
                 return `${feature.name} = ${displayValue}`
             }
+            const nothing = `<${(feature as Link).multiple ? "none" : "not set"}>`
             if (feature instanceof Containment) {
                 const valueManager = node.getContainmentValueManager(feature)
                 const children = asINodeBases(valueManager.getDirectly())
                 return [
-                    `${feature.name}:${children.length === 0 ? " <nothing>" : ""}`,
+                    `${feature.name}:${children.length === 0 ? ` ${nothing}` : ""}`,
                     indent(children.map(asText))
                 ]
             }
@@ -76,7 +89,7 @@ export const asTreeTextWith = (identificationFor: (node: INodeBase) => string):
                 const valueManager= node.getReferenceValueManager(feature)
                 const references = asINodeBases(valueManager.getDirectly())
                 return [
-                    `${feature.name} -> ${references.length === 0 ? "<none>" : references.map(identificationFor).join(", ")}`
+                    `${feature.name} -> ${references.length === 0 ? nothing : references.map(identificationFor).join(", ")}`
                 ]
             }
             return `!!! can't handle feature ${feature.name} (of meta type ${feature.metaType()})`

package/src/value-managers/references.ts

@@ -19,12 +19,7 @@ import { MultiRef, Reference, SingleRef } from "@lionweb/core"
 import { action, observable } from "mobx"
 
 import { INodeBase } from "../base-types.js"
-import {
-    EntryMovedInSameReferenceDelta,
-    ReferenceAddedDelta,
-    ReferenceChangedDelta,
-    ReferenceDeletedDelta
-} from "../deltas/index.js"
+import { CompositeDelta, ReferenceAddedDelta, ReferenceChangedDelta, ReferenceDeletedDelta } from "../deltas/index.js"
 import { checkIndex, FeatureValueManager } from "./base.js"
 
 
@@ -219,7 +214,10 @@ export abstract class MultiReferenceValueManager<T extends INodeBase> extends Re
     @action move(oldIndex: number, newIndex: number) {
         const target = this.moveDirectly(oldIndex, newIndex);
         if (target !== undefined) {
-            this.emitDelta(() => new EntryMovedInSameReferenceDelta(this.container, this.reference, oldIndex, newIndex, target));
+            this.emitDelta(() => new CompositeDelta([
+                new ReferenceDeletedDelta(this.container, this.reference, oldIndex, target),
+                new ReferenceAddedDelta(this.container, this.reference, newIndex < oldIndex ? newIndex : newIndex - 1, target)
+            ]));
         }
     }