Merge master

src/Customizations/AllKnownLayouts.ts

@@ -0,0 +1,62 @@
+import known_themes from "../assets/generated/known_themes.json"
+import LayoutConfig from "../Models/ThemeConfig/LayoutConfig"
+import { LayoutConfigJson } from "../Models/ThemeConfig/Json/LayoutConfigJson"
+
+/**
+ * Somewhat of a dictionary, which lazily parses needed themes
+ */
+export class AllKnownLayoutsLazy {
+    private readonly dict: Map<string, { data: LayoutConfig } | { func: () => LayoutConfig }> =
+        new Map()
+    constructor() {
+        for (const layoutConfigJson of known_themes["themes"]) {
+            this.dict.set(layoutConfigJson.id, {
+                func: () => {
+                    const layout = new LayoutConfig(<LayoutConfigJson>layoutConfigJson, true)
+                    for (let i = 0; i < layout.layers.length; i++) {
+                        let layer = layout.layers[i]
+                        if (typeof layer === "string") {
+                            throw "Layer " + layer + " was not expanded in " + layout.id
+                        }
+                    }
+                    return layout
+                },
+            })
+        }
+    }
+
+    public get(key: string): LayoutConfig {
+        const thunk = this.dict.get(key)
+        if (thunk === undefined) {
+            return undefined
+        }
+        if (thunk["data"]) {
+            return thunk["data"]
+        }
+        const layout = thunk["func"]()
+        this.dict.set(key, { data: layout })
+        return layout
+    }
+
+    public keys() {
+        return this.dict.keys()
+    }
+
+    public values() {
+        return Array.from(this.keys()).map((k) => this.get(k))
+    }
+}
+
+export class AllKnownLayouts {
+    public static allKnownLayouts: AllKnownLayoutsLazy = new AllKnownLayoutsLazy()
+
+    static AllPublicLayers() {
+        const layers = [].concat(
+            ...this.allKnownLayouts
+                .values()
+                .filter((layout) => !layout.hideFromOverview)
+                .map((layout) => layout.layers)
+        )
+        return layers
+    }
+}

src/Customizations/AllSharedLayers.ts

@@ -0,0 +1,68 @@
+import LayerConfig from "../Models/ThemeConfig/LayerConfig"
+import { Utils } from "../Utils"
+import known_layers from "../assets/generated/known_layers.json"
+import { LayerConfigJson } from "../Models/ThemeConfig/Json/LayerConfigJson"
+import { AllKnownLayouts } from "./AllKnownLayouts"
+export class AllSharedLayers {
+    public static sharedLayers: Map<string, LayerConfig> = AllSharedLayers.getSharedLayers()
+    public static getSharedLayersConfigs(): Map<string, LayerConfigJson> {
+        const sharedLayers = new Map<string, LayerConfigJson>()
+        for (const layer of known_layers.layers) {
+            // @ts-ignore
+            sharedLayers.set(layer.id, layer)
+        }
+
+        return sharedLayers
+    }
+    private static getSharedLayers(): Map<string, LayerConfig> {
+        const sharedLayers = new Map<string, LayerConfig>()
+        for (const layer of known_layers.layers) {
+            try {
+                // @ts-ignore
+                const parsed = new LayerConfig(layer, "shared_layers")
+                sharedLayers.set(layer.id, parsed)
+            } catch (e) {
+                if (!Utils.runningFromConsole) {
+                    console.error(
+                        "CRITICAL: Could not parse a layer configuration!",
+                        layer.id,
+                        " due to",
+                        e
+                    )
+                }
+            }
+        }
+
+        return sharedLayers
+    }
+
+    public static AllPublicLayers(options?: {
+        includeInlineLayers: true | boolean
+    }): LayerConfig[] {
+        const allLayers: LayerConfig[] = []
+        const seendIds = new Set<string>()
+        AllSharedLayers.sharedLayers.forEach((layer, key) => {
+            seendIds.add(key)
+            allLayers.push(layer)
+        })
+        if (options?.includeInlineLayers ?? true) {
+            const publicLayouts = Array.from(AllKnownLayouts.allKnownLayouts.values()).filter(
+                (l) => !l.hideFromOverview
+            )
+            for (const layout of publicLayouts) {
+                if (layout.hideFromOverview) {
+                    continue
+                }
+                for (const layer of layout.layers) {
+                    if (seendIds.has(layer.id)) {
+                        continue
+                    }
+                    seendIds.add(layer.id)
+                    allLayers.push(layer)
+                }
+            }
+        }
+
+        return allLayers
+    }
+}