nitropack-nightly 2.11.0-20250221-151704.a7feefae → 2.11.0-20250224-142059.8ccbde5f

package/dist/core/index.mjs

@@ -1374,9 +1374,8 @@ declare module "nitropack/types" {
       ]
     });
     for (const alias in tsConfig.compilerOptions.paths) {
-      const paths = tsConfig.compilerOptions.paths[alias];
-      tsConfig.compilerOptions.paths[alias] = await Promise.all(
-        paths.map(async (path) => {
+      const paths = await Promise.all(
+        tsConfig.compilerOptions.paths[alias].map(async (path) => {
           if (!isAbsolute(path)) {
             return path;
           }
@@ -1390,6 +1389,7 @@ declare module "nitropack/types" {
           );
         })
       );
+      tsConfig.compilerOptions.paths[alias] = [...new Set(paths)];
     }
     tsConfig.include = [
       ...new Set(

package/dist/meta/index.d.mts

@@ -1,3 +1,3 @@
-const version = "2.11.0-20250221-151704.a7feefae";
+const version = "2.11.0-20250224-142059.8ccbde5f";
 
 export { version };

package/dist/meta/index.d.ts

@@ -1,3 +1,3 @@
-const version = "2.11.0-20250221-151704.a7feefae";
+const version = "2.11.0-20250224-142059.8ccbde5f";
 
 export { version };

package/dist/meta/index.mjs

@@ -1,3 +1,3 @@
-const version = "2.11.0-20250221-151704.a7feefae";
+const version = "2.11.0-20250224-142059.8ccbde5f";
 
 export { version };

package/dist/rollup/index.mjs

@@ -1089,7 +1089,7 @@ function unique(arr) {
   return [...new Set(arr)];
 }
 function getImportId(p, lazy) {
-  return (lazy ? "_lazy_" : "_") + hash(p).slice(0, 6);
+  return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
 }
 const WILDCARD_PATH_RE = /\/\*\*.*$/;
 function extendMiddlewareWithRuleOverlaps(handlers2, routeRules) {
@@ -1967,10 +1967,12 @@ const getRollupConfig = (nitro) => {
     virtual(
       {
         "#nitro-internal-virtual/plugins": `
-${nitroPlugins.map((plugin) => `import _${hash(plugin)} from '${plugin}';`).join("\n")}
+${nitroPlugins.map(
+          (plugin) => `import _${hash(plugin).replace(/-/g, "")} from '${plugin}';`
+        ).join("\n")}
 
 export const plugins = [
-  ${nitroPlugins.map((plugin) => `_${hash(plugin)}`).join(",\n")}
+  ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
 ]
     `
       },

package/dist/runtime/internal/cache.mjs

@@ -6,10 +6,10 @@ import {
   isEvent,
   splitCookiesString
 } from "h3";
-import { hash } from "ohash";
 import { parseURL } from "ufo";
 import { useNitroApp } from "./app.mjs";
 import { useStorage } from "./storage.mjs";
+import { hash } from "./hash.mjs";
 function defaultCacheOptions() {
   return {
     name: "_",
@@ -119,7 +119,7 @@ export function cachedFunction(fn, opts = {}) {
   return defineCachedFunction(fn, opts);
 }
 function getKey(...args) {
-  return args.length > 0 ? hash(args, {}) : "";
+  return args.length > 0 ? hash(args) : "";
 }
 function escapeKey(key) {
   return String(key).replace(/\W/g, "");

package/dist/runtime/internal/hash.d.ts

@@ -0,0 +1,6 @@
+export declare function hash(value: any): any;
+/**
+Source: https://github.com/unjs/ohash/blob/v1/src/object-hash.ts
+Based on https://github.com/puleos/object-hash v3.0.0 (MIT)
+ */
+export declare function serialize(object: any): string;

package/dist/runtime/internal/hash.mjs

@@ -0,0 +1,179 @@
+import { digest } from "ohash";
+export function hash(value) {
+  return digest(typeof value === "string" ? value : serialize(value)).replace(/[-_]/g, "").slice(0, 10);
+}
+export function serialize(object) {
+  const hasher = new Hasher();
+  hasher.dispatch(object);
+  return hasher.buff;
+}
+class Hasher {
+  buff = "";
+  #context = /* @__PURE__ */ new Map();
+  write(str) {
+    this.buff += str;
+  }
+  dispatch(value) {
+    const type = value === null ? "null" : typeof value;
+    return this[type](value);
+  }
+  object(object) {
+    if (object && typeof object.toJSON === "function") {
+      return this.object(object.toJSON());
+    }
+    const objString = Object.prototype.toString.call(object);
+    let objType = "";
+    const objectLength = objString.length;
+    objType = objectLength < 10 ? "unknown:[" + objString + "]" : objString.slice(8, objectLength - 1);
+    objType = objType.toLowerCase();
+    let objectNumber = null;
+    if ((objectNumber = this.#context.get(object)) === void 0) {
+      this.#context.set(object, this.#context.size);
+    } else {
+      return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+      this.write("buffer:");
+      return this.write(object.toString("utf8"));
+    }
+    if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+      if (this[objType]) {
+        this[objType](object);
+      } else {
+        this.unknown(object, objType);
+      }
+    } else {
+      const keys = Object.keys(object).sort();
+      const extraKeys = [];
+      this.write("object:" + (keys.length + extraKeys.length) + ":");
+      const dispatchForKey = (key) => {
+        this.dispatch(key);
+        this.write(":");
+        this.dispatch(object[key]);
+        this.write(",");
+      };
+      for (const key of keys) {
+        dispatchForKey(key);
+      }
+      for (const key of extraKeys) {
+        dispatchForKey(key);
+      }
+    }
+  }
+  array(arr, unordered) {
+    unordered = unordered === void 0 ? false : unordered;
+    this.write("array:" + arr.length + ":");
+    if (!unordered || arr.length <= 1) {
+      for (const entry of arr) {
+        this.dispatch(entry);
+      }
+      return;
+    }
+    const contextAdditions = /* @__PURE__ */ new Map();
+    const entries = arr.map((entry) => {
+      const hasher = new Hasher();
+      hasher.dispatch(entry);
+      for (const [key, value] of hasher.#context) {
+        contextAdditions.set(key, value);
+      }
+      return hasher.toString();
+    });
+    this.#context = contextAdditions;
+    entries.sort();
+    return this.array(entries, false);
+  }
+  date(date) {
+    return this.write("date:" + date.toJSON());
+  }
+  symbol(sym) {
+    return this.write("symbol:" + sym.toString());
+  }
+  unknown(value, type) {
+    this.write(type);
+    if (!value) {
+      return;
+    }
+    this.write(":");
+    if (value && typeof value.entries === "function") {
+      return this.array(
+        [...value.entries()],
+        true
+        /* ordered */
+      );
+    }
+  }
+  error(err) {
+    return this.write("error:" + err.toString());
+  }
+  boolean(bool) {
+    return this.write("bool:" + bool);
+  }
+  string(string) {
+    this.write("string:" + string.length + ":");
+    this.write(string);
+  }
+  function(fn) {
+    this.write("fn:");
+    if (isNativeFunction(fn)) {
+      this.dispatch("[native]");
+    } else {
+      this.dispatch(fn.toString());
+    }
+  }
+  number(number) {
+    return this.write("number:" + number);
+  }
+  null() {
+    return this.write("Null");
+  }
+  undefined() {
+    return this.write("Undefined");
+  }
+  regexp(regex) {
+    return this.write("regex:" + regex.toString());
+  }
+  arraybuffer(arr) {
+    this.write("arraybuffer:");
+    return this.dispatch(new Uint8Array(arr));
+  }
+  url(url) {
+    return this.write("url:" + url.toString());
+  }
+  map(map) {
+    this.write("map:");
+    const arr = [...map];
+    return this.array(arr, false);
+  }
+  set(set) {
+    this.write("set:");
+    const arr = [...set];
+    return this.array(arr, false);
+  }
+  bigint(number) {
+    return this.write("bigint:" + number.toString());
+  }
+}
+for (const type of [
+  "uint8array",
+  "uint8clampedarray",
+  "unt8array",
+  "uint16array",
+  "unt16array",
+  "uint32array",
+  "unt32array",
+  "float32array",
+  "float64array"
+]) {
+  Hasher.prototype[type] = function(arr) {
+    this.write(type + ":");
+    return this.array([...arr], false);
+  };
+}
+const nativeFunc = "[native code] }";
+const nativeFuncLength = nativeFunc.length;
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  return Function.prototype.toString.call(f).slice(-nativeFuncLength) === nativeFunc;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitropack-nightly",
-  "version": "2.11.0-20250221-151704.a7feefae",
+  "version": "2.11.0-20250224-142059.8ccbde5f",
   "description": "Build and Deploy Universal JavaScript Servers",
   "repository": "nitrojs/nitro",
   "license": "MIT",
@@ -108,7 +108,7 @@
     "@types/http-proxy": "^1.17.16",
     "@vercel/nft": "^0.29.2",
     "archiver": "^7.0.1",
-    "c12": "^2.0.2",
+    "c12": "^2.0.4",
     "chokidar": "^4.0.3",
     "citty": "^0.1.6",
     "compatx": "^0.1.8",
@@ -142,7 +142,7 @@
     "node-fetch-native": "^1.6.6",
     "node-mock-http": "^1.0.0",
     "ofetch": "^1.4.1",
-    "ohash": "^1.1.4",
+    "ohash": "^2.0.4",
     "openapi-typescript": "^7.6.1",
     "pathe": "^2.0.3",
     "perfect-debounce": "^1.0.0",
@@ -199,6 +199,7 @@
     "firebase-functions": "^4.9.0",
     "get-port-please": "^3.1.2",
     "miniflare": "^3.20250214.0",
+    "ohash-v1": "npm:ohash@^1.1.4",
     "prettier": "^3.5.1",
     "typescript": "^5.7.3",
     "unbuild": "^3.3.1",