@typemf/xmi 0.9.0 → 0.9.1

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   computeEmfFragment: () => computeEmfFragment,
   escapeAttributeValue: () => escapeAttributeValue,
   escapeText: () => escapeText,
+  nameSegmentAmong: () => nameSegmentAmong,
   parseXmlDocument: () => parseXmlDocument,
   registerXmiFormat: () => registerXmiFormat,
   resolveEmfFragment: () => resolveEmfFragment
@@ -45,6 +46,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/emf-fragment.ts
+var import_core = require("@typemf/core");
 function allStructuralFeaturesOf(eClass) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -73,6 +75,13 @@ function computeEmfFragment(target, roots) {
     if (!feature) {
       throw new Error("Object has a container but no containing feature - inconsistent containment state.");
     }
+    const named = nameSegment(current, container);
+    if (named !== void 0) {
+      segments.unshift(named);
+      current = container;
+      container = current.eContainer();
+      continue;
+    }
     let segment = `@${feature.getName()}`;
     if (feature.isMany()) {
       const siblings = [...container.eGet(feature)];
@@ -96,17 +105,27 @@ function computeEmfFragment(target, roots) {
   }
   return path === "" ? `/${rootIndex}` : `/${rootIndex}/${path}`;
 }
+function nameSegment(target, container) {
+  if (!(0, import_core.isENamedElement)(target) || !(0, import_core.isEModelElement)(container)) return void 0;
+  return nameSegmentAmong(target, container.eContents());
+}
+function nameSegmentAmong(target, siblings) {
+  const name = nameOf(target);
+  if (typeof name !== "string" || name === "" || /^[@%]|[\s/#]/.test(name)) return void 0;
+  let count = 0;
+  for (const sibling of siblings) {
+    if (sibling === target) return count > 0 ? `${name}.${count}` : name;
+    if (nameOf(sibling) === name) count++;
+  }
+  return void 0;
+}
 function resolveEmfFragment(fragment, roots) {
   if (fragment === "/") {
     return roots.length === 1 ? roots[0] : void 0;
   }
   if (fragment.startsWith("//")) {
-    const rest = fragment.slice(2);
     if (roots.length !== 1) return void 0;
-    if (rest.startsWith("@")) {
-      return walkSegments(rest, roots[0]);
-    }
-    return walkNamedSegments(rest, roots[0]);
+    return walkSegments(fragment.slice(2), roots[0]);
   }
   if (fragment.startsWith("/")) {
     const rest = fragment.slice(1);
@@ -120,54 +139,40 @@ function resolveEmfFragment(fragment, roots) {
   }
   return findByIdValue(fragment, roots);
 }
-function walkNamedSegments(path, start) {
-  const segments = path.split("/");
+function walkSegments(path, start) {
   let current = start;
-  for (const name of segments) {
+  for (const segment of path.split("/")) {
     if (!current) return void 0;
-    const currentClass = current.eClass();
-    const eClassifiersFeature = allStructuralFeaturesOf(currentClass).filter((feature) => feature.getName() === "eClassifiers").at(0);
-    if (eClassifiersFeature) {
-      current = findNamedChild(current, eClassifiersFeature, name);
-      continue;
-    }
-    const eStructuralFeaturesFeature = allStructuralFeaturesOf(currentClass).filter((feature) => feature.getName() === "eStructuralFeatures").at(0);
-    if (eStructuralFeaturesFeature) {
-      current = findNamedChild(current, eStructuralFeaturesFeature, name);
-      continue;
-    }
-    return void 0;
+    current = segment.startsWith("@") ? containmentStep(current, segment) : namedChild(current, segment);
   }
   return current;
 }
-function findNamedChild(container, listFeature, name) {
-  const children = [...container.eGet(listFeature)];
-  return children.find((child) => {
-    const nameFeature = allStructuralFeaturesOf(child.eClass()).filter((feature) => feature.getName() === "name").at(0);
-    return nameFeature !== void 0 && child.eGet(nameFeature) === name;
-  });
-}
-function walkSegments(path, start) {
-  let current = start;
-  for (const segment of path.split("/")) {
-    if (!segment.startsWith("@")) return void 0;
-    const dotIndex = segment.indexOf(".");
-    const featureName = dotIndex === -1 ? segment.slice(1) : segment.slice(1, dotIndex);
-    const feature = allStructuralFeaturesOf(current.eClass()).filter((feature2) => feature2.getName() === featureName).at(0);
-    if (!feature) return void 0;
-    if (feature.isMany()) {
-      const indexToken = dotIndex === -1 ? void 0 : segment.slice(dotIndex + 1);
-      const index = Number(indexToken);
-      if (indexToken === void 0 || !Number.isInteger(index)) return void 0;
-      const list = [...current.eGet(feature)];
-      const next = list[index];
-      if (!next) return void 0;
-      current = next;
-    } else {
-      current = current.eGet(feature);
-    }
+function containmentStep(current, segment) {
+  const dotIndex = segment.indexOf(".");
+  const featureName = dotIndex === -1 ? segment.slice(1) : segment.slice(1, dotIndex);
+  const feature = allStructuralFeaturesOf(current.eClass()).find((f) => f.getName() === featureName);
+  if (!feature) return void 0;
+  if (!feature.isMany()) return current.eGet(feature);
+  const index = Number(dotIndex === -1 ? void 0 : segment.slice(dotIndex + 1));
+  if (!Number.isInteger(index)) return void 0;
+  return [...current.eGet(feature)][index];
+}
+function namedChild(container, segment) {
+  const counted = /^(.*)\.(\d+)$/.exec(segment);
+  return counted && nthNamedChild(container, counted[1], Number(counted[2])) || nthNamedChild(container, segment, 0);
+}
+function nthNamedChild(container, name, n) {
+  let remaining = n;
+  for (const child of container.eContents()) {
+    if (nameOf(child) !== name) continue;
+    if (remaining === 0) return child;
+    remaining--;
   }
-  return current;
+  return void 0;
+}
+function nameOf(obj) {
+  const nameFeature = allStructuralFeaturesOf(obj.eClass()).find((f) => f.getName() === "name");
+  return nameFeature ? obj.eGet(nameFeature) : void 0;
 }
 function findByIdValue(idValue, roots) {
   for (const root of roots) {
@@ -216,10 +221,10 @@ var NamespaceCollector = class {
 };
 
 // src/xmi-resource-factory.ts
-var import_core2 = require("@typemf/core");
+var import_core3 = require("@typemf/core");
 
 // src/xmi-serializer.ts
-var import_core = require("@typemf/core");
+var import_core2 = require("@typemf/core");
 
 // src/xml-text.ts
 function escapeAttributeValue(value) {
@@ -382,11 +387,7 @@ function writeObjectParts(obj, tagName, roots, sourceResource, namespaces) {
         childrenXml += renderElement({ tagName: feature.getName(), attributes: attrs, childrenXml: "" });
       }
     } else {
-      const anyPolymorphic = encoded.some((e) => e.xsiType);
-      const tokens = encoded.map(
-        (e) => anyPolymorphic ? `${e.xsiType ?? sameTypeToken(refFeature, namespaces)} ${e.value}` : e.value
-      );
-      attributes.push([feature.getName(), tokens.join(" ")]);
+      attributes.push([feature.getName(), encoded.map((e) => `#${e.value}`).join(" ")]);
     }
   }
   return { tagName, attributes, childrenXml };
@@ -402,17 +403,12 @@ function childElementTag(child, feature, namespaces) {
   const prefix = namespaces.prefixFor(requirePackage(actual));
   return { xsiType: `${prefix}:${actual.getName()}` };
 }
-function sameTypeToken(feature, namespaces) {
-  const declared = feature.getEType();
-  const prefix = namespaces.prefixFor(requirePackage(declared));
-  return `${prefix}:${declared.getName()}`;
-}
 function encodeReferenceValue(target, feature, roots, sourceResource, namespaces) {
   const declared = feature.getEType();
   if (target.eIsProxy()) {
     const actual2 = target.eClass();
     const xsiType2 = declared !== actual2 ? `${namespaces.prefixFor(requirePackage(actual2))}:${actual2.getName()}` : void 0;
-    const proxyURI = (0, import_core.getProxyURI)(target);
+    const proxyURI = (0, import_core2.getProxyURI)(target);
     if (!proxyURI) {
       throw new Error(`eIsProxy() is true but no proxy URI is on record for this ${actual2.getName()}.`);
     }
@@ -426,7 +422,7 @@ function encodeReferenceValue(target, feature, roots, sourceResource, namespaces
   }
   const ecoreOwnPath = ecoreOwnFragmentPath(target);
   if (ecoreOwnPath !== void 0) {
-    return { value: `${import_core.EcorePackageImpl.eINSTANCE.getNsURI()}#${ecoreOwnPath}`, crossDocument: true, xsiType };
+    return { value: `${import_core2.EcorePackageImpl.eINSTANCE.getNsURI()}#${ecoreOwnPath}`, crossDocument: true, xsiType };
   }
   if (targetResource) {
     const targetDocumentURI = targetResource.getURI().deresolve(sourceResource.getURI());
@@ -449,27 +445,25 @@ function isReachableFromRoots(target, roots) {
   return false;
 }
 function ecoreOwnFragmentPath(target) {
-  const ecore = import_core.EcorePackageImpl.eINSTANCE;
-  if ((0, import_core.isEClassifier)(target)) {
+  const ecore = import_core2.EcorePackageImpl.eINSTANCE;
+  if ((0, import_core2.isEClassifier)(target)) {
     return target.getEPackage() === ecore ? `//${target.getName() ?? ""}` : void 0;
   }
   const containingClass = hasContainingClass(target) ? target.getEContainingClass() : void 0;
-  if (containingClass && containingClass.getEPackage() === ecore && isNamed(target)) {
-    return `//${containingClass.getName() ?? ""}/${target.getName() ?? ""}`;
+  if (containingClass && containingClass.getEPackage() === ecore) {
+    const segment = nameSegmentAmong(target, containingClass.eContents());
+    return segment === void 0 ? void 0 : `//${containingClass.getName() ?? ""}/${segment}`;
   }
   return void 0;
 }
 function hasContainingClass(obj) {
   return typeof obj.getEContainingClass === "function";
 }
-function isNamed(obj) {
-  return typeof obj.getName === "function";
-}
 function fragmentForTarget(target, owningResource, fallbackRoots) {
   if (!owningResource) return computeEmfFragment(target, fallbackRoots);
   const roots = owningResource.getContents().toArray();
   const serializer = owningResource.getSerializer();
-  return serializer.computeFragment ? serializer.computeFragment(target, roots) : (0, import_core.computeFragment)(target, roots);
+  return serializer.computeFragment ? serializer.computeFragment(target, roots) : (0, import_core2.computeFragment)(target, roots);
 }
 function isReferenceFeature(feature) {
   return "isContainment" in feature;
@@ -481,7 +475,7 @@ function requirePackage(eClass) {
 }
 function encodeAttributeValue(value, feature) {
   const eType = feature.getEType();
-  const text = eType && (0, import_core.isEDataType)(eType) ? (0, import_core.convertToString)(eType, value) : void 0;
+  const text = eType && (0, import_core2.isEDataType)(eType) ? (0, import_core2.convertToString)(eType, value) : void 0;
   return text ?? String(value);
 }
 function resolveElementEClass(element, packageRegistry) {
@@ -631,7 +625,7 @@ function completeObject(element, obj, ctx, elementToObj, roots) {
     const xsiType = child.getAttributeNS(XSI_NS, "type");
     const declared = refFeature.getEType();
     const proxyEClass = xsiType ? resolvePrefixedName(xsiType, child, ctx.packageRegistry) : declared;
-    const proxy = (0, import_core.createProxy)(proxyEClass, import_core.URI.parse(href).resolve(ctx.resourceURI));
+    const proxy = (0, import_core2.createProxy)(proxyEClass, import_core2.URI.parse(href).resolve(ctx.resourceURI));
     if (feature.isMany()) {
       const list = obj.eGet(feature);
       list.add(proxy);
@@ -650,7 +644,7 @@ function decodeAttributeFormReference(rawValue, feature, contextElement, roots,
     if (isAbsoluteUri(fragment) || isRelativeCrossDocument) {
       const declared = feature.getEType();
       const proxyEClass = typeToken ? resolvePrefixedName(typeToken, contextElement, ctx.packageRegistry) : declared;
-      return [(0, import_core.createProxy)(proxyEClass, import_core.URI.parse(fragment).resolve(ctx.resourceURI))];
+      return [(0, import_core2.createProxy)(proxyEClass, import_core2.URI.parse(fragment).resolve(ctx.resourceURI))];
     }
     const normalized = fragment.startsWith("#") ? fragment.slice(1) : fragment;
     const resolved = resolveEmfFragment(normalized, roots);
@@ -671,9 +665,9 @@ function isAbsoluteUri(token) {
 }
 function decodeAttributeValue(text, feature, element, ctx) {
   const eType = feature.getEType();
-  if (!eType || !(0, import_core.isEDataType)(eType)) return { value: text };
+  if (!eType || !(0, import_core2.isEDataType)(eType)) return { value: text };
   try {
-    return { value: (0, import_core.createFromString)(eType, text) };
+    return { value: (0, import_core2.createFromString)(eType, text) };
   } catch (err) {
     ctx.resource.getErrors().push({
       message: `Invalid value for '${feature.getName()}' on <${element.tagName}>: ${err.message}`
@@ -685,7 +679,7 @@ function decodeAttributeValue(text, feature, element, ctx) {
 // src/xmi-resource-factory.ts
 var XmiResourceFactory = class {
   createResource(uri) {
-    return new import_core2.ResourceImpl(uri, new XmiSerializer());
+    return new import_core3.ResourceImpl(uri, new XmiSerializer());
   }
 };
 function registerXmiFormat(registry) {
@@ -702,6 +696,7 @@ function registerXmiFormat(registry) {
   computeEmfFragment,
   escapeAttributeValue,
   escapeText,
+  nameSegmentAmong,
   parseXmlDocument,
   registerXmiFormat,
   resolveEmfFragment