@emfts/codegen 0.0.1-next.8 → 0.0.2-next.2

package/dist/templates/partials/decorator/class-file.ejs

@@ -2,17 +2,87 @@
 
 <%# Generate imports for referenced types -%>
 <%
+// GenModel documentation of a model element (class, feature, ...)
+function getDocumentation(element) {
+  const ann = element?.getEAnnotation?.('http://www.eclipse.org/emf/2002/GenModel');
+  const doc = ann?.getDetails?.()?.getByKey?.('documentation');
+  return typeof doc === 'string' && doc.length > 0 ? doc : null;
+}
+// Custom decorator annotations (#31): an eAnnotation source of the form
+// '<importable-specifier>/<DecoratorName>' (not an EMF source URI) becomes an
+// import plus a decorator application with the details as options object
+function getCustomDecorators(element) {
+  const decorators = [];
+  for (const ann of element?.getEAnnotations?.() ?? []) {
+    const source = ann.getSource?.();
+    if (!source || source.startsWith('http://') || source.startsWith('https://')) continue;
+    const slashIdx = source.lastIndexOf('/');
+    if (slashIdx <= 0) continue;
+    const name = source.substring(slashIdx + 1);
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) continue;
+    const options = [];
+    for (const entry of ann.getDetails?.() ?? []) {
+      const key = entry.eGet?.(entry.eClass().getEStructuralFeature('key'));
+      const value = entry.eGet?.(entry.eClass().getEStructuralFeature('value'));
+      if (key == null) continue;
+      const keyOut = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+      options.push(`${keyOut}: ${JSON.stringify(value ?? '')}`);
+    }
+    decorators.push({ name, specifier: source.substring(0, slashIdx), options: `{${options.join(', ')}}` });
+  }
+  return decorators;
+}
+// Determine which of the annotation decorators the class actually uses (#32)
+const classDoc = getDocumentation(eClass);
+let usesDocumentation = !!classDoc;
+let usesAttribute = false, usesReference = false, usesEnum = false;
+for (const genFeature of features) {
+  const f = genFeature.ecoreFeature;
+  if (getDocumentation(f)) usesDocumentation = true;
+  if (f.getEType() && typeMapper.isEEnum(f.getEType())) usesEnum = true;
+  else if (typeMapper.isReference(f)) usesReference = true;
+  else usesAttribute = true;
+}
+for (const genOp of operations) {
+  if (getDocumentation(genOp.ecoreOperation)) usesDocumentation = true;
+}
+const annotationNames = [
+  ...(usesDocumentation ? ['Documentation'] : []),
+  ...(usesAttribute ? ['Attribute'] : []),
+  'ModelClass',
+  ...(usesReference ? ['Reference'] : []),
+  ...(usesEnum ? ['Enum'] : [])
+];
+
+// Merge all imports per module specifier: resolved type imports, the used
+// annotation decorators, and custom decorator imports (#31, #32)
+const mergedImports = new Map();
+function addImport(specifier, name) {
+  if (!mergedImports.has(specifier)) mergedImports.set(specifier, new Set());
+  mergedImports.get(specifier).add(name);
+}
 const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'decorator');
 for (const imp of imports) {
   if (imp.typeName !== className && !imp.typeName.includes(',')) {
+    addImport(imp.importPath, imp.typeName);
+  }
+}
+for (const name of annotationNames) addImport(annotationsImport, name);
+for (const genOp of operations) {
+  for (const dec of getCustomDecorators(genOp.ecoreOperation)) {
+    addImport(dec.specifier, dec.name);
+  }
+}
+for (const [specifier, names] of mergedImports) {
 -%>
-import { <%- imp.typeName %> } from '<%- imp.importPath %>';
+import { <%- [...names].join(', ') %> } from '<%- specifier %>';
 <%
-  }
 }
 -%>
-import { Documentation, Attribute, ModelClass, Reference, Enum } from './ModelAnnotations';
 
+<% if (classDoc) { -%>
+@Documentation(<%- JSON.stringify(classDoc) %>)
+<% } -%>
 @ModelClass({ type: '<%- nsURI %>#//<%- className %>' })
 export <% if (isAbstract) { %>abstract <% } %>class <%- className %><%
 if (typeParameters && typeParameters.length > 0) {
@@ -25,8 +95,11 @@ if (typeParameters && typeParameters.length > 0) {
 if (superTypes && superTypes.length > 0) {
   const superNames = [];
   for (const st of superTypes) {
-    if (st.getName) {
-      superNames.push(st.getName());
+    // getName helper also resolves the name of an unresolved proxy from its
+    // URI fragment - a cross-package supertype must not lose its extends (#30)
+    const stName = getName(st);
+    if (stName) {
+      superNames.push(stName);
     }
   }
   if (superNames.length > 0) {
@@ -38,37 +111,31 @@ if (superTypes && superTypes.length > 0) {
   const feature = genFeature.ecoreFeature;
   const featureName = feature.getName();
   const featureType = typeMapper.mapFeatureBaseType(feature);
+  // Decorator argument is a runtime type NAME for metadata lookups -
+  // generic type arguments must not leak into it (#29). Derived from the
+  // mapped type, because an unresolved cross-package eType proxy has no getName
+  const decoratorTypeName = featureType.split('<')[0];
   const fullType = typeMapper.mapFeature(feature);
   const defaultValue = typeMapper.getDefaultValue(feature);
   const isMany = feature.isMany();
   const isRef = typeMapper.isReference(feature);
   const isEnum = feature.getEType() && typeMapper.isEEnum(feature.getEType());
 
-  // Check for documentation annotation
-  let doc = null;
-  if (feature.getEAnnotations) {
-    for (const ann of feature.getEAnnotations()) {
-      const annSource = typeof ann.getSource === 'function' ? ann.getSource() : ann.source;
-      if (annSource === 'http://www.eclipse.org/emf/2002/GenModel') {
-        const details = typeof ann.getDetails === 'function' ? ann.getDetails() : ann.details;
-        if (details && details.get) {
-          doc = details.get('documentation');
-        }
-      }
-    }
-  }
+  // GenModel documentation as @Documentation decorator; JSON.stringify keeps
+  // multiline values and quotes a valid string literal
+  const doc = getDocumentation(feature);
   if (doc) {
 -%>
-  @Documentation("<%- doc %>")
+  @Documentation(<%- JSON.stringify(doc) %>)
 <%
   }
   if (isEnum) {
 -%>
-  @Enum('<%- featureType %>')
+  @Enum('<%- decoratorTypeName %>')
 <%
   } else if (isRef) {
 -%>
-  @Reference('<%- featureType %>')
+  @Reference('<%- decoratorTypeName %>')
 <%
   } else {
 -%>
@@ -83,14 +150,19 @@ if (superTypes && superTypes.length > 0) {
   const op = genOp.ecoreOperation;
   const opName = op.getName();
   const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
-  const params = [];
-  for (const param of op.getEParameters()) {
-    const paramName = param.getName();
-    const paramType = typeMapper.mapClassifier(param.getEType());
-    params.push(`${paramName}: ${paramType}`);
+  const opDoc = getDocumentation(op);
+  if (opDoc) {
+-%>
+  @Documentation(<%- JSON.stringify(opDoc) %>)
+<%
+  }
+  for (const dec of getCustomDecorators(op)) {
+-%>
+  @<%- dec.name %>(<%- dec.options %>)
+<%
   }
 -%>
-  <%- opName %>(<%- params.join(', ') %>): <%- returnType %> {
+  <%- opName %>(<%- mapParams(op) %>): <%- returnType %> {
     throw new Error('<%- opName %> not implemented');
   }
 

package/dist/templates/partials/decorator/enum-file.ejs

@@ -28,7 +28,7 @@ export enum <%- enumName %> {
   const literal = literals[i];
   const literalName = getLiteralProp(literal, 'literal') || getLiteralProp(literal, 'name');
   const literalValue = getLiteralProp(literal, 'value');
-  const value = useStringValues ? `'${literalName}'` : literalValue;
+  const value = useStringValues ? JSON.stringify(literalName) : literalValue;
 -%>
   <%- getLiteralProp(literal, 'name') %> = <%- value %><% if (i < literals.length - 1) { %>,<% } %>
 <% } -%>

package/dist/templates/partials/decorator/interface-file.ejs

@@ -49,13 +49,7 @@ if (superTypes && superTypes.length > 0) {
   const op = genOp.ecoreOperation;
   const opName = op.getName();
   const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
-  const params = [];
-  for (const param of op.getEParameters()) {
-    const paramName = param.getName();
-    const paramType = typeMapper.mapClassifier(param.getEType());
-    params.push(`${paramName}: ${paramType}`);
-  }
 -%>
-  <%- opName %>(<%- params.join(', ') %>): <%- returnType %>;
+  <%- opName %>(<%- mapParams(op) %>): <%- returnType %>;
 <% } -%>
 }

package/dist/templates/partials/decorator/model-annotations.ejs

@@ -2,12 +2,13 @@
 
 import 'reflect-metadata';
 
-// Metadata keys
-const MODEL_CLASS_KEY = Symbol('modelClass');
-const ATTRIBUTE_KEY = Symbol('attribute');
-const REFERENCE_KEY = Symbol('reference');
-const ENUM_KEY = Symbol('enum');
-const DOCUMENTATION_KEY = Symbol('documentation');
+// Metadata keys: Symbol.for() so every generated copy of this file shares
+// the same identities and cross-package metadata readers see all models (#26)
+const MODEL_CLASS_KEY = Symbol.for('emfts.modelClass');
+const ATTRIBUTE_KEY = Symbol.for('emfts.attribute');
+const REFERENCE_KEY = Symbol.for('emfts.reference');
+const ENUM_KEY = Symbol.for('emfts.enum');
+const DOCUMENTATION_KEY = Symbol.for('emfts.documentation');
 
 /**
  * Decorator for model classes

package/dist/templates/partials/decorator/package-file.ejs

@@ -2,6 +2,8 @@
 
 // Re-export all types from this package
 <% for (const exp of exports) { -%>
-export * from './<%- exp %>';
+export * from './<%- exp %>.js';
+<% } -%>
+<% if (!annotationsPackage) { -%>
+export * from './ModelAnnotations.js';
 <% } -%>
-export * from './ModelAnnotations';

package/dist/templates/partials/emf/class-file.ejs

@@ -4,9 +4,43 @@
 const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'emf');
 const hardcodedCoreTypes = ['BasicEObject', 'EClass', 'EStructuralFeature'];
 const coreTypeImports = ['EClass', 'EStructuralFeature'];
+const coreValueImports = [];
 const typeOnlyImports = [];
 const valueImports = [];
 const importedNames = new Set();
+// Check if any feature is many-valued (needs EList imports)
+const useEList = typeMapper.useEList;
+const hasManyFeature = features.some(gf => isMany(gf.ecoreFeature));
+const hasManyMixin = (mixinFeatures || []).some(mf => isMany(mf.feature));
+if (useEList && (hasManyFeature || hasManyMixin)) {
+  coreTypeImports.push('EList', 'EReference');
+  // Determine which factory functions are needed
+  const needsContainment = features.some(gf => isMany(gf.ecoreFeature) && isContainment(gf.ecoreFeature))
+    || (mixinFeatures || []).some(mf => isMany(mf.feature) && isContainment(mf.feature));
+  const needsEObjectList = features.some(gf => isMany(gf.ecoreFeature) && !isContainment(gf.ecoreFeature) && typeMapper.isReference(gf.ecoreFeature))
+    || (mixinFeatures || []).some(mf => isMany(mf.feature) && !isContainment(mf.feature) && typeMapper.isReference(mf.feature));
+  const needsBasicList = features.some(gf => isMany(gf.ecoreFeature) && typeMapper.isAttribute(gf.ecoreFeature))
+    || (mixinFeatures || []).some(mf => isMany(mf.feature) && typeMapper.isAttribute(mf.feature));
+  if (needsContainment) coreValueImports.push('createContainmentEList');
+  if (needsEObjectList) coreValueImports.push('createEObjectEList');
+  if (needsBasicList) coreValueImports.push('createBasicEList');
+}
+// A type that appears in a value position of a field initializer needs a
+// value import - `import type` is erased and `new T()` would throw at
+// runtime (#35). Value positions: enum member access and instantiation
+const allFeatures = [
+  ...features.map(gf => gf.ecoreFeature),
+  ...(mixinFeatures || []).map(mf => mf.feature)
+];
+function isUsedAsValue(typeName) {
+  return allFeatures.some(f => {
+    const dv = typeMapper.getDefaultValue(f);
+    if (dv === null || typeof dv !== 'string') return false;
+    return dv.startsWith(typeName + '.')
+      || dv.startsWith('new ' + typeName + '(')
+      || dv.startsWith('new ' + typeName + '<');
+  });
+}
 for (const imp of imports) {
   if (imp.typeName === className || imp.typeName === interfaceName || imp.typeName === extendsClass) continue;
   if (hardcodedCoreTypes.includes(imp.typeName)) continue;
@@ -16,12 +50,7 @@ for (const imp of imports) {
     }
     continue;
   }
-  // Check if this type is used as a runtime value (e.g., enum default values)
-  const usedAsValue = features.some(gf => {
-    const dv = typeMapper.getDefaultValue(gf.ecoreFeature);
-    return dv !== null && typeof dv === 'string' && dv.startsWith(imp.typeName + '.');
-  });
-  if (usedAsValue) {
+  if (isUsedAsValue(imp.typeName)) {
     valueImports.push(imp);
   } else {
     typeOnlyImports.push(imp);
@@ -39,13 +68,20 @@ for (const imp of (mixinImports || [])) {
     }
     continue;
   }
-  typeOnlyImports.push(imp);
+  if (isUsedAsValue(imp.typeName)) {
+    valueImports.push(imp);
+  } else {
+    typeOnlyImports.push(imp);
+  }
   importedNames.add(imp.typeName);
 }
 -%>
 <% if (!extendsImport) { -%>
 import { BasicEObject } from '@emfts/core';
 <% } -%>
+<% if (coreValueImports.length > 0) { -%>
+import { <%- coreValueImports.join(', ') %> } from '@emfts/core';
+<% } -%>
 import type { <%- coreTypeImports.join(', ') %> } from '@emfts/core';
 <% for (const imp of typeOnlyImports) { -%>
 import type { <%- imp.typeName %> } from '<%- imp.importPath %>';
@@ -56,8 +92,8 @@ import { <%- imp.typeName %> } from '<%- imp.importPath %>';
 <% if (extendsImport) { -%>
 import { <%- extendsClass %> } from '<%- extendsImport %>';
 <% } -%>
-import type { <%- interfaceName %> } from './<%- interfaceName %>';
-import { <%- packagePrefix %>Package } from './<%- packagePrefix %>Package';
+import type { <%- interfaceName %> } from './<%- interfaceName %>.js';
+import { <%- packagePrefix %>Package } from './<%- packagePrefix %>Package.js';
 
 /**
  * Implementation of <%- interfaceName %>
@@ -80,14 +116,14 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
   const defaultValue = typeMapper.getDefaultValue(feature);
   const featureIsMany = isMany(feature);
 -%>
-  private _<%- featureName %><% if (!featureIsMany && defaultValue === null) { %>?<% } %>: <%- featureType %><% if (defaultValue !== null) { %> = <%- defaultValue %><% } %>;
+  private _<%- featureName %><% if (useEList && featureIsMany) { %>!<% } else if (!featureIsMany && defaultValue === null) { %>?<% } %>: <%- featureType %><% if (defaultValue !== null) { %> = <%- defaultValue %><% } %>;
 <% } -%>
 <% for (const mf of (mixinFeatures || [])) {
   const featureType = typeMapper.mapFeature(mf.feature);
   const defaultValue = typeMapper.getDefaultValue(mf.feature);
   const featureIsMany = isMany(mf.feature);
 -%>
-  private _<%- mf.name %><% if (!featureIsMany && defaultValue === null) { %>?<% } %>: <%- featureType %><% if (defaultValue !== null) { %> = <%- defaultValue %><% } %>;
+  private _<%- mf.name %><% if (useEList && featureIsMany) { %>!<% } else if (!featureIsMany && defaultValue === null) { %>?<% } %>: <%- featureType %><% if (defaultValue !== null) { %> = <%- defaultValue %><% } %>;
 <% } -%>
 
   /**
@@ -104,7 +140,28 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
   const featureType = typeMapper.mapFeature(feature);
   const featureIsMany = isMany(feature);
   const upperName = toUpperSnake(featureName);
+-%>
+<% if (useEList && featureIsMany) {
+  // EList lazy-init getter: creates the right EList on first access
+  const isRef = typeMapper.isReference(feature);
+  const isCont = isRef && isContainment(feature);
+  let factoryCall;
+  if (isCont) {
+    factoryCall = `createContainmentEList<any>(this, this.eClass().getEStructuralFeature('${featureName}') as EReference)`;
+  } else if (isRef) {
+    factoryCall = `createEObjectEList(this, this.eClass().getEStructuralFeature('${featureName}') as EReference) as unknown as ${featureType}`;
+  } else {
+    factoryCall = `createBasicEList<any>(this, this.eClass().getEStructuralFeature('${featureName}')!)`;
+  }
 -%>
+  get <%- featureName %>(): <%- featureType %> {
+    if (!this._<%- featureName %>) {
+      this._<%- featureName %> = <%- factoryCall %>;
+    }
+    return this._<%- featureName %>;
+  }
+
+<% } else { -%>
   get <%- featureName %>(): <%- featureType %> {
     return this._<%- featureName %><% if (!featureIsMany) { %>!<% } %>;
   }
@@ -134,6 +191,7 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
 <% } -%>
   }
 
+<% } -%>
 <% } -%>
 <% } -%>
 <% for (const mf of (mixinFeatures || [])) {
@@ -177,18 +235,32 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
     const featureID = this.eClass().getFeatureID(feature);
     switch (featureID) {
 <% for (const fid of featureIds) {
-  const featureType = typeMapper.mapFeature(fid.feature.ecoreFeature);
+  const feat = fid.feature.ecoreFeature;
+  const featureType = typeMapper.mapFeature(feat);
+  const featureName = getName(feat);
+  const featureIsMany = isMany(feat);
 -%>
       case <%- className %>.<%- fid.name %>:
-        this.<%- getName(fid.feature.ecoreFeature) %> = newValue as <%- featureType %>;
+<% if (useEList && featureIsMany) { -%>
+        this.<%- featureName %>.clear();
+        this.<%- featureName %>.addAll(newValue as any[]);
+<% } else { -%>
+        this.<%- featureName %> = newValue as <%- featureType %>;
+<% } -%>
         super.eSet(feature, newValue);
         break;
 <% } -%>
 <% for (const mf of (mixinFeatures || [])) {
   const featureType = typeMapper.mapFeature(mf.feature);
+  const featureIsMany = isMany(mf.feature);
 -%>
       case <%- className %>.<%- mf.upperName %>:
+<% if (useEList && featureIsMany) { -%>
+        this.<%- mf.name %>.clear();
+        this.<%- mf.name %>.addAll(newValue as any[]);
+<% } else { -%>
         this.<%- mf.name %> = newValue as <%- featureType %>;
+<% } -%>
         super.eSet(feature, newValue);
         break;
 <% } -%>
@@ -210,7 +282,9 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
   const featureName = getName(feature);
 -%>
       case <%- className %>.<%- fid.name %>:
-<% if (featureIsMany) { -%>
+<% if (useEList && featureIsMany) { -%>
+        return this._<%- featureName %> !== undefined && !this._<%- featureName %>.isEmpty();
+<% } else if (featureIsMany) { -%>
         return this._<%- featureName %> !== undefined && this._<%- featureName %>.length > 0;
 <% } else if (defaultValue !== null) { -%>
         return this._<%- featureName %> !== <%- defaultValue %>;
@@ -223,7 +297,9 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
   const defaultValue = typeMapper.getDefaultValue(mf.feature);
 -%>
       case <%- className %>.<%- mf.upperName %>:
-<% if (featureIsMany) { -%>
+<% if (useEList && featureIsMany) { -%>
+        return this._<%- mf.name %> !== undefined && !this._<%- mf.name %>.isEmpty();
+<% } else if (featureIsMany) { -%>
         return this._<%- mf.name %> !== undefined && this._<%- mf.name %>.length > 0;
 <% } else if (defaultValue !== null) { -%>
         return this._<%- mf.name %> !== <%- defaultValue %>;
@@ -249,7 +325,9 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
   const featureName = getName(feature);
 -%>
       case <%- className %>.<%- fid.name %>:
-<% if (featureIsMany) { -%>
+<% if (useEList && featureIsMany) { -%>
+        if (this._<%- featureName %>) this._<%- featureName %>.clear();
+<% } else if (featureIsMany) { -%>
         this._<%- featureName %> = [];
 <% } else if (defaultValue !== null) { -%>
         this._<%- featureName %> = <%- defaultValue %>;
@@ -263,7 +341,9 @@ export <% if (isAbstract) { %>abstract <% } %>class <%- className %> extends <%-
   const defaultValue = typeMapper.getDefaultValue(mf.feature);
 -%>
       case <%- className %>.<%- mf.upperName %>:
-<% if (featureIsMany) { -%>
+<% if (useEList && featureIsMany) { -%>
+        if (this._<%- mf.name %>) this._<%- mf.name %>.clear();
+<% } else if (featureIsMany) { -%>
         this._<%- mf.name %> = [];
 <% } else if (defaultValue !== null) { -%>
         this._<%- mf.name %> = <%- defaultValue %>;

package/dist/templates/partials/emf/factory-file.ejs

@@ -2,13 +2,13 @@
 
 import { BasicEFactory } from '@emfts/core';
 import type { EClass, EObject } from '@emfts/core';
-import { <%- packageName %>Package } from './<%- packageName %>Package';
+import { <%- packageName %>Package } from './<%- packageName %>Package.js';
 <% for (const genClass of concreteClasses) {
   const className = genClass.ecoreClass.getName();
   const implName = genClass.implClassName || (className + 'Impl');
 -%>
-import type { <%- className %> } from './<%- className %>';
-import { <%- implName %> } from './<%- implName %>';
+import type { <%- className %> } from './<%- className %>.js';
+import { <%- implName %> } from './<%- implName %>.js';
 <% } -%>
 
 /**

package/dist/templates/partials/emf/index-file.ejs

@@ -1,29 +1,35 @@
 <%- header %>
 
-// Package and Factory
-export { <%- packageName %>Package } from './<%- packageName %>Package';
-export { <%- packageName %>Factory } from './<%- packageName %>Factory';
+// Package<% if (generateFactory) { %> and Factory<% } %>
+export { <%- packageName %>Package } from './<%- packageName %>Package.js';
+<% if (generateFactory) { -%>
+export { <%- packageName %>Factory } from './<%- packageName %>Factory.js';
+<% } -%>
 
+<% if (generateInterfaces) { -%>
 // Interfaces
 <% for (const genClass of genClasses) {
   const name = getName(genClass.ecoreClass);
 -%>
-export type { <%- name %> } from './<%- name %>';
+export type { <%- name %> } from './<%- name %>.js';
+<% } -%>
 <% } -%>
 
+<% if (generateClasses) { -%>
 // Implementations (including abstract classes, as they're extended by subclasses)
 <% for (const genClass of genClasses) {
   if (!checkIsInterface(genClass.ecoreClass)) {
     const implName = genClass.implClassName || (getName(genClass.ecoreClass) + 'Impl');
 -%>
-export { <%- implName %> } from './<%- implName %>';
+export { <%- implName %> } from './<%- implName %>.js';
 <%
   }
 } -%>
+<% } -%>
 
 // Enums
 <% for (const genEnum of genEnums) {
   const name = getName(genEnum.ecoreEnum);
 -%>
-export { <%- name %>, get<%- name %>, get<%- name %>ByLiteral } from './<%- name %>';
+export { <%- name %>, get<%- name %>, get<%- name %>ByLiteral } from './<%- name %>.js';
 <% } -%>

package/dist/templates/partials/emf/interface-file.ejs

@@ -4,6 +4,11 @@
 const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'emf');
 const coreTypeImports = ['EObject'];
 const otherTypeImports = [];
+// Add EList import if any feature is many-valued and useEList is on
+const useEList = typeMapper.useEList;
+if (useEList && features.some(gf => isMany(gf.ecoreFeature))) {
+  coreTypeImports.push('EList');
+}
 for (const imp of imports) {
   if (imp.typeName === interfaceName) continue;
   if (imp.importPath === '@emfts/core') {

package/dist/templates/partials/emf/package-file.ejs

@@ -62,7 +62,7 @@ function typeRefExpr(classifier, castTo) {
   // External dependency package — resolve via EPackageRegistry
   const depNsURI = getClassifierNsURI(classifier);
   if (depNsURI) {
-    return "EPackageRegistry.INSTANCE.getEPackage('" + depNsURI + "')!.getEClassifier('" + typeName + "')!" + cast;
+    return "requireEPackage('" + depNsURI + "').getEClassifier('" + typeName + "')!" + cast;
   }
   return "getEcorePackage().getEClassifier('" + typeName + "')!" + cast;
 }
@@ -80,7 +80,7 @@ for (const genClass of genClasses) {
   }
   for (const genFeature of genClass.genFeatures) {
     const eType = getEType(genFeature.ecoreFeature);
-    if (eType && typeMapper.isReference(genFeature.ecoreFeature) && !isLocalClassifier(eType)) {
+    if (eType && !isLocalClassifier(eType)) {
       if (isEcoreClassifier(eType)) { needsEcoreImport = true; }
       else { needsRegistryImport = true; }
     }
@@ -88,12 +88,30 @@ for (const genClass of genClasses) {
 }
 -%>
 <%
-const coreImports = ['BasicEPackage', 'BasicEClass', 'BasicEAttribute', 'BasicEReference'];
+// EPackageRegistry is always needed: the package registers itself under its
+// nsURI so that other generated packages can resolve their references (#36)
+const coreImports = ['BasicEPackage', 'BasicEClass', 'BasicEAttribute', 'BasicEReference', 'EPackageRegistry'];
 if (needsEcoreImport) coreImports.push('getEcorePackage');
-if (needsRegistryImport) coreImports.push('EPackageRegistry');
 -%>
 import { <%- coreImports.join(', ') %> } from '@emfts/core';
 import type { EClass, EAttribute, EReference, EEnum } from '@emfts/core';
+<% if (generateFactory) { -%>
+import { <%- packageName %>Factory } from './<%- packageName %>Factory.js';
+<% } -%>
+<% if (needsRegistryImport) { -%>
+
+/**
+ * Resolve a dependency package from the registry, failing with an actionable
+ * message instead of a null dereference when it is not registered yet
+ */
+function requireEPackage(nsURI: string) {
+  const pkg = EPackageRegistry.INSTANCE.getEPackage(nsURI);
+  if (!pkg) {
+    throw new Error(`EPackage '${nsURI}' is not registered. Access the eINSTANCE of that model's generated package (or register it via EPackageRegistry.INSTANCE.registerPackage) before initializing <%- packageName %>Package.`);
+  }
+  return pkg;
+}
+<% } -%>
 
 /**
  * <%- packageName %> Package
@@ -138,6 +156,15 @@ export class <%- packageName %>Package extends BasicEPackage {
    * Initialize package contents
    */
   private init(): void {
+    // Register this package under its nsURI so other generated packages can
+    // resolve their cross-package references from the registry (#36).
+    // eINSTANCE is already assigned at this point
+    EPackageRegistry.INSTANCE.set(<%- packageName %>Package.eNS_URI, this);
+<% if (generateFactory) { -%>
+    // Wire the generated factory so loaded/created instances are typed Impls.
+    this.setEFactoryInstance(<%- packageName %>Factory.eINSTANCE);
+<% } -%>
+
 <% for (const genClass of genClasses) {
   const eClass = genClass.ecoreClass;
   const className = getName(eClass);
@@ -195,7 +222,9 @@ export class <%- packageName %>Package extends BasicEPackage {
    } -%>
 
     // ============================================
-    // Set ETypes for EReferences (must be done after all classes are created)
+    // Set ETypes for all features (must be done after all classes are created).
+    // An EAttribute without eType leaves the XMI reader no EDataType to
+    // convert against - every value would arrive as a raw string (#37)
     // ============================================
 <% for (const genClass of genClasses) {
      const eClass = genClass.ecoreClass;
@@ -206,14 +235,15 @@ export class <%- packageName %>Package extends BasicEPackage {
        const featureName = getName(feature);
        const featureUpperName = featureName.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
        const isRef = typeMapper.isReference(feature);
-       if (isRef) {
-         const eType = getEType(feature);
-         if (eType) {
+       const eType = getEType(feature);
+       if (!eType) continue;
+       // Local enums and datatypes have no initialized Literals entry yet
+       // (see the enum TODO above) - only class literals exist locally
+       if (!isRef && isLocalClassifier(eType)) continue;
+       const castType = isRef ? 'BasicEReference' : 'BasicEAttribute';
 -%>
-    (<%- packageName %>Package.Literals.<%- upperName %>__<%- featureUpperName %> as BasicEReference).setEType(<%- typeRefExpr(eType) %>);
-<%       }
-       }
-     }
+    (<%- packageName %>Package.Literals.<%- upperName %>__<%- featureUpperName %> as <%- castType %>).setEType(<%- typeRefExpr(eType) %>);
+<%   }
    } -%>
 
     // ============================================

package/dist/templates/partials/plain/class-file.ejs

@@ -60,14 +60,8 @@ if (superTypes && superTypes.length > 0) {
   const op = genOp.ecoreOperation;
   const opName = op.getName();
   const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
-  const params = [];
-  for (const param of op.getEParameters()) {
-    const paramName = param.getName();
-    const paramType = typeMapper.mapClassifier(param.getEType());
-    params.push(`${paramName}: ${paramType}`);
-  }
 -%>
-  <%- opName %>(<%- params.join(', ') %>): <%- returnType %> {
+  <%- opName %>(<%- mapParams(op) %>): <%- returnType %> {
     throw new Error('<%- opName %> not implemented');
   }