@windward/core 0.0.1

package/helpers/GlossaryHelper.ts

@@ -0,0 +1,137 @@
+import GlossaryTerm from "../helpers/GlossaryTerm";
+import * as _ from 'lodash'
+
+export default class GlossaryHelper {
+   private static glossaryRegex = /<span.*?.class="glossary-word".*?>(.*?)<\/span>/g
+   public static makeToolTip(term :GlossaryTerm,text :String): string {
+       let word =
+           _.isString(term.term)?
+       '<template v-slot:term>' +
+               text +
+       '</template>' :''
+       let definition =
+           _.isString(term.definition)?
+               '<template v-slot:definition>' +
+               term.definition +
+               '</template>' :''
+       let alternate_forms =
+           _.isString(term.alternate_forms)?
+               '<template v-slot:alternate_forms>' +
+               term.alternate_forms +
+               '</template>' :''
+       let related_terms =
+           _.isString(term.related_term)?
+               '<template v-slot:related_terms>' +
+               term.related_term +
+               '</template>' :''
+       return (
+           '<plugin-core-glossary-tool-tip>' +
+           word
+           +
+           definition
+           +
+           alternate_forms
+           +
+           related_terms
+           +
+           '</plugin-core-glossary-tool-tip>')
+
+    }
+    public static containsGlossaryTerms(content :string): boolean {
+        const regex = /<span.*?.class="glossary-word".*?>(.*?)<\/span>/g
+
+        return regex.exec(content) !== null
+    }
+
+    public static getContentVerifiedGlossaryTerms(content :string, glossary :any) {
+        const regex =  this.glossaryRegex
+        const currentGlossary = glossary
+
+        let match
+        const verifiedTerms: GlossaryTerm[] = []
+        while ((match = regex.exec(content)) !== null) {
+            // This is necessary to avoid infinite loops with zero-width matches
+            if (match.index === regex.lastIndex) {
+                regex.lastIndex++
+            }
+
+            // The result can be accessed through the `m`-variable.
+            currentGlossary.forEach((term) => {
+                let addTerm = true
+                verifiedTerms.forEach((verifiedTerm)=>{
+                    if(_.trim(_.toLower(verifiedTerm.term)) === _.trim(_.toLower(term.term))){
+                        addTerm = false
+                    }
+            })
+                if (_.trim(_.toLower(match[1]))=== _.trim(_.toLower(term.term)) && addTerm) {
+                    verifiedTerms.push(new GlossaryTerm(term))
+                }
+            })
+
+        }
+
+        return verifiedTerms
+    }
+
+    public static getContentUnVerifiedGlossaryTerms(content :string, glossary :any) {
+        const regex =  this.glossaryRegex
+
+        let match
+        const verifiedTerms = this.getContentVerifiedGlossaryTerms(content,glossary)
+        const unVerifiedTerms: GlossaryTerm[] = []
+        while ((match = regex.exec(content)) !== null) {
+            // This is necessary to avoid infinite loops with zero-width matches
+            if (match.index === regex.lastIndex) {
+                regex.lastIndex++
+            }
+
+            let inGlossary = []
+
+            inGlossary = glossary.filter(item =>  {
+                if(_.trim(_.toLower(item.term ))=== _.trim(_.toLower(match[1]))){
+                    return item
+
+                }
+            });
+
+            let inUnverifiedArray = false
+            unVerifiedTerms.forEach((unVerifiedTerm)=>{
+                if(_.trim(_.toLower(unVerifiedTerm.term)) ===  _.trim(_.toLower(match[1]))){
+                    inUnverifiedArray = true
+                }
+            })
+            if (  inGlossary.length===0 && !inUnverifiedArray){
+                unVerifiedTerms.push(new GlossaryTerm( {term:_.trim(match[1]),definition:'n/a'}))
+            }
+
+
+        }
+
+        return unVerifiedTerms
+    }
+    public static renderGlossaryWordsHtml(content :string, glossary :any) {
+        const regex =  this.glossaryRegex
+        const currentGlossary = glossary
+
+        let match
+        while ((match = regex.exec(content)) !== null) {
+            // This is necessary to avoid infinite loops with zero-width matches
+            if (match.index === regex.lastIndex) {
+                regex.lastIndex++
+            }
+
+            // The result can be accessed through the `m`-variable.
+                currentGlossary.forEach((term) => {
+                    if (_.trim(_.toLower(match[1]))=== _.trim(_.toLower(term.term))) {
+                        content = content.replace(
+                            match[0],
+                            this.makeToolTip(term,match[1])
+                        )
+                    }
+                })
+
+        }
+
+        return content
+    }
+}

package/helpers/GlossaryTerm.ts

@@ -0,0 +1,31 @@
+class GlossaryTerm {
+
+    term!: string
+
+    definition!: string
+
+    alternate_forms: any = null
+
+    related_term: any =null
+
+    private required: string[] = ['term', 'definition']
+
+    constructor(params: any) {
+        this.required.forEach((field) => {
+            if (!params[field]) {
+                throw new Error('Glossary term ' + field + ' is required')
+            }
+        })
+
+        this.term = params.term
+        this.definition = params.definition
+        this.alternate_forms = params.alternate_forms || null
+        this.related_term = params.related_term || null
+    }
+
+    public static toString(){
+
+    }
+}
+
+export default GlossaryTerm

package/helpers/MathHelper.ts

@@ -0,0 +1,236 @@
+import * as mathLiveObject from 'mathlive'
+import * as _ from 'lodash'
+const Mathml2latex = require('mathml-to-latex');
+export default class MathHelper {
+    /**
+     * expose mathlive object
+     */
+    public static Mathlive = mathLiveObject
+
+    /**
+     * containsMathML
+     * @param content
+     * checks is string contains mathml
+     * @return boolean
+     *
+     */
+    public static containsMathML(content: string): boolean {
+        const regex = /\<math.*?>.*?<\/math>/s
+
+        return regex.exec(content) !== null
+    }
+
+    /**
+     * containsLatex
+     * @param content
+     * checks is string contains latex
+     * @return boolean
+     *
+     */
+    public static containsLatex(content: string): boolean {
+        const regex = /\$\$.*?\$\$/g
+
+        return regex.exec(content) !== null
+    }
+
+    /**
+     * containSREnhancedLatex
+     * @param content
+     * checks is string contains latex
+     * @return boolean
+     *
+     */
+    public static containSREnhancedLatex(content: string): boolean {
+        const regex = /\*\*.*?\*\*/g
+
+        return regex.exec(content) !== null
+    }
+
+    /**
+     * convertMathMLToLatex
+     * @param content
+     * attempts to find mml in content string and replace it with latex equivalent
+     * @return string
+     */
+    public static convertContentMathMLtoLatex(content: string): string {
+        const regex = /\<math.*?>.*?<\/math>/g
+        const matches = content.match(regex)
+        if (matches) {
+            matches.forEach((match) => {
+                content = content.replace(
+                    match,
+                    `$$$` + Mathml2latex.convert(match) + '$$$'
+                )
+            })
+        }
+
+        return content
+    }
+
+    /**
+     * wrapMathContentForTinyMCE
+     * @param content
+     * wrap content in span with math class for tinymce
+     * @return string
+     */
+    public static wrapMathContentForTinyMCE(content: string): string {
+        const regex = /(\*\*|\$\$)(.*?)\1/g
+        const matches = content.match(regex)
+        if (matches) {
+            matches.forEach((match) => {
+                const temp = match.replace(/\$\$/g, '')
+                if (match.match(/\$\$.*?\$\$/g) !== null) {
+                    content = content.replace(
+                        match,
+                        "<span class ='windward-math-content'>$$$" +
+                            temp +
+                            '$$$</span>'
+                    )
+                }
+                if (match.match(/\*\*(.*?)\*\*/g) !== null) {
+                    content = content.replace(
+                        match,
+                        "<span class ='windward-math-content'>" +
+                            match +
+                            '</span>'
+                    )
+                }
+            })
+        }
+
+        return content
+    }
+
+    /**
+     * check Math Content Wrapped For TMCE
+     * @param content
+     * checks all content
+     * @return string
+     */
+    public static checkMathContentWrappedForTMCE(content: string): boolean {
+        const regex =
+            /\<span class ='windward-math-content'>(\*\*|\$\$)(.*?)\1<\/span>/g
+
+        return regex.exec(content) !== null
+    }
+
+    /**
+     * convertContentLatexToHtml
+     * @param content
+     * attempts to find latex in content string and replace it with latex equivalent
+     * @return string
+     *
+     */
+    public static convertContentLatexToHtml(content: string): string {
+        const regex = /\$\$.*?\$\$/g
+
+        const matches = content.match(regex)
+        if (matches) {
+            matches.forEach((match) => {
+                content = content.replace(
+                    match,
+                    '<span tabindex="0"  aria-label="' +
+                        // @ts-ignore
+                        mathLiveObject.convertLatexToSpeakableText(match) +
+                        '"> <span tabindex="-1" >' +
+                        mathLiveObject.convertLatexToMarkup(_.unescape(match)) +
+                        '</span></span>'
+                )
+            })
+        }
+
+        return content
+    }
+
+    /**
+     * convertContentSREnhancedLatexToHtml
+     * @param content
+     * attempts to find latex in content string and place custom SR text on renderer math div
+     * @return string
+     *
+     */
+    public static convertContentSREnhancedLatexToHtml(content: string): string {
+        const regex = /\*\*.*?\*\*/g
+
+        const matches = content.match(regex)
+        if (matches) {
+            matches.forEach((match: any) => {
+                const mathObject = JSON.parse(match.replace(/\*\*/g, ''))
+                content = content.replace(
+                    match,
+                    '<span tabindex="0"  aria-label="' +
+                        mathObject.sr_text +
+                        '"> <span tabindex="-1" >' +
+                        mathLiveObject.convertLatexToMarkup(
+                            '$$' + _.unescape(mathObject.latex) + '$$'
+                        ) +
+                        '</span></span>'
+                )
+            })
+        }
+
+        return content
+    }
+
+    /**
+     * convertMathContentToHtml
+     * @param content
+     * attempts to find any math format in content string and  convert it to HTML
+     * @return string
+     *
+     */
+    public static convertMathContentToHtml(content: string): string {
+        return MathHelper.convertContentSREnhancedLatexToHtml(
+            MathHelper.convertContentLatexToHtml(
+                MathHelper.convertContentMathMLtoLatex(content)
+            )
+        )
+    }
+
+    /**
+     * convertMathMLToLatex
+     * @param content
+     * converts mml to latex
+     *
+     */
+    public static convertMathMLToLatex(content: string): string {
+        return Mathml2latex.convert(content)
+    }
+
+    /**
+     * parseSREnhancedLatexString
+     * @param content
+     * parse SR enhanced latex string and return Object
+     * @return Object
+     *
+     */
+    public static parseSREnhancedLatexString(content: string): object {
+        const regex = /\*\*.*?\*\*/g
+
+        const matches = content.match(regex)
+        if (matches) {
+            const mathobject = JSON.parse(matches[0].replace(/\*\*/g, ''))
+            return mathobject
+        }
+
+        return {}
+    }
+
+    /**
+     * parseSRLatex
+     * @param content
+     * parse latex expression from string
+     * @return any
+     *
+     */
+    public static parseLatexString(content: string): string {
+        const regex = /\$\$.*?\$\$/g
+
+        const matches = content.match(regex)
+        if (matches) {
+            return matches[0].replace(/\$\$/g, '')
+        }
+
+        return ''
+    }
+}

package/helpers/tinymce/plugin.ts

@@ -0,0 +1,83 @@
+const MathEditorPlugin = function (editor: any) {
+    let formula: any
+    // ----- Events ----- //
+
+    editor.addCommand('equation-window', function (data: any) {
+        return editor.windowManager.openUrl({
+            url: '/plugins/tinymce/math',
+            title: 'Equation editor',
+            width: 800,
+            height: 600,
+            buttons: [
+                {
+                    type: 'cancel',
+                    text: 'cancel',
+                },
+                {
+                    type: 'custom',
+                    text: 'submit',
+                    primary: true,
+                },
+            ],
+            onAction: () => {
+                if (data.currentTarget) {
+                    editor.selection.select(data.currentTarget);
+                }
+                editor.selection.setContent(
+                    `        <span class='windward-math-content'>` +
+                        formula +
+                        `</span>`
+                )
+
+                editor.windowManager.close()
+                setOnClickEquationContent(editor)
+            },
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            onMessage: (instance: any, message: any) => {
+                switch (message.mceAction) {
+                    case 'equation-insert':
+                        formula = message.content
+                        break
+                    case 'math-plugin-mounted':
+                        window.parent.postMessage({ latex: data.latex }, '*')
+                        break
+                }
+            },
+        })
+    })
+
+    editor.ui.registry.addButton('MathEditor', {
+        text: 'Math Editor',
+        icon: 'gamma',
+        onAction: () => {
+            editor.execCommand('equation-window', true)
+        },
+    })
+    editor.on('init', function () {
+        setOnClickEquationContent(editor)
+    })
+    function setOnClickEquationContent(editor: any) {
+        const tinymceDoc = editor.getDoc()
+        const mqSpan = tinymceDoc.getElementsByClassName(
+            'windward-math-content'
+        )
+
+        // Add onclick listener to all equation content
+        for (const equationContent of mqSpan) {
+            equationContent.contentEditable = 'true'
+            if (equationContent.onclick) {
+                continue
+            }
+
+            equationContent.onclick = (event: any) => {
+                event.stopPropagation()
+                editor.execCommand('equation-window', {
+                    latex: event.target.innerText,
+                    currentTarget: event.target,
+                })
+            }
+        }
+    }
+}
+
+export { MathEditorPlugin }

package/i18n/en-US/components/content/blocks/feedback.ts

@@ -0,0 +1,28 @@
+export default {
+    feedback: 'Feedback',
+    course: 'Course',
+    module: 'Module',
+    preset: 'Presets',
+    likert: 'Add standart likert questions',
+    contact_mindedge: 'Contact Mindedge question',
+    open_response: 'Open Response',
+    response_prompt: 'Provide course feedback below',
+    no_response_entered: 'No response entered',
+    required: 'You must select an option to submit',
+    save: 'Send Feedback',
+    reset: 'Reset',
+    fill_out: 'Please fill out all fields',
+    yes: 'Yes',
+    no: 'No',
+    description:
+        "This feedback form is optional. However, we would love to hear your thoughts on this learning experience. We take your feedback very seriously, reading and reviewing each entry every day, and we are always trying to improve. Thank you for any comments you'd like to share.",
+    sent_feedback:
+        'Thank you for submitting feedback. Your input is very important and valuable to us. If you suggested improvements in your comments, we will consider those suggestions seriously. Course quality and usability are our highest priorities.',
+    scale: {
+        strongly_agree: 'Stronly Agree',
+        agree: 'Agree',
+        neutral: 'Neutral',
+        disagree: 'Disagree',
+        strongly_disagree: 'Strong Disagree',
+    },
+}

package/i18n/en-US/components/content/blocks/image.ts

@@ -0,0 +1,5 @@
+export default {
+    title: 'Pick an image',
+    description: 'Pick an image to display',
+    no_image_url: 'No Image Selected',
+}

package/i18n/en-US/components/content/blocks/index.ts

@@ -0,0 +1,15 @@
+import user_upload from './user_upload'
+import image from './image'
+import video from './video'
+import table from './table'
+import tab from './tab'
+import feedback from './feedback'
+
+export default {
+    user_upload,
+    image,
+    video,
+    table,
+    tab,
+    feedback,
+}

package/i18n/en-US/components/content/blocks/tab.ts

@@ -0,0 +1,4 @@
+export default {
+    add_tab: 'Add Tab',
+    delete_tab: 'Delete Tab'
+}

package/i18n/en-US/components/content/blocks/table.ts

@@ -0,0 +1,4 @@
+export default {
+    column: 'column',
+    row: 'cell',
+}

package/i18n/en-US/components/content/blocks/user_upload.ts

@@ -0,0 +1,12 @@
+export default {
+    user_uploads: 'User Uploads',
+    dialog_view: 'View Uploads',
+    instructions: 'Instructions:',
+    instructions_none: 'None',
+    instructions_title: 'Student instructions:',
+    must_save: 'You must save this block before users can make uploads',
+    uploaded: 'Uploaded',
+    name: 'Name',
+    size: 'Size',
+    download: 'Download',
+}

package/i18n/en-US/components/content/blocks/video.ts

@@ -0,0 +1,53 @@
+export default {
+    tabs: {
+        video: 'Video',
+        poster: 'Poster',
+        preroll: 'Preroll',
+        postroll: 'Postroll',
+    },
+    forms: {
+        unsaved: 'You have unsaved changes. Would you like to save them?',
+        cancel: 'Cancel',
+        confirm: 'Confirm',
+    },
+    video: {
+        title: 'Video File',
+        configure_blurb:
+            'Upload a video file (.mp4 or .webm), pick one from the file manager, or add via the public URL',
+        not_configured_title: 'Video not configured',
+        edit_prompt: 'Edit this block to get started',
+        autoplay: 'Autoplay on load',
+        controls: 'Show Controls',
+        loop: 'Loop video',
+        muted: 'Start muted',
+        disablepictureinpicture: 'Disable picture-in-picture button',
+        poster: 'Video poster',
+        playback_rates: 'Playback Rates',
+        rewind: 'Allow 10 Second Rewind',
+        playsinline: 'Disable fullscreen and force inline viewing',
+        captionsmenu: 'Show the interactive captions menu',
+        playlistmenu:
+            'Show playlist menu (Requires more than 1 video selected to show)',
+        playlistautoadvance: 'Auto-advance the playlist on media end',
+    },
+    caption: {
+        title: 'Captions File',
+        configure_blurb:
+            'Upload a captions file (.vtt or .xml), pick one from the file manager, or add via the public URL',
+    },
+    poster: {
+        title: 'Poster Image File',
+        configure_blurb:
+            'Upload a poster file (.png or .jpg), pick one from the file manager, or add via the public URL. This is the image that appears before the video is played.',
+    },
+    preroll: {
+        title: 'Preroll Video File',
+        configure_blurb:
+            'Upload a preroll video file (.mp4 or .webm), pick one from the file manager, or add via the public URL',
+    },
+    postroll: {
+        title: 'Postroll Video File',
+        configure_blurb:
+            'Upload a postroll video file (.mp4 or .webm), pick one from the file manager, or add via the public URL',
+    },
+}

package/i18n/en-US/components/content/index.ts

@@ -0,0 +1,5 @@
+import blocks from './blocks'
+
+export default {
+    blocks,
+}

package/i18n/en-US/components/index.ts

@@ -0,0 +1,12 @@
+import content from './content'
+import settings from './settings'
+import navigation from './navigation/index'
+import utils from './utils/index'
+
+
+export default {
+    content,
+    settings,
+    navigation,
+    utils,
+}

package/i18n/en-US/components/navigation/image.ts

@@ -0,0 +1,4 @@
+export default {
+    default_alt: 'Alt text',
+    default_aria_described: 'Aria described by',
+}

package/i18n/en-US/components/navigation/index.ts

@@ -0,0 +1,7 @@
+import user_upload from './user_upload'
+import image from './image'
+
+export default {
+    user_upload,
+    image,
+}

package/i18n/en-US/components/navigation/user_upload.ts

@@ -0,0 +1,3 @@
+export default {
+    title: 'User Uploads',
+}

package/i18n/en-US/components/settings/clickable_icon.ts

@@ -0,0 +1,9 @@
+export default {
+    title: 'Title',
+    description: 'Description',
+    information: 'Click on each of the list items below for more information.',
+    item_icon: 'Item {0} icon',
+    item_title: 'Item Title',
+    item_color: 'Item Color',
+    item_text: 'Item Text',
+}

package/i18n/en-US/components/settings/image.ts

@@ -0,0 +1 @@
+export default {}

package/i18n/en-US/components/settings/index.ts

@@ -0,0 +1,13 @@
+import image from './image'
+import user_upload from './user_upload'
+import text_editor from './text_editor'
+import video from './video'
+import clickable_icon from './clickable_icon'
+
+export default {
+    image,
+    user_upload,
+    text_editor,
+    video,
+    clickable_icon
+}