@tanem/react-nprogress 6.0.4 → 7.1.0

package/dist/react-nprogress.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-nprogress.mjs","names":["defaultIncrement","increment"],"sources":["../src/clamp.ts","../src/createTimeout.ts","../src/increment.ts","../src/useNProgress.tsx","../src/NProgress.tsx"],"sourcesContent":["export const clamp = (num: number, lower: number, upper: number): number => {\n  num = num <= upper ? num : upper\n  num = num >= lower ? num : lower\n  return num\n}\n","// Uses requestAnimationFrame rather than setTimeout for smoother animation\n// timing. Note that rAF is throttled or paused in background tabs, so progress\n// will stall when the tab is hidden and resume when it regains focus.\nexport const createTimeout = () => {\n  let handle: number | undefined\n\n  const cancel = (): void => {\n    if (handle !== undefined) {\n      window.cancelAnimationFrame(handle)\n    }\n  }\n\n  const schedule = (callback: () => void, delay: number): void => {\n    cancel()\n\n    let deltaTime\n    let start: number | undefined\n    const frame: FrameRequestCallback = (time) => {\n      start = start || time\n      deltaTime = time - start\n      if (deltaTime > delay) {\n        callback()\n        return\n      }\n      handle = window.requestAnimationFrame(frame)\n    }\n\n    handle = window.requestAnimationFrame(frame)\n  }\n\n  return {\n    cancel,\n    schedule,\n  }\n}\n","import { clamp } from './clamp'\n\nexport const increment = (progress: number): number => {\n  let amount = 0\n\n  if (progress >= 0 && progress < 0.2) {\n    amount = 0.1\n  } else if (progress >= 0.2 && progress < 0.5) {\n    amount = 0.04\n  } else if (progress >= 0.5 && progress < 0.8) {\n    amount = 0.02\n  } else if (progress >= 0.8 && progress < 0.99) {\n    amount = 0.005\n  }\n\n  return clamp(progress + amount, 0, 0.994)\n}\n","import { useEffect, useReducer, useRef } from 'react'\n\nimport { clamp } from './clamp'\nimport { createTimeout } from './createTimeout'\nimport { increment as defaultIncrement } from './increment'\nimport type { NProgressOptions, NProgressState } from './types'\n\n// A four-phase state machine. `idle` and `finished` both report\n// `isFinished: true` and differ only in the progress they hold, so the phase,\n// not `isFinished`, is what decides which transitions and timers apply.\ntype Phase = 'animating' | 'completing' | 'finished' | 'idle'\n\ninterface State {\n  phase: Phase\n  progress: number\n}\n\ntype Action =\n  | {\n      increment: (progress: number) => number\n      minimum: number\n      type: 'trickle'\n    }\n  | { minimum: number; type: 'start' }\n  | { type: 'complete' }\n  | { type: 'finish' }\n\nconst initialState: State = {\n  phase: 'idle',\n  progress: 0,\n}\n\nconst reducer = (state: State, action: Action): State => {\n  switch (action.type) {\n    case 'complete':\n      // The original nprogress `done()` computes a random progress jump before\n      // animating to 1, but its queue runs both steps in the same tick, so the\n      // jump's CSS is overwritten before paint and never renders. Omitting the\n      // jump changes nothing visually.\n      //\n      // Ignored unless an animation is actually running, which is what makes a\n      // StrictMode double-mount a no-op rather than a spurious completion.\n      return state.phase === 'animating'\n        ? { phase: 'completing', progress: 1 }\n        : state\n\n    case 'finish':\n      return { phase: 'finished', progress: 1 }\n\n    case 'start':\n      // Matches the original nprogress `start()`, which calls set(0) and so\n      // paints first at `minimum` before any trickle runs.\n      //\n      // Guarded the same way as `complete`, and for the same reason: a repeat\n      // dispatch against a running animation must not rewind the bar. That\n      // happens whenever `minimum` changes mid-animation, as well as on a\n      // StrictMode double-mount.\n      return state.phase === 'animating'\n        ? state\n        : {\n            phase: 'animating',\n            progress: clamp(0, action.minimum, 1),\n          }\n\n    case 'trickle':\n      // Clamped here rather than trusted from the increment function, so a\n      // custom one cannot take the bar outside the documented range. Stopping\n      // short of 1 is that function's own business: 1 is what completion\n      // means.\n      return {\n        ...state,\n        progress: clamp(action.increment(state.progress), action.minimum, 1),\n      }\n  }\n}\n\nexport const useNProgress = ({\n  animationDuration = 200,\n  increment = defaultIncrement,\n  incrementDuration = 200,\n  isAnimating = false,\n  minimum = 0.08,\n}: NProgressOptions = {}): NProgressState => {\n  const [{ phase, progress }, dispatch] = useReducer(reducer, initialState)\n\n  // Held in a ref so the trickle timer can read the latest increment function\n  // without listing it as a dependency. Consumers commonly pass an inline\n  // function, whose identity changes every render; depending on it directly\n  // would cancel and recreate the timer each time, and a render loop faster\n  // than `incrementDuration` would stop the bar advancing altogether.\n  const incrementRef = useRef(increment)\n  useEffect(() => {\n    incrementRef.current = increment\n  })\n\n  useEffect(() => {\n    dispatch(isAnimating ? { minimum, type: 'start' } : { type: 'complete' })\n  }, [isAnimating, minimum])\n\n  // A timer per running phase, rather than one effect branching over both.\n  // Each then depends only on the options its own phase reads, so changing an\n  // option the running phase ignores cannot cancel its timer. Both are keyed\n  // on the phase rather than on progress, so trickling does not tear down and\n  // recreate the timer mid-animation.\n  useEffect(() => {\n    if (phase !== 'animating') {\n      return\n    }\n\n    const timeout = createTimeout()\n\n    const trickle = () => {\n      dispatch({ increment: incrementRef.current, minimum, type: 'trickle' })\n      timeout.schedule(trickle, incrementDuration)\n    }\n    timeout.schedule(trickle, incrementDuration)\n\n    return () => timeout.cancel()\n  }, [incrementDuration, minimum, phase])\n\n  useEffect(() => {\n    if (phase !== 'completing') {\n      return\n    }\n\n    const timeout = createTimeout()\n    timeout.schedule(() => dispatch({ type: 'finish' }), animationDuration)\n\n    return () => timeout.cancel()\n  }, [animationDuration, phase])\n\n  return {\n    animationDuration,\n    isFinished: phase === 'finished' || phase === 'idle',\n    progress,\n  }\n}\n","import type { FC, ReactElement } from 'react'\n\nimport type { NProgressOptions, NProgressState } from './types'\nimport { useNProgress } from './useNProgress'\n\ntype Props = NProgressOptions & {\n  children: (renderProps: NProgressState) => ReactElement\n}\n\nexport const NProgress: FC<Props> = ({ children, ...restProps }: Props) => {\n  const renderProps = useNProgress(restProps)\n  return children(renderProps)\n}\n"],"mappings":";;;AAAA,MAAa,SAAS,KAAa,OAAe,UAA0B;CAC1E,MAAM,OAAO,QAAQ,MAAM;CAC3B,MAAM,OAAO,QAAQ,MAAM;CAC3B,OAAO;AACT;;;ACDA,MAAa,sBAAsB;CACjC,IAAI;CAEJ,MAAM,eAAqB;EACzB,IAAI,WAAW,KAAA,GACb,OAAO,qBAAqB,MAAM;CAEtC;CAEA,MAAM,YAAY,UAAsB,UAAwB;EAC9D,OAAO;EAEP,IAAI;EACJ,IAAI;EACJ,MAAM,SAA+B,SAAS;GAC5C,QAAQ,SAAS;GACjB,YAAY,OAAO;GACnB,IAAI,YAAY,OAAO;IACrB,SAAS;IACT;GACF;GACA,SAAS,OAAO,sBAAsB,KAAK;EAC7C;EAEA,SAAS,OAAO,sBAAsB,KAAK;CAC7C;CAEA,OAAO;EACL;EACA;CACF;AACF;;;AChCA,MAAa,aAAa,aAA6B;CACrD,IAAI,SAAS;CAEb,IAAI,YAAY,KAAK,WAAW,IAC9B,SAAS;MACJ,IAAI,YAAY,MAAO,WAAW,IACvC,SAAS;MACJ,IAAI,YAAY,MAAO,WAAW,IACvC,SAAS;MACJ,IAAI,YAAY,MAAO,WAAW,KACvC,SAAS;CAGX,OAAO,MAAM,WAAW,QAAQ,GAAG,IAAK;AAC1C;;;ACWA,MAAM,eAAsB;CAC1B,OAAO;CACP,UAAU;AACZ;AAEA,MAAM,WAAW,OAAc,WAA0B;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,YAQH,OAAO,MAAM,UAAU,cACnB;GAAE,OAAO;GAAc,UAAU;EAAE,IACnC;EAEN,KAAK,UACH,OAAO;GAAE,OAAO;GAAY,UAAU;EAAE;EAE1C,KAAK,SAQH,OAAO,MAAM,UAAU,cACnB,QACA;GACE,OAAO;GACP,UAAU,MAAM,GAAG,OAAO,SAAS,CAAC;EACtC;EAEN,KAAK,WAKH,OAAO;GACL,GAAG;GACH,UAAU,MAAM,OAAO,UAAU,MAAM,QAAQ,GAAG,OAAO,SAAS,CAAC;EACrE;CACJ;AACF;AAEA,MAAa,gBAAgB,EAC3B,oBAAoB,KACpB,WAAA,cAAYA,WACZ,oBAAoB,KACpB,cAAc,OACd,UAAU,QACU,CAAC,MAAsB;CAC3C,MAAM,CAAC,EAAE,OAAO,YAAY,YAAY,WAAW,SAAS,YAAY;CAOxE,MAAM,eAAe,OAAOC,WAAS;CACrC,gBAAgB;EACd,aAAa,UAAUA;CACzB,CAAC;CAED,gBAAgB;EACd,SAAS,cAAc;GAAE;GAAS,MAAM;EAAQ,IAAI,EAAE,MAAM,WAAW,CAAC;CAC1E,GAAG,CAAC,aAAa,OAAO,CAAC;CAOzB,gBAAgB;EACd,IAAI,UAAU,aACZ;EAGF,MAAM,UAAU,cAAc;EAE9B,MAAM,gBAAgB;GACpB,SAAS;IAAE,WAAW,aAAa;IAAS;IAAS,MAAM;GAAU,CAAC;GACtE,QAAQ,SAAS,SAAS,iBAAiB;EAC7C;EACA,QAAQ,SAAS,SAAS,iBAAiB;EAE3C,aAAa,QAAQ,OAAO;CAC9B,GAAG;EAAC;EAAmB;EAAS;CAAK,CAAC;CAEtC,gBAAgB;EACd,IAAI,UAAU,cACZ;EAGF,MAAM,UAAU,cAAc;EAC9B,QAAQ,eAAe,SAAS,EAAE,MAAM,SAAS,CAAC,GAAG,iBAAiB;EAEtE,aAAa,QAAQ,OAAO;CAC9B,GAAG,CAAC,mBAAmB,KAAK,CAAC;CAE7B,OAAO;EACL;EACA,YAAY,UAAU,cAAc,UAAU;EAC9C;CACF;AACF;;;AC/HA,MAAa,aAAwB,EAAE,UAAU,GAAG,gBAAuB;CAEzE,OAAO,SADa,aAAa,SACP,CAAC;AAC7B"}

package/package.json

@@ -1,40 +1,67 @@
 {
   "name": "@tanem/react-nprogress",
-  "version": "6.0.4",
+  "version": "7.1.0",
   "description": "A React primitive for building slim progress bars.",
-  "main": "dist/index.js",
-  "module": "dist/react-nprogress.esm.js",
-  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/react-nprogress.d.mts",
+        "default": "./dist/react-nprogress.mjs"
+      },
+      "default": {
+        "types": "./dist/react-nprogress.d.cts",
+        "default": "./dist/react-nprogress.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/react-nprogress.cjs",
+  "module": "dist/react-nprogress.mjs",
+  "types": "dist/react-nprogress.d.cts",
   "sideEffects": false,
+  "size-limit": [
+    {
+      "name": "ESM bundle",
+      "path": "dist/react-nprogress.mjs",
+      "gzip": true,
+      "limit": "1.2 kB"
+    },
+    {
+      "name": "CJS bundle",
+      "path": "dist/react-nprogress.cjs",
+      "gzip": true,
+      "limit": "1.3 kB"
+    }
+  ],
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "authors": "tanem-scripts authors > AUTHORS",
-    "build": "run-s clean compile bundle",
-    "bundle": "rollup -c",
+    "build": "run-s clean bundle",
+    "bundle": "tsdown",
     "changelog": "tanem-scripts changelog -f v$npm_package_version > CHANGELOG.md",
-    "check:format": "prettier --list-different \"**/*.{js,ts,tsx}\"",
+    "check:format": "prettier --list-different \"**/*.{cjs,cts,js,mjs,mts,ts,tsx}\"",
     "check:types": "tsc --noEmit",
     "clean": "run-p clean:*",
-    "clean:compiled": "shx rm -rf compiled",
     "clean:coverage": "shx rm -rf coverage",
-    "clean:dist": "shx rm -rf dist",
     "clean:react": "node ./scripts/clean-react.js",
-    "compile": "tsc -p tsconfig.base.json",
-    "format": "eslint . --fix && prettier --write \"**/*.{js,ts,tsx}\"",
+    "format": "eslint . --fix && prettier --write \"**/*.{cjs,cts,js,mjs,mts,ts,tsx}\"",
     "lint": "eslint . --max-warnings=0",
-    "postbundle": "npm run clean:compiled && shx cp ./index.js ./dist/index.js",
+    "package:attw": "node ./scripts/attw.js",
+    "package:publint": "publint",
+    "postbuild": "run-s package:*",
     "prepare": "npm run build",
     "release": "tanem-scripts release",
-    "test": "run-s check:* lint build test:*",
+    "size": "size-limit",
+    "test": "run-s check:* lint build size test:*",
+    "test:bundles": "jest --config ./scripts/jest/config.bundles.js",
     "test:cjs": "jest --config ./scripts/jest/config.cjs.js",
-    "test:cjsprod": "jest --config ./scripts/jest/config.cjsprod.js",
-    "test:es": "jest --config ./scripts/jest/config.es.js",
+    "test:es": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js --config ./scripts/jest/config.es.js",
     "test:react": "node ./scripts/test-react.js",
     "test:src": "jest --config ./scripts/jest/config.src.js",
-    "test:umd": "jest --config ./scripts/jest/config.umd.js",
-    "test:umdprod": "jest --config ./scripts/jest/config.umdprod.js",
     "version": "run-s test changelog authors && git add ."
   },
   "repository": {
@@ -44,8 +71,6 @@
   "keywords": [
     "animation",
     "component",
-    "higher-order-component",
-    "hoc",
     "hook",
     "hooks",
     "javascript",
@@ -70,25 +95,12 @@
   "overrides": {
     "brace-expansion": "^5.0.8"
   },
-  "dependencies": {
-    "@babel/runtime": "^7.28.6",
-    "hoist-non-react-statics": "^3.3.2"
-  },
   "devDependencies": {
-    "@babel/core": "7.29.7",
-    "@babel/plugin-transform-runtime": "7.29.0",
-    "@babel/preset-env": "7.29.0",
-    "@babel/preset-react": "7.28.5",
-    "@babel/preset-typescript": "7.28.5",
+    "@arethetypeswrong/cli": "0.18.5",
     "@eslint-react/eslint-plugin": "5.18.0",
     "@eslint/js": "10.0.1",
-    "@rollup/plugin-babel": "6.1.0",
-    "@rollup/plugin-commonjs": "29.0.0",
-    "@rollup/plugin-node-resolve": "16.0.3",
-    "@rollup/plugin-replace": "6.0.3",
-    "@rollup/plugin-terser": "1.0.0",
+    "@size-limit/file": "13.0.2",
     "@testing-library/react": "16.3.2",
-    "@types/hoist-non-react-statics": "3.3.7",
     "@types/jest": "30.0.0",
     "@types/mock-raf": "1.0.6",
     "@types/node": "24.11.0",
@@ -105,12 +117,14 @@
     "mock-raf": "1.0.1",
     "npm-run-all2": "8.0.4",
     "prettier": "3.8.1",
+    "publint": "0.3.22",
     "react": "19.2.4",
     "react-dom": "19.2.4",
-    "rollup": "4.59.0",
     "shx": "0.4.0",
+    "size-limit": "13.0.2",
     "tanem-scripts": "8.0.4",
     "ts-jest": "29.4.6",
+    "tsdown": "0.22.14",
     "typescript": "5.9.3",
     "typescript-eslint": "8.56.1"
   }

package/src/NProgress.tsx

@@ -0,0 +1,13 @@
+import type { FC, ReactElement } from 'react'
+
+import type { NProgressOptions, NProgressState } from './types'
+import { useNProgress } from './useNProgress'
+
+type Props = NProgressOptions & {
+  children: (renderProps: NProgressState) => ReactElement
+}
+
+export const NProgress: FC<Props> = ({ children, ...restProps }: Props) => {
+  const renderProps = useNProgress(restProps)
+  return children(renderProps)
+}

package/src/clamp.ts

@@ -0,0 +1,5 @@
+export const clamp = (num: number, lower: number, upper: number): number => {
+  num = num <= upper ? num : upper
+  num = num >= lower ? num : lower
+  return num
+}

package/src/createTimeout.ts

@@ -0,0 +1,35 @@
+// Uses requestAnimationFrame rather than setTimeout for smoother animation
+// timing. Note that rAF is throttled or paused in background tabs, so progress
+// will stall when the tab is hidden and resume when it regains focus.
+export const createTimeout = () => {
+  let handle: number | undefined
+
+  const cancel = (): void => {
+    if (handle !== undefined) {
+      window.cancelAnimationFrame(handle)
+    }
+  }
+
+  const schedule = (callback: () => void, delay: number): void => {
+    cancel()
+
+    let deltaTime
+    let start: number | undefined
+    const frame: FrameRequestCallback = (time) => {
+      start = start || time
+      deltaTime = time - start
+      if (deltaTime > delay) {
+        callback()
+        return
+      }
+      handle = window.requestAnimationFrame(frame)
+    }
+
+    handle = window.requestAnimationFrame(frame)
+  }
+
+  return {
+    cancel,
+    schedule,
+  }
+}

package/src/increment.ts

@@ -0,0 +1,17 @@
+import { clamp } from './clamp'
+
+export const increment = (progress: number): number => {
+  let amount = 0
+
+  if (progress >= 0 && progress < 0.2) {
+    amount = 0.1
+  } else if (progress >= 0.2 && progress < 0.5) {
+    amount = 0.04
+  } else if (progress >= 0.5 && progress < 0.8) {
+    amount = 0.02
+  } else if (progress >= 0.8 && progress < 0.99) {
+    amount = 0.005
+  }
+
+  return clamp(progress + amount, 0, 0.994)
+}

package/src/index.tsx

@@ -0,0 +1,3 @@
+export * from './NProgress'
+export type { NProgressOptions, NProgressState } from './types'
+export * from './useNProgress'

package/src/types.ts

@@ -0,0 +1,13 @@
+export interface NProgressOptions {
+  animationDuration?: number
+  increment?: (progress: number) => number
+  incrementDuration?: number
+  isAnimating?: boolean
+  minimum?: number
+}
+
+export interface NProgressState {
+  animationDuration: number
+  isFinished: boolean
+  progress: number
+}

package/src/useNProgress.tsx

@@ -0,0 +1,137 @@
+import { useEffect, useReducer, useRef } from 'react'
+
+import { clamp } from './clamp'
+import { createTimeout } from './createTimeout'
+import { increment as defaultIncrement } from './increment'
+import type { NProgressOptions, NProgressState } from './types'
+
+// A four-phase state machine. `idle` and `finished` both report
+// `isFinished: true` and differ only in the progress they hold, so the phase,
+// not `isFinished`, is what decides which transitions and timers apply.
+type Phase = 'animating' | 'completing' | 'finished' | 'idle'
+
+interface State {
+  phase: Phase
+  progress: number
+}
+
+type Action =
+  | {
+      increment: (progress: number) => number
+      minimum: number
+      type: 'trickle'
+    }
+  | { minimum: number; type: 'start' }
+  | { type: 'complete' }
+  | { type: 'finish' }
+
+const initialState: State = {
+  phase: 'idle',
+  progress: 0,
+}
+
+const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'complete':
+      // The original nprogress `done()` computes a random progress jump before
+      // animating to 1, but its queue runs both steps in the same tick, so the
+      // jump's CSS is overwritten before paint and never renders. Omitting the
+      // jump changes nothing visually.
+      //
+      // Ignored unless an animation is actually running, which is what makes a
+      // StrictMode double-mount a no-op rather than a spurious completion.
+      return state.phase === 'animating'
+        ? { phase: 'completing', progress: 1 }
+        : state
+
+    case 'finish':
+      return { phase: 'finished', progress: 1 }
+
+    case 'start':
+      // Matches the original nprogress `start()`, which calls set(0) and so
+      // paints first at `minimum` before any trickle runs.
+      //
+      // Guarded the same way as `complete`, and for the same reason: a repeat
+      // dispatch against a running animation must not rewind the bar. That
+      // happens whenever `minimum` changes mid-animation, as well as on a
+      // StrictMode double-mount.
+      return state.phase === 'animating'
+        ? state
+        : {
+            phase: 'animating',
+            progress: clamp(0, action.minimum, 1),
+          }
+
+    case 'trickle':
+      // Clamped here rather than trusted from the increment function, so a
+      // custom one cannot take the bar outside the documented range. Stopping
+      // short of 1 is that function's own business: 1 is what completion
+      // means.
+      return {
+        ...state,
+        progress: clamp(action.increment(state.progress), action.minimum, 1),
+      }
+  }
+}
+
+export const useNProgress = ({
+  animationDuration = 200,
+  increment = defaultIncrement,
+  incrementDuration = 200,
+  isAnimating = false,
+  minimum = 0.08,
+}: NProgressOptions = {}): NProgressState => {
+  const [{ phase, progress }, dispatch] = useReducer(reducer, initialState)
+
+  // Held in a ref so the trickle timer can read the latest increment function
+  // without listing it as a dependency. Consumers commonly pass an inline
+  // function, whose identity changes every render; depending on it directly
+  // would cancel and recreate the timer each time, and a render loop faster
+  // than `incrementDuration` would stop the bar advancing altogether.
+  const incrementRef = useRef(increment)
+  useEffect(() => {
+    incrementRef.current = increment
+  })
+
+  useEffect(() => {
+    dispatch(isAnimating ? { minimum, type: 'start' } : { type: 'complete' })
+  }, [isAnimating, minimum])
+
+  // A timer per running phase, rather than one effect branching over both.
+  // Each then depends only on the options its own phase reads, so changing an
+  // option the running phase ignores cannot cancel its timer. Both are keyed
+  // on the phase rather than on progress, so trickling does not tear down and
+  // recreate the timer mid-animation.
+  useEffect(() => {
+    if (phase !== 'animating') {
+      return
+    }
+
+    const timeout = createTimeout()
+
+    const trickle = () => {
+      dispatch({ increment: incrementRef.current, minimum, type: 'trickle' })
+      timeout.schedule(trickle, incrementDuration)
+    }
+    timeout.schedule(trickle, incrementDuration)
+
+    return () => timeout.cancel()
+  }, [incrementDuration, minimum, phase])
+
+  useEffect(() => {
+    if (phase !== 'completing') {
+      return
+    }
+
+    const timeout = createTimeout()
+    timeout.schedule(() => dispatch({ type: 'finish' }), animationDuration)
+
+    return () => timeout.cancel()
+  }, [animationDuration, phase])
+
+  return {
+    animationDuration,
+    isFinished: phase === 'finished' || phase === 'idle',
+    progress,
+  }
+}

package/dist/NProgress.d.ts

@@ -1,8 +0,0 @@
-import type { FC, ReactElement } from 'react';
-import type { Options } from './types';
-import { useNProgress } from './useNProgress';
-type Props = Options & {
-    children: (renderProps: ReturnType<typeof useNProgress>) => ReactElement;
-};
-export declare const NProgress: FC<Props>;
-export {};

package/dist/clamp.d.ts

@@ -1 +0,0 @@
-export declare const clamp: (num: number, lower: number, upper: number) => number;

package/dist/createQueue.d.ts

@@ -1,7 +0,0 @@
-type Next = () => void;
-type Callback = (next: Next) => void;
-export declare const createQueue: () => {
-    clear: () => void;
-    enqueue: (cb: Callback) => void;
-};
-export {};

package/dist/createTimeout.d.ts

@@ -1,4 +0,0 @@
-export declare const createTimeout: () => {
-    cancel: () => void;
-    schedule: (callback: () => void, delay: number) => void;
-};

package/dist/increment.d.ts

@@ -1 +0,0 @@
-export declare const increment: (progress: number) => number;

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from './NProgress';
-export * from './useNProgress';
-export * from './withNProgress';

package/dist/index.js

@@ -1,7 +0,0 @@
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./react-nprogress.cjs.production.js')
-} else {
-  module.exports = require('./react-nprogress.cjs.development.js')
-}