@native-router/core 1.0.0

package/README.md

@@ -0,0 +1,79 @@
+[![npm](https://img.shields.io/npm/v/@native-router/core.svg)](https://www.npmjs.com/package/@native-router/core)
+[![Build Status](https://github.com/wmzy/@native-router/core/actions/workflows/ci.yml/badge.svg)](https://github.com/wmzy/@native-router/core/actions)
+[![Coverage](https://img.shields.io/codecov/c/github/wmzy/@native-router/core.svg)](https://codecov.io/gh/wmzy/@native-router/core)
+[![install size](https://packagephobia.now.sh/badge?p=@native-router/core)](https://packagephobia.now.sh/result?p=@native-router/core)
+
+# Native Router React
+
+> A route close to the native experience for react.
+
+English | [简体中文](./README-zh_CN.md)
+
+## Features
+
+- Asynchronous navigation
+- Cancelable
+- Page data concurrent fetch
+- Link prefetch and preview
+- Most unused features can be tree-shaking
+- SSR support
+
+## Install
+
+```bash
+npm i @native-router/core
+```
+
+## Usage
+
+```tsx
+import {View, HistoryRouter as Router} from '@native-router/core';
+import Loading from '@/components/Loading';
+import RouterError from '@/components/RouterError';
+import * as userService from '@/services/user';
+
+export default function App() {
+  return (
+    <Router
+      routes={{
+        component: () => import('./Layout'),
+        children: [
+          {
+            path: '/',
+            component: () => import('./Home')
+          },
+          {
+            path: '/users',
+            component: () => import('./UserList'),
+            data: userService.fetchList
+          },
+          {
+            path: '/users/:id',
+            component: () => import('./UserProfile'),
+            data: ({id}) => userService.fetchById(+id)
+          },
+          {
+            path: '/help',
+            component: () => import('./Help')
+          },
+          {
+            path: '/about',
+            component: () => import('./About')
+          }
+        ]
+      }}
+      baseUrl="/demos"
+      errorHandler={(e) => <RouterError error={e} />}
+    >
+      <View />
+      <Loading />
+    </Router>
+  );
+}
+
+```
+See [demos](/demos/) for a complete example.
+
+## Documentation 
+
+[API](https://wmzy.github.io/@native-router/core/modules.html)

package/dist/index.mjs

@@ -0,0 +1,393 @@
+import { parsePath, createPath } from 'history';
+import { match as match$1 } from 'path-to-regexp';
+
+let i = 1;
+function uniqId() {
+  return i++;
+}
+function noop() {}
+const reject = /* @__PURE__ */Promise.reject.bind(Promise);
+function cancelPromise() {
+  return new Promise(noop);
+}
+function createCurrentGuard() {
+  let current;
+  return [function currentGuard(promise) {
+    const cur = uniqId();
+    current = cur;
+    return promise.then(result => current === cur ? result : cancelPromise()).catch(err => current === cur ? Promise.reject(err) : cancelPromise());
+  }, function cancel() {
+    current = undefined;
+  }];
+}
+
+/* eslint-disable max-classes-per-file */
+
+class NativeRouterError extends Error {}
+class NotFoundError extends NativeRouterError {
+  constructor(pathname) {
+    super(`Can't find the path: ${pathname}`);
+  }
+}
+
+/**
+ * Create a router instance.
+ * @group Methods
+ * @category Router
+ * @param routes routes config
+ * @param history {@link https://www.npmjs.com/package/history history} instance
+ * @param resolveView a callback to resolve view. see {@link defaultResolveView}
+ * @param options options
+ * @returns a router instance
+ */
+function create(routes, history, resolveView, options) {
+  const [currentGuard, cancelAll] = createCurrentGuard();
+  const {
+    index,
+    locationStack
+  } = getHistoryState({
+    history: history
+  });
+  const viewStack = new Array(locationStack.length).fill(null);
+  if (options?.currentView) {
+    viewStack[index] = options.currentView;
+  }
+  return {
+    routes: Array.isArray(routes) ? routes : [routes],
+    resolveView,
+    history: history,
+    locationStack,
+    viewStack,
+    currentGuard,
+    cancelAll,
+    errorHandler: reject,
+    ...options,
+    baseUrl: options?.baseUrl || ''
+  };
+}
+function setOptions(router, options) {
+  return Object.assign(router, options);
+}
+function getLocation({
+  history
+}) {
+  const state = history.location.state || {};
+  return {
+    ...history.location,
+    state: state.state
+  };
+}
+function getHistoryState(router) {
+  const {
+    location
+  } = router.history;
+  const state = location.state || {};
+  return {
+    index: state.index || 0,
+    locationStack: state.locationStack || [getLocation(router)]
+  };
+}
+function getCurrentView(router) {
+  return router.viewStack[getHistoryState(router).index];
+}
+
+/**
+ * Match a path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param pathname the pathname
+ * @returns the matched result
+ */
+function match(router, pathname) {
+  function matchRoutes(routes, baseUrl,
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  pathname) {
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+      const end = !route.children;
+      const matched = route.path ? match$1(route.path, {
+        strict: true,
+        sensitive: true,
+        decode: typeof decodeURIComponent === 'function' ? decodeURIComponent : undefined,
+        end
+      })(pathname) : {
+        path: '',
+        index: 0,
+        params: {}
+      };
+      if (matched) {
+        const result = {
+          route,
+          ...matched
+        };
+        if (end) return [result];
+        const children = matchRoutes(route.children, `${baseUrl}${route.path || ''}`, pathname.slice(matched.path.length));
+        if (children) return [result, ...children];
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+  return matchRoutes(router.routes, router.baseUrl, pathname.slice(router.baseUrl.length));
+}
+
+/**
+ * Path to Location.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to path string
+ * @param state the state of location
+ * @returns location
+ */
+function toLocation(router, to, state) {
+  const {
+    baseUrl
+  } = router;
+  return {
+    pathname: '',
+    search: '',
+    hash: '',
+    ...parsePath(baseUrl + to),
+    state
+  };
+}
+
+/**
+ * Resolve a location.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param location history instance
+ * @returns resolve task(a promise)
+ */
+function resolve(router, location) {
+  const matched = match(router, location.pathname);
+  const {
+    resolveView,
+    errorHandler
+  } = router;
+  return (matched ? resolveView(matched, {
+    router,
+    location
+  }) : Promise.reject(new NotFoundError(location.pathname))).catch(errorHandler);
+}
+
+/**
+ * Resolve a path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to the path
+ * @param state state of the path location
+ * @returns resolve task(a promise)
+ */
+function resolveTo(router, to, state) {
+  const location = toLocation(router, to, state);
+  return resolve(router, location);
+}
+
+/**
+ * Commit the resolve task and push history.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param resolvePromise resolve task(a promise)
+ * @param location the location to resolved
+ */
+function commit(router, resolvePromise, location) {
+  const {
+    history
+  } = router;
+  const nextIndex = getHistoryState(router).index + 1;
+  return commitBase(router, resolvePromise, location, resolvedView => {
+    router.locationStack = [...router.locationStack.slice(0, nextIndex), location];
+    router.viewStack = [...router.viewStack.slice(0, nextIndex), resolvedView];
+    history.push(location, {
+      index: nextIndex,
+      locationStack: router.locationStack,
+      state: location.state
+    });
+  });
+}
+
+/**
+ * Commit the resolve task and replace history.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param resolvePromise resolve task(a promise)
+ * @param location the location to resolved
+ */
+function commitReplace(router, resolvePromise, location) {
+  const {
+    history
+  } = router;
+  const {
+    index
+  } = getHistoryState(router);
+  return commitBase(router, resolvePromise, location, resolvedView => {
+    router.locationStack[index] = location;
+    router.viewStack[index] = resolvedView;
+    history.replace(location, {
+      index,
+      locationStack: router.locationStack,
+      state: location.state
+    });
+  });
+}
+function commitBase(router, resolvePromise, location, onResolved) {
+  const {
+    currentGuard,
+    onLoadingChange = noop
+  } = router;
+  if (router.resolving) {
+    // Cancel current resolve
+    onLoadingChange();
+  }
+  router.resolving = location;
+  onLoadingChange('pending');
+  return currentGuard(resolvePromise).then(onResolved)
+  // eslint-disable-next-line no-void
+  .then(() => void onLoadingChange('resolved')).catch(e => {
+    onLoadingChange('rejected');
+    throw e;
+  });
+}
+
+/**
+ * Navigate to a new path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to path string
+ * @param state location state
+ */
+function navigate(router, to, state) {
+  const location = toLocation(router, to, state);
+  const viewPromise = resolve(router, location);
+  return commit(router, viewPromise, location);
+}
+
+/**
+ * Refresh the page.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function refresh(router) {
+  const location = getLocation(router);
+  const viewPromise = resolve(router, location);
+  return commitReplace(router, viewPromise, location);
+}
+
+/**
+ * Navigate in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param delta history stack index
+ */
+function go(router, delta) {
+  router.history.go(delta);
+}
+
+/**
+ * Forward in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function forward(router) {
+  router.history.forward();
+}
+
+/**
+ * Back in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function back(router) {
+  router.history.back();
+}
+
+/**
+ * Create href of a route path. For {@link Link Link Component} hover url preview.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to route path
+ * @returns href
+ */
+function createHref({
+  baseUrl,
+  history
+}, to) {
+  return baseUrl + history.createHref(to);
+}
+
+/**
+ * Cancel the current navigate.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+function cancel({
+  cancelAll,
+  onLoadingChange = noop
+}) {
+  cancelAll();
+  onLoadingChange();
+}
+function initHistoryStack(router) {
+  const {
+    history
+  } = router;
+  const {
+    locationStack
+  } = getHistoryState(router);
+  return Promise.all(locationStack.map(l => resolve(router, l))).then(views => {
+    router.viewStack = views;
+    history.replace(createPath(history.location), history.location.state);
+  });
+}
+
+/**
+ * Listen the history change.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param onViewChange a callback function will be call when view changed
+ * @returns unlisten - A function that may be used to stop listening
+ */
+function listen(router, onViewChange) {
+  const {
+    history
+  } = router;
+  const rmListener = history.listen(({
+    action,
+    location
+  }) => {
+    cancel(router);
+    const state = location.state;
+    const index = state?.index || 0;
+    const view = router.viewStack[index];
+    onViewChange(view);
+    if (!view) refresh(router);
+    if (action === 'POP') {
+      history.replace(createPath(history.location), {
+        ...state,
+        locationStack: router.locationStack
+      });
+    }
+  });
+  history.replace(createPath(history.location), history.location.state);
+  return () => {
+    cancel(router);
+    rmListener();
+  };
+}
+
+export { NativeRouterError, NotFoundError, back, cancel, commit, commitReplace, create, createHref, forward, getCurrentView, getLocation, go, initHistoryStack, listen, match, navigate, refresh, resolve, resolveTo, setOptions, toLocation };

package/dist/types/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class NativeRouterError extends Error {
+}
+export declare class NotFoundError extends NativeRouterError {
+    constructor(pathname: string);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './router';
+export * from './errors';
+export type * from './types';

package/dist/types/router.d.ts

@@ -0,0 +1,154 @@
+import { History } from 'history';
+import type { Location, Matched, Options, BaseRoute, RouterInstance, ResolveView } from './types';
+/**
+ * Create a router instance.
+ * @group Methods
+ * @category Router
+ * @param routes routes config
+ * @param history {@link https://www.npmjs.com/package/history history} instance
+ * @param resolveView a callback to resolve view. see {@link defaultResolveView}
+ * @param options options
+ * @returns a router instance
+ */
+export declare function create<R extends BaseRoute = BaseRoute, V = any>(routes: R | R[], history: History, resolveView: ResolveView<R, V>, options?: Options<V>): RouterInstance<R, V>;
+export declare function setOptions<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, options: Omit<Options<V>, 'currentView'>): {
+    routes: R[];
+    baseUrl: string;
+    history: History & {
+        location: import("./types").WrappedLocation;
+    };
+    viewStack: V[];
+    locationStack: Location<any>[];
+    resolveView: ResolveView<R, V>;
+    currentGuard<T>(promise: Promise<T>): Promise<T>;
+    cancelAll(): void;
+    resolving?: Location<any> | undefined;
+} & Required<Pick<Options<V>, "baseUrl">> & Omit<Options<V>, "baseUrl"> & Omit<Options<V>, "currentView">;
+export declare function getLocation({ history }: Pick<RouterInstance<any>, 'history'>): {
+    state: any;
+    key: string;
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export declare function getCurrentView<R extends BaseRoute = BaseRoute>(router: RouterInstance<R>): any;
+/**
+ * Match a path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param pathname the pathname
+ * @returns the matched result
+ */
+export declare function match<R extends BaseRoute = BaseRoute>(router: RouterInstance<R>, pathname: string): Matched<R>[] | undefined;
+/**
+ * Path to Location.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to path string
+ * @param state the state of location
+ * @returns location
+ */
+export declare function toLocation<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, to: string, state?: any): Location;
+/**
+ * Resolve a location.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param location history instance
+ * @returns resolve task(a promise)
+ */
+export declare function resolve<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, location: Location): Promise<V>;
+/**
+ * Resolve a path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to the path
+ * @param state state of the path location
+ * @returns resolve task(a promise)
+ */
+export declare function resolveTo<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, to: string, state?: any): Promise<V>;
+/**
+ * Commit the resolve task and push history.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param resolvePromise resolve task(a promise)
+ * @param location the location to resolved
+ */
+export declare function commit<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, resolvePromise: Promise<V>, location: Location): Promise<void>;
+/**
+ * Commit the resolve task and replace history.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param resolvePromise resolve task(a promise)
+ * @param location the location to resolved
+ */
+export declare function commitReplace<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, resolvePromise: Promise<V>, location: Location): Promise<void>;
+/**
+ * Navigate to a new path.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to path string
+ * @param state location state
+ */
+export declare function navigate<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, to: string, state?: any): Promise<void>;
+/**
+ * Refresh the page.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+export declare function refresh<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>): Promise<void>;
+/**
+ * Navigate in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param delta history stack index
+ */
+export declare function go<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, delta: number): void;
+/**
+ * Forward in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+export declare function forward<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>): void;
+/**
+ * Back in history stack.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+export declare function back<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>): void;
+/**
+ * Create href of a route path. For {@link Link Link Component} hover url preview.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param to route path
+ * @returns href
+ */
+export declare function createHref<R extends BaseRoute = BaseRoute, V = any>({ baseUrl, history }: RouterInstance<R, V>, to: string): string;
+/**
+ * Cancel the current navigate.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ */
+export declare function cancel<R extends BaseRoute = BaseRoute, V = any>({ cancelAll, onLoadingChange }: RouterInstance<R, V>): void;
+export declare function initHistoryStack<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>): Promise<void>;
+/**
+ * Listen the history change.
+ * @group Methods
+ * @category Router
+ * @param router router instance
+ * @param onViewChange a callback function will be call when view changed
+ * @returns unlisten - A function that may be used to stop listening
+ */
+export declare function listen<R extends BaseRoute = BaseRoute, V = any>(router: RouterInstance<R, V>, onViewChange: (v: V) => void): () => void;

package/dist/types/types.d.ts

@@ -0,0 +1,74 @@
+import type { Path, MatchResult } from 'path-to-regexp';
+import type { History, Path as HPath } from 'history';
+import type { AnchorHTMLAttributes, ComponentType, Context as ReactContext, DetailedHTMLProps, ReactNode } from 'react';
+export type Location<T = any> = HPath & {
+    state?: T;
+};
+export type HistoryState = {
+    locationStack: Location[];
+    index: number;
+    state?: any;
+};
+export type WrappedLocation = Location<HistoryState>;
+export type Awaitable<T> = T | Promise<T>;
+export type BaseRoute<T = any> = {
+    path?: Path;
+    children?: BaseRoute<T>[];
+} & Omit<T, 'path' | 'children'>;
+export type Matched<R extends BaseRoute = BaseRoute> = {
+    route: R;
+} & MatchResult<Record<string, string>>;
+export type ResolveViewContext<R extends BaseRoute> = {
+    router: RouterInstance<R>;
+    location: Location;
+};
+export type ResolveView<R extends BaseRoute, V> = (matched: Matched<R>[], ctx: ResolveViewContext<R>) => Promise<V>;
+export type Options<V> = {
+    baseUrl?: string;
+    currentView?: V;
+    errorHandler?(e: Error): V | Promise<V>;
+    onLoadingChange?(status?: 'pending' | 'resolved' | 'rejected'): void;
+};
+export type RequiredOf<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
+export type RouterInstance<R extends BaseRoute, V = any> = {
+    routes: R[];
+    baseUrl: string;
+    history: History & {
+        location: WrappedLocation;
+    };
+    viewStack: V[];
+    locationStack: Location[];
+    resolveView: ResolveView<R, V>;
+    currentGuard<T>(promise: Promise<T>): Promise<T>;
+    cancelAll(): void;
+    resolving?: Location;
+} & RequiredOf<Options<V>, 'baseUrl'>;
+export type Context<T extends BaseRoute> = {
+    matched: Matched<T>[];
+    index: number;
+    router: RouterInstance<BaseRoute>;
+    location: Location;
+    params: Record<string, string>;
+};
+export type Route = BaseRoute<{
+    name?: string;
+    data?(ctx: Context<Route>): any | Promise<any>;
+    component?(ctx: Context<Route>): ComponentType | Promise<ComponentType | {
+        default: ComponentType;
+    }>;
+}>;
+export type StateContext<S> = {
+    SetterContext: ReactContext<((v: S) => void) | undefined>;
+    ValueContext: ReactContext<S | undefined>;
+    Provider: ComponentType<{
+        children: ReactNode;
+    }>;
+};
+export type LoadStatus = {
+    key: number;
+    status: 'pending' | 'resolved' | 'rejected';
+};
+export type LinkProps = {
+    to: string;
+    children?: ReactNode;
+} & DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;

package/dist/types/util.d.ts

@@ -0,0 +1,12 @@
+export declare function uniqId(): number;
+export declare function noop(): void;
+export declare const resolve: {
+    (): Promise<void>;
+    <T>(value: T): Promise<Awaited<T>>;
+    <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>;
+};
+export declare const reject: <T = never>(reason?: any) => Promise<T>;
+export declare function cancelPromise(): Promise<unknown>;
+export declare function createCurrentGuard(): readonly [<T>(promise: Promise<T>) => Promise<T>, () => void];
+export declare function splitProps<T extends object = object, K extends keyof T = keyof T>(obj: T, keys: K[]): [Pick<T, K>, Omit<T, K>];
+export declare function isString(maybeString: unknown): maybeString is string;

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@native-router/core",
+  "version": "1.0.0",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "types": "./dist/types/index.d.ts",
+  "keywords": [
+    "react",
+    "router",
+    "react router",
+    "react-router",
+    "async",
+    "tiny",
+    "data-fetching",
+    "prefetch",
+    "preview"
+  ],
+  "description": "A route close to the native experience for react.",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "npm test -- --watch",
+    "build": "rm -rf dist && rollup -c && tsc -p tsconfig.production.json && tsc-alias -p tsconfig.production.json",
+    "commit": "lint-staged && git-cz -n",
+    "coverage": "nyc report --reporter=text-lcov > ./.nyc_output/coverage.txt",
+    "lint": "eslint --fix src test demos *.js --ext .js,.jsx,.ts,.tsx",
+    "doc:gen": "typedoc",
+    "deploy": "npm run doc:gen && npm run build:demo && gh-pages -d dist",
+    "test": "cross-env NODE_ENV=test nyc mocha",
+    "preversion": "npm run build",
+    "postversion": "npm publish",
+    "postpublish": "git push --follow-tags && npm run deploy"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wmzy/@native-router/core"
+  },
+  "sideEffects": false,
+  "author": "wmzy",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wmzy/@native-router/core/issues"
+  },
+  "homepage": "https://github.com/wmzy/@native-router/core",
+  "engines": {
+    "node": ">=14"
+  },
+  "peerDependencies": {
+    "react": "^17.0.0 || ^18.0.0",
+    "react-dom": "^17.0.0 || ^18.0.0"
+  },
+  "dependencies": {
+    "history": "^5.3.0",
+    "path-to-regexp": "^6.2.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.22.9",
+    "@babel/preset-env": "^7.22.9",
+    "@babel/preset-react": "^7.22.5",
+    "@babel/preset-typescript": "^7.22.5",
+    "@babel/register": "^7.22.5",
+    "@linaria/babel-preset": "^4.5.4",
+    "@linaria/core": "^4.5.4",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-commonjs": "^25.0.4",
+    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@rollup/plugin-replace": "^5.0.2",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.4.5",
+    "@types/react": "^18.2.16",
+    "@types/react-dom": "^18.2.7",
+    "@types/sinon": "^10.0.15",
+    "@typescript-eslint/eslint-plugin": "^6.2.0",
+    "@typescript-eslint/parser": "^6.2.0",
+    "@vitejs/plugin-react": "^4.0.3",
+    "babel-plugin-module-resolver": "^5.0.0",
+    "commitizen": "^4.3.0",
+    "core-js": "^3.31.1",
+    "coveralls": "^3.1.1",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.45.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-airbnb-typescript": "^17.1.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-compat": "^4.1.4",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-jsx-a11y": "^6.7.1",
+    "eslint-plugin-mocha": "^10.1.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-react": "^7.33.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "gh-pages": "^5.0.0",
+    "global-jsdom": "^9.0.1",
+    "husky": "^8.0.3",
+    "jsdom": "^22.1.0",
+    "lint-staged": "^13.2.3",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0",
+    "prettier": "^3.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rollup": "^3.28.0",
+    "should": "^13.2.3",
+    "should-sinon": "0.0.6",
+    "sinon": "^15.2.0",
+    "terser": "^5.19.2",
+    "tsc-alias": "^1.8.7",
+    "typedoc": "^0.24.8",
+    "typedoc-plugin-mark-react-functional-components": "^0.2.2",
+    "typedoc-plugin-missing-exports": "^2.0.0",
+    "typescript": "^5.1.6"
+  }
+}