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

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, groupBy } 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) => {
@@ -71,6 +65,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 {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/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/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"}

package/dist/utils/toposort.js

@@ -1,41 +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
-/**
- * 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

@@ -1 +0,0 @@
-{"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/src/utils/string-sorting.ts

@@ -1,29 +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 type StringSorter = (strings: string[]) => string[]
-
-const sortedStringsWith = (strMap: (str: string) => string): StringSorter =>
-    (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())
-

package/src/utils/toposort.ts

@@ -1,49 +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
-
-/**
- * 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 = <T>(vertices: T[], edgesOf: (vertex: T) => T[]): T[] | false => {
-    const ordered: T[] = []
-
-    const visit = (current: T, chain: T[]) => {
-        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
-}
-