@modern-js/runtime-utils 0.0.0-nightly-20230914160548

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/browser/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./parsed"), exports);
+_export_star._(require("./nestedRoutes"), exports);

package/dist/cjs/browser/nestedRoutes.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  transformNestedRoutes: function() {
+    return transformNestedRoutes;
+  },
+  renderNestedRoute: function() {
+    return renderNestedRoute;
+  }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /* @__PURE__ */ _interop_require_wildcard._(require("react"));
+const _reactrouterdom = require("react-router-dom");
+const _constants = require("@modern-js/utils/universal/constants");
+const _time = require("../time");
+const transformNestedRoutes = (routes, reporter) => {
+  const routeElements = [];
+  for (const route of routes) {
+    const routeElement = renderNestedRoute(route, {
+      reporter
+    });
+    routeElements.push(routeElement);
+  }
+  return (0, _reactrouterdom.createRoutesFromElements)(routeElements);
+};
+const renderNestedRoute = (nestedRoute, options = {}) => {
+  var _config, _children;
+  const { children, index, id, component, isRoot, lazyImport, config, handle } = nestedRoute;
+  const Component = component;
+  const { parent, DeferredDataComponent, props = {}, reporter } = options;
+  const routeProps = {
+    caseSensitive: nestedRoute.caseSensitive,
+    path: nestedRoute.path,
+    id: nestedRoute.id,
+    loader: createLoader(nestedRoute, reporter),
+    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__ */ (0, _jsxruntime.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__ */ (0, _jsxruntime.jsx)(Component, {
+          fallback: /* @__PURE__ */ (0, _jsxruntime.jsx)(Loading, {})
+        });
+      } else {
+        element = /* @__PURE__ */ (0, _jsxruntime.jsx)(_react.Suspense, {
+          fallback: /* @__PURE__ */ (0, _jsxruntime.jsx)(Loading, {}),
+          children: /* @__PURE__ */ (0, _jsxruntime.jsx)(Component, {})
+        });
+      }
+    } else if (isLoadableComponent(Component) && lazyImport) {
+      element = /* @__PURE__ */ (0, _jsxruntime.jsx)(Component, {});
+    } else if (isRoot) {
+      var _props;
+      element = /* @__PURE__ */ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+          /* @__PURE__ */ (0, _jsxruntime.jsx)(Component, {
+            ...props
+          }),
+          typeof document === "undefined" && DeferredDataComponent && /* @__PURE__ */ (0, _jsxruntime.jsx)(DeferredDataComponent, {
+            nonce: (_props = props) === null || _props === void 0 ? void 0 : _props.nonce
+          })
+        ]
+      });
+    } else if (lazyImport) {
+      element = /* @__PURE__ */ (0, _jsxruntime.jsx)(_react.Suspense, {
+        fallback: null,
+        children: /* @__PURE__ */ (0, _jsxruntime.jsx)(Component, {})
+      });
+    } else {
+      element = /* @__PURE__ */ (0, _jsxruntime.jsx)(Component, {});
+    }
+  } else {
+    var _parent1;
+    nestedRoute.loading = (_parent1 = parent) === null || _parent1 === void 0 ? void 0 : _parent1.loading;
+    routeProps.element = /* @__PURE__ */ (0, _jsxruntime.jsx)(_reactrouterdom.Outlet, {});
+  }
+  if (element) {
+    routeProps.element = element;
+  }
+  const childElements = (_children = children) === null || _children === void 0 ? void 0 : _children.map((childRoute) => {
+    return renderNestedRoute(childRoute, {
+      parent: nestedRoute,
+      reporter
+    });
+  });
+  const routeElement = index ? /* @__PURE__ */ (0, _jsxruntime.jsx)(_reactrouterdom.Route, {
+    ...routeProps,
+    index: true
+  }, id) : /* @__PURE__ */ (0, _jsxruntime.jsx)(_reactrouterdom.Route, {
+    ...routeProps,
+    index: false,
+    children: childElements
+  }, id);
+  return routeElement;
+};
+function createLoader(route, reporter) {
+  const { loader } = route;
+  if (loader) {
+    return async (args) => {
+      if (typeof route.lazyImport === "function") {
+        route.lazyImport();
+      }
+      const end = (0, _time.time)();
+      const res = await loader(args);
+      const cost = end();
+      if (typeof document === "undefined" && reporter) {
+        var _reporter;
+        (_reporter = reporter) === null || _reporter === void 0 ? void 0 : _reporter.reportTiming(`${_constants.LOADER_REPORTER_NAME}-${route.id}`, cost);
+      }
+      return res;
+    };
+  } 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/cjs/browser/parsed.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "parsedJSONFromElement", {
+  enumerable: true,
+  get: function() {
+    return parsedJSONFromElement;
+  }
+});
+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/cjs/node/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  run: function() {
+    return run;
+  },
+  useHeaders: function() {
+    return useHeaders;
+  },
+  serializeJson: function() {
+    return _serialize.serializeJson;
+  }
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+const _storage = require("./storage");
+const _serialize = require("./serialize");
+_export_star._(require("./nestedRoutes"), exports);
+_export_star._(require("./loaderContext"), exports);
+const { run, useContext: useHeaders } = (0, _storage.createStorage)();

package/dist/cjs/node/loaderContext/createLoaderCtx.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  LoaderContext: function() {
+    return LoaderContext;
+  },
+  createLoaderContext: function() {
+    return createLoaderContext;
+  }
+});
+class LoaderContext {
+  getDefaultValue() {
+    if (!this.defaultValue) {
+      throw new Error("Can't get defaultValue before initialed");
+    }
+    return this.defaultValue;
+  }
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
+    this.symbol = Symbol("loaderContext");
+  }
+}
+function createLoaderContext(defaultValue) {
+  return new LoaderContext(defaultValue);
+}

package/dist/cjs/node/loaderContext/createRequestCtx.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  RequestContext: function() {
+    return RequestContext;
+  },
+  createRequestContext: function() {
+    return createRequestContext;
+  }
+});
+class RequestContext {
+  get(loaderCtx) {
+    const { symbol } = loaderCtx;
+    if (this.store.get(symbol)) {
+      return this.store.get(symbol);
+    }
+    return loaderCtx.getDefaultValue();
+  }
+  set(loaderCtx, value) {
+    const { symbol } = loaderCtx;
+    this.store.set(symbol, value);
+  }
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+}
+function createRequestContext() {
+  return new RequestContext();
+}

package/dist/cjs/node/loaderContext/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  createRequestContext: function() {
+    return _createRequestCtx.createRequestContext;
+  },
+  reporterCtx: function() {
+    return reporterCtx;
+  }
+});
+const _createLoaderCtx = require("./createLoaderCtx");
+const _createRequestCtx = require("./createRequestCtx");
+const reporterCtx = (0, _createLoaderCtx.createLoaderContext)();

package/dist/cjs/node/nestedRoutes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "matchEntry", {
+  enumerable: true,
+  get: function() {
+    return matchEntry;
+  }
+});
+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;
+}
+const matchEntry = (pathname, entries) => {
+  sortByUrlPath(entries);
+  return entries.find((entry) => pathname.startsWith(entry.urlPath));
+};

package/dist/cjs/node/router.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("react-router-dom/server"), exports);

package/dist/cjs/node/serialize.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "serializeJson", {
+  enumerable: true,
+  get: function() {
+    return serializeJson;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _serializejavascript = /* @__PURE__ */ _interop_require_default._(require("serialize-javascript"));
+const serializeJson = (data) => {
+  return (0, _serializejavascript.default)(data, {
+    isJSON: true
+  });
+};

package/dist/cjs/node/storage.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createStorage", {
+  enumerable: true,
+  get: function() {
+    return createStorage;
+  }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _async_hooks = /* @__PURE__ */ _interop_require_wildcard._(require("async_hooks"));
+const createStorage = () => {
+  let storage;
+  if (typeof _async_hooks.AsyncLocalStorage !== "undefined") {
+    storage = new _async_hooks.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
+  };
+};

package/dist/cjs/remixRouter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("@remix-run/router"), exports);

package/dist/cjs/router.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("react-router-dom"), exports);

package/dist/cjs/time.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "time", {
+  enumerable: true,
+  get: function() {
+    return time;
+  }
+});
+function processHrtime(previousTimestamp) {
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  const clocktime = now * 1e-3;
+  let seconds = Math.floor(clocktime);
+  let nanoseconds = Math.floor(clocktime % 1 * 1e9);
+  if (previousTimestamp) {
+    seconds -= previousTimestamp[0];
+    nanoseconds -= previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [
+    seconds,
+    nanoseconds
+  ];
+}
+const getLatency = (hrtime) => {
+  const [s, ns] = processHrtime(hrtime);
+  return s * 1e3 + ns / 1e6;
+};
+const time = () => {
+  const hrtime = processHrtime();
+  return () => {
+    return getLatency(hrtime);
+  };
+};

package/dist/esm/browser/index.js

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

package/dist/esm/browser/nestedRoutes.js

@@ -0,0 +1,163 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { createRoutesFromElements, Outlet, Route } from "react-router-dom";
+import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { time } from "../time";
+export var transformNestedRoutes = function(routes, reporter) {
+  var routeElements = [];
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      var routeElement = renderNestedRoute(route, {
+        reporter: reporter
+      });
+      routeElements.push(routeElement);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return createRoutesFromElements(routeElements);
+};
+export var renderNestedRoute = function(nestedRoute) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var _config, _children;
+  var children = nestedRoute.children, index = nestedRoute.index, id = nestedRoute.id, component = nestedRoute.component, isRoot = nestedRoute.isRoot, lazyImport = nestedRoute.lazyImport, config = nestedRoute.config, handle = nestedRoute.handle;
+  var Component = component;
+  var parent = options.parent, DeferredDataComponent = options.DeferredDataComponent, _options_props = options.props, props = _options_props === void 0 ? {} : _options_props, reporter = options.reporter;
+  var routeProps = {
+    caseSensitive: nestedRoute.caseSensitive,
+    path: nestedRoute.path,
+    id: nestedRoute.id,
+    loader: createLoader(nestedRoute, reporter),
+    action: nestedRoute.action,
+    hasErrorBoundary: nestedRoute.hasErrorBoundary,
+    shouldRevalidate: nestedRoute.shouldRevalidate,
+    handle: _object_spread({}, 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) {
+    var errorElement = /* @__PURE__ */ _jsx(nestedRoute.error, {});
+    routeProps.errorElement = errorElement;
+  }
+  var element;
+  if (Component) {
+    var _parent;
+    if (((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.loading) && lazyImport) {
+      var 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, _object_spread({}, 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;
+    routeProps.element = /* @__PURE__ */ _jsx(Outlet, {});
+  }
+  if (element) {
+    routeProps.element = element;
+  }
+  var childElements = (_children = children) === null || _children === void 0 ? void 0 : _children.map(function(childRoute) {
+    return renderNestedRoute(childRoute, {
+      parent: nestedRoute,
+      reporter: reporter
+    });
+  });
+  var routeElement = index ? /* @__PURE__ */ _jsx(Route, _object_spread_props(_object_spread({}, routeProps), {
+    index: true
+  }), id) : /* @__PURE__ */ _jsx(Route, _object_spread_props(_object_spread({}, routeProps), {
+    index: false,
+    children: childElements
+  }), id);
+  return routeElement;
+};
+function createLoader(route, reporter) {
+  var loader = route.loader;
+  if (loader) {
+    return function() {
+      var _ref = _async_to_generator(function(args) {
+        var end, res, cost, _reporter;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              if (typeof route.lazyImport === "function") {
+                route.lazyImport();
+              }
+              end = time();
+              return [
+                4,
+                loader(args)
+              ];
+            case 1:
+              res = _state.sent();
+              cost = end();
+              if (typeof document === "undefined" && reporter) {
+                ;
+                (_reporter = reporter) === null || _reporter === void 0 ? void 0 : _reporter.reportTiming("".concat(LOADER_REPORTER_NAME, "-").concat(route.id), cost);
+              }
+              return [
+                2,
+                res
+              ];
+          }
+        });
+      });
+      return function(args) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  } else {
+    return function() {
+      if (typeof route.lazyImport === "function") {
+        route.lazyImport();
+      }
+      return null;
+    };
+  }
+}
+function isLoadableComponent(component) {
+  return component && component.displayName === "Loadable" && component.preload && typeof component.preload === "function";
+}