@modern-js/utils 2.12.0 → 2.12.1-alpha.0

package/dist/esm-node/prettyInstructions.js

@@ -0,0 +1,77 @@
+import os from "os";
+import { chalk } from "./compiled";
+import { isDev, isSingleEntry } from "./is";
+const normalizeUrl = (url) => url.replace(/([^:]\/)\/+/g, "$1");
+const getIpv4Interfaces = () => {
+  const interfaces = os.networkInterfaces();
+  const ipv4Interfaces = [];
+  Object.keys(interfaces).forEach((key) => {
+    interfaces[key].forEach((detail) => {
+      const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
+      if (detail.family === familyV4Value) {
+        ipv4Interfaces.push(detail);
+      }
+    });
+  });
+  return ipv4Interfaces;
+};
+const getAddressUrls = (protocol = "http", port) => {
+  const ipv4Interfaces = getIpv4Interfaces();
+  return ipv4Interfaces.reduce((memo, detail) => {
+    let label = "Network:  ";
+    let url = `${protocol}://${detail.address}:${port}`;
+    if (detail.address.includes(`localhost`) || detail.internal) {
+      label = "Local:  ";
+      url = `${protocol}://localhost:${port}`;
+    }
+    memo.push({ label, url });
+    return memo;
+  }, []);
+};
+const prettyInstructions = (appContext, config) => {
+  const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+  const urls = getAddressUrls(
+    config.dev.https && isDev() ? "https" : "http",
+    port
+  );
+  const routes = !apiOnly ? serverRoutes.filter((route) => route.entryName) : serverRoutes;
+  let message = "App running at:\n\n";
+  if (isSingleEntry(entrypoints) || apiOnly) {
+    message += urls.map(
+      ({ label, url }) => `  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(
+        normalizeUrl(`${url}/${routes[0].urlPath}`)
+      )}
+`
+    ).join("");
+  } else {
+    const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
+    urls.forEach(({ label, url }) => {
+      message += `  ${chalk.bold(`> ${label}`)}
+`;
+      routes.forEach(({ entryName, urlPath, isSSR }) => {
+        if (!checkedEntries.includes(entryName)) {
+          return;
+        }
+        message += `    ${chalk.yellowBright(
+          isSSR ? "λ" : "○"
+        )}  ${chalk.yellowBright(
+          entryName.padEnd(maxNameLength + 8)
+        )}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}
+`;
+      });
+    });
+    message += "\n";
+    message += chalk.cyanBright(
+      "  λ (Server) server-side renders at runtime\n"
+    );
+    message += chalk.cyanBright(
+      "  ○ (Static) client-side renders as static HTML\n"
+    );
+  }
+  return message;
+};
+export {
+  getAddressUrls,
+  getIpv4Interfaces,
+  prettyInstructions
+};

package/dist/esm-node/printBuildError.js

@@ -0,0 +1,34 @@
+import { chalk } from "./compiled";
+import { logger } from "./logger";
+function printBuildError(err) {
+  const message = err != null && err.message;
+  const stack = err != null && err.stack;
+  if (stack && typeof message === "string" && message.indexOf("from Terser") !== -1) {
+    try {
+      const matched = /(.+)\[(.+):(.+),(.+)\]\[.+\]/.exec(stack);
+      if (!matched) {
+        throw new Error("Using errors for control flow is bad.");
+      }
+      const problemPath = matched[2];
+      const line = matched[3];
+      const column = matched[4];
+      logger.error(
+        `Failed to minify the code from this file: 
+
+ ${chalk.yellow(
+          `	${problemPath}:${line}${column !== "0" ? ":" + column : ""}`
+        )}
+`
+      );
+    } catch (ignored) {
+      logger.error(`Failed to minify the bundle. ${err}
+`);
+    }
+  } else {
+    logger.error((message || err) + "\n");
+  }
+  logger.log();
+}
+export {
+  printBuildError
+};

package/dist/esm-node/react.js

@@ -0,0 +1,20 @@
+import path from "path";
+import { fs, semver } from ".";
+const isBeyondReact17 = (cwd) => {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return false;
+  }
+  const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const deps = {
+    ...pkgInfo.devDependencies,
+    ...pkgInfo.dependencies
+  };
+  if (typeof deps.react !== "string") {
+    return false;
+  }
+  return semver.satisfies(semver.minVersion(deps.react), ">=17.0.0");
+};
+export {
+  isBeyondReact17
+};

package/dist/esm-node/readTsConfig.js

@@ -0,0 +1,13 @@
+import path from "path";
+import { fs, json5 } from "./compiled";
+const readTsConfig = (root) => {
+  return readTsConfigByFile(path.resolve(root, "./tsconfig.json"));
+};
+const readTsConfigByFile = (filename) => {
+  const content = fs.readFileSync(path.resolve(filename), "utf-8");
+  return json5.parse(content);
+};
+export {
+  readTsConfig,
+  readTsConfigByFile
+};

package/dist/esm-node/removeSlash.js

@@ -0,0 +1,8 @@
+const removeLeadingSlash = (s) => s.replace(/^\/+/, "");
+const removeTailSlash = (s) => s.replace(/\/+$/, "");
+const removeSlash = (s) => removeLeadingSlash(removeTailSlash(s));
+export {
+  removeLeadingSlash,
+  removeSlash,
+  removeTailSlash
+};

package/dist/esm-node/resolve.js

@@ -0,0 +1,38 @@
+import { ensureArray } from "./ensureArray";
+const tryResolve = (name, resolvePath) => {
+  let filePath = "";
+  try {
+    filePath = require.resolve(name, { paths: [resolvePath] });
+    delete require.cache[filePath];
+  } catch (err) {
+    if (err.code === "MODULE_NOT_FOUND") {
+      throw new Error(`Can not find module ${name}.`);
+    }
+    throw err;
+  }
+  return filePath;
+};
+const isPackageInstalled = (name, resolvePaths) => {
+  try {
+    require.resolve(name, { paths: ensureArray(resolvePaths) });
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+const getAntdMajorVersion = (appDirectory) => {
+  try {
+    const pkgJsonPath = require.resolve("antd/package.json", {
+      paths: [appDirectory]
+    });
+    const { version } = require(pkgJsonPath);
+    return Number(version.split(".")[0]);
+  } catch (err) {
+    return null;
+  }
+};
+export {
+  getAntdMajorVersion,
+  isPackageInstalled,
+  tryResolve
+};

package/dist/esm-node/routes.js

@@ -0,0 +1,24 @@
+import path from "path";
+import { normalizeToPosixPath } from "./path";
+import { MAIN_ENTRY_NAME } from "./constants";
+const getPathWithoutExt = (filename) => {
+  const extname = path.extname(filename);
+  return filename.slice(0, -extname.length);
+};
+const getRouteId = (componentPath, routesDir, entryName) => {
+  const relativePath = normalizeToPosixPath(
+    path.relative(routesDir, componentPath)
+  );
+  const pathWithoutExt = getPathWithoutExt(relativePath);
+  let id = ``;
+  if (entryName === MAIN_ENTRY_NAME) {
+    id = pathWithoutExt;
+  } else {
+    id = `${entryName}_${pathWithoutExt}`;
+  }
+  return id;
+};
+export {
+  getPathWithoutExt,
+  getRouteId
+};

package/dist/esm-node/runtimeExports.js

@@ -0,0 +1,40 @@
+import path from "path";
+import { fs } from "./compiled";
+import { normalizeOutputPath } from "./path";
+const memo = (fn) => {
+  const cache = /* @__PURE__ */ new Map();
+  return (...params) => {
+    const stringifiedParams = JSON.stringify(params);
+    const cachedResult = cache.get(stringifiedParams);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    const res = fn(...params);
+    cache.set(stringifiedParams, res);
+    return res;
+  };
+};
+const createRuntimeExportsUtils = memo(
+  (pwd = "", namespace = "index") => {
+    const entryExportFile = path.join(pwd, `.runtime-exports/${namespace}.js`);
+    const addExport = (statement) => {
+      statement = normalizeOutputPath(statement);
+      try {
+        fs.ensureFileSync(entryExportFile);
+        if (!fs.readFileSync(entryExportFile, "utf8").includes(statement)) {
+          fs.appendFileSync(entryExportFile, `${statement}
+`);
+        }
+      } catch {
+      }
+    };
+    const getPath = () => entryExportFile;
+    return {
+      addExport,
+      getPath
+    };
+  }
+);
+export {
+  createRuntimeExportsUtils
+};

package/dist/esm-node/ssr.js

@@ -0,0 +1,6 @@
+import { createStorage } from "./storage";
+const { run, useContext: useHeaders } = createStorage();
+export {
+  run,
+  useHeaders
+};

package/dist/esm-node/storage.js

@@ -0,0 +1,42 @@
+import * as ah from "async_hooks";
+const createStorage = () => {
+  let storage;
+  if (typeof ah.AsyncLocalStorage !== "undefined") {
+    storage = new ah.AsyncLocalStorage();
+  }
+  const run = (context, cb) => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    return new Promise((resolve, reject) => {
+      storage.run(context, () => {
+        try {
+          return resolve(cb());
+        } catch (error) {
+          return reject(error);
+        }
+      });
+    });
+  };
+  const useContext = () => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    const context = storage.getStore();
+    if (!context) {
+      throw new Error(
+        `Can't call useContext out of scope, make sure @modern-js/utils is a single version in node_modules`
+      );
+    }
+    return context;
+  };
+  return {
+    run,
+    useContext
+  };
+};
+export {
+  createStorage
+};

package/dist/esm-node/testUtils.js

@@ -0,0 +1,15 @@
+const initSnapshotSerializer = (root) => {
+  expect.addSnapshotSerializer({
+    test: (val) => typeof val === "string" && (val.includes("modern.js") || val.includes("node_modules") || val.includes(root)),
+    print: (val) => (
+      // eslint-disable-next-line no-nested-ternary
+      typeof val === "string" ? (
+        // eslint-disable-next-line no-nested-ternary
+        val.includes("node_modules") ? `"${val.replace(/.+node_modules/, ``).replace(/\\/g, "/")}"` : val.includes("modern.js") ? `"${val.replace(/.+modern\.js/, ``).replace(/\\/g, "/")}"` : `"${val.replace(root, "").replace(/\\/g, "/")}"`
+      ) : val
+    )
+  });
+};
+export {
+  initSnapshotSerializer
+};

package/dist/esm-node/universal/constants.js

@@ -0,0 +1,6 @@
+const ROUTE_MANIFEST = `_MODERNJS_ROUTE_MANIFEST`;
+const HMR_SOCK_PATH = "/webpack-hmr";
+export {
+  HMR_SOCK_PATH,
+  ROUTE_MANIFEST
+};

package/dist/esm-node/universal/formatWebpack.js

@@ -0,0 +1,77 @@
+const friendlySyntaxErrorLabel = "SyntaxError:";
+function isLikelyASyntaxError(message) {
+  return message.includes(friendlySyntaxErrorLabel);
+}
+function formatMessage(stats) {
+  let lines = [];
+  let message;
+  if (typeof stats === "object") {
+    const fileName = stats.moduleName ? `File: ${stats.moduleName}
+` : "";
+    const mainMessage = typeof stats.formatted === "string" ? stats.formatted : stats.message;
+    const details = stats.details ? `
+Details: ${stats.details}
+` : "";
+    const stack = stats.stack ? `
+${stats.stack}` : "";
+    message = `${fileName}${mainMessage}${details}${stack}`;
+  } else {
+    message = stats;
+  }
+  lines = message.split("\n");
+  lines = lines.map((line) => {
+    const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(
+      line
+    );
+    if (!parsingError) {
+      return line;
+    }
+    const [, errorLine, errorColumn, errorMessage] = parsingError;
+    return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`;
+  });
+  message = lines.join("\n");
+  message = message.replace(
+    /SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g,
+    `${friendlySyntaxErrorLabel} $3 ($1:$2)
+`
+  );
+  lines = message.split("\n");
+  if (lines.length > 2 && lines[1].trim() === "") {
+    lines.splice(1, 1);
+  }
+  lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, "$1");
+  if (lines[1] && lines[1].indexOf("Module not found:") !== -1) {
+    lines[1] = lines[1].replace("Error: ", "");
+  }
+  message = lines.join("\n");
+  message = message.replace(
+    /^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm,
+    ""
+  );
+  message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, "");
+  lines = message.split("\n");
+  lines = lines.filter(
+    (line, index, arr) => index === 0 || line.trim() !== "" || line.trim() !== arr[index - 1].trim()
+  );
+  message = lines.join("\n");
+  return message.trim();
+}
+function formatWebpackMessages(json) {
+  var _a, _b, _c;
+  const formattedErrors = (_a = json == null ? void 0 : json.errors) == null ? void 0 : _a.map(formatMessage);
+  const formattedWarnings = (_b = json == null ? void 0 : json.warnings) == null ? void 0 : _b.map(formatMessage);
+  const result = {
+    errors: formattedErrors || [],
+    warnings: formattedWarnings || []
+  };
+  if ((_c = result.errors) == null ? void 0 : _c.some(isLikelyASyntaxError)) {
+    result.errors = result.errors.filter(isLikelyASyntaxError);
+  }
+  if (result.errors.length > 1) {
+    result.errors.length = 1;
+  }
+  return result;
+}
+export {
+  formatWebpackMessages
+};

package/dist/esm-node/universal/nestedRoutes.js

@@ -0,0 +1,93 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Suspense } from "react";
+import {
+  createRoutesFromElements,
+  Route
+} from "react-router-dom";
+const transformNestedRoutes = (routes) => {
+  const routeElements = [];
+  for (const route of routes) {
+    const routeElement = renderNestedRoute(route);
+    routeElements.push(routeElement);
+  }
+  return createRoutesFromElements(routeElements);
+};
+const renderNestedRoute = (nestedRoute, options = {}) => {
+  const { children, index, id, component, isRoot, lazyImport } = nestedRoute;
+  const Component = component;
+  const { parent, DeferredDataComponent, props = {} } = options;
+  const routeProps = {
+    caseSensitive: nestedRoute.caseSensitive,
+    path: nestedRoute.path,
+    id: nestedRoute.id,
+    loader: createLoader(nestedRoute),
+    action: nestedRoute.action,
+    hasErrorBoundary: nestedRoute.hasErrorBoundary,
+    shouldRevalidate: nestedRoute.shouldRevalidate,
+    handle: nestedRoute.handle,
+    index: nestedRoute.index,
+    element: nestedRoute.element,
+    errorElement: nestedRoute.errorElement
+  };
+  if (nestedRoute.error) {
+    const errorElement = /* @__PURE__ */ jsx(nestedRoute.error, {});
+    routeProps.errorElement = errorElement;
+  }
+  let element;
+  if (Component) {
+    if ((parent == null ? void 0 : parent.loading) && lazyImport) {
+      const Loading = parent.loading;
+      if (isLoadableComponent(Component)) {
+        element = /* @__PURE__ */ jsx(Component, { fallback: /* @__PURE__ */ jsx(Loading, {}) });
+      } else {
+        element = /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loading, {}), children: /* @__PURE__ */ jsx(Component, {}) });
+      }
+    } else if (isLoadableComponent(Component) && lazyImport) {
+      element = /* @__PURE__ */ jsx(Component, {});
+    } else if (isRoot) {
+      element = /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Component, { ...props }),
+        typeof document === "undefined" && DeferredDataComponent && /* @__PURE__ */ jsx(DeferredDataComponent, {})
+      ] });
+    } else if (lazyImport) {
+      element = /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(Component, {}) });
+    } else {
+      element = /* @__PURE__ */ jsx(Component, {});
+    }
+  } else {
+    nestedRoute.loading = parent == null ? void 0 : parent.loading;
+  }
+  if (element) {
+    routeProps.element = element;
+  }
+  const childElements = children == null ? void 0 : children.map((childRoute) => {
+    return renderNestedRoute(childRoute, { parent: nestedRoute });
+  });
+  const routeElement = index ? /* @__PURE__ */ jsx(Route, { ...routeProps, index: true }, id) : /* @__PURE__ */ jsx(Route, { ...routeProps, index: false, children: childElements }, id);
+  return routeElement;
+};
+function createLoader(route) {
+  const { loader } = route;
+  if (loader) {
+    return (args) => {
+      if (typeof route.lazyImport === "function") {
+        route.lazyImport();
+      }
+      return loader(args);
+    };
+  } else {
+    return () => {
+      if (typeof route.lazyImport === "function") {
+        route.lazyImport();
+      }
+      return null;
+    };
+  }
+}
+function isLoadableComponent(component) {
+  return component && component.displayName === "Loadable" && component.preload && typeof component.preload === "function";
+}
+export {
+  renderNestedRoute,
+  transformNestedRoutes
+};

package/dist/esm-node/universal/remixRouter.js

@@ -0,0 +1 @@
+export * from "@remix-run/router";

package/dist/esm-node/universal/serialize.js

@@ -0,0 +1,7 @@
+import serialize from "serialize-javascript";
+const serializeJson = (data) => {
+  return serialize(data, { isJSON: true });
+};
+export {
+  serializeJson
+};

package/dist/esm-node/version.js

@@ -0,0 +1,25 @@
+import path from "path";
+import { fs, execa, semver } from "./compiled";
+async function getPnpmVersion() {
+  const { stdout } = await execa("pnpm", ["--version"]);
+  return stdout;
+}
+const isReact18 = (cwd) => {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return false;
+  }
+  const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const deps = {
+    ...pkgInfo.devDependencies,
+    ...pkgInfo.dependencies
+  };
+  if (typeof deps.react !== "string") {
+    return false;
+  }
+  return semver.satisfies(semver.minVersion(deps.react), ">=18.0.0");
+};
+export {
+  getPnpmVersion,
+  isReact18
+};

package/dist/esm-node/wait.js

@@ -0,0 +1,6 @@
+const wait = (time = 0) => new Promise((resolve) => {
+  setTimeout(resolve, time);
+});
+export {
+  wait
+};

package/dist/esm-node/watch.js

@@ -0,0 +1,36 @@
+import * as path from "path";
+import { chokidar } from "./compiled";
+const WatchChangeType = {
+  ADD: "add",
+  UNLINK: "unlink",
+  CHANGE: "change"
+};
+const watch = (watchDir, runTask, ignored = []) => {
+  let ready = false;
+  const watcher = chokidar.watch(watchDir, {
+    ignored
+  });
+  watcher.on("ready", () => ready = true);
+  watcher.on("change", async (filePath) => {
+    const changedFilePath = path.resolve(filePath);
+    await runTask({ changedFilePath, changeType: WatchChangeType.CHANGE });
+  });
+  watcher.on("add", async (filePath) => {
+    const changedFilePath = path.resolve(filePath);
+    if (ready) {
+      await runTask({ changedFilePath, changeType: WatchChangeType.ADD });
+    }
+  });
+  watcher.on("unlink", async (filePath) => {
+    const changedFilePath = path.resolve(filePath);
+    await runTask({ changedFilePath, changeType: WatchChangeType.UNLINK });
+  });
+  watcher.on("error", (err) => {
+    throw err;
+  });
+  return watcher;
+};
+export {
+  WatchChangeType,
+  watch
+};

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.12.0",
+  "version": "2.12.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -175,8 +175,8 @@
     "typescript": "^4",
     "webpack": "^5.76.2",
     "@types/serialize-javascript": "^5.0.1",
-    "@modern-js/types": "2.12.0",
     "@scripts/build": "2.12.0",
+    "@modern-js/types": "2.12.0",
     "@scripts/jest-config": "2.12.0"
   },
   "sideEffects": false,

package/dist/emptyDir.js

@@ -1,52 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-var emptyDir_exports = {};
-__export(emptyDir_exports, {
-  emptyDir: () => emptyDir
-});
-module.exports = __toCommonJS(emptyDir_exports);
-var import_compiled = require("./compiled");
-const emptyDir = (dir) => __async(void 0, null, function* () {
-  if (yield import_compiled.fs.pathExists(dir)) {
-    yield import_compiled.fs.emptyDir(dir);
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  emptyDir
-});