@tanstack/react-router 0.0.1-beta.204 → 0.0.1-beta.206

package/src/searchParams.ts

@@ -0,0 +1,78 @@
+import { decode, encode } from './qss'
+import { AnySearchSchema } from './route'
+
+export const defaultParseSearch = parseSearchWith(JSON.parse)
+export const defaultStringifySearch = stringifySearchWith(
+  JSON.stringify,
+  JSON.parse,
+)
+
+export function parseSearchWith(parser: (str: string) => any) {
+  return (searchStr: string): AnySearchSchema => {
+    if (searchStr.substring(0, 1) === '?') {
+      searchStr = searchStr.substring(1)
+    }
+
+    let query: Record<string, unknown> = decode(searchStr)
+
+    // Try to parse any query params that might be json
+    for (let key in query) {
+      const value = query[key]
+      if (typeof value === 'string') {
+        try {
+          query[key] = parser(value)
+        } catch (err) {
+          //
+        }
+      }
+    }
+
+    return query
+  }
+}
+
+export function stringifySearchWith(
+  stringify: (search: any) => string,
+  parser?: (str: string) => any,
+) {
+  function stringifyValue(val: any) {
+    if (typeof val === 'object' && val !== null) {
+      try {
+        return stringify(val)
+      } catch (err) {
+        // silent
+      }
+    } else if (typeof val === 'string' && typeof parser === 'function') {
+      try {
+        // Check if it's a valid parseable string.
+        // If it is, then stringify it again.
+        parser(val)
+        return stringify(val)
+      } catch (err) {
+        // silent
+      }
+    }
+    return val
+  }
+
+  return (search: Record<string, any>) => {
+    search = { ...search }
+
+    if (search) {
+      Object.keys(search).forEach((key) => {
+        const val = search[key]
+        if (typeof val === 'undefined' || val === undefined) {
+          delete search[key]
+        } else {
+          search[key] = stringifyValue(val)
+        }
+      })
+    }
+
+    const searchStr = encode(search as Record<string, string>).toString()
+
+    return searchStr ? `?${searchStr}` : ''
+  }
+}
+export type SearchSerializer = (searchObj: Record<string, any>) => string
+export type SearchParser = (searchStr: string) => Record<string, any>

package/src/utils.ts

@@ -0,0 +1,257 @@
+import * as React from 'react'
+export type NoInfer<T> = [T][T extends any ? 0 : never]
+export type IsAny<T, Y, N = T> = 1 extends 0 & T ? Y : N
+export type IsAnyBoolean<T> = 1 extends 0 & T ? true : false
+export type IsKnown<T, Y, N> = unknown extends T ? N : Y
+export type PickAsRequired<T, K extends keyof T> = Omit<T, K> &
+  Required<Pick<T, K>>
+export type PickAsPartial<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>
+export type PickUnsafe<T, K> = K extends keyof T ? Pick<T, K> : never
+export type PickExtra<T, K> = {
+  [TKey in keyof K as string extends TKey
+    ? never
+    : TKey extends keyof T
+    ? never
+    : TKey]: K[TKey]
+}
+
+export type PickRequired<T> = {
+  [K in keyof T as undefined extends T[K] ? never : K]: T[K]
+}
+
+// export type Expand<T> = T
+export type Expand<T> = T extends object
+  ? T extends infer O
+    ? { [K in keyof O]: O[K] }
+    : never
+  : T
+
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => any
+  ? I
+  : never
+
+// type Compute<T> = { [K in keyof T]: T[K] } | never
+
+// type AllKeys<T> = T extends any ? keyof T : never
+
+// export type MergeUnion<T, Keys extends keyof T = keyof T> = Compute<
+//   {
+//     [K in Keys]: T[Keys]
+//   } & {
+//     [K in AllKeys<T>]?: T extends any
+//       ? K extends keyof T
+//         ? T[K]
+//         : never
+//       : never
+//   }
+// >
+
+export type Assign<Left, Right> = Omit<Left, keyof Right> & Right
+
+export type AssignAll<T extends any[]> = T extends [infer Left, ...infer Right]
+  ? Right extends any[]
+    ? Assign<Left, AssignAll<Right>>
+    : Left
+  : {}
+
+// // Sample types to merge
+// type TypeA = {
+//   shared: string
+//   onlyInA: string
+//   nested: {
+//     shared: string
+//     aProp: string
+//   }
+//   array: string[]
+// }
+
+// type TypeB = {
+//   shared: number
+//   onlyInB: number
+//   nested: {
+//     shared: number
+//     bProp: number
+//   }
+//   array: number[]
+// }
+
+// type TypeC = {
+//   shared: boolean
+//   onlyInC: boolean
+//   nested: {
+//     shared: boolean
+//     cProp: boolean
+//   }
+//   array: boolean[]
+// }
+
+// type Test = Expand<Assign<TypeA, TypeB>>
+
+// // Using DeepMerge to merge TypeA and TypeB
+// type MergedType = Expand<AssignAll<[TypeA, TypeB, TypeC]>>
+
+export type Values<O> = O[ValueKeys<O>]
+export type ValueKeys<O> = Extract<keyof O, PropertyKey>
+
+export type DeepAwaited<T> = T extends Promise<infer A>
+  ? DeepAwaited<A>
+  : T extends Record<infer A, Promise<infer B>>
+  ? { [K in A]: DeepAwaited<B> }
+  : T
+
+export type PathParamMask<TRoutePath extends string> =
+  TRoutePath extends `${infer L}/$${infer C}/${infer R}`
+    ? PathParamMask<`${L}/${string}/${R}`>
+    : TRoutePath extends `${infer L}/$${infer C}`
+    ? PathParamMask<`${L}/${string}`>
+    : TRoutePath
+
+export type Timeout = ReturnType<typeof setTimeout>
+
+export type Updater<TPrevious, TResult = TPrevious> =
+  | TResult
+  | ((prev?: TPrevious) => TResult)
+
+export type NonNullableUpdater<TPrevious, TResult = TPrevious> =
+  | TResult
+  | ((prev: TPrevious) => TResult)
+
+export type PickExtract<T, U> = {
+  [K in keyof T as T[K] extends U ? K : never]: T[K]
+}
+
+export type PickExclude<T, U> = {
+  [K in keyof T as T[K] extends U ? never : K]: T[K]
+}
+
+//
+
+export const isServer = typeof document === 'undefined'
+
+export function last<T>(arr: T[]) {
+  return arr[arr.length - 1]
+}
+
+function isFunction(d: any): d is Function {
+  return typeof d === 'function'
+}
+
+export function functionalUpdate<TResult>(
+  updater: Updater<TResult> | NonNullableUpdater<TResult>,
+  previous: TResult,
+): TResult {
+  if (isFunction(updater)) {
+    return updater(previous as TResult)
+  }
+
+  return updater
+}
+
+export function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T, K> {
+  return keys.reduce((obj: any, key: K) => {
+    obj[key] = parent[key]
+    return obj
+  }, {} as any)
+}
+
+/**
+ * This function returns `a` if `b` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between immutable JSON values for example.
+ * Do not use this with signals
+ */
+export function replaceEqualDeep<T>(prev: any, _next: T): T {
+  if (prev === _next) {
+    return prev
+  }
+
+  const next = _next as any
+
+  const array = Array.isArray(prev) && Array.isArray(next)
+
+  if (array || (isPlainObject(prev) && isPlainObject(next))) {
+    const prevSize = array ? prev.length : Object.keys(prev).length
+    const nextItems = array ? next : Object.keys(next)
+    const nextSize = nextItems.length
+    const copy: any = array ? [] : {}
+
+    let equalItems = 0
+
+    for (let i = 0; i < nextSize; i++) {
+      const key = array ? i : nextItems[i]
+      copy[key] = replaceEqualDeep(prev[key], next[key])
+      if (copy[key] === prev[key]) {
+        equalItems++
+      }
+    }
+
+    return prevSize === nextSize && equalItems === prevSize ? prev : copy
+  }
+
+  return next
+}
+
+// Copied from: https://github.com/jonschlinkert/is-plain-object
+export function isPlainObject(o: any) {
+  if (!hasObjectPrototype(o)) {
+    return false
+  }
+
+  // If has modified constructor
+  const ctor = o.constructor
+  if (typeof ctor === 'undefined') {
+    return true
+  }
+
+  // If has modified prototype
+  const prot = ctor.prototype
+  if (!hasObjectPrototype(prot)) {
+    return false
+  }
+
+  // If constructor does not have an Object-specific method
+  if (!prot.hasOwnProperty('isPrototypeOf')) {
+    return false
+  }
+
+  // Most likely a plain Object
+  return true
+}
+
+function hasObjectPrototype(o: any) {
+  return Object.prototype.toString.call(o) === '[object Object]'
+}
+
+export function partialDeepEqual(a: any, b: any): boolean {
+  if (a === b) {
+    return true
+  }
+
+  if (typeof a !== typeof b) {
+    return false
+  }
+
+  if (isPlainObject(a) && isPlainObject(b)) {
+    return !Object.keys(b).some((key) => !partialDeepEqual(a[key], b[key]))
+  }
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return (
+      a.length === b.length &&
+      a.every((item, index) => partialDeepEqual(item, b[index]))
+    )
+  }
+
+  return false
+}
+
+export function useStableCallback<T extends (...args: any[]) => any>(fn: T): T {
+  const fnRef = React.useRef(fn)
+  fnRef.current = fn
+
+  const ref = React.useRef((...args: any[]) => fnRef.current(...args))
+  return ref.current as T
+}

package/build/cjs/awaited.js

@@ -1,45 +0,0 @@
-/**
- * @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';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var routerCore = require('@tanstack/router-core');
-var react = require('./react.js');
-
-function useAwaited({
-  promise
-}) {
-  const router = react.useRouter();
-  let state = promise.__deferredState;
-  const key = `__TSR__DEFERRED__${state.uid}`;
-  if (routerCore.isDehydratedDeferred(promise)) {
-    state = router.hydrateData(key);
-    promise = Promise.resolve(state.data);
-    promise.__deferredState = state;
-  }
-  if (state.status === 'pending') {
-    throw 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

@@ -1 +0,0 @@
-{"version":3,"file":"awaited.js","sources":["../../src/awaited.tsx"],"sourcesContent":["import { DeferredPromise, isDehydratedDeferred } from '@tanstack/router-core'\nimport { useRouter } from './react'\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 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","error","dehydrateData","Await","props","awaited","children"],"mappings":";;;;;;;;;;;;;;;;;AAOO,SAASA,UAAUA,CAAI;AAAEC,EAAAA,OAAAA;AAAyB,CAAC,EAAO;AAC/D,EAAA,MAAMC,MAAM,GAAGC,eAAS,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,+BAAoB,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,MAAMZ,OAAO,CAAA;AACf,GAAA;AAEA,EAAA,IAAIG,KAAK,CAACS,MAAM,KAAK,OAAO,EAAE;IAC5B,MAAMT,KAAK,CAACU,KAAK,CAAA;AACnB,GAAA;AAEAZ,EAAAA,MAAM,CAACa,aAAa,CAACT,GAAG,EAAEF,KAAK,CAAC,CAAA;AAEhC,EAAA,OAAO,CAACA,KAAK,CAACQ,IAAI,CAAC,CAAA;AACrB,CAAA;AAEO,SAASI,KAAKA,CACnBC,KAEC,EACD;AACA,EAAA,MAAMC,OAAO,GAAGlB,UAAU,CAACiB,KAAK,CAAC,CAAA;AACjC,EAAA,OAAOA,KAAK,CAACE,QAAQ,CAAC,GAAGD,OAAO,CAAC,CAAA;AACnC;;;;;"}

package/build/cjs/scroll-restoration.js

@@ -1,56 +0,0 @@
-/**
- * @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';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var React = require('react');
-var routerCore = require('@tanstack/router-core');
-var react = require('./react.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return 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__*/_interopNamespace(React);
-
-const useLayoutEffect = typeof window !== 'undefined' ? React__namespace.useLayoutEffect : React__namespace.useEffect;
-function useScrollRestoration(options) {
-  const router = react.useRouter();
-  useLayoutEffect(() => {
-    return routerCore.watchScrollPositions(router, options);
-  }, []);
-  useLayoutEffect(() => {
-    routerCore.restoreScrollPositions(router, options);
-  });
-}
-function ScrollRestoration(props) {
-  useScrollRestoration(props);
-  return null;
-}
-
-exports.ScrollRestoration = ScrollRestoration;
-exports.useScrollRestoration = useScrollRestoration;
-//# sourceMappingURL=scroll-restoration.js.map

package/build/cjs/scroll-restoration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scroll-restoration.js","sources":["../../src/scroll-restoration.tsx"],"sourcesContent":["import * as React from 'react'\nimport {\n  ScrollRestorationOptions,\n  restoreScrollPositions,\n  watchScrollPositions,\n} from '@tanstack/router-core'\nimport { useRouter } from './react'\n\nconst useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\nexport function useScrollRestoration(options?: ScrollRestorationOptions) {\n  const router = useRouter()\n\n  useLayoutEffect(() => {\n    return watchScrollPositions(router, options)\n  }, [])\n\n  useLayoutEffect(() => {\n    restoreScrollPositions(router, options)\n  })\n}\n\nexport function ScrollRestoration(props: ScrollRestorationOptions) {\n  useScrollRestoration(props)\n  return null\n}\n"],"names":["useLayoutEffect","window","React","useEffect","useScrollRestoration","options","router","useRouter","watchScrollPositions","restoreScrollPositions","ScrollRestoration","props"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,MAAMA,eAAe,GACnB,OAAOC,MAAM,KAAK,WAAW,GAAGC,gBAAK,CAACF,eAAe,GAAGE,gBAAK,CAACC,SAAS,CAAA;AAElE,SAASC,oBAAoBA,CAACC,OAAkC,EAAE;AACvE,EAAA,MAAMC,MAAM,GAAGC,eAAS,EAAE,CAAA;AAE1BP,EAAAA,eAAe,CAAC,MAAM;AACpB,IAAA,OAAOQ,+BAAoB,CAACF,MAAM,EAAED,OAAO,CAAC,CAAA;GAC7C,EAAE,EAAE,CAAC,CAAA;AAENL,EAAAA,eAAe,CAAC,MAAM;AACpBS,IAAAA,iCAAsB,CAACH,MAAM,EAAED,OAAO,CAAC,CAAA;AACzC,GAAC,CAAC,CAAA;AACJ,CAAA;AAEO,SAASK,iBAAiBA,CAACC,KAA+B,EAAE;EACjEP,oBAAoB,CAACO,KAAK,CAAC,CAAA;AAC3B,EAAA,OAAO,IAAI,CAAA;AACb;;;;;"}