@lionweb/class-core-generator 0.6.13-beta.5 → 0.6.13-beta.7

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

@@ -15,42 +15,46 @@
 // 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, 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 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";`,
@@ -60,7 +64,9 @@ 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,6 +17,7 @@
 
 import {
     Annotation,
+    asArray,
     Classifier,
     Concept,
     Enumeration,
@@ -35,70 +36,90 @@ import {
     Property,
     SingleRef
 } from "@lionweb/core"
-import { asArray } from "@lionweb/ts-utils"
-import { when, withNewlineAppended } from "littoral-templates"
+import {when, withNewlineAppended} from "littoral-templates"
+
+import {indent, switchOrIf} from "../utils/textgen.js"
+import {entityMetaType, extendsFrom, Imports, nameOfBaseClassForLanguage} from "./helpers/index.js"
 
-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:
 
-    const reflectiveMemberForEnumerationLiteral = ({ enumeration, name, key, id }: EnumerationLiteral) => {
+// enumeration:
+
+    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) {
@@ -113,6 +134,7 @@ export const reflectiveClassFor = (imports: Imports) => {
         return `// unhandled language entity <${entityMetaType(entity)}>"${entity.name}"`
     }
 
+
     const refForType = (type: SingleRef<LanguageEntity>) => {
         if (type === null) {
             return `???`
@@ -124,12 +146,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)});`
     }
 
@@ -143,24 +165,23 @@ 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(", ")});`
@@ -172,13 +193,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 ? "_" : ""
@@ -191,7 +212,10 @@ 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)),
@@ -209,13 +233,11 @@ export const reflectiveClassFor = (imports: Imports) => {
                 ``,
                 `factory(${parameterPrefix}handleDelta?: ${imports.generic("DeltaHandler")}): ${imports.generic("NodeBaseFactory")} {`,
                 indent([
-                    `return (classifier: ${imports.core("Classifier")}, ${parameterPrefix}id: ${imports.json("LionWebId")}) => {`,
+                    `return (classifier: ${imports.core("Classifier")}, ${parameterPrefix}id: ${imports.core("Id")}) => {`,
                     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})\`);`
@@ -232,7 +254,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})\`);`
@@ -246,5 +268,6 @@ export const reflectiveClassFor = (imports: Imports) => {
             `}`
         ]
     }
+
 }
 

package/src/utils/textgen.ts

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