@seniorsistemas/angular-components 14.9.14 → 14.10.0

package/esm5/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete.js

@@ -0,0 +1,356 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { autocompletion, pickedCompletion, startCompletion } from "@codemirror/autocomplete";
+import { CustomTranslationsService } from "../../../../../../utils";
+import { CodeMirror6Core } from "../../../../codemirror-6-core";
+import { isCurrentPositionInsideString } from "../../../../utils";
+import { AutocompleteService } from "./autocomplete.service";
+import { autocompleteLoadingState, showAutocompleteLoadingState, autocompleteEmptyState, showAutocompleteEmptyState } from "./autocomplete-states";
+import { RequestTypes, CompletionTypes, MetaType, Keywords, } from "../../models";
+import { getLanguageConfigs, getSafeResponse, updateCoreCompletionItems } from "../../utils";
+import { style } from "./autocomplete-style";
+/**
+ * Adds an autocomplete to the editor
+ * @returns An extension containing everything needed to create the autocomplete
+ */
+export function autocomplete() {
+    return [
+        autocompletion({ override: [getCompletionResults] }),
+        autocompleteLoadingState(),
+        autocompleteEmptyState(),
+        style(),
+    ];
+}
+var TRANSLATION_PREFIX = "core_language_tax_calculation";
+var completionResults;
+/*
+ * A function to be called when a key is pressed, the ctrl+space is triggered or when the search for completionResults is done.
+ * If there is a completionResult, returns it, otherwise starts a new async search.
+ * Will only execute the autocompletion if the current cursor position is not inside a string
+ */
+function getCompletionResults(context) {
+    var isCursorInsideString = isCurrentPositionInsideString(context.state.doc.toString().substring(0, context.pos));
+    if (isCursorInsideString)
+        return;
+    if (completionResults) {
+        var finalCompletionResults = __assign({}, completionResults);
+        var codeLength = context.state.doc.toString().length;
+        finalCompletionResults.from = finalCompletionResults.from > codeLength
+            ? codeLength
+            : finalCompletionResults.from;
+        completionResults = null;
+        return finalCompletionResults;
+    }
+    startCompletionResultsSearch(context);
+}
+var cancelLastCompletionSearch = function () { };
+var ɵ0 = cancelLastCompletionSearch;
+var codeMirrorViewElement;
+/*
+ * Starts a new completionResults's async search.
+ * Avoids the last search to be finished by calling the "cancelLastCompletionSearch" callback function
+ */
+function startCompletionResultsSearch(context) {
+    var token = new AbortController();
+    setTimeout(function () {
+        if (!token.signal.aborted) {
+            showAutocompleteLoadingState();
+            searchCompletionResults(context, token);
+        }
+    }, 500);
+    /*
+     * IMPORTANT: The following lines MUST be the way they are!
+     * Here is being add the listener to any keydown/click event so when any key is downed or mouse clicked, we cancel the last request.
+     * We do this to not show to the user a completionItem in an incorrect place of text, that can be done by either pressing the
+     * arrows, home, end, backspace and etc. The flow is:
+     * 1. We add an eventListener to keydown/click when the autocompletion's request is triggered;
+     * 2. When any key/click is pressed, we remove the listener and cancel the last request by changing the isSearchCanceled on token object
+     *  to true;
+     * 3. If any key that requires autocompletion is triggered, the flow repeats;
+     */
+    codeMirrorViewElement = CodeMirror6Core.getEditorView().contentDOM;
+    cancelLastCompletionSearch = function () {
+        codeMirrorViewElement.removeEventListener("keydown", cancelLastCompletionSearch);
+        codeMirrorViewElement.removeEventListener("click", cancelLastCompletionSearch);
+        token.abort();
+    };
+    codeMirrorViewElement.addEventListener("keydown", cancelLastCompletionSearch);
+    codeMirrorViewElement.addEventListener("click", cancelLastCompletionSearch);
+}
+/*
+ * Requests the necessary items to fill the completionResults, although it only really opens the autocomplete
+ * box (by calling the "startCompletion()", that calls the "getCompletionResults") if the current search was not cancelled
+ * by a new one
+ */
+function searchCompletionResults(context, token) {
+    var _a, _b, _c, _d;
+    return __awaiter(this, void 0, void 0, function () {
+        var codeBeforeCursor, filter, path, requests;
+        return __generator(this, function (_e) {
+            codeBeforeCursor = (_d = (_b = (_a = context === null || context === void 0 ? void 0 : context.state) === null || _a === void 0 ? void 0 : _a.doc) === null || _b === void 0 ? void 0 : _b.toString().substring(0, (_c = context === null || context === void 0 ? void 0 : context.pos) !== null && _c !== void 0 ? _c : 0)) !== null && _d !== void 0 ? _d : "";
+            filter = getFilter(codeBeforeCursor);
+            path = getPath(codeBeforeCursor, filter.length);
+            requests = getRequestsBasedOnPath(path, filter, token.signal);
+            Promise
+                .all(requests)
+                .then(function (responses) {
+                if (!token.signal.aborted) {
+                    var completions = [].concat(getKeywordsCompletions(path), getContextsCompletions(responses), getExpressionsCompletions(responses), getEntitiesCompletions(responses));
+                    var filteredCompletions = getFilteredCompletions(completions, filter);
+                    if (filteredCompletions.length) {
+                        var formattedCompletions = getFormattedCompletions(filteredCompletions, filter);
+                        var sortedCompletions = getSortedCompletions(formattedCompletions);
+                        completionResults = {
+                            from: context.pos,
+                            filter: false,
+                            options: sortedCompletions
+                        };
+                        updateCoreCompletionItems({ path: path, filter: filter, completions: sortedCompletions });
+                        startCompletion(CodeMirror6Core.getEditorView());
+                    }
+                    else {
+                        showAutocompleteEmptyState();
+                    }
+                }
+            });
+            return [2 /*return*/];
+        });
+    });
+}
+/*
+ * Returns the filter in the code written.
+ * For example in the code "controladoria.empresa", "empresa" would be the filter
+ * and in "controladoria", "controladoria" would be the filter.
+ * Allows only alphanumerics, underscore and hashtag on filter's start.
+ * Does not allow spaces
+ */
+function getFilter(string) {
+    var _a, _b;
+    if (string === undefined || string === null)
+        return "";
+    var filter = (_b = (_a = string.match(/(#|\.|)\w*$/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
+    return filter.replace(".", "").trim();
+}
+/*
+ * Returns the path in the code written based on filter.
+ * For example in the code "controladoria.empresa", "controladoria" would be the path
+ * and in "controladoria", "" would be the path.
+ * Does not allow spaces
+ */
+function getPath(string, filterLength) {
+    var _a, _b;
+    if (string === undefined || string === null)
+        return "";
+    var stringWithoutPath = string.substring(0, string.length - filterLength);
+    var path = (_b = (_a = stringWithoutPath.match(/(\w*\.)*$/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
+    return path.replace(/\.$/, "");
+}
+function getRequestsBasedOnPath(path, filter, abortSignal) {
+    var _a;
+    var languageConfigs = getLanguageConfigs();
+    var requests = [];
+    if (path === "") {
+        requests.push({
+            requestType: RequestTypes.ListContextMetadataById,
+            request: AutocompleteService.listContextMetadataById({
+                id: languageConfigs.contexts,
+            }, abortSignal)
+        });
+        requests.push({
+            requestType: RequestTypes.ListExpressionMetadata,
+            request: AutocompleteService.listExpressionMetadata({
+                context: languageConfigs.contexts,
+                subcontext: (_a = languageConfigs.subContexts) !== null && _a !== void 0 ? _a : [],
+                name: filter,
+                pageRequest: {
+                    offset: 0,
+                    size: 20
+                }
+            }, abortSignal)
+        });
+    }
+    else if (path.includes(".")) {
+        var splittedPath = path.split(".");
+        requests.push({
+            requestType: RequestTypes.GetFacadeMetadataByPath,
+            request: AutocompleteService.getFacadeMetadataByPath({
+                context: splittedPath[0],
+                entityName: splittedPath[1],
+                fields: splittedPath[2] === undefined ? undefined : splittedPath.slice(2)
+            }, abortSignal)
+        });
+    }
+    else {
+        requests.push({
+            requestType: RequestTypes.ListFacadeMetadataNames,
+            request: AutocompleteService.listFacadeMetadataNames({
+                context: [path],
+                name: filter,
+                pageRequest: {
+                    offset: 0,
+                    size: 30
+                }
+            }, abortSignal)
+        });
+    }
+    return requests.map(function (request) { return getSafeResponse(request); });
+}
+function getKeywordsCompletions(path) {
+    if (path !== "")
+        return [];
+    var completions = [
+        {
+            label: Keywords.SE,
+            apply: "SE ()\nENTAO\n\tacao\nFIM_SE",
+        },
+        {
+            label: Keywords.SENAO,
+            apply: "SENAO\n\tacao",
+        },
+        {
+            label: Keywords.CONTENHA,
+            apply: "CONTENHA(condicao)",
+        },
+        {
+            label: Keywords.ENTAO,
+            apply: "ENTAO\n\tacao",
+        },
+        {
+            label: Keywords.FIM_SE,
+            apply: "FIM_SE ",
+        },
+        {
+            label: Keywords.NAO,
+            apply: "NAO ",
+        },
+        {
+            label: Keywords.E,
+            apply: "E ",
+        },
+        {
+            label: Keywords.OU,
+            apply: "OU "
+        },
+    ];
+    return completions.map(function (completionItem) { return (__assign(__assign({}, completionItem), { detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_keyword"), type: CompletionTypes.Keyword })); });
+}
+function getContextsCompletions(responses) {
+    var _a, _b;
+    var contextsResponse = responses.find(function (response) {
+        return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListContextMetadataById;
+    });
+    if (contextsResponse) {
+        return ((_b = (_a = contextsResponse.response) === null || _a === void 0 ? void 0 : _a.contextMetadata) !== null && _b !== void 0 ? _b : [])
+            .map(function (contextMetadata) { return ({
+            label: contextMetadata.name,
+            detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_context"),
+            apply: contextMetadata.name,
+            type: CompletionTypes.Context
+        }); });
+    }
+    return [];
+}
+function getExpressionsCompletions(responses) {
+    var _a, _b;
+    var expressionsResponse = responses.find(function (response) {
+        return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListExpressionMetadata;
+    });
+    if (expressionsResponse) {
+        return ((_b = (_a = expressionsResponse.response) === null || _a === void 0 ? void 0 : _a.expressionMetadata) !== null && _b !== void 0 ? _b : [])
+            .map(function (expressionMetadata) { return ({
+            label: expressionMetadata.name,
+            detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_" + (expressionMetadata.type === MetaType.PUBLIC_EXPRESSION
+                ? "senior_expression"
+                : "user_expression")),
+            apply: expressionMetadata.name,
+            info: expressionMetadata.description,
+            type: expressionMetadata.type === MetaType.PUBLIC_EXPRESSION ? CompletionTypes.Expression : CompletionTypes.UserExpression
+        }); });
+    }
+    return [];
+}
+function getEntitiesCompletions(responses) {
+    var _a, _b, _c, _d, _e;
+    var facadesResponseFromList = responses.find(function (response) {
+        return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.ListFacadeMetadataNames;
+    });
+    if (facadesResponseFromList) {
+        return ((_b = (_a = facadesResponseFromList.response) === null || _a === void 0 ? void 0 : _a.facadeMetadataNames) !== null && _b !== void 0 ? _b : [])
+            .map(function (facade) { return ({
+            label: facade.name,
+            detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_entity"),
+            apply: facade.name,
+            type: CompletionTypes.Entity
+        }); });
+    }
+    var facadesResponseFromGet = responses.find(function (response) {
+        return (response === null || response === void 0 ? void 0 : response.requestType) === RequestTypes.GetFacadeMetadataByPath;
+    });
+    if (facadesResponseFromGet) {
+        return ((_e = (_d = (_c = facadesResponseFromGet.response) === null || _c === void 0 ? void 0 : _c.facadeMetadata) === null || _d === void 0 ? void 0 : _d.fields) !== null && _e !== void 0 ? _e : [])
+            .map(function (facade) { return ({
+            label: facade.name,
+            detail: CustomTranslationsService.translate(TRANSLATION_PREFIX + "_" + (facade.type === MetaType.ENTITY
+                ? "entity"
+                : "field")),
+            apply: facade.name,
+            type: facade.type === MetaType.ENTITY ? CompletionTypes.Entity : CompletionTypes.FinalValue
+        }); });
+    }
+    return [];
+}
+/*
+ * Filtering the completions to only deal with the necessary items
+ */
+function getFilteredCompletions(completions, filter) {
+    return completions
+        .filter(function (completionItem) {
+        return completionItem
+            .label
+            .toLowerCase()
+            .startsWith(filter.toLowerCase());
+    });
+}
+/*
+ * Overwriting the completions's apply to remove the entire current written value and apply the the entire completion's apply
+ */
+function getFormattedCompletions(completions, filter) {
+    return completions
+        .map(function (completionItem) { return (__assign(__assign({}, completionItem), { apply: getCompletionApply(filter, "" + completionItem.apply) })); });
+}
+function getCompletionApply(filter, oldApplyText) {
+    return function (view, completion, from, to) {
+        var newFrom = from - filter.length;
+        view.dispatch({
+            changes: {
+                from: newFrom,
+                to: to,
+                insert: oldApplyText
+            },
+            selection: {
+                anchor: newFrom + oldApplyText.length
+            },
+            userEvent: "input.complete",
+            annotations: pickedCompletion.of(completion)
+        });
+    };
+}
+var completionsSortOrder = [
+    CompletionTypes.Keyword,
+    CompletionTypes.Context,
+    CompletionTypes.UserExpression,
+    CompletionTypes.Expression,
+    CompletionTypes.Entity,
+    CompletionTypes.FinalValue
+];
+/*
+ * Sorts the completions following the "completionsSortOrder" priority order
+ */
+function getSortedCompletions(completions) {
+    return completions.sort(function (x, y) {
+        var xPriority = completionsSortOrder.indexOf(x.type);
+        var yPriority = completionsSortOrder.indexOf(y.type);
+        return xPriority - yPriority;
+    });
+}
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete.ts"],"names":[],"mappings":"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","sourcesContent":["import { Extension } from \"@codemirror/state\";\nimport { EditorView } from \"@codemirror/view\";\nimport {\n    autocompletion,\n    Completion,\n    CompletionContext,\n    CompletionResult,\n    pickedCompletion,\n    startCompletion\n} from \"@codemirror/autocomplete\";\n\nimport { CustomTranslationsService } from \"../../../../../../utils\";\nimport { CodeMirror6Core } from \"../../../../codemirror-6-core\";\nimport { isCurrentPositionInsideString } from \"../../../../utils\";\nimport { AutocompleteService } from \"./autocomplete.service\";\nimport {\n    autocompleteLoadingState,\n    showAutocompleteLoadingState,\n    autocompleteEmptyState,\n    showAutocompleteEmptyState\n} from \"./autocomplete-states\";\nimport {\n    TaxCalculationConfigs,\n    RequestTypes,\n    Response,\n    SafeRequest,\n    SafeResponse,\n    ListContextMetadataByIdResponse,\n    CompletionTypes,\n    ListExpressionMetadataResponse,\n    MetaType,\n    GetFacadeMetadataByPathResponse,\n    ListFacadeMetadataNamesResponse,\n    Keywords,\n} from \"../../models\";\nimport {\n    getLanguageConfigs,\n    getSafeResponse,\n    updateCoreCompletionItems\n} from \"../../utils\";\nimport { style } from \"./autocomplete-style\";\n\n/**\n * Adds an autocomplete to the editor\n * @returns An extension containing everything needed to create the autocomplete\n */\nexport function autocomplete (): Extension {\n    return [\n        autocompletion({ override: [getCompletionResults] }),\n        autocompleteLoadingState(),\n        autocompleteEmptyState(),\n        style(),\n    ];\n}\n\nconst TRANSLATION_PREFIX = \"core_language_tax_calculation\";\nlet completionResults!: CompletionResult;\n\n/*\n * A function to be called when a key is pressed, the ctrl+space is triggered or when the search for completionResults is done.\n * If there is a completionResult, returns it, otherwise starts a new async search.\n * Will only execute the autocompletion if the current cursor position is not inside a string\n */\nfunction getCompletionResults(context: CompletionContext): CompletionResult {\n    const isCursorInsideString = isCurrentPositionInsideString(context.state.doc.toString().substring(0, context.pos));\n    if (isCursorInsideString) return;\n\n    if (completionResults) {\n        const finalCompletionResults: CompletionResult = { ...completionResults };\n        const codeLength = context.state.doc.toString().length;\n        finalCompletionResults.from = finalCompletionResults.from > codeLength\n            ? codeLength\n            : finalCompletionResults.from;\n        completionResults = null;\n        return finalCompletionResults;\n    }\n    startCompletionResultsSearch(context);\n}\n\nlet cancelLastCompletionSearch: () => void = () => {};\nlet codeMirrorViewElement!: HTMLElement;\n\n/*\n * Starts a new completionResults's async search.\n * Avoids the last search to be finished by calling the \"cancelLastCompletionSearch\" callback function\n */\nfunction startCompletionResultsSearch(context: CompletionContext): void {\n    const token = new AbortController();\n    setTimeout(() => {\n        if (!token.signal.aborted) {\n            showAutocompleteLoadingState();\n            searchCompletionResults(context, token);\n        }\n    }, 500);\n\n    /*\n     * IMPORTANT: The following lines MUST be the way they are!\n     * Here is being add the listener to any keydown/click event so when any key is downed or mouse clicked, we cancel the last request.\n     * We do this to not show to the user a completionItem in an incorrect place of text, that can be done by either pressing the\n     * arrows, home, end, backspace and etc. The flow is:\n     * 1. We add an eventListener to keydown/click when the autocompletion's request is triggered;\n     * 2. When any key/click is pressed, we remove the listener and cancel the last request by changing the isSearchCanceled on token object\n     *  to true;\n     * 3. If any key that requires autocompletion is triggered, the flow repeats;\n     */\n    codeMirrorViewElement = CodeMirror6Core.getEditorView().contentDOM;\n\n    cancelLastCompletionSearch = () => {\n        codeMirrorViewElement.removeEventListener(\"keydown\", cancelLastCompletionSearch);\n        codeMirrorViewElement.removeEventListener(\"click\", cancelLastCompletionSearch);\n        token.abort();\n    };\n\n    codeMirrorViewElement.addEventListener(\"keydown\", cancelLastCompletionSearch);\n    codeMirrorViewElement.addEventListener(\"click\", cancelLastCompletionSearch);\n}\n\n/*\n * Requests the necessary items to fill the completionResults, although it only really opens the autocomplete\n * box (by calling the \"startCompletion()\", that calls the \"getCompletionResults\") if the current search was not cancelled\n * by a new one\n */\nasync function searchCompletionResults(context: CompletionContext, token: AbortController): Promise<void> {\n    const codeBeforeCursor = context?.state?.doc?.toString().substring(0, context?.pos ?? 0) ?? \"\";\n    const filter = getFilter(codeBeforeCursor);\n    const path = getPath(codeBeforeCursor, filter.length);\n    const requests: SafeResponse[] = getRequestsBasedOnPath(path, filter, token.signal);\n\n    Promise\n        .all(requests)\n        .then(responses => {\n            if (!token.signal.aborted) {\n                const completions = [].concat(\n                    getKeywordsCompletions(path),\n                    getContextsCompletions(responses),\n                    getExpressionsCompletions(responses),\n                    getEntitiesCompletions(responses)\n                );\n                const filteredCompletions: Completion[] = getFilteredCompletions(completions, filter);\n\n                if (filteredCompletions.length) {\n                    const formattedCompletions: Completion[] = getFormattedCompletions(filteredCompletions, filter);\n                    const sortedCompletions: Completion[] = getSortedCompletions(formattedCompletions);\n\n                    completionResults = {\n                        from: context.pos,\n                        filter: false,\n                        options: sortedCompletions\n                    };\n\n                    updateCoreCompletionItems({ path, filter, completions: sortedCompletions });\n                    startCompletion(CodeMirror6Core.getEditorView());\n\n                } else {\n                    showAutocompleteEmptyState();\n                }\n\n            }\n        });\n}\n\n/*\n * Returns the filter in the code written.\n * For example in the code \"controladoria.empresa\", \"empresa\" would be the filter\n * and in \"controladoria\", \"controladoria\" would be the filter.\n * Allows only alphanumerics, underscore and hashtag on filter's start.\n * Does not allow spaces\n */\nfunction getFilter(string: string): string {\n    if (string === undefined || string === null) return \"\";\n\n    const filter = string.match(/(#|\\.|)\\w*$/)?.[0] ?? \"\";\n    return filter.replace(\".\", \"\").trim();\n}\n\n/*\n * Returns the path in the code written based on filter.\n * For example in the code \"controladoria.empresa\", \"controladoria\" would be the path\n * and in \"controladoria\", \"\" would be the path.\n * Does not allow spaces\n */\nfunction getPath(string: string, filterLength: number): string {\n    if (string === undefined || string === null) return \"\";\n\n    const stringWithoutPath = string.substring(0, string.length - filterLength);\n    const path = stringWithoutPath.match(/(\\w*\\.)*$/)?.[0] ?? \"\";\n    return path.replace(/\\.$/, \"\");\n}\n\nfunction getRequestsBasedOnPath(path: string, filter: string, abortSignal: AbortSignal): SafeResponse[] {\n    const languageConfigs: TaxCalculationConfigs = getLanguageConfigs();\n    const requests: SafeRequest[] = [];\n\n    if (path === \"\") {\n        requests.push({\n            requestType: RequestTypes.ListContextMetadataById,\n            request: AutocompleteService.listContextMetadataById(\n                {\n                    id: languageConfigs.contexts,\n                },\n                abortSignal\n            )\n        });\n        requests.push({\n            requestType: RequestTypes.ListExpressionMetadata,\n            request: AutocompleteService.listExpressionMetadata(\n                {\n                    context: languageConfigs.contexts,\n                    subcontext: languageConfigs.subContexts ?? [],\n                    name: filter,\n                    pageRequest: {\n                        offset: 0,\n                        size: 20\n                    }\n                },\n                abortSignal\n            )\n        });\n\n    } else if (path.includes(\".\")) {\n        const splittedPath = path.split(\".\");\n        requests.push({\n            requestType: RequestTypes.GetFacadeMetadataByPath,\n            request: AutocompleteService.getFacadeMetadataByPath(\n                {\n                    context: splittedPath[0],\n                    entityName: splittedPath[1],\n                    fields: splittedPath[2] === undefined ? undefined : splittedPath.slice(2)\n                },\n                abortSignal\n            )\n        });\n\n    } else {\n        requests.push({\n            requestType: RequestTypes.ListFacadeMetadataNames,\n            request: AutocompleteService.listFacadeMetadataNames(\n                {\n                    context: [path],\n                    name: filter,\n                    pageRequest: {\n                        offset: 0,\n                        size: 30\n                    }\n                },\n                abortSignal\n            )\n        });\n    }\n\n    return requests.map(request => getSafeResponse(request));\n}\n\nfunction getKeywordsCompletions(path: string): Completion[] {\n    if (path !== \"\") return [];\n\n    const completions = [\n        {\n            label: Keywords.SE,\n            apply: \"SE ()\\nENTAO\\n\\tacao\\nFIM_SE\",\n        },\n        {\n            label: Keywords.SENAO,\n            apply: \"SENAO\\n\\tacao\",\n        },\n        {\n            label: Keywords.CONTENHA,\n            apply: \"CONTENHA(condicao)\",\n        },\n        {\n            label: Keywords.ENTAO,\n            apply: \"ENTAO\\n\\tacao\",\n        },\n        {\n            label: Keywords.FIM_SE,\n            apply: \"FIM_SE \",\n        },\n        {\n            label: Keywords.NAO,\n            apply: \"NAO \",\n        },\n        {\n            label: Keywords.E,\n            apply: \"E \",\n        },\n        {\n            label: Keywords.OU,\n            apply: \"OU \"\n        },\n    ];\n\n    return completions.map(completionItem => ({\n        ...completionItem,\n        detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_keyword`),\n        type: CompletionTypes.Keyword\n    }));\n}\n\nfunction getContextsCompletions(responses: Response<any>[]): Completion[] {\n    const contextsResponse: Response<ListContextMetadataByIdResponse> = responses.find(response =>\n        response?.requestType === RequestTypes.ListContextMetadataById\n    );\n\n    if (contextsResponse) {\n        return (contextsResponse.response?.contextMetadata ?? [])\n            .map(contextMetadata => ({\n                label: contextMetadata.name,\n                detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_context`),\n                apply: contextMetadata.name,\n                type: CompletionTypes.Context\n            }));\n    }\n\n    return [];\n}\n\nfunction getExpressionsCompletions(responses: Response<any>[]): Completion[] {\n    const expressionsResponse: Response<ListExpressionMetadataResponse> = responses.find(response =>\n        response?.requestType === RequestTypes.ListExpressionMetadata\n    );\n\n    if (expressionsResponse) {\n        return (expressionsResponse.response?.expressionMetadata ?? [])\n            .map(expressionMetadata => ({\n                label: expressionMetadata.name,\n                detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_${\n                    expressionMetadata.type === MetaType.PUBLIC_EXPRESSION\n                        ? \"senior_expression\"\n                        : \"user_expression\"\n                    }`),\n                apply: expressionMetadata.name,\n                info: expressionMetadata.description,\n                type: expressionMetadata.type === MetaType.PUBLIC_EXPRESSION ? CompletionTypes.Expression : CompletionTypes.UserExpression\n            }));\n    }\n\n    return [];\n}\n\nfunction getEntitiesCompletions(responses: Response<any>[]): Completion[] {\n    const facadesResponseFromList: Response<ListFacadeMetadataNamesResponse> = responses.find(response =>\n        response?.requestType === RequestTypes.ListFacadeMetadataNames\n    );\n\n    if (facadesResponseFromList) {\n        return (facadesResponseFromList.response?.facadeMetadataNames ?? [])\n            .map(facade => ({\n                label: facade.name,\n                detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_entity`),\n                apply: facade.name,\n                type: CompletionTypes.Entity\n            }));\n    }\n\n    const facadesResponseFromGet: Response<GetFacadeMetadataByPathResponse> = responses.find(response =>\n        response?.requestType === RequestTypes.GetFacadeMetadataByPath\n    );\n\n    if (facadesResponseFromGet) {\n        return (facadesResponseFromGet.response?.facadeMetadata?.fields ?? [])\n            .map(facade => ({\n                label: facade.name,\n                detail: CustomTranslationsService.translate(`${TRANSLATION_PREFIX}_${\n                    facade.type === MetaType.ENTITY\n                        ? \"entity\"\n                        : \"field\"\n                    }`),\n                apply: facade.name,\n                type: facade.type === MetaType.ENTITY ? CompletionTypes.Entity : CompletionTypes.FinalValue\n            }));\n    }\n\n    return [];\n}\n\n/*\n * Filtering the completions to only deal with the necessary items\n */\nfunction getFilteredCompletions(completions: Completion[], filter: string): Completion[] {\n    return completions\n        .filter(completionItem =>\n                completionItem\n                    .label\n                    .toLowerCase()\n                    .startsWith(filter.toLowerCase()));\n}\n\n\n/*\n * Overwriting the completions's apply to remove the entire current written value and apply the the entire completion's apply \n */\nfunction getFormattedCompletions(completions: Completion[], filter: string): Completion[] {\n    return completions\n        .map(completionItem => ({\n            ...completionItem,\n            apply: getCompletionApply(filter, `${completionItem.apply}`)\n        }));\n}\n\nfunction getCompletionApply(filter: string, oldApplyText: string): ((view: EditorView, completion: Completion, from: number, to: number) => void)  {\n    return (view: EditorView, completion: Completion, from: number, to: number): void => {\n        const newFrom = from - filter.length;\n    \n        view.dispatch({\n            changes: {\n                from: newFrom,\n                to,\n                insert: oldApplyText\n            },\n            selection: {\n                anchor: newFrom + oldApplyText.length\n            },\n            userEvent: \"input.complete\",\n            annotations: pickedCompletion.of(completion)\n        });\n    } \n}\n\nconst completionsSortOrder: CompletionTypes[] = [\n    CompletionTypes.Keyword,\n    CompletionTypes.Context,\n    CompletionTypes.UserExpression,\n    CompletionTypes.Expression,\n    CompletionTypes.Entity,\n    CompletionTypes.FinalValue\n];\n\n/*\n * Sorts the completions following the \"completionsSortOrder\" priority order\n */\nfunction getSortedCompletions(completions: Completion[]): Completion[] {\n    return completions.sort((x: Completion, y: Completion) => {\n        const xPriority = completionsSortOrder.indexOf(x.type as CompletionTypes);\n        const yPriority = completionsSortOrder.indexOf(y.type as CompletionTypes);\n\n        return xPriority - yPriority;\n    });\n}\n"]}

package/esm5/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/autocomplete/autocomplete.service.js

@@ -0,0 +1,46 @@
+import { __awaiter, __generator } from "tslib";
+import { CustomHttpClient } from "../../../../../../utils";
+var AutocompleteService = /** @class */ (function () {
+    function AutocompleteService() {
+    }
+    AutocompleteService.listContextMetadataById = function (request, abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/listContextMetadataById", request, {
+                        signal: abortSignal
+                    })];
+            });
+        });
+    };
+    AutocompleteService.listExpressionMetadata = function (request, abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/listExpressionMetadata", request, {
+                        signal: abortSignal
+                    })];
+            });
+        });
+    };
+    AutocompleteService.listFacadeMetadataNames = function (request, abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/listFacadeMetadataNames", request, {
+                        signal: abortSignal
+                    })];
+            });
+        });
+    };
+    AutocompleteService.getFacadeMetadataByPath = function (request, abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, CustomHttpClient.POST(AutocompleteService.BASE_URL + "/queries/getFacadeMetadataByPath", request, {
+                        signal: abortSignal
+                    })];
+            });
+        });
+    };
+    AutocompleteService.BASE_URL = "platform/rule_metadata";
+    return AutocompleteService;
+}());
+export { AutocompleteService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/base-configs/base-configs.js

@@ -0,0 +1,19 @@
+var _a;
+import { LRLanguage } from "@codemirror/language";
+import { buildParser } from "@lezer/generator";
+import { styleTags, tags } from "@codemirror/highlight";
+import parserGrammar from "./grammar";
+import { Keywords } from "../../models";
+export var baseConfigs = LRLanguage.define({
+    parser: buildParser(parserGrammar)
+        .configure({
+        props: [
+            styleTags((_a = {},
+                _a[Object.values(Keywords).join(" ")] = tags.keyword,
+                _a["String"] = tags.string,
+                _a["Number"] = tags.number,
+                _a))
+        ]
+    })
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb25maWdzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvY29kZS1lZGl0b3IvaW5mcmEvY29yZXMvY29kZW1pcnJvci02L2xhbmd1YWdlcy90YXgtY2FsY3VsYXRpb24vZXh0ZW5zaW9ucy9iYXNlLWNvbmZpZ3MvYmFzZS1jb25maWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQy9DLE9BQU8sRUFDSCxTQUFTLEVBQ1QsSUFBSSxFQUNQLE1BQU0sdUJBQXVCLENBQUM7QUFFL0IsT0FBTyxhQUFhLE1BQU0sV0FBVyxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxDQUFDLElBQU0sV0FBVyxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUM7SUFDekMsTUFBTSxFQUFHLFdBQVcsQ0FBQyxhQUFhLENBQUM7U0FDOUIsU0FBUyxDQUFDO1FBQ1AsS0FBSyxFQUFFO1lBQ0gsU0FBUztnQkFDTCxHQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFHLElBQUksQ0FBQyxPQUFPO2dCQUNqRCxZQUFRLEdBQUUsSUFBSSxDQUFDLE1BQU07Z0JBQ3JCLFlBQVEsR0FBRSxJQUFJLENBQUMsTUFBTTtvQkFDdkI7U0FDTDtLQUNKLENBQUM7Q0FDVCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMUkxhbmd1YWdlIH0gZnJvbSBcIkBjb2RlbWlycm9yL2xhbmd1YWdlXCI7XG5pbXBvcnQgeyBidWlsZFBhcnNlciB9IGZyb20gXCJAbGV6ZXIvZ2VuZXJhdG9yXCI7XG5pbXBvcnQge1xuICAgIHN0eWxlVGFncyxcbiAgICB0YWdzXG59IGZyb20gXCJAY29kZW1pcnJvci9oaWdobGlnaHRcIjtcblxuaW1wb3J0IHBhcnNlckdyYW1tYXIgZnJvbSBcIi4vZ3JhbW1hclwiO1xuaW1wb3J0IHsgS2V5d29yZHMgfSBmcm9tIFwiLi4vLi4vbW9kZWxzXCI7XG5cbmV4cG9ydCBjb25zdCBiYXNlQ29uZmlncyA9IExSTGFuZ3VhZ2UuZGVmaW5lKHtcbiAgICBwYXJzZXI6ICBidWlsZFBhcnNlcihwYXJzZXJHcmFtbWFyKVxuICAgICAgICAuY29uZmlndXJlKHtcbiAgICAgICAgICAgIHByb3BzOiBbXG4gICAgICAgICAgICAgICAgc3R5bGVUYWdzKHtcbiAgICAgICAgICAgICAgICAgICAgW09iamVjdC52YWx1ZXMoS2V5d29yZHMpLmpvaW4oXCIgXCIpXTogdGFncy5rZXl3b3JkLFxuICAgICAgICAgICAgICAgICAgICBcIlN0cmluZ1wiOiB0YWdzLnN0cmluZyxcbiAgICAgICAgICAgICAgICAgICAgXCJOdW1iZXJcIjogdGFncy5udW1iZXIsXG4gICAgICAgICAgICAgICAgfSlcbiAgICAgICAgICAgIF1cbiAgICAgICAgfSlcbn0pO1xuIl19

package/esm5/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/base-configs/grammar.js

@@ -0,0 +1,2 @@
+export default "\n@top Script { statement+ }\n\nstatement[@isGroup=Statement] {\n    Keyword |\n    String |\n    Number\n}\n\n@tokens {\n    String { '\"' (![\\n\"])* '\"'? }\n\n    Number { std.digit+ }\n\n    identifierChar { std.asciiLetter | $[_$\u00A1-\uDBFF\uDFFF] }\n\n    word { identifierChar (identifierChar | std.digit)* }\n\n    identifier { word }\n}\n\nKeyword {\n    kw<\"SE\">\n    kw<\"ENTAO\">\n    kw<\"FIM_SE\">\n    kw<\"SENAO\">\n    kw<\"NAO\">\n    kw<\"CONTENHA\">\n    kw<\"OU\">\n    kw<\"E\">\n}\n\nkw<term> { @specialize[@name={term}]<identifier, term> }\n\n@detectDelim\n";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhbW1hci5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BzZW5pb3JzaXN0ZW1hcy9hbmd1bGFyLWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJjb21wb25lbnRzL2NvZGUtZWRpdG9yL2luZnJhL2NvcmVzL2NvZGVtaXJyb3ItNi9sYW5ndWFnZXMvdGF4LWNhbGN1bGF0aW9uL2V4dGVuc2lvbnMvYmFzZS1jb25maWdzL2dyYW1tYXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZSw0a0JBbUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBgXG5AdG9wIFNjcmlwdCB7IHN0YXRlbWVudCsgfVxuXG5zdGF0ZW1lbnRbQGlzR3JvdXA9U3RhdGVtZW50XSB7XG4gICAgS2V5d29yZCB8XG4gICAgU3RyaW5nIHxcbiAgICBOdW1iZXJcbn1cblxuQHRva2VucyB7XG4gICAgU3RyaW5nIHsgJ1wiJyAoIVtcXFxcblwiXSkqICdcIic/IH1cblxuICAgIE51bWJlciB7IHN0ZC5kaWdpdCsgfVxuXG4gICAgaWRlbnRpZmllckNoYXIgeyBzdGQuYXNjaWlMZXR0ZXIgfCAkW18kXFx1e2ExfS1cXHV7MTBmZmZmfV0gfVxuXG4gICAgd29yZCB7IGlkZW50aWZpZXJDaGFyIChpZGVudGlmaWVyQ2hhciB8IHN0ZC5kaWdpdCkqIH1cblxuICAgIGlkZW50aWZpZXIgeyB3b3JkIH1cbn1cblxuS2V5d29yZCB7XG4gICAga3c8XCJTRVwiPlxuICAgIGt3PFwiRU5UQU9cIj5cbiAgICBrdzxcIkZJTV9TRVwiPlxuICAgIGt3PFwiU0VOQU9cIj5cbiAgICBrdzxcIk5BT1wiPlxuICAgIGt3PFwiQ09OVEVOSEFcIj5cbiAgICBrdzxcIk9VXCI+XG4gICAga3c8XCJFXCI+XG59XG5cbmt3PHRlcm0+IHsgQHNwZWNpYWxpemVbQG5hbWU9e3Rlcm19XTxpZGVudGlmaWVyLCB0ZXJtPiB9XG5cbkBkZXRlY3REZWxpbVxuYDtcbiJdfQ==

package/esm5/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/on-paste-completion-items-updater/models/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9jb2RlLWVkaXRvci9pbmZyYS9jb3Jlcy9jb2RlbWlycm9yLTYvbGFuZ3VhZ2VzL3RheC1jYWxjdWxhdGlvbi9leHRlbnNpb25zL29uLXBhc3RlLWNvbXBsZXRpb24taXRlbXMtdXBkYXRlci9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qIEludGVyZmFjZXMgKi9cbmV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXMvcmVxdWVzdC1leHRyYS1pbmZvXCI7XG4iXX0=

package/esm5/components/code-editor/infra/cores/codemirror-6/languages/tax-calculation/extensions/on-paste-completion-items-updater/models/interfaces/request-extra-info.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC1leHRyYS1pbmZvLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvY29kZS1lZGl0b3IvaW5mcmEvY29yZXMvY29kZW1pcnJvci02L2xhbmd1YWdlcy90YXgtY2FsY3VsYXRpb24vZXh0ZW5zaW9ucy9vbi1wYXN0ZS1jb21wbGV0aW9uLWl0ZW1zLXVwZGF0ZXIvbW9kZWxzL2ludGVyZmFjZXMvcmVxdWVzdC1leHRyYS1pbmZvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFJlcXVlc3RFeHRyYUluZm8ge1xuICAgIHBhdGg6IHN0cmluZztcbiAgICBmaWx0ZXI6IHN0cmluZztcbn1cbiJdfQ==