one 1.25.5 → 1.25.6

package/dist/cjs/useMatches.native.js

@@ -0,0 +1,128 @@
+"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 useMatches_exports = {};
+__export(useMatches_exports, {
+  getClientMatchesSnapshot: () => getClientMatchesSnapshot,
+  setClientMatches: () => setClientMatches,
+  subscribeToClientMatches: () => subscribeToClientMatches,
+  updateMatchLoaderData: () => updateMatchLoaderData,
+  useMatch: () => useMatch,
+  useMatches: () => useMatches,
+  usePageMatch: () => usePageMatch
+});
+module.exports = __toCommonJS(useMatches_exports);
+var import_react = require("react");
+var import_one_server_only = require("./vite/one-server-only.native.js");
+var clientMatches = [];
+var clientMatchesListeners = /* @__PURE__ */new Set();
+function subscribeToClientMatches(callback) {
+  clientMatchesListeners.add(callback);
+  return function () {
+    return clientMatchesListeners.delete(callback);
+  };
+}
+function getClientMatchesSnapshot() {
+  return clientMatches;
+}
+function setClientMatches(matches) {
+  clientMatches = matches;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = clientMatchesListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var listener = _step.value;
+      listener();
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+}
+function updateMatchLoaderData(routeId, loaderData) {
+  clientMatches = clientMatches.map(function (m) {
+    return m.routeId === routeId ? {
+      ...m,
+      loaderData
+    } : m;
+  });
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = clientMatchesListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var listener = _step.value;
+      listener();
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+}
+function useMatches() {
+  var serverContext = (0, import_one_server_only.useServerContext)();
+  if (process.env.VITE_ENVIRONMENT === "ssr") {
+    var _ref;
+    return (_ref = serverContext === null || serverContext === void 0 ? void 0 : serverContext.matches) !== null && _ref !== void 0 ? _ref : [];
+  }
+  var clientStoreMatches = (0, import_react.useSyncExternalStore)(subscribeToClientMatches, getClientMatchesSnapshot,
+  // server snapshot for hydration - must match what SSR rendered
+  function () {
+    var _ref2;
+    return (_ref2 = serverContext === null || serverContext === void 0 ? void 0 : serverContext.matches) !== null && _ref2 !== void 0 ? _ref2 : [];
+  });
+  return clientStoreMatches;
+}
+function useMatch(routeId) {
+  var matches = useMatches();
+  return matches.find(function (m) {
+    return m.routeId === routeId;
+  });
+}
+function usePageMatch() {
+  var matches = useMatches();
+  return matches[matches.length - 1];
+}
+//# sourceMappingURL=useMatches.native.js.map

package/dist/cjs/useMatches.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useMatches_exports","__export","getClientMatchesSnapshot","setClientMatches","subscribeToClientMatches","updateMatchLoaderData","useMatch","useMatches","usePageMatch","module","exports","import_react","require","import_one_server_only","clientMatches","clientMatchesListeners","Set","callback","add","delete","matches","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","Symbol","iterator","_step","next","done","listener","err","return","routeId","loaderData","map","m"],"sources":["../../src/useMatches.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,kBAAA;AAAAC,QAAA,CAAAD,kBAAA;EAAAE,wBAAA,EAAAA,CAAA,KAAAA,wBAAA;EAAAC,gBAAA,EAAAA,CAAA,KAAAA,gBAAA;EAAAC,wBAAA,EAAAA,CAAA,KAAAA,wBAAA;EAAAC,qBAAA,EAAAA,CAAA,KAAAA,qBAAA;EAAAC,QAAA,EAAAA,CAAA,KAAAA,QAAA;EAAAC,UAAA,EAAAA,CAAA,KAAAA,UAAA;EAAAC,YAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAf,YAAqC,CAAAK,kBAAA;AACrC,IAAAW,YAAA,GAAAC,OAAA,QAAiC;AASjC,IAAIC,sBAA+B,GAAAD,OAAA;AACnC,IAAAE,aAAM;AAEC,IAAAC,sBAAS,kBAA+C,IAAAC,GAAA;AAC7D,SAAAZ,wBAA2BA,CAAAa,QAAQ;EACnCF,sBAAa,CAAAG,GAAA,CAAAD,QAAA,CAAuB;EACtC;IAEO,OAASF,sBAAA,CAAAI,MAA2B,CAAAF,QAAA;EACzC;AACF;AAOO,SAASf,wBAAiBA,CAAA,EAAuB;EACtD,OAAAY,aAAgB;AAChB;AACE,SAAAX,gBAASA,CAAAiB,OAAA;EACXN,aAAA,GAAAM,OAAA;EACF,IAAAC,yBAAA;IAAAC,iBAAA;IAAAC,cAAA;EAMO;IACL,SAAAC,SAAgB,GAAAT,sBAAc,CAAAU,MAAA,CAAAC,QAAA,KAAAC,KAAA,IAAAN,yBAAA,IAAAM,KAAA,GAAAH,SAAA,CAAAI,IAAA,IAAAC,IAAA,GAAAR,yBAAA;MAAK,IAAAS,QAC/B,GAAAH,KAAY,CAAA5B,KAAA;MAChB+B,QAAA;IACA;EACE,SAAAC,GAAS;IACXT,iBAAA;IACFC,cAAA,GAAAQ,GAAA;EA4CO,UAAS;IACd,IAAM;MAGF,KAAAV,yBAAY,IAAqBG,SAAO,CAAAQ,MAAA;QAC1CR,SAAO,CAAAQ,MAAA,EAAe;MACxB;IAIA,UAAM;MACJ,IAAAV,iBAAA;QACA,MAAAC,cAAA;MAAA;IAEA;EACF;AAIA;AACF,SAAAlB,sBAAA4B,OAAA,EAAAC,UAAA;EAWOpB,aAAS,GAASA,aAAyC,CAAAqB,GAAA,WAAAC,CAAA;IAChE,OAAMA,CAAA,CAAAH,OAAU,KAAAA,OAAW;MAC3B,GAAOG,CAAA;MACTF;IAWO,IAAAE,CAAS;EACd;EACA,IAAAf,yBAAuB,GAAS,IAAC;IAAAC,iBAAA;IAAAC,cAAA;EACnC","ignoreList":[]}

package/dist/cjs/useMatches.test.cjs

@@ -0,0 +1,331 @@
+var import_vitest = require("vitest");
+var import_useMatches = require("./useMatches.cjs");
+(0, import_vitest.describe)("useMatches", () => {
+  (0, import_vitest.describe)("setClientMatches", () => {
+    (0, import_vitest.it)("should update client matches without errors", () => {
+      const matches = [{
+        routeId: "/_layout",
+        pathname: "/",
+        params: {},
+        loaderData: {
+          title: "Root"
+        }
+      }, {
+        routeId: "/page",
+        pathname: "/page",
+        params: {},
+        loaderData: {
+          content: "Page content"
+        }
+      }];
+      (0, import_vitest.expect)(() => (0, import_useMatches.setClientMatches)(matches)).not.toThrow();
+    });
+    (0, import_vitest.it)("should accept empty matches array", () => {
+      (0, import_vitest.expect)(() => (0, import_useMatches.setClientMatches)([])).not.toThrow();
+    });
+  });
+  (0, import_vitest.describe)("type safety", () => {
+    (0, import_vitest.it)("should have correct RouteMatch type", () => {
+      const match = {
+        routeId: "test",
+        pathname: "/test",
+        params: {
+          id: "123"
+        },
+        loaderData: {
+          foo: "bar"
+        }
+      };
+      (0, import_vitest.expect)(match.routeId).toBe("test");
+      (0, import_vitest.expect)(match.pathname).toBe("/test");
+      (0, import_vitest.expect)(match.params.id).toBe("123");
+      (0, import_vitest.expect)(match.loaderData).toEqual({
+        foo: "bar"
+      });
+    });
+    (0, import_vitest.it)("should allow string[] params", () => {
+      const match = {
+        routeId: "test",
+        pathname: "/test",
+        params: {
+          slugs: ["a", "b", "c"]
+        },
+        loaderData: null
+      };
+      (0, import_vitest.expect)(match.params.slugs).toEqual(["a", "b", "c"]);
+    });
+    (0, import_vitest.it)("should allow undefined loaderData", () => {
+      const match = {
+        routeId: "test",
+        pathname: "/test",
+        params: {},
+        loaderData: void 0
+      };
+      (0, import_vitest.expect)(match.loaderData).toBeUndefined();
+    });
+  });
+});
+(0, import_vitest.describe)("RouteMatch ordering", () => {
+  (0, import_vitest.it)("matches should be ordered parent to child (root layout first)", () => {
+    const matches = [{
+      routeId: "/_layout",
+      pathname: "/",
+      params: {},
+      loaderData: {
+        level: "root"
+      }
+    }, {
+      routeId: "/docs/_layout",
+      pathname: "/docs",
+      params: {},
+      loaderData: {
+        level: "docs"
+      }
+    }, {
+      routeId: "/docs/intro",
+      pathname: "/docs/intro",
+      params: {},
+      loaderData: {
+        level: "page"
+      }
+    }];
+    (0, import_vitest.expect)(matches[0].routeId).toBe("/_layout");
+    (0, import_vitest.expect)(matches[0].loaderData.level).toBe("root");
+    (0, import_vitest.expect)(matches[1].routeId).toBe("/docs/_layout");
+    (0, import_vitest.expect)(matches[1].loaderData.level).toBe("docs");
+    (0, import_vitest.expect)(matches[2].routeId).toBe("/docs/intro");
+    (0, import_vitest.expect)(matches[2].loaderData.level).toBe("page");
+  });
+  (0, import_vitest.it)("last match should be the current page", () => {
+    const matches = [{
+      routeId: "/_layout",
+      pathname: "/",
+      params: {},
+      loaderData: {}
+    }, {
+      routeId: "/page",
+      pathname: "/page",
+      params: {
+        id: "123"
+      },
+      loaderData: {
+        title: "Page"
+      }
+    }];
+    const pageMatch = matches[matches.length - 1];
+    (0, import_vitest.expect)(pageMatch.routeId).toBe("/page");
+    (0, import_vitest.expect)(pageMatch.loaderData.title).toBe("Page");
+  });
+});
+(0, import_vitest.describe)("setClientMatches reactivity", () => {
+  (0, import_vitest.it)("should notify listeners when matches change", () => {
+    let notifyCount = 0;
+    const listener = () => {
+      notifyCount++;
+    };
+    const matches1 = [{
+      routeId: "/page1",
+      pathname: "/page1",
+      params: {},
+      loaderData: {}
+    }];
+    const matches2 = [{
+      routeId: "/page2",
+      pathname: "/page2",
+      params: {},
+      loaderData: {}
+    }];
+    (0, import_useMatches.setClientMatches)(matches1);
+    (0, import_useMatches.setClientMatches)(matches2);
+    (0, import_vitest.expect)(notifyCount).toBe(0);
+  });
+  (0, import_vitest.it)("should handle multiple sequential updates", () => {
+    const matches1 = [{
+      routeId: "/a",
+      pathname: "/a",
+      params: {},
+      loaderData: {
+        n: 1
+      }
+    }];
+    const matches2 = [{
+      routeId: "/b",
+      pathname: "/b",
+      params: {},
+      loaderData: {
+        n: 2
+      }
+    }];
+    const matches3 = [{
+      routeId: "/c",
+      pathname: "/c",
+      params: {},
+      loaderData: {
+        n: 3
+      }
+    }];
+    (0, import_vitest.expect)(() => {
+      (0, import_useMatches.setClientMatches)(matches1);
+      (0, import_useMatches.setClientMatches)(matches2);
+      (0, import_useMatches.setClientMatches)(matches3);
+    }).not.toThrow();
+  });
+});
+(0, import_vitest.describe)("RouteMatch with dynamic params", () => {
+  (0, import_vitest.it)("should handle single dynamic param", () => {
+    const match = {
+      routeId: "/users/[id]",
+      pathname: "/users/123",
+      params: {
+        id: "123"
+      },
+      loaderData: {
+        user: {
+          name: "John"
+        }
+      }
+    };
+    (0, import_vitest.expect)(match.params.id).toBe("123");
+  });
+  (0, import_vitest.it)("should handle multiple dynamic params", () => {
+    const match = {
+      routeId: "/users/[userId]/posts/[postId]",
+      pathname: "/users/123/posts/456",
+      params: {
+        userId: "123",
+        postId: "456"
+      },
+      loaderData: {
+        post: {
+          title: "Hello"
+        }
+      }
+    };
+    (0, import_vitest.expect)(match.params.userId).toBe("123");
+    (0, import_vitest.expect)(match.params.postId).toBe("456");
+  });
+  (0, import_vitest.it)("should handle catch-all params", () => {
+    const match = {
+      routeId: "/docs/[...slug]",
+      pathname: "/docs/getting-started/intro",
+      params: {
+        slug: ["getting-started", "intro"]
+      },
+      loaderData: {
+        doc: {
+          content: "Hello"
+        }
+      }
+    };
+    (0, import_vitest.expect)(match.params.slug).toEqual(["getting-started", "intro"]);
+  });
+});
+(0, import_vitest.describe)("RouteMatch loaderData scenarios", () => {
+  (0, import_vitest.it)("should handle complex nested loaderData", () => {
+    const match = {
+      routeId: "/dashboard",
+      pathname: "/dashboard",
+      params: {},
+      loaderData: {
+        user: {
+          id: 1,
+          profile: {
+            name: "John",
+            settings: {
+              theme: "dark",
+              notifications: true
+            }
+          }
+        },
+        posts: [{
+          id: 1,
+          title: "Post 1"
+        }, {
+          id: 2,
+          title: "Post 2"
+        }]
+      }
+    };
+    const data = match.loaderData;
+    (0, import_vitest.expect)(data.user.profile.settings.theme).toBe("dark");
+    (0, import_vitest.expect)(data.posts).toHaveLength(2);
+  });
+  (0, import_vitest.it)("should handle null loaderData", () => {
+    const match = {
+      routeId: "/empty",
+      pathname: "/empty",
+      params: {},
+      loaderData: null
+    };
+    (0, import_vitest.expect)(match.loaderData).toBeNull();
+  });
+  (0, import_vitest.it)("should handle array loaderData", () => {
+    const match = {
+      routeId: "/list",
+      pathname: "/list",
+      params: {},
+      loaderData: [1, 2, 3, 4, 5]
+    };
+    (0, import_vitest.expect)(match.loaderData).toEqual([1, 2, 3, 4, 5]);
+  });
+  (0, import_vitest.it)("should handle primitive loaderData", () => {
+    const match = {
+      routeId: "/count",
+      pathname: "/count",
+      params: {},
+      loaderData: 42
+    };
+    (0, import_vitest.expect)(match.loaderData).toBe(42);
+  });
+});
+(0, import_vitest.describe)("finding matches", () => {
+  const createMatches = () => [{
+    routeId: "/_layout",
+    pathname: "/",
+    params: {},
+    loaderData: {
+      root: true
+    }
+  }, {
+    routeId: "/docs/_layout",
+    pathname: "/docs",
+    params: {},
+    loaderData: {
+      navItems: ["intro", "guide"]
+    }
+  }, {
+    routeId: "/docs/[slug]",
+    pathname: "/docs/intro",
+    params: {
+      slug: "intro"
+    },
+    loaderData: {
+      title: "Introduction",
+      headings: ["h1", "h2"]
+    }
+  }];
+  (0, import_vitest.it)("should find match by exact routeId", () => {
+    const matches = createMatches();
+    const found = matches.find(m => m.routeId === "/docs/_layout");
+    (0, import_vitest.expect)(found).toBeDefined();
+    (0, import_vitest.expect)(found.loaderData.navItems).toEqual(["intro", "guide"]);
+  });
+  (0, import_vitest.it)("should find match by routeId pattern", () => {
+    const matches = createMatches();
+    const found = matches.find(m => m.routeId.includes("_layout"));
+    (0, import_vitest.expect)(found).toBeDefined();
+    (0, import_vitest.expect)(found.routeId).toBe("/_layout");
+  });
+  (0, import_vitest.it)("should get page match (last in array)", () => {
+    const matches = createMatches();
+    const pageMatch = matches[matches.length - 1];
+    (0, import_vitest.expect)(pageMatch.routeId).toBe("/docs/[slug]");
+    (0, import_vitest.expect)(pageMatch.loaderData.title).toBe("Introduction");
+  });
+  (0, import_vitest.it)("should get layout match for a page", () => {
+    const matches = createMatches();
+    const layoutMatch = matches.find(m => m.routeId.includes("/docs/") && m.routeId.includes("_layout"));
+    (0, import_vitest.expect)(layoutMatch).toBeDefined();
+    (0, import_vitest.expect)(layoutMatch.loaderData.navItems).toBeDefined();
+  });
+});