Fix logout URL

Required doing some reformatting in InsturctorToolbar.jsx
to make the linter happy.

Also, add dev-build command.

.env.development

@@ -1,16 +1,16 @@
 NODE_ENV='development'
 PORT=2000
 ACCESS_TOKEN_COOKIE_NAME='edx-jwt-cookie-header-payload'
-BASE_URL='localhost:2000'
+BASE_URL='localhost:19000/learning'
 CREDENTIALS_BASE_URL='http://localhost:18150'
 CSRF_TOKEN_API_PATH='/csrf/api/v1/token'
 ECOMMERCE_BASE_URL='http://localhost:18130'
 LANGUAGE_PREFERENCE_COOKIE_NAME='openedx-language-preference'
 LMS_BASE_URL='http://localhost:18000'
 LOGIN_URL='http://localhost:18000/login'
-LOGOUT_URL='http://localhost:18000/login'
+LOGOUT_URL='http://localhost:18000/logout'
 MARKETING_SITE_BASE_URL='http://localhost:18000'
-ORDER_HISTORY_URL='localhost:1996/orders'
+ORDER_HISTORY_URL='localhost:19000/orders'
 REFRESH_ACCESS_TOKEN_ENDPOINT='http://localhost:18000/login_refresh'
 SEGMENT_KEY=null
 SITE_NAME='edX'

docs/decisions/0002-courseware-page-decisions.md

@@ -0,0 +1,50 @@
+# Courseware Page Decisions
+
+## Courseware data loading
+
+Today we have strictly hierarchical courses - a course contains sections, which contain sequences, which contain units, which contain components.
+
+In creating the courseware pages of this app, we needed to choose how often we fetch data from the server.  If we fetch it once and try to get the whole course, including all the data we need in its entire hierarchy, then the request will take 30+ seconds and be a horrible UX.  If we try to fetch too granularly, we risk making hundreds of calls to the LMS, incuring both request overhead and common server-side processing that needs to occur for each of those requests.
+
+Instead, we've chosen to load data via the following:
+
+- The course blocks API (/api/courses/v2/blocks) for getting the overall structure of the course (limited data on the whole hierarchy)
+- The course metadata API (/api/courseware/course) for detailed top-level data, such as dates, enrollment status, info for tabs across the top of the page, etc.
+- The sequence metadata API (/api/courseware/sequence) for detailed information on a sequence, such as which unit to display, any banner messages, whether or not the sequence has a prerequisite, if it's an exam, etc.
+- The xblock endpoint (http://localhost:18000/xblock/:block_id) which renders HTML for an xBlock by ID, used to render Unit contents.  This HTML is loaded into the application via an iFrame.
+
+These APIs aren't perfect for our usage, but they're getting the job done for now.  They weren't built for our purposes and thus load more information than we strictly need, and aren't as performant as we'd like.  Future milestones of the application may rely on new, more performant APIs (possibly BFFs)
+
+## Unit iframing
+
+We determined, as part of our project discovery, that in order to deliver value to users sooner, we would iframe in content of units.  This allowed us to avoid rebuilding the UI for unit/component xblocks in the micro-frontend, which is a daunting task.  It also allows existing custom xblocks to continue to work for now, as they wouldn't have to be re-written.
+
+A future iteration of the project may go back and pull the unit rendering into the MFE.
+
+## Strictly hierarchical courses
+
+We've also made the assumption that courses are strictly hierarchical - a given section, sequence, or unit doesn't have multiple parents.  This is important, as it allows us to navigate the tree in the client in a deterministic way.  If we need to find out who the parent section of a sequence is, there's only one answer to that question.
+
+## Determining which sequences and units to show
+
+The courseware URL scheme:
+
+`/course/:courseId(/:sequenceId(/:unitId))`
+
+Sequence ID and unit ID are optional.
+
+Today, if the URL only specifies the course ID, we need to pick a sequence to show.  We do this by picking the first sequence of the course (as dictated by the course blocks API) and update the URL to match.  _After_ the URL has been updated, the application will attempt to load that sequence.
+
+Similarly, if the URL doesn't contain a unit ID, we use the `position` field of the sequence to determine which unit we want to display from that sequence.  If the position isn't specified in the sequence, we choose the first unit of the sequence.  After determining which unit to display, we update the URL to match.  After the URL is updated, the application will attempt to load that unit via an iFrame.
+
+## "Container" components vs. display components
+
+This application makes use of a few "container" components at the top level - CoursewareContainer and CourseHomeContainer.
+
+The point of these containers is to introduce a layer of abstraction between the UI representation of the pages and the way their data was loaded, as described above.
+
+We don't want our Course.jsx component to be intimately aware - for example - that it's data is loaded via two separate APIs that are then merged together.  That's not useful information - it just needs to know where it's data is and if it's loaded.  Furthermore, this layer of abstraction lets us normalize field names between the various APIs to let our MFE code be more consistent and readable.  This normalization is done in the src/data/api.js layer.
+
+## Navigation
+
+Course navigation in a hierarchical course happens primarily via the "sequence navigation".  This component lets users navigate to the next and previous unit in the course, and also select specific units within the sequence directly.  The next and previous buttons (SequenceNavigation and UnitNavigation) delegate decision making up the tree to CoursewareContainer.  This is an intentional separation of concerns which should allow different CoursewareContainer-like components to make different decisions about what it means to go to the "next" or "previous" sequence.  This is in support of future course types such as "pathway" courses and adaptive learning sequences.  There is no actual code written for these course types, but it felt like a good separation of concerns.

docs/decisions/0003-course-home-decisions.md

@@ -0,0 +1,7 @@
+# Course Home Decisions
+
+The course home page is not complete as of this writing.
+
+It was added to the MFE as a proof of concept for the Engagement theme's Always Available squad, as they were intending to do some work in the legacy course home page in the LMS, and we wanted to understand whether it would be more easily done in this application.
+
+It uses the same APIs as the courseware page, for the most part.  This may not always be the case, but it is for now.  Differing API shapes may be faster for both pages.

docs/decisions/0004-model-store.md

@@ -0,0 +1,7 @@
+## Model Store
+
+Because we have a variety of models in this app (course, section, sequence, unit), we use a set of generic 'model store' reducers in redux to manage this data.  Once loaded from the APIs, the data is put into the model store by type and by ID, which allows us to quickly access it in the application.  Furthermore, any sub-trees of model children (like "items" in the sequence metadata API) are flattened out and stored by ID in the model-store, and their arrays replaced by arrays of IDs.  This is a recommended way to store data in redux as documented here:
+
+https://redux.js.org/faq/organizing-state#how-do-i-organize-nested-or-duplicate-data-in-my-state
+
+(As an additional data point, djoy has stored data in this format in multiple projects over the years and found it to be very effective)

docs/decisions/0005-components-own-their-loading-state.md

@@ -0,0 +1,17 @@
+# Components Own Their Own Loading State
+
+Currently, the majority of the components in the component tree for both Courseware and CourseHome own their own loading state.  This means that they're _aware_ of the loading status (loading, loaded, failed) of the resources they depend on, and are expected to adjust their own rendering based on that state.
+
+The alternative is for a given component's parent to be responsible for this logic.  Under normal circumstances, if the parents were responsible, it would probably result in simpler code in general.  A component could just take for granted that if it's being rendered, all it's data must be ready.  
+
+*We think that that approach (giving the parents responsibility) isn't appropriate for this application.*
+
+We expect - in the longer term - that different courses/course staff may switch out component implementations.  Use a different form of SequenceNavigation, for instance.  Because of this, we didn't want parent components to be too aware of the nature of their children.  The children are more self-contained this way, though we sacrifice some simplicity for it.
+
+If, for instance, the Sequence component renders a skeleton of the SequenceNavigation, the look of that skeleton is going to be based on an understanding of how the SequenceNavigation renders itself.  If the SequenceNavigation implementation is switched out, that loading code in the Sequence may be wrong/misleading to the user.  If we leave the loading logic in the parent, we then have to branch it for all the types of SequenceNavigations that may exist - this violates the Open/Closed principle by forcing us to update our application when we try to make a new extension/implementation of a sub-component (assuming we have a plugin/extension/component replacement framework in place).
+
+By moving the loading logic into the components themselves, the idea is to allow a given component to render as much of itself as it reasonably can - this may mean just a spinner, or it may mean a "skeleton" UI while the resources are loading.  The parent doesn't need to be aware of the details.
+
+## Under what circumstances would we reverse this decision?
+
+If we find, in time, that we aren't seeing that "switching out component implementations" is a thing that's happening, then we can probably simplify the application code by giving parents the responsibility of deciding when to render their children, rather than keeping that responsibility with the children themselves.  

docs/xblock-links.md

@@ -1,30 +0,0 @@
-# Perf test courses
-
-These courses have some large xblocks and small ones.  One course has many sequences, the other has fewer.
-
-## Big course:  course-v1:MITx+CTL.SC0x+3T2016
-
-- MFE URL: https://learning.edx.org/course/course-v1%3AMITx%2BCTL.SC0x%2B3T2016/0
-- URL: https://courses.edx.org/courses/course-v1:MITx+CTL.SC0x+3T2016/course/
-
-### Small xblock
-- ID: block-v1:MITx+CTL.SC0x+3T2016+type@vertical+block@0586b59f1cf74e3c982f0b9070e7ad33
-- URL: https://courses.edx.org/courses/course-v1:MITx+CTL.SC0x+3T2016/courseware/6a31d02d958e45a398d8a5f1592bdd78/b1ede7bf43c248e19894040718443750/1?activate_block_id=block-v1%3AMITx%2BCTL.SC0x%2B3T2016%2Btype%40vertical%2Bblock%400586b59f1cf74e3c982f0b9070e7ad33
-
-### Big xblock
-- ID: block-v1:MITx+CTL.SC0x+3T2016+type@vertical+block@84d6e785f548431a9e82e58d2df4e971
-- URL: https://courses.edx.org/courses/course-v1:MITx+CTL.SC0x+3T2016/courseware/b77abc02967e401ca615b23dacf8d115/4913db3e36f14ccd8c98c374b9dae809/2?activate_block_id=block-v1%3AMITx%2BCTL.SC0x%2B3T2016%2Btype%40vertical%2Bblock%4084d6e785f548431a9e82e58d2df4e971
-
-## Small course: course-v1:edX+DevSec101+3T2018
-
-- URL: https://courses.edx.org/courses/course-v1:edX+DevSec101+3T2018/course/
-- MFE URL: https://learning.edx.org/course/course-v1%3AedX%2BDevSec101%2B3T2018/0
-
-### Small xblock
-- ID: block-v1:edX+DevSec101+3T2018+type@vertical+block@931f96d1822a4fe5b521fcda19245dca
-- URL: https://courses.edx.org/courses/course-v1:edX+DevSec101+3T2018/courseware/ee898e64bd174e4aba4c07cd2673e5d3/1a37309647814ab8b333c7a17d50abc4/1?activate_block_id=block-v1%3AedX%2BDevSec101%2B3T2018%2Btype%40vertical%2Bblock%40931f96d1822a4fe5b521fcda19245dca
-
-### Big-ish xblock
-
-- ID: block-v1:edX+DevSec101+3T2018+type@vertical+block@d88210fbc2b74ceab167a52def04e2a0
-- URL: https://courses.edx.org/courses/course-v1:edX+DevSec101+3T2018/courseware/b0e2c2b78b5d49308e1454604a255403/38c7049bc8e44d309ab3bdb7f54ae6ae/2?activate_block_id=block-v1%3AedX%2BDevSec101%2B3T2018%2Btype%40vertical%2Bblock%40d88210fbc2b74ceab167a52def04e2a0

package.json

@@ -12,9 +12,10 @@
   ],
   "scripts": {
     "build": "fedx-scripts webpack",
+    "dev-build": "fedx-scripts webpack-dev",
     "i18n_extract": "BABEL_ENV=i18n fedx-scripts babel src --quiet > /dev/null",
     "is-es5": "es-check es5 ./dist/*.js",
-    "lint": "fedx-scripts eslint",
+    "lint": "fedx-scripts eslint --ext .js --ext .jsx .",
     "snapshot": "fedx-scripts jest --updateSnapshot",
     "start": "fedx-scripts webpack-dev-server --progress",
     "test": "fedx-scripts jest --coverage --passWithNoTests"
@@ -36,13 +37,15 @@
   "dependencies": {
     "@edx/frontend-component-footer": "^10.0.6",
     "@edx/frontend-component-header": "^2.0.3",
-    "@edx/frontend-platform": "^1.1.11",
-    "@edx/paragon": "^7.2.0",
+    "@edx/frontend-platform": "^1.3.1",
+    "@edx/paragon": "^7.2.1",
     "@fortawesome/fontawesome-svg-core": "^1.2.26",
     "@fortawesome/free-brands-svg-icons": "^5.12.0",
     "@fortawesome/free-regular-svg-icons": "^5.12.0",
     "@fortawesome/free-solid-svg-icons": "^5.12.0",
     "@fortawesome/react-fontawesome": "^0.1.8",
+    "@reduxjs/toolkit": "^1.2.3",
+    "classnames": "^2.2.6",
     "core-js": "^3.6.2",
     "prop-types": "^15.7.2",
     "react": "^16.12.0",
@@ -50,11 +53,11 @@
     "react-redux": "^7.1.3",
     "react-router": "^5.1.2",
     "react-router-dom": "^5.1.2",
-    "redux": "^4.0.4",
+    "redux": "^4.0.5",
     "regenerator-runtime": "^0.13.3"
   },
   "devDependencies": {
-    "@edx/frontend-build": "^2.0.5",
+    "@edx/frontend-build": "github:edx/frontend-build#kdmccormick/devstack-frontends",
     "codecov": "^3.6.1",
     "es-check": "^5.1.0",
     "glob": "^7.1.6",

src/CoursewareRedirect.jsx

@@ -0,0 +1,30 @@
+import React from 'react';
+import { Switch, Route, useRouteMatch } from 'react-router';
+import { getConfig } from '@edx/frontend-platform';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+import PageLoading from './PageLoading';
+
+export default () => {
+  const { path } = useRouteMatch();
+  return (
+    <div className="flex-grow-1">
+      <PageLoading srMessage={(
+        <FormattedMessage
+          id="learn.redirect.interstitial.message"
+          description="The screen-reader message when a page is about to redirect"
+          defaultMessage="Redirecting..."
+        />
+      )}
+      />
+
+      <Switch>
+        <Route
+          path={`${path}/course-home/:courseId`}
+          render={({ match }) => {
+            global.location.assign(`${getConfig().LMS_BASE_URL}/courses/${match.params.courseId}/course/`);
+          }}
+        />
+      </Switch>
+    </div>
+  );
+};

src/PageLoading.jsx

@@ -33,5 +33,5 @@ export default class PageLoading extends Component {
 }
 
 PageLoading.propTypes = {
-  srMessage: PropTypes.string.isRequired,
+  srMessage: PropTypes.node.isRequired,
 };

src/components/CourseTabsNavigation.jsx

@@ -1,74 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
-import messages from './messages';
-import NavTab from './NavTab';
-
-function CourseTabsNavigation({ activeTabSlug, courseTabs, intl }) {
-  const courseNavTabs = courseTabs.map(({ slug, ...courseTab }) => (
-    <NavTab
-      isActive={slug === activeTabSlug}
-      key={slug}
-      {...courseTab}
-    />
-  ));
-
-  return (
-    <nav
-      aria-label={intl.formatMessage(messages['learn.navigation.course.tabs.label'])}
-      className="nav nav-underline-tabs"
-    >
-      {courseNavTabs}
-    </nav>
-  );
-}
-
-CourseTabsNavigation.propTypes = {
-  activeTabSlug: PropTypes.string,
-  courseTabs: PropTypes.arrayOf(PropTypes.shape({
-    title: PropTypes.string.isRequired,
-    priority: PropTypes.number.isRequired,
-    slug: PropTypes.string.isRequired,
-    url: PropTypes.string.isRequired,
-  })),
-  intl: intlShape.isRequired,
-};
-
-CourseTabsNavigation.defaultProps = {
-  activeTabSlug: undefined,
-  courseTabs: [
-    {
-      title: 'Course',
-      slug: 'course',
-      priority: 1,
-      url: 'http://localhost:18000/courses/course-v1:edX+DemoX+Demo_Course/course/',
-    },
-
-    {
-      title: 'Discussion',
-      slug: 'discussion',
-      priority: 2,
-      url: 'http://localhost:18000/courses/course-v1:edX+DemoX+Demo_Course/discussion/forum/',
-    },
-    {
-      title: 'Wiki',
-      slug: 'wiki',
-      priority: 3,
-      url: 'http://localhost:18000/courses/course-v1:edX+DemoX+Demo_Course/course_wiki',
-    },
-    {
-      title: 'Progress',
-      slug: 'progress',
-      priority: 4,
-      url: 'http://localhost:18000/courses/course-v1:edX+DemoX+Demo_Course/progress',
-    },
-    {
-      title: 'Instructor',
-      slug: 'instructor',
-      priority: 5,
-      url: 'http://localhost:18000/courses/course-v1:edX+DemoX+Demo_Course/instructor',
-    },
-  ],
-};
-
-export default injectIntl(CourseTabsNavigation);

src/components/NavTab.jsx

@@ -1,30 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import classNames from 'classnames';
-
-
-export default function NavTab(props) {
-  const {
-    isActive, url, title, ...attrs
-  } = props;
-
-  const className = classNames(
-    'nav-item nav-link',
-    { active: isActive },
-    attrs.className,
-  );
-
-  return <a {...attrs} className={className} href={url}>{title}</a>;
-}
-
-NavTab.propTypes = {
-  className: PropTypes.string,
-  isActive: PropTypes.bool,
-  title: PropTypes.string.isRequired,
-  url: PropTypes.string.isRequired,
-};
-
-NavTab.defaultProps = {
-  className: undefined,
-  isActive: false,
-};

src/course-header/CourseTabsNavigation.jsx

@@ -0,0 +1,50 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
+import { getConfig } from '@edx/frontend-platform';
+import classNames from 'classnames';
+
+import messages from './messages';
+import Tabs from '../tabs/Tabs';
+
+function CourseTabsNavigation({
+  activeTabSlug, tabs, intl,
+}) {
+  return (
+    <div className="course-tabs-navigation">
+      <div className="container-fluid">
+        <Tabs
+          className="nav-underline-tabs"
+          aria-label={intl.formatMessage(messages['learn.navigation.course.tabs.label'])}
+        >
+          {tabs.map(({ url, title, slug }) => (
+            <a
+              key={slug}
+              className={classNames('nav-item flex-shrink-0 nav-link', { active: slug === activeTabSlug })}
+              href={`${getConfig().LMS_BASE_URL}${url}`}
+            >
+              {title}
+            </a>
+          ))}
+        </Tabs>
+      </div>
+    </div>
+  );
+}
+
+CourseTabsNavigation.propTypes = {
+  activeTabSlug: PropTypes.string,
+  tabs: PropTypes.arrayOf(PropTypes.shape({
+    title: PropTypes.string.isRequired,
+    priority: PropTypes.number.isRequired,
+    slug: PropTypes.string.isRequired,
+    url: PropTypes.string.isRequired,
+  })).isRequired,
+  intl: intlShape.isRequired,
+};
+
+CourseTabsNavigation.defaultProps = {
+  activeTabSlug: undefined,
+};
+
+export default injectIntl(CourseTabsNavigation);

src/course-header/Header.jsx

@@ -0,0 +1,74 @@
+import React, { useContext } from 'react';
+import PropTypes from 'prop-types';
+import { Dropdown } from '@edx/paragon';
+import { getConfig } from '@edx/frontend-platform';
+import { AppContext } from '@edx/frontend-platform/react';
+
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faUserCircle } from '@fortawesome/free-solid-svg-icons';
+
+import logo from './assets/logo.svg';
+
+function LinkedLogo({
+  href,
+  src,
+  alt,
+  ...attributes
+}) {
+  return (
+    <a href={href} {...attributes}>
+      <img className="d-block" src={src} alt={alt} />
+    </a>
+  );
+}
+
+LinkedLogo.propTypes = {
+  href: PropTypes.string.isRequired,
+  src: PropTypes.string.isRequired,
+  alt: PropTypes.string.isRequired,
+};
+
+export default function Header({
+  courseOrg, courseNumber, courseTitle,
+}) {
+  const { authenticatedUser } = useContext(AppContext);
+
+  return (
+    <header className="course-header">
+      <div className="container-fluid py-2 d-flex align-items-center ">
+        <LinkedLogo
+          className="logo"
+          href={`${getConfig().LMS_BASE_URL}/dashboard`}
+          src={logo}
+          alt={getConfig().SITE_NAME}
+        />
+        <div className="flex-grow-1 course-title-lockup" style={{ lineHeight: 1 }}>
+          <span className="d-block small m-0">{courseOrg} {courseNumber}</span>
+          <span className="d-block m-0 font-weight-bold course-title">{courseTitle}</span>
+        </div>
+
+        <Dropdown className="user-dropdown">
+          <Dropdown.Button>
+            <FontAwesomeIcon icon={faUserCircle} className="d-md-none" size="lg" />
+            <span className="d-none d-md-inline">
+              {authenticatedUser.username}
+            </span>
+          </Dropdown.Button>
+          <Dropdown.Menu className="dropdown-menu-right">
+            <Dropdown.Item href={`${getConfig().LMS_BASE_URL}/dashboard`}>Dashboard</Dropdown.Item>
+            <Dropdown.Item href={`${getConfig().LMS_BASE_URL}/u/${authenticatedUser.username}`}>Profile</Dropdown.Item>
+            <Dropdown.Item href={`${getConfig().LMS_BASE_URL}/account/settings`}>Account</Dropdown.Item>
+            <Dropdown.Item href={getConfig().ORDER_HISTORY_URL}>Order History</Dropdown.Item>
+            <Dropdown.Item href={getConfig().LOGOUT_URL}>Sign Out</Dropdown.Item>
+          </Dropdown.Menu>
+        </Dropdown>
+      </div>
+    </header>
+  );
+}
+
+Header.propTypes = {
+  courseOrg: PropTypes.string.isRequired,
+  courseNumber: PropTypes.string.isRequired,
+  courseTitle: PropTypes.string.isRequired,
+};

src/course-header/assets/logo.svg

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="1168px" height="540px" viewBox="0 0 1168 540" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: Sketch 53.2 (72643) - https://sketchapp.com -->
+    <title>logo</title>
+    <desc>Created with Sketch.</desc>
+    <g id="logo" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <polygon id="Path" fill="#209FDA" fill-rule="nonzero" points="1166.81993 85.5 1166.81993 2.84217094e-14 953.759925 2.84217094e-14 953.759925 85.5 1002.17993 85.5 915.859925 191.98 829.459925 85.5 878.099925 85.5 878.099925 2.84217094e-14 718.919925 2.84217094e-14 718.919925 95.72 856.479925 265.26 718.919925 434.96 718.919925 452.02 784.499925 452.02 784.499925 539.64 878.099925 539.64 878.099925 452.02 823.919925 452.02 915.919925 338.52 915.939925 338.52 1008.03993 452.02 953.759925 452.02 953.759925 539.64 1166.81993 539.64 1166.81993 452.02 1126.85993 452.02 975.319925 265.26 1121.01993 85.5"></polygon>
+        <polygon id="Path" fill="#026BA4" fill-rule="nonzero" points="664.019925 7.10542736e-15 664.019925 85.5 710.619925 85.5 718.919925 95.72 718.919925 7.10542736e-15"></polygon>
+        <polygon id="Path" fill="#026BA4" fill-rule="nonzero" points="718.919925 452.02 718.919925 434.96 705.079925 452.02 664.019925 452.02 664.019925 539.64 784.499925 539.64 784.499925 452.02"></polygon>
+        <path d="M321.999925,411.86 L397.659925,411.86 C388.805702,433.829527 376.258024,454.122269 360.559925,471.86 C344.364089,454.216816 331.320914,433.921419 321.999925,411.86" id="Path" fill="#78212E" fill-rule="nonzero"></path>
+        <path d="M360.559925,189.28 C338.58337,213.190393 322.501981,241.908137 313.599925,273.14 C317.134915,280.039338 320.007771,287.25831 322.179925,294.7 L397.059925,294.7 C399.306706,287.354671 402.25356,280.242036 405.859925,273.46 C397.464721,242.277678 381.959326,213.464341 360.559925,189.28 Z M322.179925,294.7 C328.784599,317.438017 328.978396,341.558795 322.739925,364.4 L396.399925,364.4 C389.855554,341.597488 390.06397,317.386469 396.999925,294.7 L322.179925,294.7 Z M322.179925,294.7 L308.679925,294.7 C304.690779,317.752715 304.575868,341.309464 308.339925,364.4 L322.739925,364.4 C328.978396,341.558795 328.784599,317.438017 322.179925,294.7 L322.179925,294.7 Z" id="Shape" fill="#78212E" fill-rule="nonzero"></path>
+        <path d="M710.619925,85.5 L664.019925,85.5 L664.019925,0.02 L576.019925,0.02 L576.019925,85.5 L632.859925,85.5 L632.859925,159.2 C598.417874,134.487772 557.04992,121.286425 514.659925,121.48 C456.044663,121.405246 400.107354,146.01621 360.559925,189.28 C381.937732,213.470272 397.422343,242.283149 405.799925,273.46 C426.944121,233.500977 468.451514,208.51034 513.659925,208.52 C581.059925,208.52 632.879925,263.16 632.879925,330.52 L632.879925,331.2 C632.539925,398.28 580.879925,452.56 513.659925,452.56 C468.477451,452.593197 426.976426,427.652566 405.799925,387.74 L405.799925,387.74 C401.869213,380.340239 398.718926,372.551658 396.399925,364.5 L308.399925,364.5 C309.686934,372.450225 311.443338,380.317312 313.659925,388.06 C315.970162,396.190434 318.775397,404.171995 322.059925,411.96 L397.659925,411.96 C388.805702,433.929527 376.258024,454.222269 360.559925,471.96 C400.107354,515.22379 456.044663,539.834754 514.659925,539.76 C571.465111,540.091874 625.745998,516.316729 664.019925,474.34 L664.019925,452.04 L705.059925,452.04 L718.899925,434.96 L718.899925,95.74 L710.619925,85.5 Z M632.879925,501.9 L632.879925,539.74 L664.019925,539.74 L664.019925,474.18 C654.623775,484.469293 644.18821,493.758755 632.879925,501.9 L632.879925,501.9 Z M313.599925,273.14 C311.569597,280.231983 309.927163,287.429316 308.679925,294.7 L322.179925,294.7 C320.007771,287.25831 317.134915,280.039338 313.599925,273.14 L313.599925,273.14 Z" id="Shape" fill="#8A8C8F" fill-rule="nonzero"></path>
+        <path d="M410.399925,294.7 C409.199925,287.5 407.659925,280.4 405.799925,273.46 C402.19356,280.242036 399.246706,287.354671 396.999925,294.7 C390.06397,317.386469 389.855554,341.597488 396.399925,364.4 L410.719925,364.4 C414.264276,341.293291 414.156293,317.77319 410.399925,294.7 L410.399925,294.7 Z M209.059925,121.48 C107.422724,121.487508 20.5081632,194.571683 3.05992537,294.7 L91.3999254,294.7 C107.135726,243.467257 154.465065,208.503753 208.059925,208.52 C252.638644,208.335148 293.496156,233.351373 313.599925,273.14 C322.501981,241.908137 338.58337,213.190393 360.559925,189.28 C322.206855,145.880863 266.976617,121.163964 209.059925,121.48 L209.059925,121.48 Z M297.479925,411.86 C275.077969,437.877726 242.392659,452.761934 208.059925,452.58 C153.691226,452.598435 105.87164,416.63791 90.7999254,364.4 L308.339925,364.4 C304.575868,341.309464 304.690779,317.752715 308.679925,294.7 L3.05992537,294.7 C-0.902504563,317.755068 -1.01739385,341.307372 2.71992537,364.4 L2.71992537,364.4 C19.3292424,465.441984 106.661918,539.594765 209.059925,539.6 C266.986094,539.900862 322.217868,515.161403 360.559925,471.74 C344.364089,454.096816 331.320914,433.801419 321.999925,411.74 L297.479925,411.86 Z" id="Shape" fill="#B72768" fill-rule="nonzero"></path>
+    </g>
+</svg>

src/course-header/index.js

@@ -0,0 +1,2 @@
+export { default as Header } from './Header';
+export { default as CourseTabsNavigation } from './CourseTabsNavigation';

src/course-home/CourseDates.jsx

@@ -0,0 +1,41 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+export default function CourseDates({
+  start,
+  end,
+  enrollmentStart,
+  enrollmentEnd,
+  enrollmentMode,
+  isEnrolled,
+}) {
+  return (
+    <section>
+      <h4>Upcoming Dates</h4>
+      <div><strong>Course Start:</strong><br />{start}</div>
+      <div><strong>Course End:</strong><br />{end}</div>
+      <div><strong>Enrollment Start:</strong><br />{enrollmentStart}</div>
+      <div><strong>Enrollment End:</strong><br />{enrollmentEnd}</div>
+      <div><strong>Mode:</strong><br />{enrollmentMode}</div>
+      <div>{isEnrolled ? 'Active Enrollment' : 'Inactive Enrollment'}</div>
+    </section>
+  );
+}
+
+CourseDates.propTypes = {
+  start: PropTypes.string,
+  end: PropTypes.string,
+  enrollmentStart: PropTypes.string,
+  enrollmentEnd: PropTypes.string,
+  enrollmentMode: PropTypes.string,
+  isEnrolled: PropTypes.bool,
+};
+
+CourseDates.defaultProps = {
+  start: null,
+  end: null,
+  enrollmentStart: null,
+  enrollmentEnd: null,
+  enrollmentMode: null,
+  isEnrolled: false,
+};

src/course-home/CourseHome.jsx

@@ -0,0 +1,97 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Button } from '@edx/paragon';
+
+import AlertList from '../user-messages/AlertList';
+import { Header, CourseTabsNavigation } from '../course-header';
+import { useLogistrationAlert } from '../logistration-alert';
+import { useEnrollmentAlert } from '../enrollment-alert';
+
+import CourseDates from './CourseDates';
+import Section from './Section';
+import { useModel } from '../model-store';
+
+// Note that we import from the component files themselves in the enrollment-alert package.
+// This is because Reacy.lazy() requires that we import() from a file with a Component as it's
+// default export.
+// See React.lazy docs here: https://reactjs.org/docs/code-splitting.html#reactlazy
+const { EnrollmentAlert, StaffEnrollmentAlert } = React.lazy(() => import('../enrollment-alert'));
+const LogistrationAlert = React.lazy(() => import('../logistration-alert'));
+
+export default function CourseHome({
+  courseId,
+}) {
+  useLogistrationAlert();
+  useEnrollmentAlert(courseId);
+
+  const {
+    org,
+    number,
+    title,
+    start,
+    end,
+    enrollmentStart,
+    enrollmentEnd,
+    enrollmentMode,
+    isEnrolled,
+    tabs,
+    sectionIds,
+  } = useModel('courses', courseId);
+
+  return (
+    <>
+      <Header
+        courseOrg={org}
+        courseNumber={number}
+        courseTitle={title}
+      />
+      <main className="d-flex flex-column flex-grow-1">
+        <div className="container-fluid">
+          <CourseTabsNavigation tabs={tabs} className="mb-3" activeTabSlug="courseware" />
+          <AlertList
+            topic="outline"
+            className="mb-3"
+            customAlerts={{
+              clientEnrollmentAlert: EnrollmentAlert,
+              clientStaffEnrollmentAlert: StaffEnrollmentAlert,
+              clientLogistrationAlert: LogistrationAlert,
+            }}
+          />
+        </div>
+        <div className="flex-grow-1">
+          <div className="container-fluid">
+            <div className="d-flex justify-content-between mb-3">
+              <h2>{title}</h2>
+              <Button className="btn-primary" type="button">Resume Course</Button>
+            </div>
+            <div className="row">
+              <div className="col col-8">
+                {sectionIds.map((sectionId) => (
+                  <Section
+                    key={sectionId}
+                    id={sectionId}
+                    courseId={courseId}
+                  />
+                ))}
+              </div>
+              <div className="col col-4">
+                <CourseDates
+                  start={start}
+                  end={end}
+                  enrollmentStart={enrollmentStart}
+                  enrollmentEnd={enrollmentEnd}
+                  enrollmentMode={enrollmentMode}
+                  isEnrolled={isEnrolled}
+                />
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+    </>
+  );
+}
+
+CourseHome.propTypes = {
+  courseId: PropTypes.string.isRequired,
+};

src/course-home/CourseHomeContainer.jsx

@@ -0,0 +1,54 @@
+import React, { useEffect } from 'react';
+import PropTypes from 'prop-types';
+import { useDispatch, useSelector } from 'react-redux';
+import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
+
+import messages from './messages';
+import PageLoading from '../PageLoading';
+import CourseHome from './CourseHome';
+import { fetchCourse } from '../data';
+
+function CourseHomeContainer(props) {
+  const {
+    intl,
+    match,
+  } = props;
+
+  const dispatch = useDispatch();
+  useEffect(() => {
+    // The courseId from the URL is the course we WANT to load.
+    dispatch(fetchCourse(match.params.courseId));
+  }, [match.params.courseId]);
+
+  // The courseId from the store is the course we HAVE loaded.  If the URL changes,
+  // we don't want the application to adjust to it until it has actually loaded the new data.
+  const {
+    courseId,
+    courseStatus,
+  } = useSelector(state => state.courseware);
+
+  return (
+    <>
+      {courseStatus === 'loaded' ? (
+        <CourseHome
+          courseId={courseId}
+        />
+      ) : (
+        <PageLoading
+          srMessage={intl.formatMessage(messages['learn.loading.outline'])}
+        />
+      )}
+    </>
+  );
+}
+
+CourseHomeContainer.propTypes = {
+  intl: intlShape.isRequired,
+  match: PropTypes.shape({
+    params: PropTypes.shape({
+      courseId: PropTypes.string.isRequired,
+    }).isRequired,
+  }).isRequired,
+};
+
+export default injectIntl(CourseHomeContainer);

src/course-home/Section.jsx

@@ -0,0 +1,44 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Collapsible } from '@edx/paragon';
+import { faChevronRight, faChevronDown } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import SequenceLink from './SequenceLink';
+import { useModel } from '../model-store';
+
+export default function Section({ id, courseId }) {
+  const section = useModel('sections', id);
+  const { title, sequenceIds } = section;
+  return (
+    <Collapsible.Advanced className="collapsible-card mb-2">
+      <Collapsible.Trigger className="collapsible-trigger d-flex align-items-start">
+        <Collapsible.Visible whenClosed>
+          <div style={{ minWidth: '1rem' }}>
+            <FontAwesomeIcon icon={faChevronRight} />
+          </div>
+        </Collapsible.Visible>
+        <Collapsible.Visible whenOpen>
+          <div style={{ minWidth: '1rem' }}>
+            <FontAwesomeIcon icon={faChevronDown} />
+          </div>
+        </Collapsible.Visible>
+        <div className="ml-2 flex-grow-1">{title}</div>
+      </Collapsible.Trigger>
+
+      <Collapsible.Body className="collapsible-body">
+        {sequenceIds.map((sequenceId) => (
+          <SequenceLink
+            key={sequenceId}
+            id={sequenceId}
+            courseId={courseId}
+          />
+        ))}
+      </Collapsible.Body>
+    </Collapsible.Advanced>
+  );
+}
+
+Section.propTypes = {
+  id: PropTypes.string.isRequired,
+  courseId: PropTypes.string.isRequired,
+};

src/course-home/SequenceLink.jsx

@@ -0,0 +1,18 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Link } from 'react-router-dom';
+import { useModel } from '../model-store';
+
+export default function SequenceLink({ id, courseId }) {
+  const sequence = useModel('sequences', id);
+  return (
+    <div className="ml-4">
+      <Link to={`/learning/course/${courseId}/${id}`}>{sequence.title}</Link>
+    </div>
+  );
+}
+
+SequenceLink.propTypes = {
+  id: PropTypes.string.isRequired,
+  courseId: PropTypes.string.isRequired,
+};

src/course-home/index.js

@@ -0,0 +1 @@
+export { default } from './CourseHomeContainer';

src/course-home/messages.js

@@ -0,0 +1,11 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages({
+  'learn.loading.outline': {
+    id: 'learn.loading.learning.sequence',
+    defaultMessage: 'Loading learning sequence...',
+    description: 'Message when learning sequence is being loaded',
+  },
+});
+
+export default messages;

src/courseware/CoursewareContainer.jsx

@@ -0,0 +1,191 @@
+import React, { useEffect, useCallback } from 'react';
+import PropTypes from 'prop-types';
+import { useSelector, useDispatch } from 'react-redux';
+import { history } from '@edx/frontend-platform';
+
+import { useRouteMatch, Redirect } from 'react-router';
+import {
+  fetchCourse,
+  fetchSequence,
+} from '../data';
+import {
+  checkBlockCompletion,
+  saveSequencePosition,
+} from './data/thunks';
+import { useModel } from '../model-store';
+
+import Course from './course';
+
+import { sequenceIdsSelector, firstSequenceIdSelector } from './data/selectors';
+
+function useUnitNavigationHandler(courseId, sequenceId, unitId) {
+  const dispatch = useDispatch();
+  return useCallback((nextUnitId) => {
+    dispatch(checkBlockCompletion(courseId, sequenceId, unitId));
+    history.push(`/learning/course/${courseId}/${sequenceId}/${nextUnitId}`);
+  }, [courseId, sequenceId]);
+}
+
+function usePreviousSequence(sequenceId) {
+  const sequenceIds = useSelector(sequenceIdsSelector);
+  const sequences = useSelector(state => state.models.sequences);
+  if (!sequenceId || sequenceIds.length === 0) {
+    return null;
+  }
+  const sequenceIndex = sequenceIds.indexOf(sequenceId);
+  const previousSequenceId = sequenceIndex > 0 ? sequenceIds[sequenceIndex - 1] : null;
+  return previousSequenceId !== null ? sequences[previousSequenceId] : null;
+}
+
+function useNextSequence(sequenceId) {
+  const sequenceIds = useSelector(sequenceIdsSelector);
+  const sequences = useSelector(state => state.models.sequences);
+  if (!sequenceId || sequenceIds.length === 0) {
+    return null;
+  }
+  const sequenceIndex = sequenceIds.indexOf(sequenceId);
+  const nextSequenceId = sequenceIndex < sequenceIds.length - 1 ? sequenceIds[sequenceIndex + 1] : null;
+  return nextSequenceId !== null ? sequences[nextSequenceId] : null;
+}
+
+
+function useNextSequenceHandler(courseId, sequenceId) {
+  const nextSequence = useNextSequence(sequenceId);
+  const courseStatus = useSelector(state => state.courseware.courseStatus);
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+  return useCallback(() => {
+    if (nextSequence !== null) {
+      const nextUnitId = nextSequence.unitIds[0];
+      history.push(`/learning/course/${courseId}/${nextSequence.id}/${nextUnitId}`);
+    }
+  }, [courseStatus, sequenceStatus, sequenceId]);
+}
+
+function usePreviousSequenceHandler(courseId, sequenceId) {
+  const previousSequence = usePreviousSequence(sequenceId);
+  const courseStatus = useSelector(state => state.courseware.courseStatus);
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+  return useCallback(() => {
+    if (previousSequence !== null) {
+      const previousUnitId = previousSequence.unitIds[previousSequence.unitIds.length - 1];
+      history.push(`/learning/course/${courseId}/${previousSequence.id}/${previousUnitId}`);
+    }
+  }, [courseStatus, sequenceStatus, sequenceId]);
+}
+
+function useExamRedirect(sequenceId) {
+  const sequence = useModel('sequences', sequenceId);
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+  useEffect(() => {
+    if (sequenceStatus === 'loaded' && sequence.isTimeLimited) {
+      global.location.assign(sequence.lmsWebUrl);
+    }
+  }, [sequenceStatus, sequence]);
+}
+
+function useContentRedirect(courseStatus, sequenceStatus) {
+  const match = useRouteMatch();
+  const { courseId, sequenceId, unitId } = match.params;
+  const sequence = useModel('sequences', sequenceId);
+  const firstSequenceId = useSelector(firstSequenceIdSelector);
+  useEffect(() => {
+    if (courseStatus === 'loaded' && !sequenceId) {
+      // This is a replace because we don't want this change saved in the browser's history.
+      history.replace(`/learning/course/${courseId}/${firstSequenceId}`);
+    }
+  }, [courseStatus, sequenceId]);
+
+  useEffect(() => {
+    if (sequenceStatus === 'loaded' && sequenceId && !unitId) {
+      // The position may be null, in which case we'll just assume 0.
+      if (sequence.unitIds !== undefined && sequence.unitIds.length > 0) {
+        const unitIndex = sequence.position || 0;
+        const nextUnitId = sequence.unitIds[unitIndex];
+        // This is a replace because we don't want this change saved in the browser's history.
+        history.replace(`/learning/course/${courseId}/${sequence.id}/${nextUnitId}`);
+      }
+    }
+  }, [sequenceStatus, sequenceId, unitId]);
+}
+
+function useSavedSequencePosition(courseId, sequenceId, unitId) {
+  const dispatch = useDispatch();
+  const sequence = useModel('sequences', sequenceId);
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+  useEffect(() => {
+    if (sequenceStatus === 'loaded' && sequence.savePosition) {
+      const activeUnitIndex = sequence.unitIds.indexOf(unitId);
+      dispatch(saveSequencePosition(courseId, sequenceId, activeUnitIndex));
+    }
+  }, [unitId]);
+}
+
+export default function CoursewareContainer() {
+  const { params } = useRouteMatch();
+  const {
+    courseId: routeCourseUsageKey,
+    sequenceId: routeSequenceId,
+    unitId: routeUnitId,
+  } = params;
+  const dispatch = useDispatch();
+
+  useEffect(() => {
+    dispatch(fetchCourse(routeCourseUsageKey));
+  }, [routeCourseUsageKey]);
+
+  useEffect(() => {
+    if (routeSequenceId) {
+      dispatch(fetchSequence(routeSequenceId));
+    }
+  }, [routeSequenceId]);
+
+  // The courseId and sequenceId in the store are the entities we currently have loaded.
+  // We get these two IDs from the store because until fetchCourse and fetchSequence below have
+  // finished their work, the IDs in the URL are not representative of what we should actually show.
+  // This is important particularly when switching sequences.  Until a new sequence is fully loaded,
+  // there's information that we don't have yet - if we use the URL's sequence ID to tell the app
+  // which sequence is loaded, we'll instantly try to pull it out of the store and use it, before
+  // the sequenceStatus flag has even switched back to "loading", which will put our app into an
+  // invalid state.
+  const {
+    courseId,
+    sequenceId,
+    courseStatus,
+    sequenceStatus,
+  } = useSelector(state => state.courseware);
+
+  const nextSequenceHandler = useNextSequenceHandler(courseId, sequenceId);
+  const previousSequenceHandler = usePreviousSequenceHandler(courseId, sequenceId);
+  const unitNavigationHandler = useUnitNavigationHandler(courseId, sequenceId, routeUnitId);
+
+  useContentRedirect(courseStatus, sequenceStatus);
+  useExamRedirect(sequenceId);
+  useSavedSequencePosition(courseId, sequenceId, routeUnitId);
+
+  if (courseStatus === 'denied') {
+    return <Redirect to={`/learning/redirect/course-home/${courseId}`} />;
+  }
+
+  return (
+    <main className="flex-grow-1 d-flex flex-column">
+      <Course
+        courseId={courseId}
+        sequenceId={sequenceId}
+        unitId={routeUnitId}
+        nextSequenceHandler={nextSequenceHandler}
+        previousSequenceHandler={previousSequenceHandler}
+        unitNavigationHandler={unitNavigationHandler}
+      />
+    </main>
+  );
+}
+
+CoursewareContainer.propTypes = {
+  match: PropTypes.shape({
+    params: PropTypes.shape({
+      courseId: PropTypes.string.isRequired,
+      sequenceId: PropTypes.string,
+      unitId: PropTypes.string,
+    }).isRequired,
+  }).isRequired,
+};

src/courseware/course/Course.jsx

@@ -0,0 +1,129 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
+
+import { useSelector } from 'react-redux';
+import AlertList from '../../user-messages/AlertList';
+import { useLogistrationAlert } from '../../logistration-alert';
+import { useEnrollmentAlert } from '../../enrollment-alert';
+import PageLoading from '../../PageLoading';
+
+import InstructorToolbar from './InstructorToolbar';
+import Sequence from './sequence';
+
+import CourseBreadcrumbs from './CourseBreadcrumbs';
+import { Header, CourseTabsNavigation } from '../../course-header';
+import CourseSock from './course-sock';
+import Calculator from './calculator';
+import messages from './messages';
+import { useModel } from '../../model-store';
+
+// Note that we import from the component files themselves in the enrollment-alert package.
+// This is because Reacy.lazy() requires that we import() from a file with a Component as it's
+// default export.
+// See React.lazy docs here: https://reactjs.org/docs/code-splitting.html#reactlazy
+const EnrollmentAlert = React.lazy(() => import('../../enrollment-alert/EnrollmentAlert'));
+const StaffEnrollmentAlert = React.lazy(() => import('../../enrollment-alert/StaffEnrollmentAlert'));
+const LogistrationAlert = React.lazy(() => import('../../logistration-alert'));
+
+function Course({
+  courseId,
+  sequenceId,
+  unitId,
+  nextSequenceHandler,
+  previousSequenceHandler,
+  unitNavigationHandler,
+  intl,
+}) {
+  const course = useModel('courses', courseId);
+  const sequence = useModel('sequences', sequenceId);
+  const section = useModel('sections', sequence ? sequence.sectionId : null);
+
+  useLogistrationAlert();
+  useEnrollmentAlert(courseId);
+
+  const courseStatus = useSelector(state => state.courseware.courseStatus);
+
+  if (courseStatus === 'loading') {
+    return (
+      <PageLoading
+        srMessage={intl.formatMessage(messages['learn.loading.learning.sequence'])}
+      />
+    );
+  }
+
+  if (courseStatus === 'loaded') {
+    const {
+      org, number, title, isStaff, tabs, verifiedMode, showCalculator,
+    } = course;
+    return (
+      <>
+        <Header
+          courseOrg={org}
+          courseNumber={number}
+          courseTitle={title}
+        />
+        {isStaff && (
+        <InstructorToolbar
+          unitId={unitId}
+        />
+        )}
+        <CourseTabsNavigation tabs={tabs} activeTabSlug="courseware" />
+        <div className="container-fluid">
+          <AlertList
+            className="my-3"
+            topic="course"
+            customAlerts={{
+              clientEnrollmentAlert: EnrollmentAlert,
+              clientStaffEnrollmentAlert: StaffEnrollmentAlert,
+              clientLogistrationAlert: LogistrationAlert,
+            }}
+          />
+          <CourseBreadcrumbs
+            courseId={courseId}
+            sectionId={section ? section.id : null}
+            sequenceId={sequenceId}
+          />
+          <AlertList topic="sequence" />
+        </div>
+        <div className="flex-grow-1 d-flex flex-column">
+          <Sequence
+            unitId={unitId}
+            sequenceId={sequenceId}
+            courseId={courseId}
+            unitNavigationHandler={unitNavigationHandler}
+            nextSequenceHandler={nextSequenceHandler}
+            previousSequenceHandler={previousSequenceHandler}
+          />
+          {verifiedMode && <CourseSock verifiedMode={verifiedMode} />}
+          {showCalculator && <Calculator />}
+        </div>
+      </>
+    );
+  }
+
+  // courseStatus 'failed' and any other unexpected course status.
+  return (
+    <p className="text-center py-5 mx-auto" style={{ maxWidth: '30em' }}>
+      {intl.formatMessage(messages['learn.course.load.failure'])}
+    </p>
+  );
+}
+
+Course.propTypes = {
+  courseId: PropTypes.string,
+  sequenceId: PropTypes.string,
+  unitId: PropTypes.string,
+  nextSequenceHandler: PropTypes.func.isRequired,
+  previousSequenceHandler: PropTypes.func.isRequired,
+  unitNavigationHandler: PropTypes.func.isRequired,
+  intl: intlShape.isRequired,
+};
+
+Course.defaultProps = {
+  courseId: null,
+  sequenceId: null,
+  unitId: null,
+};
+
+export default injectIntl(Course);

src/courseware/course/CourseBreadcrumbs.jsx

@@ -0,0 +1,99 @@
+import React, { useMemo } from 'react';
+import PropTypes from 'prop-types';
+import { getConfig } from '@edx/frontend-platform';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faHome } from '@fortawesome/free-solid-svg-icons';
+import { useSelector } from 'react-redux';
+import { useModel } from '../../model-store';
+
+function CourseBreadcrumb({
+  url, children, withSeparator, ...attrs
+}) {
+  return (
+    <>
+      {withSeparator && (
+        <li className="mx-2 text-gray-300" role="presentation" aria-hidden>/</li>
+      )}
+      <li {...attrs}>
+        <a href={url}>{children}</a>
+      </li>
+    </>
+  );
+}
+
+CourseBreadcrumb.propTypes = {
+  url: PropTypes.string.isRequired,
+  children: PropTypes.node.isRequired,
+  withSeparator: PropTypes.bool,
+};
+
+CourseBreadcrumb.defaultProps = {
+  withSeparator: false,
+};
+
+export default function CourseBreadcrumbs({
+  courseId,
+  sectionId,
+  sequenceId,
+}) {
+  const course = useModel('courses', courseId);
+  const sequence = useModel('sequences', sequenceId);
+  const section = useModel('sections', sectionId);
+  const courseStatus = useSelector(state => state.courseware.courseStatus);
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+
+  const links = useMemo(() => {
+    if (courseStatus === 'loaded' && sequenceStatus === 'loaded') {
+      return [section, sequence].filter(node => !!node).map((node) => ({
+        id: node.id,
+        label: node.title,
+        url: `${getConfig().LMS_BASE_URL}/courses/${course.id}/course/#${node.id}`,
+      }));
+    }
+    return [];
+  }, [courseStatus, sequenceStatus]);
+
+  return (
+    <nav aria-label="breadcrumb" className="my-4">
+      <ol className="list-unstyled d-flex m-0">
+        <CourseBreadcrumb
+          url={`${getConfig().LMS_BASE_URL}/courses/${course.id}/course/`}
+          className="flex-shrink-0"
+        >
+          <FontAwesomeIcon icon={faHome} className="mr-2" />
+          <FormattedMessage
+            id="learn.breadcrumb.navigation.course.home"
+            description="The course home link in breadcrumbs nav"
+            defaultMessage="Course"
+          />
+        </CourseBreadcrumb>
+        {links.map(({ id, url, label }) => (
+          <CourseBreadcrumb
+            key={id}
+            url={url}
+            withSeparator
+            style={{
+              overflow: 'hidden',
+              textOverflow: 'ellipsis',
+              whiteSpace: 'nowrap',
+            }}
+          >
+            {label}
+          </CourseBreadcrumb>
+        ))}
+      </ol>
+    </nav>
+  );
+}
+
+CourseBreadcrumbs.propTypes = {
+  courseId: PropTypes.string.isRequired,
+  sectionId: PropTypes.string,
+  sequenceId: PropTypes.string,
+};
+
+CourseBreadcrumbs.defaultProps = {
+  sectionId: null,
+  sequenceId: null,
+};

src/courseware/course/InstructorToolbar.jsx

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { connect } from 'react-redux';
+import { Collapsible } from '@edx/paragon';
+
+function InstructorToolbar(props) {
+  // TODO: Only render this toolbar if the user is course staff
+  if (!props.activeUnitLmsWebUrl) {
+    return null;
+  }
+
+  return (
+    <div className="bg-primary text-light">
+      <div className="container-fluid py-3 d-md-flex justify-content-end align-items-center">
+        <div className="flex-grow-1">
+          <Collapsible.Advanced className="mr-5 mb-md-0">
+            You are currently previewing the new learning sequence experience.
+            <Collapsible.Trigger className="d-inline-block ml-2" style={{ cursor: 'pointer' }}>
+              <Collapsible.Visible whenClosed>
+                <span style={{ borderBottom: 'solid 1px white' }}>More info</span> &rarr;
+              </Collapsible.Visible>
+            </Collapsible.Trigger>
+            <Collapsible.Body>
+              This preview is to allow for early content testing, especially for custom content blocks, with the goal of ensuring it renders as expected in the next experience. You can learn more through the following <a className="text-white" style={{ textDecoration: 'underline' }} href="https://partners.edx.org/announcements/author-preview-learning-sequence-experience-update" target="blank" rel="noopener">Partner Portal post</a>.  Please report any issues or provide <a className="text-white" style={{ textDecoration: 'underline' }} target="blank" rel="noopener" href="https://forms.gle/R6jMYJNTCj1vgC1D6">feedback using the linked form</a>.
+              <Collapsible.Trigger className="d-inline-block ml-2" style={{ cursor: 'pointer' }}>
+                <Collapsible.Visible whenOpen>
+                  <span style={{ borderBottom: 'solid 1px white' }}>Close</span> &times;
+                </Collapsible.Visible>
+              </Collapsible.Trigger>
+            </Collapsible.Body>
+          </Collapsible.Advanced>
+        </div>
+        <div className="flex-shrink-0">
+          <a className="btn d-block btn-outline-light" href={props.activeUnitLmsWebUrl}>View unit in the existing experience</a>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+InstructorToolbar.propTypes = {
+  activeUnitLmsWebUrl: PropTypes.string,
+};
+
+InstructorToolbar.defaultProps = {
+  activeUnitLmsWebUrl: undefined,
+};
+
+const mapStateToProps = (state, props) => {
+  if (!props.unitId) {
+    return {};
+  }
+
+  const activeUnit = state.models.units[props.unitId];
+  return {
+    activeUnitLmsWebUrl: activeUnit ? activeUnit.lmsWebUrl : undefined,
+  };
+};
+
+export default connect(mapStateToProps)(InstructorToolbar);

src/courseware/course/bookmark/BookmarkButton.jsx

@@ -0,0 +1,71 @@
+import React, { useCallback } from 'react';
+import PropTypes from 'prop-types';
+import { StatefulButton } from '@edx/paragon';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+import { useDispatch } from 'react-redux';
+import BookmarkOutlineIcon from './BookmarkOutlineIcon';
+import BookmarkFilledIcon from './BookmarkFilledIcon';
+import { removeBookmark, addBookmark } from './data/thunks';
+
+const addBookmarkLabel = (
+  <FormattedMessage
+    id="unit.bookmark.button.add.bookmark"
+    defaultMessage="Bookmark this page"
+    description="The button to bookmark a page"
+  />
+);
+
+const hasBookmarkLabel = (
+  <FormattedMessage
+    id="unit.bookmark.button.remove.bookmark"
+    defaultMessage="Bookmarked"
+    description="The button to show a page is bookmarked and the button to remove that bookmark"
+  />
+);
+
+export default function BookmarkButton({
+  isBookmarked, isProcessing, unitId,
+}) {
+  const bookmarkState = isBookmarked ? 'bookmarked' : 'default';
+  const state = isProcessing ? `${bookmarkState}Processing` : bookmarkState;
+
+  const dispatch = useDispatch();
+  const toggleBookmark = useCallback(() => {
+    if (isBookmarked) {
+      dispatch(removeBookmark(unitId));
+    } else {
+      dispatch(addBookmark(unitId));
+    }
+  }, [isBookmarked, unitId]);
+
+  return (
+    <StatefulButton
+      className="btn-link px-1 ml-n1 btn-sm"
+      onClick={toggleBookmark}
+      state={state}
+      disabledStates={['defaultProcessing', 'bookmarkedProcessing']}
+      labels={{
+        default: addBookmarkLabel,
+        defaultProcessing: addBookmarkLabel,
+        bookmarked: hasBookmarkLabel,
+        bookmarkedProcessing: hasBookmarkLabel,
+      }}
+      icons={{
+        default: <BookmarkOutlineIcon className="text-primary" />,
+        defaultProcessing: <BookmarkOutlineIcon className="text-primary" />,
+        bookmarked: <BookmarkFilledIcon className="text-primary" />,
+        bookmarkedProcessing: <BookmarkFilledIcon className="text-primary" />,
+      }}
+    />
+  );
+}
+
+BookmarkButton.propTypes = {
+  unitId: PropTypes.string.isRequired,
+  isBookmarked: PropTypes.bool,
+  isProcessing: PropTypes.bool.isRequired,
+};
+
+BookmarkButton.defaultProps = {
+  isBookmarked: false,
+};

src/courseware/course/bookmark/BookmarkFilledIcon.jsx

@@ -0,0 +1,7 @@
+import React from 'react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faBookmark } from '@fortawesome/free-solid-svg-icons';
+
+export default function BookmarkFilledIcon(props) {
+  return <FontAwesomeIcon icon={faBookmark} {...props} />;
+}

src/courseware/course/bookmark/BookmarkOutlineIcon.jsx

@@ -0,0 +1,7 @@
+import React from 'react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faBookmark } from '@fortawesome/free-regular-svg-icons';
+
+export default function BookmarkOutlineIcon(props) {
+  return <FontAwesomeIcon icon={faBookmark} {...props} />;
+}

src/courseware/course/bookmark/data/api.js

@@ -0,0 +1,13 @@
+import { getConfig } from '@edx/frontend-platform';
+import { getAuthenticatedHttpClient, getAuthenticatedUser } from '@edx/frontend-platform/auth';
+
+const bookmarksBaseUrl = `${getConfig().LMS_BASE_URL}/api/bookmarks/v1/bookmarks/`;
+
+export async function createBookmark(usageId) {
+  return getAuthenticatedHttpClient().post(bookmarksBaseUrl, { usage_id: usageId });
+}
+
+export async function deleteBookmark(usageId) {
+  const { username } = getAuthenticatedUser();
+  return getAuthenticatedHttpClient().delete(`${bookmarksBaseUrl}${username},${usageId}/`);
+}

src/courseware/course/bookmark/data/thunks.js

@@ -0,0 +1,78 @@
+
+import { logError } from '@edx/frontend-platform/logging';
+import {
+  createBookmark,
+  deleteBookmark,
+} from './api';
+import { updateModel } from '../../../../model-store';
+
+export function addBookmark(unitId) {
+  return async (dispatch) => {
+    // Optimistically update the bookmarked flag.
+    dispatch(updateModel({
+      modelType: 'units',
+      model: {
+        id: unitId,
+        bookmarked: true,
+        bookmarkedUpdateState: 'loading',
+      },
+    }));
+
+    try {
+      await createBookmark(unitId);
+      dispatch(updateModel({
+        modelType: 'units',
+        model: {
+          id: unitId,
+          bookmarked: true,
+          bookmarkedUpdateState: 'loaded',
+        },
+      }));
+    } catch (error) {
+      logError(error);
+      dispatch(updateModel({
+        modelType: 'units',
+        model: {
+          id: unitId,
+          bookmarked: false,
+          bookmarkedUpdateState: 'failed',
+        },
+      }));
+    }
+  };
+}
+
+export function removeBookmark(unitId) {
+  return async (dispatch) => {
+    // Optimistically update the bookmarked flag.
+    dispatch(updateModel({
+      modelType: 'units',
+      model: {
+        id: unitId,
+        bookmarked: false,
+        bookmarkedUpdateState: 'loading',
+      },
+    }));
+    try {
+      await deleteBookmark(unitId);
+      dispatch(updateModel({
+        modelType: 'units',
+        model: {
+          id: unitId,
+          bookmarked: false,
+          bookmarkedUpdateState: 'loaded',
+        },
+      }));
+    } catch (error) {
+      logError(error);
+      dispatch(updateModel({
+        modelType: 'units',
+        model: {
+          id: unitId,
+          bookmarked: true,
+          bookmarkedUpdateState: 'failed',
+        },
+      }));
+    }
+  };
+}

src/courseware/course/bookmark/index.js

@@ -0,0 +1,3 @@
+export { default as BookmarkButton } from './BookmarkButton';
+export { default as BookmarkFilledIcon } from './BookmarkFilledIcon';
+export { default as BookmarkOutlineIcon } from './BookmarkFilledIcon';

src/courseware/course/calculator/calculator.scss

@@ -0,0 +1,27 @@
+.calculator {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 100;
+  .calculator-trigger {
+    cursor: pointer;
+    display: inline-block;
+    position: relative;
+    z-index: 2;
+    background-color: #f1f1f1;
+    border: solid 1px #ddd;
+    border-bottom: none;
+    border-top-left-radius: .3rem;
+    border-top-right-radius: .3rem;
+    border-bottom-left-radius: 0;
+    border-bottom-right-radius: 0;
+    &:before {
+      border-radius: .5rem;
+    }
+  }
+  .calculator-content {
+    background-color: #f1f1f1;
+    box-shadow: 0 -1px 0 0 #ddd;
+  }
+}

src/courseware/course/calculator/index.jsx

@@ -0,0 +1,393 @@
+import React, { Component } from 'react';
+import { Collapsible } from '@edx/paragon';
+import { getConfig } from '@edx/frontend-platform';
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+import {
+  FormattedMessage, injectIntl, intlShape,
+} from '@edx/frontend-platform/i18n';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import {
+  faCalculator, faQuestionCircle, faTimesCircle, faEquals,
+} from '@fortawesome/free-solid-svg-icons';
+import messages from './messages';
+import './calculator.scss';
+
+class Calculator extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      equation: '',
+      result: '',
+    };
+    this.handleSubmit = this.handleSubmit.bind(this);
+  }
+
+  async handleSubmit(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    const urlEncoded = new URLSearchParams();
+    urlEncoded.append('equation', this.state.equation);
+
+    const response = await getAuthenticatedHttpClient().get(
+      `${getConfig().LMS_BASE_URL}/calculate?${urlEncoded.toString()}`,
+    );
+    this.setState(() => ({ result: response.data.result }));
+  }
+
+  changeEquation(value) {
+    this.setState(() => ({ equation: value }));
+  }
+
+  render() {
+    return (
+      <Collapsible.Advanced className="calculator">
+        <div className="container-fluid text-right">
+          <Collapsible.Trigger tag="a" className="calculator-trigger btn">
+            <Collapsible.Visible whenOpen>
+              <FontAwesomeIcon icon={faTimesCircle} aria-hidden="true" className="mr-2" />
+            </Collapsible.Visible>
+            <Collapsible.Visible whenClosed>
+              <FontAwesomeIcon icon={faCalculator} aria-hidden="true" className="mr-2" />
+            </Collapsible.Visible>
+            {this.props.intl.formatMessage(messages['calculator.button.label'])}
+          </Collapsible.Trigger>
+        </div>
+        <Collapsible.Body className="calculator-content pt-4">
+          <form onSubmit={this.handleSubmit} className="container-fluid form-inline flex-nowrap">
+            <input
+              type="text"
+              placeholder={this.props.intl.formatMessage(messages['calculator.input.field.label'])}
+              aria-label={this.props.intl.formatMessage(messages['calculator.input.field.label'])}
+              className="form-control w-100"
+              onChange={(event) => this.changeEquation(event.target.value)}
+            />
+            <button
+              className="btn btn-primary mx-3"
+              aria-label={this.props.intl.formatMessage(messages['calculator.submit.button.label'])}
+              type="submit"
+            >
+              <FontAwesomeIcon icon={faEquals} aria-hidden="true" />
+            </button>
+            <input
+              type="text"
+              tabIndex="-1"
+              readOnly
+              aria-live="polite"
+              placeholder={this.props.intl.formatMessage(messages['calculator.result.field.placeholder'])}
+              aria-label={this.props.intl.formatMessage(messages['calculator.result.field.label'])}
+              className="form-control w-50"
+              value={this.state.result}
+            />
+          </form>
+
+          <Collapsible.Advanced>
+            <div className="container-fluid">
+              <Collapsible.Trigger className="btn btn-link btn-sm px-0 d-inline-flex align-items-center">
+                <Collapsible.Visible whenOpen>
+                  <FontAwesomeIcon icon={faTimesCircle} aria-hidden="true" className="mr-2" />
+                </Collapsible.Visible>
+                <Collapsible.Visible whenClosed>
+                  <FontAwesomeIcon icon={faQuestionCircle} aria-hidden="true" className="mr-2" />
+                </Collapsible.Visible>
+                <FormattedMessage
+                  id="calculator.instructions.button.label"
+                  defaultMessage="Calculator Instructions"
+                />
+              </Collapsible.Trigger>
+            </div>
+            <Collapsible.Body className="container-fluid pt-3" style={{ maxHeight: '50vh', overflow: 'auto' }}>
+              <FormattedMessage
+                tagName="h6"
+                id="calculator.instructions"
+                defaultMessage="For detailed information, see {expressions_link} in the {edx_guide}."
+                values={{
+                  expressions_link: (
+                    <a href="https://edx.readthedocs.io/projects/edx-guide-for-students/en/latest/completing_assignments/SFD_mathformatting.html#math-formatting">
+                      <FormattedMessage
+                        id="calculator.instructions.expressions.link.title"
+                        defaultMessage="Entering Mathematical and Scientific Expressions"
+                      />
+                    </a>
+                  ),
+                  edx_guide: (
+                    <a href="https://edx-guide-for-students.readthedocs.io/en/latest/index.html">
+                      <FormattedMessage
+                        id="calculator.instructions.edx.guide.link.title"
+                        defaultMessage="edX Guide for Students"
+                      />
+                    </a>
+                  ),
+                }}
+              />
+              <p>
+                <strong>
+                  <FormattedMessage
+                    id="calculator.instructions.useful.tips"
+                    defaultMessage="Useful tips:"
+                  />
+                </strong>
+              </p>
+              <ul>
+                <li className="hint-item" id="hint-paren">
+                  <FormattedMessage
+                    id="calculator.hint1"
+                    defaultMessage="Use parentheses () to make expressions clear. You can use parentheses inside other parentheses."
+                  />
+                </li>
+                <li className="hint-item" id="hint-spaces">
+                  <FormattedMessage
+                    id="calculator.hint2"
+                    defaultMessage="Do not use spaces in expressions."
+                  />
+                </li>
+                <li className="hint-item" id="hint-howto-constants">
+                  <FormattedMessage
+                    id="calculator.hint3"
+                    defaultMessage="For constants, indicate multiplication explicitly (example: 5*c)."
+                  />
+                </li>
+                <li className="hint-item" id="hint-howto-maffixes">
+                  <FormattedMessage
+                    id="calculator.hint4"
+                    defaultMessage="For affixes, type the number and affix without a space (example: 5c)."
+                  />
+                </li>
+                <li className="hint-item" id="hint-howto-functions">
+                  <FormattedMessage
+                    id="calculator.hint5"
+                    defaultMessage="For functions, type the name of the function, then the expression in parentheses."
+                  />
+                </li>
+              </ul>
+              <table className="table small">
+                <thead>
+                  <tr>
+                    <th scope="col">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.heading"
+                        defaultMessage="To Use"
+                      />
+                    </th>
+                    <th scope="col">
+                      <FormattedMessage
+                        id="calculator.instruction.table.type.heading"
+                        defaultMessage="Type"
+                      />
+                    </th>
+                    <th scope="col">
+                      <FormattedMessage
+                        id="calculator.instruction.table.examples.heading"
+                        defaultMessage="Examples"
+                      />
+                    </th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.numbers"
+                        defaultMessage="Numbers"
+                      />
+                    </th>
+                    <td>
+                      <ul className="list-unstyled m-0">
+                        <li>
+                          <FormattedMessage
+                            id="calculator.instruction.table.to.use.numbers.type1"
+                            defaultMessage="Integers"
+                          />
+                        </li>
+                        <li>
+                          <FormattedMessage
+                            id="calculator.instruction.table.to.use.numbers.type2"
+                            defaultMessage="Fractions"
+                          />
+                        </li>
+                        <li>
+                          <FormattedMessage
+                            id="calculator.instruction.table.to.use.numbers.type3"
+                            defaultMessage="Decimals"
+                          />
+                        </li>
+                      </ul>
+                    </td>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>2520</li>
+                        <li>2/3</li>
+                        <li>3.14, .98</li>
+                      </ul>
+                    </td>
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.operators"
+                        defaultMessage="Operators"
+                      />
+                    </th>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>
+                          {' + - * / '}
+                          <FormattedMessage
+                            id="calculator.instruction.table.to.use.operators.type1"
+                            defaultMessage="(add, subtract, multiply, divide)"
+                          />
+                        </li>
+                        <li>
+                          {'^ '}
+                          <FormattedMessage
+                            id="calculator.instruction.table.to.use.operators.type2"
+                            defaultMessage="(raise to a power)"
+                          />
+                        </li>
+                        <li>
+                          {'|| '}
+                          <FormattedMessage
+                            id="calculator.instruction.table.to.use.operators.type3"
+                            defaultMessage="(parallel resistors)"
+                          />
+                        </li>
+                      </ul>
+                    </td>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>x+(2*y)/x-1</li>
+                        <li>x^(n+1)</li>
+                        <li>v_IN+v_OUT</li>
+                        <li>1||2</li>
+                      </ul>
+                    </td>
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.constants"
+                        defaultMessage="Constants"
+                      />
+                    </th>
+                    <td dir="auto">c, e, g, i, j, k, pi, q, T</td>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>20*c</li>
+                        <li>418*T</li>
+                      </ul>
+                    </td>
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.affixes"
+                        defaultMessage="Affixes"
+                      />
+                    </th>
+                    <td dir="auto">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.affixes.type"
+                        defaultMessage="Percent sign (%) and metric affixes ({affixes})"
+                        values={{
+                          affixes: 'd, c, m, u, n, p, k, M, G, T',
+                        }}
+                      />
+                    </td>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>20%</li>
+                        <li>20c</li>
+                        <li>418T</li>
+                      </ul>
+                    </td>
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.basic.functions"
+                        defaultMessage="Basic functions"
+                      />
+                    </th>
+                    <td dir="auto">abs, exp, fact, factorial, ln, log2, log10, sqrt</td>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>abs(x+y)</li>
+                        <li>sqrt(x^2-y)</li>
+                      </ul>
+                    </td>
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.trig.functions"
+                        defaultMessage="Trigonometric functions"
+                      />
+                    </th>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>sin, cos, tan, sec, csc, cot</li>
+                        <li>arcsin, sinh, arcsinh</li>
+                      </ul>
+                    </td>
+                    <td dir="auto">
+                      <ul className="list-unstyled m-0">
+                        <li>sin(4x+y)</li>
+                        <li>arccsch(4x+y)</li>
+                      </ul>
+                    </td>
+                    <td dir="auto" />
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.scientific.notation"
+                        defaultMessage="Scientific notation"
+                      />
+                    </th>
+                    <td dir="auto">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.scientific.notation.type1"
+                        defaultMessage="{exponentSyntax} and the exponent"
+                        values={{
+                          exponentSyntax: '10^',
+                        }}
+                      />
+                    </td>
+                    <td dir="auto">10^-9</td>
+                  </tr>
+                  <tr>
+                    <th scope="row">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.scientific.notation.type2"
+                        defaultMessage="{notationSyntax} notation"
+                        values={{
+                          notationSyntax: 'e',
+                        }}
+                      />
+                    </th>
+                    <td dir="auto">
+                      <FormattedMessage
+                        id="calculator.instruction.table.to.use.scientific.notation.type3"
+                        defaultMessage="{notationSyntax} and the exponent"
+                        values={{
+                          notationSyntax: '1e',
+                        }}
+                      />
+                    </td>
+                    <td dir="auto">1e-9</td>
+                  </tr>
+                </tbody>
+              </table>
+            </Collapsible.Body>
+          </Collapsible.Advanced>
+        </Collapsible.Body>
+      </Collapsible.Advanced>
+    );
+  }
+}
+
+Calculator.propTypes = {
+  intl: intlShape.isRequired,
+};
+
+
+export default injectIntl(Calculator);

src/courseware/course/calculator/messages.js

@@ -0,0 +1,31 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages({
+  'calculator.button.label': {
+    id: 'calculator.button.label',
+    defaultMessage: 'Calculator',
+    description: 'Button label to expand or close the calculator',
+  },
+  'calculator.input.field.label': {
+    id: 'calculator.input.field.label',
+    defaultMessage: 'Calculator Input',
+    description: 'label for calculator input',
+  },
+  'calculator.submit.button.label': {
+    id: 'calculator.submit.button.label',
+    defaultMessage: 'Calculate',
+    description: 'Submit button label to execute the calculator',
+  },
+  'calculator.result.field.label': {
+    id: 'calculator.result.field.label',
+    defaultMessage: 'Calculator Result',
+    description: 'label for calculator result',
+  },
+  'calculator.result.field.placeholder': {
+    id: 'calculator.result.field.placeholder',
+    defaultMessage: 'Result',
+    description: 'placeholder for calculator result',
+  },
+});
+
+export default messages;

src/courseware/course/course-sock/index.jsx

@@ -0,0 +1,175 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+import LearnerQuote1 from './assets/learner-quote.png';
+import LearnerQuote2 from './assets/learner-quote2.png';
+import VerifiedCert from './assets/verified-cert.png';
+
+export default class CourseSock extends Component {
+  constructor(props) {
+    super(props);
+    this.verifiedMode = props.verifiedMode;
+    this.state = { showUpsell: false };
+  }
+
+  handleClick = () => {
+    this.setState(state => ({
+      showUpsell: !state.showUpsell,
+    }));
+  }
+
+  render() {
+    const buttonClass = this.state.showUpsell ? 'btn-success' : 'btn-outline-success';
+    return (
+      <div className="verification-sock container py-5">
+        <div className="d-flex justify-content-center">
+          <button type="button" aria-expanded="false" className={`btn ${buttonClass}`} onClick={this.handleClick}>
+            <FormattedMessage
+              id="coursesock.upsell.heading"
+              defaultMessage="Learn About Verified Certificates"
+              description="The heading for the upsell dialog"
+            />
+          </button>
+        </div>
+        {this.state.showUpsell && (
+        <div className="d-flex justify-content-around">
+          <div className="mt-3">
+            <h2 className="font-weight-lighter">
+              <FormattedMessage
+                id="coursesock.upsell.verifiedcert"
+                defaultMessage="edX Verified Certificate"
+              />
+            </h2>
+            <h3>
+              <FormattedMessage
+                id="coursesock.upsell.why"
+                defaultMessage="Why upgrade?"
+              />
+            </h3>
+            <ul>
+              <li><FormattedMessage
+                id="coursesock.upsell.reason1"
+                defaultMessage="Official proof of completion"
+              />
+              </li>
+              <li><FormattedMessage
+                id="coursesock.upsell.reason2"
+                defaultMessage="Easily shareable certificate"
+              />
+              </li>
+              <li><FormattedMessage
+                id="coursesock.upsell.reason3"
+                defaultMessage="Proven motivator to complete the course"
+              />
+              </li>
+              <li><FormattedMessage
+                id="coursesock.upsell.reason4"
+                defaultMessage="Certificate purchases help edX continue to offer free courses"
+              />
+              </li>
+            </ul>
+            <h3><FormattedMessage
+              id="coursesock.upsell.howtitle"
+              defaultMessage="How it works"
+            />
+            </h3>
+            <ul>
+              <li><FormattedMessage
+                id="coursesock.upsell.how1"
+                defaultMessage="Pay the Verified Certificate upgrade fee"
+              />
+              </li>
+              <li><FormattedMessage
+                id="coursesock.upsell.how2"
+                defaultMessage="Verify your identity with a webcam and government-issued ID"
+              />
+              </li>
+              <li><FormattedMessage
+                id="coursesock.upsell.how3"
+                defaultMessage="Study hard and pass the course"
+              />
+              </li>
+              <li><FormattedMessage
+                id="coursesock.upsell.how4"
+                defaultMessage="Share your certificate with friends, employers, and others"
+              />
+              </li>
+            </ul>
+            <h3><FormattedMessage
+              id="coursesock.upsell.storytitle"
+              defaultMessage="edX Learner Stories"
+            />
+            </h3>
+            <div className="d-flex align-items-center my-4">
+              <img style={{ maxWidth: '4rem' }} alt="Christina Fong" src={LearnerQuote1} />
+              <div className="w-50 px-4">
+                <FormattedMessage
+                  id="coursesock.upsell.story1"
+                  defaultMessage="My certificate has helped me showcase my knowledge on my
+                   resume - I feel like this certificate could really help me land
+                   my dream job!"
+                />
+                <br />
+                <strong>&mdash; <FormattedMessage
+                  id="coursesock.upsell.learner"
+                  description="Name of learner"
+                  defaultMessage="{ name }, edX Learner"
+                  values={{ name: 'Christina Fong' }}
+                />
+                </strong>
+              </div>
+            </div>
+            <div className="d-flex align-items-center my-2">
+              <img style={{ maxWidth: '4rem' }} alt="Chery Troell" src={LearnerQuote2} />
+              <div className="w-50 px-4">
+                <FormattedMessage
+                  id="coursesock.upsell.story2"
+                  defaultMessage="I wanted to include a verified certificate on my resume and my profile to
+                 illustrate that I am working towards this goal I have and that I have
+                 achieved something while I was unemployed."
+                />
+                <br />
+                <strong>&mdash; <FormattedMessage
+                  id="coursesock.upsell.learner"
+                  description="Name of learner"
+                  defaultMessage="{ name }, edX Learner"
+                  values={{ name: 'Cheryl Troell' }}
+                />
+                </strong>
+              </div>
+            </div>
+          </div>
+          <div className="d-flex flex-column justify-content-between">
+            <img alt="Example Certificate" src={VerifiedCert} />
+            <a href={this.verifiedMode.upgradeUrl} className="btn btn-success btn-lg btn-upgrade focusable" data-creative="original_sock" data-position="sock">
+              <FormattedMessage
+                id="coursesock.upsell.upgrade"
+                defaultMessage="Upgrade ({symbol}{price} {currency})"
+                values={{
+                  symbol: this.verifiedMode.currencySymbol,
+                  price: this.verifiedMode.price,
+                  currency: this.verifiedMode.currency,
+                }}
+              />
+            </a>
+          </div>
+        </div>
+        )}
+      </div>
+    );
+  }
+}
+
+CourseSock.propTypes = {
+  verifiedMode: PropTypes.shape({
+    price: PropTypes.number,
+    currency: PropTypes.string,
+    currencySymbol: PropTypes.string,
+    sku: PropTypes.string,
+    upgradeUrl: PropTypes.string,
+  }),
+};
+
+CourseSock.defaultProps = {
+  verifiedMode: null,
+};

src/courseware/course/index.js

@@ -0,0 +1 @@
+export { default } from './Course';

src/courseware/course/messages.js

@@ -6,10 +6,10 @@ const messages = defineMessages({
     defaultMessage: 'Loading learning sequence...',
     description: 'Message when learning sequence is being loaded',
   },
-  'learn.loading.error': {
-    id: 'learn.loading.error',
-    defaultMessage: 'Error: {error}',
-    description: 'Message when learning sequence fails to load',
+  'learn.course.load.failure': {
+    id: 'learn.course.load.failure',
+    defaultMessage: 'There was an error loading this course.',
+    description: 'Message when a course fails to load',
   },
 });
 

src/courseware/course/sequence/Sequence.jsx

@@ -0,0 +1,201 @@
+/* eslint-disable no-use-before-define */
+import React, {
+  useEffect, useContext, Suspense, useState,
+} from 'react';
+import PropTypes from 'prop-types';
+import { sendTrackEvent } from '@edx/frontend-platform/analytics';
+import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
+
+import { useSelector } from 'react-redux';
+import Unit from './Unit';
+import { SequenceNavigation, UnitNavigation } from './sequence-navigation';
+import PageLoading from '../../../PageLoading';
+import messages from './messages';
+import UserMessagesContext from '../../../user-messages/UserMessagesContext';
+import { useModel } from '../../../model-store';
+
+const ContentLock = React.lazy(() => import('./content-lock'));
+
+function Sequence({
+  unitId,
+  sequenceId,
+  courseId,
+  unitNavigationHandler,
+  nextSequenceHandler,
+  previousSequenceHandler,
+  intl,
+}) {
+  const sequence = useModel('sequences', sequenceId);
+  const unit = useModel('units', unitId);
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+  const handleNext = () => {
+    const nextIndex = sequence.unitIds.indexOf(unitId) + 1;
+    if (nextIndex < sequence.unitIds.length) {
+      const newUnitId = sequence.unitIds[nextIndex];
+      handleNavigate(newUnitId);
+    } else {
+      nextSequenceHandler();
+    }
+  };
+
+  const handlePrevious = () => {
+    const previousIndex = sequence.unitIds.indexOf(unitId) - 1;
+    if (previousIndex >= 0) {
+      const newUnitId = sequence.unitIds[previousIndex];
+      handleNavigate(newUnitId);
+    } else {
+      previousSequenceHandler();
+    }
+  };
+
+  const handleNavigate = (destinationUnitId) => {
+    unitNavigationHandler(destinationUnitId);
+  };
+
+  const logEvent = (eventName, widgetPlacement, targetUnitId) => {
+    // Note: tabs are tracked with a 1-indexed position
+    // as opposed to a 0-index used throughout this MFE
+    const currentIndex = sequence.unitIds.length > 0 ? sequence.unitIds.indexOf(unitId) : 0;
+    const payload = {
+      current_tab: currentIndex + 1,
+      id: unitId,
+      tab_count: sequence.unitIds.length,
+      widget_placement: widgetPlacement,
+    };
+    if (targetUnitId) {
+      const targetIndex = sequence.unitIds.indexOf(targetUnitId);
+      payload.target_tab = targetIndex + 1;
+    }
+    sendTrackEvent(eventName, payload);
+  };
+
+  const { add, remove } = useContext(UserMessagesContext);
+  useEffect(() => {
+    let id = null;
+    if (sequenceStatus === 'loaded') {
+      if (sequence.bannerText) {
+        id = add({
+          code: null,
+          dismissible: false,
+          text: sequence.bannerText,
+          type: 'info',
+          topic: 'sequence',
+        });
+      }
+    }
+    return () => {
+      if (id) {
+        remove(id);
+      }
+    };
+  }, [sequenceStatus, sequence]);
+
+  const [unitHasLoaded, setUnitHasLoaded] = useState(false);
+  const handleUnitLoaded = () => {
+    setUnitHasLoaded(true);
+  };
+  useEffect(() => {
+    if (unit) {
+      setUnitHasLoaded(false);
+    }
+  }, [unit]);
+
+  if (sequenceStatus === 'loading') {
+    return (
+      <PageLoading
+        srMessage={intl.formatMessage(messages['learn.loading.learning.sequence'])}
+      />
+    );
+  }
+
+  const gated = sequence.gatedContent !== undefined && sequence.gatedContent.gated;
+
+  if (sequenceStatus === 'loaded') {
+    return (
+      <div className="sequence-container">
+        <div className="sequence">
+          <SequenceNavigation
+            sequenceId={sequenceId}
+            unitId={unitId}
+            className="mb-4"
+            nextSequenceHandler={() => {
+              logEvent('edx.ui.lms.sequence.next_selected', 'top');
+              handleNext();
+            }}
+            onNavigate={(destinationUnitId) => {
+              logEvent('edx.ui.lms.sequence.tab_selected', 'top', destinationUnitId);
+              handleNavigate(destinationUnitId);
+            }}
+            previousSequenceHandler={() => {
+              logEvent('edx.ui.lms.sequence.previous_selected', 'top');
+              handlePrevious();
+            }}
+          />
+          <div className="unit-container flex-grow-1">
+            {gated && (
+              <Suspense
+                fallback={(
+                  <PageLoading
+                    srMessage={intl.formatMessage(messages['learn.loading.content.lock'])}
+                  />
+                )}
+              >
+                <ContentLock
+                  courseId={courseId}
+                  sequenceTitle={sequence.title}
+                  prereqSectionName={sequence.gatedContent.gatedSectionName}
+                  prereqId={sequence.gatedContent.prereqId}
+                />
+              </Suspense>
+            )}
+            {!gated && unitId !== null && (
+              <Unit
+                key={unitId}
+                id={unitId}
+                onLoaded={handleUnitLoaded}
+              />
+            )}
+            {unitHasLoaded && (
+              <UnitNavigation
+                sequenceId={sequenceId}
+                unitId={unitId}
+                onClickPrevious={() => {
+                  logEvent('edx.ui.lms.sequence.previous_selected', 'bottom');
+                  handlePrevious();
+                }}
+                onClickNext={() => {
+                  logEvent('edx.ui.lms.sequence.next_selected', 'bottom');
+                  handleNext();
+                }}
+              />
+            )}
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  // sequence status 'failed' and any other unexpected sequence status.
+  return (
+    <p className="text-center py-5 mx-auto" style={{ maxWidth: '30em' }}>
+      {intl.formatMessage(messages['learn.course.load.failure'])}
+    </p>
+  );
+}
+
+Sequence.propTypes = {
+  unitId: PropTypes.string,
+  sequenceId: PropTypes.string,
+  courseId: PropTypes.string.isRequired,
+  unitNavigationHandler: PropTypes.func.isRequired,
+  nextSequenceHandler: PropTypes.func.isRequired,
+  previousSequenceHandler: PropTypes.func.isRequired,
+  intl: intlShape.isRequired,
+};
+
+Sequence.defaultProps = {
+  sequenceId: null,
+  unitId: null,
+};
+
+export default injectIntl(Sequence);

src/courseware/course/sequence/Unit.jsx

@@ -0,0 +1,66 @@
+import React, { useRef, useEffect, useState } from 'react';
+import PropTypes from 'prop-types';
+import { getConfig } from '@edx/frontend-platform';
+import BookmarkButton from '../bookmark/BookmarkButton';
+import { useModel } from '../../../model-store';
+
+export default function Unit({
+  onLoaded,
+  id,
+}) {
+  const iframeRef = useRef(null);
+  const iframeUrl = `${getConfig().LMS_BASE_URL}/xblock/${id}?show_title=0&show_bookmark_button=0`;
+
+  const [iframeHeight, setIframeHeight] = useState(0);
+  const [hasLoaded, setHasLoaded] = useState(false);
+
+  const unit = useModel('units', id);
+
+  useEffect(() => {
+    global.onmessage = (event) => {
+      const { type, payload } = event.data;
+
+      if (type === 'plugin.resize') {
+        setIframeHeight(payload.height);
+        if (!hasLoaded && iframeHeight === 0 && payload.height > 0) {
+          setHasLoaded(true);
+          if (onLoaded) {
+            onLoaded();
+          }
+        }
+      }
+    };
+  }, []);
+
+  return (
+    <div className="unit">
+      <h2 className="mb-0 h4">{unit.title}</h2>
+      <BookmarkButton
+        unitId={unit.id}
+        isBookmarked={unit.bookmarked}
+        isProcessing={unit.bookmarkedUpdateState === 'loading'}
+      />
+      <div className="unit-iframe-wrapper">
+        <iframe
+          id="unit-iframe"
+          title={unit.title}
+          ref={iframeRef}
+          src={iframeUrl}
+          allowFullScreen
+          height={iframeHeight}
+          scrolling="no"
+          referrerPolicy="origin"
+        />
+      </div>
+    </div>
+  );
+}
+
+Unit.propTypes = {
+  id: PropTypes.string.isRequired,
+  onLoaded: PropTypes.func,
+};
+
+Unit.defaultProps = {
+  onLoaded: undefined,
+};

src/courseware/course/sequence/content-lock/ContentLock.jsx

@@ -1,34 +1,32 @@
-import React, { useContext, useCallback } from 'react';
+import React, { useCallback } from 'react';
+import PropTypes from 'prop-types';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { faLock } from '@fortawesome/free-solid-svg-icons';
 import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
 import { history } from '@edx/frontend-platform';
 import { Button } from '@edx/paragon';
 
-import SubSectionMetadataContext from '../SubSectionMetadataContext';
 import messages from './messages';
-import { useCurrentSubSection } from '../../data/hooks';
-import CourseStructureContext from '../../CourseStructureContext';
-
-function ContentLock({ intl }) {
-  const { courseId } = useContext(CourseStructureContext);
-  const metadata = useContext(SubSectionMetadataContext);
-  const subSection = useCurrentSubSection();
 
+function ContentLock({
+  intl, courseId, prereqSectionName, prereqId, sequenceTitle,
+}) {
   const handleClick = useCallback(() => {
-    history.push(`/course/${courseId}/${metadata.gatedContent.prereqId}`);
+    history.push(`/learning/course/${courseId}/${prereqId}`);
   });
 
   return (
     <>
       <h3>
-        <FontAwesomeIcon icon={faLock} />{' '}
-        {subSection.displayName}
+        <FontAwesomeIcon icon={faLock} />
+        {' '}
+        {sequenceTitle}
       </h3>
       <h4>{intl.formatMessage(messages['learn.contentLock.content.locked'])}</h4>
-      <p>{intl.formatMessage(messages['learn.contentLock.complete.prerequisite'], {
-        prereqSectionName: metadata.gatedContent.prereqSectionName,
-      })}
+      <p>
+        {intl.formatMessage(messages['learn.contentLock.complete.prerequisite'], {
+          prereqSectionName,
+        })}
       </p>
       <p>
         <Button className="btn-primary" onClick={handleClick}>{intl.formatMessage(messages['learn.contentLock.goToSection'])}</Button>
@@ -36,9 +34,11 @@ function ContentLock({ intl }) {
     </>
   );
 }
-
 ContentLock.propTypes = {
   intl: intlShape.isRequired,
+  courseId: PropTypes.string.isRequired,
+  prereqSectionName: PropTypes.string.isRequired,
+  prereqId: PropTypes.string.isRequired,
+  sequenceTitle: PropTypes.string.isRequired,
 };
-
 export default injectIntl(ContentLock);

src/courseware/course/sequence/index.js

@@ -0,0 +1 @@
+export { default } from './Sequence';

src/courseware/course/sequence/messages.js

@@ -0,0 +1,21 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages({
+  'learn.loading.content.lock': {
+    id: 'learn.loading.content.lock',
+    defaultMessage: 'Loading locked content messaging...',
+    description: 'Message shown when an interface about locked content is being loaded',
+  },
+  'learn.loading.learning.sequence': {
+    id: 'learn.loading.learning.sequence',
+    defaultMessage: 'Loading learning sequence...',
+    description: 'Message when learning sequence is being loaded',
+  },
+  'learn.course.load.failure': {
+    id: 'learn.course.load.failure',
+    defaultMessage: 'There was an error loading this course.',
+    description: 'Message when a course fails to load',
+  },
+});
+
+export default messages;

src/courseware/course/sequence/sequence-navigation/CompleteIcon.jsx

@@ -0,0 +1,7 @@
+import React from 'react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faCheck } from '@fortawesome/free-solid-svg-icons';
+
+export default function CompleteIcon(props) {
+  return <FontAwesomeIcon icon={faCheck} {...props} />;
+}

src/courseware/course/sequence/sequence-navigation/SequenceNavigation.jsx

@@ -0,0 +1,84 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Button } from '@edx/paragon';
+import classNames from 'classnames';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faChevronLeft, faChevronRight } from '@fortawesome/free-solid-svg-icons';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+
+import { useSelector } from 'react-redux';
+import UnitButton from './UnitButton';
+import SequenceNavigationTabs from './SequenceNavigationTabs';
+import { useSequenceNavigationMetadata } from './hooks';
+import { useModel } from '../../../../model-store';
+
+export default function SequenceNavigation({
+  unitId,
+  sequenceId,
+  className,
+  onNavigate,
+  nextSequenceHandler,
+  previousSequenceHandler,
+}) {
+  const sequence = useModel('sequences', sequenceId);
+  const { isFirstUnit, isLastUnit } = useSequenceNavigationMetadata(sequenceId, unitId);
+  const isLocked = sequence.gatedContent !== undefined && sequence.gatedContent.gated;
+  const sequenceStatus = useSelector(state => state.courseware.sequenceStatus);
+
+  const renderUnitButtons = () => {
+    if (isLocked) {
+      return (
+        <UnitButton unitId={unitId} title="" contentType="lock" isActive onClick={() => {}} />
+      );
+    }
+    if (sequence.unitIds.length === 0 || unitId === null) {
+      return (
+        <div style={{ flexBasis: '100%', minWidth: 0, borderBottom: 'solid 1px #EAEAEA' }} />
+      );
+    }
+    return (
+      <SequenceNavigationTabs
+        unitIds={sequence.unitIds}
+        unitId={unitId}
+        showCompletion={sequence.showCompletion}
+        onNavigate={onNavigate}
+      />
+    );
+  };
+
+  return sequenceStatus === 'loaded' && (
+    <nav className={classNames('sequence-navigation', className)}>
+      <Button className="previous-btn" onClick={previousSequenceHandler} disabled={isFirstUnit}>
+        <FontAwesomeIcon icon={faChevronLeft} className="mr-2" size="sm" />
+        <FormattedMessage
+          defaultMessage="Previous"
+          id="learn.sequence.navigation.previous.button"
+          description="The Previous button in the sequence nav"
+        />
+      </Button>
+      {renderUnitButtons()}
+      <Button className="next-btn" onClick={nextSequenceHandler} disabled={isLastUnit}>
+        <FormattedMessage
+          defaultMessage="Next"
+          id="learn.sequence.navigation.next.button"
+          description="The Next button in the sequence nav"
+        />
+        <FontAwesomeIcon icon={faChevronRight} className="ml-2" size="sm" />
+      </Button>
+    </nav>
+  );
+}
+
+SequenceNavigation.propTypes = {
+  sequenceId: PropTypes.string.isRequired,
+  unitId: PropTypes.string,
+  className: PropTypes.string,
+  onNavigate: PropTypes.func.isRequired,
+  nextSequenceHandler: PropTypes.func.isRequired,
+  previousSequenceHandler: PropTypes.func.isRequired,
+};
+
+SequenceNavigation.defaultProps = {
+  className: null,
+  unitId: null,
+};

src/courseware/course/sequence/sequence-navigation/SequenceNavigationDropdown.jsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Dropdown } from '@edx/paragon';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+
+import UnitButton from './UnitButton';
+
+export default function SequenceNavigationDropdown({
+  unitId,
+  onNavigate,
+  showCompletion,
+  unitIds,
+}) {
+  return (
+    <Dropdown className="sequence-navigation-dropdown">
+      <Dropdown.Button className="dropdown-button font-weight-normal w-100 border-right-0">
+        <FormattedMessage
+          defaultMessage="{current} of {total}"
+          description="The title of the mobile menu for sequence navigation of units"
+          id="learn.course.sequence.navigation.mobile.menu"
+          values={{
+            current: unitIds.indexOf(unitId) + 1,
+            total: unitIds.length,
+          }}
+        />
+      </Dropdown.Button>
+      <Dropdown.Menu className="w-100">
+        {unitIds.map(buttonUnitId => (
+          <UnitButton
+            className="w-100"
+            isActive={unitId === buttonUnitId}
+            key={buttonUnitId}
+            onClick={onNavigate}
+            showCompletion={showCompletion}
+            showTitle
+            unitId={buttonUnitId}
+          />
+        ))}
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+}
+
+SequenceNavigationDropdown.propTypes = {
+  unitId: PropTypes.string.isRequired,
+  onNavigate: PropTypes.func.isRequired,
+  showCompletion: PropTypes.bool.isRequired,
+  unitIds: PropTypes.arrayOf(PropTypes.string).isRequired,
+};

src/courseware/course/sequence/sequence-navigation/SequenceNavigationTabs.jsx

@@ -0,0 +1,53 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+import UnitButton from './UnitButton';
+import SequenceNavigationDropdown from './SequenceNavigationDropdown';
+import useIndexOfLastVisibleChild from '../../../../tabs/useIndexOfLastVisibleChild';
+
+export default function SequenceNavigationTabs({
+  unitIds, unitId, showCompletion, onNavigate,
+}) {
+  const [
+    indexOfLastVisibleChild,
+    containerRef,
+    invisibleStyle,
+  ] = useIndexOfLastVisibleChild();
+  const shouldDisplayDropdown = indexOfLastVisibleChild === -1;
+
+  return (
+    <div style={{ flexBasis: '100%', minWidth: 0 }}>
+      <div className="sequence-navigation-tabs-container" ref={containerRef}>
+        <div
+          className="sequence-navigation-tabs d-flex flex-grow-1"
+          style={shouldDisplayDropdown ? invisibleStyle : null}
+        >
+          {unitIds.map(buttonUnitId => (
+            <UnitButton
+              key={buttonUnitId}
+              unitId={buttonUnitId}
+              isActive={unitId === buttonUnitId}
+              showCompletion={showCompletion}
+              onClick={onNavigate}
+            />
+          ))}
+        </div>
+      </div>
+      {shouldDisplayDropdown && (
+        <SequenceNavigationDropdown
+          unitId={unitId}
+          onNavigate={onNavigate}
+          showCompletion={showCompletion}
+          unitIds={unitIds}
+        />
+      )}
+    </div>
+  );
+}
+
+SequenceNavigationTabs.propTypes = {
+  unitId: PropTypes.string.isRequired,
+  onNavigate: PropTypes.func.isRequired,
+  showCompletion: PropTypes.bool.isRequired,
+  unitIds: PropTypes.arrayOf(PropTypes.string).isRequired,
+};

src/courseware/course/sequence/sequence-navigation/UnitButton.jsx

@@ -0,0 +1,75 @@
+import React, { useCallback } from 'react';
+import PropTypes from 'prop-types';
+import { connect } from 'react-redux';
+import classNames from 'classnames';
+import { Button } from '@edx/paragon';
+
+import UnitIcon from './UnitIcon';
+import CompleteIcon from './CompleteIcon';
+import BookmarkFilledIcon from '../../bookmark/BookmarkFilledIcon';
+
+function UnitButton({
+  onClick,
+  title,
+  contentType,
+  isActive,
+  bookmarked,
+  complete,
+  showCompletion,
+  unitId,
+  className,
+  showTitle,
+}) {
+  const handleClick = useCallback(() => {
+    onClick(unitId);
+  });
+
+  return (
+    <Button
+      className={classNames({
+        active: isActive,
+        complete: showCompletion && complete,
+      }, className)}
+      onClick={handleClick}
+      title={title}
+    >
+      <UnitIcon type={contentType} />
+      {showTitle && <span className="unit-title">{title}</span>}
+      {showCompletion && complete ? <CompleteIcon size="sm" className="text-success ml-2" /> : null}
+      {bookmarked ? (
+        <BookmarkFilledIcon
+          className="text-primary small position-absolute"
+          style={{ top: '-3px', right: '5px' }}
+        />
+      ) : null}
+    </Button>
+  );
+}
+
+UnitButton.propTypes = {
+  bookmarked: PropTypes.bool,
+  className: PropTypes.string,
+  complete: PropTypes.bool,
+  contentType: PropTypes.string.isRequired,
+  isActive: PropTypes.bool,
+  onClick: PropTypes.func.isRequired,
+  showCompletion: PropTypes.bool,
+  showTitle: PropTypes.bool,
+  title: PropTypes.string.isRequired,
+  unitId: PropTypes.string.isRequired,
+};
+
+UnitButton.defaultProps = {
+  className: undefined,
+  isActive: false,
+  bookmarked: false,
+  complete: false,
+  showTitle: false,
+  showCompletion: true,
+};
+
+const mapStateToProps = (state, props) => ({
+  ...state.models.units[props.unitId],
+});
+
+export default connect(mapStateToProps)(UnitButton);

src/courseware/course/sequence/sequence-navigation/UnitIcon.jsx

@@ -0,0 +1,37 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import {
+  faFilm, faBook, faEdit, faTasks, faLock,
+} from '@fortawesome/free-solid-svg-icons';
+
+export default function UnitIcon({ type }) {
+  let icon = null;
+  switch (type) {
+    case 'video':
+      icon = faFilm;
+      break;
+    case 'other':
+      icon = faBook;
+      break;
+    case 'vertical':
+      icon = faTasks;
+      break;
+    case 'problem':
+      icon = faEdit;
+      break;
+    case 'lock':
+      icon = faLock;
+      break;
+    default:
+      icon = faBook;
+  }
+
+  return (
+    <FontAwesomeIcon icon={icon} />
+  );
+}
+
+UnitIcon.propTypes = {
+  type: PropTypes.oneOf(['video', 'other', 'vertical', 'problem', 'lock']).isRequired,
+};

src/courseware/course/sequence/sequence-navigation/UnitNavigation.jsx

@@ -0,0 +1,66 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Button } from '@edx/paragon';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faChevronLeft, faChevronRight } from '@fortawesome/free-solid-svg-icons';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+import { useSequenceNavigationMetadata } from './hooks';
+
+export default function UnitNavigation(props) {
+  const {
+    sequenceId,
+    unitId,
+    onClickPrevious,
+    onClickNext,
+  } = props;
+
+  const { isFirstUnit, isLastUnit } = useSequenceNavigationMetadata(sequenceId, unitId);
+
+  return (
+    <div className="unit-navigation d-flex">
+      <Button
+        className="btn-outline-secondary previous-button mr-2"
+        disabled={isFirstUnit}
+        onClick={onClickPrevious}
+      >
+        <FontAwesomeIcon icon={faChevronLeft} className="mr-2" size="sm" />
+        <FormattedMessage
+          id="learn.sequence.navigation.after.unit.previous"
+          description="The button to go to the previous unit"
+          defaultMessage="Previous"
+        />
+      </Button>
+      {isLastUnit ? (
+        <div className="m-2">
+          <span role="img" aria-hidden="true">&#129303;</span> {/* This is a hugging face emoji */}
+          {' '}
+          <FormattedMessage
+            id="learn.end.of.course"
+            description="Message shown to students in place of a 'Next' button when they're at the end of a course."
+            defaultMessage="You've reached the end of this course!"
+          />
+        </div>
+      ) : (
+        <Button
+          className="btn-outline-primary next-button"
+          onClick={onClickNext}
+          disabled={isLastUnit}
+        >
+          <FormattedMessage
+            id="learn.sequence.navigation.after.unit.next"
+            description="The button to go to the next unit"
+            defaultMessage="Next"
+          />
+          <FontAwesomeIcon icon={faChevronRight} className="ml-2" size="sm" />
+        </Button>
+      )}
+    </div>
+  );
+}
+
+UnitNavigation.propTypes = {
+  sequenceId: PropTypes.string.isRequired,
+  unitId: PropTypes.string.isRequired,
+  onClickPrevious: PropTypes.func.isRequired,
+  onClickNext: PropTypes.func.isRequired,
+};

src/courseware/course/sequence/sequence-navigation/hooks.js

@@ -0,0 +1,24 @@
+/* eslint-disable import/prefer-default-export */
+
+import { useSelector } from 'react-redux';
+import { useModel } from '../../../../model-store';
+import { sequenceIdsSelector } from '../../../data/selectors';
+
+export function useSequenceNavigationMetadata(currentSequenceId, currentUnitId) {
+  const sequenceIds = useSelector(sequenceIdsSelector);
+  const sequence = useModel('sequences', currentSequenceId);
+  const courseStatus = useSelector(state => state.courseware.courseStatus);
+
+  // If we don't know the sequence and unit yet, then assume no.
+  if (courseStatus !== 'loaded' || !currentSequenceId || !currentUnitId) {
+    return { isFirstUnit: false, isLastUnit: false };
+  }
+  const isFirstSequence = sequenceIds.indexOf(currentSequenceId) === 0;
+  const isFirstUnitInSequence = sequence.unitIds.indexOf(currentUnitId) === 0;
+  const isFirstUnit = isFirstSequence && isFirstUnitInSequence;
+  const isLastSequence = sequenceIds.indexOf(currentSequenceId) === sequenceIds.length - 1;
+  const isLastUnitInSequence = sequence.unitIds.indexOf(currentUnitId) === sequence.unitIds.length - 1;
+  const isLastUnit = isLastSequence && isLastUnitInSequence;
+
+  return { isFirstUnit, isLastUnit };
+}

src/courseware/course/sequence/sequence-navigation/index.js

@@ -0,0 +1,2 @@
+export { default as SequenceNavigation } from './SequenceNavigation';
+export { default as UnitNavigation } from './UnitNavigation';

src/courseware/data/api.js

@@ -0,0 +1,47 @@
+import { getConfig } from '@edx/frontend-platform';
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+
+const getSequenceXModuleHandlerUrl = (courseId, sequenceId) => `${getConfig().LMS_BASE_URL}/courses/${courseId}/xblock/${sequenceId}/handler/xmodule_handler`;
+
+export async function getBlockCompletion(courseId, sequenceId, usageKey) {
+  // Post data sent to this endpoint must be url encoded
+  // TODO: Remove the need for this to be the case.
+  // TODO: Ensure this usage of URLSearchParams is working in Internet Explorer
+  const urlEncoded = new URLSearchParams();
+  urlEncoded.append('usage_key', usageKey);
+  const requestConfig = {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+  };
+
+  const { data } = await getAuthenticatedHttpClient().post(
+    `${getSequenceXModuleHandlerUrl(courseId, sequenceId)}/get_completion`,
+    urlEncoded.toString(),
+    requestConfig,
+  );
+
+  if (data.complete) {
+    return true;
+  }
+
+  return false;
+}
+
+export async function updateSequencePosition(courseId, sequenceId, position) {
+  // Post data sent to this endpoint must be url encoded
+  // TODO: Remove the need for this to be the case.
+  // TODO: Ensure this usage of URLSearchParams is working in Internet Explorer
+  const urlEncoded = new URLSearchParams();
+  // Position is 1-indexed on the server and 0-indexed in this app. Adjust here.
+  urlEncoded.append('position', position + 1);
+  const requestConfig = {
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+  };
+
+  const { data } = await getAuthenticatedHttpClient().post(
+    `${getSequenceXModuleHandlerUrl(courseId, sequenceId)}/goto_position`,
+    urlEncoded.toString(),
+    requestConfig,
+  );
+
+  return data;
+}

src/courseware/data/selectors.js

@@ -0,0 +1,25 @@
+/* eslint-disable import/prefer-default-export */
+export function sequenceIdsSelector(state) {
+  if (state.courseware.courseStatus !== 'loaded') {
+    return [];
+  }
+  const { sectionIds = [] } = state.models.courses[state.courseware.courseId];
+
+  const sequenceIds = sectionIds
+    .flatMap(sectionId => state.models.sections[sectionId].sequenceIds);
+
+  return sequenceIds;
+}
+
+export function firstSequenceIdSelector(state) {
+  if (state.courseware.courseStatus !== 'loaded') {
+    return null;
+  }
+  const { sectionIds = [] } = state.models.courses[state.courseware.courseId];
+
+  if (sectionIds.length === 0) {
+    return null;
+  }
+
+  return state.models.sections[sectionIds[0]].sequenceIds[0];
+}

src/courseware/data/thunks.js

@@ -0,0 +1,66 @@
+import { logError } from '@edx/frontend-platform/logging';
+import {
+  getBlockCompletion,
+  updateSequencePosition,
+} from './api';
+import {
+  updateModel,
+} from '../../model-store';
+
+export function checkBlockCompletion(courseId, sequenceId, unitId) {
+  return async (dispatch, getState) => {
+    const { models } = getState();
+    if (models.units[unitId].complete) {
+      return; // do nothing. Things don't get uncompleted after they are completed.
+    }
+
+    try {
+      const isComplete = await getBlockCompletion(courseId, sequenceId, unitId);
+      dispatch(updateModel({
+        modelType: 'units',
+        model: {
+          id: unitId,
+          complete: isComplete,
+        },
+      }));
+    } catch (error) {
+      logError(error);
+    }
+  };
+}
+
+export function saveSequencePosition(courseId, sequenceId, position) {
+  return async (dispatch, getState) => {
+    const { models } = getState();
+    const initialPosition = models.sequences[sequenceId].position;
+    // Optimistically update the position.
+    dispatch(updateModel({
+      modelType: 'sequences',
+      model: {
+        id: sequenceId,
+        position,
+      },
+    }));
+    try {
+      await updateSequencePosition(courseId, sequenceId, position);
+      // Update again under the assumption that the above call succeeded, since it doesn't return a
+      // meaningful response.
+      dispatch(updateModel({
+        modelType: 'sequences',
+        model: {
+          id: sequenceId,
+          position,
+        },
+      }));
+    } catch (error) {
+      logError(error);
+      dispatch(updateModel({
+        modelType: 'sequences',
+        model: {
+          id: sequenceId,
+          position: initialPosition,
+        },
+      }));
+    }
+  };
+}

src/courseware/index.js

@@ -0,0 +1 @@
+export { default } from './CoursewareContainer';

src/courseware/messages.js

@@ -0,0 +1,11 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages({
+  'learn.loading.error': {
+    id: 'learn.loading.error',
+    defaultMessage: 'Error: {error}',
+    description: 'Message when learning sequence fails to load',
+  },
+});
+
+export default messages;

src/data/api.js

@@ -0,0 +1,147 @@
+/* eslint-disable import/prefer-default-export */
+import { getConfig, camelCaseObject } from '@edx/frontend-platform';
+import { getAuthenticatedHttpClient, getAuthenticatedUser } from '@edx/frontend-platform/auth';
+import { logError } from '@edx/frontend-platform/logging';
+
+function normalizeMetadata(metadata) {
+  return {
+    id: metadata.id,
+    title: metadata.name,
+    number: metadata.number,
+    org: metadata.org,
+    enrollmentStart: metadata.enrollment_start,
+    enrollmentEnd: metadata.enrollment_end,
+    end: metadata.end,
+    start: metadata.start,
+    enrollmentMode: metadata.enrollment.mode,
+    isEnrolled: metadata.enrollment.is_active,
+    canLoadCourseware: metadata.can_load_courseware,
+    isStaff: metadata.is_staff,
+    verifiedMode: camelCaseObject(metadata.verified_mode),
+    tabs: camelCaseObject(metadata.tabs),
+    showCalculator: metadata.show_calculator,
+  };
+}
+
+export async function getCourseMetadata(courseId) {
+  const url = `${getConfig().LMS_BASE_URL}/api/courseware/course/${courseId}`;
+  const { data } = await getAuthenticatedHttpClient().get(url);
+  return normalizeMetadata(data);
+}
+
+function normalizeBlocks(courseId, blocks) {
+  const models = {
+    courses: {},
+    sections: {},
+    sequences: {},
+    units: {},
+  };
+  Object.values(blocks).forEach(block => {
+    switch (block.type) {
+      case 'course':
+        models.courses[block.id] = {
+          id: courseId,
+          title: block.display_name,
+          sectionIds: block.children || [],
+        };
+        break;
+      case 'chapter':
+        models.sections[block.id] = {
+          id: block.id,
+          title: block.display_name,
+          sequenceIds: block.children || [],
+        };
+        break;
+
+      case 'sequential':
+        models.sequences[block.id] = {
+          id: block.id,
+          title: block.display_name,
+          lmsWebUrl: block.lms_web_url,
+          unitIds: block.children || [],
+        };
+        break;
+      case 'vertical':
+        models.units[block.id] = {
+          id: block.id,
+          title: block.display_name,
+        };
+        break;
+      default:
+        logError(`Unexpected course block type: ${block.type} with ID ${block.id}.  Expected block types are course, chapter, sequential, and vertical.`);
+    }
+  });
+
+  // Next go through each list and use their child lists to decorate those children with a
+  // reference back to their parent.
+  Object.values(models.courses).forEach(course => {
+    if (Array.isArray(course.sectionIds)) {
+      course.sectionIds.forEach(sectionId => {
+        const section = models.sections[sectionId];
+        section.courseId = course.id;
+      });
+    }
+  });
+
+  Object.values(models.sections).forEach(section => {
+    if (Array.isArray(section.sequenceIds)) {
+      section.sequenceIds.forEach(sequenceId => {
+        models.sequences[sequenceId].sectionId = section.id;
+      });
+    }
+  });
+
+  Object.values(models.sequences).forEach(sequence => {
+    if (Array.isArray(sequence.unitIds)) {
+      sequence.unitIds.forEach(unitId => {
+        models.units[unitId].sequenceId = sequence.id;
+      });
+    }
+  });
+
+  return models;
+}
+
+export async function getCourseBlocks(courseId) {
+  const { username } = getAuthenticatedUser();
+  const url = new URL(`${getConfig().LMS_BASE_URL}/api/courses/v2/blocks/`);
+  url.searchParams.append('course_id', courseId);
+  url.searchParams.append('username', username);
+  url.searchParams.append('depth', 3);
+  url.searchParams.append('requested_fields', 'children,show_gated_sections');
+
+  const { data } = await getAuthenticatedHttpClient().get(url.href, {});
+  return normalizeBlocks(courseId, data.blocks);
+}
+
+function normalizeSequenceMetadata(sequence) {
+  return {
+    sequence: {
+      id: sequence.item_id,
+      unitIds: sequence.items.map(unit => unit.id),
+      bannerText: sequence.banner_text,
+      title: sequence.display_name,
+      gatedContent: camelCaseObject(sequence.gated_content),
+      isTimeLimited: sequence.is_time_limited,
+      // Position comes back from the server 1-indexed. Adjust here.
+      activeUnitIndex: sequence.position ? sequence.position - 1 : 0,
+      saveUnitPosition: sequence.save_position,
+      showCompletion: sequence.show_completion,
+    },
+    units: sequence.items.map(unit => ({
+      id: unit.id,
+      sequenceId: sequence.item_id,
+      bookmarked: unit.bookmarked,
+      complete: unit.complete,
+      title: unit.page_title,
+      contentType: unit.type,
+    })),
+  };
+}
+
+export async function getSequenceMetadata(sequenceId) {
+  const { data } = await getAuthenticatedHttpClient()
+    .get(`${getConfig().LMS_BASE_URL}/api/courseware/sequence/${sequenceId}`, {});
+
+  return normalizeSequenceMetadata(data);
+}

src/data/index.js

@@ -0,0 +1,6 @@
+export {
+  fetchCourse,
+  fetchSequence,
+} from './thunks';
+
+export { reducer } from './slice';

src/data/slice.js

@@ -0,0 +1,61 @@
+/* eslint-disable no-param-reassign */
+import { createSlice } from '@reduxjs/toolkit';
+
+export const LOADING = 'loading';
+export const LOADED = 'loaded';
+export const FAILED = 'failed';
+export const DENIED = 'denied';
+
+const slice = createSlice({
+  name: 'courseware',
+  initialState: {
+    courseStatus: 'loading',
+    courseId: null,
+    sequenceStatus: 'loading',
+    sequenceId: null,
+  },
+  reducers: {
+    fetchCourseRequest: (state, { payload }) => {
+      state.courseId = payload.courseId;
+      state.courseStatus = LOADING;
+    },
+    fetchCourseSuccess: (state, { payload }) => {
+      state.courseId = payload.courseId;
+      state.courseStatus = LOADED;
+    },
+    fetchCourseFailure: (state, { payload }) => {
+      state.courseId = payload.courseId;
+      state.courseStatus = FAILED;
+    },
+    fetchCourseDenied: (state, { payload }) => {
+      state.courseId = payload.courseId;
+      state.courseStatus = DENIED;
+    },
+    fetchSequenceRequest: (state, { payload }) => {
+      state.sequenceId = payload.sequenceId;
+      state.sequenceStatus = LOADING;
+    },
+    fetchSequenceSuccess: (state, { payload }) => {
+      state.sequenceId = payload.sequenceId;
+      state.sequenceStatus = LOADED;
+    },
+    fetchSequenceFailure: (state, { payload }) => {
+      state.sequenceId = payload.sequenceId;
+      state.sequenceStatus = FAILED;
+    },
+  },
+});
+
+export const {
+  fetchCourseRequest,
+  fetchCourseSuccess,
+  fetchCourseFailure,
+  fetchCourseDenied,
+  fetchSequenceRequest,
+  fetchSequenceSuccess,
+  fetchSequenceFailure,
+} = slice.actions;
+
+export const {
+  reducer,
+} = slice;

src/data/thunks.js

@@ -0,0 +1,107 @@
+import { logError } from '@edx/frontend-platform/logging';
+import {
+  getCourseMetadata,
+  getCourseBlocks,
+  getSequenceMetadata,
+} from './api';
+import {
+  addModelsMap, updateModel, updateModels, updateModelsMap, addModel,
+} from '../model-store';
+import {
+  fetchCourseRequest,
+  fetchCourseSuccess,
+  fetchCourseFailure,
+  fetchCourseDenied,
+  fetchSequenceRequest,
+  fetchSequenceSuccess,
+  fetchSequenceFailure,
+} from './slice';
+
+export function fetchCourse(courseId) {
+  return async (dispatch) => {
+    dispatch(fetchCourseRequest({ courseId }));
+    Promise.allSettled([
+      getCourseMetadata(courseId),
+      getCourseBlocks(courseId),
+    ]).then(([courseMetadataResult, courseBlocksResult]) => {
+      if (courseMetadataResult.status === 'fulfilled') {
+        dispatch(addModel({
+          modelType: 'courses',
+          model: courseMetadataResult.value,
+        }));
+      }
+
+      if (courseBlocksResult.status === 'fulfilled') {
+        const {
+          courses, sections, sequences, units,
+        } = courseBlocksResult.value;
+
+        dispatch(updateModelsMap({
+          modelType: 'courses',
+          modelsMap: courses,
+        }));
+        dispatch(addModelsMap({
+          modelType: 'sections',
+          modelsMap: sections,
+        }));
+        // We update for sequences and units because the sequence metadata may have come back first.
+        dispatch(updateModelsMap({
+          modelType: 'sequences',
+          modelsMap: sequences,
+        }));
+        dispatch(updateModelsMap({
+          modelType: 'units',
+          modelsMap: units,
+        }));
+      }
+
+      const fetchedMetadata = courseMetadataResult.status === 'fulfilled';
+      const fetchedBlocks = courseBlocksResult.status === 'fulfilled';
+
+      // Log errors for each request if needed. Course block failures may occur
+      // even if the course metadata request is successful
+      if (!fetchedBlocks) {
+        logError(courseBlocksResult.reason);
+      }
+      if (!fetchedMetadata) {
+        logError(courseMetadataResult.reason);
+      }
+
+      if (fetchedMetadata) {
+        if (courseMetadataResult.value.canLoadCourseware && fetchedBlocks) {
+          // User has access
+          dispatch(fetchCourseSuccess({ courseId }));
+          return;
+        }
+        // User either doesn't have access or only has partial access
+        // (can't access course blocks)
+        dispatch(fetchCourseDenied({ courseId }));
+        return;
+      }
+
+      // Definitely an error happening
+      dispatch(fetchCourseFailure({ courseId }));
+    });
+  };
+}
+
+export function fetchSequence(sequenceId) {
+  return async (dispatch) => {
+    dispatch(fetchSequenceRequest({ sequenceId }));
+    try {
+      const { sequence, units } = await getSequenceMetadata(sequenceId);
+      dispatch(updateModel({
+        modelType: 'sequences',
+        model: sequence,
+      }));
+      dispatch(updateModels({
+        modelType: 'units',
+        models: units,
+      }));
+      dispatch(fetchSequenceSuccess({ sequenceId }));
+    } catch (error) {
+      logError(error);
+      dispatch(fetchSequenceFailure({ sequenceId }));
+    }
+  };
+}

src/enrollment-alert/EnrollmentAlert.jsx

@@ -0,0 +1,24 @@
+import React from 'react';
+import { getConfig } from '@edx/frontend-platform';
+import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
+
+import Alert from '../user-messages/Alert';
+import messages from './messages';
+
+function EnrollmentAlert({ intl }) {
+  return (
+    <Alert type="error">
+      {intl.formatMessage(messages['learning.enrollment.alert'])}
+      {' '}
+      <a href={`${getConfig().LMS_BASE_URL}/api/enrollment/v1/enrollment`}>
+        {intl.formatMessage(messages['learning.enrollment.enroll.now'])}
+      </a>
+    </Alert>
+  );
+}
+
+EnrollmentAlert.propTypes = {
+  intl: intlShape.isRequired,
+};
+
+export default injectIntl(EnrollmentAlert);

src/enrollment-alert/StaffEnrollmentAlert.jsx

@@ -0,0 +1,24 @@
+import React from 'react';
+import { getConfig } from '@edx/frontend-platform';
+import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
+
+import Alert from '../user-messages/Alert';
+import messages from './messages';
+
+function StaffEnrollmentAlert({ intl }) {
+  return (
+    <Alert type="info" dismissible>
+      {intl.formatMessage(messages['learning.staff.enrollment.alert'])}
+      {' '}
+      <a href={`${getConfig().LMS_BASE_URL}/api/enrollment/v1/enrollment`}>
+        {intl.formatMessage(messages['learning.enrollment.enroll.now'])}
+      </a>
+    </Alert>
+  );
+}
+
+StaffEnrollmentAlert.propTypes = {
+  intl: intlShape.isRequired,
+};
+
+export default injectIntl(StaffEnrollmentAlert);

src/enrollment-alert/hooks.js

@@ -0,0 +1,36 @@
+/* eslint-disable import/prefer-default-export */
+import { useContext, useState, useEffect } from 'react';
+import UserMessagesContext from '../user-messages/UserMessagesContext';
+import { useModel } from '../model-store';
+
+export function useEnrollmentAlert(courseId) {
+  const course = useModel('courses', courseId);
+  const { add, remove } = useContext(UserMessagesContext);
+  const [alertId, setAlertId] = useState(null);
+  const isEnrolled = course && course.isEnrolled;
+  useEffect(() => {
+    if (course && course.isEnrolled !== undefined) {
+      if (!course.isEnrolled && alertId === null) {
+        if (course.isStaff) {
+          setAlertId(add({
+            code: 'clientStaffEnrollmentAlert',
+            topic: 'course',
+          }));
+        } else {
+          setAlertId(add({
+            code: 'clientEnrollmentAlert',
+            topic: 'course',
+          }));
+        }
+      } else if (course.isEnrolled && alertId !== null) {
+        remove(alertId);
+        setAlertId(null);
+      }
+    }
+    return () => {
+      if (alertId !== null) {
+        remove(alertId);
+      }
+    };
+  }, [course, isEnrolled]);
+}

src/enrollment-alert/index.js

@@ -0,0 +1,3 @@
+export { default as EnrollmentAlert } from './EnrollmentAlert';
+export { default as StaffEnrollmentAlert } from './StaffEnrollmentAlert';
+export { useEnrollmentAlert } from './hooks';

src/enrollment-alert/messages.js

@@ -0,0 +1,21 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages({
+  'learning.enrollment.alert': {
+    id: 'learning.enrollment.alert',
+    defaultMessage: 'You must be enrolled in the course to see course content.',
+    description: 'Message shown to indicate that a user needs to enroll in a course prior to viewing the course content.  Shown as part of an alert, along with a link to enroll.',
+  },
+  'learning.staff.enrollment.alert': {
+    id: 'learning.staff.enrollment.alert',
+    defaultMessage: 'You are viewing this course as staff, and are not enrolled.',
+    description: 'Message shown to indicate that a user is not enrolled, but is able to view a course anyway because they are staff. Shown as part of an alert, along with a link to enroll.',
+  },
+  'learning.enrollment.enroll.now': {
+    id: 'learning.enrollment.enroll.now',
+    defaultMessage: 'Enroll Now',
+    description: 'A link prompting the user to click on it to enroll in the currently viewed course.',
+  },
+});
+
+export default messages;

src/index.jsx

@@ -1,41 +1,46 @@
 import 'core-js/stable';
 import 'regenerator-runtime/runtime';
 
-import { APP_INIT_ERROR, APP_READY, subscribe, initialize } from '@edx/frontend-platform';
+import {
+  APP_INIT_ERROR, APP_READY, subscribe, initialize,
+} from '@edx/frontend-platform';
 import { AppProvider, ErrorPage } from '@edx/frontend-platform/react';
 import React from 'react';
 import ReactDOM from 'react-dom';
-import { Route, Switch, Link } from 'react-router-dom';
+import { Route, Switch } from 'react-router-dom';
 
-import Header, { messages as headerMessages } from '@edx/frontend-component-header';
+import { messages as headerMessages } from '@edx/frontend-component-header';
 import Footer, { messages as footerMessages } from '@edx/frontend-component-footer';
 
 import appMessages from './i18n';
-import CourseTabsNavigation from './components/CourseTabsNavigation';
-import LearningSequencePage from './learning-sequence/LearningSequencePage';
+import UserMessagesProvider from './user-messages/UserMessagesProvider';
 
 import './index.scss';
 import './assets/favicon.ico';
+import CoursewareContainer from './courseware';
+import CourseHomeContainer from './course-home';
+import CoursewareRedirect from './CoursewareRedirect';
+
+import store from './store';
 
 subscribe(APP_READY, () => {
   ReactDOM.render(
-    <AppProvider>
-      <Header />
-      <div className="container pt-2">
-        <CourseTabsNavigation activeTabSlug="course" />
-      </div>
-      <Switch>
-        {/* Staging: course-v1:UBCx+Water201x_2+2T2015 */}
-        <Route
-          exact
-          path="/"
-          render={() => <Link to="/course/course-v1%3AedX%2BDemoX%2BDemo_Course/block-v1:edX+DemoX+Demo_Course+type@sequential+block@edx_introduction/block-v1:edX+DemoX+Demo_Course+type@vertical+block@vertical_0270f6de40fc">Visit Demo Course</Link>}
-        />
-        <Route path="/course/:courseId/:subSectionId/:unitId" component={LearningSequencePage} />
-        <Route path="/course/:courseId/:subSectionId" component={LearningSequencePage} />
-        <Route path="/course/:courseId" component={LearningSequencePage} />
-      </Switch>
-      <Footer />
+    <AppProvider store={store}>
+      <UserMessagesProvider>
+        <Switch>
+          <Route path="/learning/redirect" component={CoursewareRedirect} />
+          <Route path="/learning/course/:courseId/home" component={CourseHomeContainer} />
+          <Route
+            path={[
+              '/learning/course/:courseId/:sequenceId/:unitId',
+              '/learning/course/:courseId/:sequenceId',
+              '/learning/course/:courseId',
+            ]}
+            component={CoursewareContainer}
+          />
+        </Switch>
+        <Footer />
+      </UserMessagesProvider>
     </AppProvider>,
     document.getElementById('root'),
   );
@@ -46,6 +51,9 @@ subscribe(APP_INIT_ERROR, (error) => {
 });
 
 initialize({
+  // TODO: Remove this once the course blocks api supports unauthenticated
+  // access and we are prepared to support public courses in this app.
+  requireAuthenticatedUser: true,
   messages: [
     appMessages,
     headerMessages,

src/index.scss

@@ -1,17 +1,51 @@
+$primary: #1176B2;
 @import '~@edx/paragon/scss/edx/theme.scss';
 
-@import './learning-sequence/index';
-
 @import "~@edx/frontend-component-header/dist/index";
 @import "~@edx/frontend-component-footer/dist/footer";
 
+// TODO: Fix .btn-outline-light style in paragon
+.btn-outline-light {
+  &:hover, &:focus {
+    color: $primary;
+    border-color: $white;
+    background-color: $white;
+  }
+  &:not(:disabled):not(.disabled):active {
+    border-color: $white;
+  }
+}
+
+// TODO: Fix .container-fluid for mobile in paragon
+.container-fluid {
+  @media (max-width: -1 + map-get($grid-breakpoints, 'sm')) {
+    padding-left: $grid-gutter-width/2;
+    padding-right: $grid-gutter-width/2;
+  }
+}
+
 #root {
   display: flex;
   flex-direction: column;
-  height: 100vh;
-
+  min-height: 100vh;
+  main {
+    flex-grow: 1;
+  }
   header {
     flex: 0;
+
+    .logo {
+      display: block;
+      box-sizing: content-box;
+      position: relative;
+      top: .10em;
+      height: 1.75rem;
+      margin-right: 1rem;
+      img {
+        display: block;
+        height: 100%;
+      }
+    }
   }
 
   footer {
@@ -19,17 +53,257 @@
   }
 }
 
+.course-header {
+  min-width: 0;
+  .course-title-lockup {
+    min-width: 0;
+    span {
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+  }
+  .user-dropdown {
+    .btn {
+      height: 3rem;
+      @media (max-width: -1 + map-get($grid-breakpoints, 'sm')) {
+        padding: 0 .5rem;
+      }
+    }
+  }
+}
+.course-tabs-navigation {
+  border-bottom: solid 1px #EAEAEA;
+}
+
 .nav-underline-tabs {
+  margin: 0 0 -1px;
   .nav-link {
     border-bottom: 4px solid transparent;
-    color: theme-color('gray', 700);
+    border-top: 4px solid transparent;
+    color: theme-color('gray', 400);
+
+    // temporary until we can remove .btn class from dropdowns
+    border-left: 0;
+    border-right: 0;
+    border-radius: 0;
 
     &:hover,
     &:focus,
     &.active {
       font-weight: $font-weight-normal;
       color: theme-color('primary', 500);
-      border-color: theme-color('primary', 500);
+      border-bottom-color: theme-color('primary', 500);
     }
   }
 }
+
+.sequence-container {
+  display: flex;
+  flex-direction: column;
+  flex-grow: 1;
+  margin-bottom: 4rem;
+  // On mobile, the unit container will be responsible
+  // for container padding.
+  @media (min-width: map-get($grid-breakpoints, 'sm')) {
+    max-width: 1440px;
+    width: 100%;
+    padding: 0 $grid-gutter-width;
+    margin-right: auto;
+    margin-left: auto;
+  }
+}
+
+.sequence {
+  @media (min-width: map-get($grid-breakpoints, 'sm')) {
+    border: solid 1px #EAEAEA;
+    border-radius: 4px;
+  }
+}
+
+.sequence-navigation {
+  display: flex;
+  @media (min-width: map-get($grid-breakpoints, 'sm')) {
+    margin: -1px -1px 0;
+  }
+
+  .btn {
+    flex-grow: 1;
+    display: inline-flex;
+    border-radius: 0;
+    border: solid 1px #EAEAEA;
+    border-left-width: 0;
+    position: relative;
+    font-weight: 400;
+    padding: 0 .375rem;
+    height: 3rem;
+    justify-content: center;
+    align-items: center;
+    color: theme-color('gray', 400);
+    white-space: nowrap;
+
+    &:hover,
+    &:focus,
+    &.active {
+      color: theme-color('gray', 700);
+    }
+    &:focus {
+      z-index: 1;
+    }
+    &.active {
+      &:after {
+        content: '';
+        position: absolute;
+        bottom: -1px;
+        left: 0;
+        right: 0;
+        height: 2px;
+        background: $primary;
+      }
+    }
+    &.complete {
+      background-color: #EEF7E5;
+      color: $success;
+    }
+
+    &:first-child {
+      border-left-width: 0;
+    }
+    &:last-child {
+      border-right-width: 0;
+    }
+  }
+
+  .sequence-navigation-tabs-container {
+    flex-grow: 1;
+    flex-shrink: 1;
+    flex-basis: 100%;
+    display: flex;
+    // min-width 0 prevents the flex item from overflowing the parent container
+    // https://dev.to/martyhimmel/quick-tip-to-stop-flexbox-from-overflowing-peb
+    min-width: 0;
+  }
+  .sequence-navigation-tabs {
+    .btn {
+      flex-basis: 100%;
+      min-width: 4rem;
+    }
+  }
+  .sequence-navigation-dropdown {
+    .dropdown-menu .btn {
+      flex-basis: 100%;
+      min-width: 4rem;
+      padding-left: 1rem;
+      padding-right: 1rem;
+      display: inline-flex;
+      align-items: center;
+      justify-content: flex-start;
+      border-right: 0;
+      & + .btn {
+        border-top: 0;
+      }
+      .unit-title {
+        flex-grow: 1;
+        text-align: left;
+        overflow: hidden;
+        min-width: 0;
+        margin: 0 1rem;
+        text-overflow: ellipsis;
+      }
+      &.active {
+        &:after {
+          content: '';
+          position: absolute;
+          bottom: 0px;
+          left: -1px;
+          top: 0;
+          right: auto;
+          width: 2px;
+          height: auto;
+          background: $primary;
+        }
+      }
+    }
+  }
+
+  .previous-btn, .next-btn {
+    min-width: 4rem;
+    color: theme-color('gray', 700);
+    display: inline-flex;
+    justify-content: center;
+    align-items: center;
+    @media (max-width: -1 + map-get($grid-breakpoints, 'sm')) {
+      padding-top: 1rem;
+      padding-bottom: 1rem;
+      span {
+        @include sr-only();
+      }
+    }
+    @media (min-width: map-get($grid-breakpoints, 'sm')) {
+      min-width: 10rem;
+    }
+  }
+
+  .previous-btn {
+    border-left-width: 0;
+    margin-left: 0;
+    @media (min-width: map-get($grid-breakpoints, 'sm')) {
+      border-left-width: 1px;
+      border-top-left-radius: 4px;
+    }
+  }
+
+  .next-btn {
+    border-left-width: 1px;
+    border-right-width: 0;
+    @media (min-width: map-get($grid-breakpoints, 'sm')) {
+      border-top-right-radius: 4px;
+      border-right-width: 1px;
+    }
+  }
+}
+
+.unit-container {
+  padding: 0 $grid-gutter-width 2rem;
+  max-width: 1024px;
+  margin-left: auto;
+  margin-right: auto;
+  @media (min-width: 830px) {
+    padding-left: 40px;
+    padding-right: 40px;
+  }
+}
+
+.unit-iframe-wrapper {
+  margin: 0 -20px 2rem;
+  @media (min-width: 830px) {
+    margin: 0 -40px 2rem;
+  }
+}
+
+#unit-iframe {
+  width: 100%;
+  border: none;
+  display: block;
+}
+
+.unit-navigation {
+  display: flex;
+  justify-content: center;
+  max-width: 640px;
+  margin: 0 auto;
+  .previous-button,
+  .next-button {
+    white-space: nowrap;
+    border-radius: 4px;
+    &:focus:before {
+      border-radius: 6px;
+    }
+  }
+  .next-button {
+    flex-basis: 75%;
+  }
+  .previous-button {
+    flex-basis: 25%;
+  }
+}

src/learning-sequence/CourseBreadcrumbs.jsx

@@ -1,54 +0,0 @@
-import React, { useContext } from 'react';
-import PropTypes from 'prop-types';
-
-import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
-import { faChevronRight } from '@fortawesome/free-solid-svg-icons';
-import { getConfig } from '@edx/frontend-platform';
-
-import CourseStructureContext from './CourseStructureContext';
-import { useBlockAncestry } from './data/hooks';
-
-const CourseBreadcrumbs = () => {
-  const { courseId, unitId } = useContext(CourseStructureContext);
-
-  const ancestry = useBlockAncestry(unitId);
-
-  const links = ancestry.map(ancestor => ({
-    id: ancestor.id,
-    label: ancestor.displayName,
-    url: `${getConfig().LMS_BASE_URL}/courses/${courseId}/course/#${ancestor.id}`,
-  }));
-
-  return (
-    <nav aria-label="breadcrumb">
-      <ol className="list-inline">
-        {links.map(({ id, url, label }, i) => (
-          <CourseBreadcrumb key={id} url={url} label={label} last={i === links.length - 1} />
-        ))}
-      </ol>
-    </nav>
-  );
-};
-
-export default CourseBreadcrumbs;
-
-function CourseBreadcrumb({ url, label, last }) {
-  return (
-    <React.Fragment key={`${label}-${url}`}>
-      <li className="list-inline-item">
-        {last ? label : (<a href={url}>{label}</a>)}
-      </li>
-      {!last &&
-        <li className="list-inline-item" role="presentation" aria-label="spacer">
-          <FontAwesomeIcon icon={faChevronRight} />
-        </li>
-      }
-    </React.Fragment>
-  );
-}
-
-CourseBreadcrumb.propTypes = {
-  url: PropTypes.string.isRequired,
-  label: PropTypes.string.isRequired,
-  last: PropTypes.bool.isRequired,
-};

src/learning-sequence/CourseStructureContext.jsx

@@ -1,5 +0,0 @@
-import React from 'react';
-
-const CourseStructureContext = React.createContext({});
-
-export default CourseStructureContext;

src/learning-sequence/LearningSequencePage.jsx

@@ -1,58 +0,0 @@
-import React, { useEffect } from 'react';
-import PropTypes from 'prop-types';
-import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
-
-import PageLoading from './PageLoading';
-import messages from './messages';
-import CourseBreadcrumbs from './CourseBreadcrumbs';
-import CourseStructureContext from './CourseStructureContext';
-import { useLoadCourseStructure, useMissingSubSectionRedirect } from './data/hooks';
-import SubSection from './sub-section/SubSection';
-import { history } from '@edx/frontend-platform';
-
-function LearningSequencePage({ match, intl }) {
-  const {
-    courseId,
-    subSectionId,
-    unitId,
-  } = match.params;
-
-  const { blocks, loaded, courseBlockId } = useLoadCourseStructure(courseId);
-
-  useMissingSubSectionRedirect(loaded, blocks, courseId, courseBlockId, subSectionId);
-
-  return (
-    <main className="container-fluid d-flex flex-column flex-grow-1">
-      <CourseStructureContext.Provider value={{
-          courseId,
-          courseBlockId,
-          subSectionId,
-          unitId,
-          blocks,
-          loaded,
-        }}
-      >
-        {!loaded && <PageLoading
-          srMessage={intl.formatMessage(messages['learn.loading.learning.sequence'])}
-        />}
-
-        {loaded && unitId && <CourseBreadcrumbs />}
-        {subSectionId && <SubSection />}
-      </CourseStructureContext.Provider>
-
-    </main>
-  );
-}
-
-export default injectIntl(LearningSequencePage);
-
-LearningSequencePage.propTypes = {
-  match: PropTypes.shape({
-    params: PropTypes.shape({
-      courseId: PropTypes.string.isRequired,
-      subSectionId: PropTypes.string,
-      unitId: PropTypes.string,
-    }).isRequired,
-  }).isRequired,
-  intl: intlShape.isRequired,
-};

src/learning-sequence/data/api.js

@@ -1,15 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
-import { getConfig } from '@edx/frontend-platform';
-
-export async function getCourseBlocks(courseId, username) {
-  const url = new URL(`${getConfig().LMS_BASE_URL}/api/courses/v2/blocks/`);
-  url.searchParams.append('course_id', decodeURIComponent(courseId));
-  url.searchParams.append('username', username);
-  url.searchParams.append('depth', 3);
-  url.searchParams.append('requested_fields', 'children,show_gated_sections');
-
-  const { data } = await getAuthenticatedHttpClient().get(url.href, {});
-
-  return data;
-}

src/learning-sequence/data/hooks.js

@@ -1,136 +0,0 @@
-import { useContext, useMemo, useState, useEffect } from 'react';
-import { history } from '@edx/frontend-platform';
-import { AppContext } from '@edx/frontend-platform/react';
-
-import CourseStructureContext from '../CourseStructureContext';
-import { getCourseBlocks } from './api';
-import { findBlockAncestry, createBlocksMap, createSubSectionIdList, createUnitIdList } from './utils';
-
-export function useBlockAncestry(blockId) {
-  const { blocks, loaded } = useContext(CourseStructureContext);
-  return useMemo(() => {
-    if (!loaded) {
-      return [];
-    }
-    return findBlockAncestry(
-      blocks,
-      blockId,
-    );
-  }, [blocks, blockId, loaded]);
-}
-
-export function useMissingSubSectionRedirect(
-  loaded,
-  blocks,
-  courseId,
-  courseBlockId,
-  subSectionId,
-) {
-  useEffect(() => {
-    if (loaded && !subSectionId) {
-      const course = blocks[courseBlockId];
-      const nextSectionId = course.children[0];
-      const nextSection = blocks[nextSectionId];
-      const nextSubSectionId = nextSection.children[0];
-      const nextSubSection = blocks[nextSubSectionId];
-      const nextUnitId = nextSubSection.children[0];
-      history.push(`/course/${courseId}/${nextSubSectionId}/${nextUnitId}`);
-    }
-  }, [loaded, subSectionId]);
-}
-
-export function useLoadCourseStructure(courseId) {
-  const { authenticatedUser } = useContext(AppContext);
-
-  const [blocks, setBlocks] = useState(null);
-  const [loaded, setLoaded] = useState(false);
-  const [courseBlockId, setCourseBlockId] = useState();
-
-  useEffect(() => {
-    setLoaded(false);
-    getCourseBlocks(courseId, authenticatedUser.username).then((blocksData) => {
-      setBlocks(createBlocksMap(blocksData.blocks));
-      setCourseBlockId(blocksData.root);
-      setLoaded(true);
-    });
-  }, [courseId]);
-
-  return {
-    blocks, loaded, courseBlockId,
-  };
-}
-
-export function useCurrentCourse() {
-  const { loaded, courseBlockId, blocks } = useContext(CourseStructureContext);
-
-  return loaded ? blocks[courseBlockId] : null;
-}
-
-export function useCurrentSubSection() {
-  const { loaded, blocks, subSectionId } = useContext(CourseStructureContext);
-
-  return loaded && subSectionId ? blocks[subSectionId] : null;
-}
-
-export function useCurrentSection() {
-  const { loaded, blocks } = useContext(CourseStructureContext);
-  const subSection = useCurrentSubSection();
-  return loaded ? blocks[subSection.parentId] : null;
-}
-
-export function useCurrentUnit() {
-  const { loaded, blocks, unitId } = useContext(CourseStructureContext);
-
-  return loaded && unitId ? blocks[unitId] : null;
-}
-
-
-export function useUnitIds() {
-  const { loaded, blocks, courseBlockId } = useContext(CourseStructureContext);
-
-  return useMemo(
-    () => (loaded ? createUnitIdList(blocks, courseBlockId) : []),
-    [loaded, blocks, courseBlockId],
-  );
-}
-
-
-export function usePreviousUnit() {
-  const { loaded, blocks, unitId } = useContext(CourseStructureContext);
-  const unitIds = useUnitIds();
-
-  const currentUnitIndex = unitIds.indexOf(unitId);
-  if (currentUnitIndex === 0) {
-    return null;
-  }
-  return loaded ? blocks[unitIds[currentUnitIndex - 1]] : null;
-}
-
-export function useNextUnit() {
-  const { loaded, blocks, unitId } = useContext(CourseStructureContext);
-  const unitIds = useUnitIds();
-
-  const currentUnitIndex = unitIds.indexOf(unitId);
-  if (currentUnitIndex === unitIds.length - 1) {
-    return null;
-  }
-  return loaded ? blocks[unitIds[currentUnitIndex + 1]] : null;
-}
-
-export function useCurrentSubSectionUnits() {
-  const { loaded, blocks } = useContext(CourseStructureContext);
-  const subSection = useCurrentSubSection();
-
-  return loaded ? subSection.children.map(id => blocks[id]) : [];
-}
-
-export function useSubSectionIdList() {
-  const { loaded, blocks, courseBlockId } = useContext(CourseStructureContext);
-
-  const subSectionIdList = useMemo(
-    () => (loaded ? createSubSectionIdList(blocks, courseBlockId) : []),
-    [blocks, courseBlockId],
-  );
-
-  return subSectionIdList;
-}

src/learning-sequence/data/utils.js

@@ -1,67 +0,0 @@
-/* eslint-disable no-plusplus */
-import { camelCaseObject } from '@edx/frontend-platform';
-
-export function createBlocksMap(blocksData) {
-  const blocks = {};
-  const blocksList = Object.values(blocksData);
-
-  // First go through the list and flesh out our blocks map, camelCasing the objects as we go.
-  for (let i = 0; i < blocksList.length; i++) {
-    const block = blocksList[i];
-    blocks[block.id] = camelCaseObject(block);
-  }
-
-  // Next go through the blocksList again - now that we've added them all to the blocks map - and
-  // append a parent ID to every child found in every `children` list, using the blocks map to find
-  // them.
-  for (let i = 0; i < blocksList.length; i++) {
-    const block = blocksList[i];
-
-    if (Array.isArray(block.children)) {
-      for (let j = 0; j < block.children.length; j++) {
-        const childId = block.children[j];
-        const child = blocks[childId];
-        child.parentId = block.id;
-      }
-    }
-  }
-
-  return blocks;
-}
-
-export function createSubSectionIdList(blocks, entryPointId, subSections = []) {
-  const block = blocks[entryPointId];
-  if (block.type === 'sequential') {
-    subSections.push(block.id);
-  }
-  if (Array.isArray(block.children)) {
-    for (let i = 0; i < block.children.length; i++) {
-      const childId = block.children[i];
-      createSubSectionIdList(blocks, childId, subSections);
-    }
-  }
-  return subSections;
-}
-
-export function createUnitIdList(blocks, entryPointId, units = []) {
-  const block = blocks[entryPointId];
-  if (block.type === 'vertical') {
-    units.push(block.id);
-  }
-  if (Array.isArray(block.children)) {
-    for (let i = 0; i < block.children.length; i++) {
-      const childId = block.children[i];
-      createUnitIdList(blocks, childId, units);
-    }
-  }
-  return units;
-}
-
-export function findBlockAncestry(blocks, blockId, descendents = []) {
-  const block = blocks[blockId];
-  descendents.unshift(block);
-  if (block.parentId === undefined) {
-    return descendents;
-  }
-  return findBlockAncestry(blocks, block.parentId, descendents);
-}

src/learning-sequence/index.scss

@@ -1,4 +0,0 @@
-iframe {
-  border: 0;
-  width: 100%;
-}

src/learning-sequence/sub-section/SubSection.jsx

@@ -1,65 +0,0 @@
-import React, { useContext, Suspense } from 'react';
-import { injectIntl, intlShape } from '@edx/frontend-platform/i18n';
-
-import SubSectionNavigation from './SubSectionNavigation';
-import CourseStructureContext from '../CourseStructureContext';
-import Unit from './Unit';
-import {
-  useLoadSubSectionMetadata,
-  useExamRedirect,
-  usePersistentUnitPosition,
-  useMissingUnitRedirect,
-} from './data/hooks';
-import SubSectionMetadataContext from './SubSectionMetadataContext';
-import PageLoading from '../PageLoading';
-import messages from './messages';
-import { useCurrentUnit } from '../data/hooks';
-
-const ContentLock = React.lazy(() => import('./content-lock'));
-
-function SubSection({ intl }) {
-  const {
-    courseId,
-    subSectionId,
-    unitId,
-    blocks,
-  } = useContext(CourseStructureContext);
-  const { metadata, loaded } = useLoadSubSectionMetadata(courseId, subSectionId);
-  usePersistentUnitPosition(courseId, subSectionId, unitId, metadata);
-
-  useExamRedirect(metadata, blocks);
-
-  useMissingUnitRedirect(metadata, loaded);
-  const unit = useCurrentUnit();
-
-  const ready = blocks !== null && metadata !== null && unitId && unit;
-
-  if (!ready) {
-    return null;
-  }
-
-  const isGated = metadata.gatedContent.gated;
-
-  return (
-    <SubSectionMetadataContext.Provider value={metadata}>
-      <section className="d-flex flex-column flex-grow-1">
-        <SubSectionNavigation />
-        {isGated && (
-          <Suspense fallback={<PageLoading
-            srMessage={intl.formatMessage(messages['learn.loading.content.lock'])}
-          />}
-          >
-            <ContentLock />
-          </Suspense>
-        )}
-        {!isGated && <Unit id={unitId} unit={unit} />}
-      </section>
-    </SubSectionMetadataContext.Provider>
-  );
-}
-
-SubSection.propTypes = {
-  intl: intlShape.isRequired,
-};
-
-export default injectIntl(SubSection);

src/learning-sequence/sub-section/SubSectionMetadataContext.jsx

@@ -1,5 +0,0 @@
-import React from 'react';
-
-const SubSectionMetadataContext = React.createContext({});
-
-export default SubSectionMetadataContext;

src/learning-sequence/sub-section/SubSectionNavigation.jsx

@@ -1,144 +0,0 @@
-import React, { useCallback, useContext } from 'react';
-import PropTypes from 'prop-types';
-import { history } from '@edx/frontend-platform';
-import { Button } from '@edx/paragon';
-import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
-import { faFilm, faBook, faPencilAlt, faTasks, faLock } from '@fortawesome/free-solid-svg-icons';
-
-import { usePreviousUnit, useNextUnit, useCurrentSubSectionUnits, useCurrentUnit } from '../data/hooks';
-import CourseStructureContext from '../CourseStructureContext';
-import SubSectionMetadataContext from './SubSectionMetadataContext';
-
-function UnitIcon({ type }) {
-  let icon = null;
-  switch (type) {
-    case 'video':
-      icon = faFilm;
-      break;
-    case 'other':
-      icon = faBook;
-      break;
-    case 'vertical':
-      icon = faTasks;
-      break;
-    case 'problem':
-      icon = faPencilAlt;
-      break;
-    case 'lock':
-      icon = faLock;
-      break;
-    default:
-      icon = faBook;
-  }
-
-  return (
-    <FontAwesomeIcon icon={icon} />
-  );
-}
-
-UnitIcon.propTypes = {
-  type: PropTypes.oneOf(['video', 'other', 'vertical', 'problem', 'lock']).isRequired,
-};
-
-export default function SubSectionNavigation() {
-  const { courseId, unitId } = useContext(CourseStructureContext);
-  const previousUnit = usePreviousUnit();
-  const nextUnit = useNextUnit();
-
-  const handlePreviousClick = useCallback(() => {
-    if (previousUnit) {
-      history.push(`/course/${courseId}/${previousUnit.parentId}/${previousUnit.id}`);
-    }
-  });
-  const handleNextClick = useCallback(() => {
-    if (nextUnit) {
-      history.push(`/course/${courseId}/${nextUnit.parentId}/${nextUnit.id}`);
-    }
-  });
-
-  const handleUnitClick = useCallback((unit) => {
-    history.push(`/course/${courseId}/${unit.parentId}/${unit.id}`);
-  });
-
-  if (!unitId) {
-    return null;
-  }
-
-  return (
-    <nav className="flex-grow-0 d-flex w-100 mb-3">
-      <Button
-        key="previous"
-        className="btn-outline-primary"
-        onClick={handlePreviousClick}
-      >
-        Previous
-      </Button>
-      <UnitNavigation clickHandler={handleUnitClick} />
-      <Button
-        key="next"
-        className="btn-outline-primary"
-        onClick={handleNextClick}
-      >
-        Next
-      </Button>
-    </nav>
-  );
-}
-
-function UnitNavigation({ clickHandler }) {
-  const currentUnit = useCurrentUnit();
-  const units = useCurrentSubSectionUnits();
-  const metadata = useContext(SubSectionMetadataContext);
-
-  const isGated = metadata.gatedContent.gated;
-
-  return (
-    <div className="btn-group ml-2 mr-2 flex-grow-1 d-flex" role="group">
-      {!isGated && units.map(unit => (
-        <UnitButton key={unit.id} unit={unit} disabled={unit.id === currentUnit.id} clickHandler={clickHandler} />
-      ))}
-      {isGated && <UnitButton key={currentUnit.id} unit={currentUnit} disabled locked />}
-    </div>
-  );
-}
-
-UnitNavigation.propTypes = {
-  clickHandler: PropTypes.func.isRequired,
-};
-
-function UnitButton({
-  unit, disabled, locked, clickHandler,
-}) {
-  const { id, type } = unit;
-  const handleClick = useCallback(() => {
-    if (clickHandler !== null) {
-      clickHandler(unit);
-    }
-  }, [unit]);
-
-  return (
-    <Button
-      key={id}
-      className="btn-outline-secondary unit-button flex-grow-1"
-      onClick={handleClick}
-      disabled={disabled}
-    >
-      <UnitIcon type={locked ? 'lock' : type} />
-    </Button>
-  );
-}
-
-UnitButton.propTypes = {
-  unit: PropTypes.shape({
-    id: PropTypes.string.isRequired,
-    type: PropTypes.oneOf(['video', 'other', 'vertical', 'problem']).isRequired,
-  }).isRequired,
-  disabled: PropTypes.bool.isRequired, // Whether or not the button will function.
-  locked: PropTypes.bool, // Whether the unit is semantically "locked" and unnavigable.
-  clickHandler: PropTypes.func,
-};
-
-UnitButton.defaultProps = {
-  clickHandler: null,
-  locked: false,
-};

src/learning-sequence/sub-section/Unit.jsx

@@ -1,24 +0,0 @@
-import React, { useRef } from 'react';
-import PropTypes from 'prop-types';
-import { getConfig } from '@edx/frontend-platform';
-
-export default function Unit({ id, unit }) {
-  const iframeRef = useRef(null);
-  const iframeUrl = `${getConfig().LMS_BASE_URL}/xblock/${id}`;
-  const { displayName } = unit;
-  return (
-    <iframe
-      className="flex-grow-1"
-      title={displayName}
-      ref={iframeRef}
-      src={iframeUrl}
-    />
-  );
-}
-
-Unit.propTypes = {
-  id: PropTypes.string.isRequired,
-  unit: PropTypes.shape({
-    displayName: PropTypes.string.isRequired,
-  }).isRequired,
-};

src/learning-sequence/sub-section/data/api.js

@@ -1,33 +0,0 @@
-import { getConfig } from '@edx/frontend-platform';
-import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
-
-/* eslint-disable import/prefer-default-export */
-
-const getSubSectionXModuleHandlerUrl = (courseId, subSectionId) =>
-  `${getConfig().LMS_BASE_URL}/courses/${courseId}/xblock/${subSectionId}/handler/xmodule_handler`;
-
-export async function getSubSectionMetadata(courseId, subSectionId) {
-  const { data } = await getAuthenticatedHttpClient()
-    .get(`${getSubSectionXModuleHandlerUrl(courseId, subSectionId)}/metadata`, {});
-
-  return data;
-}
-
-export async function saveSubSectionPosition(courseId, subSectionId, position) {
-  // Post data sent to this endpoint must be url encoded
-  // TODO: Remove the need for this to be the case.
-  // TODO: Ensure this usage of URLSearchParams is working in Internet Explorer
-  const urlEncoded = new URLSearchParams();
-  urlEncoded.append('position', position);
-  const requestConfig = {
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-  };
-
-  const { data } = await getAuthenticatedHttpClient().post(
-    `${getSubSectionXModuleHandlerUrl(courseId, subSectionId)}/goto_position`,
-    urlEncoded.toString(),
-    requestConfig,
-  );
-
-  return data;
-}

src/learning-sequence/sub-section/data/hooks.js

@@ -1,75 +0,0 @@
-import { useState, useEffect, useContext } from 'react';
-import { camelCaseObject, history } from '@edx/frontend-platform';
-
-import { getSubSectionMetadata, saveSubSectionPosition } from './api';
-import CourseStructureContext from '../../CourseStructureContext';
-
-export function useLoadSubSectionMetadata(courseId, subSectionId) {
-  const [metadata, setMetadata] = useState(null);
-  const [loaded, setLoaded] = useState(false);
-
-  useEffect(() => {
-    setLoaded(false);
-    setMetadata(null);
-    getSubSectionMetadata(courseId, subSectionId).then((data) => {
-      setMetadata(camelCaseObject(data));
-      setLoaded(true);
-    });
-  }, [courseId, subSectionId]);
-
-  return {
-    metadata,
-    loaded,
-  };
-}
-
-export function useExamRedirect(metadata, blocks) {
-  useEffect(() => {
-    if (metadata !== null && blocks !== null) {
-      if (metadata.isTimeLimited) {
-        global.location.href = blocks[metadata.itemId].lmsWebUrl;
-      }
-    }
-  }, [metadata, blocks]);
-}
-
-/**
- * Save the position of current unit the subsection
- */
-export function usePersistentUnitPosition(courseId, subSectionId, unitId, subSectionMetadata) {
-  useEffect(() => {
-    // All values must be defined to function
-    const hasNeededData = courseId && subSectionId && unitId && subSectionMetadata;
-    if (!hasNeededData) {
-      return;
-    }
-
-    const { items, savePosition } = subSectionMetadata;
-
-    // A sub-section can individually specify whether positions should be saved
-    if (!savePosition) {
-      return;
-    }
-
-    const unitIndex = items.findIndex(({ id }) => unitId === id);
-    // "position" is a 1-indexed value due to legacy compatibility concerns.
-    // TODO: Make this value 0-indexed
-    const newPosition = unitIndex + 1;
-
-    // TODO: update the local understanding of the position and
-    // don't make requests to update the position if they still match?
-    saveSubSectionPosition(courseId, subSectionId, newPosition);
-  }, [courseId, subSectionId, unitId, subSectionMetadata]);
-}
-
-export function useMissingUnitRedirect(metadata, loaded) {
-  const { courseId, subSectionId, unitId } = useContext(CourseStructureContext);
-  useEffect(() => {
-    if (loaded && metadata.itemId === subSectionId && !unitId) {
-      // Position comes from the server as a 1-indexed array index.  Convert it to 0-indexed.
-      const position = metadata.position - 1;
-      const nextUnitId = metadata.items[position].id;
-      history.push(`/course/${courseId}/${subSectionId}/${nextUnitId}`);
-    }
-  }, [loaded, metadata, unitId]);
-}

src/learning-sequence/sub-section/messages.js

@@ -1,11 +0,0 @@
-import { defineMessages } from '@edx/frontend-platform/i18n';
-
-const messages = defineMessages({
-  'learn.loading.content.lock': {
-    id: 'learn.loading.content.lock',
-    defaultMessage: 'Loading locked content messaging...',
-    description: 'Message shown when an interface about locked content is being loaded',
-  },
-});
-
-export default messages;

src/logistration-alert/LogistrationAlert.jsx

@@ -0,0 +1,43 @@
+import React from 'react';
+import { getConfig } from '@edx/frontend-platform';
+import { injectIntl, intlShape, FormattedMessage } from '@edx/frontend-platform/i18n';
+import { getLoginRedirectUrl } from '@edx/frontend-platform/auth';
+
+import Alert from '../user-messages/Alert';
+import messages from './messages';
+
+function LogistrationAlert({ intl }) {
+  const signIn = (
+    <a href={`${getLoginRedirectUrl(global.location.href)}`}>
+      {intl.formatMessage(messages['learning.logistration.login'])}
+    </a>
+  );
+
+  // TODO: Pull this registration URL building out into a function, like the login one above.
+  // This is complicated by the fact that we don't have a REGISTER_URL env variable available.
+  const register = (
+    <a href={`${getConfig().LMS_BASE_URL}/register?next=${encodeURIComponent(global.location.href)}`}>
+      {intl.formatMessage(messages['learning.logistration.register'])}
+    </a>
+  );
+
+  return (
+    <Alert type="error">
+      <FormattedMessage
+        id="learning.logistration.alert"
+        description="Prompts the user to sign in or register to see course content."
+        defaultMessage="Please {signIn} or {register} to see course content."
+        values={{
+          signIn,
+          register,
+        }}
+      />
+    </Alert>
+  );
+}
+
+LogistrationAlert.propTypes = {
+  intl: intlShape.isRequired,
+};
+
+export default injectIntl(LogistrationAlert);

src/logistration-alert/hooks.js

@@ -0,0 +1,28 @@
+/* eslint-disable import/prefer-default-export */
+import { useContext, useState, useEffect } from 'react';
+import { AppContext } from '@edx/frontend-platform/react';
+import UserMessagesContext from '../user-messages/UserMessagesContext';
+
+export function useLogistrationAlert() {
+  const { authenticatedUser } = useContext(AppContext);
+  const { add, remove } = useContext(UserMessagesContext);
+  const [alertId, setAlertId] = useState(null);
+  useEffect(() => {
+    if (authenticatedUser === null && alertId === null) {
+      setAlertId(add({
+        code: 'clientLogistrationAlert',
+        dismissible: false,
+        type: 'error',
+        topic: 'course',
+      }));
+    } else if (authenticatedUser !== null && alertId !== null) {
+      remove(alertId);
+      setAlertId(null);
+    }
+    return () => {
+      if (alertId !== null) {
+        remove(alertId);
+      }
+    };
+  }, [authenticatedUser]);
+}

src/logistration-alert/index.js

@@ -0,0 +1,2 @@
+export { default } from './LogistrationAlert';
+export { useLogistrationAlert } from './hooks';

src/logistration-alert/messages.js

@@ -0,0 +1,16 @@
+import { defineMessages } from '@edx/frontend-platform/i18n';
+
+const messages = defineMessages({
+  'learning.logistration.login': {
+    id: 'learning.logistration.login',
+    defaultMessage: 'sign in',
+    description: 'Text in a link, prompting the user to log in.  Used in "learning.logistration.alert"',
+  },
+  'learning.logistration.register': {
+    id: 'learning.logistration.register',
+    defaultMessage: 'register',
+    description: 'Text in a link, prompting the user to create an account.  Used in "learning.logistration.alert"',
+  },
+});
+
+export default messages;

src/model-store/hooks.js

@@ -0,0 +1,17 @@
+import { useSelector, shallowEqual } from 'react-redux';
+
+export function useModel(type, id) {
+  return useSelector(
+    state => (state.models[type] !== undefined ? state.models[type][id] : undefined),
+    shallowEqual,
+  );
+}
+
+export function useModels(type, ids) {
+  return useSelector(
+    state => ids.map(
+      id => (state.models[type] !== undefined ? state.models[type][id] : undefined),
+    ),
+    shallowEqual,
+  );
+}

src/model-store/index.js

@@ -0,0 +1,16 @@
+export {
+  reducer,
+  addModel,
+  addModels,
+  addModelsMap,
+  updateModel,
+  updateModels,
+  updateModelsMap,
+  removeModel,
+  removeModels,
+} from './slice';
+
+export {
+  useModel,
+  useModels,
+} from './hooks';

src/model-store/slice.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-param-reassign */
+import { createSlice } from '@reduxjs/toolkit';
+
+function add(state, modelType, model) {
+  const { id } = model;
+  if (state[modelType] === undefined) {
+    state[modelType] = {};
+  }
+  state[modelType][id] = model;
+}
+
+function update(state, modelType, model) {
+  if (state[modelType] === undefined) {
+    state[modelType] = {};
+  }
+  state[modelType][model.id] = { ...state[modelType][model.id], ...model };
+}
+
+function remove(state, modelType, id) {
+  if (state[modelType] === undefined) {
+    state[modelType] = {};
+  }
+
+  delete state[modelType][id];
+}
+
+const slice = createSlice({
+  name: 'models',
+  initialState: {},
+  reducers: {
+    addModel: (state, { payload }) => {
+      const { modelType, model } = payload;
+      add(state, modelType, model);
+    },
+    addModels: (state, { payload }) => {
+      const { modelType, models } = payload;
+      models.forEach(model => add(state, modelType, model));
+    },
+    addModelsMap: (state, { payload }) => {
+      const { modelType, modelsMap } = payload;
+      Object.values(modelsMap).forEach(model => add(state, modelType, model));
+    },
+    updateModel: (state, { payload }) => {
+      const { modelType, model } = payload;
+      update(state, modelType, model);
+    },
+    updateModels: (state, { payload }) => {
+      const { modelType, models } = payload;
+      models.forEach(model => update(state, modelType, model));
+    },
+    updateModelsMap: (state, { payload }) => {
+      const { modelType, modelsMap } = payload;
+      Object.values(modelsMap).forEach(model => update(state, modelType, model));
+    },
+    removeModel: (state, { payload }) => {
+      const { modelType, id } = payload;
+      remove(state, modelType, id);
+    },
+    removeModels: (state, { payload }) => {
+      const { modelType, ids } = payload;
+      ids.forEach(id => remove(state, modelType, id));
+    },
+  },
+});
+
+export const {
+  addModel,
+  addModels,
+  addModelsMap,
+  updateModel,
+  updateModels,
+  updateModelsMap,
+  removeModel,
+  removeModels,
+} = slice.actions;
+
+export const { reducer } = slice;

src/store.js

@@ -0,0 +1,12 @@
+import { configureStore } from '@reduxjs/toolkit';
+import { reducer as coursewareReducer } from './data';
+import { reducer as modelsReducer } from './model-store';
+
+const store = configureStore({
+  reducer: {
+    models: modelsReducer,
+    courseware: coursewareReducer,
+  },
+});
+
+export default store;

src/tabs/Tabs.jsx

@@ -0,0 +1,72 @@
+import React, { useMemo } from 'react';
+import PropTypes from 'prop-types';
+import { Dropdown } from '@edx/paragon';
+import { FormattedMessage } from '@edx/frontend-platform/i18n';
+import classNames from 'classnames';
+import useIndexOfLastVisibleChild from './useIndexOfLastVisibleChild';
+
+export default function Tabs({ children, className, ...attrs }) {
+  const [
+    indexOfLastVisibleChild,
+    containerElementRef,
+    invisibleStyle,
+    overflowElementRef,
+  ] = useIndexOfLastVisibleChild();
+
+  const tabChildren = useMemo(() => {
+    const childrenArray = React.Children.toArray(children);
+    const indexOfOverflowStart = indexOfLastVisibleChild + 1;
+
+    // All tabs will be rendered. Those that would overflow are set to invisible.
+    const wrappedChildren = childrenArray.map((child, index) => React.cloneElement(child, {
+      style: index > indexOfLastVisibleChild ? invisibleStyle : null,
+    }));
+
+    // Build the list of items to put in the overflow menu
+    const overflowChildren = childrenArray.slice(indexOfOverflowStart)
+      .map(overflowChild => React.cloneElement(overflowChild, { className: 'dropdown-item' }));
+
+    // Insert the overflow menu at the cut off index (even if it will be hidden
+    // it so it can be part of measurements)
+    wrappedChildren.splice(indexOfOverflowStart, 0, (
+      <div
+        className="nav-item flex-shrink-0"
+        style={indexOfOverflowStart >= React.Children.count(children) ? invisibleStyle : null}
+        ref={overflowElementRef}
+        key="overflow"
+      >
+        <Dropdown>
+          <Dropdown.Button className="nav-link font-weight-normal">
+            <FormattedMessage
+              id="learn.course.tabs.navigation.overflow.menu"
+              description="The title of the overflow menu for course tabs"
+              defaultMessage="More..."
+            />
+          </Dropdown.Button>
+          <Dropdown.Menu className="dropdown-menu-right">{overflowChildren}</Dropdown.Menu>
+        </Dropdown>
+      </div>
+    ));
+    return wrappedChildren;
+  }, [children, indexOfLastVisibleChild]);
+
+  return (
+    <nav
+      {...attrs}
+      className={classNames('nav flex-nowrap', className)}
+      ref={containerElementRef}
+    >
+      {tabChildren}
+    </nav>
+  );
+}
+
+Tabs.propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+};
+
+Tabs.defaultProps = {
+  children: null,
+  className: undefined,
+};

src/tabs/useIndexOfLastVisibleChild.js

@@ -0,0 +1,77 @@
+import { useLayoutEffect, useRef, useState } from 'react';
+import useWindowSize from './useWindowSize';
+
+const invisibleStyle = {
+  position: 'absolute',
+  left: 0,
+  pointerEvents: 'none',
+  visibility: 'hidden',
+};
+
+/**
+ * This hook will find the index of the last child of a containing element
+ * that fits within its bounding rectangle. This is done by summing the widths
+ * of the children until they exceed the width of the container.
+ *
+ * The hook returns an array containing:
+ * [indexOfLastVisibleChild, containerElementRef, invisibleStyle, overflowElementRef]
+ *
+ * indexOfLastVisibleChild - the index of the last visible child
+ * containerElementRef - a ref to be added to the containing html node
+ * invisibleStyle - a set of styles to be applied to child of the containing node
+ *    if it needs to be hidden. These styles remove the element visually, from
+ *    screen readers, and from normal layout flow. But, importantly, these styles
+ *    preserve the width of the element, so that future width calculations will
+ *    still be accurate.
+ * overflowElementRef - a ref to be added to an html node inside the container
+ *    that is likely to be used to contain a "More" type dropdown or other
+ *    mechanism to reveal hidden children. The width of this element is always
+ *    included when determining which children will fit or not. Usage of this ref
+ *    is optional.
+ */
+export default function useIndexOfLastVisibleChild() {
+  const containerElementRef = useRef(null);
+  const overflowElementRef = useRef(null);
+  const containingRectRef = useRef({});
+  const [indexOfLastVisibleChild, setIndexOfLastVisibleChild] = useState(-1);
+  const windowSize = useWindowSize();
+
+  useLayoutEffect(() => {
+    const containingRect = containerElementRef.current.getBoundingClientRect();
+
+    // No-op if the width is unchanged.
+    // (Assumes tabs themselves don't change count or width).
+    if (!containingRect.width === containingRectRef.current.width) {
+      return;
+    }
+    // Update for future comparison
+    containingRectRef.current = containingRect;
+
+    // Get array of child nodes from NodeList form
+    const childNodesArr = Array.prototype.slice.call(containerElementRef.current.children);
+    const { nextIndexOfLastVisibleChild } = childNodesArr
+      // filter out the overflow element
+      .filter(childNode => childNode !== overflowElementRef.current)
+      // sum the widths to find the last visible element's index
+      .reduce((acc, childNode, index) => {
+        // use floor to prevent rounding errors
+        acc.sumWidth += Math.floor(childNode.getBoundingClientRect().width);
+        if (acc.sumWidth <= containingRect.width) {
+          acc.nextIndexOfLastVisibleChild = index;
+        }
+        return acc;
+      }, {
+        // Include the overflow element's width to begin with. Doing this means
+        // sometimes we'll show a dropdown with one item in it when it would fit,
+        // but allowing this case dramatically simplifies the calculations we need
+        // to do above.
+        sumWidth: overflowElementRef.current ? overflowElementRef.current.getBoundingClientRect().width : 0,
+        nextIndexOfLastVisibleChild: -1,
+      });
+
+
+    setIndexOfLastVisibleChild(nextIndexOfLastVisibleChild);
+  }, [windowSize, containerElementRef.current]);
+
+  return [indexOfLastVisibleChild, containerElementRef, invisibleStyle, overflowElementRef];
+}

src/tabs/useWindowSize.js

@@ -0,0 +1,26 @@
+import { useState, useEffect } from 'react';
+
+export default function useWindowSize() {
+  const isClient = typeof global === 'object';
+
+  const getSize = () => ({
+    width: isClient ? global.innerWidth : undefined,
+    height: isClient ? global.innerHeight : undefined,
+  });
+
+  const [windowSize, setWindowSize] = useState(getSize);
+
+  useEffect(() => {
+    if (!isClient) {
+      return false;
+    }
+
+    const handleResize = () => {
+      setWindowSize(getSize());
+    };
+    global.addEventListener('resize', handleResize);
+    return () => global.removeEventListener('resize', handleResize);
+  }, []);
+
+  return windowSize;
+}