@lionweb/utilities 0.7.0-beta.18 → 0.7.0-beta.19

package/src/serialization/metric-types.ts

@@ -0,0 +1,43 @@
+import { LionWebKey } from "@lionweb/json"
+
+type OptionallyNamed = {
+    name?: string   // == name when it can be looked up
+}
+
+type LanguagePointer = {
+    key: LionWebKey
+    version: string
+} & OptionallyNamed
+
+/* abstract */ type ClassifierMetric = {
+    language: LanguagePointer
+    key: LionWebKey         // key of classifier
+} & OptionallyNamed
+
+type ClassifierMetaTypes = "annotation" | "concept" | "interface"
+
+type ClassifierInstantiationMetric = {
+    metaType?: ClassifierMetaTypes
+    instantiations: number
+} & ClassifierMetric
+
+type LanguageMetric = {
+    instantiations: number
+} & LanguagePointer
+
+// TODO  order?
+type Metrics = {
+    languagesWithInstantiations: LanguageMetric[]
+    instantiatedClassifiers: ClassifierInstantiationMetric[]
+    uninstantiatedInstantiableClassifiers: ClassifierMetric[]
+    languagesWithoutInstantiations: LanguagePointer[]
+}
+
+
+export type {
+    ClassifierInstantiationMetric,
+    ClassifierMetaTypes,
+    LanguagePointer,
+    Metrics
+}
+

package/src/serialization/ordering.ts

@@ -0,0 +1,73 @@
+import {
+    LionWebJsonChunk,
+    LionWebJsonContainment,
+    LionWebJsonMetaPointer,
+    LionWebJsonNode,
+    LionWebJsonProperty,
+    LionWebJsonReference,
+    LionWebJsonReferenceTarget,
+    LionWebJsonUsedLanguage
+} from "@lionweb/json"
+
+const orderedMetaPointer = ({ language, version, key }: LionWebJsonMetaPointer): LionWebJsonMetaPointer => ({
+    language,
+    version,
+    key
+})
+
+const orderedSerializedLanguageReference = ({ key, version }: LionWebJsonUsedLanguage): LionWebJsonUsedLanguage => ({
+    key,
+    version
+})
+
+const orderedSerializedReferenceTarget = ({ reference, resolveInfo }: LionWebJsonReferenceTarget): LionWebJsonReferenceTarget => ({
+    resolveInfo,
+    reference
+})
+
+const orderedSerializedProperty = ({ property, value }: LionWebJsonProperty): LionWebJsonProperty => ({
+    property: orderedMetaPointer(property),
+    value
+})
+
+const orderedSerializedContainment = ({ containment, children }: LionWebJsonContainment): LionWebJsonContainment => ({
+    containment: orderedMetaPointer(containment),
+    children    // TODO  ensure [] if empty
+})
+
+const orderedSerializedReference = ({ reference, targets }: LionWebJsonReference): LionWebJsonReference => ({
+    reference: orderedMetaPointer(reference),
+    targets: targets.map(orderedSerializedReferenceTarget)    // TODO  ensure [] if empty
+})
+
+const orderedSerializedNode = ({
+    id,
+    classifier,
+    properties,
+    containments,
+    references,
+    annotations,
+    parent
+}: LionWebJsonNode): LionWebJsonNode => ({
+    id,
+    classifier: orderedMetaPointer(classifier),
+    properties: properties.map(orderedSerializedProperty),
+    containments: containments.map(orderedSerializedContainment),
+    references: references.map(orderedSerializedReference),
+    annotations,    // TODO  ensure [] if empty
+    parent
+})
+
+const orderedSerializationChunk = ({ serializationFormatVersion, languages, nodes }: LionWebJsonChunk): LionWebJsonChunk => ({
+    serializationFormatVersion,
+    languages: languages.map(orderedSerializedLanguageReference),
+    nodes: nodes.map(orderedSerializedNode)
+})
+
+export {
+    orderedMetaPointer,
+    orderedSerializationChunk,
+    orderedSerializedLanguageReference,
+    orderedSerializedProperty,
+    orderedSerializedReferenceTarget
+}

package/src/serialization/sorting.ts

@@ -0,0 +1,33 @@
+import { LionWebJsonChunk } from "@lionweb/json"
+import { sortByStringKey } from "@lionweb/ts-utils"
+import { orderedMetaPointer, orderedSerializedLanguageReference, orderedSerializedProperty, orderedSerializedReferenceTarget } from "./ordering.js"
+
+
+/**
+ * @return A sorted version of a {@link SerializedModel JSON serialization}, which should make it easier to inspect.
+ *  Note that the sorted version destroy the order of links, which might effectively alter semantics.
+ */
+export const sortedSerializationChunk = ({serializationFormatVersion, languages, nodes}: LionWebJsonChunk): LionWebJsonChunk =>
+    ({
+        serializationFormatVersion,
+        languages: sortByStringKey(languages, ({key}) => key).map(orderedSerializedLanguageReference),
+        nodes: sortByStringKey(nodes, ({id}) => id)
+            .map((node) => ({
+                id: node.id,
+                classifier: orderedMetaPointer(node.classifier),
+                properties: sortByStringKey(node.properties, ({property}) => property.key).map(orderedSerializedProperty),
+                containments: sortByStringKey(node.containments, ({containment}) => containment.key)
+                        .map(({containment, children}) => ({
+                            containment: orderedMetaPointer(containment),
+                            children: children.sort()
+                        })),
+                references: sortByStringKey(node.references, ({reference}) => reference.key)
+                        .map(({reference, targets}) => ({
+                            reference: orderedMetaPointer(reference),
+                            targets: sortByStringKey(targets, ({reference}) => reference).map(orderedSerializedReferenceTarget)
+                        })),
+                annotations: node.annotations.sort(),
+                parent: node.parent
+            }))
+    })
+

package/src/serialization/textualizer.ts

@@ -0,0 +1,93 @@
+import { Enumeration, Language, MemoisingSymbolTable, Property } from "@lionweb/core"
+import {
+    LionWebId,
+    LionWebJsonChunk,
+    LionWebJsonContainment,
+    LionWebJsonMetaPointer,
+    LionWebJsonNode,
+    LionWebJsonProperty,
+    LionWebJsonReference,
+    LionWebJsonReferenceTarget
+} from "@lionweb/json"
+import { byIdMap } from "@lionweb/ts-utils"
+import { asString, indentWith, Template } from "littoral-templates"
+
+const indent = indentWith("    ")(1)
+
+const prependWith = (template: Template, prefix: string): Template => prefix + asString(template)
+
+export const genericAsTreeText = ({ nodes }: LionWebJsonChunk, languages: Language[] = []) => {
+    const nodesById: { [id: LionWebId]: LionWebJsonNode } = byIdMap(nodes)
+    const symbolTable = new MemoisingSymbolTable(languages)
+
+    const nameOrKey = (classifier: LionWebJsonMetaPointer, feature: LionWebJsonMetaPointer): string =>
+        symbolTable.featureMatching(classifier, feature)?.name ?? `[${feature.key}]`
+
+    const propertyAsText = (classifier: LionWebJsonMetaPointer, { property: propertyMetaPointer, value }: LionWebJsonProperty) => {
+        const property = symbolTable.featureMatching(classifier, propertyMetaPointer)
+        const identification = nameOrKey(classifier, propertyMetaPointer)
+        const displayValue =
+            property instanceof Property
+                ? property.type instanceof Enumeration
+                    ? (property.type.literals.find(literal => literal.key === value)?.name ?? value)
+                    : (() => {
+                          switch (property?.type?.name) {
+                              case "String":
+                                  return `'${value}'`
+                              default:
+                                  return value
+                          }
+                      })()
+                : value
+        return `${identification} = ${displayValue}`
+    }
+
+    const referenceTargetAsText = ({ reference: referenceId, resolveInfo }: LionWebJsonReferenceTarget) =>
+        `${referenceId}${resolveInfo === undefined ? `` : ` (${resolveInfo})`}`
+
+    const referenceAsText = (classifier: LionWebJsonMetaPointer, { reference, targets }: LionWebJsonReference) =>
+        `${nameOrKey(classifier, reference)} -> ${targets.length === 0 ? `<none>` : targets.map(referenceTargetAsText).join(", ")}`
+
+    const containmentAsText = (classifier: LionWebJsonMetaPointer, { containment, children }: LionWebJsonContainment) => [
+        `${nameOrKey(classifier, containment)}:${children.length === 0 ? ` <none>` : ``}`,
+        indent(
+            children.map(childId =>
+                childId in nodesById ? asText(nodesById[childId]) : `<child with id=${childId} not present in this chunk>`
+            )
+        )
+    ]
+
+    const annotationAsText = (annotationId: LionWebId) =>
+        annotationId in nodesById
+            ? prependWith(asText(nodesById[annotationId]), "@ ")
+            : `<annotation with id=${annotationId} not present in this chunk>`
+
+    const curry1 =
+        <T1, T2, R>(func: (t1: T1, t2: T2) => R, t1: T1): ((t2: T2) => R) =>
+        (t2: T2) =>
+            func(t1, t2)
+
+    const asText = ({
+        id,
+        classifier: classifierMetaPointer,
+        properties,
+        containments,
+        references,
+        annotations
+    }: LionWebJsonNode): Template => [
+        `${symbolTable.entityMatching(classifierMetaPointer)?.name ?? `[${classifierMetaPointer.key}]`} (id: ${id}) {`,
+        indent([
+            properties.map(curry1(propertyAsText, classifierMetaPointer)),
+            references.map(curry1(referenceAsText, classifierMetaPointer)),
+            containments.map(curry1(containmentAsText, classifierMetaPointer)),
+            annotations.map(annotationAsText)
+        ]),
+        `}`
+    ]
+
+    return asString(
+        nodes
+            .filter(node => node.parent === null) // root nodes
+            .map(asText)
+    )
+}

package/src/utils/json.ts

@@ -0,0 +1,8 @@
+import { asPrettyJsonString } from "@lionweb/ts-utils"
+import { readFileSync, writeFileSync } from "fs"
+
+
+export const writeJsonAsFile = (path: string, json: unknown) => writeFileSync(path, asPrettyJsonString(json))
+
+export const readFileAsJson = (path: string): unknown => JSON.parse(readFileSync(path).toString())
+