@lionweb/core 0.8.0-beta.5 → 0.8.0-beta.7

package/src/m3/index.ts

@@ -1,12 +1,16 @@
-export * from "./builtins.js"
+export { newPropertyValueDeserializerRegistry, newPropertyValueSerializerRegistry, propertyValueDeserializerFrom, propertyValueSerializerFrom } from "./builtins-common.js"
+export type * from "./builtins-common.js"
+export { isBuiltinNodeConcept } from "./builtins-function.js"
 export * from "./constraints.js"
 export * from "./deserializer.js"
-export * from "./facade.js"
 export * from "./factory.js"
 export * from "./feature-resolvers.js"
 export * from "./functions.js"
-export * from "./lioncore.js"
+export { lioncoreKey } from "./lioncore-common.js"
+export * from "./reading-writing.js"
 export * from "./reference-checker.js"
 export * from "./serializer.js"
 export * from "./symbol-table.js"
 export * from "./types.js"
+export { LionWebVersion } from "./version.js"
+export * from "./versions.js"

package/src/m3/lioncore-common.ts

@@ -0,0 +1,42 @@
+import { Concept, Interface, Language, Property } from "./types.js"
+import { StringsMapper } from "@lionweb/ts-utils"
+
+/**
+ * The key for the LionCore language.
+ */
+export const lioncoreKey = "LionCore-M3"
+
+/**
+ * A key generator for the LionCore language.
+ * *Note*: don’t export!
+ */
+export const generatedLionCoreKeyFrom: StringsMapper = (...names) =>
+    names.length === 1 ? lioncoreKey : names.slice(1).join("-")
+
+
+/**
+ * Type def. for objects that façade (a version of) the LionCore language.
+ */
+export type LionCoreFacade = {
+    language: Language
+    metaConcepts: {
+        annotation: Concept
+        classifier: Concept
+        concept: Concept
+        interface: Concept
+        containment: Concept
+        enumeration: Concept
+        enumerationLiteral: Concept
+        ikeyed: Interface
+        language: Concept
+        primitiveType: Concept
+        property: Concept
+        reference: Concept
+    }
+    metaFeatures: {
+        concept_abstract: Property
+        ikeyed_key: Property
+        language_version: Property
+    }
+}
+

package/src/m3/reading-writing.ts

@@ -0,0 +1,160 @@
+import { metaTypedBasedClassifierDeducerFor, qualifiedNameOf } from "./functions.js"
+import { LionWebVersion } from "./version.js"
+import { LionWebVersions } from "./versions.js"
+import { Reader } from "../reading.js"
+import {
+    Annotation,
+    Classifier,
+    Concept,
+    Containment,
+    Enumeration,
+    EnumerationLiteral,
+    Interface,
+    Language,
+    M3Concept,
+    PrimitiveType,
+    Property,
+    Reference
+} from "./types.js"
+import { updateSettingsNameBased, Writer } from "../writing.js"
+
+
+/**
+ * @return an instance of {@link Reader} to read instances of the LionCore M3 (so M2s),
+ * according to the specified {@link LionWebVersion LionWeb `version`}.
+ */
+export const lioncoreReaderFor = (version: LionWebVersion): Reader<M3Concept> => ({
+    classifierOf: metaTypedBasedClassifierDeducerFor(version.lioncoreFacade.language),
+    getFeatureValue: (node, feature) =>
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (node as any)[feature.name], // (mirrors name-based update of settings)
+    enumerationLiteralFrom: (value, _) => value as EnumerationLiteral | null
+})
+
+/**
+ * An instance of {@link Reader} to read instances of the LionCore M3 (so M2s),
+ * according to the 2023.1 version of LionWeb.
+ *
+ * @deprecated Use {@link lioncoreReaderFor} instead.
+ */
+export const lioncoreReader: Reader<M3Concept> = lioncoreReaderFor(LionWebVersions.v2023_1)
+
+/**
+ * Alias for {@link lioncoreReader}, kept for backward compatibility, and to be removed later.
+ *
+ * @deprecated Use {@link lioncoreReaderFor} instead (skipping `lioncoreReader`).
+ */
+export const lioncoreExtractionFacade = lioncoreReader
+
+
+/**
+ * An instance of {@link Writer} for instances of the LionCore M3 (so M2s),
+ * according to the specified {@link LionWebVersion LionWeb `version`}.
+ */
+export const lioncoreWriterFor = (version: LionWebVersion): Writer<M3Concept> => {
+    const { lioncoreFacade, builtinsFacade } = version
+    const { ikeyed_key } = lioncoreFacade.metaFeatures
+    const { inamed_name } = builtinsFacade.features
+    const { metaConcepts, metaFeatures } = lioncoreFacade
+    return {
+        nodeFor: (parent, classifier, id, propertySettings) => {
+            switch (classifier.key) {
+                case metaConcepts.annotation.key:
+                    return new Annotation(
+                        parent as Language,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.concept.key:
+                    return new Concept(
+                        parent as Language,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id,
+                        propertySettings[metaFeatures.concept_abstract.key] as boolean
+                    )
+                case metaConcepts.interface.key:
+                    return new Interface(
+                        parent as Language,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.containment.key:
+                    return new Containment(
+                        parent as Classifier,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.enumeration.key:
+                    return new Enumeration(
+                        parent as Language,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.enumerationLiteral.key:
+                    return new EnumerationLiteral(
+                        parent as Enumeration,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.language.key:
+                    return new Language(
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[metaFeatures.language_version.key] as string,
+                        id,
+                        propertySettings[metaFeatures.ikeyed_key.key] as string
+                    )
+                case metaConcepts.primitiveType.key:
+                    return new PrimitiveType(
+                        parent as Language,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.property.key:
+                    return new Property(
+                        parent as Classifier,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                case metaConcepts.reference.key:
+                    return new Reference(
+                        parent as Classifier,
+                        propertySettings[inamed_name.key] as string,
+                        propertySettings[ikeyed_key.key] as string,
+                        id
+                    )
+                default:
+                    throw new Error(
+                        `don't know a node of concept ${qualifiedNameOf(classifier)} with key ${classifier.key} that's not in LionCore M3`
+                    )
+            }
+        },
+        setFeatureValue: (node, feature, value) => {
+            updateSettingsNameBased(node as unknown as Record<string, unknown>, feature, value)
+        },
+        encodingOf: literal => literal
+    }
+}
+
+/**
+ * An instance of {@link Writer} for instances of the LionCore M3 (so M2s),
+ * according to the 2023.1 LionWeb version.
+ *
+ * @deprecated Use {@link lioncoreWriterFor} instead.
+ */
+export const lioncoreWriter: Writer<M3Concept> = lioncoreWriterFor(LionWebVersions.v2023_1)
+
+/**
+ * Alias for {@link lioncoreWriter}, kept for backward compatibility, and to be deprecated and removed later.
+ *
+ * @deprecated Use {@link lioncoreWriterFor} instead (skipping `lioncoreWrite` altogether).
+ */
+export const lioncoreInstantationFacade = lioncoreWriter
+

package/src/m3/serializer.ts

@@ -1,13 +1,36 @@
 import { LionWebJsonChunk } from "@lionweb/json"
 import { serializerWith } from "../serializer.js"
-import { lioncoreReader } from "./facade.js"
+import { lioncoreReaderFor } from "./reading-writing.js"
 import { Language } from "./types.js"
+import { LionWebVersion } from "./version.js"
+import { LionWebVersions } from "./versions.js"
 
 
+/**
+ * Type def. for objects that contain all necessary data to deserialize one or more languages from a {@link LionWebJsonChunk serialization chunk}.
+ */
+export type LanguageSerializationData = {
+    /**
+     * The version of the LionWeb serialization format to serialize in.
+     * Default = {@link LionWebVersions.v2023_1}.
+     */
+    lionWebVersion?: LionWebVersion
+    languages: Language[]
+}
+
+/**
+ * @return the {@link LionWebJsonChunk serialization chunk} serializing the given languages (M2s, as instances of the LionCore M3),
+ * according to the configured {@link LionWebVersion} (which itself defaults to {@link LionWebVersions.v2023_1}).
+ */
+export const serializeLanguagesFor = (data: LanguageSerializationData) => {
+    const lionwebVersion = data.lionWebVersion ?? LionWebVersions.v2023_1
+    return serializerWith({ reader: lioncoreReaderFor(lionwebVersion) })(data.languages)
+}
+
 /**
  * Serializes languages (i.e., instances of the LionCore metametamodel, using {@link M3Concept these type definitions})
  * into the LionWeb serialization JSON format.
  */
 export const serializeLanguages = (...languages: Language[]): LionWebJsonChunk =>
-    serializerWith({ reader: lioncoreReader })(languages)
+    serializerWith({ reader: lioncoreReaderFor(LionWebVersions.v2023_1) })(languages)
 

package/src/m3/symbol-table.ts

@@ -18,15 +18,15 @@ interface SymbolTable {
 
     /**
      * Looks up the {@link LanguageEntity}, as pointed to by the given {@link LionWebJsonMetaPointer},
-     * or {@code undefined} if it couldn't be found.
+     * or `undefined` if it couldn't be found.
      */
     entityMatching(entityMetaPointer: LionWebJsonMetaPointer): LanguageEntity | undefined
 
     /**
      * Looks up the {@link Feature}, as pointed to by the {@link LionWebJsonMetaPointer} given second,
      * as a feature of the {@link Classifier}, as pointed to by the {@link LionWebJsonMetaPointer} given first,
-     * or {@code undefined} it it couldn't be found.
-     * *Note* that the {@code language} and {@code version} values of both {@link LionWebJsonMetaPointer}-typed arguments should coincide,
+     * or `undefined` it it couldn't be found.
+     * *Note* that the `language` and `version` values of both {@link LionWebJsonMetaPointer}-typed arguments should coincide,
      * although this is typically not checked!
      */
     featureMatching(entityMetaPointer: LionWebJsonMetaPointer, featureMetaPointer: LionWebJsonMetaPointer): Feature | undefined

package/src/m3/types.ts

@@ -5,15 +5,9 @@
 
 import { LionWebId, LionWebJsonMetaPointer, LionWebKey } from "@lionweb/json"
 import { ResolveInfoDeducer } from "../reading.js"
-import { MultiRef, SingleRef, referenceToSet } from "../references.js"
+import { MultiRef, referenceToSet, SingleRef } from "../references.js"
 import { Node } from "../types.js"
-
-
-/**
- * The key of the LionCore language containing the built-ins.
- * (It's defined here because of instantiation order.)
- */
-const lioncoreBuiltinsKey = "LionCore-builtins"
+import { lioncoreBuiltinsKey } from "./builtins-common.js"
 
 
 // Types appear roughly in the order of top-to-down+left-to-right in the diagram at:
@@ -72,7 +66,7 @@ abstract class M3Node implements IKeyed, IMetaTyped {
         this.key = key
         return this
     }
-    annotations: Node[] = [] // (containment)
+    readonly annotations: Node[] = [] // (containment)
 }
 
 abstract class Feature extends M3Node {
@@ -136,7 +130,7 @@ abstract class LanguageEntity extends M3Node {
 }
 
 abstract class Classifier extends LanguageEntity {
-    features: Feature[] = [] // (containment)
+    readonly features: Feature[] = [] // (containment)
     havingFeatures(...features: Feature[]) {
         this.features.push(...features.filter((feature) => this.features.indexOf(feature) < 0))
         return this
@@ -158,7 +152,7 @@ class Concept extends Classifier {
     abstract: boolean
     partition: boolean
     extends?: SingleRef<Concept>    // (reference)
-    implements: MultiRef<Interface> = []  // (reference)
+    readonly implements: MultiRef<Interface> = []  // (reference)
     constructor(language: Language, name: string, key: LionWebKey, id: LionWebId, abstract: boolean, extends_?: SingleRef<Concept>) {
         super(language, name, key, id)
         this.abstract = abstract
@@ -181,7 +175,7 @@ class Annotation extends Classifier {
         return "Annotation"
     }
     extends?: SingleRef<Annotation> // (reference)
-    implements: MultiRef<Interface> = [] // (reference)
+    readonly implements: MultiRef<Interface> = [] // (reference)
     annotates: SingleRef<Classifier> = referenceToSet()   // (reference)
     constructor(language: Language, name: string, key: LionWebKey, id: LionWebId, extends_?: SingleRef<Annotation>) {
         super(language, name, key, id)
@@ -202,7 +196,7 @@ class Interface extends Classifier {
     metaType(): string {
         return "Interface"
     }
-    extends: MultiRef<Interface> = []    // (reference)
+    readonly extends: MultiRef<Interface> = []    // (reference)
     extending(...interfaces: Interface[]): Interface {
         // TODO  check actual types of interfaces, or use type shapes/interfaces
         this.extends.push(...interfaces)
@@ -227,7 +221,7 @@ class Enumeration extends DataType {
     metaType(): string {
         return "Enumeration"
     }
-    literals: EnumerationLiteral[] = [] // (containment)
+    readonly literals: EnumerationLiteral[] = [] // (containment)
     havingLiterals(...literals: EnumerationLiteral[]) {
         this.literals.push(...literals.filter((literal) => this.literals.indexOf(literal) < 0))
         return this
@@ -251,8 +245,8 @@ class Language extends M3Node {
         return "Language"
     }
     version: string
-    entities: LanguageEntity[] = []   // (containment)
-    dependsOn: MultiRef<Language> = []  // special (!) reference
+    readonly entities: LanguageEntity[] = []   // (containment)
+    readonly dependsOn: MultiRef<Language> = []  // special (!) reference
         // (!) special because deserializer needs to be aware of where to get the instance from
     constructor(name: string, version: string, id: LionWebId, key: LionWebKey) {
         super(id, name, key)
@@ -304,6 +298,7 @@ export {
     EnumerationLiteral,
     Feature,
     Interface,
+    M3Node,
     Language,
     LanguageEntity,
     Link,
@@ -319,7 +314,6 @@ export type {
     IKeyed,
     IMetaTyped,
     INamed,
-    M3Concept,
-    M3Node
+    M3Concept
 }
 

package/src/m3/version.ts

@@ -0,0 +1,23 @@
+import { LionCoreFacade } from "./lioncore-common.js"
+import { LionCoreBuiltinsFacade } from "./builtins-common.js"
+
+/**
+ * Representation of a LionWeb version.
+ */
+export class LionWebVersion {
+    constructor(
+        /**
+         * The value of the root-level `serializationFormatVersion` field for {@link LionWebJsonChunk serialization chunks} *emitted* by this version.
+         */
+        public readonly serializationFormatVersion: string,
+        public readonly lioncoreFacade: LionCoreFacade,
+        public readonly builtinsFacade: LionCoreBuiltinsFacade
+    ) {
+    }
+}
+
+/*
+ * This class must be in a separate file to avoid circular initializations:
+ *  versions.ts[LionWebVersions] -> version-<version>.ts -> version.ts
+ */
+

package/src/m3/versions/v2023_1/builtins-legacy.ts

@@ -0,0 +1,126 @@
+import { asMinimalJsonString } from "@lionweb/ts-utils"
+import { shouldBeIdentical } from "../../builtins-common.js"
+import { DataType, Property } from "../../types.js"
+import { PropertyValueDeserializer } from "../../../deserializer.js"
+import { isUnresolvedReference } from "../../../references.js"
+import { PropertyValueSerializer } from "../../../serializer.js"
+import { v2023_1 } from "./version.js"
+
+
+abstract class DataTypeRegistry<T> {
+    private map = new Map<DataType, T>()
+
+    private _sealed = false
+
+    sealed() {
+        this._sealed = true
+        return this
+    }
+
+    public register(dataType: DataType, t: T) {
+        if (this._sealed) {
+            throw new Error(`can't register a data type with a register that has been sealed`)
+        }
+        this.map.set(dataType, t)
+    }
+
+    protected byType(targetDataType: DataType): T | undefined {
+        for (const [dataType, t] of this.map.entries()) {
+            if (shouldBeIdentical(targetDataType, dataType)) {
+                return t
+            }
+        }
+        return undefined
+    }
+}
+
+
+const { booleanDataType, integerDataType, jsonDataType, stringDataType } = v2023_1.builtinsFacade.primitiveTypes
+
+
+/**
+ * An implementation of {@link PropertyValueDeserializer} that knows how to deserialize serialized values of all the built-in primitive types.
+ *
+ * @deprecated
+ */
+export class BuiltinPropertyValueDeserializer
+    extends DataTypeRegistry<(value: string) => unknown>
+    implements PropertyValueDeserializer {
+    constructor() {
+        super()
+        this.register(stringDataType, (value) => value)
+        this.register(booleanDataType, (value) => JSON.parse(value))
+        this.register(integerDataType, (value) => Number(value))
+        this.register(jsonDataType, (value) => JSON.parse(value as string))
+    }
+
+    deserializeValue(value: string | undefined, property: Property): unknown | undefined {
+        if (value === undefined) {
+            if (property.optional) {
+                return undefined
+            }
+            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 (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)
+        if (specificDeserializer != undefined) {
+            return specificDeserializer(value)
+        } else {
+            throw new Error(`can't deserialize value of property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}") of type "${type!.name}": ${value}`)
+        }
+    }
+}
+
+/**
+ * Misspelled alias of {@link BuiltinPropertyValueDeserializer}, kept for backward compatibility, and to be deprecated and removed later.
+ *
+ * @deprecated
+ */
+export class DefaultPrimitiveTypeDeserializer extends BuiltinPropertyValueDeserializer {
+}
+
+/**
+ * An implementation of {@link PropertyValueSerializer} that knows how to serialize values of all the built-in primitive types.
+ *
+ * @deprecated
+ */
+export class BuiltinPropertyValueSerializer extends DataTypeRegistry<(value: unknown) => string> implements PropertyValueSerializer {
+    constructor() {
+        super()
+        this.register(stringDataType, (value) => value as string)
+        this.register(booleanDataType, (value) => `${value as boolean}`)
+        this.register(integerDataType, (value) => `${value as number}`)
+        this.register(jsonDataType, (value) => asMinimalJsonString(value))
+    }
+
+    serializeValue(value: unknown | undefined, property: Property): string | null {
+        if (value === undefined) {
+            if (property.optional) {
+                return null
+            }
+            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 (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)
+        if (specificSerializer != undefined) {
+            return specificSerializer(value)
+        } else {
+            throw new Error(`can't serialize value of property "${property.name}" (on classifier "${property.classifier.name}" in language "${property.classifier.language.name}") of type "${type!.name}": ${value}`)
+        }
+    }
+}
+
+/**
+ * Misspelled alias of {@link BuiltinPropertyValueSerializer}, kept for backward compatibility, and to be deprecated and removed later.
+ *
+ * @deprecated
+ */
+export class DefaultPrimitiveTypeSerializer extends BuiltinPropertyValueSerializer {
+}
+

package/src/m3/versions/v2023_1/builtins.ts

@@ -0,0 +1,102 @@
+import { asMinimalJsonString } from "@lionweb/ts-utils"
+import {
+    LionCoreBuiltinsFacade,
+    lioncoreBuiltinsIdAndKeyGenerator,
+    newPropertyValueDeserializerRegistry,
+    newPropertyValueSerializerRegistry,
+    propertyValueDeserializerFrom,
+    propertyValueSerializerFrom
+} from "../../builtins-common.js"
+import { isBuiltinNodeConcept } from "../../builtins-function.js"
+import { LanguageFactory } from "../../factory.js"
+
+
+const factory = new LanguageFactory(
+    "LionCore_builtins",
+    "2023.1",
+    lioncoreBuiltinsIdAndKeyGenerator,
+    lioncoreBuiltinsIdAndKeyGenerator
+)
+/*
+ * ID == key: `LionCore-builtins-${qualified name _without_ "LionCore-builtins", dash-separated}`
+ */
+
+
+const stringDataType = factory.primitiveType("String")
+const booleanDataType = factory.primitiveType("Boolean")
+const integerDataType = factory.primitiveType("Integer")
+const jsonDataType = factory.primitiveType("JSON")
+
+const node = factory.concept("Node", true)
+
+const inamed = factory.interface("INamed")
+
+const inamed_name = factory.property(inamed, "name").ofType(stringDataType)
+
+
+export const lioncoreBuiltinsFacade: LionCoreBuiltinsFacade = {
+    language: factory.language,
+    propertyValueDeserializer: propertyValueDeserializerFrom(
+        newPropertyValueDeserializerRegistry()
+            .set(stringDataType, (value) => value)
+            .set(booleanDataType, (value) => JSON.parse(value))
+            .set(integerDataType, (value) => Number(value))
+            .set(jsonDataType, (value) => JSON.parse(value as string))
+    ),
+    propertyValueSerializer: propertyValueSerializerFrom(
+        newPropertyValueSerializerRegistry()
+            .set(stringDataType, (value) => value as string)
+            .set(booleanDataType, (value) => `${value as boolean}`)
+            .set(integerDataType, (value) => `${value as number}`)
+            .set(jsonDataType, (value) => asMinimalJsonString(value))
+    ),
+    classifiers: { node, inamed },
+    features: { inamed_name },
+    primitiveTypes: {
+        stringDataType,
+        booleanDataType,
+        integerDataType,
+        jsonDataType,
+        /**
+         * Misspelled alias of {@link stringDataType}, kept for backward compatibility, and to be deprecated and removed later.
+         */
+        stringDatatype: stringDataType,
+        /**
+         * Misspelled alias of {@link booleanDataType}, kept for backward compatibility, and to be deprecated and removed later.
+         */
+        booleanDatatype: booleanDataType,
+        /**
+         * Misspelled alias of {@link integerDataType}, kept for backward compatibility, and to be deprecated and removed later.
+         */
+        integerDatatype: integerDataType,
+        /**
+         * Misspelled alias of {@link jsonDataType}, kept for backward compatibility, and to be deprecated and removed later.
+         */
+        jsonDatatype: jsonDataType
+    }
+}
+
+
+/**
+ * Definition of a LionCore language that serves as a standard library of built-in primitive types.
+ *
+ * @deprecated Use `<LionWebVersion>.builtinsFacade.isBuiltinNodeConcept` instead.
+ */
+export const lioncoreBuiltins = factory.language
+/**
+ * @deprecated Use `<LionWebVersion>.builtinsFacade.primitiveTypes` instead.
+ */
+export const builtinPrimitives = lioncoreBuiltinsFacade.primitiveTypes
+/**
+ * @deprecated Use `<LionWebVersion>.builtinsFacade.classifiers` instead.
+ */
+export const builtinClassifiers = lioncoreBuiltinsFacade.classifiers
+/**
+ * @deprecated Use `<LionWebVersion>.builtinsFacade.features` instead.
+ */
+export const builtinFeatures = lioncoreBuiltinsFacade.features
+/**
+ * @deprecated Use {@link isBuiltinNodeConcept} instead.
+ */
+export const isBuiltinConcept = isBuiltinNodeConcept
+