@typemf/generator 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typemf/generator",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -30,9 +30,9 @@
     "provenance": true
   },
   "dependencies": {
-    "@typemf/core": "0.6.0",
-    "@typemf/node": "0.6.0",
-    "@typemf/xmi": "0.6.0",
+    "@typemf/core": "0.7.0",
+    "@typemf/node": "0.7.0",
+    "@typemf/xmi": "0.7.0",
     "nunjucks": "^3.2.4",
     "prettier": "^3.9.8"
   },

package/templates/typescript/eclass.njk

@@ -339,6 +339,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
 {% endfor %}
 
   eGet(feature: EStructuralFeature): unknown {
+    this.requireOwnFeature(feature);
     switch (feature.getFeatureID()) {
 {% for feature in ownFeatures %}
 {% if featureGetter(feature) or trivialDerivedFormula(feature) %}
@@ -363,6 +364,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
   }
 
   eSet(feature: EStructuralFeature, value: unknown): void {
+    this.requireOwnFeature(feature);
     switch (feature.getFeatureID()) {
 {% for feature in ownFeatures %}
 {% if feature.isMany() %}
@@ -476,6 +478,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
   }
 
   eIsSet(feature: EStructuralFeature): boolean {
+    this.requireOwnFeature(feature);
     switch (feature.getFeatureID()) {
 {% for feature in ownFeatures %}
 {% if feature.isMany() %}
@@ -526,6 +529,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
   }
 
   eUnset(feature: EStructuralFeature): void {
+    this.requireOwnFeature(feature);
     switch (feature.getFeatureID()) {
 {% for feature in ownFeatures %}
 {% if feature.isMany() and not featureGetter(feature) %}

package/templates/typescript/efactory.njk

@@ -1,4 +1,5 @@
 {% set eFactoryClassifier = findEClassByName(package, "EFactory") %}
+{% set pkgClass = packageClassName(package) %}
 {% file factoryClassName(package) + ".ts" %}
 export interface {{ factoryClassName(package) }} extends {{ useImport("EFactory", "types", {foundational: true}) }} {
 {% for classifier in concreteEClassesOf(package) %}
@@ -25,6 +26,14 @@ export interface {{ factoryClassName(package) }} extends {{ useImport("EFactory"
   double-import the old, pre-refactor version of this template had to
   guard against explicitly. #}
 export class {{ factoryClassName(package) }}Impl extends {{ useImport("EFactoryImpl", "impl", {foundational: true}) }} implements {{ useImport(factoryClassName(package), "root", {foundational: false}) }} {
+  /** The one canonical factory instance - real EMF's own `{{ factoryClassName(package) }}.eINSTANCE`, which this project
+   *  ports onto the Impl class rather than the interface (TypeScript interfaces have no statics).
+   *  Reading this also constructs the package singleton on first use (CORE-01), via the same
+   *  lazy initializer {{ pkgClass }}Impl.eINSTANCE itself goes through. */
+  static get eINSTANCE(): {{ factoryClassName(package) }} {
+    return {{ useImport("get" + pkgClass + "Ref", "impl", {file: pkgClass + "Ref", foundational: false}) }}().getEFactoryInstance() as {{ factoryClassName(package) }};
+  }
+
 {% for classifier in concreteEClassesOf(package) %}
   create{{ classifier.getName() }}(): {{ useImport(classifier.getName(), "types", {foundational: false}) }} {
     return new {{ useImport(classifier.getName() + "Impl", "impl", {foundational: false}) }}();

package/templates/typescript/epackage.njk

@@ -104,6 +104,7 @@ export interface {{ pkgClass }} extends {{ useImport("EPackage", "types", {found
 {% set _ = useImport(factoryClassName(package), "root", {foundational: false}) %}
 {% set _ = useImport(factoryClassName(package) + "Impl", "impl", {foundational: false}) %}
 {% set _ = useImport("set" + pkgClass + "Ref", "impl", {file: pkgClass + "Ref", foundational: false}) %}
+{% set _ = useImport("register" + pkgClass + "Initializer", "impl", {file: pkgClass + "Ref", foundational: false}) %}
 
 {#-
   Emits code reconstructing `element`'s real EAnnotations (source +
@@ -476,4 +477,12 @@ export class {{ pkgClass }}Impl extends EPackageImpl implements {{ pkgClass }} {
 {% endif %}
 {% endfor %}
 }
+
+// CORE-01: lets getXxxRef() construct the singleton itself, on first use, instead of only ever
+// throwing when nothing has touched {{ pkgClass }}Impl.eINSTANCE/.init() yet. A side effect of
+// this module being evaluated at all - see register{{ pkgClass }}Initializer's own doc comment
+// in {{ pkgClass }}Ref.ts.
+register{{ pkgClass }}Initializer(() => {
+  void {{ pkgClass }}Impl.eINSTANCE;
+});
 {% endfile %}

package/templates/typescript/epackageref.njk

@@ -31,14 +31,44 @@ import type { {{ packageClassName(package) }} } from '../{{ packageClassName(pac
  */
 let ref: {{ packageClassName(package) }} | undefined;
 
+/**
+ * Set once, as a module-scope side effect of {{ packageClassName(package) }}Impl.ts's own module
+ * being evaluated (see the call at the bottom of that file) - never a direct import of
+ * {{ packageClassName(package) }}Impl here, for the exact same circularity reason the class doc
+ * comment above explains. Lets get{{ packageClassName(package) }}Ref() (CORE-01) construct the
+ * singleton itself, on first use, instead of only ever throwing when nothing has touched
+ * {{ packageClassName(package) }}Impl.eINSTANCE/.init() yet.
+ */
+let initializer: (() => void) | undefined;
+let initializing = false;
+
 export function set{{ packageClassName(package) }}Ref(pkg: {{ packageClassName(package) }}): void {
   ref = pkg;
 }
 
+export function register{{ packageClassName(package) }}Initializer(init: () => void): void {
+  initializer = init;
+}
+
 export function get{{ packageClassName(package) }}Ref(): {{ packageClassName(package) }} {
+  // The `!initializing` guard turns a reentrant call before the constructor reaches its own
+  // set{{ packageClassName(package) }}Ref(this) - which should never genuinely happen; the
+  // constructor calls that first, before anything else that could call back in here - into the
+  // ordinary "not ready yet" error below instead of unbounded recursion.
+  if (!ref && initializer && !initializing) {
+    initializing = true;
+    try {
+      initializer();
+    } finally {
+      initializing = false;
+    }
+  }
   if (!ref) {
     throw new Error(
-      'get{{ packageClassName(package) }}Ref() called before the {{ packageClassName(package) }} singleton finished constructing itself.'
+      'get{{ packageClassName(package) }}Ref() called before the {{ packageClassName(package) }} singleton finished constructing itself, and no ' +
+        'initializer was registered to construct it on demand - this means {{ packageClassName(package) }}Impl.ts\'s own module ' +
+        'was never evaluated at all (an unusual bundler/tree-shaking setup). Call {{ packageClassName(package) }}Impl.eINSTANCE ' +
+        'or .init() yourself first, or check that this package is marked side-effectful.'
     );
   }
   return ref;