@lobb-js/studio 0.5.0 → 0.7.0

package/vite-plugins/lobb-extensions.js

@@ -0,0 +1,73 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+// Generates a virtual module `virtual:lobb-studio-extensions` that:
+// 1. Reads the consumer project's package.json
+// 2. Finds all @lobb-js/lobb-ext-* deps that have a ./studio subpath export
+// 3. Statically imports them as a name->factory map
+// 4. Also globs local extension studio entry points
+// Result: { "auth": authFactory, "storage": storageFactory, "myext": localFactory }
+export function lobbExtensionsPlugin() {
+  const virtualModuleId = "virtual:lobb-studio-extensions";
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+
+  return {
+    name: "lobb-studio-extensions",
+    resolveId(id) {
+      if (id === virtualModuleId) return resolvedVirtualModuleId;
+    },
+    load(id) {
+      if (id !== resolvedVirtualModuleId) return;
+
+      let pkg;
+      try {
+        pkg = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf-8"));
+      } catch {
+        return `export default {};`;
+      }
+
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      // Find @lobb-js/lobb-ext-* packages that have a ./studio export
+      const extPackages = [];
+      for (const pkgName of Object.keys(deps)) {
+        if (!pkgName.startsWith("@lobb-js/lobb-ext-")) continue;
+        try {
+          const pkgJsonPath = resolve(process.cwd(), "node_modules", pkgName, "package.json");
+          const extPkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+          if (extPkg.exports?.["./studio"]) {
+            const name = pkgName.replace("@lobb-js/lobb-ext-", "");
+            extPackages.push({ name, pkgName });
+          }
+        } catch {}
+      }
+
+      const imports = extPackages
+        .map(({ name, pkgName }) => `import ext_${name} from "${pkgName}/studio";`)
+        .join("\n");
+
+      const mapEntries = extPackages
+        .map(({ name }) => `  "${name}": ext_${name}`)
+        .join(",\n");
+
+      return `${imports}
+
+const localModules = import.meta.glob('/extensions/*/studio/index.ts', { eager: true });
+const localExtensions = Object.fromEntries(
+  Object.entries(localModules)
+    .map(([path, mod]) => {
+      const name = path.match(/\\/extensions\\/([^\\/]+)\\/studio/)?.[1];
+      return [name, mod.default];
+    })
+    .filter(([name]) => name != null)
+);
+
+const npmExtensions = {
+${mapEntries}
+};
+
+export default { ...npmExtensions, ...localExtensions };
+`;
+    },
+  };
+}

package/vite-plugins/monorepo-workspace.js

@@ -0,0 +1,138 @@
+import { readdirSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+
+/**
+ * Auto-detects workspace-linked @lobb-js/* packages and configures Vite so
+ * that monorepo dev and standalone npm-install users both work without manual
+ * configuration:
+ *
+ * - exclude:              Prevents vite-plugin-svelte's optimize-module from
+ *                         running esbuild on raw .svelte source files.
+ * - entries:              Tells Vite to crawl workspace packages at startup so
+ *                         all their deps are discovered and pre-bundled upfront
+ *                         (avoids 504 timeouts on first browser load).
+ * - include:              Re-includes leaf CJS deps of excluded packages so
+ *                         Vite still pre-bundles them for the browser.
+ * - holdUntilCrawlEnd:    Blocks the first response until optimization is done.
+ * - server.fs.allow:      Allows Vite to serve files from the monorepo root
+ *                         (needed to follow symlinks into workspace packages).
+ *
+ * For standalone users (real npm install, no symlinks) all lists are empty and
+ * the config has no effect.
+ *
+ * @returns {import('vite').Plugin}
+ */
+export function lobbWorkspaceOptimize() {
+  return {
+    name: "lobb-workspace-optimize",
+    config(_, { command }) {
+      if (command !== "serve") return;
+
+      const workspacePkgs = getLobbWorkspacePackages();
+      if (workspacePkgs.length === 0) return;
+
+      return {
+        optimizeDeps: {
+          holdUntilCrawlEnd: true,
+          entries: getWorkspaceEntries(workspacePkgs),
+          exclude: workspacePkgs,
+          include: getCjsDepsOf(workspacePkgs),
+        },
+        server: {
+          fs: {
+            allow: [getMonorepoRoot(workspacePkgs)].filter(Boolean),
+          },
+        },
+      };
+    },
+  };
+}
+
+function getLobbWorkspacePackages() {
+  const dir = resolve("node_modules/@lobb-js");
+  try {
+    return readdirSync(dir)
+      .filter((pkg) => lstatSync(join(dir, pkg)).isSymbolicLink())
+      .map((pkg) => `@lobb-js/${pkg}`);
+  } catch {
+    return [];
+  }
+}
+
+function getMonorepoRoot(pkgNames) {
+  for (const name of pkgNames) {
+    try {
+      const realPath = realpathSync(resolve(`node_modules/${name}`));
+      // realPath is e.g. /root/lobb/packages/studio — go up to find the monorepo root
+      let dir = realPath;
+      for (let i = 0; i < 5; i++) {
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        const pkgJson = tryReadJson(join(parent, "package.json"));
+        if (pkgJson?.workspaces) return parent;
+        dir = parent;
+      }
+    } catch { /* skip */ }
+  }
+  return null;
+}
+
+function getWorkspaceEntries(pkgNames) {
+  const entries = [];
+  for (const name of pkgNames) {
+    try {
+      const realPath = realpathSync(resolve(`node_modules/${name}`));
+      const pkg = tryReadJson(join(realPath, "package.json"));
+      if (!pkg) continue;
+      const exportsField = pkg.exports;
+      const entry =
+        pkg.svelte ??
+        pkg.module ??
+        pkg.main ??
+        (typeof exportsField?.["."] === "string"
+          ? exportsField["."]
+          : exportsField?.["."]?.default);
+      if (typeof entry === "string") entries.push(join(realPath, entry));
+    } catch { /* skip */ }
+  }
+  return entries;
+}
+
+function readPkgFrom(name, baseDir) {
+  let dir = baseDir;
+  for (let i = 0; i < 8; i++) {
+    const pkg = tryReadJson(join(dir, "node_modules", name, "package.json"));
+    if (pkg) return pkg;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function getCjsDepsOf(pkgNames) {
+  const deps = [];
+  for (const name of pkgNames) {
+    try {
+      const realPath = realpathSync(resolve(`node_modules/${name}`));
+      const pkg = tryReadJson(join(realPath, "package.json"));
+      if (!pkg) continue;
+      for (const dep of Object.keys(pkg.dependencies ?? {})) {
+        const depPkg = readPkgFrom(dep, realPath);
+        if (!depPkg) continue;
+        const isCjs = depPkg.type !== "module";
+        const isLeaf = Object.keys(depPkg.dependencies ?? {}).length === 0;
+        if (isCjs && isLeaf) deps.push(dep);
+      }
+    } catch { /* skip */ }
+  }
+  return [...new Set(deps)];
+}
+
+function tryReadJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}