pacc 4.40.2 → 4.40.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "4.40.2",
+  "version": "4.40.4",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -39,14 +39,14 @@
   },
   "devDependencies": {
     "ava": "^6.4.1",
-    "browser-ava": "^2.3.42",
+    "browser-ava": "^2.3.43",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",
-    "semantic-release": "^25.0.0",
+    "semantic-release": "^25.0.1",
     "typescript": "^5.9.3"
   },
   "engines": {
-    "node": ">=22.20.0"
+    "node": ">=22.21.0"
   },
   "repository": {
     "type": "git",

package/src/types.mjs

@@ -30,10 +30,23 @@ export const types = {
   object: { name: "object" }
 };
 
-export function error(message) {
+function error(message) {
   throw new Error(message);
 }
 
+function raiseOnUnknownType(type, origin) {
+  switch (typeof type) {
+    case "string":
+      if (types[type]) {
+        return types[type];
+      }
+    case "undefined":
+      error(`Unknown type ${type} in '${origin}'`);
+  }
+
+  return type;
+}
+
 export function addType(type) {
   if (type.typeDefinition) {
     const clazz = type;
@@ -46,6 +59,10 @@ export function addType(type) {
     }
   }
 
+  if (type.specializationOf) {
+    type.specializationOf.specializations[type.name] = type;
+  }
+
   if (!type.owners) {
     type.owners = [];
   }
@@ -60,28 +77,25 @@ export function addType(type) {
 
     case "string":
       if (typeof type.extends === "string") {
-        const ex = types[type.extends];
-        if (!ex) {
-          error(`${type.name}: missing type '${type.extends}'`);
-        }
-        type.extends = ex;
+        type.extends = raiseOnUnknownType(type.extends, type);
       }
-
       break;
   }
 
+  if (!types[type.name]) {
+    types[type.name] = type;
+  }
+
   for (const [path, attribute] of attributeIterator(type.attributes)) {
     if (typeof attribute.type === "string") {
       attribute.type = oneOfType(attribute.type);
     }
   }
 
-  if (types[type.name]) {
+  if (types[type.name] !== type) {
     return Object.assign(types[type.name], type);
   }
 
-  types[type.name] = type;
-
   return type;
 }
 
@@ -91,11 +105,7 @@ export function oneOfType(definition) {
       name,
       members: list.reduce((all, type) => {
         if (typeof type === "string") {
-          const t = types[type] || addType({ name: type });
-          if (!t) {
-            error(`Unknown type ${type} in '${definition}'`);
-          }
-          type = t;
+          type = raiseOnUnknownType(type, definition); // addType({ name: type });
         }
         return all.union(type.members ?? new Set([type]));
       }, new Set())
@@ -120,3 +130,15 @@ export function oneOfType(definition) {
     return aggregate(parts.join("|"), parts);
   }
 }
+
+export function resolveTypeLinks() {
+  for (const type of Object.values(types)) {
+    if (typeof type.extends === "string") {
+      type.extends = raiseOnUnknownType(type.extends, type);
+    }
+
+    if (type.owners) {
+      type.owners = type.owners.map(owner => raiseOnUnknownType(owner, type));
+    }
+  }
+}

package/types/types.d.mts

@@ -1,6 +1,6 @@
-export function error(message: any): void;
 export function addType(type: any): any;
 export function oneOfType(definition: any): any;
+export function resolveTypeLinks(): void;
 export const types: {
     string: {
         name: string;