@arcgis/coding-components 4.31.0-next.33 → 4.31.0-next.34

package/dist/esm/loader.js

@@ -1,11 +1,11 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
-import { b as bootstrapLazy } from './index-b16f119e.js';
-export { s as setNonce } from './index-b16f119e.js';
-import { g as globalScripts } from './app-globals-5a151155.js';
+import { b as bootstrapLazy } from './index-f65aa2e7.js';
+export { s as setNonce } from './index-f65aa2e7.js';
+import { g as globalScripts } from './app-globals-424a420a.js';
 
 const defineCustomElements = async (win, options) => {
   if (typeof window === 'undefined') return undefined;

package/dist/esm/{sql-expr-defaults-bdfdf7b4.js → sql-expr-defaults-b496e04d.js}

@@ -1,10 +1,10 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
-import { F as isNotUndefined, D as Deferred, G as safeAsyncCall, H as devToolsAwareTimeout, J as safeCall, f as fieldsToProfileValues, i as isPredefinedProfile, b as isFeatureSetDefinition, m as main, L as LanguageDefaultsBase, d as fetchT9nStringsBundle, E as EditorProfile, U as Uri } from './language-defaults-base-e68e4d35.js';
-import { g as getAssetPath } from './index-b16f119e.js';
+import { F as isNotUndefined, D as Deferred, G as safeAsyncCall, H as devToolsAwareTimeout, J as safeCall, f as fieldsToProfileValues, i as isPredefinedProfile, b as isFeatureSetDefinition, m as main, L as LanguageDefaultsBase, d as fetchT9nStringsBundle, E as EditorProfile, U as Uri } from './language-defaults-base-42358eac.js';
+import { g as getAssetPath } from './index-f65aa2e7.js';
 
 // src/framework.ts
 function retrieveComponentMembers(component, isLit) {
@@ -1251,18 +1251,6 @@ async function convertToEditorProfileDefinition(predefinedProfile, locale = "en"
     return editorProfile;
 }
 // #endregion
-// #region profile utils
-/**
- * util to retrieve fields from the $layer variable in the api context.
- */
-const getFieldsFromLayerVariable = (profile) => {
-    if (profile.variables) {
-        const layerVar = profile.variables.find((variable) => variable.name === "$layer" && variable.type === "dictionary");
-        return layerVar.properties ?? [];
-    }
-    return [];
-};
-// #endregion
 
 /**
  * Returns the sql-expression worker for the model.
@@ -1281,7 +1269,7 @@ async function getSqlExprWorker(uri) {
  * @returns sql-expression mode module
  */
 async function getMode() {
-    return await import('./sql-expr-mode-e58e1f11.js');
+    return await import('./sql-expr-mode-626418cf.js');
 }
 
 const languageId = "arcgis-sql-expression";
@@ -1336,4 +1324,4 @@ class SqlExprDefaults extends LanguageDefaultsBase {
 }
 const sqlExprDefaults = new SqlExprDefaults();
 
-export { getMode as a, getFieldsFromLayerVariable as b, getSet as g, makeController as m, sqlExprDefaults as s, useControllerManager as u, watch as w };
+export { getMode as a, getSet as g, makeController as m, sqlExprDefaults as s, useControllerManager as u, watch as w };

package/dist/esm/sql-expr-mode-626418cf.js

@@ -0,0 +1,463 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
+ * v4.31.0-next.34
+ */
+import { g as editor, P as debounce, z as languages, Q as Emitter } from './language-defaults-base-42358eac.js';
+import { s as sqlExprDefaults } from './sql-expr-defaults-b496e04d.js';
+import './index-f65aa2e7.js';
+
+/**
+ * Manager to create our sql-expression worker and client proxy
+ */
+class SqlExprWorkerManager {
+    constructor(_defaults) {
+        this._defaults = _defaults;
+        this._worker = null;
+        this._client = null;
+        // Observes the sql-expression defaults. If modified then stop the worker.
+        this._configChangeListener = this._defaults.onDidChange(() => this.stopWorker());
+    }
+    dispose() {
+        this._configChangeListener.dispose();
+        this.stopWorker();
+    }
+    stopWorker() {
+        if (this._worker) {
+            this._worker.dispose();
+            this._worker = null;
+        }
+        this._client = null;
+    }
+    async _getClientProxy() {
+        // We used createWebWorker to create or run the web worker if it isn’t already created.
+        // Otherwise, we get and return the proxy client.
+        if (!this._client) {
+            const { languageId, languageOptions } = this._defaults;
+            this._worker = editor.createWebWorker({
+                moduleId: "SqlExprWorker",
+                label: languageId,
+                createData: {
+                    languageId,
+                    languageOptions,
+                },
+            });
+            this._client = this._worker.getProxy();
+        }
+        return await this._client;
+    }
+    async getLanguageServiceWorker(...resources) {
+        const _client = await this._getClientProxy();
+        await this._worker?.withSyncedResources(resources);
+        return _client;
+    }
+}
+
+// list of properties that sit on a SQLNode and can have children
+var ChildBearingProperties;
+(function (ChildBearingProperties) {
+    ChildBearingProperties["ARGS"] = "args";
+    ChildBearingProperties["CLAUSES"] = "clauses";
+    ChildBearingProperties["ELSE"] = "else";
+    ChildBearingProperties["END"] = "end";
+    ChildBearingProperties["EXPR"] = "expr";
+    ChildBearingProperties["LEFT"] = "left";
+    ChildBearingProperties["OPERAND"] = "operand";
+    ChildBearingProperties["QUALIFIER"] = "qualifier";
+    ChildBearingProperties["RIGHT"] = "right";
+    ChildBearingProperties["START"] = "start";
+    ChildBearingProperties["VALUE"] = "value";
+})(ChildBearingProperties || (ChildBearingProperties = {}));
+// list of node types that can have children
+var ChildBearingNodeTypes;
+(function (ChildBearingNodeTypes) {
+    ChildBearingNodeTypes["CASE_EXPRESSION"] = "case-expression";
+    ChildBearingNodeTypes["EXPRESSION_LIST"] = "expression-list";
+    ChildBearingNodeTypes["FUNCTION"] = "function";
+    ChildBearingNodeTypes["INTERVAL"] = "interval";
+    ChildBearingNodeTypes["INTERVAL_QUALIFIER"] = "interval-qualifier";
+    ChildBearingNodeTypes["WHEN_CLAUSE"] = "when-clause";
+    ChildBearingNodeTypes["UNARY_EXPRESSION"] = "unary-expression";
+    ChildBearingNodeTypes["BINARY_EXPRESSION"] = "binary-expression";
+})(ChildBearingNodeTypes || (ChildBearingNodeTypes = {}));
+// use object to ensure the list matches the types from the JS api
+const castDataTypesDict = {
+    date: "DATE",
+    float: "FLOAT",
+    integer: "INTEGER",
+    real: "REAL",
+    smallint: "SMALLINT",
+    time: "TIME",
+    timestamp: "TIMESTAMP",
+    varchar: "VARCHAR",
+};
+// convert the object to a list of strings for easier use, but keep type information
+Object.values(castDataTypesDict);
+const sqlExprKeywords = [
+    "AND",
+    "AS",
+    "BETWEEN",
+    "BOTH",
+    "CASE",
+    "CAST",
+    "CURRENT_DATE",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    "DATE",
+    "DAY",
+    "ELSE",
+    "END",
+    "ESCAPE",
+    "FALSE",
+    "FLOAT",
+    "FOR",
+    "FROM",
+    "HOUR",
+    "IN",
+    "INTEGER",
+    "INTERVAL",
+    "IS",
+    "LEADING",
+    "LIKE",
+    "MINUTE",
+    "MONTH",
+    "NOT",
+    "NULL",
+    "OR",
+    "POSITION",
+    "REAL",
+    "SECOND",
+    "SMALLINT",
+    "SUBSTRING",
+    "THEN",
+    "TIME",
+    "TIMESTAMP",
+    "TIMEZONE_HOUR",
+    "TIMEZONE_MINUTE",
+    "TO",
+    "TRAILING",
+    "TRIM",
+    "TRUE",
+    "VARCHAR",
+    "WHEN",
+    "WITH",
+    "YEAR",
+    "ZONE",
+];
+const sqlExprOperators = [
+    // Logical
+    "AND",
+    "BETWEEN",
+    "IN",
+    "LIKE",
+    "NOT",
+    "OR",
+    // Predicates
+    "IS",
+    "NULL",
+];
+const sqlExprFunctions = [
+    // Conversion
+    "CAST",
+    // Datetime
+    "EXTRACT",
+    "CURRENT_DATE",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    // Mathematical
+    "ABS",
+    "ACOS",
+    "ASIN",
+    "ATAN",
+    "CEILING",
+    "COS",
+    "FLOOR",
+    "LOG",
+    "LOG10",
+    "POWER",
+    "ROUND",
+    "SIGN",
+    "SIN",
+    "TAN",
+    // String
+    "CHAR_LENGTH",
+    "COALESCE",
+    "CONCAT",
+    "LOWER",
+    "POSITION",
+    "TRIM",
+    "UPPER",
+];
+
+const sqlExprLanguageConfig = {
+    comments: {
+        lineComment: "--",
+        blockComment: ["/*", "*/"],
+    },
+    brackets: [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+    ],
+    autoClosingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+    ],
+    surroundingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+    ],
+};
+// TODO: trim down
+const sqlExprLanguageSyntax = {
+    defaultToken: "",
+    tokenPostfix: ".sql",
+    ignoreCase: true,
+    brackets: [
+        { open: "[", close: "]", token: "delimiter.square" },
+        { open: "(", close: ")", token: "delimiter.parenthesis" },
+    ],
+    keywords: sqlExprKeywords,
+    operators: sqlExprOperators,
+    builtinFunctions: sqlExprFunctions,
+    builtinVariables: [],
+    tokenizer: {
+        root: [
+            { include: "@comments" },
+            { include: "@whitespace" },
+            { include: "@numbers" },
+            { include: "@strings" },
+            { include: "@complexIdentifiers" },
+            { include: "@scopes" },
+            [/[;,.]/, "delimiter"],
+            [/[()]/, "@brackets"],
+            [
+                /[\w@#$]+/,
+                {
+                    cases: {
+                        "@operators": "operator",
+                        "@builtinVariables": "predefined",
+                        "@builtinFunctions": "predefined",
+                        "@keywords": "keyword",
+                        "@default": "identifier",
+                    },
+                },
+            ],
+            [/[<>=!%&+\-*/|~^]/, "operator"],
+        ],
+        whitespace: [[/\s+/, "white"]],
+        comments: [
+            [/--+.*/, "comment"],
+            [/\/\*/, { token: "comment.quote", next: "@comment" }],
+        ],
+        comment: [
+            [/[^*/]+/, "comment"],
+            // Not supporting nested comments, as nested comments seem to not be standard?
+            // i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
+            // [/\/\*/, { token: 'comment.quote', next: '@push' }],    // nested comment not allowed :-(
+            [/\*\//, { token: "comment.quote", next: "@pop" }],
+            [/./, "comment"],
+        ],
+        numbers: [
+            [/0[xX][0-9a-fA-F]*/, "number"],
+            [/[$][+-]*\d*(\.\d*)?/, "number"],
+            [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, "number"],
+        ],
+        strings: [
+            [/N'/, { token: "string", next: "@string" }],
+            [/'/, { token: "string", next: "@string" }],
+        ],
+        string: [
+            [/[^']+/, "string"],
+            [/''/, "string"],
+            [/'/, { token: "string", next: "@pop" }],
+        ],
+        complexIdentifiers: [[/"/, { token: "identifier.quote", next: "@quotedIdentifier" }]],
+        quotedIdentifier: [
+            [/[^"]+/, "identifier"],
+            [/""/, "identifier"],
+            [/"/, { token: "identifier.quote", next: "@pop" }],
+        ],
+        scopes: [
+            [/(BEGIN|CASE)\b/i, { token: "keyword.block" }],
+            [/END\b/i, { token: "keyword.block" }],
+            [/WHEN\b/i, { token: "keyword.choice" }],
+            [/THEN\b/i, { token: "keyword.choice" }],
+        ],
+    },
+};
+
+class SqlExprCompletionProvider {
+    constructor(_worker, _defaults) {
+        this._worker = _worker;
+        this._defaults = _defaults;
+    }
+    async provideCompletionItems(model, position) {
+        try {
+            const worker = await this._worker(model.uri);
+            const word = model.getWordUntilPosition(position);
+            const range = {
+                startLineNumber: position.lineNumber,
+                endLineNumber: position.lineNumber,
+                startColumn: word.startColumn,
+                endColumn: word.endColumn,
+            };
+            const apiContext = this._defaults.getApiContextForModel(model.uri);
+            return await worker.doComplete(model.uri.toString(), range, position, apiContext);
+        }
+        catch (err) {
+            console.error(err);
+            return { suggestions: [] };
+        }
+    }
+}
+// TODO: create DiagnosticsAdapter common class
+class SqlExprDiagnosticsAdapter {
+    constructor(_languageId, _worker, { defaults, diagnosticService, }) {
+        this._languageId = _languageId;
+        this._worker = _worker;
+        this._disposables = [];
+        this._listener = new Map();
+        this._diagnosticsService = diagnosticService;
+        this._defaults = defaults;
+        const onModelAdd = (model) => {
+            const languageId = model.getLanguageId();
+            if (languageId !== this._languageId) {
+                return;
+            }
+            const debouncedValidate = debounce(() => {
+                this._doValidate(model, languageId).catch((err) => {
+                    throw err;
+                });
+            });
+            this._listener.set(model.uri.toString(), model.onDidChangeContent(debouncedValidate));
+            this._doValidate(model, languageId).catch(console.error);
+        };
+        const onModelRemoved = (model) => {
+            const uri = model.uri.toString();
+            editor.setModelMarkers(model, this._languageId, []);
+            const listener = this._listener.get(uri);
+            if (listener) {
+                listener.dispose();
+                this._listener.delete(uri);
+            }
+        };
+        this._disposables.push(editor.onDidCreateModel(onModelAdd));
+        this._disposables.push(editor.onWillDisposeModel((model) => onModelRemoved(model)));
+        this._disposables.push(editor.onDidChangeModelLanguage((event) => {
+            onModelRemoved(event.model);
+            onModelAdd(event.model);
+        }));
+        this._disposables.push(defaults.onDidChange(() => {
+            editor.getModels().forEach((model) => {
+                if (model.getLanguageId() === this._languageId) {
+                    onModelRemoved(model);
+                    onModelAdd(model);
+                }
+            });
+        }));
+        this._disposables.push(defaults.onModelContextDidChange((key) => {
+            editor.getModels().forEach((model) => {
+                if (model.getLanguageId() === this._languageId && model.uri.toString() === key) {
+                    this._doValidate(model, this._languageId).catch(console.error);
+                }
+            });
+        }));
+        this._disposables.push({
+            dispose: () => {
+                this._listener.forEach((value) => value.dispose());
+                this._listener.clear();
+            },
+        });
+        editor.getModels().forEach(onModelAdd);
+    }
+    async _doValidate(model, languageId) {
+        if (!model.isAttachedToEditor()) {
+            return;
+        }
+        try {
+            const workerProxy = await this._worker(model.uri);
+            const context = this._defaults.getApiContextForModel(model.uri);
+            const diagnostics = await workerProxy.doValidation(model.uri.toString(), context);
+            this._diagnosticsService.fireDiagnosticsChange(model.uri, diagnostics);
+            editor.setModelMarkers(model, languageId, diagnostics);
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+}
+
+let sqlExprWorker;
+/**
+ * Returns the sql-expression worker for the model uris.
+ * @param uris The model uris for which to get the worker.
+ * @returns The sql-expression worker.
+ */
+async function getSqlExprWorker(...uris) {
+    return await new Promise((resolve, reject) => {
+        if (!sqlExprWorker) {
+            reject(new Error("sql expression worker not registered!"));
+            return;
+        }
+        resolve(sqlExprWorker(...uris));
+    });
+}
+class SqlExprDiagnosticService {
+    constructor() {
+        this._onDiagnosticsChange = new Emitter();
+    }
+    /**
+     * An event to signal changes to the diagnostics.
+     * The event value is the uri string and the diagnostics.
+     */
+    get onDiagnosticsChange() {
+        return this._onDiagnosticsChange.event;
+    }
+    /**
+     * Fires the diagnostics change event.
+     * @param uri The uri of the model for which the diagnostics changed.
+     * @param diagnostics The diagnostics for the model.
+     */
+    fireDiagnosticsChange(uri, diagnostics) {
+        this._onDiagnosticsChange.fire({ uri, diagnostics });
+    }
+}
+const sqlExprDiagnosticService = new SqlExprDiagnosticService();
+/**
+ *
+ * @returns The Sql Expression Diagnostic Service.
+ */
+function getSqlExprDiagnosticService() {
+    return sqlExprDiagnosticService;
+}
+function setupMode(defaults) {
+    const client = new SqlExprWorkerManager(defaults);
+    const workerAccessor = async (...uris) => await client.getLanguageServiceWorker(...uris);
+    sqlExprWorker = workerAccessor;
+    // Use the sql-expression Monarch Json to define the highlighting
+    languages.setMonarchTokensProvider(sqlExprDefaults.languageId, sqlExprLanguageSyntax);
+    languages.setLanguageConfiguration(sqlExprDefaults.languageId, sqlExprLanguageConfig);
+    const completionProvider = new SqlExprCompletionProvider(workerAccessor, sqlExprDefaults);
+    languages.registerCompletionItemProvider(sqlExprDefaults.languageId, completionProvider);
+    // Creates and registers a Completion Adapter
+    // Registers a completion item provider for our custom language
+    // TODO: Creates and registers a Formatter
+    // languages.registerDocumentFormattingEditProvider(
+    //   SqlExprDefaults.languageId,
+    //   new FormattingProvider(workerAccessor, SqlExprDefaults),
+    // );
+    // eslint-disable-next-line no-new
+    new SqlExprDiagnosticsAdapter(defaults.languageId, workerAccessor, {
+        defaults,
+        diagnosticService: sqlExprDiagnosticService,
+    });
+}
+
+export { getSqlExprDiagnosticService, getSqlExprWorker, setupMode };

package/dist/esm/{tsMode-31b5e806.js → tsMode-50c3b01e.js}

@@ -1,9 +1,9 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
-import { N as typescriptDefaults, M as monaco_editor_core_star } from './language-defaults-base-e68e4d35.js';
+import { N as typescriptDefaults, M as monaco_editor_core_star } from './language-defaults-base-42358eac.js';
 
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.

package/dist/esm/{typescript-b2aa1d45.js → typescript-20e50254.js}

@@ -1,9 +1,9 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
-import { M as monaco_editor_core_star } from './language-defaults-base-e68e4d35.js';
+import { M as monaco_editor_core_star } from './language-defaults-base-42358eac.js';
 
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.

package/dist/loader/cdn.js

@@ -1,6 +1,6 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
 module.exports = require('../cjs/loader.cjs.js');

package/dist/loader/index.cjs.js

@@ -1,6 +1,6 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
 module.exports = require('../cjs/loader.cjs.js');

package/dist/loader/index.es2017.js

@@ -1,6 +1,6 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
 export * from '../esm/loader.js';

package/dist/loader/index.js

@@ -1,7 +1,7 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.33
+ * v4.31.0-next.34
  */
 (function(){if("undefined"!==typeof window&&void 0!==window.Reflect&&void 0!==window.customElements){var a=HTMLElement;window.HTMLElement=function(){return Reflect.construct(a,[],this.constructor)};HTMLElement.prototype=a.prototype;HTMLElement.prototype.constructor=HTMLElement;Object.setPrototypeOf(HTMLElement,a)}})();
 export * from '../esm/loader.js';

package/dist/types/data/arcgis-web-compoments/actions-runner-1/_work/arcgis-web-components/arcgis-web-components/packages/coding-packages/coding-components/.stencil/stencil.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from "../../../../../../../../../../stencil-public-runtime";
+declare const config: Config;
+export { config };

package/dist/types/utils/sql-expr-monaco/sql-expr-completion.d.ts

@@ -1,6 +1,56 @@
-import * as monaco from "monaco-editor";
-import type { ApiItem, ApiVariable } from "@arcgis/languages-api-utils";
-export declare function sqlExpressionCompletion(range: monaco.IRange, model: monaco.editor.ITextModel, position: monaco.Position, sdkFunctions: Record<string, ApiItem>): Promise<monaco.languages.CompletionItem[]>;
-/** source  */
-export declare const sqlBinOps: string[];
-export declare function generateCompletionItems(fields: ApiVariable[], range: monaco.IRange, sdkFunctions: Record<string, ApiItem>): Record<"fieldsCompletion" | "sqlBinOpsCompletion" | "sqlDataTypeCompletion" | "sqlFunctionCompletion" | "sqlKeywordsCompletion", monaco.languages.CompletionItem[]>;
+/**
+ * @remarks This module is only intended to be loaded within the SQL expression worker.
+ */
+import type { IRange, Position, languages } from "monaco-editor";
+import type { ApiDatabase, ApiVariable } from "@arcgis/languages-api-utils";
+import type { ICompletionContext } from "./types";
+/**
+ * Class used for sql expression completion
+ */
+export declare class SqlExpressionCompletion {
+    private _sdkFunctions;
+    private _fields;
+    constructor(sdkLibrary: ApiDatabase, fields: ApiVariable[]);
+    getCompletions(range: IRange, modelContent: string, position: Position): Promise<languages.CompletionItem[]>;
+    /**
+     * traverses the tree to find the node that contains the current position
+     * @param node The current node to traverse
+     * @param position The current position
+     */
+    traverse(node: __esri.SQLNode, completionContext: ICompletionContext): void;
+    /**
+     * gets completions by finding the context of the current node and suggesting completions based on that context
+     */
+    private _getCompletions;
+    /**
+     * utilizes peggy's error handling to provide suggestions for the user.
+     */
+    private handleParserFailure;
+    /**
+     * gets completions based on the function node
+     * @param context the context root of the current node, see {@link identifyContextRoot}
+     * @param slotPosition the position of the current node in the context root, see {@link getSlotPosition}
+     * @param completionContext the completion context
+     */
+    private _getCompletionsFromFunction;
+    /**
+     * checks if the position is within the current node
+     * @param node The current node to check
+     * @param position The current position
+     * @returns boolean
+     */
+    private _isPositionWithinNode;
+    private _suggestFields;
+    private _suggestFunctions;
+    private _suggestDataTypes;
+    private _suggestDatePeriods;
+    private _suggestTrimParts;
+    private _suggestDateLiterals;
+    private _suggestExpressions;
+    private _suggestNull;
+    /**
+     * looks at the node and finds any children attached to it. If there are children, it will traverse them.
+     * @param node The current node to traverse
+     */
+    private _traverseChildren;
+}