monoverse 0.0.8 → 0.0.10

package/dist/assets/index.lazy-B2wDxrXt.js

@@ -0,0 +1,21 @@
+import{c,r as n,j as e,a as f,$ as g,_ as j,b as v,d as b,u as p,e as k,L as N,B as i,E as x,D as w,f as M,g as P,h as D,i as $,k as R}from"./index-UQPMV9jG.js";/**
+ * @license lucide-react v0.363.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */const z=c("CirclePlus",[["circle",{cx:"12",cy:"12",r:"10",key:"1mglay"}],["path",{d:"M8 12h8",key:"1wcyev"}],["path",{d:"M12 8v8",key:"napkw2"}]]);/**
+ * @license lucide-react v0.363.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */const C=c("File",[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z",key:"1rqfz7"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4",key:"tnqrlb"}]]);/**
+ * @license lucide-react v0.363.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */const E=c("Link",[["path",{d:"M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71",key:"1cjeqo"}],["path",{d:"M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71",key:"19qd67"}]]);/**
+ * @license lucide-react v0.363.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */const _=c("Trash2",[["path",{d:"M3 6h18",key:"d0wm0j"}],["path",{d:"M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6",key:"4alrt4"}],["path",{d:"M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2",key:"v07s0e"}],["line",{x1:"10",x2:"10",y1:"11",y2:"17",key:"1uufr5"}],["line",{x1:"14",x2:"14",y1:"11",y2:"17",key:"xtxkd"}]]),h=n.forwardRef(({className:t,type:s,...a},l)=>e.jsx("input",{type:s,className:f("flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",t),ref:l,...a}));h.displayName="Input";const L=n.forwardRef((t,s)=>n.createElement(g.label,j({},t,{ref:s,onMouseDown:a=>{var l;(l=t.onMouseDown)===null||l===void 0||l.call(t,a),!a.defaultPrevented&&a.detail>1&&a.preventDefault()}}))),m=L,V=v("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"),y=n.forwardRef(({className:t,...s},a)=>e.jsx(m,{ref:a,className:f(V(),t),...s}));y.displayName=m.displayName;const q=b("/_layout/")({component:F});function F(){const{projects:t,removeProject:s,selectProject:a}=p(),[l,o]=n.useState(!1),d=k();return e.jsxs("div",{className:"mt-10",children:[e.jsx("div",{className:"text-center",children:e.jsx(N,{className:"cursor-default"})}),e.jsx("div",{className:"mx-auto mt-10 max-w-xl",children:e.jsxs("div",{className:"flex flex-col items-stretch gap-4",children:[e.jsxs(i,{variant:"link",className:"flex items-center justify-center gap-2",onClick:()=>{o(!0)},children:[e.jsx(z,{}),"Add project"]}),x.PROJECT_MODE==="online",t.list.length>0?t.list.map((r,u)=>e.jsxs("div",{className:"group flex items-center gap-3",children:[e.jsxs(i,{disabled:x.PROJECT_MODE==="online",onClick:()=>{a(r),d.navigate({to:"/overview"})},variant:"ghost",className:"flex grow items-center justify-start gap-2 text-center",children:[r.type==="filepath"?e.jsx(C,{}):e.jsx(E,{}),r.value]}),e.jsx(i,{className:"opacity-30 transition-opacity group-hover:opacity-100",variant:"ghost",onClick:()=>{s(r)},children:e.jsx(_,{})})]},u)):e.jsx("div",{className:"text-center text-2xl font-bold text-[gray] dark:text-muted",children:"No projects added yet."})]})}),l&&e.jsx(O,{open:l,onOpenChange:o})]})}function O({open:t,onOpenChange:s}){const[a,l]=n.useState(""),{type:o}=n.useMemo(()=>{const r=new RegExp("^(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$","i"),u=/^(\/|([a-zA-Z]:\\)).*$/;return r.test(a)?{type:"url"}:u.test(a)?{type:"filepath"}:{type:"invalid"}},[a]),{addProject:d}=p();return e.jsxs(w,{open:t,onOpenChange:s,children:[e.jsx(M,{className:"bg-background/80"}),e.jsxs(P,{children:[e.jsx(D,{children:"Add Project"}),e.jsxs("div",{className:"space-y-3",children:[e.jsx(y,{htmlFor:"name",children:"Directory Path | Github URL"}),e.jsx(h,{id:"name",value:a,onChange:r=>{l(r.target.value)}})]}),e.jsx($,{children:e.jsx(i,{disabled:o==="invalid",onClick:()=>{R(o!=="invalid"),d({type:o,value:a}),s(!1)},children:"Save changes"})})]})]})}export{q as Route};

package/dist/cli.js

@@ -0,0 +1,481 @@
+// cli.ts
+import * as trpcExpress from "@trpc/server/adapters/express";
+import express from "express";
+import { fileURLToPath } from "url";
+import path4 from "path";
+
+// trpc/server.ts
+import { z as z5 } from "zod";
+
+// domain/core/schema/schema.ts
+import { z } from "zod";
+var dependencySchema = z.object({
+  name: z.string(),
+  versionRange: z.string(),
+  type: z.enum([
+    "dependency",
+    "devDependency",
+    "peerDependency",
+    "optionalDependency"
+  ])
+});
+var workspaceSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  dependencies: z.array(dependencySchema)
+});
+var monorepoSchema = z.object({
+  workspaces: z.array(workspaceSchema)
+});
+var dependencyRecordSchema = z.record(z.string());
+var packageJsonSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  version: z.string().optional(),
+  // Dependencies
+  dependencies: dependencyRecordSchema.optional(),
+  devDependencies: dependencyRecordSchema.optional(),
+  peerDependencies: dependencyRecordSchema.optional(),
+  optionalDependencies: dependencyRecordSchema.optional()
+}).passthrough();
+
+// domain/tools/ts.ts
+var removeUndefined = (obj) => {
+  const result = { ...obj };
+  for (const key in result) {
+    const value = result[key];
+    if (value === void 0) {
+      delete result[key];
+    }
+  }
+  return result;
+};
+
+// domain/core/schema/transform.ts
+var transformPackageJsonToWorkspace = (packageJson) => {
+  const validatedPackageJson = packageJsonSchema.parse(packageJson);
+  const {
+    dependencies,
+    devDependencies,
+    peerDependencies,
+    optionalDependencies
+  } = validatedPackageJson;
+  const getDependencies = (list, type) => {
+    if (!list)
+      return [];
+    return Object.entries(list).map(([name, versionRange]) => {
+      return {
+        name,
+        versionRange,
+        type
+      };
+    });
+  };
+  return workspaceSchema.parse(
+    // removeUndefined to ensure that the workspace doesn't have any undefined
+    removeUndefined({
+      name: validatedPackageJson.name,
+      description: validatedPackageJson.description,
+      dependencies: [
+        ...getDependencies(dependencies, "dependency"),
+        ...getDependencies(devDependencies, "devDependency"),
+        ...getDependencies(peerDependencies, "peerDependency"),
+        ...getDependencies(optionalDependencies, "optionalDependency")
+      ]
+    })
+  );
+};
+
+// domain/core/version.ts
+import { gt, maxSatisfying, minSatisfying } from "semver";
+
+// domain/implementation/api/bundlephobia.ts
+import { z as z2 } from "zod";
+var requestSchema = z2.string();
+var responseSchema = z2.object({
+  assets: z2.array(
+    z2.object({
+      gzip: z2.number(),
+      name: z2.string(),
+      size: z2.number(),
+      type: z2.string()
+    })
+  ),
+  dependencyCount: z2.number(),
+  dependencySizes: z2.array(
+    z2.object({ approximateSize: z2.number(), name: z2.string() })
+  ),
+  description: z2.string().optional(),
+  name: z2.string(),
+  version: z2.string()
+});
+
+// domain/implementation/api/package-info.ts
+import { z as z4 } from "zod";
+
+// domain/implementation/api/schema.ts
+import { z as z3 } from "zod";
+var packageSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional(),
+  repository: z3.string().optional(),
+  licence: z3.string().optional(),
+  versions: z3.array(z3.string())
+});
+
+// domain/implementation/api/package-info.ts
+var requestSchema2 = z4.string();
+var responseSchema2 = z4.object({
+  name: z4.string(),
+  versions: z4.record(z4.any()),
+  description: z4.string().optional(),
+  repository: z4.object({
+    url: z4.string().optional()
+  }).optional(),
+  licence: z4.string().optional()
+});
+
+// domain/implementation/filesystem/filesystem.ts
+import { getPackages as getWorkspaces } from "@monorepo-utils/package-utils";
+import fs from "fs";
+import path from "path";
+import invariant from "tiny-invariant";
+var getMonorepoInfo = (dirPath) => {
+  const monorepoDir = detectMonorepoDir(dirPath);
+  const workspaceDir = detectWorkspaceDir(dirPath);
+  if (monorepoDir) {
+    const workspaces = getMonorepoWorkspacesAtDir(monorepoDir);
+    invariant(workspaces !== void 0, "monorepo should be defined");
+    return {
+      workspaces
+    };
+  } else if (workspaceDir) {
+    const workspace = getWorkspaceAtDir(workspaceDir);
+    invariant(workspace !== void 0, "workspace should be defined");
+    return {
+      workspaces: [workspace]
+    };
+  }
+  return void 0;
+};
+var detectMonorepoDir = (dirPath) => {
+  dirPath = path.resolve(dirPath);
+  while (true) {
+    const monorepo = getMonorepoWorkspacesAtDir(dirPath);
+    if (monorepo)
+      return dirPath;
+    const parentDir = path.dirname(dirPath);
+    if (parentDir === dirPath)
+      return void 0;
+    dirPath = parentDir;
+  }
+};
+function getMonorepoWorkspacesAtDir(dir) {
+  const workspaces = getWorkspaces(dir);
+  if (!workspaces || workspaces.length === 0)
+    return void 0;
+  return workspaces.map((workspace) => {
+    const { packageJSON, location } = workspace;
+    const parsedPackageJson = packageJsonSchema.parse(packageJSON);
+    return {
+      workspace: transformPackageJsonToWorkspace(packageJSON),
+      location,
+      packageJSON: parsedPackageJson
+    };
+  });
+}
+function detectWorkspaceDir(dirPath) {
+  while (true) {
+    const workspace = getWorkspaceAtDir(dirPath);
+    if (workspace)
+      return dirPath;
+    const parentDir = path.dirname(dirPath);
+    if (parentDir === dirPath)
+      return void 0;
+    dirPath = parentDir;
+  }
+}
+function getWorkspaceAtDir(dir) {
+  const workspacePackageJson = path.resolve(dir, "package.json");
+  try {
+    const packageJson = JSON.parse(
+      fs.readFileSync(workspacePackageJson, "utf-8")
+    );
+    const parsedPackageJson = packageJsonSchema.parse(packageJson);
+    return {
+      location: dir,
+      packageJSON: parsedPackageJson,
+      workspace: transformPackageJsonToWorkspace(packageJson)
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// domain/implementation/filesystem/sync-dependency-versions.ts
+import fs2 from "fs";
+import path2 from "path";
+import { sortPackageJson } from "sort-package-json";
+var syncDependencyVersions = (monorepoInfo, updates) => {
+  try {
+    const updatedWorkspaces = /* @__PURE__ */ new Set();
+    for (const update of updates) {
+      for (const { packageJSON, workspace } of monorepoInfo.workspaces) {
+        if (packageJSON.dependencies?.[update.dependencyName]) {
+          packageJSON.dependencies[update.dependencyName] = update.versionRange;
+          updatedWorkspaces.add(workspace.name);
+        }
+        if (packageJSON.devDependencies?.[update.dependencyName]) {
+          packageJSON.devDependencies[update.dependencyName] = update.versionRange;
+          updatedWorkspaces.add(workspace.name);
+        }
+        if (packageJSON.peerDependencies?.[update.dependencyName]) {
+          packageJSON.peerDependencies[update.dependencyName] = update.versionRange;
+          updatedWorkspaces.add(workspace.name);
+        }
+      }
+    }
+    for (const {
+      location,
+      workspace,
+      packageJSON
+    } of monorepoInfo.workspaces) {
+      if (updatedWorkspaces.has(workspace.name)) {
+        fs2.writeFileSync(
+          path2.join(location, "package.json"),
+          sortPackageJson(JSON.stringify(packageJSON, null, 2))
+        );
+      }
+    }
+  } catch {
+    return { success: false };
+  }
+  return { success: true };
+};
+
+// domain/implementation/git/clone.ts
+import AdmZip from "adm-zip";
+import fs3, { createWriteStream } from "fs";
+import { mkdtemp, rm } from "fs/promises";
+import os from "os";
+import path3 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var downloadGitRepo = async (url) => {
+  const tempDir = await mkdtemp(path3.join(os.tmpdir(), "monoverse-"));
+  const outputPath = path3.join(tempDir, "github-zip.zip");
+  const outputDir = path3.join(tempDir, "github-extract");
+  await rm(outputDir, { recursive: true, force: true });
+  await rm(outputPath, { force: true });
+  const { ok } = await downloadZip(url, outputPath);
+  if (!ok) {
+    throw new Error("Failed to download the zip file");
+  }
+  const zip = new AdmZip(outputPath);
+  zip.extractAllTo(outputDir, true);
+  return {
+    projectDir: await getInnerDirPath(outputDir),
+    cleanupDir: () => {
+      return rm(tempDir, { recursive: true, force: true });
+    }
+  };
+};
+async function downloadZip(url, outputPath) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    return { ok: false, error: "Failed to fetch the zip file" };
+  }
+  if (!response.body) {
+    return { ok: false, error: "Response body is empty" };
+  }
+  const nodeReadableStream = Readable.fromWeb(response.body);
+  await pipeline(nodeReadableStream, createWriteStream(outputPath));
+  return { ok: true };
+}
+var getInnerDirPath = (dirPath) => {
+  return new Promise((resolve, reject) => {
+    const files = fs3.readdirSync(dirPath);
+    const innerDir = files.find((f) => {
+      console.log("f", path3.join(dirPath, f));
+      return fs3.statSync(path3.join(dirPath, f)).isDirectory();
+    });
+    if (!innerDir) {
+      return reject("No inner directory found");
+    }
+    resolve(path3.join(dirPath, innerDir));
+  });
+};
+
+// trpc/functionality/overview.ts
+var getOverview = (dirPath) => {
+  const monorepoInfo = getMonorepoInfo(dirPath);
+  if (!monorepoInfo) {
+    return null;
+  }
+  const workspacesMap = monorepoInfo.workspaces.reduce(
+    (acc, { workspace }) => {
+      acc[workspace.name] = workspace;
+      return acc;
+    },
+    {}
+  );
+  const dependencyLinks = monorepoInfo.workspaces.map(({ workspace }) => {
+    const internalDependencies = workspace.dependencies.filter((dep) => !!workspacesMap[dep.name]).map((v) => v.name);
+    return {
+      workspaceName: workspace.name,
+      internalDependencies
+    };
+  });
+  const getDependencyType = (workspace) => {
+    const hasDecendants = dependencyLinks.find((v) => v.workspaceName === workspace).internalDependencies.length > 0;
+    const hasAncestors = dependencyLinks.filter((v) => {
+      if (v.workspaceName === workspace)
+        return false;
+      if (v.internalDependencies.includes(workspace))
+        return true;
+      return false;
+    }).length > 0;
+    if (hasDecendants && hasAncestors) {
+      return "internal";
+    }
+    if (hasAncestors) {
+      return "leaf";
+    }
+    return "standalone";
+  };
+  return dependencyLinks.map((link) => {
+    return {
+      ...link,
+      dependenciesCount: workspacesMap[link.workspaceName].dependencies.length,
+      type: getDependencyType(link.workspaceName)
+    };
+  });
+};
+
+// trpc/functionality/sync-updates.ts
+var getSyncUpdates = (dirPath) => {
+  const monorepoInfo = getMonorepoInfo(dirPath);
+  if (!monorepoInfo) {
+    return null;
+  }
+  const workspaceMap = monorepoInfo.workspaces.reduce(
+    (acc, { workspace }) => {
+      acc[workspace.name] = true;
+      return acc;
+    },
+    {}
+  );
+  return monorepoInfo.workspaces.flatMap(({ workspace }) => {
+    return workspace.dependencies.map((dependency) => {
+      return {
+        dependencyName: dependency.name,
+        dependencyType: dependency.type,
+        workspaceName: workspace.name,
+        versionRange: dependency.versionRange,
+        isInternalDependency: !!workspaceMap[dependency.name]
+      };
+    });
+  });
+};
+
+// trpc/functionality/sync-versions.ts
+var syncVersions = (dirPath, updates) => {
+  const monorepoInfo = getMonorepoInfo(dirPath);
+  if (!monorepoInfo) {
+    return null;
+  }
+  return syncDependencyVersions(monorepoInfo, updates);
+};
+
+// trpc/setup.ts
+import { initTRPC } from "@trpc/server";
+var t = initTRPC.create();
+var router = t.router;
+var publicProcedure = t.procedure;
+
+// trpc/server.ts
+var appRouter = router({
+  helloWorld: publicProcedure.query(async () => {
+    return "Hello, World!";
+  }),
+  getOverview: publicProcedure.input(
+    z5.object({
+      type: z5.union([z5.literal("filepath"), z5.literal("url")]),
+      value: z5.string()
+    })
+  ).query(async ({ input }) => {
+    const { type, value } = input;
+    if (type === "filepath") {
+      const dirPath = value;
+      const result = getOverview(dirPath);
+      return {
+        success: true,
+        result
+      };
+    } else {
+      const { projectDir, cleanupDir } = await downloadGitRepo(value);
+      const result = getOverview(projectDir);
+      await cleanupDir();
+      return {
+        success: true,
+        result
+      };
+    }
+  }),
+  getSyncUpdates: publicProcedure.input(
+    z5.object({
+      type: z5.union([z5.literal("filepath"), z5.literal("url")]),
+      value: z5.string()
+    })
+  ).query(async ({ input }) => {
+    const { type, value } = input;
+    if (type === "filepath") {
+      const dirPath = value;
+      const result = getSyncUpdates(dirPath);
+      return {
+        success: true,
+        result
+      };
+    } else {
+      const { projectDir, cleanupDir } = await downloadGitRepo(value);
+      const result = getSyncUpdates(projectDir);
+      await cleanupDir();
+      return {
+        success: true,
+        result
+      };
+    }
+  }),
+  syncDependencies: publicProcedure.input(
+    z5.object({
+      dirPath: z5.string(),
+      updates: z5.array(
+        z5.object({
+          dependencyName: z5.string(),
+          versionRange: z5.string()
+        })
+      )
+    })
+  ).mutation(async ({ input }) => {
+    const result = syncVersions(input.dirPath, input.updates);
+    return result;
+  })
+});
+
+// cli.ts
+var __DIRNAME = fileURLToPath(new URL(".", import.meta.url));
+var app = express();
+app.use(
+  "/api",
+  trpcExpress.createExpressMiddleware({
+    router: appRouter
+  })
+);
+app.use(express.static("dist"));
+app.get("*", (_, res) => {
+  res.sendFile(path4.join(__DIRNAME, "dist", "index.html"));
+});
+var port = 21212;
+app.listen(port, () => {
+  console.log(`Server listening... http://localhost:${port}/`);
+});

package/dist/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>monoverse</title>
+    <script type="module" crossorigin src="/assets/index-UQPMV9jG.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DIUWvkwu.css">
+  </head>
+  <body class="dark">
+    <div id="root"></div>
+  </body>
+</html>

package/dist/vite.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>