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

package/dist/esm/browser/parsed.js

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

package/dist/esm/node/index.js

@@ -0,0 +1,6 @@
+import { createStorage } from "./storage";
+var _createStorage = createStorage(), run = _createStorage.run, useHeaders = _createStorage.useContext;
+export { run, useHeaders };
+export { serializeJson } from "./serialize";
+export * from "./nestedRoutes";
+export * from "./loaderContext";

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

@@ -0,0 +1,20 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+export var LoaderContext = /* @__PURE__ */ function() {
+  "use strict";
+  function LoaderContext2(defaultValue) {
+    _class_call_check(this, LoaderContext2);
+    this.defaultValue = defaultValue;
+    this.symbol = Symbol("loaderContext");
+  }
+  var _proto = LoaderContext2.prototype;
+  _proto.getDefaultValue = function getDefaultValue() {
+    if (!this.defaultValue) {
+      throw new Error("Can't get defaultValue before initialed");
+    }
+    return this.defaultValue;
+  };
+  return LoaderContext2;
+}();
+export function createLoaderContext(defaultValue) {
+  return new LoaderContext(defaultValue);
+}

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

@@ -0,0 +1,24 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+export var RequestContext = /* @__PURE__ */ function() {
+  "use strict";
+  function RequestContext2() {
+    _class_call_check(this, RequestContext2);
+    this.store = /* @__PURE__ */ new Map();
+  }
+  var _proto = RequestContext2.prototype;
+  _proto.get = function get(loaderCtx) {
+    var symbol = loaderCtx.symbol;
+    if (this.store.get(symbol)) {
+      return this.store.get(symbol);
+    }
+    return loaderCtx.getDefaultValue();
+  };
+  _proto.set = function set(loaderCtx, value) {
+    var symbol = loaderCtx.symbol;
+    this.store.set(symbol, value);
+  };
+  return RequestContext2;
+}();
+export function createRequestContext() {
+  return new RequestContext();
+}

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

@@ -0,0 +1,3 @@
+import { createLoaderContext } from "./createLoaderCtx";
+export { createRequestContext } from "./createRequestCtx";
+export var reporterCtx = createLoaderContext();

package/dist/esm/node/nestedRoutes.js

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

package/dist/esm/node/router.js

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

package/dist/esm/node/serialize.js

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

package/dist/esm/node/storage.js

@@ -0,0 +1,36 @@
+import * as ah from "async_hooks";
+var createStorage = function() {
+  var storage;
+  if (typeof ah.AsyncLocalStorage !== "undefined") {
+    storage = new ah.AsyncLocalStorage();
+  }
+  var run = function(context, cb) {
+    if (!storage) {
+      throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
+    }
+    return new Promise(function(resolve, reject) {
+      storage.run(context, function() {
+        try {
+          return resolve(cb());
+        } catch (error) {
+          return reject(error);
+        }
+      });
+    });
+  };
+  var useContext = function() {
+    if (!storage) {
+      throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
+    }
+    var 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: run,
+    useContext: useContext
+  };
+};
+export { createStorage };

package/dist/esm/remixRouter.js

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

package/dist/esm/router.js

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

package/dist/esm/time.js

@@ -0,0 +1,29 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+function processHrtime(previousTimestamp) {
+  var now = (/* @__PURE__ */ new Date()).getTime();
+  var clocktime = now * 1e-3;
+  var seconds = Math.floor(clocktime);
+  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
+  if (previousTimestamp) {
+    seconds -= previousTimestamp[0];
+    nanoseconds -= previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [
+    seconds,
+    nanoseconds
+  ];
+}
+var getLatency = function(hrtime) {
+  var _processHrtime = _sliced_to_array(processHrtime(hrtime), 2), s = _processHrtime[0], ns = _processHrtime[1];
+  return s * 1e3 + ns / 1e6;
+};
+export var time = function() {
+  var hrtime = processHrtime();
+  return function() {
+    return getLatency(hrtime);
+  };
+};

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

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

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

@@ -0,0 +1,129 @@
+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 const transformNestedRoutes = (routes, reporter) => {
+  const routeElements = [];
+  for (const route of routes) {
+    const routeElement = renderNestedRoute(route, {
+      reporter
+    });
+    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 = {}, 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__ */ _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;
+    routeProps.element = /* @__PURE__ */ _jsx(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__ */ _jsx(Route, {
+    ...routeProps,
+    index: true
+  }, id) : /* @__PURE__ */ _jsx(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 = 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(`${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/esm-node/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/node/index.js

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

package/dist/esm-node/node/loaderContext/createLoaderCtx.js

@@ -0,0 +1,15 @@
+export 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");
+  }
+}
+export function createLoaderContext(defaultValue) {
+  return new LoaderContext(defaultValue);
+}

package/dist/esm-node/node/loaderContext/createRequestCtx.js

@@ -0,0 +1,19 @@
+export 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();
+  }
+}
+export function createRequestContext() {
+  return new RequestContext();
+}

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

@@ -0,0 +1,3 @@
+import { createLoaderContext } from "./createLoaderCtx";
+export { createRequestContext } from "./createRequestCtx";
+export const reporterCtx = createLoaderContext();

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

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

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

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

package/dist/esm-node/router.js

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

package/dist/esm-node/time.js

@@ -0,0 +1,28 @@
+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;
+};
+export const time = () => {
+  const hrtime = processHrtime();
+  return () => {
+    return getLatency(hrtime);
+  };
+};

package/dist/types/browser/index.d.ts

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

package/dist/types/browser/nestedRoutes.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { NestedRoute, Reporter } from '@modern-js/types';
+export declare const transformNestedRoutes: (routes: NestedRoute[], reporter: Reporter) => import("react-router-dom").RouteObject[];
+type DeferredDataComponentType = (props?: {
+  nonce?: string;
+}) => JSX.Element | null;
+export declare const renderNestedRoute: (nestedRoute: NestedRoute, options?: {
+  parent?: NestedRoute;
+  DeferredDataComponent?: DeferredDataComponentType;
+  props?: Record<string, any>;
+  reporter?: Reporter;
+}) => JSX.Element;
+export {};

package/dist/types/browser/parsed.d.ts

@@ -0,0 +1 @@
+export declare const parsedJSONFromElement: (id: string) => any;

package/dist/types/node/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/**
+ * ssr helpers
+ */
+import type { IncomingHttpHeaders } from 'http';
+declare const run: <O>(context: IncomingHttpHeaders, cb: () => O | Promise<O>) => Promise<O>, useHeaders: () => IncomingHttpHeaders;
+export { run, useHeaders };
+export { serializeJson } from './serialize';
+export * from './nestedRoutes';
+export * from './loaderContext';

package/dist/types/node/loaderContext/createLoaderCtx.d.ts

@@ -0,0 +1,7 @@
+export declare class LoaderContext<T = unknown> {
+  symbol: symbol;
+  private defaultValue?;
+  constructor(defaultValue?: T);
+  getDefaultValue(): T;
+}
+export declare function createLoaderContext<T = unknown>(defaultValue?: T): LoaderContext<T>;

package/dist/types/node/loaderContext/createRequestCtx.d.ts

@@ -0,0 +1,7 @@
+import { LoaderContext } from './createLoaderCtx';
+export declare class RequestContext {
+  private store;
+  get<T>(loaderCtx: LoaderContext<T>): T;
+  set<T = unknown>(loaderCtx: LoaderContext, value: T): void;
+}
+export declare function createRequestContext(): RequestContext;

package/dist/types/node/loaderContext/index.d.ts

@@ -0,0 +1,4 @@
+import type { Reporter } from '@modern-js/types';
+export { createRequestContext, type RequestContext } from './createRequestCtx';
+export type { LoaderContext } from './createLoaderCtx';
+export declare const reporterCtx: import("./createLoaderCtx").LoaderContext<Reporter>;

package/dist/types/node/nestedRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { ModernServerContext, ServerRoute } from '@modern-js/types';
+export type ServerContext = Pick<ModernServerContext, 'logger' | 'req' | 'reporter' | 'res' | 'params' | 'headers' | 'method' | 'url' | 'host' | 'protocol' | 'origin' | 'href' | 'path' | 'query'>;
+export declare const matchEntry: (pathname: string, entries: ServerRoute[]) => ServerRoute | undefined;

package/dist/types/node/router.d.ts

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

package/dist/types/node/serialize.d.ts

@@ -0,0 +1 @@
+export declare const serializeJson: (data: any) => string;

package/dist/types/node/storage.d.ts

@@ -0,0 +1,5 @@
+declare const createStorage: <T>() => {
+  run: <O>(context: T, cb: () => O | Promise<O>) => Promise<O>;
+  useContext: () => T;
+};
+export { createStorage };

package/dist/types/remixRouter.d.ts

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

package/dist/types/router.d.ts

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

package/dist/types/time.d.ts

@@ -0,0 +1 @@
+export declare const time: () => () => number;