Add github_code/freeCodeCamp__freeCodeCamp from GitHub (part 4)

.gitattributes

@@ -59,3 +59,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 code_syntax_dataset_1GB.csv filter=lfs diff=lfs merge=lfs -text
+github_code/freeCodeCamp__freeCodeCamp/client/static/fonts/noto-sans-japanese/NotoSansJP-Black.woff filter=lfs diff=lfs merge=lfs -text
+github_code/freeCodeCamp__freeCodeCamp/client/static/fonts/noto-sans-japanese/NotoSansJP-Bold.woff filter=lfs diff=lfs merge=lfs -text
+github_code/freeCodeCamp__freeCodeCamp/client/static/fonts/noto-sans-japanese/NotoSansJP-Light.woff filter=lfs diff=lfs merge=lfs -text
+github_code/freeCodeCamp__freeCodeCamp/client/static/fonts/noto-sans-japanese/NotoSansJP-Regular.woff filter=lfs diff=lfs merge=lfs -text

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/mobile-layout.test.tsx

@@ -0,0 +1,145 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { MobileLayout } from './mobile-layout';
+
+vi.mock('i18next', () => ({
+  default: {
+    t: (key: string) => key
+  }
+}));
+
+vi.mock('../components/independent-lower-jaw', () => ({
+  default: () => <div data-testid='independent-lower-jaw' />
+}));
+
+const mockProps = {
+  editor: <div>Editor</div>,
+  hasEditableBoundaries: false,
+  hasPreview: false,
+  instructions: <div>Instructions</div>,
+  notes: '',
+  preview: <div>Preview</div>,
+  onPreviewResize: vi.fn(),
+  windowTitle: 'Test Title',
+  showPreviewPortal: false,
+  showPreviewPane: false,
+  removePortalWindow: vi.fn(),
+  setShowPreviewPortal: vi.fn(),
+  setShowPreviewPane: vi.fn(),
+  portalWindow: null,
+  updateUsingKeyboardInTablist: vi.fn(),
+  testOutput: <div>Test Output</div>,
+  usesMultifileEditor: false,
+  usesTerminal: false
+};
+
+const renderMobileLayout = (
+  props: Partial<React.ComponentProps<typeof MobileLayout>> = {}
+) => render(<MobileLayout {...mockProps} {...props} />);
+
+describe('<MobileLayout />', () => {
+  it('renders instructions, code, console, preview, portal controls, and the lower jaw when preview is available', () => {
+    renderMobileLayout({
+      hasPreview: true,
+      showPreviewPane: true
+    });
+
+    expect(screen.getByRole('tablist')).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.instructions' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.code' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.console' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.preview' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'aria.move-preview-to-new-window' })
+    ).toBeInTheDocument();
+    expect(screen.getByTestId('independent-lower-jaw')).toBeInTheDocument();
+  });
+
+  it('renders instructions, code, console, and the lower jaw when preview is unavailable', () => {
+    renderMobileLayout({
+      hasPreview: false
+    });
+
+    expect(screen.getByRole('tablist')).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.instructions' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.code' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.console' })
+    ).toBeInTheDocument();
+    expect(
+      screen.queryByRole('tab', { name: 'learn.editor-tabs.preview' })
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', { name: 'aria.move-preview-to-new-window' })
+    ).not.toBeInTheDocument();
+    expect(screen.getByTestId('independent-lower-jaw')).toBeInTheDocument();
+  });
+
+  it('renders the lower jaw for challenges with editable boundaries', () => {
+    renderMobileLayout({ hasEditableBoundaries: true });
+
+    expect(screen.getByTestId('independent-lower-jaw')).toBeInTheDocument();
+  });
+
+  it('should render language selector when isDailyCodingChallenge is true', () => {
+    renderMobileLayout({
+      isDailyCodingChallenge: true,
+      dailyCodingChallengeLanguage: 'javascript'
+    });
+    expect(screen.getByText('JS')).toBeInTheDocument();
+  });
+
+  it('should not render language selector when isDailyCodingChallenge is false', () => {
+    renderMobileLayout({ isDailyCodingChallenge: false });
+    expect(screen.queryByText('JS')).not.toBeInTheDocument();
+    expect(screen.queryByText('PY')).not.toBeInTheDocument();
+  });
+
+  it('should call setDailyCodingChallengeLanguage when a language is selected', () => {
+    const setDailyCodingChallengeLanguage = vi.fn();
+    renderMobileLayout({
+      isDailyCodingChallenge: true,
+      dailyCodingChallengeLanguage: 'javascript',
+      setDailyCodingChallengeLanguage
+    });
+
+    // Open dropdown
+    fireEvent.click(screen.getByText('JS'));
+
+    // Click Python option
+    fireEvent.click(screen.getByText('Python'));
+
+    expect(setDailyCodingChallengeLanguage).toHaveBeenCalledWith('python');
+  });
+
+  it('renders notes in the notes tab for multifile editor challenges', async () => {
+    const user = userEvent.setup();
+    render(
+      <MobileLayout
+        {...mockProps}
+        notes='<p>This is a test note</p>'
+        usesMultifileEditor={true}
+      />
+    );
+
+    await user.click(
+      screen.getByRole('tab', { name: 'learn.editor-tabs.notes' })
+    );
+
+    expect(screen.getByText('This is a test note')).toBeVisible();
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/mobile-layout.tsx

@@ -0,0 +1,343 @@
+import i18next from 'i18next';
+import React, { Component } from 'react';
+import { faWindowRestore } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { createSelector } from 'reselect';
+import { connect } from 'react-redux';
+import store from 'store';
+import {
+  Tabs,
+  TabsContent,
+  TabsTrigger,
+  TabsList,
+  Dropdown,
+  MenuItem
+} from '@freecodecamp/ui';
+import { DailyCodingChallengeLanguages } from '../../../redux/prop-types';
+
+import {
+  removePortalWindow,
+  setShowPreviewPortal,
+  setShowPreviewPane
+} from '../redux/actions';
+import {
+  portalWindowSelector,
+  showPreviewPortalSelector,
+  showPreviewPaneSelector
+} from '../redux/selectors';
+import { isRtlLanguage } from '../../../utils/is-rtl-language';
+import PreviewPortal from '../components/preview-portal';
+import Notes from '../components/notes';
+import IndependentLowerJaw from '../components/independent-lower-jaw';
+import EditorTabs from './editor-tabs';
+
+interface MobileLayoutProps {
+  editor: JSX.Element | null;
+  hasEditableBoundaries: boolean;
+  hasPreview: boolean;
+  instructions: JSX.Element;
+  isDailyCodingChallenge?: boolean;
+  dailyCodingChallengeLanguage?: DailyCodingChallengeLanguages;
+  setDailyCodingChallengeLanguage?: (
+    language: DailyCodingChallengeLanguages
+  ) => void;
+  notes: string;
+  preview: JSX.Element;
+  onPreviewResize: () => void;
+  windowTitle: string;
+  showPreviewPortal: boolean;
+  showPreviewPane: boolean;
+  removePortalWindow: () => void;
+  setShowPreviewPortal: (arg: boolean) => void;
+  setShowPreviewPane: (arg: boolean) => void;
+  portalWindow: null | Window;
+  updateUsingKeyboardInTablist: (arg0: boolean) => void;
+  testOutput: JSX.Element;
+  usesMultifileEditor: boolean;
+  usesTerminal: boolean;
+}
+
+const tabs = {
+  editor: 'editor',
+  preview: 'preview',
+  console: 'console',
+  notes: 'notes',
+  instructions: 'instructions'
+} as const;
+
+type Tab = keyof typeof tabs;
+
+interface MobileLayoutState {
+  currentTab: Tab;
+}
+
+const mapDispatchToProps = {
+  removePortalWindow,
+  setShowPreviewPortal,
+  setShowPreviewPane
+};
+
+const mapStateToProps = createSelector(
+  showPreviewPortalSelector,
+  showPreviewPaneSelector,
+  portalWindowSelector,
+
+  (
+    showPreviewPortal: boolean,
+    showPreviewPane: boolean,
+    portalWindow: null | Window
+  ) => ({
+    showPreviewPortal,
+    showPreviewPane,
+    portalWindow
+  })
+);
+
+export class MobileLayout extends Component<
+  MobileLayoutProps,
+  MobileLayoutState
+> {
+  static displayName: string;
+
+  state: MobileLayoutState = {
+    currentTab: this.props.hasEditableBoundaries
+      ? tabs.editor
+      : tabs.instructions
+  };
+
+  switchTab = (tab: string): void => {
+    this.setState({
+      currentTab: tab as Tab
+    });
+  };
+
+  handleKeyDown = (): void => this.props.updateUsingKeyboardInTablist(true);
+
+  handleClick = (): void => this.props.updateUsingKeyboardInTablist(false);
+
+  render(): JSX.Element {
+    const { currentTab } = this.state;
+    const {
+      hasEditableBoundaries,
+      instructions,
+      editor,
+      testOutput,
+      hasPreview,
+      notes,
+      preview,
+      onPreviewResize,
+      showPreviewPane,
+      showPreviewPortal,
+      removePortalWindow,
+      setShowPreviewPane,
+      setShowPreviewPortal,
+      portalWindow,
+      windowTitle,
+      usesMultifileEditor,
+      usesTerminal,
+      isDailyCodingChallenge,
+      dailyCodingChallengeLanguage,
+      setDailyCodingChallengeLanguage
+    } = this.props;
+
+    const handleLanguageChange = (
+      language: DailyCodingChallengeLanguages
+    ): void => {
+      store.set('dailyCodingChallengeLanguage', language);
+      if (setDailyCodingChallengeLanguage) {
+        setDailyCodingChallengeLanguage(language);
+      }
+    };
+
+    const displayPreviewPane = hasPreview && showPreviewPane;
+    const displayPreviewPortal = hasPreview && showPreviewPortal;
+
+    const togglePane = (pane: string): void => {
+      if (pane === 'showPreviewPane') {
+        if (!showPreviewPane && showPreviewPortal) {
+          setShowPreviewPortal(false);
+        }
+        setShowPreviewPane(!showPreviewPane);
+        portalWindow?.close();
+        removePortalWindow();
+      } else if (pane === 'showPreviewPortal') {
+        if (!showPreviewPortal && showPreviewPane) {
+          setShowPreviewPane(false);
+        }
+        setShowPreviewPortal(!showPreviewPortal);
+        if (showPreviewPortal) {
+          portalWindow?.close();
+          removePortalWindow();
+        }
+      } else {
+        setShowPreviewPane(true);
+        setShowPreviewPortal(false);
+      }
+    };
+
+    // sets screen reader text for the portal button
+    function getPortalBtnSrText() {
+      // preview open in main window
+      let portalBtnSrText = i18next.t('aria.move-preview-to-new-window');
+
+      // preview open in external window
+      if (showPreviewPortal && !showPreviewPane) {
+        portalBtnSrText = i18next.t('aria.close-external-preview-window');
+      }
+
+      return portalBtnSrText;
+    }
+
+    const previewTriggerText =
+      usesTerminal == false
+        ? 'learn.editor-tabs.preview'
+        : 'learn.editor-tabs.terminal';
+
+    // Unlike the desktop layout the mobile version does not have an ActionRow,
+    // but still needs a way to switch between the different tabs.
+    return (
+      <>
+        <Tabs
+          id='mobile-layout'
+          dir={isRtlLanguage ? 'rtl' : 'ltr'}
+          className={hasEditableBoundaries ? 'has-editable-boundaries' : ''}
+          onKeyDown={this.handleKeyDown}
+          onMouseDown={this.handleClick}
+          onTouchStart={this.handleClick}
+          defaultValue={currentTab}
+          onValueChange={this.switchTab}
+          {...(hasPreview && { 'data-haspreview': 'true' })}
+        >
+          <TabsList className='nav-lists'>
+            {isDailyCodingChallenge && (
+              <Dropdown>
+                <Dropdown.Toggle
+                  className='mobile-lang-selector-toggle'
+                  id='mobile-language-selector'
+                >
+                  {dailyCodingChallengeLanguage === 'javascript'
+                    ? 'JS'
+                    : 'PY'}{' '}
+                </Dropdown.Toggle>
+                <Dropdown.Menu>
+                  <MenuItem onClick={() => handleLanguageChange('javascript')}>
+                    JavaScript
+                  </MenuItem>
+                  <MenuItem onClick={() => handleLanguageChange('python')}>
+                    Python
+                  </MenuItem>
+                </Dropdown.Menu>
+              </Dropdown>
+            )}
+            {!hasEditableBoundaries && (
+              <TabsTrigger value={tabs.instructions}>
+                {i18next.t('learn.editor-tabs.instructions')}
+              </TabsTrigger>
+            )}
+            <TabsTrigger value={tabs.editor}>
+              {i18next.t('learn.editor-tabs.code')}
+            </TabsTrigger>
+            {!!notes && usesMultifileEditor && (
+              <TabsTrigger value={tabs.notes}>
+                {i18next.t('learn.editor-tabs.notes')}
+              </TabsTrigger>
+            )}
+            <TabsTrigger value={tabs.console}>
+              {i18next.t('learn.editor-tabs.console')}
+            </TabsTrigger>
+            {hasPreview && (
+              <TabsTrigger value={tabs.preview}>
+                {i18next.t(previewTriggerText)}
+              </TabsTrigger>
+            )}
+          </TabsList>
+
+          <TabsContent
+            tabIndex={-1}
+            className='tab-content'
+            value={tabs.editor}
+          >
+            {usesMultifileEditor && <EditorTabs />}
+            {editor}
+          </TabsContent>
+          {!hasEditableBoundaries && (
+            <TabsContent
+              tabIndex={-1}
+              className='tab-content'
+              value={tabs.instructions}
+            >
+              {instructions}
+            </TabsContent>
+          )}
+          <TabsContent
+            tabIndex={-1}
+            className='tab-content'
+            value={tabs.console}
+          >
+            {testOutput}
+          </TabsContent>
+          {!!notes && usesMultifileEditor && (
+            <TabsContent
+              tabIndex={-1}
+              className='tab-content'
+              value={tabs.notes}
+            >
+              <Notes notes={notes} />
+            </TabsContent>
+          )}
+          {hasPreview && (
+            <TabsContent
+              tabIndex={-1}
+              className='tab-content'
+              data-playwright-test-label='preview-pane'
+              value={tabs.preview}
+              forceMount
+              // forceMount causes the preview tabpanel to never be hidden,
+              // so we need to manually add it when preview is not active.
+              {...(this.state.currentTab === 'preview' ? {} : { hidden: true })}
+            >
+              <div className='portal-button-wrap'>
+                <button
+                  className='portal-button'
+                  aria-expanded={!!showPreviewPortal}
+                  onClick={() => togglePane('showPreviewPortal')}
+                >
+                  <span className='sr-only'>{getPortalBtnSrText()}</span>
+                  <FontAwesomeIcon icon={faWindowRestore} />
+                </button>
+              </div>
+              {displayPreviewPane && preview}
+              {showPreviewPortal && (
+                <p className='preview-external-window'>
+                  {i18next.t('learn.preview-external-window')}
+                </p>
+              )}
+            </TabsContent>
+          )}
+          <IndependentLowerJaw />
+          {hasPreview && this.state.currentTab !== 'preview' && (
+            <div className='portal-button-wrap'>
+              <button
+                className='portal-button'
+                aria-expanded={!!showPreviewPortal}
+                onClick={() => togglePane('showPreviewPortal')}
+              >
+                <span className='sr-only'>{getPortalBtnSrText()}</span>
+                <FontAwesomeIcon icon={faWindowRestore} />
+              </button>
+            </div>
+          )}
+        </Tabs>
+        {displayPreviewPortal && (
+          <PreviewPortal onResize={onPreviewResize} windowTitle={windowTitle}>
+            {preview}
+          </PreviewPortal>
+        )}
+      </>
+    );
+  }
+}
+
+MobileLayout.displayName = 'MobileLayout';
+
+export default connect(mapStateToProps, mapDispatchToProps)(MobileLayout);

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/multifile-editor.tsx

@@ -0,0 +1,173 @@
+import React, { useRef } from 'react';
+import { connect } from 'react-redux';
+import { ReflexContainer, ReflexElement, ReflexSplitter } from 'react-reflex';
+import { createSelector } from 'reselect';
+import { isDonationModalOpenSelector } from '../../../redux/selectors';
+import {
+  canFocusEditorSelector,
+  visibleEditorsSelector
+} from '../redux/selectors';
+import { getTargetEditor } from '../utils/get-target-editor';
+import { isRtlLanguage } from '../../../utils/is-rtl-language';
+import './editor.css';
+import Editor, { type EditorProps } from './editor';
+
+export type VisibleEditors = {
+  indexhtml?: boolean;
+  indexjsx?: boolean;
+  stylescss?: boolean;
+  scriptjs?: boolean;
+  indexts?: boolean;
+  indextsx?: boolean;
+  mainpy?: boolean;
+  tsconfigjson?: boolean;
+};
+type MultifileEditorProps = Pick<
+  EditorProps,
+  | 'usesMultifileEditor'
+  | 'showProjectPreview'
+  | 'title'
+  | 'resizeProps'
+  | 'isUsingKeyboardInTablist'
+  | 'isMobileLayout'
+  | 'initialTests'
+  | 'editorRef'
+  | 'containerRef'
+  | 'block'
+  | 'superBlock'
+  | 'challengeFiles'
+  | 'description'
+  // We use dimensions to trigger a re-render of the editor
+  | 'dimensions'
+> & {
+  visibleEditors: VisibleEditors;
+};
+
+const mapStateToProps = createSelector(
+  visibleEditorsSelector,
+  canFocusEditorSelector,
+  isDonationModalOpenSelector,
+  (visibleEditors: VisibleEditors, canFocus: boolean, open) => ({
+    visibleEditors,
+    canFocus: open ? false : canFocus
+  })
+);
+
+const MultifileEditor = (props: MultifileEditorProps) => {
+  const {
+    block,
+    superBlock,
+    challengeFiles,
+    containerRef,
+    description,
+    editorRef,
+    initialTests,
+    isMobileLayout,
+    isUsingKeyboardInTablist,
+    resizeProps,
+    title,
+    visibleEditors: {
+      stylescss,
+      indexhtml,
+      scriptjs,
+      indexts,
+      indexjsx,
+      indextsx,
+      mainpy,
+      tsconfigjson
+    },
+    usesMultifileEditor,
+    showProjectPreview
+  } = props;
+  // TODO: the tabs mess up the rendering (scroll doesn't work properly and
+  // the in-editor description)
+
+  const reflexProps = {
+    propagateDimensions: true
+  };
+
+  const targetEditor = getTargetEditor(challengeFiles);
+
+  // Only one editor should be focused and that should happen once, after it has
+  // been mounted. This ref allows the editors to coordinate, without having to
+  // resort to redux.
+  const canFocusOnMountRef = useRef(true);
+
+  const editorKeys = [];
+
+  // The order of the keys should match the order set by sortChallengeFiles
+  if (indexjsx) editorKeys.push('indexjsx');
+  if (indextsx) editorKeys.push('indextsx');
+  if (indexhtml) editorKeys.push('indexhtml');
+  if (stylescss) editorKeys.push('stylescss');
+  if (scriptjs) editorKeys.push('scriptjs');
+  if (mainpy) editorKeys.push('mainpy');
+  if (indexts) editorKeys.push('indexts');
+  if (tsconfigjson) editorKeys.push('tsconfigjson');
+
+  const editorAndSplitterKeys = editorKeys.reduce((acc: string[] | [], key) => {
+    if (acc.length === 0) {
+      return [key];
+    } else {
+      return [...acc, `${key}-splitter`, key];
+    }
+  }, []);
+
+  if (isRtlLanguage) {
+    editorAndSplitterKeys.reverse();
+  }
+
+  return (
+    <ReflexContainer
+      orientation='horizontal'
+      {...reflexProps}
+      {...resizeProps}
+      className='editor-container'
+    >
+      <ReflexElement flex={10} {...reflexProps} {...resizeProps}>
+        <ReflexContainer orientation='vertical'>
+          {editorAndSplitterKeys.map(key => {
+            const isSplitter = key.endsWith('-splitter');
+            if (isSplitter) {
+              return (
+                <ReflexSplitter propagate={true} {...resizeProps} key={key} />
+              );
+            } else {
+              return (
+                <ReflexElement
+                  data-playwright-test-label={`editor-container-${key}`}
+                  {...reflexProps}
+                  {...resizeProps}
+                  key={key}
+                >
+                  <Editor
+                    canFocusOnMountRef={canFocusOnMountRef}
+                    block={block}
+                    superBlock={superBlock}
+                    challengeFiles={challengeFiles}
+                    containerRef={containerRef}
+                    description={targetEditor === key ? description : ''}
+                    editorRef={editorRef}
+                    fileKey={key}
+                    initialTests={initialTests}
+                    isMobileLayout={isMobileLayout}
+                    isUsingKeyboardInTablist={isUsingKeyboardInTablist}
+                    resizeProps={resizeProps}
+                    dimensions={props.dimensions ?? { height: 0, width: 0 }}
+                    title={title}
+                    usesMultifileEditor={usesMultifileEditor}
+                    showProjectPreview={showProjectPreview}
+                  />
+                </ReflexElement>
+              );
+            }
+          })}
+        </ReflexContainer>
+      </ReflexElement>
+    </ReflexContainer>
+  );
+};
+
+MultifileEditor.displayName = 'MultifileEditor';
+
+export default connect(mapStateToProps)(MultifileEditor);

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/react-types-license

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

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/saved-challenges.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+import type {
+  ChallengeFile,
+  SavedChallengeFile
+} from '../../../redux/prop-types';
+import { mergeChallengeFiles } from './saved-challenges';
+
+const jsChallenge = {
+  contents: 'js contents',
+  fileKey: 'jsFileKey',
+  name: 'name',
+  ext: 'js' as const,
+  history: [],
+  seed: 'original js contents',
+  path: 'index.js'
+};
+
+const cssChallenge = {
+  contents: 'css contents',
+  fileKey: 'cssFileKey',
+  name: 'name',
+  ext: 'css' as const,
+  history: [],
+  seed: 'original css contents',
+  path: 'styles.css'
+};
+
+const htmlChallenge = {
+  contents: 'html contents',
+  fileKey: 'htmlFileKey',
+  name: 'name',
+  ext: 'html' as const,
+  history: [],
+  seed: 'original html contents',
+  path: 'index.html'
+};
+
+const savedJsChallenge: SavedChallengeFile = {
+  contents: 'saved js contents',
+  fileKey: 'jsFileKey',
+  name: 'name',
+  ext: 'js' as const
+};
+
+const savedCssChallenge: SavedChallengeFile = {
+  contents: 'saved css contents',
+  fileKey: 'cssFileKey',
+  name: 'name',
+  ext: 'css' as const
+};
+
+const savedHtmlChallenge: SavedChallengeFile = {
+  contents: 'saved html contents',
+  fileKey: 'htmlFileKey',
+  name: 'name',
+  ext: 'html' as const
+};
+
+describe('mergeChallengeFiles', () => {
+  it('should return files if savedChallengeFiles is undefined', () => {
+    const files: ChallengeFile[] = [htmlChallenge];
+    const savedChallengeFiles = undefined;
+
+    const result = mergeChallengeFiles(files, savedChallengeFiles);
+
+    expect(result).toEqual(files);
+  });
+
+  it('should return an empty array if files is undefined', () => {
+    const files = undefined;
+    const savedChallengeFiles = [savedJsChallenge];
+
+    const result = mergeChallengeFiles(files, savedChallengeFiles);
+
+    expect(result).toEqual([]);
+  });
+
+  it('should return files if savedChallengeFiles has a different length', () => {
+    const files: ChallengeFile[] = [cssChallenge];
+    const savedChallengeFiles: SavedChallengeFile[] = [
+      savedCssChallenge,
+      savedJsChallenge
+    ];
+
+    const result = mergeChallengeFiles(files, savedChallengeFiles);
+
+    expect(result).toEqual(files);
+  });
+
+  it('should return files if the fileKey properties do not match', () => {
+    const files: ChallengeFile[] = [jsChallenge, cssChallenge];
+    const savedChallengeFiles: SavedChallengeFile[] = [
+      savedHtmlChallenge,
+      savedCssChallenge
+    ];
+
+    const result = mergeChallengeFiles(files, savedChallengeFiles);
+
+    expect(result).toEqual(files);
+  });
+
+  it('should use the contents from the saved file', () => {
+    const files: ChallengeFile[] = [cssChallenge, htmlChallenge, jsChallenge];
+    const savedChallengeFiles = [
+      savedJsChallenge,
+      savedCssChallenge,
+      savedHtmlChallenge
+    ];
+
+    const result = mergeChallengeFiles(files, savedChallengeFiles);
+
+    expect(result).toEqual([
+      {
+        ...cssChallenge,
+        contents: savedCssChallenge.contents
+      },
+      {
+        ...htmlChallenge,
+        contents: savedHtmlChallenge.contents
+      },
+      {
+        ...jsChallenge,
+        contents: savedJsChallenge.contents
+      }
+    ]);
+  });
+
+  it('should not mutate the original files and savedChallengeFiles arrays', () => {
+    const files: ChallengeFile[] = [jsChallenge, cssChallenge];
+    const savedChallengeFiles: SavedChallengeFile[] = [
+      savedJsChallenge,
+      savedCssChallenge
+    ];
+
+    const filesCopy = JSON.parse(JSON.stringify(files));
+    const savedFilesCopy = JSON.parse(JSON.stringify(savedChallengeFiles));
+
+    mergeChallengeFiles(files, savedChallengeFiles);
+
+    expect(files).toEqual(filesCopy);
+    expect(savedChallengeFiles).toEqual(savedFilesCopy);
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/saved-challenges.ts

@@ -0,0 +1,30 @@
+import { ChallengeFile, SavedChallengeFile } from '../../../redux/prop-types';
+
+export function mergeChallengeFiles(
+  files?: ChallengeFile[] | null,
+  savedFiles?: SavedChallengeFile[] | null
+): ChallengeFile[] {
+  if (!files) return [];
+  if (!savedFiles) return files;
+  if (files.length !== savedFiles.length) return files;
+
+  const sortedChallengeFiles = files.toSorted((a, b) =>
+    a.fileKey.localeCompare(b.fileKey)
+  );
+  const sortedSavedChallengeFiles = savedFiles.toSorted((a, b) =>
+    a.fileKey.localeCompare(b.fileKey)
+  );
+
+  const fileKeysMatch = sortedChallengeFiles.every(
+    (file, index) => file.fileKey === sortedSavedChallengeFiles[index].fileKey
+  );
+
+  if (!fileKeysMatch) return files;
+
+  return sortedChallengeFiles.map((file, index) => ({
+    ...file,
+    contents: sortedSavedChallengeFiles[index].contents,
+    editableRegionBoundaries:
+      sortedSavedChallengeFiles[index].editableRegionBoundaries
+  }));
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/show.tsx

@@ -0,0 +1,593 @@
+import { graphql } from 'gatsby';
+import React, { useState, useEffect, useRef } from 'react';
+import Helmet from 'react-helmet';
+import { useTranslation } from 'react-i18next';
+import { connect } from 'react-redux';
+import { HandlerProps } from 'react-reflex';
+import { useMediaQuery } from 'react-responsive';
+import { bindActionCreators, Dispatch } from 'redux';
+import store from 'store';
+import { editor } from 'monaco-editor';
+import type { FitAddon } from '@xterm/addon-fit';
+
+import { useFeature } from '@growthbook/growthbook-react';
+import { challengeTypes } from '@freecodecamp/shared/config/challenge-types';
+import LearnLayout from '../../../components/layouts/learn';
+import { MAX_MOBILE_WIDTH } from '../../../../config/misc';
+
+import type {
+  ChallengeFiles,
+  ChallengeMeta,
+  ChallengeNode,
+  Hooks,
+  DailyCodingChallengeLanguages,
+  DailyCodingChallengeNode,
+  DailyCodingChallengePageContext,
+  PageContext,
+  ResizeProps,
+  SavedChallenge,
+  SavedChallengeFiles,
+  Test
+} from '../../../redux/prop-types';
+import { isContained } from '../../../utils/is-contained';
+import ChallengeDescription from '../components/challenge-description';
+import Hotkeys from '../components/hotkeys';
+import ResetModal from '../components/reset-modal';
+import ChallengeTitle from '../components/challenge-title';
+import CompletionModal from '../components/completion-modal';
+import HelpModal from '../components/help-modal';
+import ShortcutsModal from '../components/shortcuts-modal';
+import MobileAppModal from '../components/mobile-app-modal';
+import Output from '../components/output';
+import Preview, { type PreviewProps } from '../components/preview';
+import ProjectPreviewModal from '../components/project-preview-modal';
+import SidePanel from '../components/side-panel';
+import VideoModal from '../components/video-modal';
+import {
+  cancelTests,
+  challengeMounted,
+  createFiles,
+  executeChallenge,
+  initConsole,
+  initTests,
+  initHooks,
+  initVisibleEditors,
+  previewMounted,
+  updateChallengeMeta,
+  openModal,
+  setEditorFocusability,
+  setIsAdvancing
+} from '../redux/actions';
+import {
+  challengeFilesSelector,
+  consoleOutputSelector,
+  isChallengeCompletedSelector
+} from '../redux/selectors';
+import { savedChallengesSelector } from '../../../redux/selectors';
+import { getGuideUrl } from '../utils';
+import { preloadPage } from '../../../../utils/gatsby/page-loading';
+import envData from '../../../../config/env.json';
+import { getChallengePaths } from '../utils/challenge-paths';
+import { challengeHasPreview, isJavaScriptChallenge } from '../utils/build';
+import { XtermTerminal } from './xterm';
+import MultifileEditor from './multifile-editor';
+import DesktopLayout from './desktop-layout';
+import MobileLayout from './mobile-layout';
+import { mergeChallengeFiles } from './saved-challenges';
+
+import './classic.css';
+import '../components/test-frame.css';
+
+const mapStateToProps = (state: unknown) => ({
+  challengeFiles: challengeFilesSelector(state) as ChallengeFiles,
+  output: consoleOutputSelector(state) as string,
+  isChallengeCompleted: isChallengeCompletedSelector(state),
+  savedChallenges: savedChallengesSelector(state) as SavedChallenge[]
+});
+
+const mapDispatchToProps = (dispatch: Dispatch) =>
+  bindActionCreators(
+    {
+      createFiles,
+      initConsole,
+      initTests,
+      initHooks,
+      initVisibleEditors,
+      updateChallengeMeta,
+      challengeMounted,
+      executeChallenge,
+      cancelTests,
+      previewMounted,
+      openModal,
+      setEditorFocusability,
+      setIsAdvancing
+    },
+    dispatch
+  );
+
+interface ShowClassicProps extends Pick<PreviewProps, 'previewMounted'> {
+  cancelTests: () => void;
+  challengeMounted: (arg0: string) => void;
+  createFiles: (arg0: ChallengeFiles | SavedChallengeFiles) => void;
+  dailyCodingChallengeLanguage: DailyCodingChallengeLanguages;
+  data: { challengeNode: ChallengeNode | DailyCodingChallengeNode };
+  executeChallenge: (options?: { showCompletionModal: boolean }) => void;
+  challengeFiles: ChallengeFiles;
+  initConsole: (arg0: string) => void;
+  initTests: (tests: Test[]) => void;
+  initHooks: (hooks?: Hooks) => void;
+  initVisibleEditors: () => void;
+  isChallengeCompleted: boolean;
+  isDailyCodingChallenge?: boolean;
+  output: string;
+  pageContext: PageContext | DailyCodingChallengePageContext;
+  updateChallengeMeta: (arg0: ChallengeMeta) => void;
+  openModal: (modal: string) => void;
+  setDailyCodingChallengeLanguage: (
+    language: DailyCodingChallengeLanguages
+  ) => void;
+  setEditorFocusability: (canFocus: boolean) => void;
+  setIsAdvancing: (arg: boolean) => void;
+  savedChallenges: SavedChallenge[];
+}
+
+interface ReflexLayout {
+  codePane: { flex: number };
+  editorPane: { flex: number };
+  instructionPane: { flex: number };
+  notesPane: { flex: number };
+  previewPane: { flex: number };
+  testsPane: { flex: number };
+}
+
+interface RenderEditorArgs {
+  isMobileLayout: boolean;
+  isUsingKeyboardInTablist: boolean;
+}
+
+const REFLEX_LAYOUT = 'challenge-layout';
+const BASE_LAYOUT = {
+  codePane: { flex: 1 },
+  editorPane: { flex: 1 },
+  instructionPane: { flex: 1 },
+  previewPane: { flex: 0.7 },
+  notesPane: { flex: 0.7 },
+  testsPane: { flex: 0.3 }
+};
+
+const StepPreview = ({
+  dimensions,
+  disableIframe,
+  previewMounted,
+  challengeType,
+  xtermFitRef
+}: Pick<PreviewProps, 'disableIframe' | 'previewMounted'> & {
+  challengeType: number;
+  xtermFitRef: React.MutableRefObject<FitAddon | null>;
+  dimensions?: { width: number; height: number };
+}) => {
+  return challengeType === challengeTypes.python ||
+    challengeType === challengeTypes.multifilePythonCertProject ||
+    challengeType === challengeTypes.pyLab ||
+    challengeType === challengeTypes.dailyChallengePy ? (
+    <XtermTerminal dimensions={dimensions} xtermFitRef={xtermFitRef} />
+  ) : (
+    <Preview disableIframe={disableIframe} previewMounted={previewMounted} />
+  );
+};
+
+// The newline is important, because this text ends up in a `pre` element.
+const defaultOutput = `
+/**
+* Your test output will go here
+*/`;
+
+function ShowClassic({
+  challengeFiles,
+  data: {
+    challengeNode: {
+      challenge: {
+        challengeFiles: seedChallengeFiles,
+        block,
+        demoType,
+        title,
+        description,
+        instructions,
+        id,
+        hooks,
+        tests,
+        challengeType,
+        hasEditableBoundaries = false,
+        superBlock,
+        helpCategory,
+        forumTopicId,
+        usesMultifileEditor,
+        notes,
+        videoUrl,
+        translationPending,
+        saveSubmissionToDB
+      }
+    }
+  },
+  pageContext: {
+    challengeMeta,
+    challengeMeta: { isFirstStep, nextChallengePath },
+    projectPreview: { challengeData }
+  },
+  createFiles,
+  cancelTests,
+  challengeMounted,
+  initConsole,
+  initTests,
+  initHooks,
+  initVisibleEditors,
+  dailyCodingChallengeLanguage,
+  isDailyCodingChallenge = false,
+  setDailyCodingChallengeLanguage,
+  updateChallengeMeta,
+  openModal,
+  setIsAdvancing,
+  savedChallenges,
+  isChallengeCompleted,
+  output,
+  executeChallenge,
+  previewMounted
+}: ShowClassicProps) {
+  const { t } = useTranslation();
+  const [resizing, setResizing] = useState(false);
+  const [usingKeyboardInTablist, setUsingKeyboardInTablist] = useState(false);
+  const containerRef = useRef<HTMLElement>(null);
+  const editorRef = useRef<editor.IStandaloneCodeEditor>();
+  const instructionsPanelRef = useRef<HTMLDivElement>(null);
+  const xtermFitRef = useRef<FitAddon | null>(null);
+  const isMobile = useMediaQuery({
+    query: `(max-width: ${MAX_MOBILE_WIDTH}px)`
+  });
+
+  const guideUrl = getGuideUrl({ forumTopicId, title, block, superBlock });
+
+  const blockNameTitle = `${t(
+    `intro:${superBlock}.blocks.${block}.title`
+  )}: ${title}`;
+  const windowTitle = `${blockNameTitle} | freeCodeCamp.org`;
+  const openConsole = isJavaScriptChallenge({ challengeType });
+  const hasPreview = challengeHasPreview({ challengeType });
+  const getLayoutState = () => {
+    const reflexLayout = store.get(REFLEX_LAYOUT) as ReflexLayout | null;
+
+    // Check that the layout values stored are valid (exist in base layout). If
+    // not valid, it will fallback to the base layout values and be set on next
+    // user resize.
+    const isValidLayout =
+      reflexLayout &&
+      isContained(Object.keys(BASE_LAYOUT), Object.keys(reflexLayout));
+
+    if (!isValidLayout) store.remove(REFLEX_LAYOUT);
+
+    return isValidLayout ? reflexLayout : BASE_LAYOUT;
+  };
+
+  const onPreviewResize = () => xtermFitRef.current?.fit();
+
+  // layout: Holds the information of the panes sizes for desktop view
+  const [layout, setLayout] = useState(getLayoutState());
+
+  const onStopResize = (event: HandlerProps) => {
+    setResizing(false);
+    // 'name' is used to identify the Elements whose layout is stored.
+    const { name, flex } = event.component.props;
+
+    // onStopResize can be called multiple times before the state changes, so
+    // we need an updater function to ensure all updates are applied.
+    setLayout(l => {
+      const newLayout = name ? { ...l, [name]: { flex } } : l;
+      store.set(REFLEX_LAYOUT, newLayout);
+      return newLayout;
+    });
+  };
+
+  const setHtmlHeight = () => {
+    const vh = String(window.innerHeight - 1);
+    document.documentElement.style.height = vh + 'px';
+  };
+  const onResize = () => {
+    setResizing(true);
+  };
+  const resizeProps: ResizeProps = {
+    onResize,
+    onStopResize
+  };
+
+  const updateUsingKeyboardInTablist = (
+    usingKeyboardInTablist: boolean
+  ): void => {
+    setUsingKeyboardInTablist(usingKeyboardInTablist);
+  };
+
+  // AB testing Pre-fetch in the Spanish locale
+  const isPreFetchEnabled = useFeature('prefetch_ab_test').on;
+
+  const showSidePanelTests = isMobile || !hasEditableBoundaries;
+
+  // Show test
+
+  useEffect(() => {
+    if (
+      isPreFetchEnabled &&
+      (envData as { clientLocale: string }).clientLocale === 'espanol'
+    ) {
+      preloadPage(nextChallengePath);
+    }
+  }, [nextChallengePath, isPreFetchEnabled]);
+
+  useEffect(() => {
+    initializeComponent(title);
+
+    window.addEventListener('resize', setHtmlHeight);
+    setHtmlHeight();
+
+    return () => {
+      createFiles([]);
+      cancelTests();
+      window.removeEventListener('resize', setHtmlHeight);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [dailyCodingChallengeLanguage]);
+
+  const initializeComponent = (title: string): void => {
+    initConsole('');
+
+    const savedChallenge = savedChallenges?.find(challenge => {
+      return challenge.id === challengeMeta.id;
+    });
+
+    createFiles(
+      mergeChallengeFiles(seedChallengeFiles, savedChallenge?.challengeFiles)
+    );
+
+    initTests(tests);
+    initHooks(hooks);
+
+    initVisibleEditors();
+
+    // Typically, this kind of preview only appears on the first step of a
+    // project and is shown (once) automatically. In contrast, labs are more
+    // freeform, so the preview is shown on demand.
+    if (demoType === 'onLoad') openModal('projectPreview');
+    const challengePaths = getChallengePaths({
+      currentCurriculumPaths: challengeMeta
+    });
+
+    updateChallengeMeta({
+      ...challengeMeta,
+      title,
+      challengeType,
+      helpCategory,
+      description,
+      ...challengePaths
+    });
+    challengeMounted(challengeMeta.id);
+    setIsAdvancing(false);
+  };
+
+  const renderInstructionsPanel = ({ hasDemo }: { hasDemo: boolean }) => {
+    return (
+      <SidePanel
+        challengeDescription={
+          <ChallengeDescription
+            description={description}
+            instructions={instructions}
+            superBlock={superBlock}
+            challengeId={id}
+            block={block}
+          />
+        }
+        challengeTitle={
+          <ChallengeTitle
+            isCompleted={isChallengeCompleted}
+            translationPending={translationPending}
+          >
+            {title}
+          </ChallengeTitle>
+        }
+        instructionsPanelRef={instructionsPanelRef}
+        hasDemo={hasDemo}
+        showSidePanelTests={showSidePanelTests}
+      />
+    );
+  };
+
+  const renderEditor = ({
+    isMobileLayout,
+    isUsingKeyboardInTablist
+  }: RenderEditorArgs) => {
+    return (
+      challengeFiles && (
+        <MultifileEditor
+          challengeFiles={challengeFiles}
+          block={block}
+          superBlock={superBlock}
+          containerRef={containerRef}
+          description={description}
+          editorRef={editorRef}
+          initialTests={tests}
+          isMobileLayout={isMobileLayout}
+          isUsingKeyboardInTablist={isUsingKeyboardInTablist}
+          resizeProps={resizeProps}
+          title={title}
+          usesMultifileEditor={usesMultifileEditor}
+          showProjectPreview={demoType === 'onLoad'}
+        />
+      )
+    );
+  };
+
+  const usesTerminal =
+    challengeType === challengeTypes.python ||
+    challengeType === challengeTypes.multifilePythonCertProject ||
+    challengeType === challengeTypes.pyLab ||
+    challengeType === challengeTypes.dailyChallengePy;
+
+  return (
+    <Hotkeys
+      challengeType={challengeType}
+      executeChallenge={executeChallenge}
+      containerRef={containerRef}
+      instructionsPanelRef={instructionsPanelRef}
+      usesMultifileEditor={usesMultifileEditor}
+      editorRef={editorRef}
+    >
+      <LearnLayout>
+        <Helmet title={windowTitle} />
+        {isMobile ? (
+          <MobileLayout
+            editor={renderEditor({
+              isMobileLayout: true,
+              isUsingKeyboardInTablist: usingKeyboardInTablist
+            })}
+            hasEditableBoundaries={hasEditableBoundaries}
+            hasPreview={hasPreview}
+            isDailyCodingChallenge={isDailyCodingChallenge}
+            dailyCodingChallengeLanguage={dailyCodingChallengeLanguage}
+            setDailyCodingChallengeLanguage={setDailyCodingChallengeLanguage}
+            instructions={renderInstructionsPanel({
+              hasDemo: demoType === 'onClick'
+            })}
+            notes={notes}
+            onPreviewResize={onPreviewResize}
+            preview={
+              <StepPreview
+                challengeType={challengeType}
+                disableIframe={resizing}
+                previewMounted={previewMounted}
+                xtermFitRef={xtermFitRef}
+              />
+            }
+            windowTitle={windowTitle}
+            testOutput={
+              <Output defaultOutput={defaultOutput} output={output} />
+            }
+            updateUsingKeyboardInTablist={updateUsingKeyboardInTablist}
+            usesMultifileEditor={usesMultifileEditor}
+            usesTerminal={usesTerminal}
+          />
+        ) : (
+          <DesktopLayout
+            challengeFiles={challengeFiles}
+            challengeType={challengeType}
+            editor={renderEditor({
+              isMobileLayout: false,
+              isUsingKeyboardInTablist: usingKeyboardInTablist
+            })}
+            hasEditableBoundaries={hasEditableBoundaries}
+            hasPreview={hasPreview}
+            instructions={renderInstructionsPanel({
+              hasDemo: demoType === 'onClick'
+            })}
+            isDailyCodingChallenge={isDailyCodingChallenge}
+            dailyCodingChallengeLanguage={dailyCodingChallengeLanguage}
+            setDailyCodingChallengeLanguage={setDailyCodingChallengeLanguage}
+            isFirstStep={isFirstStep}
+            layoutState={layout}
+            notes={notes}
+            onPreviewResize={onPreviewResize}
+            preview={
+              <StepPreview
+                challengeType={challengeType}
+                disableIframe={resizing}
+                previewMounted={previewMounted}
+                xtermFitRef={xtermFitRef}
+              />
+            }
+            resizeProps={resizeProps}
+            testOutput={
+              <Output defaultOutput={defaultOutput} output={output} />
+            }
+            windowTitle={windowTitle}
+            startWithConsoleShown={openConsole}
+          />
+        )}
+        <CompletionModal />
+        <HelpModal
+          challengeTitle={title}
+          challengeBlock={block}
+          superBlock={superBlock}
+          guideUrl={guideUrl}
+          videoUrl={videoUrl}
+        />
+        <VideoModal videoUrl={videoUrl} />
+        <ResetModal
+          saveSubmissionToDB={saveSubmissionToDB}
+          challengeTitle={title}
+        />
+        <ProjectPreviewModal
+          challengeData={challengeData}
+          closeText={t('buttons.start-coding')}
+          previewTitle={
+            demoType === 'onClick'
+              ? t('learn.demo-project-title')
+              : t('learn.project-preview-title')
+          }
+        />
+        <ShortcutsModal />
+        <MobileAppModal superBlock={superBlock} />
+      </LearnLayout>
+    </Hotkeys>
+  );
+}
+
+ShowClassic.displayName = 'ShowClassic';
+
+export default connect(mapStateToProps, mapDispatchToProps)(ShowClassic);
+
+export const query = graphql`
+  query ClassicChallenge($id: String!) {
+    challengeNode(id: { eq: $id }) {
+      challenge {
+        block
+        demoType
+        title
+        description
+        id
+        hasEditableBoundaries
+        instructions
+        notes
+        challengeType
+        helpCategory
+        videoUrl
+        superBlock
+        translationPending
+        forumTopicId
+        hooks {
+          beforeAll
+          beforeEach
+          afterEach
+          afterAll
+        }
+        fields {
+          slug
+        }
+        required {
+          link
+          src
+        }
+        usesMultifileEditor
+        challengeFiles {
+          fileKey
+          ext
+          name
+          contents
+          head
+          tail
+          editableRegionBoundaries
+          history
+        }
+        saveSubmissionToDB
+        tests {
+          text
+          testString
+        }
+      }
+    }
+  }
+`;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/xterm-original.css

@@ -0,0 +1,231 @@
+/**
+ * Copyright (c) 2014 The xterm.js authors. All rights reserved.
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * https://github.com/chjj/term.js
+ * @license MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Originally forked from (with the author's permission):
+ *   Fabrice Bellard's javascript vt100 for jslinux:
+ *   http://bellard.org/jslinux/
+ *   Copyright (c) 2011 Fabrice Bellard
+ *   The original design remains. The terminal itself
+ *   has been extended to include xterm CSI codes, among
+ *   other features.
+ */
+
+/**
+ *  Default styles for xterm.js
+ */
+
+.xterm {
+  cursor: text;
+  position: relative;
+  user-select: none;
+  -ms-user-select: none;
+  -webkit-user-select: none;
+}
+
+.xterm.focus,
+.xterm:focus {
+  outline: none;
+}
+
+.xterm .xterm-helpers {
+  position: absolute;
+  top: 0;
+  /**
+     * The z-index of the helpers must be higher than the canvases in order for
+     * IMEs to appear on top.
+     */
+  z-index: 5;
+}
+
+.xterm .xterm-helper-textarea {
+  padding: 0;
+  border: 0;
+  margin: 0;
+  /* Move textarea out of the screen to the far left, so that the cursor is not visible */
+  position: absolute;
+  opacity: 0;
+  left: -9999em;
+  top: 0;
+  width: 0;
+  height: 0;
+  z-index: -5;
+  /** Prevent wrapping so the IME appears against the textarea at the correct position */
+  white-space: nowrap;
+  overflow: hidden;
+  resize: none;
+}
+
+.xterm .composition-view {
+  /* TODO: Composition position got messed up somewhere */
+  background: #000;
+  color: #fff;
+  display: none;
+  position: absolute;
+  white-space: nowrap;
+  z-index: 1;
+}
+
+.xterm .composition-view.active {
+  display: block;
+}
+
+.xterm .xterm-viewport {
+  /* On OS X this is required in order for the scroll bar to appear fully opaque */
+  background-color: #000;
+  overflow-y: scroll;
+  cursor: default;
+  position: absolute;
+  right: 0;
+  left: 0;
+  top: 0;
+  bottom: 0;
+}
+
+.xterm .xterm-screen {
+  position: relative;
+}
+
+.xterm .xterm-screen canvas {
+  position: absolute;
+  left: 0;
+  top: 0;
+}
+
+.xterm .xterm-scroll-area {
+  visibility: hidden;
+}
+
+.xterm-char-measure-element {
+  display: inline-block;
+  visibility: hidden;
+  position: absolute;
+  top: 0;
+  left: -9999em;
+  line-height: normal;
+}
+
+.xterm.enable-mouse-events {
+  /* When mouse events are enabled (eg. tmux), revert to the standard pointer cursor */
+  cursor: default;
+}
+
+.xterm.xterm-cursor-pointer,
+.xterm .xterm-cursor-pointer {
+  cursor: pointer;
+}
+
+.xterm.column-select.focus {
+  /* Column selection mode */
+  cursor: crosshair;
+}
+
+.xterm .xterm-accessibility,
+.xterm .xterm-message {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  right: 0;
+  z-index: 10;
+  color: transparent;
+  pointer-events: none;
+}
+
+.xterm .live-region {
+  position: absolute;
+  left: -9999px;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+}
+
+.xterm-dim {
+  /* Dim should not apply to background, so the opacity of the foreground color is applied
+     * explicitly in the generated class and reset to 1 here */
+  opacity: 1 !important;
+}
+
+.xterm-underline-1 {
+  text-decoration: underline;
+}
+.xterm-underline-2 {
+  text-decoration: double underline;
+}
+.xterm-underline-3 {
+  text-decoration: wavy underline;
+}
+.xterm-underline-4 {
+  text-decoration: dotted underline;
+}
+.xterm-underline-5 {
+  text-decoration: dashed underline;
+}
+
+.xterm-overline {
+  text-decoration: overline;
+}
+
+.xterm-overline.xterm-underline-1 {
+  text-decoration: overline underline;
+}
+.xterm-overline.xterm-underline-2 {
+  text-decoration: overline double underline;
+}
+.xterm-overline.xterm-underline-3 {
+  text-decoration: overline wavy underline;
+}
+.xterm-overline.xterm-underline-4 {
+  text-decoration: overline dotted underline;
+}
+.xterm-overline.xterm-underline-5 {
+  text-decoration: overline dashed underline;
+}
+
+.xterm-strikethrough {
+  text-decoration: line-through;
+}
+
+.xterm-screen .xterm-decoration-container .xterm-decoration {
+  z-index: 6;
+  position: absolute;
+}
+
+.xterm-screen
+  .xterm-decoration-container
+  .xterm-decoration.xterm-decoration-top-layer {
+  z-index: 7;
+}
+
+.xterm-decoration-overview-ruler {
+  z-index: 8;
+  position: absolute;
+  top: 0;
+  right: 0;
+  pointer-events: none;
+}
+
+.xterm-decoration-top {
+  z-index: 2;
+  position: relative;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/xterm.css

@@ -0,0 +1,3 @@
+.xterm-screen {
+  height: 100vh !important;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/classic/xterm.tsx

@@ -0,0 +1,148 @@
+import React, { MutableRefObject, useEffect, useRef } from 'react';
+import type { FitAddon } from '@xterm/addon-fit';
+import type { IDisposable, Terminal } from '@xterm/xterm';
+import { useTranslation } from 'react-i18next';
+
+import { registerTerminal } from '../utils/python-worker-handler';
+import './xterm.css';
+import './xterm-original.css';
+
+const registerServiceWorker = async () => {
+  if ('serviceWorker' in navigator) {
+    try {
+      await navigator.serviceWorker.register('/python-input-sw.js');
+    } catch (error) {
+      console.error(`Registration failed`);
+      console.error(error);
+    }
+  }
+};
+
+export const XtermTerminal = ({
+  xtermFitRef,
+  dimensions
+}: {
+  xtermFitRef: MutableRefObject<FitAddon | null>;
+  dimensions?: { height: number; width: number };
+}) => {
+  const termContainerRef = useRef<HTMLDivElement | null>(null);
+  const { t } = useTranslation();
+
+  useEffect(() => {
+    void registerServiceWorker();
+
+    let term: Terminal | null;
+
+    async function createTerminal() {
+      const disposables: IDisposable[] = [];
+      const { Terminal } = await import('@xterm/xterm');
+      const { FitAddon } = await import('@xterm/addon-fit');
+
+      // Setting convertEol so that \n is converted to \r\n. Otherwise the terminal
+      // will interpret \n as line feed and just move the cursor to the next line.
+      // convertEol makes every \n a \r\n.
+      term = new Terminal({ convertEol: true });
+      const fitAddon = new FitAddon();
+      xtermFitRef.current = fitAddon;
+      term.loadAddon(fitAddon);
+      if (termContainerRef.current) term.open(termContainerRef.current);
+      fitAddon.fit();
+
+      // xterm does provide a11y support via the `screenReaderMode` option.
+      // However, the mode only works best if the user interacts with the terminal directly.
+      // Since we feed the content to xterm, it's better to control the output a11y ourselves.
+      const termContainerDiv =
+        termContainerRef.current?.querySelector('.xterm');
+      const outputForScreenReader = document.createElement('div');
+
+      outputForScreenReader.setAttribute('role', 'region');
+      outputForScreenReader.setAttribute(
+        'aria-label',
+        t('aria.terminal-output')
+      );
+      outputForScreenReader.classList.add('sr-only');
+      termContainerDiv?.appendChild(outputForScreenReader);
+
+      const print = (text?: string) => {
+        term?.writeln(`${text ?? ''}`);
+        outputForScreenReader.textContent = text ?? '';
+      };
+
+      // TODO: prevent user from moving cursor outside the current input line and
+      // handle insertion and deletion properly. While backspace and delete don't
+      // seem to work, we can use "\x1b[0K" to clear from the cursor to the end.
+      // Also, we should not add special characters to the userinput string.
+      const input = (text?: string) => {
+        print(text);
+        let userinput = '';
+        // Eslint is correct that this only gets assigned once, but we can't use
+        // const because the declaration (before keyListener is defined) and
+        // assignment (after keyListener is defined) must be separate.
+        // eslint-disable-next-line prefer-const
+        let disposable: IDisposable | undefined;
+
+        const done = () => {
+          disposable?.dispose();
+          navigator.serviceWorker.controller?.postMessage(
+            JSON.stringify({
+              type: 'msg',
+              value: userinput
+            })
+          );
+        };
+
+        const keyListener = (key: string) => {
+          if (key === '\u007F' || key === '\b') {
+            // Backspace or delete key
+            term?.write('\b \b'); // Move cursor back, replace character with space, then move cursor back again
+            userinput = userinput.slice(0, -1); // Remove the last character from userinput
+          }
+          if (key == '\r') {
+            term?.write('\r\n');
+            done();
+          } else {
+            userinput += key;
+            term?.write(key);
+          }
+        };
+
+        disposable = term?.onData(keyListener); // Listen for key events and store the disposable
+        if (disposable) disposables.push(disposable);
+      };
+      const reset = () => {
+        // Ironically, term.reset(), while synchronous, is not a reliable way to
+        // reset the terminal. It does not clear the input buffer, so old print
+        // statements can still appear. The \x1bc (ESC c) escape sequence triggers
+        // a full terminal reset, which is what we want.
+        term?.write('\x1bc');
+        disposables.forEach(disposable => disposable.dispose());
+        disposables.length = 0;
+
+        outputForScreenReader.textContent = '';
+      };
+      registerTerminal({ print, input, reset });
+    }
+
+    void createTerminal();
+
+    return () => {
+      term?.dispose();
+    };
+  }, [xtermFitRef, t]);
+
+  useEffect(() => {
+    if (xtermFitRef.current) xtermFitRef.current.fit();
+
+    // dimensions is an implicit dependency, since it's not directly used by the
+    // effect, but fitAddon.fit() needs to be called whenever the container size
+    // changes.
+  }, [xtermFitRef, dimensions]);
+
+  return (
+    <div
+      data-playwright-test-label='xterm-terminal'
+      style={{ height: dimensions?.height }}
+      ref={termContainerRef}
+    ></div>
+  );
+};

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/codeally.css

@@ -0,0 +1,3 @@
+button[aria-described-by='codeally-cookie-warning'] {
+  font-size: 1.1rem;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/codespaces-instructions.tsx

@@ -0,0 +1,211 @@
+import React from 'react';
+import { Trans, useTranslation } from 'react-i18next';
+import { Spacer, Button, Callout } from '@freecodecamp/ui';
+
+import { CodeAllyButton } from '../../../components/growth-book/codeally-button';
+
+interface CodespacesInstructionsProps {
+  challengeType: number;
+  copyUrl: () => void;
+  copyUserToken: () => void;
+  generateUserToken: () => Promise<void>;
+  isSignedIn: boolean;
+  title: string;
+  userToken: string | null;
+}
+
+export function CodespacesInstructions({
+  challengeType,
+  copyUrl,
+  copyUserToken,
+  generateUserToken,
+  isSignedIn,
+  title,
+  userToken
+}: CodespacesInstructionsProps) {
+  const { t } = useTranslation();
+
+  function openCodespaces() {
+    const codespacesUrl = `https://codespaces.new/freeCodeCamp/rdb-alpha`;
+
+    window.open(codespacesUrl, '_blank');
+  }
+
+  return (
+    <div className='ca-description'>
+      <p>{t('learn.codespaces.intro')}</p>
+      <CodespacesContinueAlert title={title} />
+      <ol>
+        <li>
+          <Trans i18nKey='learn.codespaces.step-1'>
+            <a
+              href='https://github.com/signup'
+              rel='noopener noreferrer'
+              target='_blank'
+            >
+              placeholder
+            </a>
+          </Trans>
+        </li>
+        {isSignedIn && (
+          <>
+            <Spacer size='xs' />
+            <p>{t('learn.local.sub-step-heading')}</p>
+            <ol>
+              <li>{t('learn.local.sub-step-1')}</li>
+              <Spacer size='xxs' />
+              <Button
+                disabled={!!userToken}
+                block={true}
+                onClick={() => void generateUserToken()}
+              >
+                {t('learn.local.generate-token-btn')}
+              </Button>
+              <Spacer size='xs' />
+              <li>{t('learn.local.sub-step-2')}</li>
+              <Spacer size='xxs' />
+              <Button
+                disabled={!userToken}
+                block={true}
+                onClick={copyUserToken}
+              >
+                {t('learn.local.copy-token-btn')}
+              </Button>
+              <Spacer size='xs' />
+              <li>
+                <Trans i18nKey='learn.codespaces.sub-step-3'>
+                  <a
+                    href='https://github.com/settings/codespaces/secrets/new'
+                    rel='noopener noreferrer'
+                    target='_blank'
+                  >
+                    Codespaces secrets page
+                  </a>
+                </Trans>
+              </li>
+              <li>
+                <Trans i18nKey='learn.codespaces.sub-step-4'>
+                  <code>placeholder</code>
+                </Trans>
+              </li>
+              <li>
+                <Trans i18nKey='learn.codespaces.sub-step-5'>
+                  <code>placeholder</code>
+                </Trans>
+              </li>
+              <Spacer size='xxs' />
+              <CodespacesLogoutAlert course={title} />
+              <Spacer size='xxs' />
+              <li>
+                <Trans i18nKey='learn.codespaces.sub-step-6'>
+                  <code>placeholder</code>
+                  <code>placeholder</code>
+                </Trans>
+              </li>
+              <li>
+                <Trans i18nKey='learn.codespaces.sub-step-7'>
+                  <code>placeholder</code>
+                </Trans>
+              </li>
+            </ol>
+            <Spacer size='s' />
+          </>
+        )}
+        <li>{t('learn.codespaces.step-2')}</li>
+        <li style={{ listStyle: 'none' }}>
+          <Spacer size='xxs' />
+          <CodeAllyButton
+            challengeType={challengeType}
+            onClick={openCodespaces}
+          />
+        </li>
+      </ol>
+      <ol start={3}>
+        <li>{t('learn.codespaces.step-3')}</li>
+        <li>
+          {t('learn.codespaces.step-4')}
+          <ul>
+            <li>{t('learn.codespaces.step-5')}</li>
+            <li>
+              <Trans i18nKey='learn.codespaces.step-6'>
+                <code>placeholder</code>
+              </Trans>
+            </li>
+            <li>
+              <Trans i18nKey='learn.codespaces.step-7'>
+                <code>placeholder</code>
+              </Trans>
+            </li>
+            <li>
+              <Trans i18nKey='learn.codespaces.step-8'>
+                <code>placeholder</code>
+              </Trans>
+            </li>
+            <li>{t('learn.local.step-6')}</li>
+            <li>{t('learn.local.step-7')}</li>
+            <Spacer size='xxs' />
+            <Button block={true} onClick={copyUrl}>
+              {t('learn.local.copy-url')}
+            </Button>
+            <Spacer size='xs' />
+            <li>{t('learn.local.step-8')}</li>
+          </ul>
+        </li>
+        <li>{t('learn.codespaces.step-9')}</li>
+      </ol>
+    </div>
+  );
+}
+
+interface CodespacesContinueAlertProps {
+  title: string;
+}
+
+function CodespacesContinueAlert({ title }: CodespacesContinueAlertProps) {
+  const { t } = useTranslation();
+  return (
+    <>
+      <Callout variant='note' label={t('misc.note')}>
+        <Trans values={{ title }} i18nKey='learn.codespaces.continue-project'>
+          <a
+            href='https://github.com/codespaces'
+            rel='noopener noreferrer'
+            target='_blank'
+          >
+            placeholder
+          </a>
+        </Trans>
+        <Spacer size='m' />
+        <Trans i18nKey='learn.codespaces.learn-more'>
+          <a
+            href='https://forum.freecodecamp.org/t/relational-database-curriculum-in-codespaces/761449'
+            rel='noopener noreferrer'
+            target='_blank'
+          >
+            placeholder
+          </a>
+        </Trans>
+      </Callout>
+      <Spacer size='xs' />
+      <Callout variant='caution' label={t('misc.caution')}>
+        {t('learn.codespaces.reuse-tab-warning')}
+      </Callout>
+    </>
+  );
+}
+
+interface CodespacesLogoutAlertProps {
+  course: string;
+}
+
+function CodespacesLogoutAlert({
+  course
+}: CodespacesLogoutAlertProps): JSX.Element {
+  const { t } = useTranslation();
+
+  return (
+    <Callout variant='caution' label={t('misc.caution')}>
+      {t('learn.codespaces.logout-warning', { course })}
+    </Callout>
+  );
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/local-instructions.tsx

@@ -0,0 +1,131 @@
+import React from 'react';
+import { Trans, useTranslation } from 'react-i18next';
+import { Spacer, Button } from '@freecodecamp/ui';
+
+import { Link } from '../../../components/helpers';
+import RdbLocalLogoutAlert from './rdb-local-logout-alert';
+
+interface LocalInstructionsProps {
+  copyUrl: () => void;
+  copyUserToken: () => void;
+  generateUserToken: () => Promise<void>;
+  isSignedIn: boolean;
+  title: string;
+  userToken: string | null;
+}
+
+export function LocalInstructions({
+  copyUrl,
+  copyUserToken,
+  generateUserToken,
+  isSignedIn,
+  title,
+  userToken
+}: LocalInstructionsProps) {
+  const { t } = useTranslation();
+
+  return (
+    <div className='ca-description'>
+      <p>{t('learn.local.intro')}</p>
+      <ul>
+        <li>
+          <Link external={true} to='https://docs.docker.com/engine/'>
+            Docker Engine
+          </Link>
+        </li>
+        <li>
+          <Trans i18nKey='learn.local.download-vscode'>
+            <Link external={true} to='https://code.visualstudio.com/download'>
+              placeholder
+            </Link>
+            <Link
+              external={true}
+              to='https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers'
+            >
+              placeholder
+            </Link>
+          </Trans>
+        </li>
+        <li>
+          <Link external={true} to='https://git-scm.com/downloads'>
+            Git
+          </Link>
+        </li>
+      </ul>
+      <Spacer size='m' />
+      <p>{t('learn.local.heading')}</p>
+      <ol>
+        <li>
+          <Trans i18nKey='learn.local.step-1'>
+            <code>placeholder</code>
+          </Trans>
+        </li>
+        <li>
+          <Trans i18nKey='learn.local.step-2'>
+            <code>placeholder</code>
+            <code>placeholder</code>
+            <code>placeholder</code>
+          </Trans>
+        </li>
+        {isSignedIn && (
+          <>
+            <Spacer size='s' />
+            <p>{t('learn.local.sub-step-heading')}</p>
+            <ol>
+              <li>{t('learn.local.sub-step-1')}</li>
+              <Spacer size='xxs' />
+              <Button
+                disabled={!!userToken}
+                block={true}
+                onClick={() => void generateUserToken()}
+              >
+                {t('learn.local.generate-token-btn')}
+              </Button>
+              <Spacer size='xs' />
+              <li>{t('learn.local.sub-step-2')}</li>
+              <Spacer size='xxs' />
+              <Button
+                disabled={!userToken}
+                block={true}
+                onClick={copyUserToken}
+              >
+                {t('learn.local.copy-token-btn')}
+              </Button>
+              <Spacer size='xs' />
+              <li>
+                <Trans i18nKey='learn.local.sub-step-3'>
+                  <code>placeholder</code>
+                  <code>placeholder</code>
+                  <code>placeholder</code>
+                </Trans>
+              </li>
+              <Spacer size='xs' />
+              <RdbLocalLogoutAlert title={title} />
+            </ol>
+            <Spacer size='s' />
+          </>
+        )}
+        <li>
+          <Trans i18nKey='learn.local.step-3'>
+            <code>placeholder</code>
+          </Trans>
+        </li>
+        <li>{t('learn.local.step-4')}</li>
+        <li>
+          <Trans i18nKey='learn.local.step-5'>
+            <code>placeholder</code>
+          </Trans>
+        </li>
+        <li>{t('learn.local.step-6')}</li>
+        <li>{t('learn.local.step-7')}</li>
+        <Spacer size='xxs' />
+        <Button block={true} onClick={copyUrl}>
+          {t('learn.local.copy-url')}
+        </Button>
+        <Spacer size='xs' />
+        <li>{t('learn.local.step-8')}</li>
+        <li>{t('learn.local.step-9')}</li>
+      </ol>
+    </div>
+  );
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/project-submit.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'vitest';
+
+import { isCodeAllyProjectCompleted } from './project-submit';
+
+const challengeId = '5e601c775ac9d0ecd8b94aff';
+
+describe('isCodeAllyProjectCompleted', () => {
+  test('returns false when the project has not been completed', () => {
+    expect(
+      isCodeAllyProjectCompleted({
+        challengeId,
+        completedChallenges: [],
+        partiallyCompletedChallenges: []
+      })
+    ).toBe(false);
+  });
+
+  test('returns true when the project is partially completed', () => {
+    expect(
+      isCodeAllyProjectCompleted({
+        challengeId,
+        completedChallenges: [],
+        partiallyCompletedChallenges: [{ id: challengeId }]
+      })
+    ).toBe(true);
+  });
+
+  test('returns true when the project is completed', () => {
+    expect(
+      isCodeAllyProjectCompleted({
+        challengeId,
+        completedChallenges: [{ id: challengeId }],
+        partiallyCompletedChallenges: []
+      })
+    ).toBe(true);
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/project-submit.ts

@@ -0,0 +1,17 @@
+type ChallengeWithId = {
+  id: string;
+};
+
+export function isCodeAllyProjectCompleted({
+  challengeId,
+  completedChallenges,
+  partiallyCompletedChallenges
+}: {
+  challengeId: string;
+  completedChallenges: ChallengeWithId[];
+  partiallyCompletedChallenges: ChallengeWithId[];
+}): boolean {
+  return [...partiallyCompletedChallenges, ...completedChallenges].some(
+    challenge => challenge.id === challengeId
+  );
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/rdb-local-logout-alert.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Callout } from '@freecodecamp/ui';
+
+interface RdbLocalLogoutAlertProps {
+  title: string;
+}
+
+function RdbLocalLogoutAlert({ title }: RdbLocalLogoutAlertProps): JSX.Element {
+  const { t } = useTranslation();
+
+  return (
+    <Callout variant='caution' label={t('misc.caution')}>
+      {t('learn.local.logout-warning', { course: title })}
+    </Callout>
+  );
+}
+
+RdbLocalLogoutAlert.displayName = 'RdbLocalLogoutAlert';
+
+export default RdbLocalLogoutAlert;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/rdb-step-1-instructions.tsx

@@ -0,0 +1,32 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Spacer } from '@freecodecamp/ui';
+
+import ChallengeHeading from '../components/challenge-heading';
+import PrismFormatted from '../components/prism-formatted';
+
+interface RdbStep1InstructionsProps {
+  instructions: string;
+  isCompleted: boolean;
+}
+
+function RdbStep1Instructions({
+  instructions,
+  isCompleted
+}: RdbStep1InstructionsProps): JSX.Element {
+  const { t } = useTranslation();
+
+  return (
+    <>
+      <ChallengeHeading heading={t('learn.step-1')} isCompleted={isCompleted} />
+      <Spacer size='m' />
+      <div className='ca-description'>{t('learn.runs-in-vm')}</div>
+      <Spacer size='m' />
+      <PrismFormatted text={instructions} />
+    </>
+  );
+}
+
+RdbStep1Instructions.displayName = 'RdbStep1Instructions';
+
+export default RdbStep1Instructions;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/rdb-step-2-instructions.tsx

@@ -0,0 +1,33 @@
+import React from 'react';
+
+import { useTranslation } from 'react-i18next';
+import { Spacer } from '@freecodecamp/ui';
+
+import ChallengeHeading from '../components/challenge-heading';
+import PrismFormatted from '../components/prism-formatted';
+
+interface RdbStep2InstructionsProps {
+  notes: string;
+  isCompleted: boolean;
+}
+
+function RdbStep2Instructions({
+  isCompleted,
+  notes
+}: RdbStep2InstructionsProps): JSX.Element {
+  const { t } = useTranslation();
+
+  return (
+    <>
+      <ChallengeHeading heading={t('learn.step-2')} isCompleted={isCompleted} />
+      <Spacer size='m' />
+      <div className='ca-description'>{t('learn.submit-public-url')}</div>
+      <Spacer size='m' />
+      <PrismFormatted text={notes} />
+    </>
+  );
+}
+
+RdbStep2Instructions.displayName = 'RdbStep2Instructions';
+
+export default RdbStep2Instructions;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/codeally/show.tsx

@@ -0,0 +1,399 @@
+// Package Utilities
+import { graphql } from 'gatsby';
+import React, { Fragment, useEffect, useRef } from 'react';
+import Helmet from 'react-helmet';
+import type { TFunction } from 'i18next';
+import { withTranslation } from 'react-i18next';
+import { connect } from 'react-redux';
+import { bindActionCreators } from 'redux';
+import type { Dispatch } from 'redux';
+import { createSelector } from 'reselect';
+import { Container, Col, Row, Spacer } from '@freecodecamp/ui';
+import { useFeature } from '@growthbook/growthbook-react';
+
+// Local Utilities
+import LearnLayout from '../../../components/layouts/learn';
+import ChallengeTitle from '../components/challenge-title';
+import PrismFormatted from '../components/prism-formatted';
+import { challengeTypes } from '@freecodecamp/shared/config/challenge-types';
+import CompletionModal from '../components/completion-modal';
+import HelpModal from '../components/help-modal';
+import Hotkeys from '../components/hotkeys';
+import { updateUserToken } from '../../../redux/actions';
+import {
+  completedChallengesSelector,
+  partiallyCompletedChallengesSelector,
+  isSignedInSelector,
+  userTokenSelector
+} from '../../../redux/selectors';
+import {
+  challengeMounted,
+  updateChallengeMeta,
+  openModal,
+  updateSolutionFormValues,
+  initTests
+} from '../redux/actions';
+import { isChallengeCompletedSelector } from '../redux/selectors';
+import { createFlashMessage } from '../../../components/Flash/redux';
+import {
+  ChallengeNode,
+  ChallengeMeta,
+  CompletedChallenge,
+  Test
+} from '../../../redux/prop-types';
+import ProjectToolPanel from '../projects/tool-panel';
+import { getChallengePaths } from '../utils/challenge-paths';
+import SolutionForm from '../projects/solution-form';
+import { FlashMessages } from '../../../components/Flash/redux/flash-messages';
+import { SuperBlocks } from '@freecodecamp/shared/config/curriculum';
+import { CodeAllyDown } from '../../../components/growth-book/codeally-down';
+import { postUserToken } from '../../../utils/ajax';
+import RdbStep1Instructions from './rdb-step-1-instructions';
+import RdbStep2Instructions from './rdb-step-2-instructions';
+import { LocalInstructions } from './local-instructions';
+
+import './codeally.css';
+import { CodespacesInstructions } from './codespaces-instructions';
+import { isCodeAllyProjectCompleted } from './project-submit';
+
+// Redux
+const mapStateToProps = createSelector(
+  completedChallengesSelector,
+  isChallengeCompletedSelector,
+  isSignedInSelector,
+  partiallyCompletedChallengesSelector,
+  userTokenSelector,
+  (
+    completedChallenges: CompletedChallenge[],
+    isChallengeCompleted: boolean,
+    isSignedIn: boolean,
+    partiallyCompletedChallenges: CompletedChallenge[],
+    userToken: string | null
+  ) => ({
+    completedChallenges,
+    isChallengeCompleted,
+    isSignedIn,
+    partiallyCompletedChallenges,
+    userToken
+  })
+);
+
+const mapDispatchToProps = (dispatch: Dispatch) =>
+  bindActionCreators(
+    {
+      challengeMounted,
+      createFlashMessage,
+      openCompletionModal: () => openModal('completion'),
+      initTests,
+      updateUserToken,
+      updateChallengeMeta,
+      updateSolutionFormValues
+    },
+    dispatch
+  );
+
+// Types
+interface ShowCodeAllyProps {
+  challengeMounted: (arg0: string) => void;
+  completedChallenges: CompletedChallenge[];
+  createFlashMessage: typeof createFlashMessage;
+  data: { challengeNode: ChallengeNode };
+  initTests: (xs: Test[]) => void;
+  isChallengeCompleted: boolean;
+  isSignedIn: boolean;
+  openCompletionModal: () => void;
+  pageContext: {
+    challengeMeta: ChallengeMeta;
+  };
+  partiallyCompletedChallenges: CompletedChallenge[];
+  t: TFunction;
+  updateChallengeMeta: (arg0: ChallengeMeta) => void;
+  updateUserToken: (arg0: string) => void;
+  updateSolutionFormValues: () => void;
+  userToken: string | null;
+}
+
+function ShowCodeAlly({
+  completedChallenges,
+  data,
+  isChallengeCompleted,
+  isSignedIn,
+  partiallyCompletedChallenges,
+  t,
+  updateSolutionFormValues,
+  userToken,
+  updateUserToken,
+  createFlashMessage,
+  challengeMounted,
+  initTests,
+  pageContext: { challengeMeta },
+  updateChallengeMeta,
+  openCompletionModal
+}: ShowCodeAllyProps) {
+  const container = useRef<HTMLElement>(null);
+
+  const {
+    challengeNode: {
+      challenge: {
+        block,
+        challengeType,
+        tests,
+        description,
+        helpCategory,
+        id: challengeId,
+        instructions,
+        notes,
+        superBlock,
+        title,
+        translationPending,
+        url
+      }
+    }
+  } = data;
+  const blockNameTitle = `${t(
+    `intro:${superBlock}.blocks.${block}.title`
+  )}: ${title}`;
+  const windowTitle = `${blockNameTitle} | freeCodeCamp.org`;
+
+  const isPartiallyCompleted = partiallyCompletedChallenges.some(
+    challenge => challenge.id === challengeId
+  );
+
+  const isCompleted = completedChallenges.some(
+    challenge => challenge.id === challengeId
+  );
+
+  useEffect(() => {
+    initTests(tests);
+    const challengePaths = getChallengePaths({
+      currentCurriculumPaths: challengeMeta
+    });
+    updateChallengeMeta({
+      ...challengeMeta,
+      title,
+      challengeType,
+      helpCategory,
+      description,
+      ...challengePaths
+    });
+    challengeMounted(challengeMeta.id);
+    // hack to ensure the container is focused after the component mounts
+    // and Gatsby doesn't interfere with the focus.
+    requestAnimationFrame(() => container.current?.focus());
+    // This effect should be run once on mount
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const handleSubmit = ({
+    showCompletionModal
+  }: {
+    showCompletionModal: boolean;
+  }) => {
+    if (
+      !isCodeAllyProjectCompleted({
+        challengeId,
+        completedChallenges,
+        partiallyCompletedChallenges
+      })
+    ) {
+      createFlashMessage({
+        type: 'danger',
+        message: FlashMessages.CompleteProjectFirst
+      });
+    } else if (showCompletionModal) {
+      openCompletionModal();
+    }
+  };
+
+  const rdbLocalInstructions = useFeature('rdb-local-instructions');
+  const rdbCodespacesInstructions = useFeature('rdb-codespaces-instructions');
+
+  const coderoadTutorial = `https://raw.githubusercontent.com/${url}/main/tutorial.json`;
+
+  async function generateUserToken() {
+    const createUserTokenResponse = await postUserToken();
+    const { data = { userToken: null } } = createUserTokenResponse;
+
+    if (data?.userToken) {
+      updateUserToken(data.userToken);
+      createFlashMessage({
+        type: 'success',
+        message: FlashMessages.UserTokenGenerated
+      });
+    } else {
+      createFlashMessage({
+        type: 'danger',
+        message: FlashMessages.UserTokenGenerateError
+      });
+    }
+  }
+
+  function copyUserToken() {
+    navigator.clipboard.writeText(userToken ?? '').then(
+      () => {
+        createFlashMessage({
+          type: 'success',
+          message: FlashMessages.UserTokenCopied
+        });
+      },
+      () => {
+        createFlashMessage({
+          type: 'danger',
+          message: FlashMessages.UserTokenCopyError
+        });
+      }
+    );
+  }
+
+  function copyUrl() {
+    navigator.clipboard.writeText(coderoadTutorial ?? '').then(
+      () => {
+        createFlashMessage({
+          type: 'success',
+          message: FlashMessages.CourseUrlCopied
+        });
+      },
+      () => {
+        createFlashMessage({
+          type: 'danger',
+          message: FlashMessages.CourseUrlCopyError
+        });
+      }
+    );
+  }
+
+  const setups = [
+    {
+      name: t('learn.codespaces.summary'),
+      component: CodespacesInstructions,
+      on: rdbCodespacesInstructions.on
+    },
+    {
+      name: t('learn.local.summary'),
+      component: LocalInstructions,
+      on: rdbLocalInstructions.on
+    }
+  ];
+
+  const setupsToShow = setups.filter(setup => {
+    return setup.on;
+  });
+
+  return (
+    <Hotkeys containerRef={container}>
+      <LearnLayout>
+        <Helmet title={windowTitle} />
+        <Container>
+          <Row>
+            <Col md={8} mdOffset={2} sm={10} smOffset={1} xs={12}>
+              <Spacer size='m' />
+              {superBlock === SuperBlocks.RelationalDb && <CodeAllyDown />}
+              <Spacer size='m' />
+              <ChallengeTitle
+                isCompleted={isChallengeCompleted}
+                translationPending={translationPending}
+              >
+                {title}
+              </ChallengeTitle>
+              <Spacer size='m' />
+              <PrismFormatted text={description} />
+              <Spacer size='m' />
+
+              {setupsToShow.map(({ name, component: SetupComponent }, i) => (
+                <Fragment key={name}>
+                  <details
+                    open={i === 0}
+                    style={{ border: '1px solid #ccc', padding: '16px' }}
+                  >
+                    <summary>{name}</summary>
+                    <Spacer size='s' />
+                    <SetupComponent
+                      {...{
+                        challengeType,
+                        copyUrl,
+                        copyUserToken,
+                        generateUserToken,
+                        isSignedIn,
+                        title,
+                        userToken
+                      }}
+                    />
+                  </details>
+                  <Spacer size='s' />
+                </Fragment>
+              ))}
+
+              <Spacer size='m' />
+              {isSignedIn && challengeType === challengeTypes.codeAllyCert && (
+                <>
+                  <div className='ca-description'>
+                    {t('learn.complete-both-steps')}
+                  </div>
+                  <hr />
+                  <Spacer size='m' />
+                  <RdbStep1Instructions
+                    instructions={instructions}
+                    isCompleted={isPartiallyCompleted || isCompleted}
+                  />
+                  <hr />
+                  <Spacer size='m' />
+                  <RdbStep2Instructions
+                    isCompleted={isCompleted}
+                    notes={notes}
+                  />
+                  <Spacer size='m' />
+                  <SolutionForm
+                    challengeType={challengeType}
+                    description={description}
+                    onSubmit={handleSubmit}
+                    updateSolutionForm={updateSolutionFormValues}
+                  />
+                </>
+              )}
+
+              <ProjectToolPanel />
+              <br />
+              <Spacer size='m' />
+            </Col>
+            <CompletionModal />
+            <HelpModal
+              challengeTitle={title}
+              challengeBlock={block}
+              superBlock={superBlock}
+            />
+          </Row>
+        </Container>
+      </LearnLayout>
+    </Hotkeys>
+  );
+}
+
+export default connect(
+  mapStateToProps,
+  mapDispatchToProps
+)(withTranslation()(ShowCodeAlly));
+
+// GraphQL
+export const query = graphql`
+  query CodeAllyChallenge($id: String!) {
+    challengeNode(id: { eq: $id }) {
+      challenge {
+        block
+        challengeType
+        description
+        helpCategory
+        id
+        instructions
+        notes
+        superBlock
+        tests {
+          text
+          testString
+        }
+        title
+        translationPending
+        url
+      }
+    }
+  }
+`;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/assignments.css

@@ -0,0 +1,4 @@
+.assignments-not-complete {
+  text-align: center;
+  color: var(--danger-color);
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/assignments.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Spacer } from '@freecodecamp/ui';
+
+import ChallengeHeading from './challenge-heading';
+import PrismFormatted from './prism-formatted';
+import { getChallengeContentLangProps } from '../../../utils/challenge-content-lang';
+
+import './assignments.css';
+
+type AssignmentsProps = {
+  assignments: string[];
+  allAssignmentsCompleted: boolean;
+  handleAssignmentChange: (
+    event: React.ChangeEvent<HTMLInputElement>,
+    totalAssignments: number
+  ) => void;
+  superBlock?: string;
+};
+
+function Assignments({
+  assignments,
+  allAssignmentsCompleted,
+  handleAssignmentChange,
+  superBlock
+}: AssignmentsProps): JSX.Element {
+  const { t } = useTranslation();
+  const contentLangProps = getChallengeContentLangProps(superBlock);
+  return (
+    <>
+      <ChallengeHeading
+        heading={t('learn.assignments', { count: assignments.length })}
+      />
+      <div className='video-quiz-options'>
+        {assignments.map((assignment, index) => (
+          <label className='video-quiz-option-label' key={index}>
+            <input
+              name='assignment'
+              type='checkbox'
+              onChange={event =>
+                handleAssignmentChange(event, assignments.length)
+              }
+            />
+            <PrismFormatted
+              className={'video-quiz-option'}
+              text={assignment}
+              {...contentLangProps}
+            />
+            <Spacer size='m' />
+          </label>
+        ))}
+      </div>
+      {!allAssignmentsCompleted && (
+        <>
+          <Spacer size='m' />
+          <div className='assignments-not-complete'>
+            {t('learn.assignment-not-complete', { count: assignments.length })}
+          </div>
+        </>
+      )}
+      <Spacer size='m' />
+    </>
+  );
+}
+
+Assignments.displayName = 'Assignments';
+
+export default Assignments;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/bread-crumb.test.tsx

@@ -0,0 +1,39 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, expect, test, vi } from 'vitest';
+
+import BreadCrumb from './bread-crumb';
+
+vi.mock('i18next', () => ({
+  default: {
+    t: (key: string) => key
+  }
+}));
+
+describe('<BreadCrumb />', () => {
+  test('renders superblock and block links', () => {
+    render(
+      <BreadCrumb
+        block='workshop-cat-photo-app'
+        superBlock='responsive-web-design-v9'
+      />
+    );
+
+    expect(
+      screen.getByRole('navigation', { name: 'aria.breadcrumb-nav' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('link', {
+        name: 'intro:responsive-web-design-v9.title'
+      })
+    ).toHaveAttribute('href', '/learn/responsive-web-design-v9');
+    expect(
+      screen.getByRole('link', {
+        name: 'intro:responsive-web-design-v9.blocks.workshop-cat-photo-app.title'
+      })
+    ).toHaveAttribute(
+      'href',
+      '/learn/responsive-web-design-v9/#workshop-cat-photo-app'
+    );
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/bread-crumb.tsx

@@ -0,0 +1,44 @@
+import i18next from 'i18next';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link } from '../../../components/helpers/index';
+
+import './challenge-title.css';
+
+interface BreadCrumbProps {
+  block: string;
+  superBlock: string;
+}
+
+function BreadCrumb({ block, superBlock }: BreadCrumbProps): JSX.Element {
+  const { t } = useTranslation();
+  return (
+    <nav
+      className='challenge-title-breadcrumbs'
+      aria-label={t('aria.breadcrumb-nav')}
+    >
+      <ol data-playwright-test-label='breadcrumb-desktop'>
+        <li className='breadcrumb-left'>
+          <Link
+            state={{ breadcrumbBlockClick: block }}
+            to={`/learn/${superBlock}`}
+          >
+            <span>{i18next.t(`intro:${superBlock}.title`)}</span>
+          </Link>
+        </li>
+        <li className='breadcrumb-right'>
+          <Link
+            state={{ breadcrumbBlockClick: block }}
+            to={`/learn/${superBlock}/#${block}`}
+          >
+            {i18next.t(`intro:${superBlock}.blocks.${block}.title`)}
+          </Link>
+        </li>
+      </ol>
+    </nav>
+  );
+}
+
+BreadCrumb.displayName = 'BreadCrumb';
+
+export default BreadCrumb;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-description.css

@@ -0,0 +1,17 @@
+.challenge-instructions blockquote {
+  background-color: var(--tertiary-background);
+  color: var(--tertiary-color);
+  padding: 10px;
+  width: 100%;
+  margin: 0;
+  margin-bottom: 1.45rem;
+  font-size: 0.9rem;
+}
+
+#description ol li a {
+  word-break: break-all;
+}
+
+#description ol li {
+  line-height: 1.5;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-description.test.tsx

@@ -0,0 +1,31 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+
+import ChallengeDescription from './challenge-description';
+
+describe('<ChallengeDescription />', () => {
+  test('renders description links with their attributes', () => {
+    render(
+      <ChallengeDescription
+        block='write-your-first-code-using-c-sharp'
+        challengeId='647f85d407d29547b3bee1bb'
+        description='View <a href="https://learn.microsoft.com/users/me/achievements#trophies-section" target="_blank" rel="noreferrer">your achievements page</a>.'
+      />
+    );
+
+    expect(screen.getByText(/View/)).toBeInTheDocument();
+    expect(
+      screen.getByRole('link', { name: 'your achievements page' })
+    ).toHaveAttribute(
+      'href',
+      'https://learn.microsoft.com/users/me/achievements#trophies-section'
+    );
+    expect(
+      screen.getByRole('link', { name: 'your achievements page' })
+    ).toHaveAttribute('target', '_blank');
+    expect(
+      screen.getByRole('link', { name: 'your achievements page' })
+    ).toHaveAttribute('rel', 'noreferrer');
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-description.tsx

@@ -0,0 +1,50 @@
+import React, { useEffect } from 'react';
+import { initializeMathJax, isMathJaxAllowed } from '../../../utils/math-jax';
+import PrismFormatted from './prism-formatted';
+import './challenge-description.css';
+import { generateGithubLink } from '../../../components/create-github-link';
+import { getChallengeContentLangProps } from '../../../utils/challenge-content-lang';
+
+type Props = {
+  description?: string;
+  instructions?: string;
+  superBlock?: string;
+  challengeId: string;
+  block: string;
+};
+
+const ChallengeDescription = ({
+  description,
+  instructions,
+  superBlock,
+  challengeId,
+  block
+}: Props) => {
+  useEffect(() => {
+    if (superBlock && isMathJaxAllowed(superBlock)) {
+      initializeMathJax();
+    }
+  }, [superBlock]);
+
+  const githubLink = generateGithubLink(challengeId, block);
+  const contentLangProps = getChallengeContentLangProps(superBlock);
+  return (
+    <div
+      className={'challenge-instructions mathjax-support'}
+      data-playwright-test-label='challenge-description'
+      data-github-link={githubLink}
+    >
+      {description && (
+        <PrismFormatted text={description} {...contentLangProps} />
+      )}
+      {instructions && description && <hr />}
+      {instructions && (
+        <PrismFormatted text={instructions} {...contentLangProps} />
+      )}
+    </div>
+  );
+};
+
+ChallengeDescription.displayName = 'ChallengeDescription';
+
+export default ChallengeDescription;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-explanation.css

@@ -0,0 +1,3 @@
+.challenge-summary {
+  cursor: pointer;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-explanation.tsx

@@ -0,0 +1,41 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Spacer } from '@freecodecamp/ui';
+import { SuperBlocks } from '@freecodecamp/shared/config/curriculum';
+import PrismFormatted from './prism-formatted';
+import { getChallengeContentLangProps } from '../../../utils/challenge-content-lang';
+
+import './challenge-explanation.css';
+
+interface ChallengeExplanationProps {
+  explanation: string;
+  superBlock: SuperBlocks;
+}
+
+function ChallengeExplanation({
+  explanation,
+  superBlock
+}: ChallengeExplanationProps): JSX.Element {
+  const { t } = useTranslation();
+
+  return (
+    <>
+      <details>
+        <summary className='challenge-summary'>
+          {t('learn.explanation')}
+        </summary>
+        <Spacer size='m' />
+        <PrismFormatted
+          className={'line-numbers'}
+          text={explanation}
+          {...getChallengeContentLangProps(superBlock)}
+        />
+      </details>
+      <Spacer size='m' />
+    </>
+  );
+}
+
+ChallengeExplanation.displayName = 'ChallengeExplanation';
+
+export default ChallengeExplanation;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-heading.css

@@ -0,0 +1,10 @@
+.challenge-heading-wrap {
+  display: flex;
+  gap: 7px;
+  align-items: center;
+  justify-content: center;
+}
+
+.challenge-heading {
+  font-size: 16px;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-heading.tsx

@@ -0,0 +1,28 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import GreenPass from '../../../assets/icons/green-pass';
+
+import './challenge-heading.css';
+
+interface ChallengeHeadingProps {
+  heading: string;
+  isCompleted?: boolean;
+}
+
+function ChallengeHeading({
+  heading,
+  isCompleted = false
+}: ChallengeHeadingProps): JSX.Element {
+  const { t } = useTranslation();
+
+  return (
+    <div className='challenge-heading-wrap'>
+      <h2 className='challenge-heading'>{t(heading)}</h2>
+      {isCompleted && <GreenPass />}
+    </div>
+  );
+}
+
+ChallengeHeading.displayName = 'ChallengeHeading';
+
+export default ChallengeHeading;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-title.css

@@ -0,0 +1,117 @@
+.challenge-title-wrap {
+  text-align: center;
+}
+
+.challenge-title {
+  height: fit-content;
+  min-width: 25px;
+  margin: 20px 0px 15px;
+  padding: 0px 3px;
+  display: flex;
+  gap: 7px;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-height: fit-content;
+  white-space: pre-line;
+  flex-grow: 1;
+  flex-shrink: 1;
+  font-size: 16px;
+}
+
+.challenge-title-breadcrumbs {
+  font-size: 16px;
+  border: 1px solid var(--quaternary-background);
+  text-align: center;
+}
+
+.challenge-title-breadcrumbs ol {
+  display: flex;
+  justify-content: space-around;
+  list-style-type: none;
+  margin-bottom: 0;
+  padding-inline-start: 0;
+  width: 100%;
+}
+
+.challenge-title-breadcrumbs ol a {
+  width: 100%;
+  text-decoration: none;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  display: block;
+  padding: 0 3px;
+}
+
+.challenge-title-breadcrumbs ol a:focus {
+  background-color: inherit;
+}
+
+.challenge-title-breadcrumbs ol a:hover {
+  background-color: inherit;
+  text-decoration: underline;
+}
+
+.breadcrumb-left,
+.breadcrumb-right {
+  text-decoration: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  flex-grow: 1;
+  flex-shrink: 2;
+  padding: 0;
+}
+
+.breadcrumb-left {
+  min-width: 3rem;
+  background-color: var(--quaternary-background);
+  margin-inline-end: 0.57rem;
+}
+
+.breadcrumb-left:after {
+  background-color: var(--secondary-background);
+  content: '';
+  border-top: calc(1.375rem / 2) solid transparent;
+  border-bottom: calc(1.2rem / 2) solid transparent;
+  border-inline-start: calc(1.1rem / 2) solid var(--quaternary-background);
+  height: 100%;
+  margin-inline-start: 3px;
+}
+
+.breadcrumb-right {
+  min-width: 50px;
+}
+
+.breadcrumb-rule {
+  margin: 5px -10px;
+}
+
+.challenge-title h1 {
+  font-size: 1.1rem;
+  line-height: 1.42857143;
+  margin: 0;
+  display: inline;
+}
+
+.title-translation-cta {
+  display: flex;
+  flex-direction: row;
+  justify-content: space-around;
+  font-size: 16px;
+  height: 25px;
+  text-decoration: none;
+  color: var(--highlight-color);
+  background-color: var(--highlight-background);
+  margin-bottom: 10px;
+}
+
+.title-translation-cta:hover,
+.title-translation-cta:focus {
+  text-decoration: none;
+  color: var(--highlight-background);
+  background-color: var(--highlight-color);
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-title.test.tsx

@@ -0,0 +1,57 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+
+import ChallengeTitle from './challenge-title';
+
+vi.mock('i18next', () => ({
+  default: {
+    t: (key: string) =>
+      ({
+        'links:help-translate-link-url': 'https://example.com/help-translate',
+        'misc.translation-pending': 'Help us translate'
+      })[key] ?? key
+  }
+}));
+
+const baseProps = {
+  children: 'What Role Does HTML Play on the Web?',
+  isCompleted: false,
+  translationPending: false
+};
+
+describe('<ChallengeTitle/>', () => {
+  it('renders the challenge title without a completion icon', () => {
+    render(<ChallengeTitle {...baseProps} />);
+
+    expect(
+      screen.getByRole('heading', {
+        level: 1,
+        name: 'What Role Does HTML Play on the Web?'
+      })
+    ).toBeInTheDocument();
+    expect(screen.queryByTestId('green-pass')).not.toBeInTheDocument();
+  });
+
+  it('renders the completion icon when the challenge is completed', () => {
+    render(<ChallengeTitle {...baseProps} isCompleted={true} />);
+
+    expect(screen.getByTestId('green-pass')).toBeInTheDocument();
+  });
+
+  it('renders the translation link when translation is pending', () => {
+    render(<ChallengeTitle {...baseProps} translationPending={true} />);
+
+    expect(
+      screen.getByRole('link', { name: 'Help us translate' })
+    ).toHaveAttribute('href', 'https://example.com/help-translate');
+  });
+
+  it('does not render the translation link when translation is not pending', () => {
+    render(<ChallengeTitle {...baseProps} />);
+
+    expect(
+      screen.queryByRole('link', { name: 'Help us translate' })
+    ).not.toBeInTheDocument();
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-title.tsx

@@ -0,0 +1,41 @@
+import i18next from 'i18next';
+import React from 'react';
+import GreenPass from '../../../assets/icons/green-pass';
+import { Link } from '../../../components/helpers/index';
+
+import './challenge-title.css';
+
+interface ChallengeTitleProps {
+  children: string;
+  isCompleted: boolean;
+  translationPending?: boolean;
+}
+
+function ChallengeTitle({
+  children,
+  isCompleted,
+  translationPending
+}: ChallengeTitleProps): JSX.Element {
+  return (
+    <div className='challenge-title-wrap'>
+      {translationPending && (
+        <Link
+          className='title-translation-cta'
+          to={i18next.t('links:help-translate-link-url')}
+        >
+          {i18next.t('misc.translation-pending')}
+        </Link>
+      )}
+      <div className='challenge-title'>
+        <h1 id='content-start' data-playwright-test-label='challenge-title'>
+          {children}
+        </h1>
+        {isCompleted && <GreenPass />}
+      </div>
+    </div>
+  );
+}
+
+ChallengeTitle.displayName = 'ChallengeTitle';
+
+export default ChallengeTitle;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-transcript.css

@@ -0,0 +1,19 @@
+.challenge-transcript-heading {
+  cursor: pointer;
+  font-weight: bold;
+  margin-top: 1.5em;
+}
+
+.challenge-transcript .transcript-dialogue {
+  border: 1px solid var(--secondary-color);
+}
+
+.challenge-transcript .transcript-dialogue p {
+  margin: 0;
+  padding: 6px 13px;
+  text-align: start;
+}
+
+.challenge-transcript .transcript-dialogue p:nth-child(odd) {
+  background-color: var(--tertiary-background);
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-transcript.test.tsx

@@ -0,0 +1,114 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import store from 'store';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import ChallengeTranscript from './challenge-transcript';
+
+const baseProps = {
+  transcript: 'Sample transcript text',
+  shouldPersistExpanded: false
+};
+
+describe('<ChallengeTranscript />', () => {
+  afterEach(() => {
+    store.clearAll();
+  });
+
+  it('renders the transcript heading', () => {
+    render(<ChallengeTranscript {...baseProps} />);
+    expect(screen.getByText('learn.transcript')).toBeVisible();
+  });
+
+  it('renders collapsed by default', () => {
+    render(<ChallengeTranscript {...baseProps} />);
+    expect(screen.getByTestId('challenge-transcript')).not.toHaveAttribute(
+      'open'
+    );
+    expect(screen.getByText('Sample transcript text')).not.toBeVisible();
+  });
+
+  it("renders collapsed when localstorage 'fcc-transcript-expanded = false'", () => {
+    store.set('fcc-transcript-expanded', false);
+    render(<ChallengeTranscript {...baseProps} />);
+    expect(screen.getByTestId('challenge-transcript')).not.toHaveAttribute(
+      'open'
+    );
+    expect(screen.getByText('Sample transcript text')).not.toBeVisible();
+  });
+
+  it("renders expanded when 'fcc-transcript-expanded = true' and shouldPersistExpanded = true", () => {
+    store.set('fcc-transcript-expanded', true);
+    render(<ChallengeTranscript {...baseProps} shouldPersistExpanded={true} />);
+    expect(screen.getByTestId('challenge-transcript')).toHaveAttribute('open');
+    expect(screen.getByText('Sample transcript text')).toBeVisible();
+  });
+
+  it('writes to localstorage when shouldPersistExpanded = true', () => {
+    const setSpy = vi.spyOn(store, 'set');
+    render(<ChallengeTranscript {...baseProps} shouldPersistExpanded={true} />);
+    fireEvent.click(screen.getByText('learn.transcript'));
+    expect(setSpy).toHaveBeenCalledWith('fcc-transcript-expanded', true);
+    setSpy.mockRestore();
+  });
+
+  it('does not write to localstorage when shouldPersistExpanded = false', () => {
+    const setSpy = vi.spyOn(store, 'set');
+    render(<ChallengeTranscript {...baseProps} />);
+    fireEvent.click(screen.getByText('learn.transcript'));
+    expect(setSpy).not.toHaveBeenCalled();
+    setSpy.mockRestore();
+  });
+
+  it('should render the transcript as paragraphs when isDialogue is true', () => {
+    store.set('fcc-transcript-expanded', true);
+
+    render(
+      <ChallengeTranscript
+        {...baseProps}
+        transcript={'<p><b>Alice</b>: Hello</p><p><b>Bob</b>: World</p>'}
+        shouldPersistExpanded={true}
+        isDialogue={true}
+      />
+    );
+
+    /* eslint-disable testing-library/no-node-access */
+    const aliceB = screen.getByText('Alice');
+    expect(aliceB).toBeVisible();
+    expect(aliceB.tagName).toBe('B');
+
+    const aliceP = aliceB.parentElement;
+    expect(aliceP?.tagName).toBe('P');
+    expect(aliceP?.textContent).toBe('Alice: Hello');
+
+    const bobB = screen.getByText('Bob');
+    expect(bobB).toBeVisible();
+    expect(bobB.tagName).toBe('B');
+
+    const bobP = bobB.parentElement;
+    expect(bobP?.tagName).toBe('P');
+    expect(bobP?.textContent).toBe('Bob: World');
+    /* eslint-enable testing-library/no-node-access */
+  });
+
+  it('should render the transcript with PrismFormatted when isDialogue is false', () => {
+    store.set('fcc-transcript-expanded', true);
+
+    render(
+      <ChallengeTranscript
+        {...baseProps}
+        transcript='<pre><code class="language-js">console.log("hi")</code></pre>'
+        shouldPersistExpanded={true}
+        isDialogue={false}
+      />
+    );
+
+    const preElement = screen.getByRole('region');
+    expect(preElement).toBeVisible();
+    expect(preElement.tagName).toBe('PRE');
+
+    // eslint-disable-next-line testing-library/no-node-access
+    const codeElement = preElement.querySelector('code');
+    expect(codeElement).toBeInTheDocument();
+    expect(preElement).toHaveTextContent('console.log("hi")');
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/challenge-transcript.tsx

@@ -0,0 +1,76 @@
+import React, { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Spacer } from '@freecodecamp/ui';
+import store from 'store';
+
+import PrismFormatted from './prism-formatted';
+import { getChallengeContentLangProps } from '../../../utils/challenge-content-lang';
+import './challenge-transcript.css';
+
+interface ChallengeTranscriptProps {
+  transcript: string;
+  shouldPersistExpanded?: boolean;
+  isDialogue?: boolean;
+  superBlock?: string;
+}
+
+function ChallengeTranscript({
+  transcript,
+  shouldPersistExpanded,
+  isDialogue,
+  superBlock
+}: ChallengeTranscriptProps): JSX.Element {
+  const { t } = useTranslation();
+
+  // default to collapsed
+  const [isOpen, setIsOpen] = useState(() =>
+    shouldPersistExpanded
+      ? ((store.get('fcc-transcript-expanded') as boolean | null) ?? false)
+      : false
+  );
+
+  function toggleExpandedState(e: React.MouseEvent<HTMLDetailsElement>) {
+    e.preventDefault();
+    if (shouldPersistExpanded) {
+      store.set('fcc-transcript-expanded', !isOpen);
+    }
+    setIsOpen(!isOpen);
+  }
+
+  return (
+    <>
+      <details
+        data-testid='challenge-transcript'
+        className='challenge-transcript'
+        open={isOpen}
+      >
+        <summary
+          onClick={toggleExpandedState}
+          aria-expanded={isOpen}
+          className='challenge-transcript-heading'
+        >
+          {t('learn.transcript')}
+        </summary>
+        <Spacer size='m' />
+        {isDialogue ? (
+          <div
+            className='transcript-dialogue'
+            dangerouslySetInnerHTML={{ __html: transcript }}
+            {...getChallengeContentLangProps(superBlock)}
+          />
+        ) : (
+          <PrismFormatted
+            className='line-numbers'
+            text={transcript}
+            {...getChallengeContentLangProps(superBlock)}
+          />
+        )}
+      </details>
+      <Spacer size='m' />
+    </>
+  );
+}
+
+ChallengeTranscript.displayName = 'ChallengeTranscript';
+
+export default ChallengeTranscript;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/completion-modal.css

@@ -0,0 +1,113 @@
+.completion-success-icon {
+  width: 200px;
+  height: 200px;
+  transform: scale(1.5);
+  opacity: 0;
+  animation: success-icon-animation 150ms linear 100ms forwards;
+}
+
+@keyframes success-icon-animation {
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+.completion-block-details {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  align-self: center;
+  justify-content: space-between;
+  width: 100%;
+  gap: 0.5rem;
+}
+
+.completion-block-name {
+  font-weight: 700;
+  font-size: 1rem;
+  margin-bottom: 4px;
+}
+
+.completion-block-meta {
+  color: var(--quaternary-color);
+  font-size: 0.8rem;
+  margin-top: 5px;
+}
+
+.completion-block-details .completion-block-name {
+  font-size: 1.2rem;
+}
+
+.completion-block-details .completion-block-meta {
+  font-size: 1rem;
+}
+
+.progress-bar-wrap {
+  width: 100%;
+  position: relative;
+  border: 1px solid var(--quaternary-color);
+}
+
+.progress-header {
+  display: flex;
+  flex-direction: row;
+  justify-content: space-between;
+  width: 100%;
+  font-size: 0.9rem;
+}
+
+.progress-bar-background {
+  width: 100%;
+  height: 10px;
+  color: var(--primary-color);
+  background-color: var(--quaternary-background);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: absolute;
+
+  top: 0;
+  left: 0;
+}
+
+.progress-bar-percent {
+  height: 10px;
+  overflow: hidden;
+  position: relative;
+  background-color: var(--primary-color);
+  transition: width 0ms linear;
+}
+
+/* The maximum width of login button is 500px, which is set in global.css.
+   An override is needed as 500px is not enough to allow the button to span the modal width. */
+.completion-modal-login-btn .signup-btn {
+  max-width: 100%;
+}
+
+.completion-modal-body {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+@media screen and (max-width: 991px) {
+  .progress-bar-wrap,
+  .progress-bar-background {
+    height: 10px;
+  }
+
+  .completion-success-icon {
+    width: 160px;
+    height: 160px;
+  }
+
+  .completion-message {
+    font-weight: 600;
+    font-size: 1.2rem;
+  }
+
+  .completion-block-name {
+    font-size: 1rem;
+  }
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/completion-modal.test.tsx

@@ -0,0 +1,390 @@
+import React from 'react';
+import type { TFunction } from 'i18next';
+import { runSaga } from 'redux-saga';
+import { describe, test, it, expect, beforeEach, vi, type Mock } from 'vitest';
+import { fireEvent, render, screen } from '../../../../utils/test-utils';
+
+import { getCompletedPercentage } from '../../../utils/get-completion-percentage';
+import { fireConfetti } from '../../../utils/fire-confetti';
+import { createStore } from '../../../redux/create-store';
+import { executeChallengeSaga } from '../redux/execute-challenge-saga';
+import {
+  challengeDataSelector,
+  challengeMetaSelector,
+  challengeTestsSelector,
+  isBuildEnabledSelector,
+  isBlockNewlyCompletedSelector,
+  currentBlockIdsSelector
+} from '../redux/selectors';
+import { completedChallengesIdsSelector } from '../../../redux/selectors';
+import { curriculumData } from '../../../services/curriculum-data';
+import { getTestRunner } from '../utils/build';
+import ConnectedCompletionModal, {
+  combineFileData,
+  CompletionModal
+} from './completion-modal';
+import { mockCurriculumData } from '../utils/__fixtures__/curriculum-data';
+import { useStaticQuery } from 'gatsby';
+import { ChallengeNode, SuperBlockStructure } from '../../../redux/prop-types';
+vi.mock('../../../analytics');
+vi.mock('../../../utils/fire-confetti');
+vi.mock('../../../components/Progress', () => ({
+  default: () => <div data-testid='progress-bar-container' />
+}));
+vi.mock('../../../components/Header/components/login', () => ({
+  default: ({ children }: { children?: React.ReactNode }) => (
+    <a href='/learn'>{children}</a>
+  )
+}));
+vi.mock('../redux/selectors');
+vi.mock('../../../redux/selectors');
+vi.mock('../utils/build');
+const mockSubmitChallenge = vi.hoisted(() => vi.fn());
+vi.mock('../utils/fetch-all-curriculum-data', () => ({
+  useSubmit: () => mockSubmitChallenge
+}));
+vi.mock('../../../utils/get-words');
+vi.mock('@freecodecamp/challenge-builder/build');
+const mockFireConfetti = fireConfetti as Mock;
+const mockTestRunner = vi.fn().mockReturnValue({ pass: true });
+const mockBuildEnabledSelector = isBuildEnabledSelector as Mock;
+const mockChallengeTestsSelector = challengeTestsSelector as Mock;
+const mockChallengeMetaSelector = challengeMetaSelector as Mock;
+const mockChallengeDataSelector = challengeDataSelector as Mock;
+const mockIsBlockNewlyCompletedSelector = isBlockNewlyCompletedSelector as Mock;
+const mockCurrentBlockIdsSelector = vi.mocked(currentBlockIdsSelector);
+const mockCompletedChallengesIdsSelector =
+  completedChallengesIdsSelector as unknown as Mock;
+const mockGetTestRunner = getTestRunner as Mock;
+mockBuildEnabledSelector.mockReturnValue(true);
+mockChallengeTestsSelector.mockReturnValue([
+  { text: 'Test 1', testString: 'mock test code' }
+]);
+mockChallengeMetaSelector.mockReturnValue({
+  challengeType: 'mock_challenge_type'
+});
+mockChallengeDataSelector.mockReturnValue({
+  challengeFiles: ['mock_challenge_files']
+});
+mockGetTestRunner.mockReturnValue(mockTestRunner);
+
+const completedChallengesIds = ['1', '3', '5'];
+const currentBlockIds = ['1', '3', '5', '7'];
+const id = '7';
+const fakeCompletedChallengesIds = ['1', '3', '5', '7', '8'];
+const t = ((key: string) => key) as TFunction;
+
+function renderCompletionModal(
+  props: Partial<React.ComponentProps<typeof CompletionModal>> = {}
+) {
+  return render(
+    <CompletionModal
+      challengeFiles={[]}
+      close={vi.fn()}
+      completedChallengesIds={[]}
+      dashedName='mock-challenge'
+      id='mock-id'
+      isOpen={true}
+      isSignedIn={true}
+      isSubmitting={false}
+      message='Great job'
+      t={t}
+      {...props}
+    />,
+    createStore()
+  );
+}
+
+describe('<CompletionModal />', () => {
+  beforeEach(() => {
+    mockSubmitChallenge.mockClear();
+    vi.stubGlobal(
+      'ResizeObserver',
+      class ResizeObserver {
+        observe = vi.fn();
+        unobserve = vi.fn();
+        disconnect = vi.fn();
+      }
+    );
+    vi.spyOn(window.navigator, 'userAgent', 'get').mockReturnValue('Linux');
+    Object.defineProperty(window, 'innerWidth', {
+      configurable: true,
+      value: 1200
+    });
+    vi.mocked(useStaticQuery).mockReturnValue(mockCurriculumData);
+    // Initialize curriculum data singleton for tests
+    const structuresMap: Record<string, SuperBlockStructure> = {};
+    mockCurriculumData.allSuperBlockStructure.nodes.forEach(node => {
+      structuresMap[node.superBlock] = node as SuperBlockStructure;
+    });
+    curriculumData.initialize({
+      challengeNodes: mockCurriculumData.allChallengeNode
+        .nodes as unknown as ChallengeNode[],
+      certificateNodes: mockCurriculumData.allCertificateNode.nodes,
+      superBlockStructures: structuresMap
+    });
+  });
+
+  describe('rendering', () => {
+    it('renders the signed-out completion state', () => {
+      renderCompletionModal({ isSignedIn: false });
+
+      expect(
+        screen.getByRole('heading', { name: 'Great job' })
+      ).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: 'Close' })).toBeInTheDocument();
+      expect(
+        screen.getByTestId('fcc-completion-success-icon')
+      ).toBeInTheDocument();
+      expect(screen.getByTestId('progress-bar-container')).toBeInTheDocument();
+      expect(
+        screen.getByRole('link', { name: 'learn.sign-in-save' })
+      ).toHaveAttribute('href', '/learn');
+      expect(
+        screen.getByRole('button', { name: 'buttons.go-to-next-ctrl' })
+      ).toBeInTheDocument();
+    });
+
+    it('renders the signed-in completion state', () => {
+      renderCompletionModal();
+
+      expect(
+        screen.queryByRole('link', { name: 'learn.sign-in-save' })
+      ).not.toBeInTheDocument();
+      expect(
+        screen.getByRole('button', { name: 'buttons.submit-and-go-ctrl' })
+      ).toBeInTheDocument();
+    });
+
+    it('uses mobile button text when signed out on small screens', () => {
+      Object.defineProperty(window, 'innerWidth', {
+        configurable: true,
+        value: 320
+      });
+
+      renderCompletionModal({ isSignedIn: false });
+
+      expect(
+        screen.getByRole('button', { name: 'buttons.go-to-next' })
+      ).toBeInTheDocument();
+    });
+
+    it('uses Command button text on macOS desktops', () => {
+      vi.spyOn(window.navigator, 'userAgent', 'get').mockReturnValue('Mac OS');
+
+      renderCompletionModal();
+
+      expect(
+        screen.getByRole('button', { name: 'buttons.submit-and-go-cmd' })
+      ).toBeInTheDocument();
+    });
+
+    it('uses mobile button text on small screens', () => {
+      Object.defineProperty(window, 'innerWidth', {
+        configurable: true,
+        value: 320
+      });
+
+      renderCompletionModal();
+
+      expect(
+        screen.getByRole('button', { name: 'buttons.submit-and-go' })
+      ).toBeInTheDocument();
+    });
+
+    it('closes when the close button is clicked', () => {
+      const close = vi.fn();
+      renderCompletionModal({ close });
+
+      fireEvent.click(screen.getByRole('button', { name: 'Close' }));
+
+      expect(close).toHaveBeenCalled();
+    });
+
+    it('submits when the submit button is clicked', () => {
+      renderCompletionModal();
+
+      fireEvent.click(
+        screen.getByRole('button', { name: 'buttons.submit-and-go-ctrl' })
+      );
+
+      expect(mockSubmitChallenge).toHaveBeenCalled();
+    });
+
+    it('submits when the keyboard shortcut is pressed', () => {
+      renderCompletionModal();
+
+      fireEvent.keyDown(screen.getByRole('dialog'), {
+        ctrlKey: true,
+        key: 'Enter'
+      });
+
+      expect(mockSubmitChallenge).toHaveBeenCalled();
+    });
+  });
+
+  describe('fireConfetti', () => {
+    beforeEach(() => {
+      mockFireConfetti.mockClear();
+    });
+    test('should fire when block is completed and challenge data exists', async () => {
+      const payload = { showCompletionModal: true };
+      const challengeId = 'bd7158d8c442eddfaeb5bd18';
+      const blockIds = ['step1', 'step2', 'step3', challengeId];
+      const store = createStore({
+        challenge: {
+          modal: { completion: true },
+          challengeMeta: {
+            id: challengeId,
+            certification: 'responsive-web-design'
+          }
+        }
+      });
+      mockIsBlockNewlyCompletedSelector.mockReturnValue(true);
+      mockChallengeMetaSelector.mockReturnValue({
+        id: challengeId,
+        isLastChallengeInBlock: true,
+        challengeType: 'mock_challenge_type'
+      });
+      mockCurrentBlockIdsSelector.mockReturnValue(blockIds);
+      mockCompletedChallengesIdsSelector.mockReturnValue(['step1', 'step2']);
+      // Curriculum data is initialized in beforeEach
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      await runSaga(store, executeChallengeSaga, { payload }).done;
+      expect(mockFireConfetti).toHaveBeenCalledTimes(1);
+    });
+    test('should not fire when challenge data is empty (saga guard)', async () => {
+      const payload = { showCompletionModal: true };
+      const challengeId = 'bd7158d8c442eddfaeb5bd18';
+      const store = createStore({
+        challenge: {
+          modal: { completion: true },
+          challengeMeta: {
+            id: challengeId,
+            certification: 'responsive-web-design'
+          }
+        }
+      });
+      mockIsBlockNewlyCompletedSelector.mockReturnValue(true);
+      mockChallengeMetaSelector.mockReturnValue({
+        id: challengeId,
+        isLastChallengeInBlock: true,
+        challengeType: 'mock_challenge_type'
+      });
+      // Reset curriculum data to empty state to test the guard
+      curriculumData.initialize({
+        certificateNodes: [],
+        challengeNodes: [],
+        superBlockStructures: {}
+      });
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      await runSaga(store, executeChallengeSaga, { payload }).done;
+      expect(mockFireConfetti).toHaveBeenCalledTimes(0);
+    });
+    test('should not fire when block is not completed', async () => {
+      const payload = { showCompletionModal: true };
+      const store = createStore({
+        challenge: {
+          modal: { completion: true },
+          challengeMeta: {
+            id: 'bd7158d8c442eddfaeb5bd18',
+            certification: 'responsive-web-design' // Make sure the certification matches
+          }
+        }
+      });
+      mockIsBlockNewlyCompletedSelector.mockReturnValue(false);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      await runSaga(store, executeChallengeSaga, { payload }).done;
+      expect(mockFireConfetti).toHaveBeenCalledTimes(0);
+    });
+    test('should not fire if certification project has been completed', () => {
+      const store = createStore({
+        challenge: {
+          modal: { completion: true },
+          challengeMeta: {
+            // Build a Tribute Page's id:
+            id: 'bd7158d8c442eddfaeb5bd18'
+          }
+        }
+      });
+      render(<ConnectedCompletionModal />, store);
+
+      expect(mockFireConfetti).toHaveBeenCalledTimes(0);
+    });
+    test('should NOT fire if the challenge is not a project', () => {
+      const store = createStore({
+        challenge: {
+          modal: { completion: true },
+          challengeMeta: {
+            // id from learn-advanced-array-methods-by-building-a-statistics-calculator:
+            id: '6352e79d15aae30fac58f48e'
+          }
+        }
+      });
+
+      render(<ConnectedCompletionModal />, store);
+
+      expect(mockFireConfetti).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('getCompletedPercentage', () => {
+    it('returns 25 if one out of four challenges are complete', () => {
+      expect(
+        getCompletedPercentage([], currentBlockIds, currentBlockIds[1])
+      ).toBe(25);
+    });
+
+    it('returns 75 if three out of four challenges are complete', () => {
+      expect(
+        getCompletedPercentage(
+          completedChallengesIds,
+          currentBlockIds,
+          completedChallengesIds[0]
+        )
+      ).toBe(75);
+    });
+
+    it('returns 100 if all challenges have been completed', () => {
+      expect(
+        getCompletedPercentage(completedChallengesIds, currentBlockIds, id)
+      ).toBe(100);
+    });
+
+    it('returns 100 if more challenges have been complete than exist', () => {
+      expect(
+        getCompletedPercentage(fakeCompletedChallengesIds, currentBlockIds, id)
+      ).toBe(100);
+    });
+  });
+
+  describe('File Download Content', () => {
+    it('Should label each section appropriately', () => {
+      const indexHtml = {
+        name: 'index',
+        ext: 'html',
+        contents: 'some html elements'
+      };
+      const stylesCSS = {
+        name: 'styles',
+        ext: 'css',
+        contents: 'some css styles'
+      };
+      const scriptJS = {
+        name: 'script',
+        ext: 'js',
+        contents: 'some javascript'
+      };
+      const result = combineFileData([indexHtml, stylesCSS, scriptJS]);
+      expect(result).toContain('** start of index.html **');
+      expect(result).toContain('** end of index.html **');
+      expect(result).toContain('** start of styles.css **');
+      expect(result).toContain('** end of styles.css **');
+      expect(result).toContain('** start of script.js **');
+      expect(result).toContain('** end of script.js **');
+    });
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/completion-modal.tsx

@@ -0,0 +1,228 @@
+import React, { useEffect, useCallback, useState } from 'react';
+import type { TFunction } from 'i18next';
+import { withTranslation } from 'react-i18next';
+import { connect } from 'react-redux';
+import { createSelector } from 'reselect';
+import { Button, Modal, Spacer } from '@freecodecamp/ui';
+
+import Login from '../../../components/Header/components/login';
+import {
+  isSignedInSelector,
+  completedChallengesIdsSelector
+} from '../../../redux/selectors';
+import { ChallengeFiles } from '../../../redux/prop-types';
+import { closeModal } from '../redux/actions';
+import {
+  isCompletionModalOpenSelector,
+  successMessageSelector,
+  challengeFilesSelector,
+  challengeMetaSelector,
+  isSubmittingSelector
+} from '../redux/selectors';
+import Progress from '../../../components/Progress';
+import GreenPass from '../../../assets/icons/green-pass';
+import { MAX_MOBILE_WIDTH } from '../../../../config/misc';
+import './completion-modal.css';
+import callGA from '../../../analytics/call-ga';
+import { useSubmit } from '../utils/fetch-all-curriculum-data';
+
+const mapStateToProps = createSelector(
+  challengeFilesSelector,
+  challengeMetaSelector,
+  completedChallengesIdsSelector,
+  isCompletionModalOpenSelector,
+  isSignedInSelector,
+  successMessageSelector,
+  isSubmittingSelector,
+  (
+    challengeFiles: ChallengeFiles,
+    {
+      dashedName,
+      id
+    }: {
+      dashedName: string;
+      id: string;
+    },
+    completedChallengesIds: string[],
+    isOpen: boolean,
+    isSignedIn: boolean,
+    message: string,
+    isSubmitting: boolean
+  ) => ({
+    challengeFiles,
+    id,
+    dashedName,
+    completedChallengesIds,
+    isOpen,
+    isSignedIn,
+    message,
+    isSubmitting
+  })
+);
+
+const mapDispatchToProps = {
+  close: () => closeModal('completion')
+};
+
+type StateProps = ReturnType<typeof mapStateToProps>;
+
+interface CompletionModalProps extends StateProps {
+  close: () => void;
+  t: TFunction;
+}
+
+interface DownloadableChallengeFile {
+  name: string;
+  ext: string;
+  contents: string;
+}
+
+export function CompletionModal({
+  challengeFiles,
+  close,
+  dashedName,
+  isOpen,
+  isSignedIn,
+  isSubmitting,
+  message,
+  t
+}: CompletionModalProps): JSX.Element {
+  const [downloadURL, setDownloadURL] = useState<string>();
+  const submitChallenge = useSubmit();
+  // We can't useMemo here, because it does not guarantee that the URL object
+  // will be revoked when the dependencies change.
+  useEffect(() => {
+    // downloadURL is not in the dependency array because it should only change
+    // if the challengeFiles change. It is in the useEffect so that we cannot
+    // leak URL objects.
+    if (downloadURL) URL.revokeObjectURL(downloadURL);
+    if (challengeFiles?.length) {
+      const allFileContents = combineFileData(challengeFiles);
+      const blob = new Blob([allFileContents], { type: 'text/json' });
+      setDownloadURL(URL.createObjectURL(blob));
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [challengeFiles]);
+
+  useEffect(() => {
+    return () => {
+      close();
+    };
+  }, [close]);
+
+  useEffect(() => {
+    if (isOpen) {
+      callGA({ event: 'pageview', pagePath: '/completion-modal' });
+    }
+  }, [isOpen]);
+
+  const handleKeypress = useCallback(
+    (e: React.KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        e.stopPropagation();
+        close();
+      }
+      if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
+        e.preventDefault();
+        // Since Hotkeys also listens to Ctrl + Enter we have to stop this event
+        // getting to it.
+        e.stopPropagation();
+        submitChallenge();
+      }
+    },
+    [close, submitChallenge]
+  );
+
+  const isMacOS = navigator.userAgent.includes('Mac OS');
+
+  const isDesktop = window.innerWidth > MAX_MOBILE_WIDTH;
+
+  let buttonText;
+  if (isDesktop) {
+    if (isMacOS) {
+      buttonText = isSignedIn
+        ? t('buttons.submit-and-go-cmd')
+        : t('buttons.go-to-next-cmd');
+    } else {
+      buttonText = isSignedIn
+        ? t('buttons.submit-and-go-ctrl')
+        : t('buttons.go-to-next-ctrl');
+    }
+  } else {
+    buttonText = isSignedIn
+      ? t('buttons.submit-and-go')
+      : t('buttons.go-to-next');
+  }
+
+  return (
+    <Modal
+      onClose={close}
+      open={!!isOpen}
+      size='large'
+      onKeyDown={isOpen ? handleKeypress : undefined}
+    >
+      <Modal.Header closeButtonClassNames='close'>{message}</Modal.Header>
+      <Modal.Body className='completion-modal-body'>
+        <GreenPass
+          className='completion-success-icon'
+          data-testid='fcc-completion-success-icon'
+          data-playwright-test-label='completion-success-icon'
+        />
+        <div className='completion-block-details'>
+          <Progress />
+        </div>
+      </Modal.Body>
+      <Modal.Footer>
+        {isSignedIn ? null : (
+          <div className='completion-modal-login-btn'>
+            <Login block={true}>{t('learn.sign-in-save')}</Login>
+            <Spacer size='xxs' />
+          </div>
+        )}
+        <Button
+          block={true}
+          size='large'
+          variant='primary'
+          disabled={isSubmitting}
+          onClick={() => submitChallenge()}
+        >
+          {buttonText}
+        </Button>
+        <Spacer size='xxs' />
+        {downloadURL ? (
+          <Button
+            block={true}
+            size='large'
+            variant='primary'
+            download={`${dashedName}.txt`}
+            href={downloadURL}
+          >
+            {t('learn.download-solution')}
+          </Button>
+        ) : null}
+      </Modal.Footer>
+    </Modal>
+  );
+}
+
+CompletionModal.displayName = 'CompletionModal';
+
+export default connect(
+  mapStateToProps,
+  mapDispatchToProps
+)(withTranslation()(CompletionModal));
+
+export function combineFileData(challengeFiles: DownloadableChallengeFile[]) {
+  return challengeFiles.reduce<string>(function (
+    allFiles: string,
+    currentFile: DownloadableChallengeFile
+  ) {
+    const beforeText = `** start of ${currentFile.name + '.' + currentFile.ext} **\n\n`;
+    const afterText = `\n\n** end of ${currentFile.name + '.' + currentFile.ext} **\n\n`;
+    allFiles +=
+      challengeFiles.length > 0
+        ? `${beforeText}${currentFile.contents}${afterText}`
+        : currentFile.contents;
+    return allFiles;
+  }, '');
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/custom-monaco-editor.css

@@ -0,0 +1,9 @@
+.monaco-editor-wrapper {
+  padding-block-start: 8px;
+  flex: 1;
+}
+
+.monaco-editor .line-numbers {
+  color: #858591 !important;
+  font-size: 12px;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/custom-monaco-editor.tsx

@@ -0,0 +1,101 @@
+import React from 'react';
+import Loadable from '@loadable/component';
+import type * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { useActiveCode, useSandpack } from '@codesandbox/sandpack-react';
+import './custom-monaco-editor.css';
+
+const MonacoEditor = Loadable(() => import('react-monaco-editor'));
+
+const CustomMonacoEditor = () => {
+  const { code, updateCode } = useActiveCode();
+  const { sandpack } = useSandpack();
+
+  const getLanguage = (filePath: string): string => {
+    const extension = filePath.split('.').pop();
+
+    switch (extension) {
+      case 'js':
+      case 'jsx':
+        return 'javascript';
+      case 'ts':
+      case 'tsx':
+        return 'typescript';
+      case 'html':
+        return 'html';
+      case 'css':
+        return 'css';
+      default:
+        return 'plaintext';
+    }
+  };
+  // theme
+  const FCC_DARK_CUSTOM: monacoEditor.editor.IStandaloneThemeData = {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+      { token: 'comment', foreground: '858591', fontStyle: 'italic' },
+      { token: 'keyword', foreground: 'dbb8ff' },
+      { token: 'tag', foreground: 'f07178' },
+      { token: 'punctuation', foreground: '99c9ff' },
+      { token: 'definition', foreground: 'ffffff' },
+      { token: 'property', foreground: '99c9ff' },
+      { token: 'static', foreground: 'f78c6c' },
+      { token: 'string', foreground: 'acd157' },
+      { token: 'number', foreground: 'f78c6c' },
+      { token: 'variable', foreground: 'ffffff' },
+      { token: 'type', foreground: 'dbb8ff' },
+      { token: 'function', foreground: 'ffffff' },
+      { token: 'identifier', foreground: 'ffffff' },
+      { token: 'regexp', foreground: 'acd157' },
+      { token: 'delimiter', foreground: 'ffffff' },
+      { token: 'attribute.name', foreground: '99c9ff' },
+      { token: 'attribute.value', foreground: 'acd157' },
+      { token: 'annotation', foreground: 'dbb8ff' },
+      { token: 'constant', foreground: 'f78c6c' },
+      { token: 'class', foreground: 'dbb8ff' },
+      { token: 'interface', foreground: 'dbb9ff' },
+      { token: 'namespace', foreground: 'dbb8ff' },
+      { token: 'enum', foreground: 'dbb8ff' },
+      { token: 'operator', foreground: 'ffffff' }
+    ],
+    colors: {
+      'editor.background': '#0a0a23', // surface1
+      'editor.foreground': '#ffffff', // base (plain syntax)
+      'editorCursor.foreground': '#ffffff',
+      'editor.selectionBackground': '#3b3b4f',
+      'editor.lineHighlightBackground': '#3b3b4f', // surface3
+      'editorBracketMatch.border': '#dbb8ff'
+    }
+  };
+
+  const handleEditor = (monaco: typeof monacoEditor) => {
+    monaco.editor.defineTheme('fcc-dark', FCC_DARK_CUSTOM);
+  };
+
+  return (
+    <div className='monaco-editor-wrapper'>
+      <MonacoEditor
+        width='100%'
+        height='100%'
+        language={getLanguage(sandpack.activeFile)}
+        theme='fcc-dark'
+        editorWillMount={handleEditor}
+        key={sandpack.activeFile}
+        defaultValue={code}
+        onChange={value => {
+          updateCode(value || '');
+        }}
+        options={{
+          lineNumbersMinChars: 2,
+          minimap: { enabled: false },
+          scrollBeyondLastLine: false,
+          automaticLayout: true
+        }}
+      />
+    </div>
+  );
+};
+
+CustomMonacoEditor.displayname = 'CustomMonacoEditor';
+
+export default CustomMonacoEditor;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/daily-challenge-bread-crumb.test.tsx

@@ -0,0 +1,48 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import DailyChallengeBreadCrumb from './daily-challenge-bread-crumb';
+
+vi.mock('i18next', () => ({
+  default: {
+    t: (key: string) => key
+  }
+}));
+
+describe('<DailyChallengeBreadCrumb />', () => {
+  it('renders nothing when there is no param', () => {
+    const { container } = render(<DailyChallengeBreadCrumb />);
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('renders nothing for an invalid param', () => {
+    const { container } = render(
+      <DailyChallengeBreadCrumb dailyChallengeParam='not-a-date' />
+    );
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('renders nothing for a shape-valid but semantically invalid month-day', () => {
+    const { container } = render(
+      <DailyChallengeBreadCrumb dailyChallengeParam='13-45' />
+    );
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('shows only the month and day for a full "yyyy-MM-dd" date, with no year', () => {
+    render(<DailyChallengeBreadCrumb dailyChallengeParam='2026-07-15' />);
+
+    expect(
+      screen.getByRole('navigation', { name: 'aria.breadcrumb-nav' })
+    ).toBeInTheDocument();
+    expect(screen.getByText('July 15')).toBeInTheDocument();
+    expect(screen.queryByText('2026')).not.toBeInTheDocument();
+  });
+
+  it('shows only the month and day for a year-agnostic "MM-DD" param', () => {
+    render(<DailyChallengeBreadCrumb dailyChallengeParam='07-15' />);
+
+    expect(screen.getByText('July 15')).toBeInTheDocument();
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/daily-challenge-bread-crumb.tsx

@@ -0,0 +1,43 @@
+import i18next from 'i18next';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link } from '../../../components/helpers/index';
+
+import './challenge-title.css';
+import {
+  isValidDateOrMonthDayString,
+  formatDisplayDate
+} from '../../../components/daily-coding-challenge/helpers';
+
+function DailyChallengeBreadCrumb({
+  dailyChallengeParam
+}: {
+  dailyChallengeParam?: string;
+}): JSX.Element | null {
+  const { t } = useTranslation();
+
+  return dailyChallengeParam &&
+    isValidDateOrMonthDayString(dailyChallengeParam) ? (
+    <nav
+      className='challenge-title-breadcrumbs'
+      aria-label={t('aria.breadcrumb-nav')}
+    >
+      <ol data-playwright-test-label='breadcrumb-desktop'>
+        <li className='breadcrumb-left'>
+          <Link to={`/learn/daily-coding-challenge/archive`}>
+            <span>{i18next.t(`intro:daily-coding-challenge.title`)}</span>
+          </Link>
+        </li>
+        <li className='breadcrumb-right'>
+          <Link to={`/learn/daily-coding-challenge/archive`}>
+            {formatDisplayDate(dailyChallengeParam)}
+          </Link>
+        </li>
+      </ol>
+    </nav>
+  ) : null;
+}
+
+DailyChallengeBreadCrumb.displayName = 'DailyChallengeBreadCrumb';
+
+export default DailyChallengeBreadCrumb;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/fill-in-the-blanks.test.tsx

@@ -0,0 +1,87 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { FillInTheBlank } from '../../../redux/prop-types';
+import FillInTheBlanks from './fill-in-the-blanks';
+
+const fillInTheBlank = {
+  sentence: '<p>Is BLANK your book? No, BLANK is my book.</p>',
+  blanks: [
+    { answer: 'this', feedback: null, audioId: null },
+    {
+      answer: 'that',
+      feedback: '<p>Use <code>that</code> for something further away.</p>',
+      audioId: null
+    }
+  ]
+} satisfies FillInTheBlank;
+
+type FillInTheBlanksProps = React.ComponentProps<typeof FillInTheBlanks>;
+
+const defaultProps = {
+  fillInTheBlank,
+  answersCorrect: [null, null],
+  showFeedback: false,
+  feedback: null,
+  showWrong: false,
+  handleInputChange: vi.fn()
+} satisfies FillInTheBlanksProps;
+
+function renderFillInTheBlanks(overrides: Partial<FillInTheBlanksProps> = {}) {
+  const props = { ...defaultProps, ...overrides };
+
+  render(<FillInTheBlanks {...props} />);
+}
+
+describe('<FillInTheBlanks />', () => {
+  it('marks incorrect blanks and shows feedback', () => {
+    renderFillInTheBlanks({
+      answersCorrect: [true, false],
+      showWrong: true,
+      showFeedback: true,
+      feedback: fillInTheBlank.blanks[1].feedback
+    });
+
+    expect(screen.getByText('learn.wrong-answer')).toBeInTheDocument();
+    expect(screen.getByText('this')).toHaveClass('correct-blank-answer');
+    expect(screen.getByText(/for something further away/)).toBeInTheDocument();
+
+    const blanks = screen.getAllByRole('textbox', {
+      name: 'learn.fill-in-the-blank.blank'
+    });
+    expect(blanks).toHaveLength(1);
+    expect(blanks[0]).toHaveAttribute('aria-invalid', 'true');
+  });
+
+  it('renders every blank as text when every answer is correct', () => {
+    renderFillInTheBlanks({
+      answersCorrect: [true, true]
+    });
+
+    expect(screen.queryByText('learn.wrong-answer')).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole('textbox', {
+        name: 'learn.fill-in-the-blank.blank'
+      })
+    ).not.toBeInTheDocument();
+    expect(screen.getByText('this')).toHaveClass('correct-blank-answer');
+    expect(screen.getByText('that')).toHaveClass('correct-blank-answer');
+  });
+
+  it('calls the input change handler with the blank index and value', async () => {
+    const user = userEvent.setup();
+    const handleInputChange = vi.fn();
+    renderFillInTheBlanks({ handleInputChange });
+
+    await user.type(
+      screen.getAllByRole('textbox', {
+        name: 'learn.fill-in-the-blank.blank'
+      })[1],
+      'that'
+    );
+
+    expect(handleInputChange).toHaveBeenLastCalledWith(1, 'that');
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/fill-in-the-blanks.tsx

@@ -0,0 +1,217 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Spacer } from '@freecodecamp/ui';
+
+import { parseBlanks, parseAnswer } from '../fill-in-the-blank/parse-blanks';
+import PrismFormatted from '../components/prism-formatted';
+import { getChallengeContentLangProps } from '../../../utils/challenge-content-lang';
+import {
+  FillInTheBlankInputType,
+  FillInTheBlank
+} from '../../../redux/prop-types';
+import ChallengeHeading from './challenge-heading';
+import PinyinToHanziInput from './pinyin-to-hanzi-input';
+import PinyinToneInput from './pinyin-tone-input';
+
+type FillInTheBlankProps = {
+  fillInTheBlank: FillInTheBlank;
+  inputType?: FillInTheBlankInputType;
+  answersCorrect: (boolean | null)[];
+  showFeedback: boolean;
+  feedback: string | null;
+  showWrong: boolean;
+  handleInputChange: (inputIndex: number, value: string) => void;
+  superBlock?: string;
+};
+
+const AnswerText = ({ answer }: { answer: string }) => {
+  const parsedAnswer = parseAnswer(answer);
+
+  if (typeof parsedAnswer === 'string') {
+    return <span className='correct-blank-answer'>{parsedAnswer}</span>;
+  }
+
+  return (
+    <ruby className='correct-blank-answer'>
+      {parsedAnswer.hanzi}
+      <rp>(</rp>
+      <rt>{parsedAnswer.pinyin}</rt>
+      <rp>)</rp>
+    </ruby>
+  );
+};
+
+type BlankInputProps = {
+  blankIndex: number;
+  answer: string;
+  isCorrect: boolean | null;
+  className: string;
+  onChange: (index: number, value: string) => void;
+  ariaLabel: string;
+  inputType?: 'pinyin-to-hanzi' | 'pinyin-tone';
+};
+
+const BlankInput = ({
+  blankIndex,
+  answer,
+  isCorrect,
+  className,
+  onChange,
+  ariaLabel,
+  inputType
+}: BlankInputProps) => {
+  const parsedAnswer = parseAnswer(answer);
+  const answerLength =
+    typeof parsedAnswer === 'string'
+      ? parsedAnswer.length
+      : parsedAnswer.pinyin.length;
+
+  if (inputType === 'pinyin-to-hanzi' && typeof parsedAnswer === 'object') {
+    return (
+      <PinyinToHanziInput
+        index={blankIndex}
+        expectedAnswer={parsedAnswer}
+        isCorrect={isCorrect}
+        onChange={onChange}
+        className={className}
+        maxLength={answerLength + 3}
+        size={answerLength}
+        ariaLabel={ariaLabel}
+      />
+    );
+  } else if (inputType === 'pinyin-tone' && typeof parsedAnswer === 'string') {
+    return (
+      <PinyinToneInput
+        index={blankIndex}
+        isCorrect={isCorrect}
+        onChange={onChange}
+        className={className}
+        maxLength={answerLength + 3}
+        size={answerLength}
+        ariaLabel={ariaLabel}
+      />
+    );
+  }
+
+  // Default text input
+  return (
+    <input
+      type='text'
+      maxLength={answerLength + 3}
+      className={className}
+      onChange={e => onChange(blankIndex, e.target.value)}
+      size={answerLength}
+      autoComplete='off'
+      aria-label={ariaLabel}
+      {...(isCorrect === false ? { 'aria-invalid': 'true' } : {})}
+    />
+  );
+};
+
+function FillInTheBlanks({
+  fillInTheBlank: { sentence, blanks },
+  inputType,
+  answersCorrect,
+  showFeedback,
+  feedback,
+  showWrong,
+  handleInputChange,
+  superBlock
+}: FillInTheBlankProps): JSX.Element {
+  const { t } = useTranslation();
+
+  const getInputClass = (index: number): string => {
+    let cls = 'fill-in-the-blank-input';
+
+    if (answersCorrect[index] === false) {
+      cls += ' incorrect-blank-answer';
+    }
+
+    return cls;
+  };
+
+  const paragraphs = parseBlanks(sentence);
+  const blankAnswers = blanks.map(b => b.answer);
+
+  const ariaInputDescription =
+    inputType === 'pinyin-to-hanzi'
+      ? t('aria.pinyin-to-hanzi-input-desc')
+      : inputType === 'pinyin-tone'
+        ? t('aria.pinyin-tone-input-desc')
+        : '';
+
+  return (
+    <>
+      <ChallengeHeading heading={t('learn.fill-in-the-blank.heading')} />
+      <Spacer size='xs' />
+      <p className='sr-only'>{ariaInputDescription}</p>
+      <div
+        className='fill-in-the-blank-wrap'
+        {...getChallengeContentLangProps(superBlock)}
+      >
+        {paragraphs.map((p, i) => (
+          // both keys, i and j, are stable between renders, since
+          // the paragraphs are static.
+          <p key={i}>
+            {p.map((node, j) => {
+              const { type, value } = node;
+
+              if (type === 'text') {
+                return value;
+              }
+
+              if (type === 'hanzi-pinyin') {
+                const { hanzi, pinyin } = value;
+                return (
+                  <ruby key={j}>
+                    {hanzi}
+                    <rp>(</rp>
+                    <rt>{pinyin}</rt>
+                    <rp>)</rp>
+                  </ruby>
+                );
+              }
+
+              // If a blank is answered correctly, render the answer as part of the sentence.
+              if (answersCorrect[value] === true) {
+                return <AnswerText key={j} answer={blankAnswers[value]} />;
+              }
+
+              return (
+                <BlankInput
+                  key={j}
+                  blankIndex={value}
+                  answer={blankAnswers[value]}
+                  isCorrect={answersCorrect[value]}
+                  className={getInputClass(value)}
+                  onChange={handleInputChange}
+                  ariaLabel={t('learn.fill-in-the-blank.blank')}
+                  inputType={inputType}
+                />
+              );
+            })}
+          </p>
+        ))}
+      </div>
+      <Spacer size='m' />
+      <div aria-live='polite'>
+        {showWrong && (
+          <div className='text-center'>
+            <span>{t('learn.wrong-answer')}</span>
+            <Spacer size='m' />
+          </div>
+        )}
+        {showFeedback && feedback && (
+          <PrismFormatted
+            text={feedback}
+            {...getChallengeContentLangProps(superBlock)}
+          />
+        )}
+      </div>
+    </>
+  );
+}
+
+FillInTheBlanks.displayName = 'FillInTheBlanks';
+
+export default FillInTheBlanks;

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/help-modal.css

@@ -0,0 +1,15 @@
+.help-form-legend {
+  color: var(--secondary-color);
+  border: 0;
+  font-size: 18px;
+}
+
+.checkbox-container {
+  display: flex;
+  width: 100%;
+  text-align: left;
+}
+
+.help-text-warning {
+  text-align: left;
+}

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/help-modal.test.tsx

@@ -0,0 +1,305 @@
+import React from 'react';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeAll, afterEach } from 'vitest';
+import i18n from '../../../../i18n/config-for-tests';
+import translations from '../../../../i18n/locales/english/translations.json';
+import { generateSearchLink, HelpModal } from './help-modal';
+
+vi.unmock('react-i18next');
+
+const validDescription =
+  'Example text with enough characters to validate that the forum help form can be submitted.';
+
+const createDefaultHelpModalProps = () => ({
+  closeHelpModal: vi.fn(),
+  createQuestion: vi.fn(),
+  isOpen: true,
+  challengeTitle: 'Write Your First C# Code',
+  challengeBlock: 'write-your-first-code-using-c-sharp',
+  superBlock: 'foundational-c-sharp-with-microsoft',
+  openVideoModal: vi.fn()
+});
+
+const renderHelpModal = (
+  props: Partial<React.ComponentProps<typeof HelpModal>> = {}
+) => {
+  const helpModalProps = {
+    ...createDefaultHelpModalProps(),
+    ...props
+  };
+
+  return {
+    ...render(<HelpModal {...helpModalProps} />),
+    helpModalProps
+  };
+};
+
+const openHelpForm = async () => {
+  await userEvent.click(
+    screen.getByRole('button', { name: translations.buttons['create-post'] })
+  );
+};
+
+const getDescriptionInput = () =>
+  screen.getByRole('textbox', {
+    name: /^Tell us what's happening:/
+  });
+
+beforeAll(() => {
+  i18n.addResourceBundle('en', 'translations', translations, true, true);
+
+  type ResizeObserverMockInstance = {
+    observe: ResizeObserver['observe'];
+    unobserve: ResizeObserver['unobserve'];
+    disconnect: ResizeObserver['disconnect'];
+  };
+
+  Object.defineProperty(window, 'ResizeObserver', {
+    writable: true,
+    value: vi.fn(function (
+      this: ResizeObserverMockInstance,
+      _cb: ResizeObserverCallback
+    ) {
+      this.observe = vi.fn();
+      this.unobserve = vi.fn();
+      this.disconnect = vi.fn();
+    })
+  });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('generateSearchLink', () => {
+  it("should return a link with search query containing block name and challenge title if the title includes 'step'", async () => {
+    await i18n.reloadResources('en', 'intro');
+    const link = generateSearchLink(
+      'Step 10',
+      'learn-basic-javascript-by-building-a-role-playing-game',
+      'javascript-algorithms-and-data-structures-v8'
+    );
+
+    expect(link).toBe(
+      'https://forum.freecodecamp.org/search?q=javascript-algorithms-and-data-structures-v8.blocks.learn-basic-javascript-by-building-a-role-playing-game.title%20-%20Step%2010%20in%3Atitle'
+    );
+  });
+
+  it("should return a link with search query containing block name and challenge title if the title includes 'task'", () => {
+    const link = generateSearchLink(
+      'Task 10',
+      'learn-greetings-in-your-first-day-at-the-office',
+      'a2-english-for-developers'
+    );
+
+    expect(link).toBe(
+      'https://forum.freecodecamp.org/search?q=a2-english-for-developers.blocks.learn-greetings-in-your-first-day-at-the-office.title%20-%20Task%2010%20in%3Atitle'
+    );
+  });
+
+  it("should return a link with search query containing only challenge title if the title does not include 'step' or 'task'", () => {
+    const link = generateSearchLink(
+      'Perform Basic String Formatting in C#',
+      'write-your-first-code-using-c-sharp',
+      'foundational-c-sharp-with-microsoft'
+    );
+
+    expect(link).toBe(
+      'https://forum.freecodecamp.org/search?q=foundational-c-sharp-with-microsoft.blocks.write-your-first-code-using-c-sharp.title%20-%20Perform%20Basic%20String%20Formatting%20in%20C%23%20in%3Atitle'
+    );
+  });
+});
+
+describe('<HelpModal />', () => {
+  it('renders the initial help options and warning copy', () => {
+    renderHelpModal();
+
+    const dialog = screen.getByRole('dialog', {
+      name: translations.buttons['get-help']
+    });
+
+    expect(dialog).toBeInTheDocument();
+    expect(
+      within(dialog).getByText(/If you've already tried the/)
+    ).toBeInTheDocument();
+    expect(
+      within(dialog).getByText(/Before making a new post/)
+    ).toBeInTheDocument();
+    expect(
+      within(dialog).getByRole('button', {
+        name: translations.buttons['create-post']
+      })
+    ).toBeInTheDocument();
+    expect(
+      within(dialog).getByRole('button', {
+        name: translations.buttons.cancel
+      })
+    ).toBeInTheDocument();
+    expect(
+      within(dialog).getByRole('button', {
+        name: translations.buttons.close
+      })
+    ).toBeInTheDocument();
+  });
+
+  it('renders a guide link and video button when video is available', async () => {
+    const { helpModalProps } = renderHelpModal({
+      guideUrl: 'https://forum.example.com/guide',
+      videoUrl: 'https://example.com/video'
+    });
+
+    const dialog = screen.getByRole('dialog', {
+      name: translations.buttons['get-help']
+    });
+
+    expect(
+      within(dialog).getByRole('link', {
+        name: translations.buttons['get-hint']
+      })
+    ).toHaveAttribute('href', 'https://forum.example.com/guide');
+
+    await userEvent.click(
+      within(dialog).getByRole('button', {
+        name: translations.buttons['watch-video']
+      })
+    );
+
+    expect(helpModalProps.openVideoModal).toHaveBeenCalledTimes(1);
+    expect(helpModalProps.closeHelpModal).toHaveBeenCalledTimes(1);
+  });
+
+  it('omits the video button when video is unavailable', () => {
+    renderHelpModal();
+
+    expect(
+      screen.queryByRole('button', {
+        name: translations.buttons['watch-video']
+      })
+    ).not.toBeInTheDocument();
+  });
+
+  it('closes from the cancel and header close buttons', async () => {
+    const { helpModalProps, unmount } = renderHelpModal();
+
+    await userEvent.click(
+      screen.getByRole('button', { name: translations.buttons.cancel })
+    );
+
+    expect(helpModalProps.closeHelpModal).toHaveBeenCalledTimes(1);
+
+    unmount();
+    const { helpModalProps: secondHelpModalProps } = renderHelpModal();
+
+    await userEvent.click(
+      screen.getByRole('button', { name: translations.buttons.close })
+    );
+
+    expect(secondHelpModalProps.closeHelpModal).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders forum links with safe external-link attributes', () => {
+    renderHelpModal();
+
+    expect(
+      screen.getByRole('link', { name: 'Read-Search-Ask' })
+    ).toHaveAttribute('href', 'https://forum.freecodecamp.org/t/19514');
+    expect(
+      screen.getByRole('link', {
+        name: 'check if your question has already been answered on the forum'
+      })
+    ).toHaveAttribute(
+      'href',
+      'https://forum.freecodecamp.org/search?q=foundational-c-sharp-with-microsoft.blocks.write-your-first-code-using-c-sharp.title%20-%20Write%20Your%20First%20C%23%20Code%20in%3Atitle'
+    );
+
+    screen.getAllByRole('link').forEach(link => {
+      expect(link).toHaveAttribute('target', '_blank');
+      expect(link).toHaveAttribute('rel', 'noopener noreferrer');
+    });
+  });
+
+  it('keeps submit disabled until both confirmations are checked', async () => {
+    renderHelpModal();
+
+    await openHelpForm();
+
+    const rsaCheckbox = screen.getByRole('checkbox', {
+      name: translations.aria['rsa-checkbox']
+    });
+    const similarQuestionsCheckbox = screen.getByRole('checkbox', {
+      name: translations.aria['similar-questions-checkbox']
+    });
+    const descriptionInput = getDescriptionInput();
+    const submitButton = screen.getByRole('button', {
+      name: translations.buttons.submit
+    });
+
+    // paste is preferable since typing the whole description is slow (each
+    // keystroke triggers a re-render) and times the test out on loaded CI
+    // runners
+    await userEvent.click(descriptionInput);
+    await userEvent.paste(validDescription);
+
+    expect(submitButton).toHaveAttribute('aria-disabled', 'true');
+
+    await userEvent.click(rsaCheckbox);
+    expect(submitButton).toHaveAttribute('aria-disabled', 'true');
+
+    await userEvent.click(rsaCheckbox);
+    await userEvent.click(similarQuestionsCheckbox);
+    expect(submitButton).toHaveAttribute('aria-disabled', 'true');
+  });
+
+  it('keeps submit disabled when the description is too short', async () => {
+    renderHelpModal();
+
+    await openHelpForm();
+
+    await userEvent.click(
+      screen.getByRole('checkbox', {
+        name: translations.aria['rsa-checkbox']
+      })
+    );
+    await userEvent.click(
+      screen.getByRole('checkbox', {
+        name: translations.aria['similar-questions-checkbox']
+      })
+    );
+    await userEvent.type(getDescriptionInput(), 'Too short');
+
+    expect(
+      screen.getByRole('button', { name: translations.buttons.submit })
+    ).toHaveAttribute('aria-disabled', 'true');
+  });
+
+  it('submits a valid help request and closes the modal', async () => {
+    const { helpModalProps } = renderHelpModal();
+
+    await openHelpForm();
+
+    await userEvent.click(
+      screen.getByRole('checkbox', {
+        name: translations.aria['rsa-checkbox']
+      })
+    );
+    await userEvent.click(
+      screen.getByRole('checkbox', {
+        name: translations.aria['similar-questions-checkbox']
+      })
+    );
+    // paste is preferable since typing the whole description is slow (each
+    // keystroke triggers a re-render) and times the test out on loaded CI
+    // runners
+    await userEvent.click(getDescriptionInput());
+    await userEvent.paste(validDescription);
+    await userEvent.click(
+      screen.getByRole('button', { name: translations.buttons.submit })
+    );
+
+    expect(helpModalProps.createQuestion).toHaveBeenCalledWith(
+      validDescription
+    );
+    expect(helpModalProps.closeHelpModal).toHaveBeenCalledTimes(1);
+  });
+});

github_code/freeCodeCamp__freeCodeCamp/client/src/templates/Challenges/components/help-modal.tsx

@@ -0,0 +1,350 @@
+import React, { useMemo, useState, useRef, useEffect } from 'react';
+import { Trans, useTranslation } from 'react-i18next';
+import { connect } from 'react-redux';
+import { Dispatch, bindActionCreators } from 'redux';
+import { Button, FormControl, Modal, Spacer } from '@freecodecamp/ui';
+
+import { t } from 'i18next';
+import envData from '../../../../config/env.json';
+import { createQuestion, closeModal, openModal } from '../redux/actions';
+import { isHelpModalOpenSelector } from '../redux/selectors';
+
+import './help-modal.css';
+import callGA from '../../../analytics/call-ga';
+
+interface HelpModalProps {
+  closeHelpModal: () => void;
+  createQuestion: (description: string) => void;
+  isOpen?: boolean;
+  challengeTitle: string;
+  challengeBlock: string;
+  superBlock: string;
+  guideUrl?: string;
+  videoUrl?: string;
+  openVideoModal: () => void;
+}
+
+const { forumLocation } = envData;
+const DESCRIPTION_MIN_CHARS = 50;
+const DESCRIPTION_MAX_CHARS = 500;
+const RSA = forumLocation + '/t/19514';
+
+const mapStateToProps = (state: unknown) => ({
+  isOpen: isHelpModalOpenSelector(state) as boolean
+});
+const mapDispatchToProps = (dispatch: Dispatch) =>
+  bindActionCreators(
+    {
+      createQuestion,
+      closeHelpModal: () => closeModal('help'),
+      openVideoModal: () => openModal('video')
+    },
+    dispatch
+  );
+
+export const generateSearchLink = (
+  title: string,
+  block: string,
+  superBlock: string
+) => {
+  const titleText = t(`intro:${superBlock}.blocks.${block}.title`);
+  const selector = 'in:title';
+  const query = encodeURIComponent(`${titleText} - ${title} ${selector}`);
+  const search = `${forumLocation}/search?q=${query}`;
+  return search;
+};
+
+interface CheckboxProps {
+  name: string;
+  i18nKey: string;
+  onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+  value: boolean;
+  href: string;
+  label: string;
+}
+
+function Checkbox({
+  name,
+  i18nKey,
+  onChange,
+  value,
+  href,
+  label
+}: CheckboxProps) {
+  const { t } = useTranslation();
+
+  return (
+    <div className='checkbox-container'>
+      <input
+        id={name}
+        name={name}
+        type='checkbox'
+        onChange={onChange}
+        checked={value}
+        required
+        // Instead of reusing the `i18nKey`, use a plain text version for label
+        // as input label should not contain interactive elements
+        aria-label={t(label)}
+      />
+
+      <span>
+        <Trans i18nKey={i18nKey}>
+          <a href={href} rel='noopener noreferrer' target='_blank'>
+            placeholder
+            <span className='sr-only'>{t('aria.opens-new-window')}</span>
+          </a>
+        </Trans>
+      </span>
+    </div>
+  );
+}
+
+export function HelpModal({
+  closeHelpModal,
+  createQuestion,
+  isOpen,
+  challengeBlock,
+  superBlock,
+  challengeTitle,
+  guideUrl,
+  videoUrl,
+  openVideoModal
+}: HelpModalProps): JSX.Element {
+  const { t } = useTranslation();
+  const [showHelpForm, setShowHelpForm] = useState(false);
+  const [description, setDescription] = useState('');
+  const [readSearchCheckbox, setReadSearchCheckbox] = useState(false);
+  const [similarQuestionsCheckbox, setSimilarQuestionsCheckbox] =
+    useState(false);
+
+  const formRef = useRef<HTMLFormElement>(null);
+
+  useEffect(() => {
+    if (showHelpForm) {
+      formRef.current?.querySelector('input')?.focus();
+    }
+  }, [showHelpForm]);
+
+  const canSubmitForm = useMemo(() => {
+    return (
+      description.length >= DESCRIPTION_MIN_CHARS &&
+      readSearchCheckbox &&
+      similarQuestionsCheckbox
+    );
+  }, [description, readSearchCheckbox, similarQuestionsCheckbox]);
+
+  const resetFormValues = () => {
+    setDescription('');
+    setReadSearchCheckbox(false);
+    setSimilarQuestionsCheckbox(false);
+  };
+
+  const handleClose = () => {
+    closeHelpModal();
+    setShowHelpForm(false);
+    resetFormValues();
+  };
+
+  const handleOpenVideo = () => {
+    openVideoModal();
+    handleClose();
+  };
+
+  const handleSubmit = (event: React.FormEvent) => {
+    event.preventDefault();
+
+    if (!canSubmitForm) {
+      return;
+    }
+
+    setShowHelpForm(false);
+    resetFormValues();
+    createQuestion(description);
+    closeHelpModal();
+  };
+
+  const hintUrl = guideUrl
+    ? guideUrl
+    : generateSearchLink(challengeTitle, challengeBlock, superBlock);
+
+  if (isOpen) {
+    callGA({ event: 'pageview', pagePath: '/help-modal' });
+  }
+  return (
+    <Modal onClose={handleClose} open={!!isOpen}>
+      <Modal.Header closeButtonClassNames='close'>
+        {t('buttons.get-help')}
+      </Modal.Header>
+      <Modal.Body>
+        {showHelpForm ? (
+          <form onSubmit={handleSubmit} ref={formRef}>
+            <fieldset>
+              <legend className='help-form-legend'>
+                {t('learn.must-confirm-statements')}
+              </legend>
+
+              <Checkbox
+                name='read-search-ask-checkbox'
+                i18nKey='learn.read-search-ask-checkbox'
+                label='aria.rsa-checkbox'
+                onChange={event => setReadSearchCheckbox(event.target.checked)}
+                value={readSearchCheckbox}
+                href={RSA}
+              />
+
+              <Spacer size='xs' />
+
+              <Checkbox
+                name='similar-questions-checkbox'
+                i18nKey='learn.similar-questions-checkbox'
+                label='aria.similar-questions-checkbox'
+                onChange={event =>
+                  setSimilarQuestionsCheckbox(event.target.checked)
+                }
+                value={similarQuestionsCheckbox}
+                href={generateSearchLink(
+                  challengeTitle,
+                  challengeBlock,
+                  superBlock
+                )}
+              />
+            </fieldset>
+
+            <Spacer size='s' />
+
+            <label htmlFor='help-modal-form-description'>
+              {t('forum-help.whats-happening')}
+              <span className='sr-only'>{t('learn.min-50-max-500')}</span>
+            </label>
+
+            <FormControl
+              id='help-modal-form-description'
+              name='description'
+              onChange={(event: React.ChangeEvent<HTMLInputElement>) => {
+                setDescription(event.target.value);
+              }}
+              componentClass='textarea'
+              rows={5}
+              value={description}
+              placeholder={t('forum-help.describe')}
+              minLength={DESCRIPTION_MIN_CHARS}
+              maxLength={DESCRIPTION_MAX_CHARS}
+              required
+            />
+
+            <Spacer size='s' />
+
+            {description.length < DESCRIPTION_MIN_CHARS ? (
+              <p>
+                {t('learn.minimum-characters', {
+                  characters: DESCRIPTION_MIN_CHARS - description.length
+                })}
+              </p>
+            ) : (
+              <p>
+                {t('learn.characters-left', {
+                  characters: DESCRIPTION_MAX_CHARS - description.length
+                })}
+              </p>
+            )}
+
+            <Spacer size='xxs' />
+
+            <Button
+              block={true}
+              size='large'
+              variant='primary'
+              type='submit'
+              disabled={!canSubmitForm}
+            >
+              {t('buttons.submit')}
+            </Button>
+            <Spacer size='xxs' />
+            <Button
+              block={true}
+              size='large'
+              variant='primary'
+              onClick={handleClose}
+            >
+              {t('buttons.cancel')}
+            </Button>
+          </form>
+        ) : (
+          <>
+            <div className='help-text-warning'>
+              <p>
+                <Trans i18nKey='learn.tried-rsa'>
+                  <a href={RSA} rel='noopener noreferrer' target='_blank'>
+                    placeholder
+                  </a>
+                </Trans>
+              </p>
+              <p>
+                <Trans i18nKey='learn.rsa-forum'>
+                  <a
+                    href={generateSearchLink(
+                      challengeTitle,
+                      challengeBlock,
+                      superBlock
+                    )}
+                    rel='noopener noreferrer'
+                    target='_blank'
+                  >
+                    placeholder
+                  </a>
+                  placeholder
+                </Trans>
+              </p>
+            </div>
+            <Button
+              block={true}
+              size='large'
+              variant='primary'
+              href={hintUrl}
+              target='_blank'
+              rel='noopener noreferrer'
+            >
+              {t('buttons.get-hint')}
+            </Button>
+            <Spacer size='xxs' />
+            {videoUrl && (
+              <>
+                <Button
+                  block={true}
+                  size='large'
+                  variant='primary'
+                  onClick={handleOpenVideo}
+                  data-playwright-test-label='watch-a-video-modal-button'
+                >
+                  {t('buttons.watch-video')}
+                </Button>
+                <Spacer size='xxs' />
+              </>
+            )}
+            <Button
+              block={true}
+              size='large'
+              variant='primary'
+              onClick={() => setShowHelpForm(true)}
+            >
+              {t('buttons.create-post')}
+            </Button>
+            <Spacer size='xxs' />
+            <Button
+              block={true}
+              size='large'
+              variant='primary'
+              onClick={handleClose}
+            >
+              {t('buttons.cancel')}
+            </Button>
+          </>
+        )}
+      </Modal.Body>
+    </Modal>
+  );
+}
+
+HelpModal.displayName = 'HelpModal';
+
+export default connect(mapStateToProps, mapDispatchToProps)(HelpModal);