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

package/dist/esm-node/parsed.js

@@ -1,20 +0,0 @@
-const parsedJSONFromElement = (id) => {
-  const elements = document.querySelectorAll(`#${id}`);
-  if (elements.length === 0) {
-    return void 0;
-  }
-  const element = elements[elements.length - 1];
-  if (element) {
-    try {
-      const parsed = JSON.parse((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;
-};
-export {
-  parsedJSONFromElement
-};

package/dist/esm-node/remixRouter.js

@@ -1,7 +0,0 @@
-export * from "@remix-run/router";
-import * as remixRouter from "@remix-run/router";
-const symbolName = "UNSAFE_DEFERRED_SYMBOL";
-const DEFERRED_SYMBOL = symbolName in remixRouter ? remixRouter[symbolName] : Symbol("deferred");
-export {
-  DEFERRED_SYMBOL
-};

package/dist/esm-node/router.js

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

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

@@ -1,21 +0,0 @@
-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.js

@@ -1,31 +0,0 @@
-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);
-  };
-};
-export {
-  time
-};

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

@@ -1,18 +0,0 @@
-const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
-const getAsyncLocalStorage = () => {
-  if (isBrowser) {
-    console.error("You should not get async storage in browser");
-    return null;
-  } else {
-    try {
-      const serverStorage = require("./async_storage.server");
-      return serverStorage.getAsyncLocalStorage();
-    } catch (err) {
-      console.error("Failed to load server async storage", err);
-      return null;
-    }
-  }
-};
-export {
-  getAsyncLocalStorage
-};

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

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

package/dist/esm-node/universal/cache.js

@@ -1,401 +0,0 @@
-import { LRUCache } from "lru-cache";
-import { getAsyncLocalStorage } from "./async_storage";
-const CacheSize = {
-  KB: 1024,
-  MB: 1024 * 1024,
-  GB: 1024 * 1024 * 1024
-};
-const CacheTime = {
-  SECOND: 1e3,
-  MINUTE: 60 * 1e3,
-  HOUR: 60 * 60 * 1e3,
-  DAY: 24 * 60 * 60 * 1e3,
-  WEEK: 7 * 24 * 60 * 60 * 1e3,
-  MONTH: 30 * 24 * 60 * 60 * 1e3
-};
-function estimateObjectSize(data) {
-  const type = typeof data;
-  if (type === "number")
-    return 8;
-  if (type === "boolean")
-    return 4;
-  if (type === "string")
-    return Math.max(data.length * 2, 1);
-  if (data === null || data === void 0)
-    return 1;
-  if (ArrayBuffer.isView(data)) {
-    return Math.max(data.byteLength, 1);
-  }
-  if (Array.isArray(data)) {
-    return Math.max(data.reduce((acc, item) => acc + estimateObjectSize(item), 0), 1);
-  }
-  if (data instanceof Map || data instanceof Set) {
-    return 1024;
-  }
-  if (data instanceof Date) {
-    return 8;
-  }
-  if (type === "object") {
-    return Math.max(Object.entries(data).reduce((acc, [key, value]) => acc + key.length * 2 + estimateObjectSize(value), 0), 1);
-  }
-  return 1;
-}
-class MemoryContainer {
-  async get(key) {
-    return this.lru.get(key);
-  }
-  async set(key, value, options) {
-    if (options === null || options === void 0 ? void 0 : options.ttl) {
-      this.lru.set(key, value, {
-        ttl: options.ttl * 1e3
-      });
-    } else {
-      this.lru.set(key, value);
-    }
-  }
-  async has(key) {
-    return this.lru.has(key);
-  }
-  async delete(key) {
-    return this.lru.delete(key);
-  }
-  async clear() {
-    this.lru.clear();
-  }
-  constructor(options) {
-    var _options_maxSize;
-    this.lru = new LRUCache({
-      maxSize: (_options_maxSize = options === null || options === void 0 ? void 0 : options.maxSize) !== null && _options_maxSize !== void 0 ? _options_maxSize : CacheSize.GB,
-      sizeCalculation: estimateObjectSize,
-      updateAgeOnGet: true,
-      updateAgeOnHas: true
-    });
-  }
-}
-const isServer = typeof window === "undefined";
-const requestCacheMap = /* @__PURE__ */ new WeakMap();
-const TAG_PREFIX = "tag:";
-const CACHE_PREFIX = "modernjs_cache:";
-const ongoingRevalidations = /* @__PURE__ */ new Map();
-let storage;
-let cacheConfig = {
-  maxSize: CacheSize.GB
-};
-function getStorage() {
-  if (storage) {
-    return storage;
-  }
-  if (cacheConfig.container) {
-    storage = cacheConfig.container;
-  } else {
-    storage = new MemoryContainer({
-      maxSize: cacheConfig.maxSize
-    });
-  }
-  return storage;
-}
-function configureCache(config) {
-  cacheConfig = {
-    ...cacheConfig,
-    ...config
-  };
-  storage = void 0;
-}
-function generateKey(args) {
-  return JSON.stringify(args, (_, value) => {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      return Object.keys(value).sort().reduce((result, key) => {
-        result[key] = value[key];
-        return result;
-      }, {});
-    }
-    return value;
-  });
-}
-function generateStableFunctionId(fn) {
-  const fnString = fn.toString();
-  let hash = 0;
-  for (let i = 0; i < fnString.length; i++) {
-    const char = fnString.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return `fn_${fn.name || "anonymous"}_${Math.abs(hash).toString(36)}`;
-}
-function cache(fn, options) {
-  return async (...args) => {
-    if (isServer && typeof options === "undefined") {
-      var _storage_useContext;
-      const storage2 = getAsyncLocalStorage();
-      const request = storage2 === null || storage2 === void 0 ? void 0 : (_storage_useContext = storage2.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
-      if (request) {
-        let shouldDisableCaching = false;
-        if (cacheConfig.unstable_shouldDisable) {
-          shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
-            request
-          });
-        }
-        if (shouldDisableCaching) {
-          return fn(...args);
-        }
-        let requestCache = requestCacheMap.get(request);
-        if (!requestCache) {
-          requestCache = /* @__PURE__ */ new Map();
-          requestCacheMap.set(request, requestCache);
-        }
-        let fnCache = requestCache.get(fn);
-        if (!fnCache) {
-          fnCache = /* @__PURE__ */ new Map();
-          requestCache.set(fn, fnCache);
-        }
-        const key = generateKey(args);
-        if (fnCache.has(key)) {
-          return fnCache.get(key);
-        }
-        const promise = fn(...args);
-        fnCache.set(key, promise);
-        try {
-          const data = await promise;
-          return data;
-        } catch (error) {
-          fnCache.delete(key);
-          throw error;
-        }
-      }
-    } else if (typeof options !== "undefined") {
-      try {
-        const { tag, maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey, unstable_shouldCache } = options;
-        let missReason;
-        const currentStorage = getStorage();
-        const now = Date.now();
-        const tags = tag ? Array.isArray(tag) ? tag : [
-          tag
-        ] : [];
-        const genKey = getKey ? getKey(...args) : generateKey(args);
-        let finalKey;
-        if (customKey) {
-          finalKey = customKey({
-            params: args,
-            fn,
-            generatedKey: genKey
-          });
-        } else {
-          const functionId = generateStableFunctionId(fn);
-          finalKey = `${functionId}:${genKey}`;
-        }
-        const storageKey = `${CACHE_PREFIX}${finalKey}`;
-        let shouldDisableCaching = false;
-        if (isServer && cacheConfig.unstable_shouldDisable) {
-          var _asyncStorage_useContext;
-          const asyncStorage = getAsyncLocalStorage();
-          const request = asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext = asyncStorage.useContext()) === null || _asyncStorage_useContext === void 0 ? void 0 : _asyncStorage_useContext.request;
-          if (request) {
-            shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
-              request
-            });
-          }
-        }
-        if (!shouldDisableCaching) {
-          const cached = await currentStorage.get(storageKey);
-          if (cached) {
-            try {
-              const cacheItem = cached;
-              const age = now - cacheItem.timestamp;
-              if (age < maxAge) {
-                onCache === null || onCache === void 0 ? void 0 : onCache({
-                  status: "hit",
-                  key: finalKey,
-                  params: args,
-                  result: cacheItem.data
-                });
-                return cacheItem.data;
-              }
-              if (revalidate > 0 && age < maxAge + revalidate) {
-                onCache === null || onCache === void 0 ? void 0 : onCache({
-                  status: "stale",
-                  key: finalKey,
-                  params: args,
-                  result: cacheItem.data
-                });
-                if (!ongoingRevalidations.has(storageKey)) {
-                  const revalidationPromise = (async () => {
-                    try {
-                      const newData = await fn(...args);
-                      let shouldCache = true;
-                      if (unstable_shouldCache) {
-                        shouldCache = await unstable_shouldCache({
-                          params: args,
-                          result: newData
-                        });
-                      }
-                      if (shouldCache) {
-                        await setCacheItem(currentStorage, storageKey, newData, tags, maxAge, revalidate);
-                      }
-                    } catch (error) {
-                      if (isServer) {
-                        var _asyncStorage_useContext_monitors, _asyncStorage_useContext2;
-                        const asyncStorage = getAsyncLocalStorage();
-                        asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext2 = asyncStorage.useContext()) === null || _asyncStorage_useContext2 === void 0 ? void 0 : (_asyncStorage_useContext_monitors = _asyncStorage_useContext2.monitors) === null || _asyncStorage_useContext_monitors === void 0 ? void 0 : _asyncStorage_useContext_monitors.error(error.message);
-                      } else {
-                        console.error("Background revalidation failed:", error);
-                      }
-                    } finally {
-                      ongoingRevalidations.delete(storageKey);
-                    }
-                  })();
-                  ongoingRevalidations.set(storageKey, revalidationPromise);
-                }
-                return cacheItem.data;
-              }
-              missReason = 3;
-            } catch (error) {
-              console.warn("Failed to parse cached data:", error);
-              missReason = 4;
-            }
-          } else {
-            missReason = 2;
-          }
-        } else {
-          missReason = 1;
-        }
-        const data = await fn(...args);
-        if (!shouldDisableCaching) {
-          let shouldCache = true;
-          if (unstable_shouldCache) {
-            shouldCache = await unstable_shouldCache({
-              params: args,
-              result: data
-            });
-          }
-          if (shouldCache) {
-            await setCacheItem(currentStorage, storageKey, data, tags, maxAge, revalidate);
-          }
-        }
-        onCache === null || onCache === void 0 ? void 0 : onCache({
-          status: "miss",
-          key: finalKey,
-          params: args,
-          result: data,
-          reason: missReason
-        });
-        return data;
-      } catch (error) {
-        console.warn("Cache operation failed, falling back to direct execution:", error);
-        const data = await fn(...args);
-        const { onCache } = options;
-        try {
-          onCache === null || onCache === void 0 ? void 0 : onCache({
-            status: "miss",
-            key: "cache_failed",
-            params: args,
-            result: data,
-            reason: 5
-          });
-        } catch (callbackError) {
-          console.warn("Failed to call onCache callback:", callbackError);
-        }
-        return data;
-      }
-    } else {
-      console.warn("The cache function will not work because it runs on the browser and there are no options are provided.");
-      return fn(...args);
-    }
-  };
-}
-async function setCacheItem(storage2, storageKey, data, tags, maxAge, revalidate) {
-  const newItem = {
-    data,
-    timestamp: Date.now(),
-    tags: tags.length > 0 ? tags : void 0
-  };
-  const ttl = (maxAge + revalidate) / 1e3;
-  await storage2.set(storageKey, newItem, {
-    ttl: ttl > 0 ? ttl : void 0
-  });
-  await updateTagRelationships(storage2, storageKey, tags);
-}
-async function updateTagRelationships(storage2, storageKey, tags) {
-  for (const tag of tags) {
-    const tagStoreKey = `${TAG_PREFIX}${tag}`;
-    const keyList = await storage2.get(tagStoreKey);
-    const keyArray = keyList || [];
-    if (!keyArray.includes(storageKey)) {
-      keyArray.push(storageKey);
-    }
-    await storage2.set(tagStoreKey, keyArray);
-  }
-}
-async function removeKeyFromTags(storage2, storageKey, tags) {
-  for (const tag of tags) {
-    const tagStoreKey = `${TAG_PREFIX}${tag}`;
-    const keyList = await storage2.get(tagStoreKey);
-    if (keyList) {
-      try {
-        const keyArray = Array.isArray(keyList) ? keyList : [];
-        const updatedKeyList = keyArray.filter((key) => key !== storageKey);
-        if (updatedKeyList.length > 0) {
-          await storage2.set(tagStoreKey, updatedKeyList);
-        } else {
-          await storage2.delete(tagStoreKey);
-        }
-      } catch (error) {
-        console.warn(`Failed to process tag key list for tag ${tag}:`, error);
-      }
-    }
-  }
-}
-function withRequestCache(handler) {
-  if (!isServer) {
-    return handler;
-  }
-  return async (req, ...args) => {
-    const storage2 = getAsyncLocalStorage();
-    return storage2.run({
-      request: req
-    }, () => handler(req, ...args));
-  };
-}
-async function revalidateTag(tag) {
-  const currentStorage = getStorage();
-  const tagStoreKey = `${TAG_PREFIX}${tag}`;
-  const keyList = await currentStorage.get(tagStoreKey);
-  if (keyList) {
-    try {
-      const keyArray = Array.isArray(keyList) ? keyList : [];
-      for (const cacheKey of keyArray) {
-        const cached = await currentStorage.get(cacheKey);
-        if (cached) {
-          try {
-            const cacheItem = cached;
-            if (cacheItem.tags) {
-              const otherTags = cacheItem.tags.filter((t) => t !== tag);
-              await removeKeyFromTags(currentStorage, cacheKey, otherTags);
-            }
-          } catch (error) {
-            console.warn("Failed to parse cached data while revalidating:", error);
-          }
-        }
-        await currentStorage.delete(cacheKey);
-      }
-      await currentStorage.delete(tagStoreKey);
-    } catch (error) {
-      console.warn("Failed to process tag key list:", error);
-    }
-  }
-}
-async function clearStore() {
-  const currentStorage = getStorage();
-  await currentStorage.clear();
-  storage = void 0;
-  ongoingRevalidations.clear();
-}
-export {
-  CacheSize,
-  CacheTime,
-  cache,
-  clearStore,
-  configureCache,
-  generateKey,
-  revalidateTag,
-  withRequestCache
-};

package/dist/esm-node/universal/request.js

@@ -1,50 +0,0 @@
-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;
-}
-function parseHeaders(request) {
-  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] : "/";
-}
-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;
-}
-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;
-}
-export {
-  getHost,
-  getPathname,
-  parseCookie,
-  parseHeaders,
-  parseQuery
-};

package/dist/esm-node/url.js

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

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

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

package/dist/types/remixRouter.d.ts

@@ -1,2 +0,0 @@
-export * from '@remix-run/router';
-export declare const DEFERRED_SYMBOL: symbol;