@servicenow/sdk-build-plugins 2.0.1

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

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