@lionweb/class-core-generator 0.6.13-beta.0

package/src/api/helpers/features.ts

@@ -0,0 +1,121 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+    builtinClassifiers,
+    Classifier,
+    Datatype,
+    Enumeration,
+    Feature,
+    isContainment,
+    isProperty,
+    isReference,
+    LanguageEntity,
+    Link,
+    PrimitiveType,
+    Property,
+    SingleRef
+} from "@lionweb/core"
+import {Imports, tsTypeForPrimitiveType} from "./index.js"
+
+
+export const typeOf = (feature: Feature): SingleRef<LanguageEntity> => {
+    if (feature instanceof Property) {
+        return feature.type
+    }
+    if (feature instanceof Link) {
+        return feature.type
+    }
+    return null
+}
+
+
+export const tsTypeForDatatype = (datatype: SingleRef<Datatype>, imports: Imports) => {
+    if (datatype === null) {
+        return `unknown /* [ERROR] can't compute a TS type for a null datatype */`
+    }
+    if (datatype instanceof PrimitiveType) {
+        return tsTypeForPrimitiveType(datatype)
+    }
+    if (datatype instanceof Enumeration) {
+        return imports.entity(datatype)
+    }
+    return `unknown /* [ERROR] can't compute a TS type for datatype ${datatype.name} that has an unhandled/-known meta-type ${datatype.constructor.name} */`
+}
+
+
+export const tsTypeForClassifier = (classifier: SingleRef<Classifier>, imports: Imports) => {
+    if (classifier === null) {
+        return `unknown /* [ERROR] can't compute a TS type for a null classifier */`
+    }
+    return classifier === builtinClassifiers.node ? imports.generic("INodeBase") : imports.entity(classifier)
+}
+
+
+export const optionalityPostfix = (feature: Feature) => feature.optional ? " | undefined" : ""
+
+export const tsFieldTypeForFeature = (feature: Feature, imports: Imports): string => {
+    const type = typeOf(feature)
+    if (type === null) {
+        return `unknown /* [ERROR] can't compute a TS type for feature ${feature.name} on classifier ${feature.classifier.name} with null type */`
+    }
+    if (isProperty(feature)) {
+        const typeId = (() => {
+            if (type instanceof PrimitiveType) {
+                return tsTypeForPrimitiveType(type)
+            }
+            if (type instanceof Enumeration) {
+                return type.name
+            }
+            return `unknown /* [ERROR] can't compute a TS type for feature ${feature.name} on classifier ${feature.classifier.name} whose type has an unhandled/-known meta-type ${type.constructor.name} */`
+        })()
+        return `${typeId}${(optionalityPostfix(feature))}`
+    }
+    if (isContainment(feature)) {
+        const typeId = type === builtinClassifiers.node ? imports.generic("INodeBase") : imports.entity(type)
+        return `${typeId}${feature.multiple ? "[]" : optionalityPostfix(feature)}`
+    }
+    if (isReference(feature)) {
+        const typeId = type === builtinClassifiers.node ? imports.generic("INodeBase") : imports.entity(type)
+        return `${imports.core("SingleRef")}<${typeId}>${feature.multiple ? "[]" : optionalityPostfix(feature)}`
+    }
+    return `unknown /* [ERROR] can't compute a TS type for feature ${feature.name} on classifier ${feature.classifier.name} whose type has an unhandled/-known meta-type ${type.constructor.name} */`
+}
+
+export const tsTypeForValueManager = (feature: Feature, imports: Imports): string => {
+    const type = typeOf(feature)
+    if (type === null) {
+        return `unknown /* [ERROR] can't compute a TS type for feature ${feature.name} on classifier ${feature.classifier.name} with null type */`
+    }
+    if (isProperty(feature)) {
+        const typeId = (() => {
+            if (type instanceof PrimitiveType) {
+                return tsTypeForPrimitiveType(type)
+            }
+            if (type instanceof Enumeration) {
+                return type.name
+            }
+            return `unknown /* [ERROR] can't compute a TS type for feature ${feature.name} on classifier ${feature.classifier.name} whose type has an unhandled/-known meta-type ${type.constructor.name} */`
+        })()
+        return typeId
+    }
+    if (isContainment(feature) || isReference(feature)) {
+        return type === builtinClassifiers.node ? imports.generic("INodeBase") : imports.entity(type)
+    }
+    return `unknown /* [ERROR] can't compute a TS type for feature ${feature.name} on classifier ${feature.classifier.name} whose type has an unhandled/-known meta-type ${type.constructor.name} */`
+}
+

package/src/api/helpers/imports-tracking.ts

@@ -0,0 +1,96 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {Language, LanguageEntity, lioncoreBuiltins} from "@lionweb/core"
+import {asJSIdentifier} from "../../utils/textgen.js"
+
+
+export const importRenamingForLanguage = (language: Language) =>
+    asJSIdentifier(language.name)
+
+export const nameOfBaseClassForLanguage = (language: Language) =>
+    asJSIdentifier(language.name) + "Base"
+
+
+const lionCoreBuiltinsIdentifier = nameOfBaseClassForLanguage(lioncoreBuiltins)
+
+
+export class Imports {
+
+    constructor(public readonly thisLanguage: Language) {
+    }
+
+    get thisLanguageNameAsJsIdentifier() {
+        return asJSIdentifier(this.thisLanguage.name)
+    }
+
+    get thisBaseClassName() {
+        return this.thisLanguageNameAsJsIdentifier + "Base"
+    }
+
+    private readonly _coreImports = new Set<string>()
+    get coreImports() {
+        return [...this._coreImports]
+    }
+    core(identifier: string) {
+        this._coreImports.add(identifier)
+        return identifier
+    }
+
+    private readonly _genericImports = new Set<string>()
+    get genericImports() {
+        return [...this._genericImports]
+    }
+    generic(identifier: string) {
+        this._genericImports.add(identifier)
+        return identifier
+    }
+
+    private readonly _indexImports = new Set<string>()
+    get indexImports() {
+        return [...this._indexImports]
+    }
+    entity(entity: LanguageEntity) {
+        if (entity.language === lioncoreBuiltins) {
+            this._genericImports.add(entity.name)
+            return entity.name
+        }
+        if (entity.language === this.thisLanguage) {
+            return entity.name
+        }
+        this._languageImports.add(importRenamingForLanguage(entity.language))
+        return `${importRenamingForLanguage(entity.language)}.${entity.name}`
+    }
+
+    private readonly _languageImports = new Set<string>()
+    get languageImports() {
+        return [...this._languageImports]
+    }
+    language(language: Language) {
+        if (language === lioncoreBuiltins) {
+            this._genericImports.add(lionCoreBuiltinsIdentifier)
+            return lionCoreBuiltinsIdentifier
+        }
+        const externalName = importRenamingForLanguage(language)
+        if (language === this.thisLanguage) {
+            return nameOfBaseClassForLanguage(language)
+        }
+        this._languageImports.add(externalName)
+        return `${externalName}.${nameOfBaseClassForLanguage(language)}`
+    }
+}
+

package/src/api/helpers/index.ts

@@ -0,0 +1,24 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./classifiers.js"
+export * from "./dependencies.js"
+export * from "./entities.js"
+export * from "./features.js"
+export * from "./imports-tracking.js"
+export * from "./mps-annotations.js"
+export * from "./types.js"

package/src/api/helpers/mps-annotations.ts

@@ -0,0 +1,69 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {Id, SerializationChunk} from "@lionweb/core"
+
+
+export abstract class MpsAnnotation {
+    constructor(public readonly annotatedNodeId: Id) {
+    }
+}
+
+export class ConceptDescription extends MpsAnnotation {
+    constructor(annotatedNodeId: Id, public readonly shortDescription: string | null, public readonly alias: string | null) {
+        super(annotatedNodeId)
+    }
+    toString() {
+        return `<ConceptDescription> annotatedNodeId=${this.annotatedNodeId}, shortDescription="${this.shortDescription}"`
+    }
+}
+
+export class Deprecated extends MpsAnnotation {
+    constructor(annotatedNodeId: Id, public readonly comment: string | null, public readonly build: string | null) {
+        super(annotatedNodeId)
+    }
+    toString() {
+        return `<Deprecated> annotatedNodeId=${this.annotatedNodeId}, comment="${this.comment}", build="${this.build}"`
+    }
+}
+
+
+export const extractedMpsAnnotations = ({nodes}: SerializationChunk): MpsAnnotation[] =>
+    nodes.flatMap<MpsAnnotation>(({classifier, properties, parent}) => {
+        const propertyValue = (key: string): string | null => {
+            const property = properties.find(({property}) => property.key === key)
+            return property === undefined
+                ? null
+                : property.value
+        }
+        if (classifier.language !== "io-lionweb-mps-specific" || classifier.version !== "0") {
+            return []
+        }
+        switch (classifier.key) {
+            case "ConceptDescription": {
+                return [new ConceptDescription(parent!, propertyValue("ConceptDescription-conceptShortDescription"), propertyValue("ConceptDescription-conceptAlias"))]
+            }
+            case "Deprecated": {
+                return [new Deprecated(parent!, propertyValue("Deprecated-comment"), propertyValue("Deprecated-build"))]
+            }
+            default: {
+                console.log(`couldn't handle MPS annotation with key ${classifier.key}`)
+                return []
+            }
+        }
+    })
+

package/src/api/helpers/types.ts

@@ -0,0 +1,31 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {builtinPrimitives, PrimitiveType} from "@lionweb/core"
+
+
+export const tsTypeForPrimitiveType = (primitiveType: PrimitiveType): string => {
+    switch (primitiveType) {
+        case builtinPrimitives.booleanDatatype: return `boolean`
+        case builtinPrimitives.stringDatatype: return `string`
+        case builtinPrimitives.integerDatatype: return `number`
+        case builtinPrimitives.jsonDatatype: return `unknown`
+        default:
+            return `string`
+    }
+}
+

package/src/api/index-ts.ts

@@ -0,0 +1,59 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {Language} from "@lionweb/core"
+import {asString, commaSeparated} from "littoral-templates"
+
+import {indent} from "../utils/textgen.js"
+import {dependencyOrderOf} from "../utils/toposort.js"
+import {dependenciesThroughDirectInheritanceOf, importRenamingForLanguage, nameOfBaseClassForLanguage} from "./helpers/index.js"
+import {GeneratorOptions} from "./generator.js"
+
+
+export const indexTsFor = (languages: Language[], options: GeneratorOptions) => {
+    const dependenciesInOrderOfDirectInheritance = dependencyOrderOf(languages, dependenciesThroughDirectInheritanceOf)
+    if (dependenciesInOrderOfDirectInheritance === false) {
+        console.error(`⚠ CYCLE detected! Proceeding with order of languages as-is, instead of in type-wise (through direct inheritance) dependency order ⇒ generated code might not initialize!`)
+    }
+    const languagesForImports = dependenciesInOrderOfDirectInheritance === false
+        ? languages
+        : dependenciesInOrderOfDirectInheritance
+                .filter((language) => languages.indexOf(language) > -1)
+
+    return asString([
+        options.header === undefined ? [] : [options.header, ``],
+        `import {ILanguageBase, LionCore_builtinsBase} from "${options.genericImportLocation}";`,
+        ``,
+        languagesForImports.map((language) => `import * as ${importRenamingForLanguage(language)} from "./${language.name}.g.js";`),
+        ``,
+        `// ensure that all languages get wired up by triggering that through their first entity:`,
+        `LionCore_builtinsBase.INSTANCE.String;`,
+        languages
+            .filter(({entities}) => entities.length > 0)
+            .map((language) => `${importRenamingForLanguage(language)}.${nameOfBaseClassForLanguage(language)}.INSTANCE.${language.entities[0].name};`),
+        ``,
+        `export const allLanguageBases: ILanguageBase[] = [`,
+        indent(commaSeparated(languagesForImports.map((language) => `${importRenamingForLanguage(language)}.${nameOfBaseClassForLanguage(language)}.INSTANCE`))),
+        `];`,
+        ``,
+        `export {`,
+        indent(commaSeparated(languages.map(importRenamingForLanguage))),
+        `};`,
+        ``
+    ])
+}
+

package/src/api/index.ts

@@ -0,0 +1,21 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export {generateLanguage, generateApiFromLanguages, generateApiFromLanguagesJson} from "./generator.js"
+export * from "./generation-headers.js"
+export * from "./helpers/mps-annotations.js"
+export * from "./mega-factory.templates.js"

package/src/api/language-file.templates.ts

@@ -0,0 +1,79 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {Concept, groupBy, Language} from "@lionweb/core"
+import {asString, commaSeparated, when, withNewlineAppended} from "littoral-templates"
+
+import {typeForLanguageEntity} from "./entity-types.templates.js"
+import {reflectiveClassFor} from "./reflective-layer.templates.js"
+import {indent} from "../utils/textgen.js"
+import {sortedStringsByUppercase} from "../utils/string-sorting.js"
+import {dependencyOrderOf} from "../utils/toposort.js"
+import {Imports} from "./helpers/index.js"
+import {GeneratorOptions} from "./generator.js"
+
+
+const importStatement = (dep: string, items: string[]) =>
+    when(items.length > 0)([
+        `import {`,
+        indent(commaSeparated(sortedStringsByUppercase(items))),
+        `} from "${dep}";`,
+        ``
+    ])
+
+
+export const languageFileFor = (language: Language, options: GeneratorOptions) => {
+
+    const {name, version, key, id, entities} = language
+
+    const imports = new Imports(language)
+
+    const orderedEntities = dependencyOrderOf(entities, (entity) => (entity instanceof Concept && !!entity.extends) ? [entity.extends] : [])
+    if (typeof orderedEntities === "boolean") {
+        throw new Error(`language ${name} has a cycle among the graph of entities with edges formed by the inheritance dependency`)
+    }
+
+    const mpsAnnotationsPerId = groupBy(options.mpsAnnotations, ({annotatedNodeId}) => annotatedNodeId)
+
+    const postImportsPart = [
+        ``,
+        reflectiveClassFor(imports)(language),
+        ``,
+        ``,
+        orderedEntities
+            .filter((entity) => entity.language === language)
+            .map(withNewlineAppended(typeForLanguageEntity(imports, mpsAnnotationsPerId)))
+    ]
+
+    return asString([
+        options?.header ?? [],
+        `/*
+ * language's metadata:
+ *     name:    ${name}
+ *     version: ${version}
+ *     key:     ${key}
+ *     id:      ${id}
+ */`,
+        ``,
+        ``,
+        importStatement(`@lionweb/core`, imports.coreImports),
+        importStatement(options.genericImportLocation, imports.genericImports),
+        importStatement(`./index.g.js`, imports.languageImports),
+        postImportsPart
+    ])
+}
+

package/src/api/mega-factory.templates.ts

@@ -0,0 +1,79 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import {isConcrete, Language, LanguageEntity} from "@lionweb/core"
+import {asString, commaSeparated} from "littoral-templates"
+
+import {asJSIdentifier, indent} from "../utils/textgen.js"
+import {Deprecated, MpsAnnotation} from "./helpers/index.js";
+
+
+export const megaFactoryFor = (megaFactoryName: string, languages: Language[], mpsAnnotations: MpsAnnotation[] = [], header?: string) => {
+    const isNotDeprecated = (entity: LanguageEntity)=>
+        !mpsAnnotations.some(
+            (mpsAnnotation) => mpsAnnotation.annotatedNodeId === entity.id && mpsAnnotation instanceof Deprecated
+        )
+
+    const requiresFactoryMethod = (entity: LanguageEntity) =>
+        isConcrete(entity) && isNotDeprecated(entity)
+
+    const factoryFor = (language: Language) => [
+        `${asJSIdentifier(language.name)}Factory = {`,
+        indent(commaSeparated(
+            language.entities
+                .filter(requiresFactoryMethod)
+                .map((classifier) => `create${classifier.name}: () => ${asJSIdentifier(language.name)}.${classifier.name}.create(newId(), this.handleDelta)`)
+        )),
+        `}`,
+        ``
+    ]
+
+    const languagesWithFactoryMethods = languages
+        .filter(
+            (language) => language.entities.some(requiresFactoryMethod)
+        )
+
+    return asString([
+        header ?? [],
+        `import {DeltaHandler} from "@tls/lionweb-class-core";`,
+        ``,
+        `import {`,
+        indent(commaSeparated(
+            languagesWithFactoryMethods.map(({name}) => asJSIdentifier(name))
+        )),
+        `} from "./index.g.js";`,
+        ``,
+        `import {newId} from "../index.js";`,
+        ``,
+        ``,
+        `export class ${megaFactoryName} {`,
+        indent([
+            ``,
+            `constructor(`,
+            indent([
+                `public readonly handleDelta?: DeltaHandler`
+            ]),
+            `) {`,
+            `}`,
+            ``,
+            languagesWithFactoryMethods.map(factoryFor)
+        ]),
+        `}`,
+        ``
+    ])
+}
+