@peers-app/peers-ui 0.14.0 → 0.15.0

package/src/ui-router/routes-loader.ts

@@ -1,4 +1,13 @@
-import { debounceByArgs, IPackage, IPeersPackageRoutes, observable, Packages, PackageVersions, rpcServerCalls } from "@peers-app/peers-sdk";
+import {
+  debounceByArgs,
+  type IPackage,
+  type IPeersPackageRoutes,
+  type IPeersUIRoute,
+  observable,
+  Packages,
+  PackageVersions,
+  rpcServerCalls,
+} from "@peers-app/peers-sdk";
 import "../ui-defaults";
 
 export const allPackages = observable<IPackage[]>([]);
@@ -8,26 +17,24 @@ export const loadAllRoutes = async () => {
   if (allRoutesLoaded) return;
   allRoutesLoaded = true;
   // Filter packages that have an active version
-  let packagesWithUI = await Packages().list({
+  const packagesWithUI = await Packages().list({
     disabled: { $ne: true },
     activePackageVersionId: { $exists: true },
   });
   allPackages(packagesWithUI);
-  await Promise.all(
-    packagesWithUI.map(pkg => loadRoutesBundle(pkg))
-  );
+  await Promise.all(packagesWithUI.map((pkg) => loadRoutesBundle(pkg)));
 
-  Packages().dataChanged.subscribe(async evt => {
+  Packages().dataChanged.subscribe(async (evt) => {
     const _allPackages = allPackages();
-    if (evt.op === 'insert') {
+    if (evt.op === "insert") {
       _allPackages.push(evt.dataObject);
-    } else if (evt.op === 'delete') {
-      let idx = allPackages().findIndex(p => p.packageId === evt.dataObject.packageId);
+    } else if (evt.op === "delete") {
+      const idx = allPackages().findIndex((p) => p.packageId === evt.dataObject.packageId);
       if (idx >= 0) {
         _allPackages.splice(idx, 1);
       }
     } else {
-      let idx = allPackages().findIndex(p => p.packageId === evt.dataObject.packageId);
+      const idx = allPackages().findIndex((p) => p.packageId === evt.dataObject.packageId);
       if (idx >= 0) {
         _allPackages[idx] = evt.dataObject;
       }
@@ -35,8 +42,7 @@ export const loadAllRoutes = async () => {
     allPackages([..._allPackages]);
   });
 
-
-  Packages().dataChanged.subscribe(evt => {
+  Packages().dataChanged.subscribe((evt) => {
     const pkg = evt.dataObject;
     const loadingPromise = routeLoadingPromises[pkg.packageId];
     if (!loadingPromise) return;
@@ -44,19 +50,24 @@ export const loadAllRoutes = async () => {
   });
 
   return true;
-}
+};
+
+type RoutesBundleWindow = Window & {
+  registerPeersUIRoute?: (route: IPeersUIRoute) => void;
+};
 
-const routeLoadingPromises: Record<string, Promise<any>> = {};
-function loadRoutesBundle(pkg: IPackage, forceRefresh?: boolean): Promise<any> {
+const routeLoadingPromises: Record<string, Promise<unknown>> = {};
+function loadRoutesBundle(pkg: IPackage, forceRefresh?: boolean): Promise<unknown> {
   // Dynamically import the bundle
-  let importPromise: Promise<any> = routeLoadingPromises[pkg.packageId];
+  let importPromise: Promise<unknown> = routeLoadingPromises[pkg.packageId];
   if (!importPromise || forceRefresh) {
     console.log(`loading routes bundle for ${pkg.name}`);
     // just importing the module (running it) should be registering all of the package UIs with the Peers App runtime
 
     importPromise = (async () => {
       try {
-        while (!(window as any).registerPeersUIRoute) {
+        const w = window as RoutesBundleWindow;
+        while (!w.registerPeersUIRoute) {
           console.log(`waiting for registerPeersUIRoute to be defined on the window object`);
           await new Promise((resolve) => setTimeout(resolve, 20));
         }
@@ -66,26 +77,31 @@ function loadRoutesBundle(pkg: IPackage, forceRefresh?: boolean): Promise<any> {
           try {
             const pv = await PackageVersions().get(pkg.activePackageVersionId);
             routesBundleFileId = pv?.routesBundleFileId;
-          } catch { /* no version record */ }
+          } catch {
+            /* no version record */
+          }
         }
 
-        let bundleCode = '';
+        let bundleCode = "";
         if (routesBundleFileId) {
           bundleCode = await rpcServerCalls.getFileContents(routesBundleFileId);
         }
         if (bundleCode) {
           const exportRoutes = (peerRoutes: IPeersPackageRoutes) => {
-            peerRoutes.routes.forEach(route => {
-              (window as any).registerPeersUIRoute(route);
+            const rw = window as RoutesBundleWindow;
+            peerRoutes.routes.forEach((route) => {
+              rw.registerPeersUIRoute?.(route);
             });
-          }
+          };
 
-          const bundleFunction = new Function('exportRoutes', bundleCode);
+          const bundleFunction = new Function("exportRoutes", bundleCode);
           bundleFunction(exportRoutes);
 
           return {};
         } else if (routesBundleFileId) {
-          console.warn(`Routes bundle file not found for ${pkg.name} (fileId: ${routesBundleFileId})`);
+          console.warn(
+            `Routes bundle file not found for ${pkg.name} (fileId: ${routesBundleFileId})`,
+          );
         }
         return null;
       } catch (err) {