@modern-js/utils 2.26.0 → 2.27.0

package/dist/esm-node/cli/prettyInstructions.js

@@ -0,0 +1,77 @@
+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;
+};
+export const getAddressUrls = (protocol = "http", port, host) => {
+  const LOCAL_LABEL = "Local:  ";
+  const NETWORK_LABEL = "Network:  ";
+  const isLocalhost = (url) => {
+    return url === null || url === void 0 ? 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;
+  }, []);
+};
+export const prettyInstructions = (appContext, config) => {
+  var _appContext_builder_context_devServer, _appContext_builder, _config_dev;
+  const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+  const isHttps = isDev() && ((_appContext_builder_context_devServer = (_appContext_builder = appContext.builder) === null || _appContext_builder === void 0 ? void 0 : _appContext_builder.context.devServer) === null || _appContext_builder_context_devServer === void 0 ? void 0 : _appContext_builder_context_devServer.https);
+  const urls = getAddressUrls(isHttps ? "https" : "http", port, (_config_dev = config.dev) === null || _config_dev === void 0 ? void 0 : _config_dev.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;
+};

package/dist/esm-node/cli/require.js

@@ -0,0 +1,52 @@
+import { findExists } from "./fs";
+export const compatRequire = (filePath, interop = true) => {
+  const mod = require(filePath);
+  const rtnESMDefault = interop && (mod === null || mod === void 0 ? void 0 : mod.__esModule);
+  return rtnESMDefault ? mod.default : mod;
+};
+export const dynamicImport = new Function("modulePath", "return import(modulePath)");
+export const requireExistModule = (filename, opt) => {
+  const final = {
+    extensions: [
+      ".ts",
+      ".js"
+    ],
+    interop: true,
+    ...opt
+  };
+  const exist = findExists(final.extensions.map((ext) => `${filename}${ext}`));
+  if (!exist) {
+    return null;
+  }
+  return compatRequire(exist, final.interop);
+};
+export const cleanRequireCache = (filelist) => {
+  filelist.forEach((filepath) => {
+    delete require.cache[filepath];
+  });
+};
+export function deleteRequireCache(path) {
+  if (require.cache[path]) {
+    delete require.cache[path];
+  }
+  if (module.children) {
+    module.children = module.children.filter((item) => item.filename !== path);
+  }
+}
+export 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;
+};

package/dist/esm-node/cli/runtimeExports.js

@@ -0,0 +1,35 @@
+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;
+  };
+};
+export 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
+  };
+});

package/dist/esm-node/cli/watch.js

@@ -0,0 +1,41 @@
+import path from "path";
+import { chokidar } from "../compiled";
+export const WatchChangeType = {
+  ADD: "add",
+  UNLINK: "unlink",
+  CHANGE: "change"
+};
+export 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;
+};

package/dist/esm-node/compiled.js

@@ -0,0 +1,33 @@
+import { Import } from "./import";
+export { default as fs } from "../compiled/fs-extra";
+export { default as ora } from "../compiled/ora";
+export { default as glob } from "../compiled/glob";
+export { default as yaml } from "../compiled/js-yaml";
+export { default as chalk } from "../compiled/chalk";
+export { default as debug } from "../compiled/debug";
+export { default as slash } from "../compiled/slash";
+export { default as execa } from "../compiled/execa";
+export { default as json5 } from "../compiled/json5";
+export { default as upath } from "../compiled/upath";
+export { default as pkgUp } from "../compiled/pkg-up";
+export { nanoid } from "../compiled/nanoid";
+export { default as semver } from "../compiled/semver";
+export { default as dotenv } from "../compiled/dotenv";
+export { default as lodash } from "../compiled/lodash";
+export { default as globby } from "../compiled/globby";
+export { default as address } from "../compiled/address";
+export { default as signale } from "../compiled/signale";
+export { default as urlJoin } from "../compiled/url-join";
+export { default as minimist } from "../compiled/minimist";
+export { default as fastGlob } from "../compiled/fast-glob";
+export { default as filesize } from "../compiled/filesize";
+export { default as gzipSize } from "../compiled/gzip-size";
+export { default as stripAnsi } from "../compiled/strip-ansi";
+export { default as dotenvExpand } from "../compiled/dotenv-expand";
+export { default as browserslist } from "../compiled/browserslist";
+export { default as recursiveReaddir } from "../compiled/recursive-readdir";
+export { program, Command } from "../compiled/commander";
+export { Signale } from "../compiled/signale";
+export const mime = Import.lazy("../compiled/mime-types", require);
+export const chokidar = Import.lazy("../compiled/chokidar", require);
+export const inquirer = Import.lazy("../compiled/inquirer", require);

package/dist/esm-node/import.js

@@ -0,0 +1,8 @@
+const lazy = (moduleName, requireFn) => {
+  const importLazyLocal = require("../compiled/import-lazy")(requireFn);
+  return importLazyLocal(moduleName);
+};
+export { lazy as lazyImport };
+export const Import = {
+  lazy
+};

package/dist/esm-node/index.js

@@ -0,0 +1,3 @@
+export * from "./compiled";
+export * from "./cli";
+export * from "./import";

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

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { createRoutesFromElements, Route } from "react-router-dom";
+export const transformNestedRoutes = (routes) => {
+  const routeElements = [];
+  for (const route of routes) {
+    const routeElement = renderNestedRoute(route);
+    routeElements.push(routeElement);
+  }
+  return createRoutesFromElements(routeElements);
+};
+export const renderNestedRoute = (nestedRoute, options = {}) => {
+  const { children, index, id, component, isRoot, lazyImport, config, handle } = 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: {
+      ...handle,
+      ...typeof config === "object" ? config === null || config === void 0 ? 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 || parent === void 0 ? 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, {
+            nonce: props === null || props === void 0 ? void 0 : props.nonce
+          })
+        ]
+      });
+    } else if (lazyImport) {
+      element = /* @__PURE__ */ _jsx(Suspense, {
+        fallback: null,
+        children: /* @__PURE__ */ _jsx(Component, {})
+      });
+    } else {
+      element = /* @__PURE__ */ _jsx(Component, {});
+    }
+  } else {
+    nestedRoute.loading = parent === null || parent === void 0 ? void 0 : parent.loading;
+  }
+  if (element) {
+    routeProps.element = element;
+  }
+  const childElements = children === null || children === void 0 ? 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";
+}

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

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

package/dist/esm-node/runtime/router.js

@@ -0,0 +1 @@
+export * from "react-router-dom";

package/dist/esm-node/runtime-browser/index.js

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

package/dist/esm-node/runtime-browser/parsed.js

@@ -0,0 +1,17 @@
+export const parsedJSONFromElement = (id) => {
+  const elements = document.querySelectorAll(`#${id}`);
+  if (elements.length === 0) {
+    return void 0;
+  }
+  const element = elements[elements.length - 1];
+  if (element) {
+    try {
+      const parsed = JSON.parse((element === null || element === void 0 ? void 0 : element.textContent) || "");
+      return parsed;
+    } catch (e) {
+      console.error(`parse ${id} error`, e);
+      return void 0;
+    }
+  }
+  return void 0;
+};

package/dist/esm-node/runtime-node/index.js

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

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

@@ -0,0 +1,18 @@
+function sortByUrlPath(entries) {
+  entries.sort(function(a, b) {
+    const length1 = a.urlPath.length;
+    const length2 = b.urlPath.length;
+    if (length1 < length2) {
+      return 1;
+    }
+    if (length1 > length2) {
+      return -1;
+    }
+    return 0;
+  });
+  return entries;
+}
+export const matchEntry = (pathname, entries) => {
+  sortByUrlPath(entries);
+  return entries.find((entry) => pathname.startsWith(entry.urlPath));
+};

package/dist/esm-node/runtime-node/router.js

@@ -0,0 +1 @@
+export * from "react-router-dom/server";

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

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

package/dist/esm-node/runtime-node/storage.js

@@ -0,0 +1,38 @@
+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/universal/constants.js

@@ -0,0 +1,3 @@
+export const ROUTE_MANIFEST = `_MODERNJS_ROUTE_MANIFEST`;
+export const HMR_SOCK_PATH = "/webpack-hmr";
+export const HTML_CHUNKSMAP_SEPARATOR = "<!--<?- chunksMap.js ?>-->";

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

@@ -0,0 +1,61 @@
+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: ", "");
+  }
+  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 _json_errors, _json_warnings, _result_errors;
+  const formattedErrors = json === null || json === void 0 ? void 0 : (_json_errors = json.errors) === null || _json_errors === void 0 ? void 0 : _json_errors.map(formatMessage);
+  const formattedWarnings = json === null || json === void 0 ? void 0 : (_json_warnings = json.warnings) === null || _json_warnings === void 0 ? void 0 : _json_warnings.map(formatMessage);
+  const result = {
+    errors: formattedErrors || [],
+    warnings: formattedWarnings || []
+  };
+  if ((_result_errors = result.errors) === null || _result_errors === void 0 ? void 0 : _result_errors.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/pluginDagSort.js

@@ -0,0 +1,50 @@
+export const pluginDagSort = (plugins, key = "name", preKey = "pre", postKey = "post") => {
+  let allLines = [];
+  function getPluginByAny(q) {
+    const target = plugins.find((item) => typeof q === "string" ? item[key] === q : item[key] === q[key]);
+    if (!target) {
+      throw new Error(`plugin ${q} not existed`);
+    }
+    return target;
+  }
+  plugins.forEach((item) => {
+    var _item_preKey, _item_postKey;
+    (_item_preKey = item[preKey]) === null || _item_preKey === void 0 ? void 0 : _item_preKey.forEach((p) => {
+      if (plugins.find((ap) => ap.name === p)) {
+        allLines.push([
+          getPluginByAny(p)[key],
+          getPluginByAny(item)[key]
+        ]);
+      }
+    });
+    (_item_postKey = item[postKey]) === null || _item_postKey === void 0 ? void 0 : _item_postKey.forEach((pt) => {
+      if (plugins.find((ap) => ap.name === pt)) {
+        allLines.push([
+          getPluginByAny(item)[key],
+          getPluginByAny(pt)[key]
+        ]);
+      }
+    });
+  });
+  let zeroEndPoints = plugins.filter((item) => !allLines.find((l) => l[1] === item[key]));
+  const sortedPoint = [];
+  while (zeroEndPoints.length) {
+    const zep = zeroEndPoints.shift();
+    sortedPoint.push(getPluginByAny(zep));
+    allLines = allLines.filter((l) => l[0] !== getPluginByAny(zep)[key]);
+    const restPoints = plugins.filter((item) => !sortedPoint.find((sp) => sp[key] === item[key]));
+    zeroEndPoints = restPoints.filter(
+      // eslint-disable-next-line @typescript-eslint/no-loop-func
+      (item) => !allLines.find((l) => l[1] === item[key])
+    );
+  }
+  if (allLines.length) {
+    const restInRingPoints = {};
+    allLines.forEach((l) => {
+      restInRingPoints[l[0]] = true;
+      restInRingPoints[l[1]] = true;
+    });
+    throw new Error(`plugins dependences has loop: ${Object.keys(restInRingPoints).join(",")}`);
+  }
+  return sortedPoint;
+};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.26.0",
+  "version": "2.27.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -235,9 +235,9 @@
     "typescript": "^5",
     "webpack": "^5.88.1",
     "@types/serialize-javascript": "^5.0.1",
-    "@modern-js/types": "2.26.0",
-    "@scripts/jest-config": "2.26.0",
-    "@scripts/build": "2.26.0"
+    "@modern-js/types": "2.27.0",
+    "@scripts/jest-config": "2.27.0",
+    "@scripts/build": "2.27.0"
   },
   "sideEffects": false,
   "scripts": {