@aussieljk/forkbook 0.0.0-stage → 0.0.1-1

package/dist/_node-chunks/chunk-RQVK2TOI.js

@@ -0,0 +1,298 @@
+import CJS_COMPAT_NODE_URL_5ewvyy4zw6m from 'node:url';
+import CJS_COMPAT_NODE_PATH_5ewvyy4zw6m from 'node:path';
+import CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_5ewvyy4zw6m.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_5ewvyy4zw6m.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  sync
+} from "./chunk-VQEQ7ZLS.js";
+
+// src/react-native/metro/buildIndex.ts
+import { normalizeStories, loadMainConfig } from "@aussieljk/forkbook/internal/common";
+import { readFileSync } from "node:fs";
+import path from "path";
+import { loadCsf } from "@aussieljk/forkbook/internal/csf-tools";
+import { toId } from "@aussieljk/forkbook/internal/csf";
+import {
+  sortStoriesV7,
+  userOrAutoTitleFromSpecifier
+} from "@aussieljk/forkbook/internal/preview-api";
+var cwd = process.cwd(), makeTitle = (fileName, specifier, userTitle) => {
+  let title = userOrAutoTitleFromSpecifier(fileName, specifier, userTitle);
+  if (title)
+    return title.replace("./", "");
+  if (userTitle)
+    return userTitle.replace("./", "");
+  console.error("Could not generate title!!"), process.exit(1);
+};
+function ensureRelativePathHasDot(relativePath) {
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+async function buildIndex({ configPath }) {
+  let main = await loadMainConfig({ configDir: configPath, cwd });
+  if (!main.stories || !Array.isArray(main.stories))
+    throw new Error("No stories found");
+  let storiesSpecifiers = normalizeStories(main.stories, {
+    configDir: configPath,
+    workingDir: cwd
+  }), csfStories = storiesSpecifiers.map((specifier) => sync(specifier.files, {
+    cwd: path.resolve(process.cwd(), specifier.directory),
+    absolute: !0,
+    // default to always ignore (exclude) anything in node_modules
+    ignore: ["**/node_modules"]
+  }).map((storyPath) => ((str) => path.sep === "\\" ? str.replace(/\\/g, "/") : str)(storyPath))).reduce(
+    (acc, specifierStoryPathList, specifierIndex) => {
+      let paths = specifierStoryPathList.map((storyPath) => {
+        let code = readFileSync(storyPath, { encoding: "utf-8" }).toString(), relativePath = ensureRelativePathHasDot(path.posix.relative(cwd, storyPath));
+        return {
+          result: loadCsf(code, {
+            fileName: storyPath,
+            makeTitle: (userTitle) => makeTitle(relativePath, storiesSpecifiers[specifierIndex], userTitle)
+          }).parse(),
+          specifier: storiesSpecifiers[specifierIndex],
+          fileName: relativePath
+        };
+      });
+      return [...acc, ...paths];
+    },
+    new Array()
+  ), index = {
+    v: 5,
+    entries: {}
+  };
+  for (let { result, specifier, fileName } of csfStories) {
+    let { meta, stories } = result;
+    if (stories && stories.length > 0)
+      for (let story of stories) {
+        let id = story.id ?? toId(meta.title, story.name);
+        if (!id)
+          throw new Error(`Failed to generate id for story ${story.name} in file ${fileName}`);
+        index.entries[id] = {
+          type: "story",
+          subtype: "story",
+          id,
+          name: story.name,
+          title: meta.title,
+          importPath: `${specifier.directory}/${path.posix.relative(specifier.directory, fileName)}`,
+          tags: ["story"]
+        };
+      }
+    else
+      console.log(`No stories found for ${fileName}`);
+  }
+  try {
+    let sortableStories = Object.values(index.entries);
+    return sortStoriesV7(
+      sortableStories,
+      void 0,
+      sortableStories.map((entry) => entry.importPath)
+    ), { v: 5, entries: sortableStories.reduce(
+      (acc, item) => (acc[item.id] = item, acc),
+      {}
+    ) };
+  } catch {
+    return console.warn("Failed to sort stories, using unordered index"), index;
+  }
+}
+
+// src/react-native/metro/channelServer.ts
+import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
+import { createServer as createHttpServer } from "node:http";
+import { createServer as createHttpsServer } from "node:https";
+
+// src/react-native/metro/selectStorySyncEndpoint.ts
+import { WebSocket } from "ws";
+var SELECT_STORY_SYNC_ROUTE = "/select-story-sync/", SELECT_STORY_SYNC_TIMEOUT_MS = 1e3, LAST_RENDERED_STORY_TIMEOUT_MS = 500;
+function getRenderedStoryId(event) {
+  if (!event || typeof event != "object")
+    return null;
+  let { type, args } = event;
+  if (type !== "storyRendered" || !Array.isArray(args) || args.length === 0)
+    return null;
+  let [firstArg] = args;
+  if (typeof firstArg == "string")
+    return firstArg;
+  if (firstArg && typeof firstArg == "object" && "storyId" in firstArg) {
+    let { storyId } = firstArg;
+    return typeof storyId == "string" ? storyId : null;
+  }
+  return null;
+}
+function parseStoryIdFromPath(pathname) {
+  let match = pathname.match(/^\/select-story-sync\/([^/]+)$/);
+  if (!match)
+    return null;
+  try {
+    return decodeURIComponent(match[1]) || null;
+  } catch {
+    return null;
+  }
+}
+function createSelectStorySyncEndpoint(wss) {
+  let pendingStorySelections = /* @__PURE__ */ new Map(), lastRenderedStoryIdByClient = /* @__PURE__ */ new Map(), waitForStoryRender = (storyId, timeoutMs) => {
+    let cancelSelection = () => {
+    }, resolveWait = () => {
+    };
+    return {
+      promise: new Promise((resolve, reject) => {
+        resolveWait = resolve;
+        let selections = pendingStorySelections.get(storyId);
+        selections || (selections = /* @__PURE__ */ new Set(), pendingStorySelections.set(storyId, selections));
+        let cleanup = () => {
+          clearTimeout(selection.timeout), selections.delete(selection), selections.size === 0 && pendingStorySelections.delete(storyId);
+        }, selection = {
+          resolve: () => {
+            selection.settled || (selection.settled = !0, cleanup(), resolve());
+          },
+          timeout: setTimeout(() => {
+            selection.settled || (selection.settled = !0, cleanup(), reject(new Error(`Story "${storyId}" did not render in time`)));
+          }, timeoutMs),
+          settled: !1
+        };
+        cancelSelection = () => {
+          selection.settled || (selection.settled = !0, cleanup(), resolveWait());
+        }, selections.add(selection);
+      }),
+      cancel: cancelSelection
+    };
+  }, resolveStorySelection = (storyId) => {
+    let selections = pendingStorySelections.get(storyId);
+    selections && [...selections].forEach((selection) => selection.resolve());
+  };
+  return {
+    handleRequest: async (pathname, res) => {
+      let storyId = parseStoryIdFromPath(pathname);
+      if (!storyId) {
+        res.writeHead(400, { "Content-Type": "application/json" }), res.end(JSON.stringify({ success: !1, error: "Invalid story id" }));
+        return;
+      }
+      let waitForRender = waitForStoryRender(storyId, SELECT_STORY_SYNC_TIMEOUT_MS), message = JSON.stringify({
+        type: "setCurrentStory",
+        args: [{ viewMode: "story", storyId }]
+      });
+      wss.clients.forEach((wsClient) => {
+        wsClient.readyState === WebSocket.OPEN && wsClient.send(message);
+      });
+      try {
+        [...wss.clients].some(
+          (client) => client.readyState === WebSocket.OPEN && lastRenderedStoryIdByClient.get(client) === storyId
+        ) ? await Promise.race([
+          waitForRender.promise.then(() => "rendered"),
+          new Promise((resolve) => {
+            setTimeout(() => resolve("alreadyRendered"), LAST_RENDERED_STORY_TIMEOUT_MS);
+          })
+        ]) === "alreadyRendered" && waitForRender.cancel() : await waitForRender.promise, res.writeHead(200, { "Content-Type": "application/json" }), res.end(JSON.stringify({ success: !0, storyId }));
+      } catch (error) {
+        res.writeHead(408, { "Content-Type": "application/json" }), res.end(
+          JSON.stringify({
+            success: !1,
+            storyId,
+            error: error instanceof Error ? error.message : String(error)
+          })
+        );
+      }
+    },
+    onSocketMessage: (event, ws) => {
+      let renderedStoryId = getRenderedStoryId(event);
+      renderedStoryId && (lastRenderedStoryIdByClient.set(ws, renderedStoryId), resolveStorySelection(renderedStoryId));
+    },
+    onSocketClose: (ws) => {
+      lastRenderedStoryIdByClient.delete(ws);
+    }
+  };
+}
+
+// src/react-native/metro/channelServer.ts
+function createChannelServer({
+  port = 7007,
+  host = void 0,
+  configPath,
+  websockets = !0,
+  secured = !1,
+  ssl,
+  keepNodeProcessAlive = !1
+}) {
+  if (secured && (!ssl?.key || !ssl?.cert))
+    throw new Error("[Storybook] Secure channel server requires both `ssl.key` and `ssl.cert`.");
+  let httpServer = secured ? createHttpsServer(ssl) : createHttpServer(), wss = websockets ? new WebSocketServer({ server: httpServer }) : null, selectStorySyncEndpoint = wss ? createSelectStorySyncEndpoint(wss) : null;
+  return httpServer.on("request", async (req, res) => {
+    let protocol = "encrypted" in req.socket && req.socket.encrypted ? "https" : "http", requestUrl = new URL(req.url ?? "/", `${protocol}://${req.headers.host ?? "localhost"}`);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204), res.end();
+      return;
+    }
+    if (req.method === "GET" && requestUrl.pathname === "/index.json") {
+      try {
+        let index = await buildIndex({ configPath });
+        res.writeHead(200, { "Content-Type": "application/json" }), res.end(JSON.stringify(index));
+      } catch (error) {
+        console.error("Failed to build index:", error), res.writeHead(500, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: "Failed to build story index" }));
+      }
+      return;
+    }
+    if (req.method === "POST" && requestUrl.pathname === "/send-event") {
+      if (!wss) {
+        res.writeHead(503, { "Content-Type": "application/json" }), res.end(JSON.stringify({ success: !1, error: "WebSockets are disabled" }));
+        return;
+      }
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      }), req.on("end", () => {
+        try {
+          let json = JSON.parse(body);
+          wss.clients.forEach((wsClient) => wsClient.send(JSON.stringify(json))), res.writeHead(200, { "Content-Type": "application/json" }), res.end(JSON.stringify({ success: !0 }));
+        } catch (error) {
+          console.error("Failed to parse event:", error), res.writeHead(400, { "Content-Type": "application/json" }), res.end(JSON.stringify({ success: !1, error: "Invalid JSON" }));
+        }
+      });
+      return;
+    }
+    if (req.method === "POST" && requestUrl.pathname.startsWith(SELECT_STORY_SYNC_ROUTE)) {
+      if (!selectStorySyncEndpoint) {
+        res.writeHead(503, { "Content-Type": "application/json" }), res.end(JSON.stringify({ success: !1, error: "WebSockets are disabled" }));
+        return;
+      }
+      await selectStorySyncEndpoint.handleRequest(requestUrl.pathname, res);
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: "Not found" }));
+  }), wss && (wss.on("error", () => {
+  }), setInterval(function() {
+    wss.clients.forEach(function(client) {
+      client.readyState === WebSocket2.OPEN && client.send(JSON.stringify({ type: "ping", args: [] }));
+    });
+  }, 1e4).unref?.(), wss.on("connection", function(ws) {
+    console.log("WebSocket connection established"), ws.on("error", console.error), ws.on("message", function(data) {
+      try {
+        let json = JSON.parse(data.toString());
+        selectStorySyncEndpoint?.onSocketMessage(json, ws);
+        let msg = JSON.stringify(json);
+        wss.clients.forEach((wsClient) => {
+          wsClient !== ws && wsClient.readyState === WebSocket2.OPEN && wsClient.send(msg);
+        });
+      } catch (error) {
+        console.error(error);
+      }
+    }), ws.on("close", () => {
+      selectStorySyncEndpoint?.onSocketClose(ws);
+    });
+  })), httpServer.on("error", (error) => {
+    error.code === "EADDRINUSE" ? console.warn(
+      `[Storybook] Port ${port} is already in use. The channel server will not start. Another instance may already be running.`
+    ) : console.error("[Storybook] Channel server error:", error);
+  }), httpServer.listen(port, host, () => {
+    console.log(`${wss ? secured ? "WSS" : "WebSocket" : secured ? "HTTPS" : "HTTP"} server listening on ${host ?? "localhost"}:${port}`);
+  }), keepNodeProcessAlive || httpServer.unref(), process.once("beforeExit", () => httpServer.close()), wss;
+}
+
+export {
+  buildIndex,
+  createChannelServer
+};

package/dist/_node-chunks/chunk-SRXCCL2O.js

@@ -0,0 +1,194 @@
+import CJS_COMPAT_NODE_URL_5ewvyy4zw6m from 'node:url';
+import CJS_COMPAT_NODE_PATH_5ewvyy4zw6m from 'node:path';
+import CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_5ewvyy4zw6m.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_5ewvyy4zw6m.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  globalThis_,
+  noop
+} from "./chunk-XTTAS346.js";
+
+// ../../node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+// ../../node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function getTag(value) {
+  return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
+}
+
+// ../../node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var regexpTag = "[object RegExp]", stringTag = "[object String]", numberTag = "[object Number]", booleanTag = "[object Boolean]", argumentsTag = "[object Arguments]", symbolTag = "[object Symbol]", dateTag = "[object Date]", mapTag = "[object Map]", setTag = "[object Set]", arrayTag = "[object Array]", functionTag = "[object Function]", arrayBufferTag = "[object ArrayBuffer]", objectTag = "[object Object]", errorTag = "[object Error]", dataViewTag = "[object DataView]", uint8ArrayTag = "[object Uint8Array]", uint8ClampedArrayTag = "[object Uint8ClampedArray]", uint16ArrayTag = "[object Uint16Array]", uint32ArrayTag = "[object Uint32Array]", bigUint64ArrayTag = "[object BigUint64Array]", int8ArrayTag = "[object Int8Array]", int16ArrayTag = "[object Int16Array]", int32ArrayTag = "[object Int32Array]", bigInt64ArrayTag = "[object BigInt64Array]", float32ArrayTag = "[object Float32Array]", float64ArrayTag = "[object Float64Array]";
+
+// ../../node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+function isBuffer(x) {
+  return typeof globalThis_.Buffer < "u" && globalThis_.Buffer.isBuffer(x);
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+  if (!value || typeof value != "object") return !1;
+  let proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null ? Object.prototype.toString.call(value) === "[object Object]" : !1;
+}
+
+// ../../node_modules/es-toolkit/dist/compat/util/eq.mjs
+function eq(value, other) {
+  return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+function isEqualWith(a, b, areValuesEqual) {
+  return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+  let result = areValuesEqual(a, b, property, aParent, bParent, stack);
+  if (result !== void 0) return result;
+  if (typeof a == typeof b) switch (typeof a) {
+    case "bigint":
+    case "string":
+    case "boolean":
+    case "symbol":
+    case "undefined":
+      return a === b;
+    case "number":
+      return a === b || Object.is(a, b);
+    case "function":
+      return a === b;
+    case "object":
+      return areObjectsEqual(a, b, stack, areValuesEqual);
+  }
+  return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+  if (Object.is(a, b)) return !0;
+  let aTag = getTag(a), bTag = getTag(b);
+  if (aTag === "[object Arguments]" && (aTag = objectTag), bTag === "[object Arguments]" && (bTag = objectTag), aTag !== bTag) return !1;
+  switch (aTag) {
+    case stringTag:
+      return a.toString() === b.toString();
+    case numberTag:
+      return eq(a.valueOf(), b.valueOf());
+    case booleanTag:
+    case dateTag:
+    case symbolTag:
+      return Object.is(a.valueOf(), b.valueOf());
+    case regexpTag:
+      return a.source === b.source && a.flags === b.flags;
+    case functionTag:
+      return a === b;
+  }
+  stack = stack ?? /* @__PURE__ */ new Map();
+  let aStack = stack.get(a), bStack = stack.get(b);
+  if (aStack != null && bStack != null) return aStack === b;
+  stack.set(a, b), stack.set(b, a);
+  try {
+    switch (aTag) {
+      case mapTag:
+        if (a.size !== b.size) return !1;
+        for (let [key, value] of a.entries()) if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) return !1;
+        return !0;
+      case setTag: {
+        if (a.size !== b.size) return !1;
+        let aValues = Array.from(a.values()), bValues = Array.from(b.values());
+        for (let i = 0; i < aValues.length; i++) {
+          let aValue = aValues[i], index = bValues.findIndex((bValue) => isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual));
+          if (index === -1) return !1;
+          bValues.splice(index, 1);
+        }
+        return !0;
+      }
+      case arrayTag:
+      case uint8ArrayTag:
+      case uint8ClampedArrayTag:
+      case uint16ArrayTag:
+      case uint32ArrayTag:
+      case bigUint64ArrayTag:
+      case int8ArrayTag:
+      case int16ArrayTag:
+      case int32ArrayTag:
+      case bigInt64ArrayTag:
+      case float32ArrayTag:
+      case float64ArrayTag:
+        if (isBuffer(a) !== isBuffer(b) || a.length !== b.length) return !1;
+        for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return !1;
+        return !0;
+      case arrayBufferTag:
+        return a.byteLength !== b.byteLength ? !1 : areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      case dataViewTag:
+        return a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset ? !1 : areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      case errorTag:
+        return a.name === b.name && a.message === b.message;
+      case objectTag: {
+        if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b))) return !1;
+        let aKeys = [...Object.keys(a), ...getSymbols(a)], bKeys = [...Object.keys(b), ...getSymbols(b)];
+        if (aKeys.length !== bKeys.length) return !1;
+        for (let i = 0; i < aKeys.length; i++) {
+          let propKey = aKeys[i], aProp = a[propKey];
+          if (!Object.hasOwn(b, propKey)) return !1;
+          let bProp = b[propKey];
+          if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) return !1;
+        }
+        return !0;
+      }
+      default:
+        return !1;
+    }
+  } finally {
+    stack.delete(a), stack.delete(b);
+  }
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isEqual.mjs
+function isEqual(a, b) {
+  return isEqualWith(a, b, noop);
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
+function isPrimitive(value) {
+  return value == null || typeof value != "object" && typeof value != "function";
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+function isTypedArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+export {
+  isPrimitive,
+  isTypedArray,
+  getSymbols,
+  getTag,
+  regexpTag,
+  stringTag,
+  numberTag,
+  booleanTag,
+  argumentsTag,
+  symbolTag,
+  dateTag,
+  mapTag,
+  setTag,
+  arrayTag,
+  arrayBufferTag,
+  objectTag,
+  dataViewTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  int8ArrayTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  isBuffer,
+  isPlainObject,
+  isEqual
+};

package/dist/_node-chunks/chunk-SVZ6Q3CS.js

@@ -0,0 +1,40 @@
+import CJS_COMPAT_NODE_URL_5ewvyy4zw6m from 'node:url';
+import CJS_COMPAT_NODE_PATH_5ewvyy4zw6m from 'node:path';
+import CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_5ewvyy4zw6m.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_5ewvyy4zw6m.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+
+// src/shared/utils/get-monorepo-type.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getProjectRoot } from "@aussieljk/forkbook/internal/common";
+var monorepoConfigs = {
+  Nx: "nx.json",
+  Turborepo: "turbo.json",
+  Lerna: "lerna.json",
+  Rush: "rush.json",
+  Lage: "lage.config.json"
+}, getMonorepoType = () => {
+  let monorepoType = Object.keys(monorepoConfigs).find((monorepo) => {
+    let configFile = join(getProjectRoot(), monorepoConfigs[monorepo]);
+    return existsSync(configFile);
+  });
+  if (monorepoType)
+    return monorepoType;
+  if (!existsSync(join(getProjectRoot(), "package.json")))
+    return;
+  if (JSON.parse(
+    readFileSync(join(getProjectRoot(), "package.json"), { encoding: "utf8" })
+  )?.workspaces)
+    return "Workspaces";
+};
+
+export {
+  getMonorepoType
+};