metadata engine

server/internal/utils/prioritylist.ts

@@ -0,0 +1,89 @@
+import { FilterConditionally } from "./typefilter";
+
+interface PriorityTagged<T> {
+    object: T,
+    priority: number, // Higher takes priority
+    addedIndex: number, // Lower takes priority
+}
+
+export class PriorityList<T> {
+    private source: Array<PriorityTagged<T>> = [];
+    private cachedSorted: Array<T> | undefined;
+
+    push(item: T, priority: number = 0) {
+        this.source.push({
+            object: item,
+            priority,
+            addedIndex: this.source.length,
+        });
+        this.cachedSorted = undefined;
+    }
+
+    pop(index: number = 0) {
+        this.cachedSorted = undefined;
+        return this.source.splice(index, 1)[0];
+    }
+
+    values() {
+        if (this.cachedSorted !== undefined) {
+            return this.cachedSorted;
+        }
+
+        const sorted = this.source.sort((a, b) => {
+            if (a.priority == a.priority) {
+                return a.addedIndex - b.addedIndex;
+            }
+
+            return b.priority - a.priority;
+        }).map((e) => e.object);
+        this.cachedSorted = sorted;
+
+        return this.cachedSorted;
+    }
+
+    find(predicate: (value: T, index: number, obj: T[]) => boolean) {
+        return this.source.map((e) => e.object).find(predicate);
+    }
+}
+
+
+type IndexableProperty<T> = keyof FilterConditionally<T, (() => string) | string>;
+export class PriorityListIndexed<T> extends PriorityList<T> {
+    private indexName: IndexableProperty<T>;
+    private indexMap: { [key: string]: T } = {};
+
+    constructor(indexName: IndexableProperty<T>) {
+        super();
+        this.indexName = indexName;
+    }
+
+    private getIndex(object: T): string {
+        const index = object[this.indexName];
+
+        if (typeof index === 'function') {
+            return index();
+        }
+
+        return index as string;
+    }
+
+    push(item: T, priority?: number): void {
+        const index = this.getIndex(item);
+        this.indexMap[index] = item;
+
+        super.push(item, priority);
+    }
+
+    pop(position?: number): PriorityTagged<T> {
+        const value = super.pop(position);
+
+        const index = this.getIndex(value.object);
+        delete this.indexMap[index];
+
+        return value;
+    }
+
+    get(index: string) {
+        return this.indexMap[index];
+    }
+}

server/internal/utils/typefilter.ts

@@ -0,0 +1 @@
+export type FilterConditionally<Source, Condition> = Pick<Source, { [K in keyof Source]: Source[K] extends Condition ? K : never }[keyof Source]>;