@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

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

@@ -1,551 +0,0 @@
-/* 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

@@ -1,65 +0,0 @@
-// 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

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

package/src/uxf/UxfFormulaParser/parser.ts

@@ -1,64 +0,0 @@
-// 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