@servicenow/sdk-build-plugins 2.0.1

package/src/uxf/UxfFormulaParser/grammerParser/grammarParser.js

@@ -0,0 +1,551 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-undef */
+// copied from https://code.devsnc.com/dev/uxf-formula-parser/blob/ci/master/src/uxf-formula-parser/grammar-parser/grammar-parser.js
+
+// Generated automatically by nearley, version 2.20.1
+// http://github.com/Hardmath123/nearley
+;(function () {
+    function id(x) {
+        return x[0]
+    }
+
+    const { api } = require('./api.js')
+
+    const moo = require('moo')
+
+    const lexer = moo.compile({
+        lte: '<=',
+        lt: '<',
+        gte: '>=',
+        gt: '>',
+        eq: '==',
+        neq: '!=',
+        lparan: '(',
+        rparan: ')',
+        comma: ',',
+        colon: ':',
+        lbracket: '[',
+        rbracket: ']',
+        lbrace: '{',
+        rbrace: '}',
+        plus: '+',
+        minus: '-',
+        multiply: '*',
+        divide: '/',
+        modulo: '%',
+        bash: '!',
+        true: 'true',
+        false: 'false',
+        and: '&&',
+        or: '||',
+        nullishCoalesce: '??',
+        dot: '.',
+        stateBinding: '@state.',
+        dataBinding: '@data.',
+        propBinding: '@context.props.',
+        sessionBinding: '@context.session.',
+        appBinding: '@context.app.',
+        syspropBinding: '@context.sysprop.',
+        itemBinding: '@item.',
+        eventPayloadBinding: '@payload.',
+        elementBinding: '@elements.',
+        envBinding: '@vars.',
+        unknownBinding: /@[a-z]+\./,
+        whitespace: {
+            match: /[ \t\r\n]+/,
+            lineBreaks: true,
+        },
+        number_literal: {
+            match: /[0-9]+(?:\.[0-9]+)?/,
+            value: (s) => Number(s),
+        },
+        name: /[a-zA-Z_][a-zA-Z0-9_]*/,
+        string_literal: {
+            match: /"(?:[^\n\\"]|\\["\\ntbfr])*"/,
+            value: (s) => JSON.parse(s),
+        },
+        quoted_binding_string_literal: {
+            match: /'(?:[^\n\\']|\\['\\ntbfr])*'/,
+            value: (s) => JSON.parse(s),
+        },
+        myError: moo.error,
+    })
+    const grammar = {
+        Lexer: lexer,
+        ParserRules: [
+            {
+                name: 'main',
+                symbols: ['_', 'EXP', '_'],
+                postprocess: function (d) {
+                    return api.completeParse(d[1])
+                },
+            },
+            { name: 'EXP', symbols: ['NULLISH_COALESCING_EXP'], postprocess: id },
+            {
+                name: 'NULLISH_COALESCING_EXP',
+                symbols: [
+                    'LOGICAL_OR_EXP',
+                    '_',
+                    lexer.has('nullishCoalesce') ? { type: 'nullishCoalesce' } : nullishCoalesce,
+                    '_',
+                    'LOGICAL_OR_EXP',
+                ],
+                postprocess: function (d) {
+                    return api.binaryOperator('DEFAULT', d[0], d[4])
+                },
+            },
+            { name: 'NULLISH_COALESCING_EXP', symbols: ['LOGICAL_OR_EXP'], postprocess: id },
+            {
+                name: 'LOGICAL_OR_EXP',
+                symbols: ['LOGICAL_OR_EXP', '_', lexer.has('or') ? { type: 'or' } : or, '_', 'LOGICAL_AND_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('OR', d[0], d[4])
+                },
+            },
+            { name: 'LOGICAL_OR_EXP', symbols: ['LOGICAL_AND_EXP'], postprocess: id },
+            {
+                name: 'LOGICAL_AND_EXP',
+                symbols: ['LOGICAL_AND_EXP', '_', lexer.has('and') ? { type: 'and' } : and, '_', 'EQUALITY_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('AND', d[0], d[4])
+                },
+            },
+            { name: 'LOGICAL_AND_EXP', symbols: ['EQUALITY_EXP'], postprocess: id },
+            {
+                name: 'EQUALITY_EXP',
+                symbols: ['EQUALITY_EXP', '_', lexer.has('eq') ? { type: 'eq' } : eq, '_', 'RELATIONAL_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('EQUAL', d[0], d[4])
+                },
+            },
+            {
+                name: 'EQUALITY_EXP',
+                symbols: ['EQUALITY_EXP', '_', lexer.has('neq') ? { type: 'neq' } : neq, '_', 'RELATIONAL_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('NOT_EQUAL', d[0], d[4])
+                },
+            },
+            { name: 'EQUALITY_EXP', symbols: ['RELATIONAL_EXP'], postprocess: id },
+            {
+                name: 'RELATIONAL_EXP',
+                symbols: ['RELATIONAL_EXP', '_', lexer.has('gt') ? { type: 'gt' } : gt, '_', 'ADDITIVE_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('>', d[0], d[4])
+                },
+            },
+            {
+                name: 'RELATIONAL_EXP',
+                symbols: ['RELATIONAL_EXP', '_', lexer.has('lt') ? { type: 'lt' } : lt, '_', 'ADDITIVE_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('<', d[0], d[4])
+                },
+            },
+            {
+                name: 'RELATIONAL_EXP',
+                symbols: ['RELATIONAL_EXP', '_', lexer.has('gte') ? { type: 'gte' } : gte, '_', 'ADDITIVE_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('>=', d[0], d[4])
+                },
+            },
+            {
+                name: 'RELATIONAL_EXP',
+                symbols: ['RELATIONAL_EXP', '_', lexer.has('lte') ? { type: 'lte' } : lte, '_', 'ADDITIVE_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('<=', d[0], d[4])
+                },
+            },
+            { name: 'RELATIONAL_EXP', symbols: ['ADDITIVE_EXP'], postprocess: id },
+            {
+                name: 'ADDITIVE_EXP',
+                symbols: ['ADDITIVE_EXP', '_', lexer.has('plus') ? { type: 'plus' } : plus, '_', 'MULTIPLICATIVE_EXP'],
+                postprocess: function (d) {
+                    return api.binaryOperator('ADD', d[0], d[4])
+                },
+            },
+            {
+                name: 'ADDITIVE_EXP',
+                symbols: [
+                    'ADDITIVE_EXP',
+                    '_',
+                    lexer.has('minus') ? { type: 'minus' } : minus,
+                    '_',
+                    'MULTIPLICATIVE_EXP',
+                ],
+                postprocess: function (d) {
+                    return api.binaryOperator('SUB', d[0], d[4])
+                },
+            },
+            { name: 'ADDITIVE_EXP', symbols: ['MULTIPLICATIVE_EXP'], postprocess: id },
+            {
+                name: 'MULTIPLICATIVE_EXP',
+                symbols: [
+                    'MULTIPLICATIVE_EXP',
+                    '_',
+                    lexer.has('multiply') ? { type: 'multiply' } : multiply,
+                    '_',
+                    'UNARY_EXP',
+                ],
+                postprocess: function (d) {
+                    return api.binaryOperator('MULTIPLY', d[0], d[4])
+                },
+            },
+            {
+                name: 'MULTIPLICATIVE_EXP',
+                symbols: [
+                    'MULTIPLICATIVE_EXP',
+                    '_',
+                    lexer.has('divide') ? { type: 'divide' } : divide,
+                    '_',
+                    'UNARY_EXP',
+                ],
+                postprocess: function (d) {
+                    return api.binaryOperator('DIVIDE', d[0], d[4])
+                },
+            },
+            {
+                name: 'MULTIPLICATIVE_EXP',
+                symbols: [
+                    'MULTIPLICATIVE_EXP',
+                    '_',
+                    lexer.has('modulo') ? { type: 'modulo' } : modulo,
+                    '_',
+                    'UNARY_EXP',
+                ],
+                postprocess: function (d) {
+                    return api.binaryOperator('MOD', d[0], d[4])
+                },
+            },
+            { name: 'MULTIPLICATIVE_EXP', symbols: ['UNARY_EXP'], postprocess: id },
+            {
+                name: 'UNARY_EXP',
+                symbols: [lexer.has('minus') ? { type: 'minus' } : minus, 'UNARY_EXP'],
+                postprocess: function (d) {
+                    return api.unaryOperator('NEGATE', d[1], d[0])
+                },
+            },
+            {
+                name: 'UNARY_EXP',
+                symbols: [lexer.has('bash') ? { type: 'bash' } : bash, 'UNARY_EXP'],
+                postprocess: function (d) {
+                    return api.unaryOperator('NOT', d[1], d[0])
+                },
+            },
+            { name: 'UNARY_EXP', symbols: ['TERM'], postprocess: id },
+            {
+                name: 'TERM',
+                symbols: [
+                    'NAME',
+                    lexer.has('lparan') ? { type: 'lparan' } : lparan,
+                    '_',
+                    'EXP_LIST',
+                    '_',
+                    lexer.has('rparan') ? { type: 'rparan' } : rparan,
+                ],
+                postprocess: function (d) {
+                    return api.transformFunc(d[0], api.listContainer(d[3]), d[5])
+                },
+            },
+            {
+                name: 'TERM',
+                symbols: [
+                    lexer.has('lparan') ? { type: 'lparan' } : lparan,
+                    '_',
+                    'EXP',
+                    '_',
+                    lexer.has('rparan') ? { type: 'rparan' } : rparan,
+                ],
+                postprocess: function (d) {
+                    return d[2]
+                },
+            },
+            {
+                name: 'TERM',
+                symbols: [
+                    lexer.has('lbracket') ? { type: 'lbracket' } : lbracket,
+                    '_',
+                    'EXP_LIST',
+                    '_',
+                    lexer.has('rbracket') ? { type: 'rbracket' } : rbracket,
+                ],
+                postprocess: function (d) {
+                    return api.listContainer(d[2], d[0], d[4])
+                },
+            },
+            {
+                name: 'TERM',
+                symbols: [
+                    lexer.has('lbrace') ? { type: 'lbrace' } : lbrace,
+                    '_',
+                    'MAP_PARAM_LIST',
+                    '_',
+                    lexer.has('rbrace') ? { type: 'rbrace' } : rbrace,
+                ],
+                postprocess: function (d) {
+                    return api.mapContainer(d[2], d[0], d[4])
+                },
+            },
+            { name: 'TERM', symbols: ['STRING'], postprocess: id },
+            { name: 'TERM', symbols: ['NUMBER'], postprocess: id },
+            { name: 'TERM', symbols: ['BINDING'], postprocess: id },
+            {
+                name: 'TERM',
+                symbols: [lexer.has('true') ? { type: 'true' } : true],
+                postprocess: function (d) {
+                    return api.boolean(d[0])
+                },
+            },
+            {
+                name: 'TERM',
+                symbols: [lexer.has('false') ? { type: 'false' } : false],
+                postprocess: function (d) {
+                    return api.boolean(d[0])
+                },
+            },
+            { name: 'EXP_LIST', symbols: [], postprocess: () => [] },
+            {
+                name: 'EXP_LIST',
+                symbols: ['EXP_LIST', '_', { literal: ',' }, '_', 'EXP'],
+                postprocess: function (d) {
+                    return d[0].concat(d[4])
+                },
+            },
+            {
+                name: 'EXP_LIST',
+                symbols: ['EXP'],
+                postprocess: function (d) {
+                    return [d[0]]
+                },
+            },
+            {
+                name: 'MAP_PARAM_LIST',
+                symbols: [],
+                postprocess: function (d) {
+                    return []
+                },
+            },
+            {
+                name: 'MAP_PARAM_LIST',
+                symbols: ['MAP_PARAM_LIST', '_', { literal: ',' }, '_', 'MAP_PARAM'],
+                postprocess: function (d) {
+                    d[0].push(d[4])
+                    return d[0]
+                },
+            },
+            {
+                name: 'MAP_PARAM_LIST',
+                symbols: ['MAP_PARAM'],
+                postprocess: function (d) {
+                    return [d[0]]
+                },
+            },
+            {
+                name: 'MAP_PARAM',
+                symbols: ['NAME', '_', { literal: ':' }, '_', 'EXP'],
+                postprocess: function (d) {
+                    return { name: d[0].value, value: d[4] }
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('stateBinding') ? { type: 'stateBinding' } : stateBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('STATE_BINDING', d[1], d[0])
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('dataBinding') ? { type: 'dataBinding' } : dataBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('DATA_OUTPUT_BINDING', d[1], d[0])
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('sessionBinding') ? { type: 'sessionBinding' } : sessionBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('CONTEXT_BINDING', d[1], d[0], 'session')
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('propBinding') ? { type: 'propBinding' } : propBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('CONTEXT_BINDING', d[1], d[0], 'props')
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('appBinding') ? { type: 'appBinding' } : appBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('CONTEXT_BINDING', d[1], d[0], 'app')
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('syspropBinding') ? { type: 'syspropBinding' } : syspropBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('CONTEXT_BINDING', d[1], d[0], 'sysprop')
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [
+                    lexer.has('itemBinding') ? { type: 'itemBinding' } : itemBinding,
+                    'NAME',
+                    { literal: '.' },
+                    '_BINDING',
+                ],
+                postprocess: function (d) {
+                    return api.binding('REPEATER_ITEM_BINDING', d[3], d[0], d[1].value)
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('itemBinding') ? { type: 'itemBinding' } : itemBinding, 'NAME'],
+                postprocess: function (d) {
+                    return api.binding('REPEATER_ITEM_BINDING', [], d[0], d[1].value)
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [
+                    lexer.has('eventPayloadBinding') ? { type: 'eventPayloadBinding' } : eventPayloadBinding,
+                    '_BINDING',
+                ],
+                postprocess: function (d) {
+                    return api.binding('EVENT_PAYLOAD_BINDING', d[1], d[0])
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('elementBinding') ? { type: 'elementBinding' } : elementBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('ELEMENT_BINDING', d[1], d[0])
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('envBinding') ? { type: 'envBinding' } : envBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.binding('ENV_BINDING', d[1], d[0])
+                },
+            },
+            {
+                name: 'BINDING',
+                symbols: [lexer.has('unknownBinding') ? { type: 'unknownBinding' } : unknownBinding, '_BINDING'],
+                postprocess: function (d) {
+                    return api.unknownBinding(d[0].value.slice(1, d[0].value.length - 1), d[1], d[0])
+                },
+            },
+            {
+                name: '_BINDING',
+                symbols: ['_BINDING', { literal: '.' }, '_STRING'],
+                postprocess: function (d) {
+                    return d[0].concat(d[2].value)
+                },
+            },
+            {
+                name: '_BINDING',
+                symbols: ['_BINDING', { literal: '.' }, 'NAME'],
+                postprocess: function (d) {
+                    return d[0].concat(d[2].value)
+                },
+            },
+            {
+                name: '_BINDING',
+                symbols: ['_BINDING', { literal: '.' }, 'INDEX'],
+                postprocess: function (d) {
+                    return d[0].concat(d[2])
+                },
+            },
+            {
+                name: '_BINDING',
+                symbols: ['_STRING'],
+                postprocess: function (d) {
+                    return [d[0].value]
+                },
+            },
+            {
+                name: '_BINDING',
+                symbols: ['NAME'],
+                postprocess: function (d) {
+                    return [d[0].value]
+                },
+            },
+            {
+                name: '_BINDING',
+                symbols: ['INDEX'],
+                postprocess: function (d) {
+                    return [d[0]]
+                },
+            },
+            {
+                name: 'NAME',
+                symbols: [lexer.has('name') ? { type: 'name' } : name],
+                postprocess: ([nameToken]) => {
+                    return nameToken
+                },
+            },
+            {
+                name: 'QUOTED_NAME',
+                symbols: [
+                    lexer.has('quoted_binding_string_literal')
+                        ? { type: 'quoted_binding_string_literal' }
+                        : quoted_binding_string_literal,
+                ],
+                postprocess: ([nameToken]) => {
+                    return nameToken.value
+                },
+            },
+            {
+                name: 'STRING',
+                symbols: ['_STRING'],
+                postprocess: function (d) {
+                    return api.literal(d[0])
+                },
+            },
+            {
+                name: '_STRING',
+                symbols: [lexer.has('string_literal') ? { type: 'string_literal' } : string_literal],
+                postprocess: function (d) {
+                    return d[0]
+                },
+            },
+            {
+                name: 'INDEX',
+                symbols: [lexer.has('number_literal') ? { type: 'number_literal' } : number_literal],
+                postprocess: function (d) {
+                    return `${d[0].value}`
+                },
+            },
+            {
+                name: 'NUMBER',
+                symbols: [lexer.has('number_literal') ? { type: 'number_literal' } : number_literal],
+                postprocess: function (d) {
+                    return api.literal(d[0])
+                },
+            },
+            { name: '_$ebnf$1', symbols: [] },
+            {
+                name: '_$ebnf$1',
+                symbols: ['_$ebnf$1', lexer.has('whitespace') ? { type: 'whitespace' } : whitespace],
+                postprocess: function arrpush(d) {
+                    return d[0].concat([d[1]])
+                },
+            },
+            {
+                name: '_',
+                symbols: ['_$ebnf$1'],
+                postprocess: function (d) {
+                    return null
+                },
+            },
+        ],
+        ParserStart: 'main',
+    }
+    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
+        module.exports = grammar
+    } else {
+        window.grammar = grammar
+    }
+})()

package/src/uxf/UxfFormulaParser/grammerParser/spanHelpers.js

@@ -0,0 +1,65 @@
+// Copied from sn-uxf-formula-parser-library - https://code.devsnc.com/dev/uxf-formula-parser
+
+/**
+ * https://code.devsnc.com/dev/uxf-formula-parser/blob/ci/master/src/uxf-formula-parser/grammar-parser/spanHelpers.js
+ */
+
+// given a token, gets the line and col where it starts (helper function, no need to export)
+function tokenStart(token) {
+    return {
+        line: token.line,
+        col: token.col,
+    }
+}
+
+// given a token, gets the line and col where it ends (helper function, no need to export)
+function tokenEnd(token) {
+    const lastNewLine = token.text?.lastIndexOf('\n') ?? -1
+    if (lastNewLine !== -1) {
+        throw new Error('Unsupported case: token with line breaks')
+    }
+    return {
+        line: token.line,
+        col: token.col + token.text.length,
+    }
+}
+
+// given two tokens, returns the span of the two tokens
+export function tokenSpan(token, endToken = null) {
+    const start = tokenStart(token)
+    const end = tokenEnd(endToken ?? token)
+
+    return { start, end }
+}
+
+// given two ux values (left and right operands in a binary expression), return the span of the entire expression
+export function getBinarySpan(left, right) {
+    const start = left._span.start
+    const end = right._span.end
+    return { start, end }
+}
+
+// given the token of the unary operator and the operand ux value, returns the span of a unary expression
+export function getUnarySpan(token, operand) {
+    const start = tokenStart(token)
+    const end = operand._span.end
+    return { start, end }
+}
+
+// given the binding token and the address of a binding, returns the span of the binding
+export function getBindingSpan(token, address) {
+    const start = tokenStart(token)
+    const { line, col } = start
+    var totalLength = 0
+    if (address) {
+        for (let i = 0; i < address.length; i++) {
+            totalLength += address[i].length
+            if (i !== 0) {
+                totalLength += 1
+            }
+        }
+    }
+    const endCol = col + token.value.length + totalLength
+    const end = { line, col: endCol }
+    return { start, end }
+}

package/src/uxf/UxfFormulaParser/index.ts

@@ -0,0 +1,4 @@
+import UxfFormulaParser from './parser'
+import { cleanUxValue } from './cleanUxValue'
+
+export { UxfFormulaParser as parser, cleanUxValue }

package/src/uxf/UxfFormulaParser/parser.ts

@@ -0,0 +1,64 @@
+// Copied from sn-uxf-formula-parser-library - https://code.devsnc.com/dev/uxf-formula-parser
+
+/**
+ * https://code.devsnc.com/dev/uxf-formula-parser/blob/ci/master/src/uxf-formula-parser/parser/expressionParser.js
+ */
+
+import nearley from 'nearley'
+import * as grammar from './grammerParser/grammarParser.js'
+import { getErrorMsg } from './utils/getErrorMsg'
+
+class UxfFormulaParser {
+    constructor() {}
+
+    parse(expression) {
+        let ans
+        const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar))
+
+        parser.reportError = function (token) {
+            const message = token.value
+                ? `Invalid Syntax: did not expect the token "${token.value}" when parsing expression.`
+                : 'Invalid Syntax: unparsable expression entered'
+            throw getErrorMsg(message, {
+                start: { line: token.line, col: token.col },
+                end: { line: token.line, col: token.col + token.value.length },
+            })
+        }
+
+        try {
+            // Make a parser and feed the input
+            ans = parser.feed(expression)
+
+            // Check if there are any results
+            if (ans.results.length) {
+                return {
+                    result: ans.results[0],
+                    errors: [],
+                }
+            } else {
+                // This means the input is incomplete.
+                const out = 'Error: incomplete input, parse failed. :('
+                return {
+                    result: out,
+                    errors: [
+                        {
+                            message: 'Syntax error: Incomplete formula.',
+                            severity: '8',
+                            startLineNumber: ans.lexerState.line,
+                            startColumn: ans.lexerState.col,
+                            endLineNumber: ans.lexerState.line,
+                            endColumn: ans.lexerState.col + 1,
+                        },
+                    ],
+                }
+            }
+        } catch (e: any) {
+            return {
+                result: e.message,
+                errors: [e],
+            }
+        }
+    }
+}
+
+export default UxfFormulaParser