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

package/dist/cjs/universal/request.js

@@ -1,78 +1,86 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var request_exports = {};
-__export(request_exports, {
-  getHost: () => getHost,
-  getPathname: () => getPathname,
-  parseCookie: () => parseCookie,
-  parseHeaders: () => parseHeaders,
-  parseQuery: () => parseQuery
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getHost: ()=>getHost,
+    getPathname: ()=>getPathname,
+    parseCookie: ()=>parseCookie,
+    parseHeaders: ()=>parseHeaders,
+    parseQuery: ()=>parseQuery
 });
-module.exports = __toCommonJS(request_exports);
 function parseQuery(req) {
-  const query = {};
-  const { url } = req;
-  const q = url.split("?")[1];
-  if (q) {
-    const search = new URLSearchParams(q);
-    search.forEach((v, k) => {
-      query[k] = v;
-    });
-  }
-  return query;
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
 }
 function parseHeaders(request) {
-  const headersData = {};
-  request.headers.forEach((value, key) => {
-    headersData[key] = value;
-  });
-  return headersData;
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
 }
 function getPathname(request) {
-  const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
-  return match ? match[1] : "/";
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match ? match[1] : '/';
 }
 function getHost(request) {
-  const { headers } = request;
-  let 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;
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
 }
 function parseCookie(req) {
-  const _cookie = req.headers.get("Cookie");
-  const cookie = {};
-  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach((item) => {
-    const [k, v] = item.trim().split("=");
-    if (k) {
-      cookie[k] = v;
-    }
-  });
-  return cookie;
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k) cookie[k] = v;
+    });
+    return cookie;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getHost,
-  getPathname,
-  parseCookie,
-  parseHeaders,
-  parseQuery
+exports.getHost = __webpack_exports__.getHost;
+exports.getPathname = __webpack_exports__.getPathname;
+exports.parseCookie = __webpack_exports__.parseCookie;
+exports.parseHeaders = __webpack_exports__.parseHeaders;
+exports.parseQuery = __webpack_exports__.parseQuery;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getHost",
+    "getPathname",
+    "parseCookie",
+    "parseHeaders",
+    "parseQuery"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/url.js

@@ -1,34 +1,39 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var url_exports = {};
-__export(url_exports, {
-  normalizePathname: () => normalizePathname
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizePathname: ()=>normalizePathname
 });
-module.exports = __toCommonJS(url_exports);
 function normalizePathname(pathname) {
-  const normalized = "/" + pathname.replace(/^\/+|\/+$/g, "");
-  if (normalized === "/") {
+    const normalized = '/' + pathname.replace(/^\/+|\/+$/g, '');
     return normalized;
-  }
-  return normalized;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  normalizePathname
+exports.normalizePathname = __webpack_exports__.normalizePathname;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizePathname"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/esm/browser/deferreds.mjs

@@ -0,0 +1,118 @@
+function invariant(value, message) {
+    if (false === value || null == value) throw new Error(message);
+}
+class AbortedDeferredError extends Error {
+}
+function isTrackedPromise(value) {
+    return value instanceof Promise && true === value._tracked;
+}
+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 (void 0 === error && void 0 === data) {
+            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 (void 0 === data) {
+            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((aborted)=>{
+                    signal.removeEventListener('abort', onAbort);
+                    if (aborted || this.done) resolve(aborted);
+                });
+            });
+        }
+        return aborted;
+    }
+    get done() {
+        return 0 === this.pendingKeysSet.size;
+    }
+    get unwrappedData() {
+        invariant(null !== this.data && 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 = new Set();
+        this.subscribers = new Set();
+        this.__modern_deferred = true;
+        this.deferredKeys = [];
+        invariant(data && 'object' == typeof data && !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 = new Map();
+export { AbortedDeferredError, DeferredData, activeDeferreds, invariant };

package/dist/esm/browser/nestedRoutes.mjs

@@ -0,0 +1,104 @@
+import { 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";
+import { time } from "../time";
+import { getAsyncLocalStorage } from "../universal/async_storage";
+import { DeferredData, activeDeferreds as external_deferreds_activeDeferreds } from "./deferreds";
+const privateDefer = (data)=>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,
+            ...'object' == typeof config ? 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?.loading && lazyImport) {
+        const Loading = parent.loading;
+        element = isLoadableComponent(Component) ? /*#__PURE__*/ jsx(Component, {
+            fallback: /*#__PURE__*/ jsx(Loading, {})
+        }) : /*#__PURE__*/ jsx(Suspense, {
+            fallback: /*#__PURE__*/ jsx(Loading, {}),
+            children: /*#__PURE__*/ jsx(Component, {})
+        });
+    } else element = isLoadableComponent(Component) && lazyImport ? /*#__PURE__*/ jsx(Component, {}) : isRoot ? /*#__PURE__*/ jsx(Component, {
+        ...props
+    }) : lazyImport ? /*#__PURE__*/ jsx(Suspense, {
+        fallback: null,
+        children: /*#__PURE__*/ jsx(Component, {})
+    }) : /*#__PURE__*/ jsx(Component, {});
+    else {
+        nestedRoute.loading = parent?.loading;
+        routeProps.element = /*#__PURE__*/ jsx(Outlet, {});
+    }
+    if (element) routeProps.element = element;
+    const childElements = children?.map((childRoute)=>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 null != value && 'object' == typeof value && Object.getPrototypeOf(value) === Object.prototype;
+}
+function createLoader(route) {
+    const { loader } = route;
+    if (loader) return async (args)=>{
+        if ('function' == typeof route.lazyImport) route.lazyImport();
+        const end = time();
+        const res = await loader(args);
+        let activeDeferreds = null;
+        activeDeferreds = "u" < typeof document ? (await getAsyncLocalStorage())?.useContext()?.activeDeferreds : external_deferreds_activeDeferreds;
+        if (isPlainObject(res)) {
+            const deferredData = privateDefer(res);
+            activeDeferreds.set(route.id, deferredData);
+        }
+        const cost = end();
+        if ("u" < typeof document) {
+            const storage = await getAsyncLocalStorage();
+            storage?.useContext().monitors?.timing(`${LOADER_REPORTER_NAME}-${route.id?.replace(/\//g, '_')}`, cost);
+        }
+        return res;
+    };
+    return ()=>{
+        if ('function' == typeof route.lazyImport) route.lazyImport();
+        return null;
+    };
+}
+function isLoadableComponent(component) {
+    return component && 'Loadable' === component.displayName && component.preload && 'function' == typeof component.preload;
+}
+export { renderNestedRoute, transformNestedRoutes };

package/dist/esm/merge.mjs

@@ -0,0 +1,26 @@
+function isObject(obj) {
+    return obj && 'object' == typeof obj && !Array.isArray(obj);
+}
+function isComplexInstance(obj) {
+    if (!isObject(obj)) return false;
+    const hasMethods = 'function' == typeof obj.init || 'function' == typeof obj.changeLanguage || 'function' == typeof obj.t;
+    const hasInternalProps = void 0 !== obj.isInitialized || void 0 !== obj.language || void 0 !== obj.store;
+    return hasMethods || hasInternalProps;
+}
+function merge(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) for(const key in source)if (isComplexInstance(source[key])) Object.assign(target, {
+        [key]: source[key]
+    });
+    else 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/fileReader.mjs

@@ -0,0 +1,47 @@
+import fs_extra 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_extra);
+        return _readfile(path, encoding);
+    }
+    _readFileFactory(fs) {
+        return async (path, encoding = 'utf-8')=>{
+            const cache = await this.storage.get(path);
+            if (null === cache) return null;
+            if (cache) return this.encodingContent(cache, encoding);
+            const isExistFile = await new Promise((resolve)=>{
+                fs.stat(path, (err, stats)=>{
+                    if (err) return void resolve(false);
+                    stats.isFile() ? resolve(true) : resolve(false);
+                });
+            });
+            if (isExistFile) {
+                const content = await fs.promises.readFile(path);
+                this.storage.set(path, content);
+                return this.encodingContent(content, encoding);
+            }
+            this.storage.set(path, null);
+            return null;
+        };
+    }
+    reset(fs) {
+        fs && (this.fs = fs);
+        return this.storage.clear?.();
+    }
+    encodingContent(value, encoding) {
+        if ('utf-8' === encoding) return value.toString();
+        return value;
+    }
+    constructor(storage){
+        this.fs = fs_extra;
+        this.storage = storage;
+    }
+}
+const fileReader = new FileReader(createMemoryStorage('__file__system'));
+export { FileReader, fileReader };

package/dist/{esm-node/node/index.js → esm/node/index.mjs}

@@ -1,8 +1,5 @@
-import { storage } from "../universal/async_storage.server";
+import { storage } from "../universal/async_storage.server.mjs";
 import { serializeJson } from "./serialize";
 export * from "./loaderContext";
 export * from "./stream";
-export {
-  serializeJson,
-  storage
-};
+export { serializeJson, storage };

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

@@ -0,0 +1,14 @@
+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/loaderContext/createRequestCtx.mjs

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

package/dist/{esm-node/node/loaderContext/index.js → esm/node/loaderContext/index.mjs}

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

package/dist/esm/node/serialize.mjs

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

package/dist/esm/node/storer/container.mjs

@@ -0,0 +1,38 @@
+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)=>JSON.stringify(value).length
+        });
+    }
+}
+MemoryContainer.BYTE = 1;
+MemoryContainer.KB = 1024 * MemoryContainer.BYTE;
+MemoryContainer.MB = 1024 * MemoryContainer.KB;
+MemoryContainer.ms = 1;
+MemoryContainer.second = 1000 * MemoryContainer.ms;
+MemoryContainer.minute = 60 * MemoryContainer.second;
+MemoryContainer.hour = 60 * MemoryContainer.minute;
+export { MemoryContainer };

package/dist/{esm-node/node/storer/index.js → esm/node/storer/index.mjs}

@@ -1,11 +1,7 @@
 import { MemoryContainer } from "./container";
 import { Storage } from "./storage";
-import { Storage as Storage2 } from "./storage";
 const memoryContainer = new MemoryContainer();
 function createMemoryStorage(namespace) {
-  return new Storage(namespace, memoryContainer);
+    return new Storage(namespace, memoryContainer);
 }
-export {
-  Storage2 as Storage,
-  createMemoryStorage
-};
+export { Storage, createMemoryStorage };