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

package/dist/cjs/{app-globals-18ba6880.js → app-globals-bade840e.js}

@@ -1,7 +1,7 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
- * See https://js.arcgis.com/4.30/esri/copyright.txt for details.
- * v4.30.0
+ * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
+ * v4.31.0-next.10
  */
 'use strict';
 

package/dist/cjs/arcade-defaults-8b8d6c07.js

@@ -0,0 +1,116 @@
+/*!
+ * 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 index = require('./index-37a86ff4.js');
+
+/**
+ * Returns the arcade diagnostic service.
+ * Example:
+ * ```ts
+ * const diagnosticService = await getArcadeDiagnosticService();
+ * diagnosticService.onDidChangeDiagnostics(({uri, diaganostics }) => {
+ *  // Filter the diagnostics for the uri of interest
+ *  // Do something with the diagnostics
+ * });
+ * ```
+ */
+async function getArcadeDiagnosticService() {
+    const mode = await getMode();
+    return mode.getArcadeDiagnosticService();
+}
+/**
+ * Returns the arcade worker for the model.
+ * Example:
+ * ```ts
+ * const arcadeWorker = await getArcadeWorker(model.uri);
+ * ```
+ * @returns arcade worker
+ */
+async function getArcadeWorker(uri) {
+    const mode = await getMode();
+    return await mode.getArcadeWorker(uri);
+}
+/**
+ * Request the arcade mode
+ * @returns arcade mode module
+ */
+async function getMode() {
+    return await Promise.resolve().then(function () { return require('./arcade-mode-dce44622.js'); });
+}
+
+const arcadeLanguageId = "arcade";
+class ArcadeLanguageServiceDefaults extends languageDefaultsBase.LanguageDefaultsBase {
+    constructor() {
+        super(...arguments);
+        this._languageId = arcadeLanguageId;
+        this._languageOptions = {};
+    }
+    /**
+     * Create an EditorProfile for the given model id using the given definition and locale.
+     * The EditorProfile is used by the the Arcade Language service as well by the cosing components.
+     * The definition can be a pre-defined profile or an editor profile definition.
+     * If the locale is not provided then the 'en' locale is used.
+     * @param modelId The model id for which to create the context.
+     * @param definition The definition to use for the model context.
+     * @param locale The locale to use for the model context.
+     * @returns The EditorProfile for the model.
+     */
+    async setProfileForModel(modelId, definition, apiContext = { locale: "en" }) {
+        // Convert pre-defined profile to a runtime profile
+        if (languageDefaultsBase.isPredefinedProfile(definition)) {
+            definition = await languageDefaultsBase.convertToEditorProfileDefinition(definition, apiContext.locale);
+        }
+        const profileStrings = await languageDefaultsBase.fetchT9nStringsBundle(apiContext.locale, index.getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
+        if (!profileStrings) {
+            throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
+        }
+        this.disposeForModel(modelId);
+        const key = this._getApiKey(modelId);
+        const editorProfile = new languageDefaultsBase.EditorProfile(definition, profileStrings);
+        this._profileMap.set(key, editorProfile);
+        const apiProfile = await editorProfile.toLSProfile();
+        this.updateApiContextForModel(modelId, {
+            locale: apiContext.locale,
+            profile: apiProfile,
+            snippets: apiContext.snippets,
+        });
+    }
+    /**
+     * Set or update the Arcade language service options.
+     * @param languageOptions The language options to set.
+     */
+    setLanguageOptions(languageOptions = {}) {
+        // Check if options have actually changed.
+        // Avoid restarting the worker when no updates.
+        // Today we only have the 'assetsPath' as a property
+        if (this._languageOptions.assetsPath === languageOptions.assetsPath) {
+            return;
+        }
+        this._languageOptions = { ...this._languageOptions, ...languageOptions };
+        this._onDidChange.fire(this);
+    }
+    /**
+     * Gets the API library for the given model id.
+     * @param modelId The model id for which to get the API library.
+     * @returns The API library for the model.
+     */
+    async getApiLibrary(modelId) {
+        const uri = languageDefaultsBase.Uri.parse(modelId);
+        const worker = await getArcadeWorker(uri);
+        return await worker.getApiLibrary(this.getApiContextForModel(uri));
+    }
+}
+const arcadeDefaults = new ArcadeLanguageServiceDefaults();
+const arcade = {
+    setProfileForModel: arcadeDefaults.setProfileForModel.bind(arcadeDefaults),
+};
+
+exports.arcade = arcade;
+exports.arcadeDefaults = arcadeDefaults;
+exports.getArcadeDiagnosticService = getArcadeDiagnosticService;
+exports.getMode = getMode;

package/dist/cjs/arcade-language-features-747fb1da.js

@@ -0,0 +1,274 @@
+/*!
+ * 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');
+
+//#region Diagnostic
+class DiagnosticsAdapter {
+    constructor(_languageId, _worker, { defaults, diagnosticsService, }) {
+        this._languageId = _languageId;
+        this._worker = _worker;
+        this._disposables = [];
+        this._listener = new Map();
+        this._diagnosticsService = diagnosticsService;
+        this._defaults = defaults;
+        const onModelAdd = (model) => {
+            const languageId = model.getLanguageId();
+            if (languageId !== this._languageId) {
+                return;
+            }
+            const debouncedValidate = languageDefaultsBase.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 uriStr = model.uri.toString();
+            languageDefaultsBase.editor.setModelMarkers(model, this._languageId, []);
+            const listener = this._listener.get(uriStr);
+            if (listener) {
+                listener.dispose();
+                this._listener.delete(uriStr);
+            }
+        };
+        this._disposables.push(languageDefaultsBase.editor.onDidCreateModel(onModelAdd));
+        this._disposables.push(languageDefaultsBase.editor.onWillDisposeModel((model) => {
+            onModelRemoved(model);
+        }));
+        this._disposables.push(languageDefaultsBase.editor.onDidChangeModelLanguage((event) => {
+            onModelRemoved(event.model);
+            onModelAdd(event.model);
+        }));
+        this._disposables.push(defaults.onDidChange(() => {
+            languageDefaultsBase.editor.getModels().forEach((model) => {
+                if (model.getLanguageId() === this._languageId) {
+                    onModelRemoved(model);
+                    onModelAdd(model);
+                }
+            });
+        }));
+        this._disposables.push(defaults.onModelContextDidChange((key) => {
+            languageDefaultsBase.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();
+            },
+        });
+        languageDefaultsBase.editor.getModels().forEach(onModelAdd);
+    }
+    dispose() {
+        this._disposables.forEach((d) => d.dispose());
+        this._disposables = [];
+    }
+    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);
+            const markers = diagnostics.map((d) => toMarker(model.uri, d));
+            this._diagnosticsService.fireDiagnosticsChange(model.uri, diagnostics);
+            languageDefaultsBase.editor.setModelMarkers(model, languageId, markers);
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+}
+function toSeverity(languageServiceSeverity) {
+    switch (languageServiceSeverity) {
+        case languageDefaultsBase.main.exports.DiagnosticSeverity.Error:
+            return languageDefaultsBase.MarkerSeverity.Error;
+        case languageDefaultsBase.main.exports.DiagnosticSeverity.Warning:
+            return languageDefaultsBase.MarkerSeverity.Warning;
+        case languageDefaultsBase.main.exports.DiagnosticSeverity.Information:
+            return languageDefaultsBase.MarkerSeverity.Info;
+        case languageDefaultsBase.main.exports.DiagnosticSeverity.Hint:
+            return languageDefaultsBase.MarkerSeverity.Hint;
+        default:
+            return languageDefaultsBase.MarkerSeverity.Info;
+    }
+}
+function toMarker(_resource, diag) {
+    // Diagnostics positions are zero-based, MarkerData are 1-based
+    return {
+        severity: toSeverity(diag.severity),
+        startLineNumber: diag.range.start.line + 1,
+        startColumn: diag.range.start.character + 1,
+        endLineNumber: diag.range.end.line + 1,
+        endColumn: diag.range.end.character + 1,
+        message: diag.message,
+    };
+}
+//#endregion
+//#region Completion
+function fromPosition(position) {
+    // Language service is zero based
+    return { character: position.column - 1, line: position.lineNumber - 1 };
+}
+function toRange(range) {
+    return new languageDefaultsBase.Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
+}
+function toTextEdit(textEdit) {
+    return {
+        range: toRange(textEdit.range),
+        text: textEdit.newText,
+    };
+}
+function isInsertReplaceEdit(edit) {
+    return (typeof edit.insert !== "undefined" &&
+        typeof edit.replace !== "undefined");
+}
+// TODO: extract this function to common util
+function toCompletionItemKind(kind) {
+    const mItemKind = languageDefaultsBase.languages.CompletionItemKind;
+    switch (kind) {
+        case languageDefaultsBase.main.exports.CompletionItemKind.Text:
+            return mItemKind.Text;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Method:
+            return mItemKind.Method;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Function:
+            return mItemKind.Function;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Constructor:
+            return mItemKind.Constructor;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Field:
+            return mItemKind.Field;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Variable:
+            return mItemKind.Variable;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Class:
+            return mItemKind.Class;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Interface:
+            return mItemKind.Interface;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Module:
+            return mItemKind.Module;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Property:
+            return mItemKind.Property;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Unit:
+            return mItemKind.Unit;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Value:
+            return mItemKind.Value;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Enum:
+            return mItemKind.Enum;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Keyword:
+            return mItemKind.Keyword;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Snippet:
+            return mItemKind.Snippet;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Color:
+            return mItemKind.Color;
+        case languageDefaultsBase.main.exports.CompletionItemKind.File:
+            return mItemKind.File;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Reference:
+            return mItemKind.Reference;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Folder:
+            return mItemKind.Folder;
+        case languageDefaultsBase.main.exports.CompletionItemKind.EnumMember:
+            return mItemKind.EnumMember;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Constant:
+            return mItemKind.Constant;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Struct:
+            return mItemKind.Struct;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Event:
+            return mItemKind.Event;
+        case languageDefaultsBase.main.exports.CompletionItemKind.Operator:
+            return mItemKind.Operator;
+        case languageDefaultsBase.main.exports.CompletionItemKind.TypeParameter:
+            return mItemKind.TypeParameter;
+        default:
+            return mItemKind.Property;
+    }
+}
+class CompletionProvider {
+    constructor(_worker, _defaults) {
+        this._worker = _worker;
+        this._defaults = _defaults;
+        this.triggerCharacters = [".", "("];
+    }
+    async provideCompletionItems(model, position) {
+        const worker = await this._worker(model.uri);
+        const context = this._defaults.getApiContextForModel(model.uri);
+        const completionList = await worker.doComplete(model.uri.toString(), fromPosition(position), context);
+        const wordInfo = model.getWordUntilPosition(position);
+        const wordRange = new languageDefaultsBase.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+        const items = completionList.items.map((entry) => {
+            const item = {
+                label: entry.label,
+                insertText: entry.insertText || entry.label,
+                sortText: entry.sortText,
+                filterText: entry.filterText,
+                detail: entry.detail,
+                range: wordRange,
+                kind: toCompletionItemKind(entry.kind),
+            };
+            if (entry.textEdit) {
+                if (isInsertReplaceEdit(entry.textEdit)) {
+                    item.range = {
+                        insert: toRange(entry.textEdit.insert),
+                        replace: toRange(entry.textEdit.replace),
+                    };
+                }
+                else {
+                    item.range = toRange(entry.textEdit.range);
+                }
+                item.insertText = entry.textEdit.newText;
+            }
+            if (entry.additionalTextEdits) {
+                item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
+            }
+            if (entry.insertTextFormat === languageDefaultsBase.main.exports.InsertTextFormat.Snippet) {
+                item.insertTextRules = languageDefaultsBase.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+            }
+            if (entry.documentation) {
+                if (typeof entry.documentation === "string") {
+                    item.documentation = entry.documentation;
+                }
+                else {
+                    item.documentation = {
+                        supportThemeIcons: false,
+                        value: entry.documentation.value,
+                        supportHtml: true,
+                    };
+                }
+            }
+            return item;
+        });
+        return {
+            incomplete: completionList.isIncomplete,
+            suggestions: items,
+        };
+    }
+}
+//#endregion
+//#region Formatter
+class FormattingProvider {
+    constructor(_worker, _defaults) {
+        this._worker = _worker;
+        this._defaults = _defaults;
+    }
+    async provideDocumentFormattingEdits(model) {
+        const worker = await this._worker(model.uri);
+        const context = this._defaults.getApiContextForModel(model.uri.toString());
+        const edits = await worker.doFormat(model.uri.toString(), context);
+        return edits.map((e) => ({ range: toRange(e.range), text: e.newText }));
+    }
+}
+//#endregion
+
+exports.CompletionProvider = CompletionProvider;
+exports.DiagnosticsAdapter = DiagnosticsAdapter;
+exports.FormattingProvider = FormattingProvider;
+exports.toCompletionItemKind = toCompletionItemKind;