@modern-js/utils 2.13.4 → 2.14.0

package/dist/esm/path.js

@@ -0,0 +1,50 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { nanoid, upath, lodash as _ } from "./compiled";
+const isPathString = (test) => path.posix.basename(test) !== test || path.win32.basename(test) !== test;
+const isRelativePath = (test) => /^\.\.?($|[\\/])/.test(test);
+const normalizeOutputPath = (s) => s.replace(/\\/g, "\\\\");
+const normalizeToPosixPath = (p) => upath.normalizeSafe(path.normalize(p || "")).replace(/^([a-zA-Z]+):/, (_2, m) => `/${m.toLowerCase()}`);
+const getTemplatePath = (prefix) => {
+  const tmpRoot = fs.realpathSync(os.tmpdir());
+  const parts = [tmpRoot];
+  prefix && parts.push(prefix);
+  parts.push(nanoid());
+  return path.resolve(...parts);
+};
+function compilePathMatcherRegExp(match) {
+  if (typeof match !== "string") {
+    return match;
+  }
+  const escaped = _.escapeRegExp(match);
+  return new RegExp(`(?<=\\W|^)${escaped}(?=\\W|$)`);
+}
+const _joinPathParts = (_part, i, parts) => _(parts).filter((part) => !["/", "\\"].includes(part)).tap((parts2) => parts2.unshift("")).slice(0, i + 2).join("/");
+function upwardPaths(start) {
+  return _(start).split(/[/\\]/).filter(Boolean).map(_joinPathParts).reverse().push("/").value();
+}
+function getRealTemporaryDirectory() {
+  let ret = null;
+  try {
+    ret = os.tmpdir();
+    ret = fs.realpathSync(ret);
+  } catch {
+  }
+  return ret;
+}
+function splitPathString(str) {
+  return str.split(/[\\/]/);
+}
+export {
+  _joinPathParts,
+  compilePathMatcherRegExp,
+  getRealTemporaryDirectory,
+  getTemplatePath,
+  isPathString,
+  isRelativePath,
+  normalizeOutputPath,
+  normalizeToPosixPath,
+  splitPathString,
+  upwardPaths
+};

package/dist/esm/pathSerializer.js

@@ -0,0 +1,46 @@
+import os from "os";
+import _ from "../compiled/lodash";
+import {
+  compilePathMatcherRegExp,
+  normalizeToPosixPath,
+  getRealTemporaryDirectory,
+  splitPathString,
+  upwardPaths
+} from "./path";
+const matchUpwardPathsAsUnknown = (p) => _(upwardPaths(normalizeToPosixPath(p))).map((match) => ({ match, mark: "unknown" })).slice(1, -1).value();
+function applyPathMatcher(matcher, str, options = {}) {
+  const regex = compilePathMatcherRegExp(matcher.match);
+  const replacer = (substring, ...args) => {
+    if (options.minPartials && splitPathString(substring).length < options.minPartials) {
+      return substring;
+    }
+    const ret = typeof matcher.mark === "string" ? matcher.mark : matcher.mark(substring, ...args);
+    return `<${_.snakeCase(ret).toUpperCase()}>`;
+  };
+  return str.replace(regex, replacer);
+}
+function applyMatcherReplacement(matchers, str, options = {}) {
+  return matchers.reduce((ret, matcher) => {
+    return applyPathMatcher(matcher, ret, options);
+  }, str);
+}
+const createDefaultPathMatchers = (root) => {
+  const ret = [
+    {
+      match: /(?<=\/)(\.pnpm\/.+?\/node_modules)(?=\/)/,
+      mark: "pnpmInner"
+    }
+  ];
+  const tmpdir = getRealTemporaryDirectory();
+  tmpdir && ret.push({ match: tmpdir, mark: "temp" });
+  ret.push({ match: os.tmpdir(), mark: "temp" });
+  ret.push({ match: os.homedir(), mark: "home" });
+  ret.push(...matchUpwardPathsAsUnknown(root));
+  return ret;
+};
+export {
+  applyMatcherReplacement,
+  applyPathMatcher,
+  createDefaultPathMatchers,
+  matchUpwardPathsAsUnknown
+};

package/dist/esm/plugin.js

@@ -0,0 +1,23 @@
+import { INTERNAL_CLI_PLUGINS } from "./constants";
+import { isDepExists } from "./is";
+function getInternalPlugins(appDirectory, internalPlugins = INTERNAL_CLI_PLUGINS) {
+  return [
+    ...Object.keys(internalPlugins).filter((name) => {
+      const config = internalPlugins[name];
+      if (typeof config !== "string" && config.forced === true) {
+        return true;
+      }
+      return isDepExists(appDirectory, name);
+    }).map((name) => {
+      const config = internalPlugins[name];
+      if (typeof config !== "string") {
+        return config.path;
+      } else {
+        return config;
+      }
+    })
+  ];
+}
+export {
+  getInternalPlugins
+};

package/dist/esm/prettyInstructions.js

@@ -0,0 +1,95 @@
+import os from "os";
+import { chalk } from "./compiled";
+import { isDev, isSingleEntry } from "./is";
+import { DEFAULT_DEV_HOST } from "./constants";
+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, host) => {
+  const LOCAL_LABEL = "Local:  ";
+  const NETWORK_LABEL = "Network:  ";
+  const isLocalhost = (url) => url == null ? void 0 : url.includes("localhost");
+  if (host && host !== DEFAULT_DEV_HOST) {
+    return [
+      {
+        label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+        url: `${protocol}://${host}:${port}`
+      }
+    ];
+  }
+  const ipv4Interfaces = getIpv4Interfaces();
+  return ipv4Interfaces.reduce((memo, detail) => {
+    if (isLocalhost(detail.address) || detail.internal) {
+      memo.push({
+        label: LOCAL_LABEL,
+        url: `${protocol}://localhost:${port}`
+      });
+    } else {
+      memo.push({
+        label: NETWORK_LABEL,
+        url: `${protocol}://${detail.address}:${port}`
+      });
+    }
+    return memo;
+  }, []);
+};
+const prettyInstructions = (appContext, config) => {
+  var _a;
+  const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+  const urls = getAddressUrls(
+    config.dev.https && isDev() ? "https" : "http",
+    port,
+    (_a = config.dev) == null ? void 0 : _a.host
+  );
+  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/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/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/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/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/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/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/runtime/index.js

@@ -0,0 +1 @@
+export * from "./parsed";

package/dist/esm/runtime/parsed.js

@@ -0,0 +1,16 @@
+const parsedJSONFromElement = (id) => {
+  const element = document.getElementById(id);
+  if (element) {
+    try {
+      const parsed = JSON.parse(element.textContent || "");
+      return parsed;
+    } catch (e) {
+      console.error(`parse ${id} error`, e);
+      return void 0;
+    }
+  }
+  return void 0;
+};
+export {
+  parsedJSONFromElement
+};

package/dist/esm/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/ssr.js

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

package/dist/esm/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/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/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/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/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, config } = 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: typeof config === "object" ? config == null ? void 0 : config.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/universal/remixRouter.js

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

package/dist/esm/universal/serialize.js

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