@arcgis/coding-components 4.30.0 → 4.31.0-next.10

package/dist/cjs/arcade-mode-dce44622.js

@@ -0,0 +1,336 @@
+/*!
+ * 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.10
+ */
+'use strict';
+
+const languageDefaultsBase = require('./language-defaults-base-b32cb091.js');
+const arcadeLanguageFeatures = require('./arcade-language-features-747fb1da.js');
+require('./index-37a86ff4.js');
+
+var V={False:"false",Null:"null",True:"true"},f={Break:"break",Continue:"continue",Else:"else",For:"for",From:"from",Function:"function",If:"if",Import:"import",Export:"export",In:"in",Return:"return",Var:"var",While:"while"},Ee=["++","--"],Je=["-","+","!","~"],Qe=["=","/=","*=","%=","+=","-="],Ze=["||","&&"],Lt=["|","&",">>","<<",">>>","^","==","!=","<","<=",">",">=","+","-","*","/","%"];var U=[[],[],[]];Ee.forEach(t=>U[t.length-1]?.push(t));Je.forEach(t=>U[t.length-1]?.push(t));Ze.forEach(t=>U[t.length-1]?.push(t));Qe.forEach(t=>U[t.length-1]?.push(t));Lt.forEach(t=>U[t.length-1]?.push(t));var ft=Object.values(f),gt=Object.values(V);gt.map(t=>({label:t,kind:languageDefaultsBase.main.exports.CompletionItemKind.Constant}));ft.map(t=>({label:t,kind:languageDefaultsBase.main.exports.CompletionItemKind.Keyword}));
+
+const operators = [
+    "<=",
+    ">=",
+    "==",
+    "!=",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "++",
+    "--",
+    "<<",
+    ">>",
+    ">>>",
+    "&",
+    "|",
+    "^",
+    "!",
+    "~",
+    "&&",
+    "||",
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "**=",
+    "/=",
+    "%=",
+];
+const arcadeLanguageConfiguration = {
+    // the default separators except `@$`
+    wordPattern: /(-?\d*\.\d\w*)|([^`~!#%\^&\*\(\)\-=\+\[\{\]\}\\\|;:'",\.<>\/\?\s]+)/gu,
+    comments: {
+        lineComment: "//",
+        blockComment: ["/*", "*/"],
+    },
+    brackets: [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+    ],
+    autoClosingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: '"', close: '"', notIn: ["string"] },
+        { open: "'", close: "'", notIn: ["string", "comment"] },
+        { open: "`", close: "`", notIn: ["string", "comment"] },
+    ],
+    autoCloseBefore: ";:.,=}])` \n\t",
+    folding: {
+        markers: {
+            start: /^\s*\/\/\s*#?region\b/u,
+            end: /^\s*\/\/\s*#?endregion\b/u,
+        },
+    },
+    indentationRules: {
+        // ^(.*\*/)?\s*\}.*$
+        decreaseIndentPattern: /^((?!.*?\/\*).*\*\/)?\s*[\}\]\)].*$/u,
+        // ^.*\{[^}"']*$
+        increaseIndentPattern: /^((?!\/\/).)*(\{[^}"'`]*|\([^)"'`]*|\[[^\]"'`]*)$/u,
+    },
+};
+const arcadeMonarchLanguage = {
+    // Set defaultToken to invalid to see what you do not tokenize yet
+    defaultToken: "invalid",
+    tokenPostfix: ".arc",
+    // Arcade is case insensitive
+    ignoreCase: true,
+    // builtinFunctions: [...arcadeService.FunctionNames],
+    // Arcade keywords. 'from' is a special case as we want to treat it as a keyword in
+    // import statement but as an identifer in var statement.
+    keywords: ft.filter((k) => k !== "from"),
+    operators,
+    constants: ["true", "false", "null"],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/u,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/u,
+    digits: /\d+(_+\d+)*/u,
+    octaldigits: /[0-7]+(_+[0-7]+)*/u,
+    binarydigits: /[0-1]+(_+[0-1]+)*/u,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/u,
+    regexpctl: /[(){}\[\]\$\^|\-*+?\.]/u,
+    regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/u,
+    // The main tokenizer for our languages
+    tokenizer: {
+        root: [[/[{}]/u, "delimiter.bracket"], { include: "common" }],
+        common: [
+            // import statement. import followed by a white space
+            [/import(?=\s)/u, { token: "keyword", next: "@import" }],
+            // identifiers and keywords
+            [
+                /[a-z_$][\w$]*/u,
+                {
+                    cases: {
+                        "@constants": "constant",
+                        "@keywords": "keyword",
+                        "@default": "identifier",
+                    },
+                },
+            ],
+            // whitespace
+            { include: "@whitespace" },
+            // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+            [
+                /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|\/|,|\)|\]|\}|$))/u,
+                { token: "regexp", bracket: "@open", next: "@regexp" },
+            ],
+            // delimiters and operators
+            [/[()\[\]]/u, "@brackets"],
+            [/[<>](?!@symbols)/u, "@brackets"],
+            [
+                /@symbols/u,
+                {
+                    cases: {
+                        "@operators": "delimiter",
+                        "@default": "",
+                    },
+                },
+            ],
+            // numbers
+            [/(@digits)[eE]([\-+]?(@digits))?/u, "number"],
+            [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/u, "number"],
+            [/0[xX](@hexdigits)/u, "number"],
+            [/0[oO]?(@octaldigits)/u, "number"],
+            [/0[bB](@binarydigits)/u, "number"],
+            [/(@digits)/u, "number"],
+            // delimiter: after number because of .\d floats
+            [/[;,.]/u, "delimiter"],
+            // strings
+            [/"([^"\\]|\\.)*$/u, "string.invalid"], // non-teminated string
+            [/'([^'\\]|\\.)*$/u, "string.invalid"], // non-teminated string
+            [/"/u, "string", "@string_double"],
+            [/'/u, "string", "@string_single"],
+            [/`/u, "string", "@string_backtick"],
+        ],
+        import: [
+            // import keyword
+            [/import(?=\s)/u, { token: "keyword" }],
+            // whitespace
+            { include: "@whitespace" },
+            // identifier
+            [/[a-z_$][\w$]*/u, "identifier"],
+            // whitespace
+            { include: "@whitespace" },
+            // from keyword
+            [/from/u, { token: "keyword", next: "@popall" }],
+        ],
+        whitespace: [
+            [/[ \t\r\n]+/u, ""],
+            [/\/\*/u, "comment", "@comment"],
+            [/\/\/.*$/u, "comment"],
+        ],
+        comment: [
+            [/[^\/*]+/u, "comment"],
+            [/\*\//u, "comment", "@pop"],
+            [/[\/*]/u, "comment"],
+        ],
+        // We match regular expression quite precisely
+        regexp: [
+            [/(\{)(\d+(?:,\d*)?)(\})/u, ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]],
+            [
+                /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/u,
+                ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }],
+            ],
+            [/(\()(\?:|\?=|\?!)/u, ["regexp.escape.control", "regexp.escape.control"]],
+            [/[()]/u, "regexp.escape.control"],
+            [/@regexpctl/u, "regexp.escape.control"],
+            [/[^\\\/]/u, "regexp"],
+            [/@regexpesc/u, "regexp.escape"],
+            [/\\\./u, "regexp.invalid"],
+            [/(\/)([gimsuy]*)/u, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]],
+        ],
+        regexrange: [
+            [/-/u, "regexp.escape.control"],
+            [/\^/u, "regexp.invalid"],
+            [/@regexpesc/u, "regexp.escape"],
+            [/[^\]]/u, "regexp"],
+            [/\]/u, { token: "regexp.escape.control", next: "@pop", bracket: "@close" }],
+        ],
+        string_double: [
+            [/[^\\"]+/u, "string"],
+            [/@escapes/u, "string.escape"],
+            [/\\./u, "string.escape.invalid"],
+            [/"/u, "string", "@pop"],
+        ],
+        string_single: [
+            [/[^\\']+/u, "string"],
+            [/@escapes/u, "string.escape"],
+            [/\\./u, "string.escape.invalid"],
+            [/'/u, "string", "@pop"],
+        ],
+        string_backtick: [
+            [/\$\{/u, { token: "delimiter.bracket", next: "@bracketCounting" }],
+            [/[^\\`$]+/u, "string"],
+            [/@escapes/u, "string.escape"],
+            [/\\./u, "string.escape.invalid"],
+            [/`/u, "string", "@pop"],
+        ],
+        bracketCounting: [
+            [/\{/u, "delimiter.bracket", "@bracketCounting"],
+            [/\}/u, "delimiter.bracket", "@pop"],
+            { include: "common" },
+        ],
+    },
+};
+
+/**
+ * Manager to create our arcade worker and client proxy
+ */
+class WorkerManager {
+    constructor(_defaults) {
+        this._defaults = _defaults;
+        this._worker = null;
+        this._client = null;
+        // Observes the arcade 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 = languageDefaultsBase.editor.createWebWorker({
+                moduleId: "ArcadeWorker",
+                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;
+    }
+}
+
+let arcadeWorker;
+/**
+ * Returns the arcade worker for the model uris.
+ * @param uris The model uris for which to get the worker.
+ * @returns The arcade worker.
+ */
+async function getArcadeWorker(...uris) {
+    return await new Promise((resolve, reject) => {
+        if (!arcadeWorker) {
+            reject(new Error("TypeScript not registered!"));
+            return;
+        }
+        resolve(arcadeWorker(...uris));
+    });
+}
+/**
+ * The Arcade Language Diagnostic Service.
+ * Consumers can listen to the diagnostics change event to get notified when the diagnostics change.
+ */
+class ArcadeDiagnosticService {
+    constructor() {
+        this._onDiagnosticsChange = new languageDefaultsBase.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 arcadeDiagnosticService = new ArcadeDiagnosticService();
+/**
+ * Get the Arcade Diagnostic Service.
+ * @returns The Arcade Language Diagnostic Service.
+ */
+function getArcadeDiagnosticService() {
+    return arcadeDiagnosticService;
+}
+function setupMode(arcadeDefaults) {
+    const client = new WorkerManager(arcadeDefaults);
+    const workerAccessor = async (...uris) => await client.getLanguageServiceWorker(...uris);
+    arcadeWorker = workerAccessor;
+    // Use the arcade Monarch Json to define the highlighting
+    languageDefaultsBase.languages.setMonarchTokensProvider(arcadeDefaults.languageId, arcadeMonarchLanguage);
+    languageDefaultsBase.languages.setLanguageConfiguration(arcadeDefaults.languageId, arcadeLanguageConfiguration);
+    // Creates and registers a Completion Adapter
+    languageDefaultsBase.languages.registerCompletionItemProvider(arcadeDefaults.languageId, new arcadeLanguageFeatures.CompletionProvider(workerAccessor, arcadeDefaults));
+    // Creates and registers a Formatter
+    languageDefaultsBase.languages.registerDocumentFormattingEditProvider(arcadeDefaults.languageId, new arcadeLanguageFeatures.FormattingProvider(workerAccessor, arcadeDefaults));
+    // Creates a Diagnostic Adapter
+    // eslint-disable-next-line no-new
+    new arcadeLanguageFeatures.DiagnosticsAdapter(arcadeDefaults.languageId, workerAccessor, {
+        defaults: arcadeDefaults,
+        diagnosticsService: arcadeDiagnosticService,
+    });
+}
+
+exports.getArcadeDiagnosticService = getArcadeDiagnosticService;
+exports.getArcadeWorker = getArcadeWorker;
+exports.setupMode = setupMode;