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

package/dist/utils/textgen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textgen.js","sourceRoot":"","sources":["../../src/utils/textgen.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,EAAE;AACF,iEAAiE;AACjE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,EAAE;AACF,sEAAsE;AACtE,sCAAsC;AAEtC;;;GAGG;AAGH,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAW,MAAM,oBAAoB,CAAA;AAGjE;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AAG3C,MAAM,cAAc,GAAG,CAAC,QAAgC,EAAE,EAAE,CACxD,CAAC,GAAW,EAAE,EAAE;IACZ,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnB,OAAO,GAAG,CAAA;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;UACxB,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAClD,CAAC,CAAA;AAEL;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAAA;AAEtE;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAAA;AAGtE;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,GAAW,EAAU,EAAE,CAClD,GAAG;KACE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;KACpB,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAG7B,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,SAAkB,EAAE,IAAkB,EAAE,KAAa,EAAE,EAAE,CAC9E,CAAC,IAAY,EAAE,EAAE,CACb,SAAS;IACL,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,EAAE;IAC5B,CAAC,CAAC,IAAI,CAAA;AAKlB,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,UAAkB,EAAE,KAAkB,EAAE,YAAsB,EAAE,EAAE,CACzF,KAAK,CAAC,MAAM,GAAG,CAAC;IACZ,CAAC,CAAC;QACE,WAAW,UAAU,KAAK;QAC1B,MAAM,CAAC;YACH,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC,QAAQ,cAAc,YAAY,WAAW,GAAG,CAAC;YAC9F,YAAY,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE;SAC7G,CAAC;QACF,GAAG;KACN;IACD,CAAC,CAAC;QACE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC;YACzC,OAAO,UAAU,QAAQ,cAAc,KAAK;YAC5C,MAAM,CAAC,UAAU,WAAW,GAAG,CAAC;YAChC,GAAG;SACN,CAAC;QACF,YAAY;KACf,CAAA"}

package/dist/utils/toposort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Computes the topological order of the transitive closure of the graph with the given vertices and edges given by the edge function,
+ * or returns {@code false} if there's a cycle.
+ */
+export declare const dependencyOrderOf: <T>(vertices: T[], edgesOf: (vertex: T) => T[]) => false | T[];
+//# sourceMappingURL=toposort.d.ts.map

package/dist/utils/toposort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toposort.d.ts","sourceRoot":"","sources":["../../src/utils/toposort.ts"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,gEA0B7B,CAAA"}

package/dist/utils/toposort.js

@@ -0,0 +1,41 @@
+// 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
+/**
+ * Computes the topological order of the transitive closure of the graph with the given vertices and edges given by the edge function,
+ * or returns {@code false} if there's a cycle.
+ */
+export const dependencyOrderOf = (vertices, edgesOf) => {
+    const ordered = [];
+    const visit = (current, chain) => {
+        if (ordered.indexOf(current) > -1) {
+            return false;
+        }
+        if (chain.indexOf(current) > -1) {
+            return true;
+        }
+        const extendedChain = [...chain, current];
+        const hasCycle = edgesOf(current).some((edge) => visit(edge, extendedChain));
+        ordered.push(current);
+        if (hasCycle) {
+            console.dir(ordered);
+        }
+        return hasCycle;
+    };
+    const hasCycle = vertices.some((vertex) => visit(vertex, []));
+    return hasCycle ? false : ordered;
+};
+//# sourceMappingURL=toposort.js.map

package/dist/utils/toposort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toposort.js","sourceRoot":"","sources":["../../src/utils/toposort.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,EAAE;AACF,iEAAiE;AACjE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,EAAE;AACF,sEAAsE;AACtE,sCAAsC;AAEtC;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAI,QAAa,EAAE,OAA2B,EAAe,EAAE;IAC5F,MAAM,OAAO,GAAQ,EAAE,CAAA;IAEvB,MAAM,KAAK,GAAG,CAAC,OAAU,EAAE,KAAU,EAAE,EAAE;QACrC,IAAI,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAChC,OAAO,KAAK,CAAA;QAChB,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAA;QACf,CAAC;QACD,MAAM,aAAa,GAAG,CAAE,GAAG,KAAK,EAAE,OAAO,CAAE,CAAA;QAC3C,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAClC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,CACvC,CAAA;QACD,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACrB,IAAI,QAAQ,EAAE,CAAC;YACX,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QACxB,CAAC;QACD,OAAO,QAAQ,CAAA;IACnB,CAAC,CAAA;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAC1B,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,CAChC,CAAA;IAED,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAA;AACrC,CAAC,CAAA"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lionweb/class-core-generator",
+  "version": "0.6.13-beta.0",
+  "description": "Generator for implementations of languages based on the class-core package",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "typings": "dist/index.d.ts",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LionWeb-io/lionweb-typescript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LionWeb-io/lionweb-typescript/issues"
+  },
+  "scripts": {
+    "clean": "rm -rf dist/ node_modules/ lionweb-class-core-generator-*.tgz",
+    "build": "tsc",
+    "lint": "eslint src",
+    "pre-release-either": "npm run clean && npm install && npm run build",
+    "prerelease": "npm run pre-release-either",
+    "release": "npm publish",
+    "prerelease-beta": "npm run pre-release-either",
+    "release-beta": "npm publish --tag beta"
+  },
+  "devDependencies": {
+    "@lionweb/core": "0.6.13-beta.0",
+    "@lionweb/utilities": "0.6.13-beta.0",
+    "@types/node": "20.17.30",
+    "littoral-templates": "0.3.0",
+    "typescript": "5.3.3"
+  }
+}

package/src/api/entity-types.templates.ts

@@ -0,0 +1,257 @@
+// 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,
+    Enumeration,
+    Feature,
+    featureMetaType,
+    Id,
+    Interface,
+    isContainment,
+    isProperty,
+    isReference,
+    LanguageEntity,
+    Link,
+    nameSorted,
+    PrimitiveType,
+    Property,
+    Reference,
+    SingleRef
+} from "@lionweb/core"
+import {commaSeparated, when, withNewlineAppended} from "littoral-templates"
+
+import {indent, switchOrIf, withFirstUpper, wrapInIf} from "../utils/textgen.js"
+import {
+    ConceptDescription,
+    Deprecated,
+    entityMetaType,
+    extendsFrom,
+    featuresToConcretelyImplementOf,
+    implementsFrom,
+    Imports,
+    isAbstract,
+    MpsAnnotation,
+    optionalityPostfix,
+    tsFieldTypeForFeature,
+    tsTypeForClassifier,
+    tsTypeForDatatype,
+    tsTypeForPrimitiveType,
+    tsTypeForValueManager
+} from "./helpers/index.js"
+
+
+const cardinalityPrefix = (feature: Feature) => {
+    if (feature instanceof Property) {
+        return feature.optional ? "Optional" : "Required"
+    }
+    if (feature instanceof Link) {
+        return `${feature.optional ? "Optional" : "Required"}${feature.multiple ? "Multi" : "Single"}`
+    }
+}
+
+const valueManagerFor = (feature: Feature) =>
+    `${cardinalityPrefix(feature)}${featureMetaType(feature)}ValueManager`
+
+export const typeForLanguageEntity = (imports: Imports, mpsAnnotationsPerId: Record<Id, MpsAnnotation[]>) => {
+
+    const sortedSuperTypesCond = <T extends Classifier>(ts: T[], prefix: string): string =>
+        ts.length === 0 ? `` : `${prefix}${nameSorted(ts).map((t) => imports.entity(t)).join(", ")}`
+
+    const extendsCond = (ref: SingleRef<Classifier>): string =>
+        ` extends ${ref === builtinClassifiers.node ? imports.generic("NodeBase") : imports.entity(ref!)}`
+
+    const classMembersForProperty = (property: Property) => {
+        const {name, type} = property
+        return [
+            `private readonly _${name}: ${imports.generic(valueManagerFor(property))}<${tsTypeForDatatype(type, imports)}>;`,
+            `get ${name}(): ${tsTypeForDatatype(type, imports)}${optionalityPostfix(property)} {`,
+            indent(`return this._${name}.get();`),
+            `}`,
+            `set ${name}(newValue: ${tsTypeForDatatype(type, imports)}${optionalityPostfix(property)}) {`,
+            indent(`this._${name}.set(newValue);`),
+            `}`
+        ]
+    }
+
+    const tsTypeForLink = (link: Link) =>
+        wrapInIf(link instanceof Reference, () => `${imports.core("SingleRef")}<`, ">")(tsTypeForClassifier(link.type, imports))
+            + (link.multiple ? "[]" : optionalityPostfix(link))
+
+    const classMembersForLink = (link: Link) => {
+        const {name, type, multiple} = link
+        return [
+            `private readonly _${name}: ${imports.generic(valueManagerFor(link))}<${tsTypeForClassifier(type, imports)}>;`,
+            `get ${name}(): ${tsTypeForLink(link)} {`,
+            indent(`return this._${name}.get();`),
+            `}`,
+            when(!multiple)([
+                `set ${name}(newValue: ${tsTypeForLink(link)}) {`,
+                indent(`this._${name}.set(newValue);`),
+                `}`
+            ]),
+            when(multiple)([
+                `add${withFirstUpper(name)}(newValue: ${tsTypeForClassifier(type, imports)}) {`,
+                indent(`this._${name}.add(newValue);`),
+                `}`,
+                `remove${withFirstUpper(name)}(valueToRemove: ${tsTypeForClassifier(type, imports)}) {`,
+                indent(`this._${name}.remove(valueToRemove);`),
+                `}`,
+                `add${withFirstUpper(name)}AtIndex(newValue: ${tsTypeForClassifier(type, imports)}, index: number) {`,
+                indent(`this._${name}.insertAtIndex(newValue, index);`),
+                `}`,
+                `move${withFirstUpper(name)}(oldIndex: number, newIndex: number) {`,
+                indent(`this._${name}.move(oldIndex, newIndex);`),
+                `}`
+            ])
+        ]
+    }
+
+    const classMembersForFeature = (feature: Feature) => {
+        if (isProperty(feature)) {
+            return classMembersForProperty(feature)
+        }
+        if (isContainment(feature) || isReference(feature)) {
+            return classMembersForLink(feature)
+        }
+        return `// unhandled feature <${feature.constructor.name}>"${feature.name}" on classifier "${feature.classifier.name}" in language "${feature.classifier.language.name}"`
+    }
+
+    const classForConcreteClassifier = (classifier: Classifier) => {
+        const features = featuresToConcretelyImplementOf(classifier)
+
+        const getValueManagers = <FT extends Feature>(features: FT[]) => {
+            if (features.length === 0) {
+                return []
+            }
+
+            const featureMetaType_ = featureMetaType(features[0])
+            const argumentName = featureMetaType_.toLowerCase()
+            return [
+                ``,
+                `get${featureMetaType_}ValueManager(${argumentName}: ${imports.core(featureMetaType_)}): ${imports.generic(featureMetaType_ + "ValueManager")}<${featureMetaType_ === "Property" ? "unknown" : imports.generic("INodeBase")}> {`,
+                indent(
+                    switchOrIf(
+                        `${argumentName}.key`,
+                        features.map((feature) => [`${imports.language(feature.classifier.language)}.INSTANCE.${feature.classifier.name}_${feature.name}.key`, `this._${feature.name}`]),
+                        `return super.get${featureMetaType_}ValueManager(${argumentName});`
+                    )
+                ),
+                `}`
+            ]
+        }
+
+        return [
+            //                                                                                        |    index (or generic for LionCore-builtins)    |                         | index (or generic for LionCore-builtins) |
+            `export ${isAbstract(classifier) ? "abstract " : ""}class ${classifier.name}${extendsCond(extendsFrom(classifier) ?? builtinClassifiers.node)}${sortedSuperTypesCond(implementsFrom(classifier), " implements ")} {`,
+            indent([
+                when(!isAbstract(classifier))(
+                    () =>
+                        [
+                            `static create(id: Id, handleDelta?: ${imports.generic("DeltaHandler")}, parentInfo?: ${imports.generic("Parentage")}): ${classifier.name} {`,
+                            indent([
+                                `return new ${classifier.name}(${imports.language(classifier.language)}.INSTANCE.${classifier.name}, id, handleDelta, parentInfo);`
+                            ]),
+                            `}`,
+                        ]
+                ),
+                when(features.length > 0)(
+                    () =>
+                        [
+                            ``,
+                            features.map(withNewlineAppended(classMembersForFeature)),
+                            `public constructor(classifier: ${imports.core("Classifier")}, id: ${imports.core("Id")}, handleDelta?: ${imports.generic("DeltaHandler")}, parentInfo?: ${imports.generic("Parentage")}) {`,
+                            indent([
+                                `super(classifier, id, handleDelta, parentInfo);`,
+                                features.map((feature) => `this._${feature.name} = new ${imports.generic(valueManagerFor(feature))}<${tsTypeForValueManager(feature, imports)}>(${imports.language(feature.classifier.language)}.INSTANCE.${feature.classifier.name}_${feature.name}, this);`)
+                            ]),
+                            `}`,
+                            getValueManagers(features.filter(isProperty)),
+                            getValueManagers(features.filter(isContainment)),
+                            getValueManagers(features.filter(isReference))
+                        ]
+                ),
+            ]),
+            `}`
+        ]
+    }
+
+
+    const typeForEnumeration = (enumeration: Enumeration) =>
+        [
+            `export enum ${enumeration.name} {`,
+            indent(
+                commaSeparated(enumeration.literals.map(({name, key}) => `${name} = "${key}"`))
+                    // Using TS string enums means that the key _is_ the literal's runtime TS representation.
+            ),
+            `}`
+        ]
+
+
+    const interfaceFor = (interface_: Interface) =>
+        [
+            `export interface ${interface_.name} extends ${interface_.extends.length > 0 ? interface_.extends.map((superInterface) => imports.entity(superInterface)).join(", ") : imports.generic("INodeBase")} {`,
+            indent(
+                interface_.features.map((feature) => `${feature.name}: ${tsFieldTypeForFeature(feature, imports)};`)
+            ),
+            `}`
+        ]
+
+
+    const typeForPrimitiveType = (primitiveType: PrimitiveType) =>
+        `export type ${primitiveType.name} = ${tsTypeForPrimitiveType(primitiveType)};`
+
+    const jsDocFor = (entity: LanguageEntity) => {
+        const mpsAnnotationsForEntity = mpsAnnotationsPerId[entity.id] ?? []
+        const conceptDescription = mpsAnnotationsForEntity.find((mpsAnnotation) => mpsAnnotation instanceof ConceptDescription) as ConceptDescription
+        const hasShortConceptDescription = !!(conceptDescription?.shortDescription)
+        const deprecated = mpsAnnotationsForEntity.find((mpsAnnotation) => mpsAnnotation instanceof Deprecated) as Deprecated
+        return when(hasShortConceptDescription || deprecated !== undefined)([
+            `/**`,
+            when(hasShortConceptDescription)(
+                () => ` * ${conceptDescription.shortDescription}`
+            ),
+            when(deprecated !== undefined)(
+                () => ` * @deprecated ${deprecated.comment ?? ""}${deprecated.build === null ? "" : ` (build: ${deprecated.build})`}`
+            ),
+            ` */`
+        ])
+    }
+
+    return (entity: LanguageEntity) =>
+        [
+            jsDocFor(entity),
+            (() => {
+                if (entity instanceof Interface) {
+                    return interfaceFor(entity)
+                }
+                if (entity instanceof Classifier) {
+                    return classForConcreteClassifier(entity)
+                }
+                if (entity instanceof Enumeration) {
+                    return typeForEnumeration(entity)
+                }
+                if (entity instanceof PrimitiveType) {
+                    return typeForPrimitiveType(entity)
+                }
+                return `// unhandled language entity <${entityMetaType(entity)}>"${entity.name}"`
+            })()
+        ]
+
+}
+

package/src/api/generation-headers.ts

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE
+//
+// SPDX-License-Identifier: LicenseRef-TRUMPF
+
+import {asString} from "littoral-templates"
+
+/**
+ * @return the given string, reversed — "abc" -> "cba"
+ * Note: only used to hack around the REUSE compliance checker!
+ */
+const reverseString = (str: string) =>
+    str.split("").reverse().join("")
+
+/**
+ * The license header (as //-styled comments) for code originating from Trumpf Laser SE, licensed under Apache-2.0.
+ */
+const trumpfOriginatingApache2_0LicenseHeaderComments = `// 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.
+//
+// ${reverseString("txeTthgirypoCeliF-XDPS")}: 2025 TRUMPF Laser SE and other contributors
+// ${reverseString("reifitnedI-esneciL-XDPS")}: Apache-2.0
+`
+
+/**
+ * Generic (//-styled) comments warning about code being generated.
+ */
+export const generatedCodeWarningComments = `// Warning: this file is generated!
+// Modifying it by hand is useless at best, and sabotage at worst.
+`
+
+/**
+ * The empty line-separation concatenation of the Trumpf-flavored Apache-2.0 license header and the generation warning.
+ */
+export const defaultTrumpfOriginatingApache2_0LicensedHeader =
+    asString([trumpfOriginatingApache2_0LicenseHeaderComments, ``, generatedCodeWarningComments, ``])
+

package/src/api/generator.ts

@@ -0,0 +1,84 @@
+// 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 {deserializeLanguages, Language, lioncore, SerializationChunk} from "@lionweb/core"
+import {readFileAsJson} from "@lionweb/utilities"
+import {writeFileSync} from "fs"
+import {join} from "path"
+import {cwd} from "process"
+
+import {indexTsFor} from "./index-ts.js"
+import {languageFileFor} from "./language-file.templates.js"
+import {MpsAnnotation} from "./helpers/index.js"
+
+
+const properGenericImportLocation = "@lionweb/class-core"
+
+
+export type GeneratorOptions = {
+    mpsAnnotations: MpsAnnotation[]
+    genericImportLocation: string
+    header?: string
+}
+
+
+const withDefaults = (options?: Partial<GeneratorOptions>): GeneratorOptions => ({
+    mpsAnnotations: options?.mpsAnnotations ?? [],
+    genericImportLocation: options?.genericImportLocation ?? properGenericImportLocation,
+    header: options?.header
+})
+
+
+export const generateLanguage = (language: Language, generationPath: string, options?: Partial<GeneratorOptions>): string => {
+    const {name} = language
+    const fileName = `${name}.g.ts`
+    writeFileSync(join(generationPath, fileName), languageFileFor(language, withDefaults(options)))
+    return fileName
+}
+
+
+export const generateApiFromLanguagesJson = (languagesJsonPath: string, generationPath: string, options?: Partial<GeneratorOptions>) => {
+    console.log(`Running API generator with cwd: ${cwd()}`)
+    console.log(`   Path to languages: ${languagesJsonPath}`)
+    console.log(`   Generation path:   ${generationPath}`)
+
+    const languagesJson = readFileAsJson(languagesJsonPath) as SerializationChunk
+    const languages = deserializeLanguages(languagesJson, lioncore)
+    generateApiFromLanguages(languages, generationPath, options)
+}
+
+
+export const generateApiFromLanguages = (languages: Language[], generationPath: string, maybeOptions?: Partial<GeneratorOptions>) => {
+    console.log(`   Generated:`)
+
+    const options = withDefaults(maybeOptions)
+
+    if (languages.length > 1) {
+        writeFileSync(join(generationPath, "index.g.ts"), indexTsFor(languages, options))
+        console.log(`       index.g.ts`)
+    }
+
+    languages.forEach((language) => {
+        const {name, version, key, id} = language
+        const fileName = generateLanguage(language, generationPath, options)
+        console.log(`       ${fileName} -> language: ${name} (version=${version}, key=${key}, id=${id})`)
+    })
+
+    console.log(`[done]`)
+    console.log()
+}
+

package/src/api/helpers/classifiers.ts

@@ -0,0 +1,67 @@
+// 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 {
+    allFeaturesOf,
+    allSuperTypesOf,
+    Annotation,
+    Classifier,
+    Concept,
+    Feature,
+    Interface,
+    MultiRef,
+    SingleRef
+} from "@lionweb/core"
+import {uniquesAmong} from "@lionweb/utilities/dist/utils/array.js"
+
+
+export const isAbstract = (classifier: Classifier): boolean =>
+    classifier instanceof Concept && classifier.abstract
+/*
+ * The logical inverse is: classifier instanceof Annotation || (classifier instanceof Concept && !classifier.abstract)
+ */
+
+
+export const extendsFrom = (classifier: Classifier): SingleRef<Classifier> | undefined => {
+    if (classifier instanceof Annotation) {
+        return classifier.extends
+    }
+    if (classifier instanceof Concept) {
+        return classifier.extends
+    }
+    return undefined
+}
+
+export const implementsFrom = (classifier: Classifier): MultiRef<Classifier> => {
+    if (classifier instanceof Annotation) {
+        return classifier.implements
+    }
+    if (classifier instanceof Concept) {
+        return classifier.implements
+    }
+    return []
+}
+
+export const featuresToConcretelyImplementOf = (classifier: Classifier): Feature[] => {
+    if (classifier instanceof Interface) {
+        return []
+    }
+    const implementedFeatures = uniquesAmong(allSuperTypesOf(classifier).flatMap(featuresToConcretelyImplementOf))
+    return allFeaturesOf(classifier)
+        .filter((feature) => implementedFeatures.indexOf(feature) === -1)
+}
+

package/src/api/helpers/dependencies.ts

@@ -0,0 +1,62 @@
+// 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 {Classifier, cycleWith, inheritsFrom, Language, nameOf, nameSorted} from "@lionweb/core"
+import {uniquesAmong} from "@lionweb/utilities/dist/utils/array.js"
+import {asString, when} from "littoral-templates"
+import {indent} from "../../utils/index.js"
+
+
+/**
+ * @return all languages that any {@link Classifier classifier} of the given {@link Language language} depends on through direct inheritance.
+ */
+export const dependenciesThroughDirectInheritanceOf = (language: Language) =>
+    uniquesAmong(
+        language.entities
+            .filter((entity) => entity instanceof Classifier)
+            .flatMap((entity) => inheritsFrom(entity as Classifier))
+            .map((classifier) => classifier.language)
+            .filter((depLanguage) => depLanguage !== language)
+    )
+
+
+/**
+ * @return the – currently only those arising from direct inheritance on classifier-level – dependencies of the given {@link Language languages},
+ *  as a human-readable text
+ */
+export const verboseDependencies = (languages: Language[]): string => {
+    const nameSortedLanguages = nameSorted(languages)
+    return asString([
+        nameSortedLanguages.map((language) => {
+            const deps = dependenciesThroughDirectInheritanceOf(language)
+            const what = `direct type-wise dependencies (through inheritance)`
+            const cycle = cycleWith(language, dependenciesThroughDirectInheritanceOf)
+            return deps.length === 0
+                ? `language ${language.name} has no ${what}`
+                : [
+                    `language ${language.name} has the following ${what}:`,
+                    indent([
+                        nameSorted(dependenciesThroughDirectInheritanceOf(language)).map(nameOf),
+                        when(cycle.length > 0)(
+                            `⚠ language "${language.name}" is part of the following cycle through type-wise (through direct inheritance): ${cycle.map(nameOf).join(" -> ")}`
+                        )
+                    ])
+                ]
+        })
+    ])
+}
+

package/src/api/helpers/entities.ts

@@ -0,0 +1,43 @@
+// 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 {Annotation, Concept, Interface, LanguageEntity, PrimitiveType} from "@lionweb/core"
+
+
+type EntityMetaType =
+    | "Annotation"
+    | "Concept"
+    | "Enumeration"
+    | "Interface"
+    | "PrimitiveType"
+
+export const entityMetaType = (entity: LanguageEntity): EntityMetaType => {
+    if (entity instanceof Annotation) {
+        return "Annotation"
+    }
+    if (entity instanceof Concept) {
+        return "Concept"
+    }
+    if (entity instanceof Interface) {
+        return "Interface"
+    }
+    if (entity instanceof PrimitiveType) {
+        return "PrimitiveType"
+    }
+    throw new Error(`unhandled LanguageEntity sub type ${entity.constructor.name}`)
+}
+