1 files changed, 68 insertions, 28 deletions

diff --git a/src/data/things/index.js b/src/data/things/index.js
index 11307b50..09765fd2 100644
--- a/src/data/things/index.js
+++ b/src/data/things/index.js
@@ -6,7 +6,7 @@ import CacheableObject from '#cacheable-object';
 import {logError} from '#cli';
 import {compositeFrom} from '#composite';
 import * as serialize from '#serialize';
-import {withEntries} from '#sugar';
+import {empty} from '#sugar';
 import Thing from '#thing';
 
 import * as additionalFileClasses from './additional-file.js';
@@ -58,6 +58,7 @@ const __dirname = path.dirname(
 function niceShowAggregate(error, ...opts) {
   showAggregate(error, {
     pathToFileURL: (f) => path.relative(__dirname, fileURLToPath(f)),
+    showClasses: false,
     ...opts,
   });
 }
@@ -90,25 +91,39 @@ function errorDuplicateClassNames() {
 }
 
 function flattenClassLists() {
-  let allClassesUnsorted = Object.create(null);
-
+  let remaining = [];
   for (const classes of Object.values(allClassLists)) {
-    for (const [name, constructor] of Object.entries(classes)) {
+    for (const constructor of Object.values(classes)) {
       if (typeof constructor !== 'function') continue;
       if (!(constructor.prototype instanceof Thing)) continue;
-      allClassesUnsorted[name] = constructor;
+      remaining.push(constructor);
+    }
+  }
+
+  let sorted = [];
+  while (true) {
+    if (sorted[0]) {
+      const superclass = Object.getPrototypeOf(sorted[0]);
+      if (superclass !== Thing) {
+        if (sorted.includes(superclass)) {
+          sorted.unshift(...sorted.splice(sorted.indexOf(superclass), 1));
+        } else {
+          sorted.unshift(superclass);
+        }
+        continue;
+      }
+    }
+
+    if (!empty(remaining)) {
+      sorted.unshift(remaining.shift());
+    } else {
+      break;
     }
   }
 
-  // Sort subclasses after their superclasses.
-  Object.assign(allClasses,
-    withEntries(allClassesUnsorted, entries =>
-      entries.sort(({[1]: A}, {[1]: B}) =>
-        (A.prototype instanceof B
-          ? +1
-       : B.prototype instanceof A
-          ? -1
-          :  0))));
+  for (const constructor of sorted) {
+    allClasses[constructor.name] = constructor;
+  }
 }
 
 function descriptorAggregateHelper({
@@ -138,6 +153,15 @@ function descriptorAggregateHelper({
   } catch (error) {
     niceShowAggregate(error);
     showFailedClasses(failedClasses);
+
+    /*
+    if (error.errors) {
+      for (const sub of error.errors) {
+        console.error(sub);
+      }
+    }
+    */
+
     return false;
   }
 }
@@ -167,10 +191,10 @@ function evaluatePropertyDescriptors() {
         }
       }
 
-      constructor[CacheableObject.propertyDescriptors] = {
-        ...constructor[CacheableObject.propertyDescriptors] ?? {},
-        ...results,
-      };
+      constructor[CacheableObject.propertyDescriptors] =
+        Object.create(constructor[CacheableObject.propertyDescriptors] ?? null);
+
+      Object.assign(constructor[CacheableObject.propertyDescriptors], results);
     },
 
     showFailedClasses(failedClasses) {
@@ -200,6 +224,27 @@ function evaluateSerializeDescriptors() {
   });
 }
 
+function finalizeYamlDocumentSpecs() {
+  return descriptorAggregateHelper({
+    message: `Errors finalizing Thing YAML document specs`,
+
+    op(constructor) {
+      const superclass = Object.getPrototypeOf(constructor);
+      if (
+        constructor[Thing.yamlDocumentSpec] &&
+        superclass[Thing.yamlDocumentSpec]
+      ) {
+        constructor[Thing.yamlDocumentSpec] =
+          Thing.extendDocumentSpec(superclass, constructor[Thing.yamlDocumentSpec]);
+      }
+    },
+
+    showFailedClasses(failedClasses) {
+      logError`Failed to finalize YAML document specs for classes: ${failedClasses.join(', ')}`;
+    },
+  });
+}
+
 function finalizeCacheableObjectPrototypes() {
   return descriptorAggregateHelper({
     message: `Errors finalizing Thing class prototypes`,
@@ -214,19 +259,14 @@ function finalizeCacheableObjectPrototypes() {
   });
 }
 
-if (!errorDuplicateClassNames())
-  process.exit(1);
+if (!errorDuplicateClassNames()) process.exit(1);
 
 flattenClassLists();
 
-if (!evaluatePropertyDescriptors())
-  process.exit(1);
-
-if (!evaluateSerializeDescriptors())
-  process.exit(1);
-
-if (!finalizeCacheableObjectPrototypes())
-  process.exit(1);
+if (!evaluatePropertyDescriptors()) process.exit(1);
+if (!evaluateSerializeDescriptors()) process.exit(1);
+if (!finalizeYamlDocumentSpecs()) process.exit(1);
+if (!finalizeCacheableObjectPrototypes()) process.exit(1);
 
 Object.assign(allClasses, {Thing});