@modern-js/utils 2.26.0 → 2.28.0

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,116 @@
+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 = {}) => {
+  var _config, _children;
+  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 = 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) {
+    var _parent;
+    if (((_parent = 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) {
+      var _props;
+      element = /* @__PURE__ */ _jsxs(_Fragment, {
+        children: [
+          /* @__PURE__ */ _jsx(Component, {
+            ...props
+          }),
+          typeof document === "undefined" && DeferredDataComponent && /* @__PURE__ */ _jsx(DeferredDataComponent, {
+            nonce: (_props = 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 {
+    var _parent1;
+    nestedRoute.loading = (_parent1 = parent) === null || _parent1 === void 0 ? void 0 : _parent1.loading;
+  }
+  if (element) {
+    routeProps.element = element;
+  }
+  const childElements = (_children = 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,18 @@
+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 {
+      var _element;
+      const parsed = JSON.parse(((_element = 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,99 @@
+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();
+}
+const noop = (message) => message;
+const defaultColor = {
+  gray: noop,
+  cyan: noop,
+  green: noop,
+  yellow: noop,
+  underline: noop
+};
+export function addErrorTips(errors, color = defaultColor) {
+  const errorHelpers = [
+    {
+      validator(message) {
+        return (message.includes("You may need an appropriate loader") || message.includes("You may need an additional loader")) && message.includes(".ts");
+      },
+      formatter(message) {
+        return `${message}
+
+${color.yellow(`If it is a TypeScript file, you can use "source.include" config to compile it. see ${color.underline("https://modernjs.dev/builder/en/api/config-source.html#sourceinclude")}`)}
+
+${color.green(`${color.gray("// config file")}
+export default {
+  source: {
+    include: [
+      ${color.gray("// add some include rules")}
+    ]
+  }
+}`)}
+        `;
+      }
+    }
+  ];
+  return errors.map((error) => {
+    const helper = errorHelpers.find((item) => item.validator(error));
+    return helper ? helper.formatter(error) : error;
+  });
+}
+function formatWebpackMessages(json, color = defaultColor) {
+  var _json_errors, _json, _json_warnings, _json1, _result_errors;
+  const formattedErrors = (_json = json) === null || _json === void 0 ? void 0 : (_json_errors = _json.errors) === null || _json_errors === void 0 ? void 0 : _json_errors.map(formatMessage);
+  const formattedWarnings = (_json1 = json) === null || _json1 === void 0 ? void 0 : (_json_warnings = _json1.warnings) === null || _json_warnings === void 0 ? void 0 : _json_warnings.map(formatMessage);
+  const result = {
+    errors: formattedErrors || [],
+    warnings: formattedWarnings || [],
+    errorTips: []
+  };
+  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;
+  }
+  result.errors = addErrorTips(result.errors, color);
+  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/dist/types/cli/constants/chainId.d.ts

@@ -37,6 +37,8 @@ export declare const CHAIN_ID: {
     readonly YAML: "yaml";
     /** Rule for wasm */
     readonly WASM: "wasm";
+    /** Rule for node */
+    readonly NODE: "node";
     /** Rule for bff */
     readonly JS_BFF_API: "js-bff-api";
   };
@@ -75,6 +77,8 @@ export declare const CHAIN_ID: {
     readonly TOML: "toml";
     /** html-loader */
     readonly HTML: "html";
+    /** node-loader */
+    readonly NODE: "html";
     /** babel-loader */
     readonly BABEL: "babel";
     /** esbuild-loader */

package/dist/types/universal/formatWebpack.d.ts

@@ -6,7 +6,20 @@
  * https://github.com/facebook/create-react-app/blob/master/LICENSE
  */
 import type { StatsCompilation } from 'webpack';
-declare function formatWebpackMessages(json?: Pick<StatsCompilation, 'errors' | 'warnings'>): {
+export declare function addErrorTips(errors: string[], color?: {
+  gray: (message: string) => string;
+  cyan: (message: string) => string;
+  green: (message: string) => string;
+  yellow: (message: string) => string;
+  underline: (message: string) => string;
+}): string[];
+declare function formatWebpackMessages(json?: Pick<StatsCompilation, 'errors' | 'warnings'>, color?: {
+  gray: (message: string) => string;
+  cyan: (message: string) => string;
+  green: (message: string) => string;
+  yellow: (message: string) => string;
+  underline: (message: string) => string;
+}): {
   errors: string[];
   warnings: string[];
 };

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.26.0",
+  "version": "2.28.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.28.0",
+    "@scripts/build": "2.28.0",
+    "@scripts/jest-config": "2.28.0"
   },
   "sideEffects": false,
   "scripts": {