@lionweb/class-core-generator 0.6.13-beta.7 → 0.7.0-alpha.2

package/src/api/index-ts.ts

@@ -15,39 +15,49 @@
 // 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"
+import { dependencyOrderOf } from "@lionweb/ts-utils"
+import { Language } from "@lionweb/core"
+import { asString, commaSeparated } from "littoral-templates"
 
+import { indent } from "../utils/textgen.js"
+import { GeneratorOptions } from "./generator.js"
+import { dependenciesThroughDirectInheritanceOf, importRenamingForLanguage, nameOfBaseClassForLanguage } from "./helpers/index.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!`)
+        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)
+    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";`),
+        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};`),
+            .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`))),
+        indent(
+            commaSeparated(
+                languagesForImports.map(
+                    language => `${importRenamingForLanguage(language)}.${nameOfBaseClassForLanguage(language)}.INSTANCE`
+                )
+            )
+        ),
         `];`,
         ``,
         `export {`,

package/src/api/index.ts

@@ -15,7 +15,6 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export {generateLanguage, generateApiFromLanguages, generateApiFromLanguagesJson} from "./generator.js"
+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

@@ -15,25 +15,19 @@
 // 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"
+import { sortedStringsByUppercase } from "@lionweb/ts-utils"
+import { Concept, Language } from "@lionweb/core"
+import { dependencyOrderOf } from "@lionweb/ts-utils"
+import { asString, commaSeparated, when, withNewlineAppended } from "littoral-templates"
+import { indent } from "../utils/textgen.js"
 
+import { typeForLanguageEntity } from "./entity-types.templates.js"
+import { GeneratorOptions } from "./generator.js"
+import { Imports } from "./helpers/index.js"
+import { reflectiveClassFor } from "./reflective-layer.templates.js"
 
 const importStatement = (dep: string, items: string[]) =>
-    when(items.length > 0)([
-        `import {`,
-        indent(commaSeparated(sortedStringsByUppercase(items))),
-        `} from "${dep}";`,
-        ``
-    ])
+    when(items.length > 0)([`import {`, indent(commaSeparated(sortedStringsByUppercase(items))), `} from "${dep}";`, ``])
 
 
 export const languageFileFor = (language: Language, options: GeneratorOptions) => {
@@ -47,8 +41,6 @@ export const languageFileFor = (language: Language, options: GeneratorOptions) =
         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),
@@ -56,7 +48,7 @@ export const languageFileFor = (language: Language, options: GeneratorOptions) =
         ``,
         orderedEntities
             .filter((entity) => entity.language === language)
-            .map(withNewlineAppended(typeForLanguageEntity(imports, mpsAnnotationsPerId)))
+            .map(withNewlineAppended(typeForLanguageEntity(imports)))
     ]
 
     return asString([
@@ -71,6 +63,7 @@ export const languageFileFor = (language: Language, options: GeneratorOptions) =
         ``,
         ``,
         importStatement(`@lionweb/core`, imports.coreImports),
+        importStatement(`@lionweb/json`, imports.jsonImports),
         importStatement(options.genericImportLocation, imports.genericImports),
         importStatement(`./index.g.js`, imports.languageImports),
         postImportsPart

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

@@ -15,46 +15,42 @@
 // 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 { 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";
+import { asJSIdentifier, indent } from "../utils/textgen.js"
+import { Deprecated, ioLionWebMpsSpecificAnnotationsFrom } from "@lionweb/io-lionweb-mps-specific"
 
+export const megaFactoryFor = (megaFactoryName: string, languages: Language[], header?: string) => {
+    const isNotDeprecated = (entity: LanguageEntity) =>
+        !ioLionWebMpsSpecificAnnotationsFrom(entity).some((annotation) => annotation instanceof Deprecated)
 
-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 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)`)
-        )),
+        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)
-        )
+    const languagesWithFactoryMethods = languages.filter(language => language.entities.some(requiresFactoryMethod))
 
     return asString([
         header ?? [],
         `import {DeltaHandler} from "@lionweb/class-core";`,
         ``,
         `import {`,
-        indent(commaSeparated(
-            languagesWithFactoryMethods.map(({name}) => asJSIdentifier(name))
-        )),
+        indent(commaSeparated(languagesWithFactoryMethods.map(({ name }) => asJSIdentifier(name)))),
         `} from "./index.g.js";`,
         ``,
         `import {newId} from "../index.js";`,
@@ -64,9 +60,7 @@ export const megaFactoryFor = (megaFactoryName: string, languages: Language[], m
         indent([
             ``,
             `constructor(`,
-            indent([
-                `public readonly handleDelta?: DeltaHandler`
-            ]),
+            indent([`public readonly handleDelta?: DeltaHandler`]),
             `) {`,
             `}`,
             ``,

package/src/api/reflective-layer.templates.ts

@@ -17,7 +17,6 @@
 
 import {
     Annotation,
-    asArray,
     Classifier,
     Concept,
     Enumeration,
@@ -36,90 +35,70 @@ import {
     Property,
     SingleRef
 } from "@lionweb/core"
-import {when, withNewlineAppended} from "littoral-templates"
-
-import {indent, switchOrIf} from "../utils/textgen.js"
-import {entityMetaType, extendsFrom, Imports, nameOfBaseClassForLanguage} from "./helpers/index.js"
+import { asArray } from "@lionweb/ts-utils"
+import { when, withNewlineAppended } from "littoral-templates"
 
+import { indent, switchOrIf } from "../utils/textgen.js"
+import { entityMetaType, extendsFrom, Imports, nameOfBaseClassForLanguage } from "./helpers/index.js"
 
 export const reflectiveClassFor = (imports: Imports) => {
-
     // classifier:
 
     const reflectiveMembersForFeature = (feature: Feature) => {
-        const {classifier, name, key, id, optional} = feature
+        const { classifier, name, key, id, optional } = feature
         const metaType = featureMetaType(feature)
         const qName = `${classifier.name}_${name}`
         return [
             `private readonly _${qName} = new ${imports.core(metaType)}(this._${classifier.name}, "${name}", "${key}", "${id}")${optional ? ".isOptional()" : ""}${isMultiple(feature) ? ".isMultiple()" : ""};`,
             //               | core (2nd x) |
             `get ${qName}(): ${metaType} {`,
-            indent([
-                `this.ensureWiredUp();`,
-                `return this._${qName};`
-            ]),
+            indent([`this.ensureWiredUp();`, `return this._${qName};`]),
             `}`
         ]
     }
 
     const reflectiveMembersForClassifier = (classifier: Classifier) => {
-        const {name, key, id, features} = classifier
+        const { name, key, id, features } = classifier
         const metaType = entityMetaType(classifier)
         return [
-            `public readonly _${name} = new ${imports.core(metaType)}(this._language, "${name}", "${key}", "${id}"${classifier instanceof Concept ? (", " + classifier.abstract) : ""});`,
+            `public readonly _${name} = new ${imports.core(metaType)}(this._language, "${name}", "${key}", "${id}"${classifier instanceof Concept ? ", " + classifier.abstract : ""});`,
             //              | core (2nd x) |
             `get ${name}(): ${metaType} {`,
-            indent([
-                `this.ensureWiredUp();`,
-                `return this._${name};`
-            ]),
+            indent([`this.ensureWiredUp();`, `return this._${name};`]),
             `}`,
             features.map(reflectiveMembersForFeature)
         ]
     }
 
+    // enumeration:
 
-// enumeration:
-
-    const reflectiveMemberForEnumerationLiteral = ({enumeration, name, key, id}: EnumerationLiteral) => {
+    const reflectiveMemberForEnumerationLiteral = ({ enumeration, name, key, id }: EnumerationLiteral) => {
         const qName = `${enumeration.name}_${name}`
         return [
             `private readonly _${qName} = new ${imports.core("EnumerationLiteral")}(this._${enumeration.name}, "${name}", "${key}", "${id}");`,
             //               |  core (2nd x)  |
             `get ${qName}(): EnumerationLiteral {`,
-            indent([
-                `this.ensureWiredUp();`,
-                `return this._${qName};`
-            ]),
+            indent([`this.ensureWiredUp();`, `return this._${qName};`]),
             `}`
         ]
     }
 
-    const reflectiveMembersForEnumeration = ({name, key, id, literals}: Enumeration) =>
-        [
-            `public readonly _${name} = new ${imports.core("Enumeration")}(this._language, "${name}", "${key}", "${id}");`,
-            //              | core (2nd x) |
-            `get ${name}(): Enumeration {`,
-            indent([
-                `this.ensureWiredUp();`,
-                `return this._${name};`
-            ]),
-            `}`,
-            literals.map(reflectiveMemberForEnumerationLiteral)
-        ]
-
-    const reflectiveMembersForPrimitiveType = ({name, key, id}: PrimitiveType) =>
-        [
-            `public readonly _${name} = new ${imports.core("PrimitiveType")}(this._language, "${name}", "${key}", "${id}");`,
-            //              | core (2nd x) |
-            `get ${name}(): PrimitiveType {`,
-            indent([
-                `this.ensureWiredUp();`,
-                `return this._${name};`
-            ]),
-            `}`
-        ]
-
+    const reflectiveMembersForEnumeration = ({ name, key, id, literals }: Enumeration) => [
+        `public readonly _${name} = new ${imports.core("Enumeration")}(this._language, "${name}", "${key}", "${id}");`,
+        //              | core (2nd x) |
+        `get ${name}(): Enumeration {`,
+        indent([`this.ensureWiredUp();`, `return this._${name};`]),
+        `}`,
+        literals.map(reflectiveMemberForEnumerationLiteral)
+    ]
+
+    const reflectiveMembersForPrimitiveType = ({ name, key, id }: PrimitiveType) => [
+        `public readonly _${name} = new ${imports.core("PrimitiveType")}(this._language, "${name}", "${key}", "${id}");`,
+        //              | core (2nd x) |
+        `get ${name}(): PrimitiveType {`,
+        indent([`this.ensureWiredUp();`, `return this._${name};`]),
+        `}`
+    ]
 
     const reflectiveMembersForEntity = (entity: LanguageEntity) => {
         if (entity instanceof Classifier) {
@@ -134,7 +113,6 @@ export const reflectiveClassFor = (imports: Imports) => {
         return `// unhandled language entity <${entityMetaType(entity)}>"${entity.name}"`
     }
 
-
     const refForType = (type: SingleRef<LanguageEntity>) => {
         if (type === null) {
             return `???`
@@ -146,12 +124,12 @@ export const reflectiveClassFor = (imports: Imports) => {
     }
 
     const wireUpStatementsForProperty = (property: Property) => {
-        const {classifier, name, type, optional} = property
+        const { classifier, name, type, optional } = property
         return `this._${classifier.name}_${name}.ofType(${refForType(type)})${optional ? ".isOptional()" : ""};`
     }
 
     const wireUpStatementsForLink = (link: Link) => {
-        const {classifier, name, type} = link
+        const { classifier, name, type } = link
         return `this._${classifier.name}_${name}.ofType(${refForType(type)});`
     }
 
@@ -165,23 +143,24 @@ export const reflectiveClassFor = (imports: Imports) => {
         return `// unhandled feature <${featureMetaType(feature)}>"${feature.name}"`
     }
 
-    const isConcreteClassifier = (classifier: Classifier): classifier is (Annotation | Concept) =>
+    const isConcreteClassifier = (classifier: Classifier): classifier is Annotation | Concept =>
         classifier instanceof Annotation || classifier instanceof Concept
 
     const wireUpStatementsForEntity = (entity: LanguageEntity) => {
-        const {name} = entity
+        const { name } = entity
         const thisLocalName = (localName: string) => `this._${name}_${localName}`
         if (entity instanceof Classifier) {
             const extends_ = extendsFrom(entity)
             return [
-                extends_ instanceof Classifier
-                    ? `this._${name}.extends = ${refForType(extends_)};`
-                    : [],
+                extends_ instanceof Classifier ? `this._${name}.extends = ${refForType(extends_)};` : [],
                 when(entity instanceof Interface && entity.extends.length > 0)(
-                    () => `this._${name}.extending(${(entity as Interface).extends.map((interface_) => refForType(interface_)).join(", ")});`
+                    () => `this._${name}.extending(${(entity as Interface).extends.map(interface_ => refForType(interface_)).join(", ")});`
                 ),
                 when(isConcreteClassifier(entity) && entity.implements.length > 0)(
-                    () => `this._${name}.implementing(${asArray((entity as (Annotation | Concept)).implements).map((interface_) => refForType(interface_)).join(", ")});`
+                    () =>
+                        `this._${name}.implementing(${asArray((entity as Annotation | Concept).implements)
+                            .map(interface_ => refForType(interface_))
+                            .join(", ")});`
                 ),
                 when(entity.features.length > 0)(
                     `this._${name}.havingFeatures(${entity.features.map(nameOf).map(thisLocalName).join(", ")});`
@@ -193,13 +172,13 @@ export const reflectiveClassFor = (imports: Imports) => {
             return `this._${name}.havingLiterals(${entity.literals.map(nameOf).map(thisLocalName).join(", ")});`
         }
         if (entity instanceof PrimitiveType) {
-            return []   // (nothing to do)
+            return [] // (nothing to do)
         }
         return `// unhandled language entity <${entityMetaType(entity)}>"${name}"`
     }
 
     return (language: Language) => {
-        const {version, id, key, entities} = language
+        const { version, id, key, entities } = language
         const enumerations = entities.filter(isEnumeration)
         const concreteClassifiers = entities.filter(isConcrete)
         const parameterPrefix = concreteClassifiers.length === 0 ? "_" : ""
@@ -212,10 +191,7 @@ export const reflectiveClassFor = (imports: Imports) => {
                 `private readonly _language: ${imports.core("Language")} = new Language("${imports.thisLanguageNameAsJsIdentifier}", "${version}", "${id}", "${key}");`,
                 //               | core | (3rd x)
                 `get language(): Language {`,
-                indent([
-                    `this.ensureWiredUp();`,
-                    `return this._language;`
-                ]),
+                indent([`this.ensureWiredUp();`, `return this._language;`]),
                 `}`,
                 ``,
                 entities.map(withNewlineAppended(reflectiveMembersForEntity)),
@@ -233,11 +209,13 @@ export const reflectiveClassFor = (imports: Imports) => {
                 ``,
                 `factory(${parameterPrefix}handleDelta?: ${imports.generic("DeltaHandler")}): ${imports.generic("NodeBaseFactory")} {`,
                 indent([
-                    `return (classifier: ${imports.core("Classifier")}, ${parameterPrefix}id: ${imports.core("Id")}) => {`,
+                    `return (classifier: ${imports.core("Classifier")}, ${parameterPrefix}id: ${imports.json("LionWebId")}) => {`,
                     indent(
                         switchOrIf(
                             "classifier.key",
-                            concreteClassifiers.map(nameOf).map((name) => [`this._${name}.key`, `${name}.create(id, ${parameterPrefix}handleDelta)`]),
+                            concreteClassifiers
+                                .map(nameOf)
+                                .map(name => [`this._${name}.key`, `${name}.create(id, ${parameterPrefix}handleDelta)`]),
                             [
                                 `const {language} = classifier;`,
                                 `throw new Error(\`can't instantiate \${classifier.name} (key=\${classifier.key}): classifier is not known in language \${language.name} (key=\${language.key}, version=\${language.version})\`);`
@@ -254,7 +232,7 @@ export const reflectiveClassFor = (imports: Imports) => {
                     `const {enumeration} = enumerationLiteral;`,
                     switchOrIf(
                         "enumeration.key",
-                        enumerations.map(nameOf).map((name) => [`this._${name}.key`, "enumerationLiteral.key as EnumType"]),
+                        enumerations.map(nameOf).map(name => [`this._${name}.key`, "enumerationLiteral.key as EnumType"]),
                         [
                             `const {language} = enumeration;`,
                             `throw new Error(\`enumeration with key \${enumeration.key} is not known in language \${language.name} (key=\${language.key}, version=\${language.version})\`);`
@@ -268,6 +246,5 @@ export const reflectiveClassFor = (imports: Imports) => {
             `}`
         ]
     }
-
 }
 

package/src/utils/index.ts

@@ -16,6 +16,5 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export {asTypeScript} from "./json-as-ts.js"
-export {sortedStrings, sortedStringsByUppercase} from "./string-sorting.js"
 export {indent} from "./textgen.js"
 

package/src/utils/textgen.ts

@@ -21,7 +21,7 @@
  */
 
 
-import {asString, indentWith, Template} from "littoral-templates"
+import { asString, indentWith, Template } from "littoral-templates"
 
 
 /**

package/dist/api/helpers/mps-annotations.d.ts

@@ -1,19 +0,0 @@
-import { Id, SerializationChunk } from "@lionweb/core";
-export declare abstract class MpsAnnotation {
-    readonly annotatedNodeId: Id;
-    constructor(annotatedNodeId: Id);
-}
-export declare class ConceptDescription extends MpsAnnotation {
-    readonly shortDescription: string | null;
-    readonly alias: string | null;
-    constructor(annotatedNodeId: Id, shortDescription: string | null, alias: string | null);
-    toString(): string;
-}
-export declare class Deprecated extends MpsAnnotation {
-    readonly comment: string | null;
-    readonly build: string | null;
-    constructor(annotatedNodeId: Id, comment: string | null, build: string | null);
-    toString(): string;
-}
-export declare const extractedMpsAnnotations: ({ nodes }: SerializationChunk) => MpsAnnotation[];
-//# sourceMappingURL=mps-annotations.d.ts.map

package/dist/api/helpers/mps-annotations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mps-annotations.d.ts","sourceRoot":"","sources":["../../../src/api/helpers/mps-annotations.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAC,EAAE,EAAE,kBAAkB,EAAC,MAAM,eAAe,CAAA;AAGpD,8BAAsB,aAAa;aACH,eAAe,EAAE,EAAE;gBAAnB,eAAe,EAAE,EAAE;CAElD;AAED,qBAAa,kBAAmB,SAAQ,aAAa;aACA,gBAAgB,EAAE,MAAM,GAAG,IAAI;aAAkB,KAAK,EAAE,MAAM,GAAG,IAAI;gBAA1G,eAAe,EAAE,EAAE,EAAkB,gBAAgB,EAAE,MAAM,GAAG,IAAI,EAAkB,KAAK,EAAE,MAAM,GAAG,IAAI;IAGtH,QAAQ;CAGX;AAED,qBAAa,UAAW,SAAQ,aAAa;aACQ,OAAO,EAAE,MAAM,GAAG,IAAI;aAAkB,KAAK,EAAE,MAAM,GAAG,IAAI;gBAAjG,eAAe,EAAE,EAAE,EAAkB,OAAO,EAAE,MAAM,GAAG,IAAI,EAAkB,KAAK,EAAE,MAAM,GAAG,IAAI;IAG7G,QAAQ;CAGX;AAGD,eAAO,MAAM,uBAAuB,cAAa,kBAAkB,KAAG,aAAa,EAuB7E,CAAA"}

package/dist/api/helpers/mps-annotations.js

@@ -1,65 +0,0 @@
-// 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 class MpsAnnotation {
-    constructor(annotatedNodeId) {
-        this.annotatedNodeId = annotatedNodeId;
-    }
-}
-export class ConceptDescription extends MpsAnnotation {
-    constructor(annotatedNodeId, shortDescription, alias) {
-        super(annotatedNodeId);
-        this.shortDescription = shortDescription;
-        this.alias = alias;
-    }
-    toString() {
-        return `<ConceptDescription> annotatedNodeId=${this.annotatedNodeId}, shortDescription="${this.shortDescription}"`;
-    }
-}
-export class Deprecated extends MpsAnnotation {
-    constructor(annotatedNodeId, comment, build) {
-        super(annotatedNodeId);
-        this.comment = comment;
-        this.build = build;
-    }
-    toString() {
-        return `<Deprecated> annotatedNodeId=${this.annotatedNodeId}, comment="${this.comment}", build="${this.build}"`;
-    }
-}
-export const extractedMpsAnnotations = ({ nodes }) => nodes.flatMap(({ classifier, properties, parent }) => {
-    const propertyValue = (key) => {
-        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 [];
-        }
-    }
-});
-//# sourceMappingURL=mps-annotations.js.map

package/dist/api/helpers/mps-annotations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mps-annotations.js","sourceRoot":"","sources":["../../../src/api/helpers/mps-annotations.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;AAKtC,MAAM,OAAgB,aAAa;IAC/B,YAA4B,eAAmB;QAAnB,oBAAe,GAAf,eAAe,CAAI;IAC/C,CAAC;CACJ;AAED,MAAM,OAAO,kBAAmB,SAAQ,aAAa;IACjD,YAAY,eAAmB,EAAkB,gBAA+B,EAAkB,KAAoB;QAClH,KAAK,CAAC,eAAe,CAAC,CAAA;QADuB,qBAAgB,GAAhB,gBAAgB,CAAe;QAAkB,UAAK,GAAL,KAAK,CAAe;IAEtH,CAAC;IACD,QAAQ;QACJ,OAAO,wCAAwC,IAAI,CAAC,eAAe,uBAAuB,IAAI,CAAC,gBAAgB,GAAG,CAAA;IACtH,CAAC;CACJ;AAED,MAAM,OAAO,UAAW,SAAQ,aAAa;IACzC,YAAY,eAAmB,EAAkB,OAAsB,EAAkB,KAAoB;QACzG,KAAK,CAAC,eAAe,CAAC,CAAA;QADuB,YAAO,GAAP,OAAO,CAAe;QAAkB,UAAK,GAAL,KAAK,CAAe;IAE7G,CAAC;IACD,QAAQ;QACJ,OAAO,gCAAgC,IAAI,CAAC,eAAe,cAAc,IAAI,CAAC,OAAO,aAAa,IAAI,CAAC,KAAK,GAAG,CAAA;IACnH,CAAC;CACJ;AAGD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,EAAC,KAAK,EAAqB,EAAmB,EAAE,CACpF,KAAK,CAAC,OAAO,CAAgB,CAAC,EAAC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAC,EAAE,EAAE;IAC9D,MAAM,aAAa,GAAG,CAAC,GAAW,EAAiB,EAAE;QACjD,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,KAAK,GAAG,CAAC,CAAA;QACtE,OAAO,QAAQ,KAAK,SAAS;YACzB,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAA;IACxB,CAAC,CAAA;IACD,IAAI,UAAU,CAAC,QAAQ,KAAK,yBAAyB,IAAI,UAAU,CAAC,OAAO,KAAK,GAAG,EAAE,CAAC;QAClF,OAAO,EAAE,CAAA;IACb,CAAC;IACD,QAAQ,UAAU,CAAC,GAAG,EAAE,CAAC;QACrB,KAAK,oBAAoB,CAAC,CAAC,CAAC;YACxB,OAAO,CAAC,IAAI,kBAAkB,CAAC,MAAO,EAAE,aAAa,CAAC,4CAA4C,CAAC,EAAE,aAAa,CAAC,iCAAiC,CAAC,CAAC,CAAC,CAAA;QAC3J,CAAC;QACD,KAAK,YAAY,CAAC,CAAC,CAAC;YAChB,OAAO,CAAC,IAAI,UAAU,CAAC,MAAO,EAAE,aAAa,CAAC,oBAAoB,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAA;QAC5G,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,2CAA2C,UAAU,CAAC,GAAG,EAAE,CAAC,CAAA;YACxE,OAAO,EAAE,CAAA;QACb,CAAC;IACL,CAAC;AACL,CAAC,CAAC,CAAA"}

package/dist/api/helpers/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/api/helpers/types.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAoB,aAAa,EAAC,MAAM,eAAe,CAAA;AAG9D,eAAO,MAAM,sBAAsB,kBAAmB,aAAa,KAAG,MASrE,CAAA"}

package/dist/api/helpers/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/api/helpers/types.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,OAAO,EAAC,iBAAiB,EAAgB,MAAM,eAAe,CAAA;AAG9D,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,aAA4B,EAAU,EAAE;IAC3E,QAAQ,aAAa,EAAE,CAAC;QACpB,KAAK,iBAAiB,CAAC,eAAe,CAAC,CAAC,OAAO,SAAS,CAAA;QACxD,KAAK,iBAAiB,CAAC,cAAc,CAAC,CAAC,OAAO,QAAQ,CAAA;QACtD,KAAK,iBAAiB,CAAC,eAAe,CAAC,CAAC,OAAO,QAAQ,CAAA;QACvD,KAAK,iBAAiB,CAAC,YAAY,CAAC,CAAC,OAAO,SAAS,CAAA;QACrD;YACI,OAAO,QAAQ,CAAA;IACvB,CAAC;AACL,CAAC,CAAA"}

package/dist/utils/string-sorting.d.ts

@@ -1,4 +0,0 @@
-export type StringSorter = (strings: string[]) => string[];
-export declare const sortedStrings: StringSorter;
-export declare const sortedStringsByUppercase: StringSorter;
-//# sourceMappingURL=string-sorting.d.ts.map

package/dist/utils/string-sorting.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-sorting.d.ts","sourceRoot":"","sources":["../../src/utils/string-sorting.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAA;AAQ1D,eAAO,MAAM,aAAa,cAAkC,CAAA;AAE5D,eAAO,MAAM,wBAAwB,cAAgD,CAAA"}

package/dist/utils/string-sorting.js

@@ -1,23 +0,0 @@
-// 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
-const sortedStringsWith = (strMap) => (strings) => {
-    strings.sort((l, r) => strMap(l).localeCompare(strMap(r)));
-    return strings;
-};
-export const sortedStrings = sortedStringsWith((str) => str);
-export const sortedStringsByUppercase = sortedStringsWith((str) => str.toUpperCase());
-//# sourceMappingURL=string-sorting.js.map

package/dist/utils/string-sorting.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-sorting.js","sourceRoot":"","sources":["../../src/utils/string-sorting.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;AAItC,MAAM,iBAAiB,GAAG,CAAC,MAA+B,EAAgB,EAAE,CACxE,CAAC,OAAO,EAAE,EAAE;IACR,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1D,OAAO,OAAO,CAAA;AAClB,CAAC,CAAA;AAEL,MAAM,CAAC,MAAM,aAAa,GAAG,iBAAiB,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAA;AAE5D,MAAM,CAAC,MAAM,wBAAwB,GAAG,iBAAiB,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAA"}

package/dist/utils/toposort.d.ts

@@ -1,6 +0,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 declare const dependencyOrderOf: <T>(vertices: T[], edgesOf: (vertex: T) => T[]) => false | T[];
-//# sourceMappingURL=toposort.d.ts.map

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

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