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

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 {asJSIdentifier, indent} from "../utils/textgen.js"
-import {Deprecated, MpsAnnotation} from "./helpers/index.js";
+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 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/textgen.ts

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