@lionweb/core 0.8.0-beta.2 → 0.8.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lionweb/core",
-    "version": "0.8.0-beta.2",
+    "version": "0.8.0-beta.4",
     "description": "LionWeb core for {Java|Type}Script",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
         "release": "npm publish"
     },
     "dependencies": {
-        "@lionweb/json": "0.8.0-beta.2",
-        "@lionweb/ts-utils": "0.8.0-beta.2"
+        "@lionweb/json": "0.8.0-beta.4",
+        "@lionweb/ts-utils": "0.8.0-beta.4"
     }
 }

package/src/deserializer.ts

@@ -7,12 +7,8 @@ import {
 } from "@lionweb/json"
 import { byIdMap, groupBy, keepDefineds } from "@lionweb/ts-utils"
 import { Writer } from "./writing.js"
-import { defaultSimplisticHandler, SimplisticHandler } from "./handler.js"
-import {
-    builtinPropertyValueDeserializer,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    BuiltinPropertyValueDeserializer
-} from "./m3/builtins.js"
+import { consoleProblemReporter, ProblemReporter } from "./reporter.js"
+import { builtinPropertyValueDeserializer } from "./m3/builtins.js"
 import { MemoisingSymbolTable } from "./m3/symbol-table.js"
 import { Classifier, Containment, Enumeration, Language, PrimitiveType, Property, Reference } from "./m3/types.js"
 import { unresolved } from "./references.js"
@@ -30,199 +26,258 @@ export interface PropertyValueDeserializer {
  */
 export interface PrimitiveTypeDeserializer extends PropertyValueDeserializer {}
 
+
 /**
- * @return a deserialization of a {@link LionWebJsonChunk}
- *
- * @param serializationChunk - a {@link SerializedModel model} from its LionWeb serialization JSON format
- * @param writer - a {@link Writer} that is used to instantiate nodes and set values on them
- * @param languages - a {@link Language language} that the serialized model is expected to conform to
- * @param dependentNodes - a collection of nodes from dependent models against which all references in the serialized model are supposed to resolve against
- * @param propertyValueDeserializer - a deserializer for values of properties (by default a {@link BuiltinPropertyValueDeserializer})
- * @param problemHandler - a handler for reporting problems (by default a {@link defaultSimplisticHandler})
+ * Type definition for functions that deserialize a given {@link LionWebJsonChunk serialization chunk},
+ * being able to link to the given `dependentNodes` (as children/containments or reference targets).
  */
-export const deserializeSerializationChunk = <NT extends Node>(
-    serializationChunk: LionWebJsonChunk,
+export type Deserializer<NT extends Node> = (serializationChunk: LionWebJsonChunk, dependentNodes?: Node[]) => NT[]
+
+
+/**
+ * Configuration parameters for a deserializer that are unchanging per invocation of the deserializer
+ * (and partially optional).
+ */
+export type DeserializerConfiguration<NT extends Node> = {
+    /**
+     * A {@link Writer} that is used to instantiate nodes (with classifiers coming from the `languages` property) and set values on them.
+     */
     writer: Writer<NT>,
+    /**
+     * An array of {@link Language languages} that the serialization chunk is expected to conform to.
+     */
     languages: Language[],
-    // TODO  facades <--> languages, so it's weird that it looks split up like this
-    dependentNodes: Node[],
-    // TODO (#13)  see if you can turn this into [nodes: Node[], writer: Writer<Node>][] after all
-    propertyValueDeserializer: PropertyValueDeserializer = builtinPropertyValueDeserializer,
-    problemHandler: SimplisticHandler = defaultSimplisticHandler
-): NT[] => {
-    if (serializationChunk.serializationFormatVersion !== currentSerializationFormatVersion) {
-        problemHandler.reportProblem(
-            `can't deserialize from serialization format other than version "${currentSerializationFormatVersion}" - assuming that version`
-        )
-    }
+    /**
+     * A deserializer for values of properties.
+     * Default: {@link builtinPropertyValueDeserializer}.
+     */
+    propertyValueDeserializer?: PropertyValueDeserializer,
+    /**
+     * An object for reporting problems to.
+     * Default: {@link consoleProblemReporter}.
+     */
+    problemReporter?: ProblemReporter
+}
 
-    const symbolTable = new MemoisingSymbolTable(languages)
 
-    const { nodes: serializedNodes } = serializationChunk
+/**
+ * @return a {@link Deserializer} function.
+ *
+ * @param configuration - a {@link DeserializerConfiguration} object to configure the deserializer to return with.
+ */
+export const deserializerWith = <NT extends Node>(configuration: DeserializerConfiguration<NT>): Deserializer<NT> => {
 
-    const serializedNodeById = byIdMap(serializedNodes)
+    const symbolTable = new MemoisingSymbolTable(configuration.languages)
+    const { writer } = configuration
 
-    const deserializedNodeById: { [id: LionWebId]: NT } = {}
+    const propertyValueDeserializer = configuration.propertyValueDeserializer ?? builtinPropertyValueDeserializer
+    const problemReporter = configuration.problemReporter ?? consoleProblemReporter
 
-    /**
-     * Instantiates a {@link Node} from the given {@link LionWebJsonNode},
-     * and stores it under its ID so references to it can be resolved.
-     * For every serialized node, only one instance will ever be constructed (through memoisation).
-     */
-    const instantiateMemoised = (serNode: LionWebJsonNode, parent?: NT): NT | null => {
-        if (serNode.id in deserializedNodeById) {
-            return deserializedNodeById[serNode.id]
-        }
-        const node = instantiate(serNode, parent)
-        if (node !== null) {
-            deserializedNodeById[node.id] = node
-        }
-        return node
-    }
+    return (serializationChunk, dependentNodes = []) => {
 
-    type ReferenceToInstall = [node: NT, feature: Reference, refId: LionWebId]
-    const referencesToInstall: ReferenceToInstall[] = []
-
-    const tryInstantiate = (
-        parent: NT | undefined,
-        classifier: Classifier,
-        id: LionWebId,
-        propertySettings: { [propertyKey: LionWebKey]: unknown }
-    ): NT | null => {
-        try {
-            return writer.nodeFor(parent, classifier, id, propertySettings)
-        } catch (e: unknown) {
-            problemHandler.reportProblem(
-                `error occurred during instantiation of a node for classifier ${classifier.name} with meta-pointer (${classifier.language.key}, ${classifier.language.version}, ${classifier.key}); reason:`
+        if (serializationChunk.serializationFormatVersion !== currentSerializationFormatVersion) {
+            problemReporter.reportProblem(
+                `can't deserialize from serialization format other than version "${currentSerializationFormatVersion}" - assuming that version`
             )
-            problemHandler.reportProblem((e as Error).toString())
-            return null
         }
-    }
 
-    /**
-     * Instantiates a {@link Node} from its {@link LionWebJsonNode serialization}.
-     */
-    const instantiate = (
-        { id, classifier: classifierMetaPointer, properties, containments, references, annotations }: LionWebJsonNode,
-        parent?: NT
-    ): NT | null => {
-        const classifier = symbolTable.entityMatching(classifierMetaPointer)
-
-        if (classifier === undefined || !(classifier instanceof Classifier)) {
-            problemHandler.reportProblem(
-                `can't deserialize node with id=${id}: can't find the classifier with key ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version})`
-            )
-            return null
-        }
+        const { nodes: serializedNodes } = serializationChunk
+        const serializedNodeById = byIdMap(serializedNodes)
+        const deserializedNodeById: { [id: LionWebId]: NT } = {}
 
-        const allFeatures = symbolTable.allFeaturesOfEntityMatching(classifierMetaPointer)
-
-        const propertySettings: { [propertyKey: LionWebKey]: unknown } = {}
-
-        const serializedPropertiesPerKey = properties === undefined ? {} : groupBy(properties, sp => sp.property.key) // (this assumes no duplicate keys among properties!)
-        if (properties !== undefined) {
-            allFeatures
-                .filter(feature => feature instanceof Property)
-                .map(feature => feature as Property)
-                .forEach(property => {
-                    if (property.key in serializedPropertiesPerKey) {
-                        const value = serializedPropertiesPerKey[property.key][0].value
-                        if (property.type instanceof PrimitiveType) {
-                            propertySettings[property.key] =
-                                value === null ? undefined : propertyValueDeserializer.deserializeValue(value, property as Property)
-                            return
-                        }
-                        if (property.type instanceof Enumeration) {
-                            const literal = property.type.literals.find(literal => literal.key === value)
-                            if (literal !== undefined) {
-                                propertySettings[property.key] = writer.encodingOf(literal)
-                            }
-                            return
-                        }
-                        // (property is not handled, because neither a primitive type nor of enumeration type)
-                    }
-                })
+        /**
+         * Instantiates a {@link Node} from the given {@link LionWebJsonNode},
+         * and stores it under its ID so references to it can be resolved.
+         * For every serialized node, only one instance will ever be constructed (through memoisation).
+         */
+        const instantiateMemoised = (serNode: LionWebJsonNode, parent?: NT): NT | null => {
+            if (serNode.id in deserializedNodeById) {
+                return deserializedNodeById[serNode.id]
+            }
+            const node = instantiate(serNode, parent)
+            if (node !== null) {
+                deserializedNodeById[node.id] = node
+            }
+            return node
         }
 
-        const node = tryInstantiate(parent, classifier, id, propertySettings)
-        if (node === null) {
-            return null
+        type ReferenceToInstall = [node: NT, feature: Reference, refId: LionWebId]
+        const referencesToInstall: ReferenceToInstall[] = []
+
+        const tryInstantiate = (
+            parent: NT | undefined,
+            classifier: Classifier,
+            id: LionWebId,
+            propertySettings: { [propertyKey: LionWebKey]: unknown }
+        ): NT | null => {
+            try {
+                return writer.nodeFor(parent, classifier, id, propertySettings)
+            } catch (e: unknown) {
+                problemReporter.reportProblem(
+                    `error occurred during instantiation of a node for classifier ${classifier.name} with meta-pointer (${classifier.language.key}, ${classifier.language.version}, ${classifier.key}); reason:`
+                )
+                problemReporter.reportProblem((e as Error).toString())
+                return null
+            }
         }
 
-        const serializedContainmentsPerKey = containments === undefined ? {} : groupBy(containments, sp => sp.containment.key) // (this assumes no duplicate keys among containments!)
-        const serializedReferencesPerKey = references === undefined ? {} : groupBy(references, sp => sp.reference.key) // (this assumes no duplicate keys among references!)
-
-        allFeatures.forEach(feature => {
-            if (feature instanceof Property && properties !== undefined && feature.key in serializedPropertiesPerKey) {
-                writer.setFeatureValue(node, feature, propertySettings[feature.key])
-            } else if (feature instanceof Containment && containments !== undefined && feature.key in serializedContainmentsPerKey) {
-                const childIds = serializedContainmentsPerKey[feature.key].flatMap(serChildren => serChildren.children) as LionWebId[]
-                if (feature.multiple) {
-                    childIds.forEach(childId => {
-                        if (childId in serializedNodeById) {
-                            writer.setFeatureValue(node, feature, instantiateMemoised(serializedNodeById[childId], node))
+        /**
+         * Instantiates a {@link Node} from its {@link LionWebJsonNode serialization}.
+         */
+        const instantiate = (
+            {
+                id,
+                classifier: classifierMetaPointer,
+                properties,
+                containments,
+                references,
+                annotations
+            }: LionWebJsonNode,
+            parent?: NT
+        ): NT | null => {
+            const classifier = symbolTable.entityMatching(classifierMetaPointer)
+
+            if (classifier === undefined || !(classifier instanceof Classifier)) {
+                problemReporter.reportProblem(
+                    `can't deserialize node with id=${id}: can't find the classifier with key ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version})`
+                )
+                return null
+            }
+
+            const allFeatures = symbolTable.allFeaturesOfEntityMatching(classifierMetaPointer)
+
+            const propertySettings: { [propertyKey: LionWebKey]: unknown } = {}
+
+            const serializedPropertiesPerKey = properties === undefined ? {} : groupBy(properties, sp => sp.property.key) // (this assumes no duplicate keys among properties!)
+            if (properties !== undefined) {
+                allFeatures
+                    .filter(feature => feature instanceof Property)
+                    .map(feature => feature as Property)
+                    .forEach(property => {
+                        if (property.key in serializedPropertiesPerKey) {
+                            const value = serializedPropertiesPerKey[property.key][0].value
+                            if (property.type instanceof PrimitiveType) {
+                                propertySettings[property.key] =
+                                    value === null ? undefined : propertyValueDeserializer.deserializeValue(value, property as Property)
+                                return
+                            }
+                            if (property.type instanceof Enumeration) {
+                                const literal = property.type.literals.find(literal => literal.key === value)
+                                if (literal !== undefined) {
+                                    propertySettings[property.key] = writer.encodingOf(literal)
+                                }
+                                return
+                            }
+                            problemReporter.reportProblem(`property ${property.name} on classifier ${classifier.name} is not handled, because its type is neither a primitive type nor an enumeration`)
                         }
                     })
-                } else {
-                    if (childIds.length > 0) {
-                        // just set the 1st one:
-                        const firstChildId = childIds[0]
-                        if (firstChildId in serializedNodeById) {
-                            writer.setFeatureValue(node, feature, instantiateMemoised(serializedNodeById[firstChildId], node))
+            }
+
+            const node = tryInstantiate(parent, classifier, id, propertySettings)
+            if (node === null) {
+                return null
+            }
+
+            const serializedContainmentsPerKey = containments === undefined ? {} : groupBy(containments, sp => sp.containment.key) // (this assumes no duplicate keys among containments!)
+            const serializedReferencesPerKey = references === undefined ? {} : groupBy(references, sp => sp.reference.key) // (this assumes no duplicate keys among references!)
+
+            allFeatures.forEach(feature => {
+                if (feature instanceof Property && properties !== undefined && feature.key in serializedPropertiesPerKey) {
+                    writer.setFeatureValue(node, feature, propertySettings[feature.key])
+                } else if (feature instanceof Containment && containments !== undefined && feature.key in serializedContainmentsPerKey) {
+                    const childIds = serializedContainmentsPerKey[feature.key].flatMap(serChildren => serChildren.children) as LionWebId[]
+                    if (feature.multiple) {
+                        childIds.forEach(childId => {
+                            if (childId in serializedNodeById) {
+                                writer.setFeatureValue(node, feature, instantiateMemoised(serializedNodeById[childId], node))
+                            }
+                        })
+                    } else {
+                        if (childIds.length > 0) {
+                            // just set the 1st one:
+                            const firstChildId = childIds[0]
+                            if (firstChildId in serializedNodeById) {
+                                writer.setFeatureValue(node, feature, instantiateMemoised(serializedNodeById[firstChildId], node))
+                            }
                         }
                     }
-                }
-            } else if (feature instanceof Reference && references !== undefined && feature.key in serializedReferencesPerKey) {
-                const serRefs = (serializedReferencesPerKey[feature.key] ?? []).flatMap(serReferences =>
-                    serReferences.targets.map(t => t.reference)
-                )
-                referencesToInstall.push(
-                    ...(serRefs.filter(serRef => typeof serRef === "string") as LionWebId[]).map(
-                        refId => [node, feature, refId] as ReferenceToInstall
+                } else if (feature instanceof Reference && references !== undefined && feature.key in serializedReferencesPerKey) {
+                    const serRefs = (serializedReferencesPerKey[feature.key] ?? []).flatMap(serReferences =>
+                        serReferences.targets.map(t => t.reference)
                     )
-                )
-            }
-        })
+                    referencesToInstall.push(
+                        ...(serRefs.filter(serRef => typeof serRef === "string") as LionWebId[]).map(
+                            refId => [node, feature, refId] as ReferenceToInstall
+                        )
+                    )
+                }
+            })
 
-        node.annotations = keepDefineds(
-            annotations
-                .filter(annotationId => annotationId in serializedNodeById)
-                .map(annotationId => instantiateMemoised(serializedNodeById[annotationId]))
+            node.annotations = keepDefineds(
+                annotations
+                    .filter(annotationId => annotationId in serializedNodeById)
+                    .map(annotationId => instantiateMemoised(serializedNodeById[annotationId]))
+            )
+                .map(annotation => annotation!)
+
+            return node
+        }
+
+        const rootLikeNodes = keepDefineds(
+            serializedNodes
+                .filter(({ parent }) => parent === null || !(parent in serializedNodeById))
+                .map(serializedNode => instantiateMemoised(serializedNode))
         )
-            .map(annotation => annotation!)
+            .map(node => node!)
 
-        return node
-    }
+        const dependentNodesById = byIdMap(dependentNodes)
 
-    const rootLikeNodes = keepDefineds(
-        serializedNodes
-            .filter(({ parent }) => parent === null || !(parent in serializedNodeById))
-            .map(serializedNode => instantiateMemoised(serializedNode))
-    )
-        .map(node => node!)
-
-    const dependentNodesById = byIdMap(dependentNodes)
-
-    referencesToInstall.forEach(([node, reference, refId]) => {
-        const target = deserializedNodeById[refId] ?? dependentNodesById[refId]
-        const value = (() => {
-            if (target === undefined) {
-                const metaTypeMessage = "concept" in node ? ` and (meta-)type ${node.concept}` : ""
-                problemHandler.reportProblem(
-                    `couldn't resolve the target with id=${refId} of a "${reference.name}" reference on the node with id=${node.id}${metaTypeMessage}`
-                )
-                return unresolved
-            }
-            return target
-        })()
-        writer.setFeatureValue(node, reference, value)
-    })
+        referencesToInstall.forEach(([node, reference, refId]) => {
+            const target = deserializedNodeById[refId] ?? dependentNodesById[refId]
+            const value = (() => {
+                if (target === undefined) {
+                    const metaTypeMessage = "concept" in node ? ` and (meta-)type ${node.concept}` : ""
+                    problemReporter.reportProblem(
+                        `couldn't resolve the target with id=${refId} of a "${reference.name}" reference on the node with id=${node.id}${metaTypeMessage}`
+                    )
+                    return unresolved
+                }
+                return target
+            })()
+            writer.setFeatureValue(node, reference, value)
+        })
+
+        return rootLikeNodes
+    }
 
-    return rootLikeNodes
 }
 
+
+/**
+ * @return a deserialization of a {@link LionWebJsonChunk}.
+ *
+ * @param serializationChunk - a {@link SerializedModel model} from its LionWeb serialization JSON format
+ * @param writer - a {@link Writer} that is used to instantiate nodes and set values on them
+ * @param languages - {@link Language languages} that the serialized model is expected to conform to
+ * @param dependentNodes - a collection of nodes from dependent models against which all references in the serialized model are supposed to resolve against
+ * @param propertyValueDeserializer - a deserializer for values of properties (by default a {@link BuiltinPropertyValueDeserializer})
+ * @param problemReporter - an object for reporting problems (by default a {@link consoleProblemReporter})
+ *
+ * This is a legacy variant of {@link deserializerWith}, kept for backward compatibility, and to be deprecated and removed later.
+ */
+export const deserializeSerializationChunk = <NT extends Node>(
+    serializationChunk: LionWebJsonChunk,
+    writer: Writer<NT>,
+    languages: Language[],
+    // TODO  facades <--> languages, so it's weird that it looks split up like this
+    dependentNodes: Node[],
+    // TODO (#13)  see if you can turn this into [nodes: Node[], writer: Writer<Node>][] after all
+    propertyValueDeserializer: PropertyValueDeserializer = builtinPropertyValueDeserializer,
+    problemReporter: ProblemReporter = consoleProblemReporter
+): NT[] => deserializerWith({ writer, languages, propertyValueDeserializer, problemReporter: problemReporter })(serializationChunk, dependentNodes)
+
 /**
  * Alias for {@link deserializeSerializationChunk}.
  */
 export const deserializeChunk = deserializeSerializationChunk
+

package/src/functions.ts

@@ -1,6 +1,7 @@
-import { LionWebId } from "@lionweb/json"
+import { LionWebId, LionWebJsonMetaPointer } from "@lionweb/json"
 import { flatMapNonCyclingFollowing, trivialFlatMapper } from "@lionweb/ts-utils"
 import { Node } from "./types.js"
+import { Feature } from "./m3/index.js"
 
 
 /**
@@ -26,3 +27,16 @@ export const asIds = (nodeOrNulls: (Node | null)[]): (LionWebId | null)[] =>
 export const idOf = <T extends Node>({id}: T): LionWebId =>
     id
 
+
+/**
+ * @return the {@link LionWebJsonMetaPointer} for the given {@link Feature}.
+ */
+export const metaPointerFor = (feature: Feature): LionWebJsonMetaPointer => {
+    const { language } = feature.classifier
+    return {
+        language: language.key,
+        version: language.version,
+        key: feature.key
+    }
+}
+

package/src/index.ts

@@ -1,10 +1,10 @@
 export * from "./deserializer.js"
 export * from "./dynamic-facade.js"
 export * from "./extraction.js"
-export * from "./handler.js"
 export * from "./functions.js"
 export * from "./reading.js"
 export * from "./references.js"
+export * from "./reporter.js"
 export * from "./serializer.js"
 export * from "./types.js"
 export * from "./version.js"

package/src/m3/builtins.ts

@@ -4,7 +4,7 @@ import { PropertyValueSerializer } from "../serializer.js"
 import { currentReleaseVersion } from "../version.js"
 import { LanguageFactory } from "./factory.js"
 import { Classifier, Concept, DataType, lioncoreBuiltinsKey, Property } from "./types.js"
-import { unresolved } from "../references.js"
+import { isUnresolvedReference } from "../references.js"
 
 const lioncoreBuiltinsIdAndKeyGenerator: StringsMapper = (...names) => [lioncoreBuiltinsKey, ...names.slice(1)].join("-")
 
@@ -129,7 +129,7 @@ export class BuiltinPropertyValueDeserializer
             throw new Error(`can't deserialize undefined as the value of required property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}")`)
         }
         const { type } = property
-        if (type === unresolved) {
+        if (isUnresolvedReference(type)) {
             throw new Error(`can't deserialize property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}") with unspecified type`)
         }
         const specificDeserializer = this.byType(type)
@@ -172,7 +172,7 @@ export class BuiltinPropertyValueSerializer extends DataTypeRegister<(value: unk
             throw new Error(`can't serialize undefined as the value of required property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}")`)
         }
         const { type } = property
-        if (type === unresolved) {
+        if (isUnresolvedReference(type)) {
             throw new Error(`can't serialize property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}") with unspecified type`)
         }
         const specificSerializer = this.byType(type)

package/src/m3/deserializer.ts

@@ -1,8 +1,8 @@
 import { LionWebJsonChunk } from "@lionweb/json"
-import { deserializeSerializationChunk } from "../deserializer.js"
+import { deserializerWith } from "../deserializer.js"
 import { nodesExtractorUsing } from "../extraction.js"
-import { defaultSimplisticHandler, SimplisticHandler } from "../handler.js"
-import { builtinPropertyValueDeserializer, lioncoreBuiltins } from "./builtins.js"
+import { consoleProblemReporter, ProblemReporter } from "../reporter.js"
+import { lioncoreBuiltins } from "./builtins.js"
 import { lioncoreReader, lioncoreWriter } from "./facade.js"
 import { lioncore } from "./lioncore.js"
 import { Language } from "./types.js"
@@ -13,26 +13,31 @@ import { Language } from "./types.js"
  * as an instance of the LionCore metametamodel, using {@link _M3Concept these type definitions}.
  */
 export const deserializeLanguages = (serializationChunk: LionWebJsonChunk, ...dependentLanguages: Language[]): Language[] =>
-    deserializeLanguagesWithHandler(serializationChunk, defaultSimplisticHandler, ...dependentLanguages)
+    deserializeLanguagesWithReporter(serializationChunk, consoleProblemReporter, ...dependentLanguages)
 
 /**
  * Deserializes languages that have been serialized into the LionWeb serialization JSON format
  * as an instance of the LionCore metametamodel, using {@link _M3Concept these type definitions}.
- * This function takes a handler to be able to see what problems occurred.
+ * This function takes a {@link ProblemReporter} to be able to see what problems occurred.
  */
-export const deserializeLanguagesWithHandler = (
+export const deserializeLanguagesWithReporter = (
     serializationChunk: LionWebJsonChunk,
-    handler: SimplisticHandler,
+    problemReporter: ProblemReporter,
     ...dependentLanguages: Language[]
 ): Language[] =>
-    deserializeSerializationChunk(
+    deserializerWith({
+        writer: lioncoreWriter,
+        languages: [lioncore, ...dependentLanguages],
+        problemReporter: problemReporter
+    })(
         serializationChunk,
-        lioncoreWriter,
-        [lioncore, ...dependentLanguages],
         [lioncoreBuiltins, ...dependentLanguages].flatMap(nodesExtractorUsing(lioncoreReader)),
-        builtinPropertyValueDeserializer,
-        handler
     )
         .filter((rootNode) => rootNode instanceof Language)
         .map((language) => (language as Language).dependingOn(...dependentLanguages))
 
+/**
+ * Legacy alias for {@link deserializeLanguagesWithReporter}, kept for backward compatibility, and to be deprecated and removed later.
+ */
+export const deserializeLanguagesWithHandler = deserializeLanguagesWithReporter
+

package/src/m3/functions.ts

@@ -7,7 +7,7 @@ import { LionWebId, LionWebKey } from "@lionweb/json"
 import { cycleWith, flatMapNonCyclingFollowing, sortByStringKey } from "@lionweb/ts-utils"
 import { containmentChain } from "../functions.js"
 import { ClassifierDeducer } from "../reading.js"
-import { isRef, unresolved } from "../references.js"
+import { isRef, UnresolvedReference } from "../references.js"
 import { Node } from "../types.js"
 import {
     Annotation,
@@ -34,7 +34,7 @@ import {
 /**
  * @return The type of the given {@link Feature}
  */
-const type = (feature: Feature): Classifier | DataType | typeof unresolved =>
+const type = (feature: Feature): Classifier | DataType | UnresolvedReference =>
     (feature as (Link | Property)).type
 
 

package/src/m3/reference-checker.ts

@@ -1,4 +1,4 @@
-import { SingleRef, unresolved } from "../references.js"
+import { isUnresolvedReference, SingleRef } from "../references.js"
 import { flatMap, qualifiedNameOf } from "./functions.js"
 import { Concept, Containment, Language, Property, Reference } from "./types.js"
 import { Node } from "../types.js"
@@ -14,7 +14,7 @@ export const checkReferences = (language: Language): string[] =>
 
             const locations: string[] = []
             const check = (location: string, ref?: SingleRef<Node>) => {
-                if (ref === unresolved) {
+                if (isUnresolvedReference(ref)) {
                     locations.push(location)
                 }
             }

package/src/m3/serializer.ts

@@ -1,5 +1,5 @@
 import { LionWebJsonChunk } from "@lionweb/json"
-import { nodeSerializer } from "../serializer.js"
+import { serializerWith } from "../serializer.js"
 import { lioncoreReader } from "./facade.js"
 import { Language } from "./types.js"
 
@@ -9,5 +9,5 @@ import { Language } from "./types.js"
  * into the LionWeb serialization JSON format.
  */
 export const serializeLanguages = (...languages: Language[]): LionWebJsonChunk =>
-    nodeSerializer(lioncoreReader)(languages)
+    serializerWith({ reader: lioncoreReader })(languages)