bare-script 3.0.14 → 3.1.0

package/lib/include/markdownUp.bare

@@ -0,0 +1,466 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/markdown-up/blob/main/LICENSE
+
+
+# Include sentinel
+if systemGlobalGet('markdownUpSentinel'):
+    return
+endif
+markdownUpSentinel = true
+
+
+# Constants
+markdownUpPixelsPerPoint = 4 / 3
+markdownUpDefaultFontSizePx = 12 * markdownUpPixelsPerPoint
+markdownUpFontWidthRatio = 0.6
+markdownUpWindowHeight = 768
+markdownUpWindowWidth = 1024
+
+
+# The simulated MarkdownUp state
+markdownUpState = objectNew( \
+    'drawingFontSizePx', markdownUpDefaultFontSizePx, \
+    'drawingHeight', 480, \
+    'drawingWidth', 640, \
+    'localStorage', objectNew(), \
+    'sessionStorage', objectNew(), \
+    'windowClipboard', '' \
+)
+
+
+#
+# Data functions
+#
+
+
+function dataLineChart(data, lineChart):
+    width = objectGet(lineChart, 'width', 640)
+    height = objectGet(lineChart, 'height', 320)
+    title = objectGet(lineChart, 'title')
+    systemLog('')
+    systemLog('<LineChart ' + width + 'x' + height + ', ' + arrayLength(data) + ' rows' + if(title, ' - ' + title, '') + '>')
+endfunction
+
+
+function dataTable(data, model):
+    # Validate the data
+    data = dataValidate(data)
+    if data == null:
+        return
+    endif
+
+    # Determine the table fields
+    fields = arrayNew()
+    modelFields = if(model != null, objectGet(model, 'fields'))
+    modelCategories = if(model != null, objectGet(model, 'categories'))
+    if modelFields != null || modelCategories != null:
+        arrayExtend(fields, modelCategories)
+        arrayExtend(fields, modelFields)
+    elif arrayLength(data) > 0:
+        arrayExtend(fields, objectKeys(arrayGet(data, 0)))
+    endif
+    if !arrayLength(fields):
+        return
+    endif
+
+    # Get precision and formatting
+    precisionDatetime = if(model != null, objectGet(model, 'datetime'))
+    precisionNumber = if(model != null, objectGet(model, 'precision', 2), 2)
+    precisionTrim = if(model != null, objectGet(model, 'trim', true), true)
+    formats = if(model != null, objectGet(model, 'formats'))
+
+    # Compute the field header widths
+    widths = objectNew()
+    for field in fields:
+        fieldWidth = stringLength(field)
+        if !objectHas(widths, field) || fieldWidth > objectGet(widths, field):
+            objectSet(widths, field, fieldWidth)
+        endif
+    endfor
+
+    # Compute the formatted field value strings and widths
+    dataFormat = arrayNew()
+    for row in data:
+        rowFormat = objectNew()
+        arrayPush(dataFormat, rowFormat)
+        for field in fields:
+            # Format the value
+            value = objectGet(row, field)
+            valueType = systemType(value)
+            if valueType == 'string':
+                valueFormat = value
+            elif valueType == 'number':
+                valueFormat = numberToFixed(value, precisionNumber, precisionTrim)
+            elif valueType == 'datetime':
+                valueFormat = datetimeISOFormat(value, precisionDatetime != null)
+            else:
+                valueFormat = stringNew(value)
+            endif
+            objectSet(rowFormat, field, valueFormat)
+
+            # Update the field width
+            valueWidth = stringLength(valueFormat)
+            if !objectHas(widths, field) || valueWidth > objectGet(widths, field):
+                objectSet(widths, field, valueWidth)
+            endif
+        endfor
+    endfor
+
+    # Compute the field header separator
+    headerSeparator = ''
+    for field in fields:
+        width = objectGet(widths, field)
+        format = if(formats != null, objectGet(formats, field))
+        align = if(format != null, objectGet(format, 'align'))
+        headerSeparator = headerSeparator + '+=' + markdownUpValueField('', width, align, '=') + '='
+    endfor
+    headerSeparator = headerSeparator + '+'
+
+    # Compute the table header fields
+    headerFields = ''
+    for field in fields:
+        width = objectGet(widths, field)
+        format = if(formats != null, objectGet(formats, field))
+        align = if(format != null, objectGet(format, 'align'))
+        header = if(format != null, objectGet(format, 'header', field), field)
+        headerFields = headerFields + '| ' + markdownUpValueField(header, width, align, ' ') + ' '
+    endfor
+    headerFields = headerFields + '|'
+
+    # Output the table header
+    systemLog('')
+    systemLog(headerSeparator)
+    systemLog(headerFields)
+    systemLog(headerSeparator)
+
+    # Output each row
+    for row in dataFormat:
+        line = ''
+        for field in fields:
+            width = objectGet(widths, field)
+            format = if(formats != null, objectGet(formats, field))
+            align = if(format != null, objectGet(format, 'align'))
+            line = line + '| ' + markdownUpValueField(objectGet(row, field), width, align, ' ') + ' '
+        endfor
+        line = line + '|'
+        systemLog(line)
+    endfor
+
+    # Output the table footer
+    systemLog(headerSeparator)
+endfunction
+
+
+function markdownUpValueField(value, width, align, fill):
+    spaces = width - stringLength(value)
+    if align == 'right':
+        return stringRepeat(fill, spaces) + value
+    elif align == 'center':
+        spacesLeft = mathFloor(spaces / 2)
+        spacesRight = spaces - spacesLeft
+        return stringRepeat(fill, spacesLeft) + value + stringRepeat(fill, spacesRight)
+    endif
+    return value + stringRepeat(fill, spaces)
+endfunction
+
+
+#
+# Document functions
+#
+
+
+function documentFontSize():
+    return markdownUpDefaultFontSizePx
+endfunction
+
+
+function documentInputValue():
+endfunction
+
+
+function documentSetFocus():
+endfunction
+
+
+function documentSetReset():
+endfunction
+
+
+function documentSetTitle():
+endfunction
+
+
+function documentURL(url):
+    return url
+endfunction
+
+
+#
+# Drawing functions
+#
+
+
+function drawArc():
+endfunction
+
+
+function drawCircle():
+endfunction
+
+
+function drawClose():
+endfunction
+
+
+function drawEllipse():
+endfunction
+
+
+function drawHLine():
+endfunction
+
+
+function drawHeight():
+    return objectGet(markdownUpState, 'drawingHeight')
+endfunction
+
+
+function drawImage():
+endfunction
+
+
+function drawLine():
+endfunction
+
+
+function drawMove():
+endfunction
+
+
+function drawNew(width, height):
+    objectSet(markdownUpState, 'drawingWidth', width)
+    objectSet(markdownUpState, 'drawingHeight', height)
+    systemLog('')
+    systemLog('<Drawing ' + width + 'x' + height + '>')
+endfunction
+
+
+function drawOnClick():
+endfunction
+
+
+function drawPathRect():
+endfunction
+
+
+function drawRect():
+endfunction
+
+
+function drawStyle():
+endfunction
+
+
+function drawText():
+endfunction
+
+
+function drawTextHeight(text, width):
+    if width > 0:
+        return width / (markdownUpFontWidthRatio * stringLength(text))
+    endif
+    return objectGet(markdownUpState, 'drawingFontSizePx')
+endfunction
+
+
+function drawTextStyle(fontSizePx):
+    objectSet(markdownUpState, 'drawingFontSizePx', if(fontSizePx != null, fontSizePx, markdownUpDefaultFontSizePx))
+endfunction
+
+
+function drawTextWidth(text, fontSizePx):
+    return markdownUpFontWidthRatio * fontSizePx * stringLength(text)
+endfunction
+
+
+function drawVLine():
+endfunction
+
+
+function drawWidth():
+    return objectGet(markdownUpState, 'drawingWidth')
+endfunction
+
+
+#
+# Element Model functions
+#
+
+
+function elementModelRender():
+endfunction
+
+
+#
+# Local storage functions
+#
+
+
+function localStorageClear():
+    objectSet(markdownUpState, 'localStorage', objectNew())
+endfunction
+
+
+function localStorageGet(key):
+    return objectGet(objectGet(markdownUpState, 'localStorage'), key)
+endfunction
+
+
+function localStorageRemove(key):
+    objectDelete(objectGet(markdownUpState, 'localStorage'), key)
+endfunction
+
+
+function localStorageSet(key, value):
+    objectSet(objectGet(markdownUpState, 'localStorage'), key, value)
+endfunction
+
+
+#
+# Markdown functions
+#
+
+
+function markdownEscape(text):
+    return regexReplace(markdownUp_markdownEscapeRegex, text, '\\$1')
+endfunction
+
+markdownUp_markdownEscapeRegex = regexNew('([\\\\[\\]()<>"\'*_~`#=+|-])')
+
+
+function markdownHeaderId(text):
+    result = stringLower(text)
+    result = regexReplace(markdownUp_markdownHeaderId_start, result, '')
+    result = regexReplace(markdownUp_markdownHeaderId_end, result, '')
+    result = regexReplace(markdownUp_markdownHeaderId_remove, result, '')
+    return regexReplace(markdownUp_markdownHeaderId_dash, result, '-')
+endfunction
+
+markdownUp_markdownHeaderId_start = regexNew('^[^a-z0-9]+')
+markdownUp_markdownHeaderId_end = regexNew('[^a-z0-9]+$')
+markdownUp_markdownHeaderId_remove = regexNew('[\'"]')
+markdownUp_markdownHeaderId_dash = regexNew('[^a-z0-9]+')
+
+
+function markdownParse():
+endfunction
+
+
+function markdownPrint(lines...):
+    markdownUp_markdownPrintHelper(lines)
+endfunction
+
+function markdownUp_markdownPrintHelper(lines):
+    for line in lines:
+        if systemType(line) == 'array':
+            markdownUp_markdownPrintHelper(line)
+        else:
+            systemLog(line)
+        endif
+    endfor
+endfunction
+
+
+function markdownTitle():
+endfunction
+
+
+#
+# Schema functions
+#
+
+
+function schemaElements(types, typeName):
+    userType = objectGet(types, typeName)
+    userTypeKey = arrayGet(objectKeys(userType), 0)
+    if userTypeKey == 'struct' && objectGet(objectGet(userType, 'struct'), 'union'):
+        userTypeKey = 'union'
+    endif
+    return arrayNew( \
+        arrayNew( \
+            objectNew('html', 'h1', 'elem', objectNew('text', userTypeKey + ' ' + typeName)) \
+        ) \
+    )
+endfunction
+
+
+#
+# Session storage functions
+#
+
+
+function sessionStorageClear():
+    objectSet(markdownUpState, 'sessionStorage', objectNew())
+endfunction
+
+
+function sessionStorageGet(key):
+    return objectGet(objectGet(markdownUpState, 'sessionStorage'), key)
+endfunction
+
+
+function sessionStorageRemove(key):
+    objectDelete(objectGet(markdownUpState, 'sessionStorage'), key)
+endfunction
+
+
+function sessionStorageSet(key, value):
+    objectSet(objectGet(markdownUpState, 'sessionStorage'), key, value)
+endfunction
+
+
+#
+# URL functions
+#
+
+
+function urlObjectCreate(data, contentType):
+    return 'blob:' + urlEncode(contentType) + '-' + urlEncode(if(stringLength(data) < 20, data, stringSlice(data, 0, 20)))
+endfunction
+
+
+#
+# Window functions
+#
+
+
+function windowClipboardRead():
+    return objectGet(markdownUpState, 'windowClipboard')
+endfunction
+
+
+function windowClipboardWrite(text):
+    return objectSet(markdownUpState, 'windowClipboard', text)
+endfunction
+
+
+function windowHeight():
+    return markdownUpWindowHeight
+endfunction
+
+
+function windowSetLocation():
+endfunction
+
+
+function windowSetResize():
+endfunction
+
+
+function windowSetTimeout():
+endfunction
+
+
+function windowWidth():
+    return markdownUpWindowWidth
+endfunction

package/lib/include/pager.mds

@@ -0,0 +1,235 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/markdown-up/blob/main/LICENSE
+
+include <args.mds>
+
+
+# Include sentinel
+if systemGlobalGet('pagerSentinel'):
+    return
+endif
+pagerSentinel = true
+
+
+# The pager model
+pagerTypes = schemaParse( \
+    'group "Pager"', \
+    '', \
+    '', \
+    '# A pager application model', \
+    'struct Pager', \
+    '', \
+    "    # The application's pages", \
+    '    PagerPage[len > 0] pages', \
+    '', \
+    '', \
+    '# A page model', \
+    'struct PagerPage', \
+    '', \
+    '    # The page name', \
+    '    string name', \
+    '', \
+    '    # If true, the page is hidden', \
+    '    optional bool hidden', \
+    '', \
+    '    # The page type', \
+    '    PagerPageType type', \
+    '', \
+    '', \
+    '# The page type', \
+    'union PagerPageType', \
+    '', \
+    '    # A function page', \
+    '    PagerPageFunction function', \
+    '', \
+    '    # A markdown resource page', \
+    '    PagerPageMarkdown markdown', \
+    '', \
+    '    # A navigation link', \
+    '    PagerPageLink link', \
+    '', \
+    '', \
+    '# A page function', \
+    'struct PagerPageFunction', \
+    '', \
+    '    # The page function', \
+    '    object function', \
+    '', \
+    '    # The page title', \
+    '    optional string title', \
+    '', \
+    '', \
+    '# A Markdown resource page', \
+    'struct PagerPageMarkdown', \
+    '', \
+    '    # The Markdown resource URL', \
+    '    string url', \
+    '', \
+    '', \
+    '# A page link', \
+    'struct PagerPageLink', \
+    '', \
+    '    # The link URL', \
+    '    string url' \
+)
+
+
+# $function: pagerValidate
+# $group: pager.mds
+# $doc: Validate a pager model
+# $arg pagerModel: The [pager model](includeModel.html#var.vName='Pager')
+# $return: The validated [pager model](includeModel.html#var.vName='Pager') or null if validation fails
+function pagerValidate(pagerModel):
+    return schemaValidate(pagerTypes, 'Pager', pagerModel)
+endfunction
+
+
+# $function: pagerMain
+# $group: pager.mds
+# $doc: The pager application main entry point
+# $arg pagerModel: The [pager model](includeModel.html#var.vName='Pager')
+# $arg options: The pager application options. The following options are available:
+# $arg options: - **arguments** - The [arguments model](includeModel.html#var.vName='ArgsArguments').
+# $arg options:   Must contain a string argument named "page".
+# $arg options: - **hideMenu** - Hide the menu links
+# $arg options: - **hideNav** - Hide the navigation links
+# $arg options: - **start** - The start page name
+async function pagerMain(pagerModel, options):
+    if options == null:
+        options = objectNew()
+    endif
+
+    # Validate the pager model
+    pagerModel = pagerValidate(pagerModel)
+    if pagerModel == null:
+        return
+    endif
+
+    # Compute the visible and navigable pages
+    pages = objectGet(pagerModel, 'pages')
+    visiblePages = arrayNew()
+    navPages = arrayNew()
+    for page in pages:
+        # Visible page?
+        if !objectGet(page, 'hidden'):
+            arrayPush(visiblePages, page)
+
+            # Navigable page?
+            pageTypeKey = arrayGet(objectKeys(objectGet(page, 'type')), 0)
+            if pageTypeKey != 'link':
+                arrayPush(navPages, page)
+            endif
+        endif
+    endfor
+
+    # Parse arguments
+    startPageName = objectGet(options, 'start', if(arrayLength(navPages), objectGet(arrayGet(navPages, 0), 'name'), null))
+    if objectHas(options, 'arguments'):
+        arguments = argsValidate(objectGet(options, 'arguments'))
+        if arguments == null:
+            return
+        endif
+    else:
+        arguments = arrayNew(objectNew('name', 'page', 'default', startPageName))
+    endif
+    args = argsParse(arguments)
+
+    # Determine the current page
+    curPage = null
+    startPage = null
+    for page in pages:
+        if objectGet(page, 'name') == objectGet(args, 'page'):
+            curPage = page
+        endif
+        if objectGet(page, 'name') == startPageName:
+            startPage = page
+        endif
+    endfor
+    if startPage == null:
+        systemLogDebug('MarkdownUp - pager.mds: Unknown start page' + if(startPageName != null, '"' + startPageName + '"', ''))
+        return
+    endif
+    if curPage == null:
+        curPage = startPage
+    endif
+
+    # Determine the current page's navigable index, if any
+    ixCurPage = -1
+    for navPage, ixNavPage in navPages:
+        if objectGet(navPage, 'name') == objectGet(curPage, 'name'):
+            ixCurPage = ixNavPage
+            break
+        endif
+    endfor
+
+    # Render the menu
+    if !objectGet(options, 'hideMenu'):
+        for page, ixPage in visiblePages:
+            pageName = objectGet(page, 'name')
+            pageType = objectGet(page, 'type')
+            pageTypeKey = arrayGet(objectKeys(pageType), 0)
+
+            # Render the menu link
+            pageNameNbsp = stringReplace(pageName, ' ', '&nbsp;')
+            separator = if(ixPage != arrayLength(visiblePages) - 1, '&nbsp;|', '')
+            if pageTypeKey == 'link':
+                pageLinkURL = objectGet(objectGet(pageType, 'link'), 'url')
+                markdownPrint('[' + markdownEscape(pageNameNbsp) + '](' + urlEncode(pageLinkURL) + ')' + separator)
+            elif pageName == objectGet(curPage, 'name'):
+                markdownPrint(markdownEscape(pageNameNbsp) + separator)
+            else:
+                markdownPrint(argsLink(arguments, pageNameNbsp, objectNew('page', pageName)) + separator)
+            endif
+        endfor
+        markdownPrint('')
+    endif
+
+    # Render the start/next/prev buttons
+    if !objectGet(options, 'hideNav') && arrayLength(navPages) > 1 && ixCurPage != -1:
+        if startPageName == objectGet(curPage, 'name'):
+            startPageName = null
+        endif
+        prevPageName = if(ixCurPage != -1 && ixCurPage - 1 >= 0, objectGet(arrayGet(navPages, ixCurPage - 1), 'name'), null)
+        nextPageName = if(ixCurPage != -1 && ixCurPage + 1 < arrayLength(navPages), objectGet(arrayGet(navPages, ixCurPage + 1), 'name'), null)
+        markdownPrint( \
+            '(&nbsp;' + if(startPageName != null, argsLink(arguments, 'Start', objectNew('page', startPageName)), 'Start') + '&nbsp;|', \
+            if(prevPageName != null, argsLink(arguments, 'Previous', objectNew('page', prevPageName)), 'Previous') + '&nbsp;|', \
+            if(nextPageName != null, argsLink(arguments, 'Next', objectNew('page', nextPageName)), 'Next') + '&nbsp;)', \
+            '' \
+        )
+    endif
+
+    # Function page?
+    curPageType = objectGet(curPage, 'type')
+    curPageTypeKey = arrayGet(objectKeys(curPageType), 0)
+    if curPageTypeKey == 'function':
+        # Set the title
+        title = objectGet(objectGet(curPageType, 'function'), 'title')
+        if title != null:
+            documentSetTitle(title)
+            markdownPrint('# ' + markdownEscape(title), '')
+        endif
+
+        # Call the page function
+        pageFn = objectGet(objectGet(curPageType, 'function'), 'function')
+        pageFn(args)
+    elif curPageTypeKey == 'markdown':
+        # Fetch the Markdown text
+        url = objectGet(objectGet(curPageType, 'markdown'), 'url')
+        markdownText = systemFetch(url)
+        if markdownText == null:
+            markdownPrint('**Error:** Failed to load "' + url + '"')
+        else:
+            # Compute and set the page title
+            markdownModel = markdownParse(markdownText)
+            title = markdownTitle(markdownModel)
+            if title == null:
+                title = 'No Title'
+            endif
+            documentSetTitle(title)
+
+            # Render the Markdown text
+            markdownPrint('', markdownText)
+        endif
+    endif
+endfunction