@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

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

@@ -1,166 +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/api.js
- */
-
-import { tokenSpan, getBinarySpan, getUnarySpan, getBindingSpan } from './spanHelpers'
-import { getErrorMsg } from '../utils/getErrorMsg'
-import functionTransformMap from './clientTransformMap'
-
-let contextMetadata = null
-
-const setContextMetadata = (cm) => {
-    contextMetadata = cm
-}
-
-const api = {
-    binding: (bindingType, address, token, category = null) => {
-        if (category) {
-            return {
-                type: bindingType,
-                binding: {
-                    address,
-                    category,
-                },
-                _span: getBindingSpan(token, address),
-            }
-        } else {
-            return {
-                type: bindingType,
-                binding: {
-                    address,
-                },
-                _span: getBindingSpan(token, address),
-            }
-        }
-    },
-    unknownBinding: (context, path, token) => {
-        // Compare
-        const metadata = contextMetadata?.find((cm) => cm.bindingLabel === context)
-        if (!metadata) {
-            throw new Error(`Unknown binding type '${context}'`)
-        }
-        const address = [...(metadata.source.binding.address ?? []), ...path]
-        return {
-            type: metadata.source.type,
-            binding: {
-                category: metadata.source.binding.category,
-                address,
-            },
-            _span: getBindingSpan(token, address),
-        }
-    },
-    completeParse: function (uxValue) {
-        const returnVal = {
-            uxValue,
-            errors: [],
-        }
-        return returnVal
-    },
-    translationLiteral: function (operands, functionToken, endToken) {
-        return {
-            type: 'TRANSLATION_LITERAL',
-            value: {
-                message: operands.container[0].value,
-                comment: '',
-            },
-            _span: tokenSpan(functionToken, endToken),
-        }
-    },
-    binaryOperator: function (operator, left, right) {
-        return {
-            type: 'BINARY',
-            operation: {
-                operator,
-                left,
-                right,
-            },
-            _span: getBinarySpan(left, right),
-        }
-    },
-    unaryOperator: (operator, operand, startToken) => {
-        return {
-            type: 'UNARY',
-            operation: {
-                operator,
-                operand,
-            },
-            _span: getUnarySpan(startToken, operand),
-        }
-    },
-    listContainer: (items, startToken, endToken) => {
-        return {
-            type: 'LIST_CONTAINER',
-            container: items,
-            _span: startToken ? tokenSpan(startToken, endToken) : null,
-        }
-    },
-    mapContainer: (params, startToken, endToken) => {
-        // TODO: Error handling for duplicate keys?
-        const mapContainer = {}
-        params.forEach((param) => (mapContainer[param.name] = param.value))
-
-        return {
-            type: 'MAP_CONTAINER',
-            container: mapContainer,
-            _span: tokenSpan(startToken, endToken),
-        }
-    },
-    transformFunc: function (functionToken, operands, endToken) {
-        const funcName = functionToken.value
-        if (funcName === 'TRANSLATE') {
-            if (operands.container.length !== 1) {
-                throw getErrorMsg(
-                    `Error: TRANSLATE expects exactly 1 argument; given ${operands.container.length}.`,
-                    tokenSpan(functionToken, endToken)
-                )
-            } else if (operands.container[0].type !== 'JSON_LITERAL') {
-                throw getErrorMsg(
-                    'Error: TRANSLATE expects a string to be passed in.',
-                    tokenSpan(functionToken, endToken)
-                )
-            } else {
-                return this.translationLiteral(operands, functionToken, endToken)
-            }
-        }
-        const mappedFunctionDef = functionTransformMap[funcName]
-
-        if (!mappedFunctionDef) {
-            throw getErrorMsg(`Error: ${funcName} is not a supported function.`, tokenSpan(functionToken, endToken))
-        }
-
-        return {
-            type: mappedFunctionDef.type || 'CLIENT_TRANSFORM',
-            transform: {
-                operator: mappedFunctionDef.name,
-                operands,
-            },
-            _span: tokenSpan(functionToken, endToken),
-        }
-    },
-
-    literal: function (literalToken) {
-        const val = literalToken.value
-        const _span = tokenSpan(literalToken)
-
-        return {
-            type: 'JSON_LITERAL',
-            value: val,
-            _span,
-        }
-    },
-
-    boolean: function (token) {
-        const val = JSON.parse(token.value)
-        const _span = tokenSpan(token)
-
-        return {
-            type: 'JSON_LITERAL',
-            value: val,
-            _span,
-        }
-    },
-}
-
-export { api, setContextMetadata }