Move frontmatter types (#1664)

Signed-off-by: Tilman Vatteroth <git@tilmanvatteroth.de>

src/redux/index.ts

@@ -17,7 +17,6 @@ import type { DarkModeConfig } from './dark-mode/types'
 import { EditorConfigReducer } from './editor/reducers'
 import type { EditorConfig } from './editor/types'
 import { NoteDetailsReducer } from './note-details/reducer'
-import type { NoteDetails } from './note-details/types'
 import { UserReducer } from './user/reducers'
 import type { OptionalUserState } from './user/types'
 import type { UiNotificationState } from './ui-notifications/types'
@@ -27,6 +26,7 @@ import { HistoryReducer } from './history/reducers'
 import { RendererStatusReducer } from './renderer-status/reducers'
 import type { RendererStatus } from './renderer-status/types'
 import { composeWithDevTools } from 'redux-devtools-extension/developmentOnly'
+import type { NoteDetails } from './note-details/types/note-details'
 
 export interface ApplicationState {
   user: OptionalUserState

src/redux/note-details/frontmatter-extractor/extractor.test.ts

@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { extractFrontmatter } from './extractor'
+import type { PresentFrontmatterExtractionResult } from './types'
+
+describe('frontmatter extraction', () => {
+  describe('isPresent property', () => {
+    it('is false when note does not contain three dashes at all', () => {
+      const testNote = 'abcdef\nmore text'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(false)
+    })
+    it('is false when note does not start with three dashes', () => {
+      const testNote = '\n---\nthis is not frontmatter'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(false)
+    })
+    it('is false when note start with less than three dashes', () => {
+      const testNote = '--\nthis is not frontmatter'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(false)
+    })
+    it('is false when note starts with three dashes but contains other characters in the same line', () => {
+      const testNote = '--- a\nthis is not frontmatter'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(false)
+    })
+    it('is false when note has no ending marker for frontmatter', () => {
+      const testNote = '---\nthis is not frontmatter\nbecause\nthere is no\nend marker'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(false)
+    })
+    it('is false when note end marker is present but with not the same amount of dashes as start marker', () => {
+      const testNote = '---\nthis is not frontmatter\n----\ncontent'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(false)
+    })
+    it('is true when note end marker is present with the same amount of dashes as start marker', () => {
+      const testNote = '---\nthis is frontmatter\n---\ncontent'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(true)
+    })
+    it('is true when note end marker is present with the same amount of dashes as start marker but without content', () => {
+      const testNote = '---\nthis is frontmatter\n---'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(true)
+    })
+    it('is true when note end marker is present with the same amount of dots as start marker', () => {
+      const testNote = '---\nthis is frontmatter\n...\ncontent'
+      const extraction = extractFrontmatter(testNote)
+      expect(extraction.isPresent).toBe(true)
+    })
+  })
+
+  describe('lineOffset property', () => {
+    it('is correct for single line frontmatter without content', () => {
+      const testNote = '---\nsingle line frontmatter\n...'
+      const extraction = extractFrontmatter(testNote) as PresentFrontmatterExtractionResult
+      expect(extraction.lineOffset).toEqual(3)
+    })
+    it('is correct for single line frontmatter with content', () => {
+      const testNote = '---\nsingle line frontmatter\n...\ncontent'
+      const extraction = extractFrontmatter(testNote) as PresentFrontmatterExtractionResult
+      expect(extraction.lineOffset).toEqual(3)
+    })
+    it('is correct for multi-line frontmatter without content', () => {
+      const testNote = '---\nabc\n123\ndef\n...'
+      const extraction = extractFrontmatter(testNote) as PresentFrontmatterExtractionResult
+      expect(extraction.lineOffset).toEqual(5)
+    })
+    it('is correct for multi-line frontmatter with content', () => {
+      const testNote = '---\nabc\n123\ndef\n...\ncontent'
+      const extraction = extractFrontmatter(testNote) as PresentFrontmatterExtractionResult
+      expect(extraction.lineOffset).toEqual(5)
+    })
+  })
+
+  describe('rawText property', () => {
+    it('contains single-line frontmatter text', () => {
+      const testNote = '---\nsingle-line\n...\ncontent'
+      const extraction = extractFrontmatter(testNote) as PresentFrontmatterExtractionResult
+      expect(extraction.rawText).toEqual('single-line')
+    })
+    it('contains multi-line frontmatter text', () => {
+      const testNote = '---\nmulti\nline\n...\ncontent'
+      const extraction = extractFrontmatter(testNote) as PresentFrontmatterExtractionResult
+      expect(extraction.rawText).toEqual('multi\nline')
+    })
+  })
+})

src/redux/note-details/frontmatter-extractor/extractor.ts

@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+import type { FrontmatterExtractionResult } from './types'
+
+const FRONTMATTER_BEGIN_REGEX = /^-{3,}$/
+const FRONTMATTER_END_REGEX = /^(?:-{3,}|\.{3,})$/
+
+/**
+ * Extracts a frontmatter block from a given multiline string.
+ * A valid frontmatter block requires the content to start with a line containing at least three dashes.
+ * The block is terminated by a line containing the same amount of dashes or dots as the first line.
+ * @param content The multiline string from which the frontmatter should be extracted.
+ * @return { isPresent } false if no frontmatter block could be found, true if a block was found.
+ *         { rawFrontmatterText } if a block was found, this property contains the extracted text without the fencing.
+ *         { frontmatterLines }   if a block was found, this property contains the number of lines to skip from the
+ *                                given multiline string for retrieving the non-frontmatter content.
+ */
+export const extractFrontmatter = (content: string): FrontmatterExtractionResult => {
+  const lines = content.split('\n')
+  if (lines.length < 2 || !FRONTMATTER_BEGIN_REGEX.test(lines[0])) {
+    return {
+      isPresent: false
+    }
+  }
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].length === lines[0].length && FRONTMATTER_END_REGEX.test(lines[i])) {
+      return {
+        isPresent: true,
+        rawText: lines.slice(1, i).join('\n'),
+        lineOffset: i + 1
+      }
+    }
+  }
+  return {
+    isPresent: false
+  }
+}

src/redux/note-details/frontmatter-extractor/types.d.ts

@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+export type FrontmatterExtractionResult = PresentFrontmatterExtractionResult | NonPresentFrontmatterExtractionResult
+
+export interface PresentFrontmatterExtractionResult {
+  isPresent: true
+  rawText: string
+  lineOffset: number
+}
+
+interface NonPresentFrontmatterExtractionResult {
+  isPresent: false
+}

src/redux/note-details/initial-state.ts

@@ -4,10 +4,10 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { NoteDetails } from './types'
 import { DateTime } from 'luxon'
-import type { SlideOptions } from '../../components/common/note-frontmatter/types'
-import { NoteTextDirection, NoteType } from '../../components/common/note-frontmatter/types'
+import type { NoteDetails } from './types/note-details'
+import type { SlideOptions } from './types/slide-show-options'
+import { NoteTextDirection, NoteType } from './types/note-details'
 
 export const initialSlideOptions: SlideOptions = {
   transition: 'zoom',

src/redux/note-details/raw-note-frontmatter-parser/parser.test.ts

@@ -0,0 +1,68 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { createNoteFrontmatterFromYaml } from './parser'
+
+describe('yaml frontmatter', () => {
+  it('should parse "title"', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml('title: test')
+    expect(noteFrontmatter.title).toEqual('test')
+  })
+
+  it('should parse "robots"', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml('robots: index, follow')
+    expect(noteFrontmatter.robots).toEqual('index, follow')
+  })
+
+  it('should parse the deprecated tags syntax', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml('tags: test123, abc')
+    expect(noteFrontmatter.tags).toEqual(['test123', 'abc'])
+    expect(noteFrontmatter.deprecatedTagsSyntax).toEqual(true)
+  })
+
+  it('should parse the tags list syntax', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml(`tags:
+      - test123
+      - abc
+    `)
+    expect(noteFrontmatter.tags).toEqual(['test123', 'abc'])
+    expect(noteFrontmatter.deprecatedTagsSyntax).toEqual(false)
+  })
+
+  it('should parse the tag inline-list syntax', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml("tags: ['test123', 'abc']")
+    expect(noteFrontmatter.tags).toEqual(['test123', 'abc'])
+    expect(noteFrontmatter.deprecatedTagsSyntax).toEqual(false)
+  })
+
+  it('should parse "breaks"', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml('breaks: false')
+    expect(noteFrontmatter.newlinesAreBreaks).toEqual(false)
+  })
+
+  it('should parse an empty opengraph object', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml('opengraph:')
+    expect(noteFrontmatter.opengraph).toEqual(new Map<string, string>())
+  })
+
+  it('should parse an opengraph title', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml(`opengraph:
+      title: Testtitle
+    `)
+    expect(noteFrontmatter.opengraph.get('title')).toEqual('Testtitle')
+  })
+
+  it('should parse multiple opengraph values', () => {
+    const noteFrontmatter = createNoteFrontmatterFromYaml(`opengraph:
+      title: Testtitle
+      image: https://dummyimage.com/48.png
+      image:type: image/png
+    `)
+    expect(noteFrontmatter.opengraph.get('title')).toEqual('Testtitle')
+    expect(noteFrontmatter.opengraph.get('image')).toEqual('https://dummyimage.com/48.png')
+    expect(noteFrontmatter.opengraph.get('image:type')).toEqual('image/png')
+  })
+})

src/redux/note-details/raw-note-frontmatter-parser/parser.ts

@@ -0,0 +1,103 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { load } from 'js-yaml'
+import type { SlideOptions } from '../types/slide-show-options'
+import type { NoteFrontmatter } from '../types/note-details'
+import { NoteTextDirection, NoteType } from '../types/note-details'
+import { ISO6391 } from '../types/iso6391'
+import type { RawNoteFrontmatter } from './types'
+import { initialSlideOptions } from '../initial-state'
+
+/**
+ * Creates a new frontmatter metadata instance based on a raw yaml string.
+ * @param rawYaml The frontmatter content in yaml format.
+ * @throws Error when the content string is invalid yaml.
+ * @return Frontmatter metadata instance containing the parsed properties from the yaml content.
+ */
+export const createNoteFrontmatterFromYaml = (rawYaml: string): NoteFrontmatter => {
+  const rawNoteFrontmatter = load(rawYaml) as RawNoteFrontmatter
+  return parseRawNoteFrontmatter(rawNoteFrontmatter)
+}
+
+/**
+ * Creates a new frontmatter metadata instance based on the given raw metadata properties.
+ * @param rawData A {@link RawNoteFrontmatter} object containing the properties of the parsed yaml frontmatter.
+ */
+const parseRawNoteFrontmatter = (rawData: RawNoteFrontmatter): NoteFrontmatter => {
+  let tags: string[]
+  let deprecatedTagsSyntax: boolean
+  if (typeof rawData?.tags === 'string') {
+    tags = rawData?.tags?.split(',').map((entry) => entry.trim()) ?? []
+    deprecatedTagsSyntax = true
+  } else if (typeof rawData?.tags === 'object') {
+    tags = rawData?.tags?.filter((tag) => tag !== null) ?? []
+    deprecatedTagsSyntax = false
+  } else {
+    tags = []
+    deprecatedTagsSyntax = false
+  }
+
+  return {
+    title: rawData.title ?? '',
+    description: rawData.description ?? '',
+    robots: rawData.robots ?? '',
+    newlinesAreBreaks: rawData.breaks ?? true,
+    GA: rawData.GA ?? '',
+    disqus: rawData.disqus ?? '',
+    lang: (rawData.lang ? ISO6391.find((lang) => lang === rawData.lang) : undefined) ?? 'en',
+    type: rawData.type === NoteType.SLIDE ? NoteType.SLIDE : NoteType.DOCUMENT,
+    dir: rawData.dir === NoteTextDirection.LTR ? NoteTextDirection.LTR : NoteTextDirection.RTL,
+    opengraph: rawData?.opengraph
+      ? new Map<string, string>(Object.entries(rawData.opengraph))
+      : new Map<string, string>(),
+
+    slideOptions: parseSlideOptions(rawData),
+    tags,
+    deprecatedTagsSyntax
+  }
+}
+
+/**
+ * Parses the {@link SlideOptions} from the {@link RawNoteFrontmatter}.
+ *
+ * @param rawData The raw note frontmatter data.
+ * @return the parsed slide options
+ */
+const parseSlideOptions = (rawData: RawNoteFrontmatter): SlideOptions => {
+  const rawSlideOptions = rawData?.slideOptions
+  return {
+    autoSlide: parseNumber(rawSlideOptions?.autoSlide) ?? initialSlideOptions.autoSlide,
+    transition: rawSlideOptions?.transition ?? initialSlideOptions.transition,
+    backgroundTransition: rawSlideOptions?.backgroundTransition ?? initialSlideOptions.backgroundTransition,
+    autoSlideStoppable: parseBoolean(rawSlideOptions?.autoSlideStoppable) ?? initialSlideOptions.autoSlideStoppable,
+    slideNumber: parseBoolean(rawSlideOptions?.slideNumber) ?? initialSlideOptions.slideNumber
+  }
+}
+
+/**
+ * Parses an unknown variable into a boolean.
+ *
+ * @param rawData The raw data
+ * @return The parsed boolean or undefined if it's not possible to parse the data.
+ */
+const parseBoolean = (rawData: unknown | undefined): boolean | undefined => {
+  return rawData === undefined ? undefined : rawData === true
+}
+
+/**
+ * Parses an unknown variable into a number.
+ *
+ * @param rawData The raw data
+ * @return The parsed number or undefined if it's not possible to parse the data.
+ */
+const parseNumber = (rawData: unknown | undefined): number | undefined => {
+  if (rawData === undefined) {
+    return undefined
+  }
+  const numValue = Number(rawData)
+  return isNaN(numValue) ? undefined : numValue
+}

src/redux/note-details/raw-note-frontmatter-parser/types.d.ts

@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+export interface RawNoteFrontmatter {
+  title: string | undefined
+  description: string | undefined
+  tags: string | string[] | undefined
+  robots: string | undefined
+  lang: string | undefined
+  dir: string | undefined
+  breaks: boolean | undefined
+  GA: string | undefined
+  disqus: string | undefined
+  type: string | undefined
+  slideOptions: { [key: string]: string } | null
+  opengraph: { [key: string]: string } | null
+}

src/redux/note-details/reducer.ts

@@ -5,15 +5,15 @@
  */
 
 import type { Reducer } from 'redux'
-import type { PresentFrontmatterExtractionResult } from '../../components/common/note-frontmatter/types'
-import type { NoteFrontmatter } from '../../components/common/note-frontmatter/note-frontmatter'
-import { createNoteFrontmatterFromYaml } from '../../components/common/note-frontmatter/note-frontmatter'
-import type { NoteDetails, NoteDetailsActions } from './types'
+import { createNoteFrontmatterFromYaml } from './raw-note-frontmatter-parser/parser'
+import type { NoteDetailsActions } from './types'
 import { NoteDetailsActionType } from './types'
-import { extractFrontmatter } from '../../components/common/note-frontmatter/extract-frontmatter'
+import { extractFrontmatter } from './frontmatter-extractor/extractor'
 import type { NoteDto } from '../../api/notes/types'
 import { initialState } from './initial-state'
 import { DateTime } from 'luxon'
+import type { NoteDetails, NoteFrontmatter } from './types/note-details'
+import type { PresentFrontmatterExtractionResult } from './frontmatter-extractor/types'
 
 export const NoteDetailsReducer: Reducer<NoteDetails, NoteDetailsActions> = (
   state: NoteDetails = initialState,
@@ -75,7 +75,15 @@ const buildStateFromTaskListUpdate = (
  */
 const buildStateFromMarkdownContentUpdate = (state: NoteDetails, markdownContent: string): NoteDetails => {
   const frontmatterExtraction = extractFrontmatter(markdownContent)
-  if (!frontmatterExtraction.isPresent) {
+  if (frontmatterExtraction.isPresent) {
+    return buildStateFromFrontmatterUpdate(
+      {
+        ...state,
+        markdownContent: markdownContent
+      },
+      frontmatterExtraction
+    )
+  } else {
     return {
       ...state,
       markdownContent: markdownContent,
@@ -85,13 +93,6 @@ const buildStateFromMarkdownContentUpdate = (state: NoteDetails, markdownContent
       frontmatterRendererInfo: initialState.frontmatterRendererInfo
     }
   }
-  return buildStateFromFrontmatterUpdate(
-    {
-      ...state,
-      markdownContent: markdownContent
-    },
-    frontmatterExtraction
-  )
 }
 
 /**

src/redux/note-details/types.ts

@@ -4,11 +4,8 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { DateTime } from 'luxon'
 import type { Action } from 'redux'
-import type { NoteFrontmatter } from '../../components/common/note-frontmatter/note-frontmatter'
 import type { NoteDto } from '../../api/notes/types'
-import type { RendererFrontmatterInfo } from '../../components/common/note-frontmatter/types'
 
 export enum NoteDetailsActionType {
   SET_DOCUMENT_CONTENT = 'note-details/content/set',
@@ -16,28 +13,6 @@ export enum NoteDetailsActionType {
   UPDATE_NOTE_TITLE_BY_FIRST_HEADING = 'note-details/update-note-title-by-first-heading',
   UPDATE_TASK_LIST_CHECKBOX = 'note-details/update-task-list-checkbox'
 }
-interface LastChange {
-  userName: string
-  timestamp: DateTime
-}
-
-/**
- * Redux state containing the currently loaded note with its content and metadata.
- */
-export interface NoteDetails {
-  markdownContent: string
-  rawFrontmatter: string
-  frontmatter: NoteFrontmatter
-  frontmatterRendererInfo: RendererFrontmatterInfo
-  id: string
-  createTime: DateTime
-  lastChange: LastChange
-  viewCount: number
-  alias: string
-  authorship: string[]
-  noteTitle: string
-  firstHeading?: string
-}
 
 export type NoteDetailsActions =
   | SetNoteDocumentContentAction

src/redux/note-details/types/iso6391.ts

@@ -0,0 +1,210 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+export const ISO6391 = [
+  'aa',
+  'ab',
+  'af',
+  'am',
+  'ar',
+  'ar-ae',
+  'ar-bh',
+  'ar-dz',
+  'ar-eg',
+  'ar-iq',
+  'ar-jo',
+  'ar-kw',
+  'ar-lb',
+  'ar-ly',
+  'ar-ma',
+  'ar-om',
+  'ar-qa',
+  'ar-sa',
+  'ar-sy',
+  'ar-tn',
+  'ar-ye',
+  'as',
+  'ay',
+  'de-at',
+  'de-ch',
+  'de-li',
+  'de-lu',
+  'div',
+  'dz',
+  'el',
+  'en',
+  'en-au',
+  'en-bz',
+  'en-ca',
+  'en-gb',
+  'en-ie',
+  'en-jm',
+  'en-nz',
+  'en-ph',
+  'en-tt',
+  'en-us',
+  'en-za',
+  'en-zw',
+  'eo',
+  'es',
+  'es-ar',
+  'es-bo',
+  'es-cl',
+  'es-co',
+  'es-cr',
+  'es-do',
+  'es-ec',
+  'es-es',
+  'es-gt',
+  'es-hn',
+  'es-mx',
+  'es-ni',
+  'es-pa',
+  'es-pe',
+  'es-pr',
+  'es-py',
+  'es-sv',
+  'es-us',
+  'es-uy',
+  'es-ve',
+  'et',
+  'eu',
+  'fa',
+  'fi',
+  'fj',
+  'fo',
+  'fr',
+  'fr-be',
+  'fr-ca',
+  'fr-ch',
+  'fr-lu',
+  'fr-mc',
+  'fy',
+  'ga',
+  'gd',
+  'gl',
+  'gn',
+  'gu',
+  'ha',
+  'he',
+  'hi',
+  'hr',
+  'hu',
+  'hy',
+  'ia',
+  'id',
+  'ie',
+  'ik',
+  'in',
+  'is',
+  'it',
+  'it-ch',
+  'iw',
+  'ja',
+  'ji',
+  'jw',
+  'ka',
+  'kk',
+  'kl',
+  'km',
+  'kn',
+  'ko',
+  'kok',
+  'ks',
+  'ku',
+  'ky',
+  'kz',
+  'la',
+  'ln',
+  'lo',
+  'ls',
+  'lt',
+  'lv',
+  'mg',
+  'mi',
+  'mk',
+  'ml',
+  'mn',
+  'mo',
+  'mr',
+  'ms',
+  'mt',
+  'my',
+  'na',
+  'nb-no',
+  'ne',
+  'nl',
+  'nl-be',
+  'nn-no',
+  'no',
+  'oc',
+  'om',
+  'or',
+  'pa',
+  'pl',
+  'ps',
+  'pt',
+  'pt-br',
+  'qu',
+  'rm',
+  'rn',
+  'ro',
+  'ro-md',
+  'ru',
+  'ru-md',
+  'rw',
+  'sa',
+  'sb',
+  'sd',
+  'sg',
+  'sh',
+  'si',
+  'sk',
+  'sl',
+  'sm',
+  'sn',
+  'so',
+  'sq',
+  'sr',
+  'ss',
+  'st',
+  'su',
+  'sv',
+  'sv-fi',
+  'sw',
+  'sx',
+  'syr',
+  'ta',
+  'te',
+  'tg',
+  'th',
+  'ti',
+  'tk',
+  'tl',
+  'tn',
+  'to',
+  'tr',
+  'ts',
+  'tt',
+  'tw',
+  'uk',
+  'ur',
+  'us',
+  'uz',
+  'vi',
+  'vo',
+  'wo',
+  'xh',
+  'yi',
+  'yo',
+  'zh',
+  'zh-cn',
+  'zh-hk',
+  'zh-mo',
+  'zh-sg',
+  'zh-tw',
+  'zu'
+] as const

src/redux/note-details/types/note-details.ts

@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import type { DateTime } from 'luxon'
+import type { SlideOptions } from './slide-show-options'
+import type { ISO6391 } from './iso6391'
+
+/**
+ * Redux state containing the currently loaded note with its content and metadata.
+ */
+export interface NoteDetails {
+  markdownContent: string
+  rawFrontmatter: string
+  frontmatter: NoteFrontmatter
+  frontmatterRendererInfo: RendererFrontmatterInfo
+  id: string
+  createTime: DateTime
+  lastChange: {
+    userName: string
+    timestamp: DateTime
+  }
+  viewCount: number
+  alias: string
+  authorship: string[]
+  noteTitle: string
+  firstHeading?: string
+}
+
+export interface NoteFrontmatter {
+  title: string
+  description: string
+  tags: string[]
+  deprecatedTagsSyntax: boolean
+  robots: string
+  lang: typeof ISO6391[number]
+  dir: NoteTextDirection
+  newlinesAreBreaks: boolean
+  GA: string
+  disqus: string
+  type: NoteType
+  opengraph: Map<string, string>
+  slideOptions: SlideOptions
+}
+
+export enum NoteTextDirection {
+  LTR = 'ltr',
+  RTL = 'rtl'
+}
+
+export enum NoteType {
+  DOCUMENT = '',
+  SLIDE = 'slide'
+}
+
+export interface RendererFrontmatterInfo {
+  lineOffset: number
+  frontmatterInvalid: boolean
+  deprecatedSyntax: boolean
+  slideOptions: SlideOptions
+}

src/redux/note-details/types/slide-show-options.d.ts

@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2021 The HedgeDoc developers (see AUTHORS file)
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import type { RevealOptions } from 'reveal.js'
+
+type WantedRevealOptions = 'autoSlide' | 'autoSlideStoppable' | 'transition' | 'backgroundTransition' | 'slideNumber'
+
+export type SlideOptions = Required<Pick<RevealOptions, WantedRevealOptions>>