@tanstack/react-router 0.0.1-beta.9 → 1.0.1

package/build/cjs/_virtual/_rollupPluginBabelHelpers.js

@@ -1,5 +1,5 @@
 /**
- * react-router
+ * @tanstack/react-router/src/index.tsx
  *
  * Copyright (c) TanStack
  *
@@ -10,40 +10,20 @@
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
-
       for (var key in source) {
         if (Object.prototype.hasOwnProperty.call(source, key)) {
           target[key] = source[key];
         }
       }
     }
-
     return target;
   };
   return _extends.apply(this, arguments);
 }
 
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-exports["extends"] = _extends;
-exports.objectWithoutPropertiesLoose = _objectWithoutPropertiesLoose;
+exports.extends = _extends;
 //# sourceMappingURL=_rollupPluginBabelHelpers.js.map

package/build/cjs/_virtual/_rollupPluginBabelHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/awaited.js

@@ -0,0 +1,43 @@
+/**
+ * @tanstack/react-router/src/index.tsx
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+var RouterProvider = require('./RouterProvider.js');
+var defer = require('./defer.js');
+
+function useAwaited({
+  promise
+}) {
+  const router = RouterProvider.useRouter();
+  let state = promise.__deferredState;
+  const key = `__TSR__DEFERRED__${state.uid}`;
+  if (defer.isDehydratedDeferred(promise)) {
+    state = router.hydrateData(key);
+    promise = Promise.resolve(state.data);
+    promise.__deferredState = state;
+  }
+  if (state.status === 'pending') {
+    throw new Promise(r => setTimeout(r, 1)).then(() => promise);
+  }
+  if (state.status === 'error') {
+    throw state.error;
+  }
+  router.dehydrateData(key, state);
+  return [state.data];
+}
+function Await(props) {
+  const awaited = useAwaited(props);
+  return props.children(...awaited);
+}
+
+exports.Await = Await;
+exports.useAwaited = useAwaited;
+//# sourceMappingURL=awaited.js.map

package/build/cjs/awaited.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaited.js","sources":["../../src/awaited.tsx"],"sourcesContent":["import { useRouter } from './RouterProvider'\nimport { DeferredPromise, isDehydratedDeferred } from './defer'\n\nexport type AwaitOptions<T> = {\n  promise: DeferredPromise<T>\n}\n\nexport function useAwaited<T>({ promise }: AwaitOptions<T>): [T] {\n  const router = useRouter()\n\n  let state = promise.__deferredState\n  const key = `__TSR__DEFERRED__${state.uid}`\n\n  if (isDehydratedDeferred(promise)) {\n    state = router.hydrateData(key)!\n    promise = Promise.resolve(state.data) as DeferredPromise<any>\n    promise.__deferredState = state\n  }\n\n  if (state.status === 'pending') {\n    throw new Promise((r) => setTimeout(r, 1)).then(() => promise)\n  }\n\n  if (state.status === 'error') {\n    throw state.error\n  }\n\n  router.dehydrateData(key, state)\n\n  return [state.data]\n}\n\nexport function Await<T>(\n  props: AwaitOptions<T> & {\n    children: (result: T) => JSX.Element\n  },\n) {\n  const awaited = useAwaited(props)\n  return props.children(...awaited)\n}\n"],"names":["useAwaited","promise","router","useRouter","state","__deferredState","key","uid","isDehydratedDeferred","hydrateData","Promise","resolve","data","status","r","setTimeout","then","error","dehydrateData","Await","props","awaited","children"],"mappings":";;;;;;;;;;;;;;;AAOO,SAASA,UAAUA,CAAI;AAAEC,EAAAA,OAAAA;AAAyB,CAAC,EAAO;AAC/D,EAAA,MAAMC,MAAM,GAAGC,wBAAS,EAAE,CAAA;AAE1B,EAAA,IAAIC,KAAK,GAAGH,OAAO,CAACI,eAAe,CAAA;AACnC,EAAA,MAAMC,GAAG,GAAI,CAAA,iBAAA,EAAmBF,KAAK,CAACG,GAAI,CAAC,CAAA,CAAA;AAE3C,EAAA,IAAIC,0BAAoB,CAACP,OAAO,CAAC,EAAE;AACjCG,IAAAA,KAAK,GAAGF,MAAM,CAACO,WAAW,CAACH,GAAG,CAAE,CAAA;IAChCL,OAAO,GAAGS,OAAO,CAACC,OAAO,CAACP,KAAK,CAACQ,IAAI,CAAyB,CAAA;IAC7DX,OAAO,CAACI,eAAe,GAAGD,KAAK,CAAA;AACjC,GAAA;AAEA,EAAA,IAAIA,KAAK,CAACS,MAAM,KAAK,SAAS,EAAE;AAC9B,IAAA,MAAM,IAAIH,OAAO,CAAEI,CAAC,IAAKC,UAAU,CAACD,CAAC,EAAE,CAAC,CAAC,CAAC,CAACE,IAAI,CAAC,MAAMf,OAAO,CAAC,CAAA;AAChE,GAAA;AAEA,EAAA,IAAIG,KAAK,CAACS,MAAM,KAAK,OAAO,EAAE;IAC5B,MAAMT,KAAK,CAACa,KAAK,CAAA;AACnB,GAAA;AAEAf,EAAAA,MAAM,CAACgB,aAAa,CAACZ,GAAG,EAAEF,KAAK,CAAC,CAAA;AAEhC,EAAA,OAAO,CAACA,KAAK,CAACQ,IAAI,CAAC,CAAA;AACrB,CAAA;AAEO,SAASO,KAAKA,CACnBC,KAEC,EACD;AACA,EAAA,MAAMC,OAAO,GAAGrB,UAAU,CAACoB,KAAK,CAAC,CAAA;AACjC,EAAA,OAAOA,KAAK,CAACE,QAAQ,CAAC,GAAGD,OAAO,CAAC,CAAA;AACnC;;;;;"}

package/build/cjs/defer.js

@@ -0,0 +1,37 @@
+/**
+ * @tanstack/react-router/src/index.tsx
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+function defer(_promise) {
+  const promise = _promise;
+  if (!promise.__deferredState) {
+    promise.__deferredState = {
+      uid: Math.random().toString(36).slice(2),
+      status: 'pending'
+    };
+    const state = promise.__deferredState;
+    promise.then(data => {
+      state.status = 'success';
+      state.data = data;
+    }).catch(error => {
+      state.status = 'error';
+      state.error = error;
+    });
+  }
+  return promise;
+}
+function isDehydratedDeferred(obj) {
+  return typeof obj === 'object' && obj !== null && !(obj instanceof Promise) && !obj.then && '__deferredState' in obj;
+}
+
+exports.defer = defer;
+exports.isDehydratedDeferred = isDehydratedDeferred;
+//# sourceMappingURL=defer.js.map

package/build/cjs/defer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.js","sources":["../../src/defer.ts"],"sourcesContent":["export type DeferredPromiseState<T> = { uid: string } & (\n  | {\n      status: 'pending'\n      data?: T\n      error?: unknown\n    }\n  | {\n      status: 'success'\n      data: T\n    }\n  | {\n      status: 'error'\n      data?: T\n      error: unknown\n    }\n)\n\nexport type DeferredPromise<T> = Promise<T> & {\n  __deferredState: DeferredPromiseState<T>\n}\n\nexport function defer<T>(_promise: Promise<T>) {\n  const promise = _promise as DeferredPromise<T>\n\n  if (!promise.__deferredState) {\n    promise.__deferredState = {\n      uid: Math.random().toString(36).slice(2),\n      status: 'pending',\n    }\n\n    const state = promise.__deferredState\n\n    promise\n      .then((data) => {\n        state.status = 'success' as any\n        state.data = data\n      })\n      .catch((error) => {\n        state.status = 'error' as any\n        state.error = error\n      })\n  }\n\n  return promise\n}\n\nexport function isDehydratedDeferred(obj: any): boolean {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    !(obj instanceof Promise) &&\n    !obj.then &&\n    '__deferredState' in obj\n  )\n}\n"],"names":["defer","_promise","promise","__deferredState","uid","Math","random","toString","slice","status","state","then","data","catch","error","isDehydratedDeferred","obj","Promise"],"mappings":";;;;;;;;;;;;AAqBO,SAASA,KAAKA,CAAIC,QAAoB,EAAE;EAC7C,MAAMC,OAAO,GAAGD,QAA8B,CAAA;AAE9C,EAAA,IAAI,CAACC,OAAO,CAACC,eAAe,EAAE;IAC5BD,OAAO,CAACC,eAAe,GAAG;AACxBC,MAAAA,GAAG,EAAEC,IAAI,CAACC,MAAM,EAAE,CAACC,QAAQ,CAAC,EAAE,CAAC,CAACC,KAAK,CAAC,CAAC,CAAC;AACxCC,MAAAA,MAAM,EAAE,SAAA;KACT,CAAA;AAED,IAAA,MAAMC,KAAK,GAAGR,OAAO,CAACC,eAAe,CAAA;AAErCD,IAAAA,OAAO,CACJS,IAAI,CAAEC,IAAI,IAAK;MACdF,KAAK,CAACD,MAAM,GAAG,SAAgB,CAAA;MAC/BC,KAAK,CAACE,IAAI,GAAGA,IAAI,CAAA;AACnB,KAAC,CAAC,CACDC,KAAK,CAAEC,KAAK,IAAK;MAChBJ,KAAK,CAACD,MAAM,GAAG,OAAc,CAAA;MAC7BC,KAAK,CAACI,KAAK,GAAGA,KAAK,CAAA;AACrB,KAAC,CAAC,CAAA;AACN,GAAA;AAEA,EAAA,OAAOZ,OAAO,CAAA;AAChB,CAAA;AAEO,SAASa,oBAAoBA,CAACC,GAAQ,EAAW;EACtD,OACE,OAAOA,GAAG,KAAK,QAAQ,IACvBA,GAAG,KAAK,IAAI,IACZ,EAAEA,GAAG,YAAYC,OAAO,CAAC,IACzB,CAACD,GAAG,CAACL,IAAI,IACT,iBAAiB,IAAIK,GAAG,CAAA;AAE5B;;;;;"}

package/build/cjs/fileRoute.js

@@ -0,0 +1,27 @@
+/**
+ * @tanstack/react-router/src/index.tsx
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+var route = require('./route.js');
+
+class FileRoute {
+  constructor(path) {
+    this.path = path;
+  }
+  createRoute = options => {
+    const route$1 = new route.Route(options);
+    route$1.isRoot = false;
+    return route$1;
+  };
+}
+
+exports.FileRoute = FileRoute;
+//# sourceMappingURL=fileRoute.js.map

package/build/cjs/fileRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileRoute.js","sources":["../../src/fileRoute.ts"],"sourcesContent":["import { ParsePathParams } from './link'\nimport {\n  AnyRoute,\n  ResolveFullPath,\n  ResolveFullSearchSchema,\n  MergeFromFromParent,\n  RouteContext,\n  AnyContext,\n  RouteOptions,\n  UpdatableRouteOptions,\n  Route,\n  AnyPathParams,\n  RootRouteId,\n  TrimPathLeft,\n  RouteConstraints,\n} from './route'\nimport { Assign, Expand, IsAny } from './utils'\n\nexport interface FileRoutesByPath {\n  // '/': {\n  //   parentRoute: typeof rootRoute\n  // }\n}\n\ntype Replace<\n  S extends string,\n  From extends string,\n  To extends string,\n> = S extends `${infer Start}${From}${infer Rest}`\n  ? `${Start}${To}${Replace<Rest, From, To>}`\n  : S\n\nexport type TrimLeft<\n  T extends string,\n  S extends string,\n> = T extends `${S}${infer U}` ? U : T\n\nexport type TrimRight<\n  T extends string,\n  S extends string,\n> = T extends `${infer U}${S}` ? U : T\n\nexport type Trim<T extends string, S extends string> = TrimLeft<\n  TrimRight<T, S>,\n  S\n>\n\nexport type RemoveUnderScores<T extends string> = Replace<\n  Replace<TrimRight<TrimLeft<T, '/_'>, '_'>, '_/', '/'>,\n  '/_',\n  '/'\n>\n\nexport type ResolveFilePath<\n  TParentRoute extends AnyRoute,\n  TFilePath extends string,\n> = TParentRoute['id'] extends RootRouteId\n  ? TrimPathLeft<TFilePath>\n  : Replace<\n      TrimPathLeft<TFilePath>,\n      TrimPathLeft<TParentRoute['types']['customId']>,\n      ''\n    >\n\nexport type FileRoutePath<\n  TParentRoute extends AnyRoute,\n  TFilePath extends string,\n> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}`\n  ? string\n  : ResolveFilePath<TParentRoute, TFilePath>\n\nexport class FileRoute<\n  TFilePath extends keyof FileRoutesByPath,\n  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n  TId extends RouteConstraints['TId'] = TFilePath,\n  TPath extends RouteConstraints['TPath'] = FileRoutePath<\n    TParentRoute,\n    TFilePath\n  >,\n  TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<\n    TParentRoute,\n    RemoveUnderScores<TPath>\n  >,\n> {\n  constructor(public path: TFilePath) {}\n\n  createRoute = <\n    TSearchSchema extends RouteConstraints['TSearchSchema'] = {},\n    TFullSearchSchema extends\n      RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<\n      TParentRoute,\n      TSearchSchema\n    >,\n    TParams extends RouteConstraints['TParams'] = Expand<\n      Record<ParsePathParams<TPath>, string>\n    >,\n    TAllParams extends RouteConstraints['TAllParams'] = MergeFromFromParent<\n      TParentRoute['types']['allParams'],\n      TParams\n    >,\n    TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext,\n    TContext extends Expand<\n      Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>\n    > = Expand<\n      Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>\n    >,\n    TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext,\n    TLoaderDeps extends Record<string, any> = {},\n    TLoaderData extends any = unknown,\n    TChildren extends RouteConstraints['TChildren'] = unknown,\n    TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute,\n  >(\n    options?: Omit<\n      RouteOptions<\n        TParentRoute,\n        string,\n        TPath,\n        TSearchSchema,\n        TFullSearchSchema,\n        TParams,\n        TAllParams,\n        TRouteContext,\n        TContext,\n        TLoaderDeps,\n        TLoaderData\n      >,\n      'getParentRoute' | 'path' | 'id'\n    > &\n      UpdatableRouteOptions<TFullSearchSchema>,\n  ): Route<\n    TParentRoute,\n    TPath,\n    TFullPath,\n    TFilePath,\n    TId,\n    TSearchSchema,\n    TFullSearchSchema,\n    TParams,\n    TAllParams,\n    TRouteContext,\n    TContext,\n    TRouterContext,\n    TLoaderDeps,\n    TLoaderData,\n    TChildren,\n    TRouteTree\n  > => {\n    const route = new Route(options as any)\n    ;(route as any).isRoot = false\n    return route as any\n  }\n}\n"],"names":["FileRoute","constructor","path","createRoute","options","route","Route","isRoot"],"mappings":";;;;;;;;;;;;;;AAuEO,MAAMA,SAAS,CAYpB;EACAC,WAAWA,CAAQC,IAAe,EAAE;IAAA,IAAjBA,CAAAA,IAAe,GAAfA,IAAe,CAAA;AAAG,GAAA;EAErCC,WAAW,GA0BTC,OAgB0C,IAkBvC;AACH,IAAA,MAAMC,OAAK,GAAG,IAAIC,WAAK,CAACF,OAAc,CAAC,CAAA;IACrCC,OAAK,CAASE,MAAM,GAAG,KAAK,CAAA;AAC9B,IAAA,OAAOF,OAAK,CAAA;GACb,CAAA;AACH;;;;"}

package/build/cjs/index.js

@@ -0,0 +1,130 @@
+/**
+ * @tanstack/react-router/src/index.tsx
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+var history = require('@tanstack/history');
+var invariant = require('tiny-invariant');
+var warning = require('tiny-warning');
+var awaited = require('./awaited.js');
+var defer = require('./defer.js');
+var CatchBoundary = require('./CatchBoundary.js');
+var fileRoute = require('./fileRoute.js');
+var lazyRouteComponent = require('./lazyRouteComponent.js');
+var link = require('./link.js');
+var Matches = require('./Matches.js');
+var path = require('./path.js');
+var qss = require('./qss.js');
+var redirects = require('./redirects.js');
+var route = require('./route.js');
+var router = require('./router.js');
+var RouterProvider = require('./RouterProvider.js');
+var scrollRestoration = require('./scroll-restoration.js');
+var searchParams = require('./searchParams.js');
+var useBlocker = require('./useBlocker.js');
+var useNavigate = require('./useNavigate.js');
+var useParams = require('./useParams.js');
+var useSearch = require('./useSearch.js');
+var utils = require('./utils.js');
+
+
+
+exports.invariant = invariant;
+exports.warning = warning;
+exports.Await = awaited.Await;
+exports.useAwaited = awaited.useAwaited;
+exports.defer = defer.defer;
+exports.isDehydratedDeferred = defer.isDehydratedDeferred;
+exports.CatchBoundary = CatchBoundary.CatchBoundary;
+exports.CatchBoundaryImpl = CatchBoundary.CatchBoundaryImpl;
+exports.ErrorComponent = CatchBoundary.ErrorComponent;
+exports.FileRoute = fileRoute.FileRoute;
+exports.lazyRouteComponent = lazyRouteComponent.lazyRouteComponent;
+exports.Link = link.Link;
+exports.useLinkProps = link.useLinkProps;
+exports.Match = Matches.Match;
+exports.MatchRoute = Matches.MatchRoute;
+exports.Matches = Matches.Matches;
+exports.Outlet = Matches.Outlet;
+exports.matchContext = Matches.matchContext;
+exports.useLoaderData = Matches.useLoaderData;
+exports.useLoaderDeps = Matches.useLoaderDeps;
+exports.useMatch = Matches.useMatch;
+exports.useMatchRoute = Matches.useMatchRoute;
+exports.useMatches = Matches.useMatches;
+exports.useParentMatches = Matches.useParentMatches;
+exports.cleanPath = path.cleanPath;
+exports.interpolatePath = path.interpolatePath;
+exports.joinPaths = path.joinPaths;
+exports.matchByPath = path.matchByPath;
+exports.matchPathname = path.matchPathname;
+exports.parsePathname = path.parsePathname;
+exports.removeBasepath = path.removeBasepath;
+exports.resolvePath = path.resolvePath;
+exports.trimPath = path.trimPath;
+exports.trimPathLeft = path.trimPathLeft;
+exports.trimPathRight = path.trimPathRight;
+exports.decode = qss.decode;
+exports.encode = qss.encode;
+exports.isRedirect = redirects.isRedirect;
+exports.redirect = redirects.redirect;
+exports.NotFoundRoute = route.NotFoundRoute;
+exports.RootRoute = route.RootRoute;
+exports.Route = route.Route;
+exports.RouteApi = route.RouteApi;
+exports.createRouteMask = route.createRouteMask;
+exports.rootRouteId = route.rootRouteId;
+exports.rootRouteWithContext = route.rootRouteWithContext;
+exports.PathParamError = router.PathParamError;
+exports.Router = router.Router;
+exports.SearchParamError = router.SearchParamError;
+exports.componentTypes = router.componentTypes;
+exports.getInitialRouterState = router.getInitialRouterState;
+exports.lazyFn = router.lazyFn;
+exports.RouterProvider = RouterProvider.RouterProvider;
+exports.getRouteMatch = RouterProvider.getRouteMatch;
+Object.defineProperty(exports, 'routerContext', {
+	enumerable: true,
+	get: function () { return RouterProvider.routerContext; }
+});
+exports.useRouter = RouterProvider.useRouter;
+exports.useRouterState = RouterProvider.useRouterState;
+exports.ScrollRestoration = scrollRestoration.ScrollRestoration;
+exports.useElementScrollRestoration = scrollRestoration.useElementScrollRestoration;
+exports.useScrollRestoration = scrollRestoration.useScrollRestoration;
+exports.defaultParseSearch = searchParams.defaultParseSearch;
+exports.defaultStringifySearch = searchParams.defaultStringifySearch;
+exports.parseSearchWith = searchParams.parseSearchWith;
+exports.stringifySearchWith = searchParams.stringifySearchWith;
+exports.Block = useBlocker.Block;
+exports.useBlocker = useBlocker.useBlocker;
+exports.Navigate = useNavigate.Navigate;
+exports.useNavigate = useNavigate.useNavigate;
+exports.useParams = useParams.useParams;
+exports.useSearch = useSearch.useSearch;
+exports.deepEqual = utils.deepEqual;
+exports.escapeJSON = utils.escapeJSON;
+exports.functionalUpdate = utils.functionalUpdate;
+exports.isPlainObject = utils.isPlainObject;
+exports.isServer = utils.isServer;
+exports.last = utils.last;
+exports.pick = utils.pick;
+exports.replaceEqualDeep = utils.replaceEqualDeep;
+exports.shallow = utils.shallow;
+exports.useLayoutEffect = utils.useLayoutEffect;
+exports.useRouteContext = utils.useRouteContext;
+exports.useStableCallback = utils.useStableCallback;
+Object.keys(history).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return history[k]; }
+	});
+});
+//# sourceMappingURL=index.js.map

package/build/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/lazyRouteComponent.js

@@ -0,0 +1,54 @@
+/**
+ * @tanstack/react-router/src/index.tsx
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+function lazyRouteComponent(importer, exportName) {
+  let loadPromise;
+  const load = () => {
+    if (!loadPromise) {
+      loadPromise = importer();
+    }
+    return loadPromise;
+  };
+  const lazyComp = /*#__PURE__*/React__namespace.lazy(async () => {
+    const moduleExports = await load();
+    const comp = moduleExports[exportName ?? 'default'];
+    return {
+      default: comp
+    };
+  });
+  lazyComp.preload = load;
+  return lazyComp;
+}
+
+exports.lazyRouteComponent = lazyRouteComponent;
+//# sourceMappingURL=lazyRouteComponent.js.map

package/build/cjs/lazyRouteComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyRouteComponent.js","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { AsyncRouteComponent } from './route'\n\nexport function lazyRouteComponent<\n  T extends Record<string, any>,\n  TKey extends keyof T = 'default',\n>(\n  importer: () => Promise<T>,\n  exportName?: TKey,\n): T[TKey] extends (props: infer TProps) => any\n  ? AsyncRouteComponent<TProps>\n  : never {\n  let loadPromise: Promise<any>\n\n  const load = () => {\n    if (!loadPromise) {\n      loadPromise = importer()\n    }\n\n    return loadPromise\n  }\n\n  const lazyComp = React.lazy(async () => {\n    const moduleExports = await load()\n    const comp = moduleExports[exportName ?? 'default']\n    return {\n      default: comp,\n    }\n  })\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["lazyRouteComponent","importer","exportName","loadPromise","load","lazyComp","React","lazy","moduleExports","comp","default","preload"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,SAASA,kBAAkBA,CAIhCC,QAA0B,EAC1BC,UAAiB,EAGT;AACR,EAAA,IAAIC,WAAyB,CAAA;EAE7B,MAAMC,IAAI,GAAGA,MAAM;IACjB,IAAI,CAACD,WAAW,EAAE;MAChBA,WAAW,GAAGF,QAAQ,EAAE,CAAA;AAC1B,KAAA;AAEA,IAAA,OAAOE,WAAW,CAAA;GACnB,CAAA;AAED,EAAA,MAAME,QAAQ,gBAAGC,gBAAK,CAACC,IAAI,CAAC,YAAY;AACtC,IAAA,MAAMC,aAAa,GAAG,MAAMJ,IAAI,EAAE,CAAA;AAClC,IAAA,MAAMK,IAAI,GAAGD,aAAa,CAACN,UAAU,IAAI,SAAS,CAAC,CAAA;IACnD,OAAO;AACLQ,MAAAA,OAAO,EAAED,IAAAA;KACV,CAAA;AACH,GAAC,CAAC,CAAA;EACAJ,QAAQ,CAASM,OAAO,GAAGP,IAAI,CAAA;AAEjC,EAAA,OAAOC,QAAQ,CAAA;AACjB;;;;"}

package/build/cjs/link.js

@@ -0,0 +1,223 @@
+/**
+ * @tanstack/react-router/src/index.tsx
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var Matches = require('./Matches.js');
+var RouterProvider = require('./RouterProvider.js');
+var utils = require('./utils.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const preloadWarning = 'Error preloading route! ☝️';
+function useLinkProps(options) {
+  const router = RouterProvider.useRouter();
+  const matchPathname = Matches.useMatch({
+    strict: false,
+    select: s => s.pathname
+  });
+  const {
+    // custom props
+    children,
+    target,
+    activeProps = () => ({
+      className: 'active'
+    }),
+    inactiveProps = () => ({}),
+    activeOptions,
+    disabled,
+    hash,
+    search,
+    params,
+    to,
+    state,
+    mask,
+    preload: userPreload,
+    preloadDelay: userPreloadDelay,
+    replace,
+    startTransition,
+    resetScroll,
+    // element props
+    style,
+    className,
+    onClick,
+    onFocus,
+    onMouseEnter,
+    onMouseLeave,
+    onTouchStart,
+    ...rest
+  } = options;
+
+  // If this link simply reloads the current route,
+  // make sure it has a new key so it will trigger a data refresh
+
+  // If this `to` is a valid external URL, return
+  // null for LinkUtils
+
+  const dest = {
+    from: options.to ? matchPathname : undefined,
+    ...options
+  };
+  let type = 'internal';
+  try {
+    new URL(`${to}`);
+    type = 'external';
+  } catch {}
+  if (type === 'external') {
+    return {
+      href: to
+    };
+  }
+  const next = router.buildLocation(dest);
+  const preload = userPreload ?? router.options.defaultPreload;
+  const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
+  const isActive = RouterProvider.useRouterState({
+    select: s => {
+      // Compare path/hash for matches
+      const currentPathSplit = s.location.pathname.split('/');
+      const nextPathSplit = next.pathname.split('/');
+      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+      // Combine the matches based on user router.options
+      const pathTest = activeOptions?.exact ? s.location.pathname === next.pathname : pathIsFuzzyEqual;
+      const hashTest = activeOptions?.includeHash ? s.location.hash === next.hash : true;
+      const searchTest = activeOptions?.includeSearch ?? true ? utils.deepEqual(s.location.search, next.search, !activeOptions?.exact) : true;
+
+      // The final "active" test
+      return pathTest && hashTest && searchTest;
+    }
+  });
+
+  // The click handler
+  const handleClick = e => {
+    if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+      e.preventDefault();
+
+      // All is well? Navigate!
+      router.commitLocation({
+        ...next,
+        replace,
+        resetScroll,
+        startTransition
+      });
+    }
+  };
+
+  // The click handler
+  const handleFocus = e => {
+    if (preload) {
+      router.preloadRoute(dest).catch(err => {
+        console.warn(err);
+        console.warn(preloadWarning);
+      });
+    }
+  };
+  const handleTouchStart = e => {
+    if (preload) {
+      router.preloadRoute(dest).catch(err => {
+        console.warn(err);
+        console.warn(preloadWarning);
+      });
+    }
+  };
+  const handleEnter = e => {
+    const target = e.target || {};
+    if (preload) {
+      if (target.preloadTimeout) {
+        return;
+      }
+      target.preloadTimeout = setTimeout(() => {
+        target.preloadTimeout = null;
+        router.preloadRoute(dest).catch(err => {
+          console.warn(err);
+          console.warn(preloadWarning);
+        });
+      }, preloadDelay);
+    }
+  };
+  const handleLeave = e => {
+    const target = e.target || {};
+    if (target.preloadTimeout) {
+      clearTimeout(target.preloadTimeout);
+      target.preloadTimeout = null;
+    }
+  };
+  const composeHandlers = handlers => e => {
+    if (e.persist) e.persist();
+    handlers.filter(Boolean).forEach(handler => {
+      if (e.defaultPrevented) return;
+      handler(e);
+    });
+  };
+
+  // Get the active props
+  const resolvedActiveProps = isActive ? utils.functionalUpdate(activeProps, {}) ?? {} : {};
+
+  // Get the inactive props
+  const resolvedInactiveProps = isActive ? {} : utils.functionalUpdate(inactiveProps, {}) ?? {};
+  return {
+    ...resolvedActiveProps,
+    ...resolvedInactiveProps,
+    ...rest,
+    href: disabled ? undefined : next.maskedLocation ? next.maskedLocation.href : next.href,
+    onClick: composeHandlers([onClick, handleClick]),
+    onFocus: composeHandlers([onFocus, handleFocus]),
+    onMouseEnter: composeHandlers([onMouseEnter, handleEnter]),
+    onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),
+    onTouchStart: composeHandlers([onTouchStart, handleTouchStart]),
+    target,
+    style: {
+      ...style,
+      ...resolvedActiveProps.style,
+      ...resolvedInactiveProps.style
+    },
+    className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined,
+    ...(disabled ? {
+      role: 'link',
+      'aria-disabled': true
+    } : undefined),
+    ['data-status']: isActive ? 'active' : undefined
+  };
+}
+const Link = /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
+  const linkProps = useLinkProps(props);
+  return /*#__PURE__*/React__namespace.createElement("a", _rollupPluginBabelHelpers.extends({
+    ref: ref
+  }, linkProps, {
+    children: typeof props.children === 'function' ? props.children({
+      isActive: linkProps['data-status'] === 'active'
+    }) : props.children
+  }));
+});
+function isCtrlEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+
+exports.Link = Link;
+exports.useLinkProps = useLinkProps;
+//# sourceMappingURL=link.js.map