the great typeinfo unfuckening

Author: outfoxxed

src/components/Header.astro

@@ -1,48 +1,18 @@
 ---
 import { ThemeSelect } from "@components/hooks/ThemeSwitch";
-import { getTypeData } from "@config/io/generateTypeData";
+import type { TypeData } from "@config/io/types";
 import Nav from "@components/navigation/sidebars/nav/index.astro";
 import TOC from "@components/navigation/sidebars/TOC.astro";
-import type { TypeTOC } from "./navigation/sidebars/types";
+import type { ConfigHeading } from "@components/navigation/sidebars/types";
 import Search from "./navigation/Search.astro";
 
-const routes = await getTypeData();
-
-const url = Astro.url.pathname.split("/");
-const currentClass = url[4];
-const currentData = routes.find(
-  item => item.name === currentClass
-);
-
-const data = currentData?.data;
-const tocFunctions =
-  data?.functions?.map(item => item.name) || null;
-
-const propsKeys = data?.properties
-  ? Object.keys(data.properties)
-  : null;
-const signalKeys = data?.signals
-  ? Object.keys(data.signals)
-  : null;
-const variantKeys = data?.variants
-  ? Object.keys(data.variants)
-  : null;
-
-let sidebarData: TypeTOC | undefined = {
-  properties: propsKeys,
-  functions: tocFunctions,
-  signals: signalKeys,
-  variants: variantKeys,
-};
-
-if (!data) {
-  sidebarData = undefined;
+interface Props {
+  title?: string;
+  headings?: ConfigHeading[];
+  type?: TypeData;
 }
 
-const {
-  title = null,
-  headings = [],
-} = Astro.props;
+const { title, headings, type } = Astro.props;
 ---
 <div class="header">
   <div class="header-item header-left">
@@ -54,6 +24,6 @@ const {
   <div class="header-item header-right">
     <Search/>
     <ThemeSelect client:load />
-    <TOC title={title} headings={headings} types={sidebarData} mobile={true}/>
+    <TOC title={title} headings={headings} type={type} mobile={true}/>
   </div>
 </div>

src/components/navigation/sidebars/TOC.astro

@@ -1,15 +1,23 @@
 ---
 import TableOfContents from "./toc";
 import type { ConfigHeading, TypeTOC } from "./types.d.ts";
+import type { TypeData } from "@config/io/types";
 
 export interface Props {
   title?: string;
   headings?: ConfigHeading[];
-  types?: TypeTOC;
+  type?: TypeData;
   mobile: boolean;
 }
 
-const { title, headings, types, mobile } = Astro.props;
+const { title, headings, type, mobile } = Astro.props;
+
+const types: TypeTOC | null = type ? {
+  properties: Object.keys(type.properties ?? {}),
+  functions: (type.functions ?? []).map(f => f.name),
+  signals: Object.keys(type.signals ?? {}),
+  variants: Object.keys(type.variants ?? {}),
+} : null;
 ---
 {((headings?.length ?? 0) != 0 || types) &&
   <div id="toc" aria-mobile={mobile} class=`toc-wrapper${mobile ? "-mobile":""}`>

src/components/navigation/sidebars/nav/RootNav.astro

@@ -7,15 +7,13 @@ export interface Props {
 
 const { currentRoute, currentModule, currentClass } = Astro.props;
 
-import { getTypeData } from "@config/io/generateTypeData";
-import { groupRoutes } from "@config/io/helpers";
+import { getModulesData } from "@config/io/generateTypeData";
 import type { TreeEntry } from "./Tree.astro";
 import Tree from "./Tree.astro";
 import Link from "./Link.astro";
 import VersionSelector from "./VersionSelector.astro"
 
-const routes = await getTypeData();
-const groupedRoutes = groupRoutes(routes);
+const modules = await getModulesData();
 
 import { getCollection } from "astro:content";
 const guidePages = await getCollection("guide");
@@ -45,18 +43,16 @@ const types = {
   title: "Quickshell Types",
   link: "/docs/types",
   current: currentRoute?.startsWith("types") ?? false,
-  entries: Object.entries(groupedRoutes.types).map(
-    ([module, items]) => ({
-      title: module,
-      link: `/docs/types/${module}`,
-      current: currentModule === module,
-      entries: items.map(type => ({
-        title: type.name,
-        link: `/docs/types/${module}/${type.name}`,
-        current: currentClass === type.name,
-      })),
-    })
-  ),
+  entries: modules.map(module => ({
+    title: module.name,
+    link: `/docs/types/${module.name}`,
+    current: currentModule === module.name,
+    entries: module.types.map(type => ({
+      title: type.name,
+      link: `/docs/types/${module.name}/${type.name}`,
+      current: currentClass === type.name,
+    }))
+  }))
 };
 
 ---

src/components/type/Properties.astro

@@ -4,22 +4,20 @@ import type {
   QMLTypeLinkObject,
   QuickshellProps,
 } from "@config/io/types";
-import { Tag, Flag } from "@icons";
+import { Tag } from "@icons";
 import TypeTitle from "./TypeTitle.astro";
 
 import TypeDetails from "./TypeDetails.astro";
 
 export interface Props {
-  propsKeys: string[];
-  propsData: QuickshellProps;
+  props: QuickshellProps;
 }
 
-const { propsKeys, propsData } = Astro.props;
+const { props } = Astro.props;
 ---
 <ul class="typedata typeprops">
   {
-    propsKeys.map(item => {
-      const propData = propsData[item]
+    Object.entries(props).map(([name, propData]) => {
       let typeLink:string;
       let linkText:string;
       let genericType:string|undefined;
@@ -37,10 +35,10 @@ const { propsKeys, propsData } = Astro.props;
         genericTypeLink = getQMLTypeLink(propData.type.of)
       }
       return (
-        <li id={ item } class="typedata-root typeprop-root">
+        <li id={ name } class="typedata-root typeprop-root">
           <TypeTitle
             typekind="prop"
-            typename={item}
+            typename={name}
             typelink={typeLink}
             typelink_text={linkText}
             typename_generic={genericType}

src/components/type/Signals.astro

@@ -1,30 +1,28 @@
 ---
 import type { QuickshellSignal } from "@config/io/types";
-import { Tag, PowerCord } from "@icons";
+import { Tag } from "@icons";
 import TypeDetails from "./TypeDetails.astro";
 import TypeTitle from "./TypeTitle.astro";
 
 export interface Props {
-  signalKeys: string[];
-  signalsData: QuickshellSignal;
+  signals: QuickshellSignal;
 }
 
-const { signalKeys, signalsData } = Astro.props;
+const { signals } = Astro.props;
 ---
 <ul class="typedata typesignals">
   {
-    signalKeys.map(item => {
-      const signalData = signalsData[item];
+    Object.entries(signals).map(([name, signalData]) => {
       const paramKeys = signalData.params.length > 0 ? signalData.params.map((param,index) => `${param.name}${index !== signalData.params.length -1 ? ", ":""}`) : []
       let genericType:string|undefined;
       let genericTypeLink:string|undefined;
       return (
-        <li id={ item } class="typedata-root typesignal-root">
+        <li id={ name } class="typedata-root typesignal-root">
           <TypeTitle
             typekind="signal"
-            typename={item}
+            typename={name}
             typelink="/docs/configuration/qml-overview#-signals"
-            typelink_text={"?"}
+            typelink_text=""
             typename_generic={genericType}
             typelink_generic={genericTypeLink}
             typedata_params={paramKeys}

src/components/type/Variants.astro

@@ -1,28 +1,25 @@
 ---
 import type { QuickshellVariant } from "@config/io/types";
-import { FourDiamonds } from "../icons";
 import TypeDetails from "./TypeDetails.astro";
 import TypeTitle from "./TypeTitle.astro";
 
 export interface Props {
-  variantKeys: string[];
-  variantsData: QuickshellVariant;
+  variants: QuickshellVariant;
 }
 
-const { variantKeys, variantsData } = Astro.props;
+const { variants } = Astro.props;
 ---
 <ul class="typedata typevariants">
   {
-    variantKeys.map(item => {
-      const variantData = variantsData[item];
+    Object.entries(variants).map(([name, variantData]) => {
       const paramKeys = variantData.params && variantData.params.length > 0
         ? variantData.params.map(param => param.name)
         : [];
       return (
-        <li id={ item } class="typedata-root typevariant-root">
+        <li id={ name } class="typedata-root typevariant-root">
           <TypeTitle 
             typekind="variant"
-            typename={item}
+            typename={name}
             typelink=""
             typelink_text=""
           />

src/config/io/generateTypeData.ts

@@ -1,57 +1,41 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 
-import type { RouteData, dirData } from "./types";
-
-async function readSubdir(basePath: string, subdir: string): Promise<dirData[]> {
-  const fullpath = path.join(basePath, subdir);
-  const filenames = await fs.readdir(fullpath);
-
-  const data = await Promise.all(
-    filenames.map(async filename => {
-      const filepath = path.join(fullpath, filename);
-      const content = await fs.readFile(filepath, "utf8");
-      const data = JSON.parse(content);
-      if (typeof data.module === "undefined") {
-        data.module = "index";
-        data.contains = filenames
-          .filter(filename => filename !== "index.json")
-          .map(filename => filename.replace(".json", ""));
-      }
-      const returnValue = {
-        fullpath: path.join(fullpath, filename),
-        filename: filename.replace(".json", ""),
-        category: subdir,
-        data: data,
-      };
-      return returnValue;
-    })
-  );
-  return data;
-}
+import type { VersionsData, ModuleData } from "./types";
+
+async function readModulesData(basePath: string): Promise<ModuleData[]> {
+  const moduleDirs = await fs.readdir(basePath);
+
+  const modules = await Promise.all(moduleDirs.map(async moduleDir => {
+    const modulePath = path.join(basePath, moduleDir);
+
+    const indexPromise = async () => {
+      const indexPath = path.join(modulePath, "index.json");
+      const indexContent = await fs.readFile(indexPath, "utf8");
+      return JSON.parse(indexContent);
+    };
 
-async function generateTypeData(basePath: string): Promise<RouteData[]> {
-  const subdirs = await fs.readdir(basePath, {
-    withFileTypes: true,
-  });
-  const routes: RouteData[] = [];
-
-  for (const subdir of subdirs) {
-    const data = await readSubdir(basePath, subdir.name);
-    const returnValue = data.map(entry => {
-      return {
-        type: entry.category,
-        name: entry.filename,
-        path: entry.fullpath,
-        data: entry.data,
-      };
+    const typeNames = (await fs.readdir(modulePath)).filter(name => name !== "index.json");
+    const typePromises = typeNames.map(async fileName => {
+      const typePath = path.join(modulePath, fileName);
+      const fileContent = await fs.readFile(typePath, "utf8");
+      return JSON.parse(fileContent);
     });
-    routes.push(...returnValue);
-  }
-  return routes;
+
+    const [index, ...types] = await Promise.all([indexPromise(), ...typePromises]);
+
+    return {
+      name: index.name,
+      description: index.description,
+      details: index.details,
+      types,
+    }
+  }));
+
+  return modules;
 }
 
-async function generateVersionsData(): Promise<VersionsData> {
+async function readVersionsData(): Promise<VersionsData> {
   const versionsPath = import.meta.env.VERSION_FILE_PATH;
 
   if (!versionsPath || versionsPath === "") {
@@ -63,9 +47,9 @@ async function generateVersionsData(): Promise<VersionsData> {
   const content = await fs.readFile(versionsPath, "utf8");
   const data = JSON.parse(content);
 
-  const versions = await Promise.all(data.versions.map(async d => ({
+  const versions = await Promise.all(data.versions.map(async (d: { name: string, types: any }) => ({
     name: d.name,
-    modules: await generateTypeData(d.types),
+    modules: await readModulesData(d.types),
   })))
 
   return {
@@ -78,13 +62,13 @@ let globalVersionsData: Promise<VersionsData>;
 
 export function getVersionsData(): Promise<VersionsData> {
   if (!globalVersionsData) {
-    globalVersionsData = generateVersionsData();
+    globalVersionsData = readVersionsData();
   }
 
   return globalVersionsData;
 }
 
-export async function getTypeData(): RouteData[] {
+export async function getModulesData(): Promise<ModuleData[]> {
   const versions = await getVersionsData();
-  return versions.versions.find(v => v.name == versions.default).modules;
+  return versions.versions.find(v => v.name == versions.default)!.modules;
 }