@bleedingdev/modern-js-runtime-utils 3.2.0-ultramodern.0

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

@@ -0,0 +1,15 @@
+import "node:module";
+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.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+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.mjs

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

package/dist/esm-node/node/nestedRoutes.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "../server/nestedRoutes.mjs";

package/dist/esm-node/node/sanitize.mjs

@@ -0,0 +1,67 @@
+import "node:module";
+const DEFAULT_UNSAFE_SSR_HEADERS = [
+    'authorization',
+    'proxy-authorization',
+    'cookie',
+    'set-cookie',
+    'x-api-key',
+    'x-auth-token',
+    'x-csrf-token',
+    'x-xsrf-token',
+    'x-forwarded-client-cert',
+    'cf-access-jwt-assertion'
+];
+const isPlainObject = (value)=>{
+    if (null === value || 'object' != typeof value) return false;
+    const proto = Object.getPrototypeOf(value);
+    return null === proto || proto === Object.prototype;
+};
+const isHeaderContainerKey = (key)=>{
+    const normalized = key.toLowerCase();
+    return 'headers' === normalized || normalized.endsWith('headers');
+};
+const normalizeHeaderName = (header)=>header.trim().toLowerCase();
+const createUnsafeHeaderSet = (unsafeHeaders = [])=>{
+    const headers = new Set(DEFAULT_UNSAFE_SSR_HEADERS);
+    for (const header of unsafeHeaders){
+        const normalized = normalizeHeaderName(header);
+        if (normalized) headers.add(normalized);
+    }
+    return headers;
+};
+const sanitizeSSRPayload = (payload, options = {})=>{
+    const removed = [];
+    const visited = new WeakMap();
+    const unsafeHeaderSet = createUnsafeHeaderSet(options.unsafeHeaders);
+    const walk = (value, path, insideHeaderContainer)=>{
+        if (Array.isArray(value)) {
+            const cached = visited.get(value);
+            if (cached) return cached;
+            const next = [];
+            visited.set(value, next);
+            value.forEach((item, index)=>{
+                next.push(walk(item, `${path}[${index}]`, insideHeaderContainer));
+            });
+            return next;
+        }
+        if (!isPlainObject(value)) return value;
+        const cached = visited.get(value);
+        if (cached) return cached;
+        const next = {};
+        visited.set(value, next);
+        for (const [key, currentValue] of Object.entries(value)){
+            const nextPath = path ? `${path}.${key}` : key;
+            if (insideHeaderContainer && unsafeHeaderSet.has(normalizeHeaderName(key))) {
+                removed.push(nextPath);
+                continue;
+            }
+            next[key] = walk(currentValue, nextPath, isHeaderContainerKey(key));
+        }
+        return next;
+    };
+    return {
+        payload: walk(payload, '', options.treatRootAsHeaders ?? false),
+        removed
+    };
+};
+export { DEFAULT_UNSAFE_SSR_HEADERS, sanitizeSSRPayload };

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

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

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

@@ -0,0 +1,39 @@
+import "node:module";
+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.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+import { MemoryContainer } from "./container.mjs";
+import { Storage } from "./storage.mjs";
+const memoryContainer = new MemoryContainer();
+function createMemoryStorage(namespace) {
+    return new Storage(namespace, memoryContainer);
+}
+export { Storage, createMemoryStorage };

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

@@ -0,0 +1,54 @@
+import "node:module";
+class Storage {
+    async keys() {
+        const _keys = [];
+        this.forEach?.((_, k)=>{
+            _keys.push(k);
+        });
+        return _keys;
+    }
+    async values() {
+        const _values = [];
+        this.forEach?.((v)=>{
+            _values.push(v);
+        });
+        return _values;
+    }
+    get(key) {
+        const uniqueKey = this.computedUniqueKey(key);
+        return this.container.get(uniqueKey);
+    }
+    async set(key, value) {
+        const uniqueKey = this.computedUniqueKey(key);
+        await this.container.set(uniqueKey, value);
+        return this;
+    }
+    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() {
+        const keys = await this.keys?.();
+        await Promise.all(keys?.map(async (key)=>this.container.delete(key)) || []);
+    }
+    forEach(fallbackFn) {
+        this.container.forEach?.((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/parsed.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+const parsedJSONFromElement = (id)=>{
+    const elements = document.querySelectorAll(`#${id}`);
+    if (0 === elements.length) return;
+    const element = elements[elements.length - 1];
+    if (element) try {
+        const parsed = JSON.parse(element?.textContent || '');
+        return parsed;
+    } catch (e) {
+        console.error(`parse ${id} error`, e);
+    }
+};
+export { parsedJSONFromElement };

package/dist/esm-node/router.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+export * from "react-router";
+const DEFERRED_SYMBOL = Symbol('deferred');
+const json = (data, init)=>{
+    const responseInit = init ? 'number' == typeof init ? {
+        status: init
+    } : init : void 0;
+    return new Response(JSON.stringify(data), responseInit);
+};
+const defer = (data, init)=>{
+    if (void 0 === init) return data;
+    {
+        const responseInit = init ? 'number' == typeof init ? {
+            status: init
+        } : init : void 0;
+        return new Response(JSON.stringify(data), responseInit);
+    }
+};
+export { DEFERRED_SYMBOL, defer, json };

package/dist/esm-node/rsc.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "react-router";

package/dist/esm-node/server/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./nestedRoutes.mjs";

package/dist/esm-node/server/nestedRoutes.mjs

@@ -0,0 +1,16 @@
+import "node:module";
+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));
+};
+export { matchEntry };

package/dist/esm-node/time.mjs

@@ -0,0 +1,28 @@
+import "node:module";
+function processHrtime(previousTimestamp) {
+    const now = new Date().getTime();
+    const clocktime = 1e-3 * now;
+    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 1e3 * s + ns / 1e6;
+};
+const time = ()=>{
+    const hrtime = processHrtime();
+    return ()=>getLatency(hrtime);
+};
+export { time };

package/dist/esm-node/universal/async_storage.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+const isBrowser = "u" > typeof window && void 0 !== window.document;
+const IS_WEB_FALLBACK = "u" > typeof IS_WEB ? IS_WEB : isBrowser;
+const getAsyncLocalStorage = async ()=>{
+    if (isBrowser) {
+        console.error('You should not get async storage in browser');
+        return null;
+    }
+    if (!IS_WEB_FALLBACK) try {
+        const serverStorage = await import("./async_storage.server.mjs");
+        return serverStorage.getAsyncLocalStorage();
+    } catch (extensionError) {
+        try {
+            const serverStorage = await import("./async_storage.server");
+            return serverStorage.getAsyncLocalStorage();
+        } catch (fallbackError) {
+            console.error('Failed to load server async storage', {
+                extensionError: extensionError instanceof Error ? extensionError.message : extensionError,
+                fallbackError: fallbackError instanceof Error ? fallbackError.message : fallbackError
+            });
+        }
+    }
+    return null;
+};
+export { getAsyncLocalStorage };

package/dist/esm-node/universal/async_storage.server.mjs

@@ -0,0 +1,33 @@
+import "node:module";
+import * as __rspack_external_async_hooks from "async_hooks";
+const createStorage = ()=>{
+    let storage;
+    if (void 0 !== __rspack_external_async_hooks.AsyncLocalStorage) storage = new __rspack_external_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/runtime-utils is a single version in node_modules");
+        return context;
+    };
+    return {
+        run,
+        useContext
+    };
+};
+const async_storage_server_storage = createStorage();
+const getAsyncLocalStorage = async ()=>async_storage_server_storage;
+export { async_storage_server_storage as storage, getAsyncLocalStorage };