@modern-js/runtime-utils 2.69.4 → 3.0.0-alpha.0

package/dist/esm/universal/request.js

@@ -1,51 +0,0 @@
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-function parseQuery(req) {
-  var query = {};
-  var url = req.url;
-  var q = url.split("?")[1];
-  if (q) {
-    var search = new URLSearchParams(q);
-    search.forEach(function(v, k) {
-      query[k] = v;
-    });
-  }
-  return query;
-}
-function parseHeaders(request) {
-  var headersData = {};
-  request.headers.forEach(function(value, key) {
-    headersData[key] = value;
-  });
-  return headersData;
-}
-function getPathname(request) {
-  var match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
-  return match ? match[1] : "/";
-}
-function getHost(request) {
-  var headers = request.headers;
-  var host = headers.get("X-Forwarded-Host");
-  if (!host) {
-    host = headers.get("Host");
-  }
-  host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
-  return host;
-}
-function parseCookie(req) {
-  var _cookie = req.headers.get("Cookie");
-  var cookie = {};
-  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach(function(item) {
-    var _item_trim_split = _sliced_to_array(item.trim().split("="), 2), k = _item_trim_split[0], v = _item_trim_split[1];
-    if (k) {
-      cookie[k] = v;
-    }
-  });
-  return cookie;
-}
-export {
-  getHost,
-  getPathname,
-  parseCookie,
-  parseHeaders,
-  parseQuery
-};

package/dist/esm/url.js

@@ -1,10 +0,0 @@
-function normalizePathname(pathname) {
-  var normalized = "/" + pathname.replace(/^\/+|\/+$/g, "");
-  if (normalized === "/") {
-    return normalized;
-  }
-  return normalized;
-}
-export {
-  normalizePathname
-};

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

@@ -1,138 +0,0 @@
-function invariant(value, message) {
-  if (value === false || value === null || typeof value === "undefined") {
-    throw new Error(message);
-  }
-}
-class AbortedDeferredError extends Error {
-}
-function isTrackedPromise(value) {
-  return value instanceof Promise && value._tracked === true;
-}
-function unwrapTrackedPromise(value) {
-  if (!isTrackedPromise(value)) {
-    return value;
-  }
-  if (value._error) {
-    throw value._error;
-  }
-  return value._data;
-}
-class DeferredData {
-  trackPromise(key, value) {
-    if (!(value instanceof Promise)) {
-      return value;
-    }
-    this.deferredKeys.push(key);
-    this.pendingKeysSet.add(key);
-    const promise = Promise.race([
-      value,
-      this.abortPromise
-    ]).then((data) => this.onSettle(promise, key, void 0, data), (error) => this.onSettle(promise, key, error));
-    promise.catch(() => {
-    });
-    Object.defineProperty(promise, "_tracked", {
-      get: () => true
-    });
-    return promise;
-  }
-  onSettle(promise, key, error, data) {
-    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
-      this.unlistenAbortSignal();
-      Object.defineProperty(promise, "_error", {
-        get: () => error
-      });
-      return Promise.reject(error);
-    }
-    this.pendingKeysSet.delete(key);
-    if (this.done) {
-      this.unlistenAbortSignal();
-    }
-    if (error === void 0 && data === void 0) {
-      const undefinedError = new Error(`Deferred data for key "${key}" resolved/rejected with \`undefined\`, you must resolve/reject with a value or \`null\`.`);
-      Object.defineProperty(promise, "_error", {
-        get: () => undefinedError
-      });
-      this.emit(false, key);
-      return Promise.reject(undefinedError);
-    }
-    if (data === void 0) {
-      Object.defineProperty(promise, "_error", {
-        get: () => error
-      });
-      this.emit(false, key);
-      return Promise.reject(error);
-    }
-    Object.defineProperty(promise, "_data", {
-      get: () => data
-    });
-    this.emit(false, key);
-    return data;
-  }
-  emit(aborted, settledKey) {
-    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));
-  }
-  subscribe(fn) {
-    this.subscribers.add(fn);
-    return () => this.subscribers.delete(fn);
-  }
-  cancel() {
-    this.controller.abort();
-    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
-    this.emit(true);
-  }
-  async resolveData(signal) {
-    let aborted = false;
-    if (!this.done) {
-      const onAbort = () => this.cancel();
-      signal.addEventListener("abort", onAbort);
-      aborted = await new Promise((resolve) => {
-        this.subscribe((aborted2) => {
-          signal.removeEventListener("abort", onAbort);
-          if (aborted2 || this.done) {
-            resolve(aborted2);
-          }
-        });
-      });
-    }
-    return aborted;
-  }
-  get done() {
-    return this.pendingKeysSet.size === 0;
-  }
-  get unwrappedData() {
-    invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
-    return Object.entries(this.data).reduce((acc, [key, value]) => Object.assign(acc, {
-      [key]: unwrapTrackedPromise(value)
-    }), {});
-  }
-  get pendingKeys() {
-    return Array.from(this.pendingKeysSet);
-  }
-  constructor(data, responseInit) {
-    this.pendingKeysSet = /* @__PURE__ */ new Set();
-    this.subscribers = /* @__PURE__ */ new Set();
-    this.__modern_deferred = true;
-    this.deferredKeys = [];
-    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
-    let reject;
-    this.abortPromise = new Promise((_, r) => reject = r);
-    this.controller = new AbortController();
-    const onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
-    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
-    this.controller.signal.addEventListener("abort", onAbort);
-    this.data = Object.entries(data).reduce((acc, [key, value]) => Object.assign(acc, {
-      [key]: this.trackPromise(key, value)
-    }), {});
-    if (this.done) {
-      this.unlistenAbortSignal();
-    }
-    this.init = responseInit;
-  }
-}
-const activeDeferreds = /* @__PURE__ */ new Map();
-export {
-  AbortedDeferredError,
-  DeferredData,
-  activeDeferreds,
-  invariant
-};

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

@@ -1,142 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
-import { Suspense } from "react";
-import { Outlet, Route, createRoutesFromElements } from "react-router-dom";
-import { time } from "../time";
-import { getAsyncLocalStorage } from "../universal/async_storage";
-import { DeferredData, activeDeferreds as originalActiveDeferreds } from "./deferreds";
-const privateDefer = (data) => {
-  return new DeferredData(data);
-};
-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, handle } = nestedRoute;
-  const Component = component;
-  const { parent, 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__ */ _jsx(Component, {
-        ...props
-      });
-    } 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;
-    routeProps.element = /* @__PURE__ */ _jsx(Outlet, {});
-  }
-  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 isPlainObject(value) {
-  return value != null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
-}
-function createLoader(route) {
-  const { loader } = route;
-  if (loader) {
-    return async (args) => {
-      if (typeof route.lazyImport === "function") {
-        route.lazyImport();
-      }
-      const end = time();
-      const res = await loader(args);
-      const isRouterV7 = process.env._MODERN_ROUTER_VERSION === "v7";
-      if (isRouterV7) {
-        let activeDeferreds = null;
-        if (typeof document === "undefined") {
-          var _getAsyncLocalStorage_useContext, _getAsyncLocalStorage;
-          activeDeferreds = (_getAsyncLocalStorage = getAsyncLocalStorage()) === null || _getAsyncLocalStorage === void 0 ? void 0 : (_getAsyncLocalStorage_useContext = _getAsyncLocalStorage.useContext()) === null || _getAsyncLocalStorage_useContext === void 0 ? void 0 : _getAsyncLocalStorage_useContext.activeDeferreds;
-        } else {
-          activeDeferreds = originalActiveDeferreds;
-        }
-        if (isPlainObject(res)) {
-          const deferredData = privateDefer(res);
-          activeDeferreds.set(route.id, deferredData);
-        }
-      }
-      const cost = end();
-      if (typeof document === "undefined") {
-        var _route_id, _storage_useContext_monitors;
-        const storage = getAsyncLocalStorage();
-        storage === null || storage === void 0 ? void 0 : (_storage_useContext_monitors = storage.useContext().monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.timing(`${LOADER_REPORTER_NAME}-${(_route_id = route.id) === null || _route_id === void 0 ? void 0 : _route_id.replace(/\//g, "_")}`, 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";
-}
-export {
-  renderNestedRoute,
-  transformNestedRoutes
-};

package/dist/esm-node/merge.js

@@ -1,29 +0,0 @@
-function isObject(obj) {
-  return obj && typeof obj === "object" && !Array.isArray(obj);
-}
-function merge(target, ...sources) {
-  if (!sources.length) {
-    return target;
-  }
-  const source = sources.shift();
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        if (!target[key]) {
-          Object.assign(target, {
-            [key]: {}
-          });
-        }
-        merge(target[key], source[key]);
-      } else {
-        Object.assign(target, {
-          [key]: source[key]
-        });
-      }
-    }
-  }
-  return merge(target, ...sources);
-}
-export {
-  merge
-};

package/dist/esm-node/node/fileReader.js

@@ -1,68 +0,0 @@
-import Fs from "@modern-js/utils/fs-extra";
-import { createMemoryStorage } from "./storer";
-class FileReader {
-  async readFile(path, encoding = "utf-8") {
-    const { fs } = this;
-    const _readfile = this._readFileFactory(fs);
-    return _readfile(path, encoding);
-  }
-  async readFileFromSystem(path, encoding = "utf-8") {
-    const _readfile = this._readFileFactory(Fs);
-    return _readfile(path, encoding);
-  }
-  _readFileFactory(fs) {
-    return async (path, encoding = "utf-8") => {
-      const cache = await this.storage.get(path);
-      if (cache === null) {
-        return null;
-      }
-      if (cache) {
-        return this.encodingContent(cache, encoding);
-      }
-      const isExistFile = await new Promise((resolve) => {
-        fs.stat(path, (err, stats) => {
-          if (err) {
-            resolve(false);
-            return;
-          }
-          if (stats.isFile()) {
-            resolve(true);
-          } else {
-            resolve(false);
-          }
-        });
-      });
-      if (isExistFile) {
-        const content = await fs.promises.readFile(path);
-        this.storage.set(path, content);
-        return this.encodingContent(content, encoding);
-      } else {
-        this.storage.set(path, null);
-        return null;
-      }
-    };
-  }
-  /**
-  * Clear the fileCache entriely.
-  */
-  reset(fs) {
-    var _this_storage_clear, _this_storage;
-    fs && (this.fs = fs);
-    return (_this_storage_clear = (_this_storage = this.storage).clear) === null || _this_storage_clear === void 0 ? void 0 : _this_storage_clear.call(_this_storage);
-  }
-  encodingContent(value, encoding) {
-    if (encoding === "utf-8") {
-      return value.toString();
-    }
-    return value;
-  }
-  constructor(storage) {
-    this.fs = Fs;
-    this.storage = storage;
-  }
-}
-const fileReader = new FileReader(createMemoryStorage("__file__system"));
-export {
-  FileReader,
-  fileReader
-};

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

@@ -1,19 +0,0 @@
-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);
-}
-export {
-  LoaderContext,
-  createLoaderContext
-};

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

@@ -1,24 +0,0 @@
-function createRequestContext(context) {
-  const _context = context || /* @__PURE__ */ new Map();
-  function get(key) {
-    if (typeof key === "string") {
-      return _context.get(key);
-    } else {
-      return _context.get(key.symbol) || key.getDefaultValue();
-    }
-  }
-  function set(key, value) {
-    if (typeof key === "string") {
-      _context.set(key, value);
-    } else {
-      _context.set(key.symbol, value);
-    }
-  }
-  return {
-    set,
-    get
-  };
-}
-export {
-  createRequestContext
-};

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

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

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

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

package/dist/esm-node/node/storer/container.js

@@ -1,44 +0,0 @@
-import { LRUCache } from "lru-cache";
-class MemoryContainer {
-  async get(key) {
-    return this.cache.get(key);
-  }
-  async set(key, value) {
-    this.cache.set(key, value);
-    return this;
-  }
-  async has(key) {
-    return this.cache.has(key);
-  }
-  async delete(key) {
-    const exist = await this.has(key);
-    if (exist) {
-      this.cache.delete(key);
-    }
-    return exist;
-  }
-  forEach(callbackFn) {
-    this.cache.forEach((value, key) => {
-      callbackFn(value, key, this);
-    });
-  }
-  constructor({ max, maxAge } = {}) {
-    this.cache = new LRUCache({
-      maxSize: (max || 256) * MemoryContainer.MB,
-      ttl: maxAge || MemoryContainer.hour,
-      sizeCalculation: (value, key) => {
-        return JSON.stringify(value).length;
-      }
-    });
-  }
-}
-MemoryContainer.BYTE = 1;
-MemoryContainer.KB = 1024 * MemoryContainer.BYTE;
-MemoryContainer.MB = 1024 * MemoryContainer.KB;
-MemoryContainer.ms = 1;
-MemoryContainer.second = MemoryContainer.ms * 1e3;
-MemoryContainer.minute = MemoryContainer.second * 60;
-MemoryContainer.hour = MemoryContainer.minute * 60;
-export {
-  MemoryContainer
-};

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

@@ -1,73 +0,0 @@
-class Storage {
-  async keys() {
-    var _this_forEach, _this;
-    const _keys = [];
-    (_this_forEach = (_this = this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this, (_, k) => {
-      _keys.push(k);
-    });
-    return _keys;
-  }
-  async values() {
-    var _this_forEach, _this;
-    const _values = [];
-    (_this_forEach = (_this = this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this, (v) => {
-      _values.push(v);
-    });
-    return _values;
-  }
-  /**
-  * Returns a specified element from the container. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Container.
-  * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
-  */
-  get(key) {
-    const uniqueKey = this.computedUniqueKey(key);
-    return this.container.get(uniqueKey);
-  }
-  /**
-  * Adds a new element with a specified key and value to the storage. If an element with the same key already exists, the element will be updated.
-  */
-  async set(key, value) {
-    const uniqueKey = this.computedUniqueKey(key);
-    await this.container.set(uniqueKey, value);
-    return this;
-  }
-  /**
-  * @returns boolean indicating whether an element with the specified key exists or not.
-  */
-  has(key) {
-    const uniqueKey = this.computedUniqueKey(key);
-    return this.container.has(uniqueKey);
-  }
-  delete(key) {
-    const uniqueKey = this.computedUniqueKey(key);
-    return this.container.delete(uniqueKey);
-  }
-  async clear() {
-    var _this_keys, _this;
-    const keys = await ((_this_keys = (_this = this).keys) === null || _this_keys === void 0 ? void 0 : _this_keys.call(_this));
-    await Promise.all((keys === null || keys === void 0 ? void 0 : keys.map(async (key) => {
-      return this.container.delete(key);
-    })) || []);
-  }
-  forEach(fallbackFn) {
-    var _this_container_forEach, _this_container;
-    (_this_container_forEach = (_this_container = this.container).forEach) === null || _this_container_forEach === void 0 ? void 0 : _this_container_forEach.call(_this_container, (v, k) => {
-      if (this.checkIsOwnkey(k)) {
-        fallbackFn(v, k, this);
-      }
-    });
-  }
-  computedUniqueKey(k) {
-    return `${this.namespace}:${k}`;
-  }
-  checkIsOwnkey(k) {
-    return k.startsWith(this.namespace);
-  }
-  constructor(namespace, container) {
-    this.namespace = namespace;
-    this.container = container;
-  }
-}
-export {
-  Storage
-};

package/dist/esm-node/node/stream.js

@@ -1,80 +0,0 @@
-import { Stream } from "stream";
-const createReadableStreamFromReadable = (source) => {
-  const pump = new StreamPump(source);
-  const stream = new ReadableStream(pump, pump);
-  return stream;
-};
-class StreamPump {
-  size(chunk) {
-    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
-  }
-  start(controller) {
-    this.controller = controller;
-    this.stream.on("data", this.enqueue);
-    this.stream.once("error", this.error);
-    this.stream.once("end", this.close);
-    this.stream.once("close", this.close);
-  }
-  pull() {
-    this.resume();
-  }
-  cancel(reason) {
-    if (this.stream.destroy) {
-      this.stream.destroy(reason);
-    }
-    process.nextTick(() => {
-      this.stream.off("data", this.enqueue);
-      this.stream.off("error", this.error);
-      this.stream.off("end", this.close);
-      this.stream.off("close", this.close);
-    });
-  }
-  enqueue(chunk) {
-    if (this.controller) {
-      try {
-        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
-        this.controller.enqueue(bytes);
-        if (available <= 0) {
-          this.pause();
-        }
-      } catch (error) {
-        this.controller.error(new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
-        this.cancel();
-      }
-    }
-  }
-  pause() {
-    if (this.stream.pause) {
-      this.stream.pause();
-    }
-  }
-  resume() {
-    if (this.stream.readable && this.stream.resume) {
-      this.stream.resume();
-    }
-  }
-  close() {
-    if (this.controller) {
-      this.controller.close();
-      delete this.controller;
-    }
-  }
-  error(error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
-  constructor(stream) {
-    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
-    this.accumalatedSize = 0;
-    this.stream = stream;
-    this.enqueue = this.enqueue.bind(this);
-    this.error = this.error.bind(this);
-    this.close = this.close.bind(this);
-  }
-}
-export {
-  createReadableStreamFromReadable
-};