@tanstack/router-core 0.0.1-beta.9 → 1.97.24

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+<img src="https://static.scarf.sh/a.png?x-pxid=d988eb79-b0fc-4a2b-8514-6a1ab932d188" />
+
+# TanStack Router Core
+
+See [https://tanstack.com/router](https://tanstack.com/router) for documentation.

package/dist/cjs/Matches.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isMatch = (match, path) => {
+  const parts = path.split(".");
+  let part;
+  let value = match;
+  while ((part = parts.shift()) != null && value != null) {
+    value = value[part];
+  }
+  return value != null;
+};
+exports.isMatch = isMatch;
+//# sourceMappingURL=Matches.cjs.map

package/dist/cjs/Matches.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matches.cjs","sources":["../../src/Matches.ts"],"sourcesContent":["import type { Constrain } from './utils'\n\nexport type AnyMatchAndValue = { match: any; value: any }\n\nexport type FindValueByIndex<\n  TKey,\n  TValue extends ReadonlyArray<any>,\n> = TKey extends `${infer TIndex extends number}` ? TValue[TIndex] : never\n\nexport type FindValueByKey<TKey, TValue> =\n  TValue extends ReadonlyArray<any>\n    ? FindValueByIndex<TKey, TValue>\n    : TValue[TKey & keyof TValue]\n\nexport type CreateMatchAndValue<TMatch, TValue> = TValue extends any\n  ? {\n      match: TMatch\n      value: TValue\n    }\n  : never\n\nexport type NextMatchAndValue<\n  TKey,\n  TMatchAndValue extends AnyMatchAndValue,\n> = TMatchAndValue extends any\n  ? CreateMatchAndValue<\n      TMatchAndValue['match'],\n      FindValueByKey<TKey, TMatchAndValue['value']>\n    >\n  : never\n\nexport type IsMatchKeyOf<TValue> =\n  TValue extends ReadonlyArray<any>\n    ? number extends TValue['length']\n      ? `${number}`\n      : keyof TValue & `${number}`\n    : TValue extends object\n      ? keyof TValue & string\n      : never\n\nexport type IsMatchPath<\n  TParentPath extends string,\n  TMatchAndValue extends AnyMatchAndValue,\n> = `${TParentPath}${IsMatchKeyOf<TMatchAndValue['value']>}`\n\nexport type IsMatchResult<\n  TKey,\n  TMatchAndValue extends AnyMatchAndValue,\n> = TMatchAndValue extends any\n  ? TKey extends keyof TMatchAndValue['value']\n    ? TMatchAndValue['match']\n    : never\n  : never\n\nexport type IsMatchParse<\n  TPath,\n  TMatchAndValue extends AnyMatchAndValue,\n  TParentPath extends string = '',\n> = TPath extends `${string}.${string}`\n  ? TPath extends `${infer TFirst}.${infer TRest}`\n    ? IsMatchParse<\n        TRest,\n        NextMatchAndValue<TFirst, TMatchAndValue>,\n        `${TParentPath}${TFirst}.`\n      >\n    : never\n  : {\n      path: IsMatchPath<TParentPath, TMatchAndValue>\n      result: IsMatchResult<TPath, TMatchAndValue>\n    }\n\nexport type IsMatch<TMatch, TPath> = IsMatchParse<\n  TPath,\n  TMatch extends any ? { match: TMatch; value: TMatch } : never\n>\n\n/**\n * Narrows matches based on a path\n * @experimental\n */\nexport const isMatch = <TMatch, TPath extends string>(\n  match: TMatch,\n  path: Constrain<TPath, IsMatch<TMatch, TPath>['path']>,\n): match is IsMatch<TMatch, TPath>['result'] => {\n  const parts = (path as string).split('.')\n  let part\n  let value: any = match\n\n  while ((part = parts.shift()) != null && value != null) {\n    value = value[part]\n  }\n\n  return value != null\n}\n"],"names":[],"mappings":";;AAgFa,MAAA,UAAU,CACrB,OACA,SAC8C;AACxC,QAAA,QAAS,KAAgB,MAAM,GAAG;AACpC,MAAA;AACJ,MAAI,QAAa;AAEjB,UAAQ,OAAO,MAAM,MAAY,MAAA,QAAQ,SAAS,MAAM;AACtD,YAAQ,MAAM,IAAI;AAAA,EAAA;AAGpB,SAAO,SAAS;AAClB;;"}

package/dist/cjs/Matches.d.cts

@@ -0,0 +1,28 @@
+import { Constrain } from './utils.cjs';
+export type AnyMatchAndValue = {
+    match: any;
+    value: any;
+};
+export type FindValueByIndex<TKey, TValue extends ReadonlyArray<any>> = TKey extends `${infer TIndex extends number}` ? TValue[TIndex] : never;
+export type FindValueByKey<TKey, TValue> = TValue extends ReadonlyArray<any> ? FindValueByIndex<TKey, TValue> : TValue[TKey & keyof TValue];
+export type CreateMatchAndValue<TMatch, TValue> = TValue extends any ? {
+    match: TMatch;
+    value: TValue;
+} : never;
+export type NextMatchAndValue<TKey, TMatchAndValue extends AnyMatchAndValue> = TMatchAndValue extends any ? CreateMatchAndValue<TMatchAndValue['match'], FindValueByKey<TKey, TMatchAndValue['value']>> : never;
+export type IsMatchKeyOf<TValue> = TValue extends ReadonlyArray<any> ? number extends TValue['length'] ? `${number}` : keyof TValue & `${number}` : TValue extends object ? keyof TValue & string : never;
+export type IsMatchPath<TParentPath extends string, TMatchAndValue extends AnyMatchAndValue> = `${TParentPath}${IsMatchKeyOf<TMatchAndValue['value']>}`;
+export type IsMatchResult<TKey, TMatchAndValue extends AnyMatchAndValue> = TMatchAndValue extends any ? TKey extends keyof TMatchAndValue['value'] ? TMatchAndValue['match'] : never : never;
+export type IsMatchParse<TPath, TMatchAndValue extends AnyMatchAndValue, TParentPath extends string = ''> = TPath extends `${string}.${string}` ? TPath extends `${infer TFirst}.${infer TRest}` ? IsMatchParse<TRest, NextMatchAndValue<TFirst, TMatchAndValue>, `${TParentPath}${TFirst}.`> : never : {
+    path: IsMatchPath<TParentPath, TMatchAndValue>;
+    result: IsMatchResult<TPath, TMatchAndValue>;
+};
+export type IsMatch<TMatch, TPath> = IsMatchParse<TPath, TMatch extends any ? {
+    match: TMatch;
+    value: TMatch;
+} : never>;
+/**
+ * Narrows matches based on a path
+ * @experimental
+ */
+export declare const isMatch: <TMatch, TPath extends string>(match: TMatch, path: Constrain<TPath, IsMatch<TMatch, TPath>["path"]>) => match is IsMatch<TMatch, TPath>["result"];

package/dist/cjs/RouterProvider.d.cts

@@ -0,0 +1,18 @@
+import { ViewTransitionOptions } from './router.cjs';
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    caseSensitive?: boolean;
+    from?: string;
+}
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    viewTransition?: boolean | ViewTransitionOptions;
+    /**
+     * @deprecated All navigations use React transitions under the hood now
+     **/
+    startTransition?: boolean;
+    ignoreBlocker?: boolean;
+}

package/dist/cjs/defer.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const router = require("./router.cjs");
+const TSR_DEFERRED_PROMISE = Symbol.for("TSR_DEFERRED_PROMISE");
+function defer(_promise, options) {
+  const promise = _promise;
+  if (promise[TSR_DEFERRED_PROMISE]) {
+    return promise;
+  }
+  promise[TSR_DEFERRED_PROMISE] = { status: "pending" };
+  promise.then((data) => {
+    promise[TSR_DEFERRED_PROMISE].status = "success";
+    promise[TSR_DEFERRED_PROMISE].data = data;
+  }).catch((error) => {
+    promise[TSR_DEFERRED_PROMISE].status = "error";
+    promise[TSR_DEFERRED_PROMISE].error = {
+      data: ((options == null ? void 0 : options.serializeError) ?? router.defaultSerializeError)(error),
+      __isServerError: true
+    };
+  });
+  return promise;
+}
+exports.TSR_DEFERRED_PROMISE = TSR_DEFERRED_PROMISE;
+exports.defer = defer;
+//# sourceMappingURL=defer.cjs.map

package/dist/cjs/defer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.cjs","sources":["../../src/defer.ts"],"sourcesContent":["import { defaultSerializeError } from './router'\n\nexport const TSR_DEFERRED_PROMISE = Symbol.for('TSR_DEFERRED_PROMISE')\n\nexport type DeferredPromiseState<T> =\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\nexport type DeferredPromise<T> = Promise<T> & {\n  [TSR_DEFERRED_PROMISE]: DeferredPromiseState<T>\n}\n\nexport function defer<T>(\n  _promise: Promise<T>,\n  options?: {\n    serializeError?: typeof defaultSerializeError\n  },\n) {\n  const promise = _promise as DeferredPromise<T>\n  // this is already deferred promise\n  if ((promise as any)[TSR_DEFERRED_PROMISE]) {\n    return promise\n  }\n  promise[TSR_DEFERRED_PROMISE] = { status: 'pending' }\n\n  promise\n    .then((data) => {\n      promise[TSR_DEFERRED_PROMISE].status = 'success'\n      promise[TSR_DEFERRED_PROMISE].data = data\n    })\n    .catch((error) => {\n      promise[TSR_DEFERRED_PROMISE].status = 'error'\n      ;(promise[TSR_DEFERRED_PROMISE] as any).error = {\n        data: (options?.serializeError ?? defaultSerializeError)(error),\n        __isServerError: true,\n      }\n    })\n\n  return promise\n}\n"],"names":["defaultSerializeError"],"mappings":";;;AAEa,MAAA,uBAAuB,OAAO,IAAI,sBAAsB;AAsBrD,SAAA,MACd,UACA,SAGA;AACA,QAAM,UAAU;AAEX,MAAA,QAAgB,oBAAoB,GAAG;AACnC,WAAA;AAAA,EAAA;AAET,UAAQ,oBAAoB,IAAI,EAAE,QAAQ,UAAU;AAGjD,UAAA,KAAK,CAAC,SAAS;AACN,YAAA,oBAAoB,EAAE,SAAS;AAC/B,YAAA,oBAAoB,EAAE,OAAO;AAAA,EAAA,CACtC,EACA,MAAM,CAAC,UAAU;AACR,YAAA,oBAAoB,EAAE,SAAS;AACrC,YAAQ,oBAAoB,EAAU,QAAQ;AAAA,MAC9C,QAAO,mCAAS,mBAAkBA,OAAAA,uBAAuB,KAAK;AAAA,MAC9D,iBAAiB;AAAA,IACnB;AAAA,EAAA,CACD;AAEI,SAAA;AACT;;;"}

package/dist/cjs/defer.d.cts

@@ -0,0 +1,20 @@
+import { defaultSerializeError } from './router.cjs';
+export declare const TSR_DEFERRED_PROMISE: unique symbol;
+export type DeferredPromiseState<T> = {
+    status: 'pending';
+    data?: T;
+    error?: unknown;
+} | {
+    status: 'success';
+    data: T;
+} | {
+    status: 'error';
+    data?: T;
+    error: unknown;
+};
+export type DeferredPromise<T> = Promise<T> & {
+    [TSR_DEFERRED_PROMISE]: DeferredPromiseState<T>;
+};
+export declare function defer<T>(_promise: Promise<T>, options?: {
+    serializeError?: typeof defaultSerializeError;
+}): DeferredPromise<T>;

package/dist/cjs/index.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const defer = require("./defer.cjs");
+const link = require("./link.cjs");
+const Matches = require("./Matches.cjs");
+const path = require("./path.cjs");
+const qss = require("./qss.cjs");
+const root = require("./root.cjs");
+const router = require("./router.cjs");
+const searchMiddleware = require("./searchMiddleware.cjs");
+const searchParams = require("./searchParams.cjs");
+const utils = require("./utils.cjs");
+exports.TSR_DEFERRED_PROMISE = defer.TSR_DEFERRED_PROMISE;
+exports.defer = defer.defer;
+exports.preloadWarning = link.preloadWarning;
+exports.isMatch = Matches.isMatch;
+exports.cleanPath = path.cleanPath;
+exports.exactPathTest = path.exactPathTest;
+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.removeTrailingSlash = path.removeTrailingSlash;
+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.rootRouteId = root.rootRouteId;
+exports.defaultSerializeError = router.defaultSerializeError;
+exports.retainSearchParams = searchMiddleware.retainSearchParams;
+exports.stripSearchParams = searchMiddleware.stripSearchParams;
+exports.defaultParseSearch = searchParams.defaultParseSearch;
+exports.defaultStringifySearch = searchParams.defaultStringifySearch;
+exports.parseSearchWith = searchParams.parseSearchWith;
+exports.stringifySearchWith = searchParams.stringifySearchWith;
+exports.createControlledPromise = utils.createControlledPromise;
+exports.deepEqual = utils.deepEqual;
+exports.escapeJSON = utils.escapeJSON;
+exports.functionalUpdate = utils.functionalUpdate;
+exports.isPlainArray = utils.isPlainArray;
+exports.isPlainObject = utils.isPlainObject;
+exports.last = utils.last;
+exports.pick = utils.pick;
+exports.replaceEqualDeep = utils.replaceEqualDeep;
+exports.shallow = utils.shallow;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

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

package/dist/cjs/index.d.cts

@@ -0,0 +1,25 @@
+export { TSR_DEFERRED_PROMISE, defer } from './defer.cjs';
+export type { DeferredPromiseState, DeferredPromise } from './defer.cjs';
+export { preloadWarning } from './link.cjs';
+export type { IsRequiredParams, ParsePathParams, AddTrailingSlash, RemoveTrailingSlashes, AddLeadingSlash, RemoveLeadingSlashes, ActiveOptions, LinkOptionsProps, ResolveCurrentPath, ResolveParentPath, ResolveRelativePath, LinkCurrentTargetElement, } from './link.cjs';
+export type { StartSerializer, Serializable, SerializerParse, SerializerParseBy, SerializerStringify, SerializerStringifyBy, } from './serializer.cjs';
+export type { ParsedLocation } from './location.cjs';
+export type { Manifest, RouterManagedTag } from './manifest.cjs';
+export { isMatch } from './Matches.cjs';
+export type { AnyMatchAndValue, FindValueByIndex, FindValueByKey, CreateMatchAndValue, NextMatchAndValue, IsMatchKeyOf, IsMatchPath, IsMatchResult, IsMatchParse, IsMatch, } from './Matches.cjs';
+export { joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, removeTrailingSlash, exactPathTest, resolvePath, parsePathname, interpolatePath, matchPathname, removeBasepath, matchByPath, } from './path.cjs';
+export type { Segment } from './path.cjs';
+export { encode, decode } from './qss.cjs';
+export { rootRouteId } from './root.cjs';
+export type { RootRouteId } from './root.cjs';
+export type { AnyPathParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, SearchFilter, SearchMiddlewareContext, SearchMiddleware, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, InferAllParams, InferAllContext, MetaDescriptor, RouteLinkEntry, SearchValidator, AnySearchValidator, DefaultSearchValidator, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, ParseSplatParams, SplatParams, ResolveParams, ParseParamsFn, StringifyParamsFn, ParamsOptions, UpdatableStaticRouteOption, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, ResolveRouteContext, ResolveLoaderData, RoutePrefix, TrimPath, TrimPathLeft, TrimPathRight, ResolveSearchSchemaFnInput, ResolveSearchSchemaInput, ResolveSearchSchemaFn, ResolveSearchSchema, } from './route.cjs';
+export { defaultSerializeError } from './router.cjs';
+export type { ViewTransitionOptions, ExtractedBaseEntry, ExtractedStream, ExtractedPromise, ExtractedEntry, StreamState, TrailingSlashOption, } from './router.cjs';
+export type { MatchLocation, CommitLocationOptions } from './RouterProvider.cjs';
+export { retainSearchParams, stripSearchParams } from './searchMiddleware.cjs';
+export { defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, } from './searchParams.cjs';
+export type { SearchSerializer, SearchParser } from './searchParams.cjs';
+export type { OptionalStructuralSharing } from './structuralSharing.cjs';
+export { last, functionalUpdate, pick, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, escapeJSON, shallow, createControlledPromise, } from './utils.cjs';
+export type { NoInfer, IsAny, PickAsRequired, PickRequired, PickOptional, WithoutEmpty, Expand, DeepPartial, MakeDifferenceOptional, IsUnion, IsNonEmptyObject, Assign, IntersectAssign, Timeout, Updater, NonNullableUpdater, StringLiteral, ThrowOrOptional, ControlledPromise, ExtractObjects, PartialMergeAllObject, MergeAllPrimitive, ExtractPrimitives, PartialMergeAll, Constrain, ConstrainLiteral, UnionToIntersection, MergeAllObjects, MergeAll, ValidateJSON, } from './utils.cjs';
+export type { StandardSchemaValidatorProps, StandardSchemaValidator, AnyStandardSchemaValidator, StandardSchemaValidatorTypes, AnyStandardSchemaValidateSuccess, AnyStandardSchemaValidateFailure, AnyStandardSchemaValidateIssue, AnyStandardSchemaValidateInput, AnyStandardSchemaValidate, ValidatorObj, AnyValidatorObj, ValidatorAdapter, AnyValidatorAdapter, AnyValidatorFn, ValidatorFn, Validator, AnyValidator, AnySchema, DefaultValidator, ResolveSearchValidatorInputFn, ResolveSearchValidatorInput, ResolveValidatorInputFn, ResolveValidatorInput, ResolveValidatorOutputFn, ResolveValidatorOutput, } from './validators.cjs';

package/dist/cjs/link.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const preloadWarning = "Error preloading route! ☝️";
+exports.preloadWarning = preloadWarning;
+//# sourceMappingURL=link.cjs.map

package/dist/cjs/link.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.cjs","sources":["../../src/link.ts"],"sourcesContent":["export type IsRequiredParams<TParams> =\n  Record<never, never> extends TParams ? never : true\n\nexport type ParsePathParams<T extends string, TAcc = never> = T &\n  `${string}$${string}` extends never\n  ? TAcc\n  : T extends `${string}$${infer TPossiblyParam}`\n    ? TPossiblyParam extends ''\n      ? TAcc\n      : TPossiblyParam & `${string}/${string}` extends never\n        ? TPossiblyParam | TAcc\n        : TPossiblyParam extends `${infer TParam}/${infer TRest}`\n          ? ParsePathParams<TRest, TParam extends '' ? TAcc : TParam | TAcc>\n          : never\n    : TAcc\n\nexport type AddTrailingSlash<T> = T & `${string}/` extends never\n  ? `${T & string}/`\n  : T\n\nexport type RemoveTrailingSlashes<T> = T & `${string}/` extends never\n  ? T\n  : T extends `${infer R}/`\n    ? R\n    : T\n\nexport type AddLeadingSlash<T> = T & `/${string}` extends never\n  ? `/${T & string}`\n  : T\n\nexport type RemoveLeadingSlashes<T> = T & `/${string}` extends never\n  ? T\n  : T extends `/${infer R}`\n    ? R\n    : T\n\nexport interface ActiveOptions {\n  exact?: boolean\n  includeHash?: boolean\n  includeSearch?: boolean\n  explicitUndefined?: boolean\n}\n\nexport interface LinkOptionsProps {\n  /**\n   * The standard anchor tag target attribute\n   */\n  target?: HTMLAnchorElement['target']\n  /**\n   * Configurable options to determine if the link should be considered active or not\n   * @default {exact:true,includeHash:true}\n   */\n  activeOptions?: ActiveOptions\n  /**\n   * The preloading strategy for this link\n   * - `false` - No preloading\n   * - `'intent'` - Preload the linked route on hover and cache it for this many milliseconds in hopes that the user will eventually navigate there.\n   * - `'viewport'` - Preload the linked route when it enters the viewport\n   */\n  preload?: false | 'intent' | 'viewport' | 'render'\n  /**\n   * When a preload strategy is set, this delays the preload by this many milliseconds.\n   * If the user exits the link before this delay, the preload will be cancelled.\n   */\n  preloadDelay?: number\n  /**\n   * Control whether the link should be disabled or not\n   * If set to `true`, the link will be rendered without an `href` attribute\n   * @default false\n   */\n  disabled?: boolean\n}\n\ntype JoinPath<TLeft extends string, TRight extends string> = TRight extends ''\n  ? TLeft\n  : TLeft extends ''\n    ? TRight\n    : `${RemoveTrailingSlashes<TLeft>}/${RemoveLeadingSlashes<TRight>}`\n\ntype RemoveLastSegment<\n  T extends string,\n  TAcc extends string = '',\n> = T extends `${infer TSegment}/${infer TRest}`\n  ? TRest & `${string}/${string}` extends never\n    ? TRest extends ''\n      ? TAcc\n      : `${TAcc}${TSegment}`\n    : RemoveLastSegment<TRest, `${TAcc}${TSegment}/`>\n  : TAcc\n\nexport type ResolveCurrentPath<\n  TFrom extends string,\n  TTo extends string,\n> = TTo extends '.'\n  ? TFrom\n  : TTo extends './'\n    ? AddTrailingSlash<TFrom>\n    : TTo & `./${string}` extends never\n      ? never\n      : TTo extends `./${infer TRest}`\n        ? AddLeadingSlash<JoinPath<TFrom, TRest>>\n        : never\n\nexport type ResolveParentPath<\n  TFrom extends string,\n  TTo extends string,\n> = TTo extends '../' | '..'\n  ? TFrom extends '' | '/'\n    ? never\n    : AddLeadingSlash<RemoveLastSegment<TFrom>>\n  : TTo & `../${string}` extends never\n    ? AddLeadingSlash<JoinPath<TFrom, TTo>>\n    : TFrom extends '' | '/'\n      ? never\n      : TTo extends `../${infer ToRest}`\n        ? ResolveParentPath<RemoveLastSegment<TFrom>, ToRest>\n        : AddLeadingSlash<JoinPath<TFrom, TTo>>\n\nexport type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom\n  ? TTo\n  : string extends TTo\n    ? TFrom\n    : undefined extends TTo\n      ? TFrom\n      : TTo extends string\n        ? TFrom extends string\n          ? TTo extends `/${string}`\n            ? TTo\n            : TTo extends `..${string}`\n              ? ResolveParentPath<TFrom, TTo>\n              : TTo extends `.${string}`\n                ? ResolveCurrentPath<TFrom, TTo>\n                : AddLeadingSlash<JoinPath<TFrom, TTo>>\n          : never\n        : never\n\nexport type LinkCurrentTargetElement = {\n  preloadTimeout?: null | ReturnType<typeof setTimeout>\n}\n\nexport const preloadWarning = 'Error preloading route! ☝️'\n"],"names":[],"mappings":";;AA4IO,MAAM,iBAAiB;;"}

package/dist/cjs/link.d.cts

@@ -0,0 +1,51 @@
+export type IsRequiredParams<TParams> = Record<never, never> extends TParams ? never : true;
+export type ParsePathParams<T extends string, TAcc = never> = T & `${string}$${string}` extends never ? TAcc : T extends `${string}$${infer TPossiblyParam}` ? TPossiblyParam extends '' ? TAcc : TPossiblyParam & `${string}/${string}` extends never ? TPossiblyParam | TAcc : TPossiblyParam extends `${infer TParam}/${infer TRest}` ? ParsePathParams<TRest, TParam extends '' ? TAcc : TParam | TAcc> : never : TAcc;
+export type AddTrailingSlash<T> = T & `${string}/` extends never ? `${T & string}/` : T;
+export type RemoveTrailingSlashes<T> = T & `${string}/` extends never ? T : T extends `${infer R}/` ? R : T;
+export type AddLeadingSlash<T> = T & `/${string}` extends never ? `/${T & string}` : T;
+export type RemoveLeadingSlashes<T> = T & `/${string}` extends never ? T : T extends `/${infer R}` ? R : T;
+export interface ActiveOptions {
+    exact?: boolean;
+    includeHash?: boolean;
+    includeSearch?: boolean;
+    explicitUndefined?: boolean;
+}
+export interface LinkOptionsProps {
+    /**
+     * The standard anchor tag target attribute
+     */
+    target?: HTMLAnchorElement['target'];
+    /**
+     * Configurable options to determine if the link should be considered active or not
+     * @default {exact:true,includeHash:true}
+     */
+    activeOptions?: ActiveOptions;
+    /**
+     * The preloading strategy for this link
+     * - `false` - No preloading
+     * - `'intent'` - Preload the linked route on hover and cache it for this many milliseconds in hopes that the user will eventually navigate there.
+     * - `'viewport'` - Preload the linked route when it enters the viewport
+     */
+    preload?: false | 'intent' | 'viewport' | 'render';
+    /**
+     * When a preload strategy is set, this delays the preload by this many milliseconds.
+     * If the user exits the link before this delay, the preload will be cancelled.
+     */
+    preloadDelay?: number;
+    /**
+     * Control whether the link should be disabled or not
+     * If set to `true`, the link will be rendered without an `href` attribute
+     * @default false
+     */
+    disabled?: boolean;
+}
+type JoinPath<TLeft extends string, TRight extends string> = TRight extends '' ? TLeft : TLeft extends '' ? TRight : `${RemoveTrailingSlashes<TLeft>}/${RemoveLeadingSlashes<TRight>}`;
+type RemoveLastSegment<T extends string, TAcc extends string = ''> = T extends `${infer TSegment}/${infer TRest}` ? TRest & `${string}/${string}` extends never ? TRest extends '' ? TAcc : `${TAcc}${TSegment}` : RemoveLastSegment<TRest, `${TAcc}${TSegment}/`> : TAcc;
+export type ResolveCurrentPath<TFrom extends string, TTo extends string> = TTo extends '.' ? TFrom : TTo extends './' ? AddTrailingSlash<TFrom> : TTo & `./${string}` extends never ? never : TTo extends `./${infer TRest}` ? AddLeadingSlash<JoinPath<TFrom, TRest>> : never;
+export type ResolveParentPath<TFrom extends string, TTo extends string> = TTo extends '../' | '..' ? TFrom extends '' | '/' ? never : AddLeadingSlash<RemoveLastSegment<TFrom>> : TTo & `../${string}` extends never ? AddLeadingSlash<JoinPath<TFrom, TTo>> : TFrom extends '' | '/' ? never : TTo extends `../${infer ToRest}` ? ResolveParentPath<RemoveLastSegment<TFrom>, ToRest> : AddLeadingSlash<JoinPath<TFrom, TTo>>;
+export type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom ? TTo : string extends TTo ? TFrom : undefined extends TTo ? TFrom : TTo extends string ? TFrom extends string ? TTo extends `/${string}` ? TTo : TTo extends `..${string}` ? ResolveParentPath<TFrom, TTo> : TTo extends `.${string}` ? ResolveCurrentPath<TFrom, TTo> : AddLeadingSlash<JoinPath<TFrom, TTo>> : never : never;
+export type LinkCurrentTargetElement = {
+    preloadTimeout?: null | ReturnType<typeof setTimeout>;
+};
+export declare const preloadWarning = "Error preloading route! \u261D\uFE0F";
+export {};

package/dist/cjs/location.d.cts

@@ -0,0 +1,12 @@
+import { ParsedHistoryState } from '@tanstack/history';
+import { AnySchema } from './validators.cjs';
+export interface ParsedLocation<TSearchObj extends AnySchema = {}> {
+    href: string;
+    pathname: string;
+    search: TSearchObj;
+    searchStr: string;
+    state: ParsedHistoryState;
+    hash: string;
+    maskedLocation?: ParsedLocation<TSearchObj>;
+    unmaskOnReload?: boolean;
+}

package/dist/cjs/manifest.d.cts

@@ -0,0 +1,24 @@
+export type Manifest = {
+    routes: Record<string, {
+        filePath?: string;
+        preloads?: Array<string>;
+        assets?: Array<RouterManagedTag>;
+    }>;
+};
+export type RouterManagedTag = {
+    tag: 'title';
+    attrs?: Record<string, any>;
+    children: string;
+} | {
+    tag: 'meta' | 'link';
+    attrs?: Record<string, any>;
+    children?: never;
+} | {
+    tag: 'script';
+    attrs?: Record<string, any>;
+    children?: string;
+} | {
+    tag: 'style';
+    attrs?: Record<string, any>;
+    children?: string;
+};

package/dist/cjs/path.cjs

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("./utils.cjs");
+function joinPaths(paths) {
+  return cleanPath(
+    paths.filter((val) => {
+      return val !== void 0;
+    }).join("/")
+  );
+}
+function cleanPath(path) {
+  return path.replace(/\/{2,}/g, "/");
+}
+function trimPathLeft(path) {
+  return path === "/" ? path : path.replace(/^\/{1,}/, "");
+}
+function trimPathRight(path) {
+  return path === "/" ? path : path.replace(/\/{1,}$/, "");
+}
+function trimPath(path) {
+  return trimPathRight(trimPathLeft(path));
+}
+function removeTrailingSlash(value, basepath) {
+  if (value.endsWith("/") && value !== "/" && value !== `${basepath}/`) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function exactPathTest(pathName1, pathName2, basepath) {
+  return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath);
+}
+function resolvePath({
+  basepath,
+  base,
+  to,
+  trailingSlash = "never",
+  caseSensitive
+}) {
+  var _a, _b;
+  base = removeBasepath(basepath, base, caseSensitive);
+  to = removeBasepath(basepath, to, caseSensitive);
+  let baseSegments = parsePathname(base);
+  const toSegments = parsePathname(to);
+  if (baseSegments.length > 1 && ((_a = utils.last(baseSegments)) == null ? void 0 : _a.value) === "/") {
+    baseSegments.pop();
+  }
+  toSegments.forEach((toSegment, index) => {
+    if (toSegment.value === "/") {
+      if (!index) {
+        baseSegments = [toSegment];
+      } else if (index === toSegments.length - 1) {
+        baseSegments.push(toSegment);
+      } else ;
+    } else if (toSegment.value === "..") {
+      baseSegments.pop();
+    } else if (toSegment.value === ".") ;
+    else {
+      baseSegments.push(toSegment);
+    }
+  });
+  if (baseSegments.length > 1) {
+    if (((_b = utils.last(baseSegments)) == null ? void 0 : _b.value) === "/") {
+      if (trailingSlash === "never") {
+        baseSegments.pop();
+      }
+    } else if (trailingSlash === "always") {
+      baseSegments.push({ type: "pathname", value: "/" });
+    }
+  }
+  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)]);
+  return cleanPath(joined);
+}
+function parsePathname(pathname) {
+  if (!pathname) {
+    return [];
+  }
+  pathname = cleanPath(pathname);
+  const segments = [];
+  if (pathname.slice(0, 1) === "/") {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: "pathname",
+      value: "/"
+    });
+  }
+  if (!pathname) {
+    return segments;
+  }
+  const split = pathname.split("/").filter(Boolean);
+  segments.push(
+    ...split.map((part) => {
+      if (part === "$" || part === "*") {
+        return {
+          type: "wildcard",
+          value: part
+        };
+      }
+      if (part.charAt(0) === "$") {
+        return {
+          type: "param",
+          value: part
+        };
+      }
+      return {
+        type: "pathname",
+        value: decodeURI(part)
+      };
+    })
+  );
+  if (pathname.slice(-1) === "/") {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: "pathname",
+      value: "/"
+    });
+  }
+  return segments;
+}
+function interpolatePath({
+  path,
+  params,
+  leaveWildcards,
+  leaveParams,
+  decodeCharMap
+}) {
+  const interpolatedPathSegments = parsePathname(path);
+  const encodedParams = {};
+  for (const [key, value] of Object.entries(params)) {
+    const isValueString = typeof value === "string";
+    if (["*", "_splat"].includes(key)) {
+      encodedParams[key] = isValueString ? encodeURI(value) : value;
+    } else {
+      encodedParams[key] = isValueString ? encodePathParam(value, decodeCharMap) : value;
+    }
+  }
+  return joinPaths(
+    interpolatedPathSegments.map((segment) => {
+      if (segment.type === "wildcard") {
+        const value = encodedParams._splat;
+        if (leaveWildcards) return `${segment.value}${value ?? ""}`;
+        return value;
+      }
+      if (segment.type === "param") {
+        if (leaveParams) {
+          const value = encodedParams[segment.value];
+          return `${segment.value}${value ?? ""}`;
+        }
+        return encodedParams[segment.value.substring(1)] ?? "undefined";
+      }
+      return segment.value;
+    })
+  );
+}
+function encodePathParam(value, decodeCharMap) {
+  let encoded = encodeURIComponent(value);
+  if (decodeCharMap) {
+    for (const [encodedChar, char] of decodeCharMap) {
+      encoded = encoded.replaceAll(encodedChar, char);
+    }
+  }
+  return encoded;
+}
+function matchPathname(basepath, currentPathname, matchLocation) {
+  const pathParams = matchByPath(basepath, currentPathname, matchLocation);
+  if (matchLocation.to && !pathParams) {
+    return;
+  }
+  return pathParams ?? {};
+}
+function removeBasepath(basepath, pathname, caseSensitive = false) {
+  const normalizedBasepath = caseSensitive ? basepath : basepath.toLowerCase();
+  const normalizedPathname = caseSensitive ? pathname : pathname.toLowerCase();
+  switch (true) {
+    // default behaviour is to serve app from the root - pathname
+    // left untouched
+    case normalizedBasepath === "/":
+      return pathname;
+    // shortcut for removing the basepath if it matches the pathname
+    case normalizedPathname === normalizedBasepath:
+      return "";
+    // in case pathname is shorter than basepath - there is
+    // nothing to remove
+    case pathname.length < basepath.length:
+      return pathname;
+    // avoid matching partial segments - strict equality handled
+    // earlier, otherwise, basepath separated from pathname with
+    // separator, therefore lack of separator means partial
+    // segment match (`/app` should not match `/application`)
+    case normalizedPathname[normalizedBasepath.length] !== "/":
+      return pathname;
+    // remove the basepath from the pathname if it starts with it
+    case normalizedPathname.startsWith(normalizedBasepath):
+      return pathname.slice(basepath.length);
+    // otherwise, return the pathname as is
+    default:
+      return pathname;
+  }
+}
+function matchByPath(basepath, from, matchLocation) {
+  if (basepath !== "/" && !from.startsWith(basepath)) {
+    return void 0;
+  }
+  from = removeBasepath(basepath, from, matchLocation.caseSensitive);
+  const to = removeBasepath(
+    basepath,
+    `${matchLocation.to ?? "$"}`,
+    matchLocation.caseSensitive
+  );
+  const baseSegments = parsePathname(from);
+  const routeSegments = parsePathname(to);
+  if (!from.startsWith("/")) {
+    baseSegments.unshift({
+      type: "pathname",
+      value: "/"
+    });
+  }
+  if (!to.startsWith("/")) {
+    routeSegments.unshift({
+      type: "pathname",
+      value: "/"
+    });
+  }
+  const params = {};
+  const isMatch = (() => {
+    for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
+      const baseSegment = baseSegments[i];
+      const routeSegment = routeSegments[i];
+      const isLastBaseSegment = i >= baseSegments.length - 1;
+      const isLastRouteSegment = i >= routeSegments.length - 1;
+      if (routeSegment) {
+        if (routeSegment.type === "wildcard") {
+          const _splat = decodeURI(
+            joinPaths(baseSegments.slice(i).map((d) => d.value))
+          );
+          params["*"] = _splat;
+          params["_splat"] = _splat;
+          return true;
+        }
+        if (routeSegment.type === "pathname") {
+          if (routeSegment.value === "/" && !(baseSegment == null ? void 0 : baseSegment.value)) {
+            return true;
+          }
+          if (baseSegment) {
+            if (matchLocation.caseSensitive) {
+              if (routeSegment.value !== baseSegment.value) {
+                return false;
+              }
+            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+              return false;
+            }
+          }
+        }
+        if (!baseSegment) {
+          return false;
+        }
+        if (routeSegment.type === "param") {
+          if (baseSegment.value === "/") {
+            return false;
+          }
+          if (baseSegment.value.charAt(0) !== "$") {
+            params[routeSegment.value.substring(1)] = decodeURIComponent(
+              baseSegment.value
+            );
+          }
+        }
+      }
+      if (!isLastBaseSegment && isLastRouteSegment) {
+        params["**"] = joinPaths(baseSegments.slice(i + 1).map((d) => d.value));
+        return !!matchLocation.fuzzy && (routeSegment == null ? void 0 : routeSegment.value) !== "/";
+      }
+    }
+    return true;
+  })();
+  return isMatch ? params : void 0;
+}
+exports.cleanPath = cleanPath;
+exports.exactPathTest = exactPathTest;
+exports.interpolatePath = interpolatePath;
+exports.joinPaths = joinPaths;
+exports.matchByPath = matchByPath;
+exports.matchPathname = matchPathname;
+exports.parsePathname = parsePathname;
+exports.removeBasepath = removeBasepath;
+exports.removeTrailingSlash = removeTrailingSlash;
+exports.resolvePath = resolvePath;
+exports.trimPath = trimPath;
+exports.trimPathLeft = trimPathLeft;
+exports.trimPathRight = trimPathRight;
+//# sourceMappingURL=path.cjs.map