@arcgis/coding-components 4.31.0-next.2 → 4.31.0-next.21

package/dist/components/arcade-defaults.js

@@ -1,253 +1,59 @@
 /*!
  * 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.2
+ * v4.31.0-next.21
  */
-import { Emitter, Uri } from 'monaco-editor';
+import { Uri } from 'monaco-editor';
+import { f as fieldsToProfileValues, i as isPredefinedProfile, a as isFeatureSetCollectionDefinition, b as isFeatureSetDefinition, c as isFeatureDefinition, L as LanguageDefaultsBase, E as EditorProfile } from './language-defaults-base.js';
+import { s as supportedLocales, f as fetchT9nStringsBundle } from './index2.js';
 import { CompletionItemKind, InsertTextMode, InsertTextFormat } from 'vscode-languageserver-types';
-import { n as newLayersFeatureLayer, i as importRequest, s as supportedFields, a as newPortalPortalItem, b as newWebScene, c as newWebMap, f as fieldAlias, d as fieldTypeToIconName, e as fieldTypeToArcadeType } from './fields.js';
-import { p as portalItemPageUrl } from './utilities.js';
-import { i as isNotNull, a as isNotUndefined, b as addLTRMark, s as setValuesInString, c as supportedLocales, f as fetchT9NStringsBundle } from './index2.js';
 import { getArcgisAssetPath as getAssetPath } from "./arcgis-assets.js";
 
-//#region Type Guards
-function isQueryableLayerInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        item.declaredClass.startsWith("esri.layers.") &&
-        "fields" in item &&
-        "queryFeatures" in item &&
-        typeof item.queryFeatures === "function");
-}
-function isSubtypeSublayerInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        item.declaredClass === "esri.layers.support.SubtypeSublayer");
-}
-function isGroupLayerInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        item.declaredClass === "esri.layers.GroupLayer");
-}
-function isMapInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        (item.declaredClass === "esri.Map" ||
-            item.declaredClass === "esri.WebMap" ||
-            item.declaredClass === "esri.WebScene"));
-}
-function isWebMapInstance(item) {
-    return item.declaredClass === "esri.WebMap";
-}
-function isWebSceneInstance(item) {
-    return item.declaredClass === "esri.WebScene";
-}
-function isLoadableMapInstance(item) {
-    return item.declaredClass === "esri.WebMap" || item.declaredClass === "esri.WebScene";
-}
-function isPortalItemDefinition(item) {
-    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
-}
-function isFeatureLayerItemDefinition(item) {
-    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
-}
-function isFieldsDefinition(item) {
-    return !!item && typeof item === "object" && "fields" in item && Array.isArray(item.fields);
-}
-function isUrlDefinition(item) {
-    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
-}
-function isSupportedServiceUrlDefinition(item) {
-    return isUrlDefinition(item) && /\/(?:featureserver|mapserver)(?:\/|$)/iu.test(item.url);
-}
-function isSubtypeInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        item.declaredClass === "esri.layers.support.Subtype");
-}
-function isCodedValueDomainInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        item.declaredClass === "esri.layers.support.CodedValueDomain");
-}
-function isInheritedDomainInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        item.declaredClass === "esri.layers.support.InheritedDomain");
-}
-function isPredefinedProfile(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "id" in item &&
-        typeof item.id === "string" &&
-        "definitions" in item &&
-        typeof item.definitions === "object" &&
-        !Array.isArray(item.definitions));
-}
-function isTitleCapableSource(item) {
-    return !!item && typeof item === "object" && "title" in item && typeof item.title === "string";
-}
-function isUrlCapableSource(item) {
-    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
-}
-function isLayerIdCapableSource(item) {
-    return !!item && typeof item === "object" && "layerId" in item && typeof item.layerId === "number";
-}
-function isFeatureTypesCapableLayer(item) {
-    return !!item && typeof item === "object" && "typeIdField" in item && "types" in item;
-}
-function isDomainsCapableLayer(item) {
-    return !!item && typeof item === "object" && "getFieldDomain" in item && typeof item.getFieldDomain === "function";
-}
-function isSubtypeFieldCapableLayer(item) {
-    return !!item && typeof item === "object" && "subtypeField" in item;
-}
-function isSubtypesCapableLayer(item) {
-    return isSubtypeFieldCapableLayer(item) && "subtypes" in item;
-}
-function isRelationshipsCapableLayer(item) {
-    return (isLayerIdCapableSource(item) &&
-        "relationships" in item &&
-        "url" in item &&
-        Array.isArray(item.relationships) &&
-        typeof item.url === "string");
-}
-function isTableCapableLayer(item) {
-    return !!item && typeof item === "object" && "isTable" in item && typeof item.isTable === "boolean";
-}
-function isLoadableSource(item) {
-    return !!item && typeof item === "object" && "load" in item && typeof item.load === "function";
-}
-//#endregion
-//#region Service Metadata
-async function supportedSourceFromDefinition(definition) {
-    if (!definition) {
-        return null;
-    }
-    let source = null;
-    if (isFieldsDefinition(definition)) {
-        source = definition;
-    }
-    else {
-        source = await newLayersFeatureLayer(definition);
-    }
-    if (isLoadableSource(source)) {
-        await source.load();
-    }
-    return source;
+/**
+ * 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();
 }
-async function serviceMetaData(url) {
-    url += "/layers";
-    const request = await importRequest();
-    const response = await request(url, { responseType: "json", query: { f: "json" } });
-    const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
-    const layers = getSupportedLayerInfos(response.data?.layers, queryCapability);
-    const tables = getSupportedLayerInfos(response.data?.tables, queryCapability);
-    return { layers, tables };
+/**
+ * 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);
 }
-function getSupportedLayerInfos(layers, queryCapability) {
-    if (!layers) {
-        return [];
-    }
-    return layers.filter((layer) => {
-        switch (layer.type) {
-            case "Feature Layer":
-            case "Oriented Imagery Layer":
-            case "Catalog Layer":
-            case "Table": {
-                const capabilities = layer.capabilities
-                    ? layer.capabilities
-                        .toLowerCase()
-                        .split(",")
-                        .map((value) => value.trim())
-                    : [];
-                return capabilities.includes(queryCapability);
-            }
-            default:
-                return false;
-        }
-    });
+/**
+ * Request the arcade mode
+ * @returns arcade mode module
+ */
+async function getMode() {
+    return await import('./arcade-mode.js');
 }
-//#endregion
 
-//#endregion
-//#region Support functions
-async function getRelatedFeatureLayer(layer, relationship) {
-    const relatedFeatureLayer = await newLayersFeatureLayer({ url: `${layer.url}/${relationship.relatedTableId}` });
-    await relatedFeatureLayer.load();
-    return relatedFeatureLayer;
-}
-function sortFields(layer) {
-    return (firstField, secondField) => {
-        if (firstField.type === "oid") {
-            return -1;
-        }
-        if (secondField.type === "oid") {
-            return 1;
-        }
-        if (isSubtypeSublayerInstance(layer)) {
-            if (firstField.name === layer.parent.subtypeField) {
-                return -1;
-            }
-            if (secondField.name === layer.parent.subtypeField) {
-                return 1;
-            }
-        }
-        if (isSubtypeFieldCapableLayer(layer)) {
-            if (firstField.name === layer.subtypeField) {
-                return -1;
-            }
-            if (secondField.name === layer.subtypeField) {
-                return 1;
-            }
-        }
-        if (isFeatureTypesCapableLayer(layer)) {
-            if (firstField.name === layer.typeIdField) {
-                return -1;
-            }
-            if (secondField.name === layer.typeIdField) {
-                return 1;
-            }
-        }
-        return firstField.name.localeCompare(secondField.name, "en", { sensitivity: "base" });
-    };
-}
-function areAllDomainsInherited(types, field) {
-    return types?.every((type) => type.domains?.[field.name]?.type === "inherited") ?? false;
-}
-// const validIdentifierExpr = new RegExp(/^[a-z_$][\w$]*$/gi);
-const validIdentifierExpr = /^[a-z_$][a-z0-9_$]*$/giu;
-function getMemberExpressionProperty(prop, includeDot = true) {
-    if (prop.match(validIdentifierExpr)) {
-        return `${includeDot ? "." : ""}${prop}`;
-    }
-    return `["${prop}"]`;
-}
-function assembleMemberExpression(obj, prop) {
-    if (!obj) {
-        return prop;
-    }
-    return `${obj}${getMemberExpressionProperty(prop)}`;
-}
-function getMapPortalItem(map) {
-    if (isWebMapInstance(map) || isWebSceneInstance(map)) {
-        return map.portalItem;
-    }
-    return null;
+// #region convert editor profile to apiProfile
+/**
+ * Converts an editor profile to an api profile.
+ * The api profile is an optimized version of the editor profile designed for minimal data transfer between the main thread and the worker.
+ */
+async function arcadeEditorToApiProfile(editorProfile) {
+    const { apiVersion, bundles, hiddenApiItems } = editorProfile.toEditorProfileDefinition();
+    const variables = await variablesToLSVariable(editorProfile.dictionaryVariables);
+    return { apiVersion, bundles, variables, hiddenApiItems: hiddenApiItems?.map((s) => s.toLowerCase()) };
 }
-//#endregion
-//#region Editor Profile to Language Service Profile functions
 async function variablesToLSVariable(editorVariables, kind = CompletionItemKind.Variable) {
     return await Promise.all(editorVariables.map(async (editorVariable) => {
         switch (editorVariable.type) {
@@ -304,63 +110,8 @@ async function featureToLSFeature(editorFeature, kind) {
     }
     // Create properties for the fields and the aliases
     // Also improve the feature completion documentation
-    let featureCompletionDescription = description;
-    const fieldProfileValues = [];
-    const aliasProfileValues = [];
-    supportedFields(source.fields).forEach((field) => {
-        let fieldCompletionDescription = `**${field.name}**  \n${field.type}`;
-        if (field.description) {
-            fieldCompletionDescription += `  \n'${field.description}`;
-        }
-        if (featureCompletionDescription) {
-            featureCompletionDescription += "  \n  \n";
-        }
-        featureCompletionDescription += `**${field.name}** (${fieldAlias(field)})  \n${field.type}`;
-        if (field.description) {
-            featureCompletionDescription += `  \n'${field.description}`;
-        }
-        // The property for the field
-        const type = fieldTypeToArcadeType(field);
-        const insertText = getMemberExpressionProperty(field.name, false);
-        const description = fieldAlias(field);
-        fieldProfileValues.push({
-            name: field.name,
-            description,
-            type,
-            completion: {
-                label: field.name,
-                detail: description,
-                insertText,
-                insertTextMode: InsertTextMode.asIs,
-                insertTextFormat: InsertTextFormat.PlainText,
-                kind: CompletionItemKind.Field,
-                documentation: { kind: "markdown", value: fieldCompletionDescription },
-            },
-        });
-        if (!field.alias || field.alias.toLowerCase() === field.name.toLowerCase()) {
-            return;
-        }
-        // The property for the alias if different than the field name
-        let aliasCompletionDescription = `**${field.alias}**  \n${field.type}`;
-        if (field.description) {
-            aliasCompletionDescription += `  \n'${field.description}`;
-        }
-        aliasProfileValues.push({
-            name: field.alias,
-            description: field.name,
-            type,
-            completion: {
-                label: field.alias,
-                detail: field.name,
-                insertText,
-                insertTextMode: InsertTextMode.asIs,
-                insertTextFormat: InsertTextFormat.PlainText,
-                kind: CompletionItemKind.Field,
-                documentation: { kind: "markdown", value: aliasCompletionDescription },
-            },
-        });
-    });
-    result.properties = [...fieldProfileValues, ...aliasProfileValues];
+    const [properties, featureCompletionDescription] = fieldsToProfileValues(source.fields, description, true);
+    result.properties = properties;
     resultCompletion.documentation = { kind: "markdown", value: featureCompletionDescription };
     return result;
 }
@@ -394,945 +145,8 @@ async function dictionaryToLSDictionary(editorDictionary, kind) {
         },
     };
 }
-/**
- * Represents a item in the EditorProfile. The profile is converted into an optimized way for
- * rendering in the editor. In addition to the representation of profile variables, other
- * structures are created such as groups.
- */
-class ProfileItemBase {
-    constructor(_profile, _label, description) {
-        this._profile = _profile;
-        this._label = _label;
-        this.description = description;
-        this.filterDescription = false;
-    }
-    /**
-     * Returns the label string.
-     */
-    getLabel() {
-        if (this._label == null) {
-            return "";
-        }
-        if (typeof this._label === "string") {
-            // Some of our variables can start with a $ sign.
-            // If the component is under RTL, the string is messed up.
-            // It is converted from $feature to feature$, This is not acceptable since the label
-            // represents a variable name. We are adding in front of the $ sign a right to left mark.
-            return addLTRMark(this._label);
-        }
-        return setValuesInString(this._profile?.intlStrings[this._label.code], this._label.formatValues);
-    }
-    /**
-     * Returns the description string.
-     */
-    getDescription() {
-        if (this.description == null) {
-            return "";
-        }
-        if (typeof this.description === "string") {
-            return this.description;
-        }
-        return setValuesInString(this._profile?.intlStrings[this.description.code], this.description.formatValues);
-    }
-    /**
-     * Returns true if the item pass the filter test
-     */
-    passFilter(filterExpression) {
-        if (!filterExpression) {
-            return true;
-        }
-        if (filterExpression.test(this.getLabel())) {
-            return true;
-        }
-        return this.filterDescription && filterExpression.test(this.getDescription());
-    }
-}
-/**
- * The base class for profile variables representation in the EditorProfile.
- */
-class VariableBase extends ProfileItemBase {
-    constructor(props) {
-        super(props.profile, props.label, props.description ?? props.declaration?.description);
-        this.declaration = props.declaration ?? {};
-        this.name = props.declaration?.name ?? "";
-        this.snippet = props.snippet ?? "";
-        this.nonInteractive = props.nonInteractive ?? false;
-        this.filterDescription = props.filterDescription ?? false;
-        this.icon = props.icon;
-    }
-}
-/**
- * Represents the IProfileValue.
- */
-class ValueVariable extends VariableBase {
-    constructor(props) {
-        super(props);
-        this.type = "text";
-        this.isCollection = false;
-        this.type = props.declaration?.type ?? "text";
-    }
-    getDescription() {
-        if (this.description == null) {
-            return this._profile?.intlStrings[this.type.toLowerCase()] ?? "";
-        }
-        return super.getDescription();
-    }
-    toProfileVariableDefinition() {
-        return { type: this.type, name: "", ...this.declaration };
-    }
-}
-/**
- * Represents the IProfileArray. The main difference is that the IProfileValue type
- * is used as valueType.
- */
-class ArrayVariable extends VariableBase {
-    constructor(props) {
-        super(props);
-        this.type = "array";
-        this.isCollection = false;
-        this.elementType = props.declaration?.elementType ?? { type: "number", name: "number" };
-    }
-    getDescription() {
-        if (this.description == null) {
-            return this._profile?.intlStrings[this.type.toLowerCase()] ?? "";
-        }
-        return super.getDescription();
-    }
-    toProfileVariableDefinition() {
-        return { type: this.type, elementType: this.elementType, name: "", ...this.declaration };
-    }
-}
-/**
- * Represents a collection of items. The collection of items can be synchronous or
- * asynchronous. If the collection is asynchronous then the collection should be
- * loaded by using the function 'load'. The property 'loaded' indicates if the
- * collection is ready or not.
- */
-class CollectionBasedVariable extends VariableBase {
-    constructor(owner, props) {
-        super(props);
-        this.owner = owner;
-        this.isCollection = true;
-        this._loaded = true;
-        /**
-         * The collection of items used to display the profile.
-         * If the collection is asynchronous, the 'load' function should
-         * be called first before using the items.
-         */
-        this.variables = [];
-    }
-    get breadcrumb() {
-        // If there's an owner, prepend its breadcrumb and append the current name
-        if (this.owner) {
-            const ownerBreadcrumb = this.owner.breadcrumb;
-            return ownerBreadcrumb ? `${ownerBreadcrumb} / ${this.name}` : this.name;
-        }
-        // If there's no owner, this is the root element, so just return its name
-        return this.name;
-    }
-    /**
-     * Returns true if the collection has been loaded
-     */
-    get loaded() {
-        return this._loaded;
-    }
-    /**
-     * Returns an url to the associated information
-     */
-    get informationUrl() {
-        return null;
-    }
-    get informationType() {
-        return "";
-    }
-}
-class GroupOfVariables extends ProfileItemBase {
-    constructor(profile, label, variables = []) {
-        super(profile, label);
-        this.variables = variables;
-        this.type = "group";
-        this.isCollection = true;
-    }
-    passFilter() {
-        return true;
-    }
-}
-class DictionaryVariable extends CollectionBasedVariable {
-    constructor(owner, props) {
-        super(owner, props);
-        this.type = "dictionary";
-        /**
-         * The variables that the dictionary holds. It is different than the variables.
-         * The variables may contain grouping.
-         */
-        this.dictionaryVariables = [];
-        this.loadPropertyDeclarations(props.declaration?.properties);
-        // If we have a snippet then wrap the properties in a group and use the snippet as the heading
-        // This is not applicable for root Dictionary such as Profile
-        if (this.snippet && this.dictionaryVariables.length) {
-            this.variables = [new GroupOfVariables(this._profile, this.snippet, this.dictionaryVariables)];
-        }
-    }
-    async loadSource() {
-        // No-op
-    }
-    loadPropertyDeclarations(declarations) {
-        this.dictionaryVariables = this.createVariableInstances(declarations);
-        this.variables = this.dictionaryVariables;
-    }
-    createVariableInstances(declarations) {
-        if (!Array.isArray(declarations)) {
-            return [];
-        }
-        const properties = [];
-        declarations.forEach((declaration) => {
-            const variable = this.createVariableInstance(declaration);
-            if (variable) {
-                properties.push(variable);
-            }
-        });
-        return properties;
-    }
-    createVariableInstance(declaration) {
-        const snippet = assembleMemberExpression(this.snippet, declaration.name);
-        switch (declaration.type) {
-            case "number":
-            case "text":
-            case "boolean":
-            case "date":
-            case "dateOnly":
-            case "time":
-            case "geometry":
-            case "knowledgeGraph":
-                return new ValueVariable({ profile: this._profile, declaration, label: snippet, snippet });
-            case "feature":
-                return new FeatureVariable(this, { profile: this._profile, declaration, label: snippet, snippet });
-            case "featureSet":
-                return new FeatureSetVariable(this, { profile: this._profile, declaration, label: snippet, snippet }, [
-                    new ValueVariable({ profile: this._profile, label: snippet, description: "", snippet }),
-                ]);
-            case "featureSetCollection":
-                return new FeatureSetCollectionVariable(this, {
-                    profile: this._profile,
-                    declaration,
-                    label: snippet,
-                    snippet,
-                });
-            case "dictionary":
-                return new DictionaryVariable(this, {
-                    profile: this._profile,
-                    declaration,
-                    label: snippet,
-                    snippet,
-                });
-            case "array":
-                return new ArrayVariable({
-                    profile: this._profile,
-                    declaration,
-                    label: snippet,
-                    snippet,
-                });
-            default:
-                console.error("Editor profile: Invalid profile variable", declaration);
-                return null;
-        }
-    }
-    toProfileVariableDefinition() {
-        return {
-            type: this.type,
-            name: "",
-            ...this.declaration,
-            properties: this.dictionaryVariables.map((variable) => variable.toProfileVariableDefinition()),
-        };
-    }
-}
-class SourceBasedVariable extends CollectionBasedVariable {
-    constructor(owner, props, relationshipsProperties) {
-        super(owner, props);
-        this.relationshipsProperties = relationshipsProperties;
-        this._source = null;
-        this._loaded = false;
-        this._definition = props.declaration?.definition;
-    }
-    get title() {
-        return isTitleCapableSource(this._source) ? this._source.title : "";
-    }
-    get url() {
-        return isUrlCapableSource(this._source) ? this._source.url : "";
-    }
-    get informationUrl() {
-        if (!this.loaded) {
-            return null;
-        }
-        if (!this.url) {
-            return null;
-        }
-        return isLayerIdCapableSource(this._source) ? `${this.url}/${this._source.layerId}` : this.url;
-    }
-    get informationType() {
-        return this._profile?.intlStrings.layer ?? "layer";
-    }
-    async loadSource() {
-        if (isNotNull(this._loadPromise) && isNotUndefined(this._loadPromise)) {
-            return await this._loadPromise;
-        }
-        this._loadPromise = this._loadSource();
-        return await this._loadPromise;
-    }
-    _getValueSnippet(field) {
-        // If the source is a feature, then we want to assemble the snippet ($feature) with the field name as a member expression
-        return this.type === "feature" ? assembleMemberExpression(this.snippet, field.name) : field.name;
-    }
-    _getSubtypeOrDomainNameSnippet(field) {
-        if (this.type !== "feature") {
-            return null;
-        }
-        if (isSubtypeFieldCapableLayer(this._source) && field.name === this._source.subtypeField) {
-            return `SubtypeName(${this.snippet})`;
-        }
-        return `DomainName(${this.snippet}, "${field.name}")`;
-    }
-    _getFieldProperty(field) {
-        // Check if the field is the type id field or of the field has a coded domain.
-        // If it has then the property will be an exanpdable property (dictionary).
-        // Otherwise just return a simple value property.
-        const subtypesOrDomainValuesDictionary = this._getDomainDictionary(field);
-        if (subtypesOrDomainValuesDictionary) {
-            return subtypesOrDomainValuesDictionary;
-        }
-        // Create the value property
-        const valueSnippet = this._getValueSnippet(field);
-        return new ValueVariable({
-            profile: this._profile,
-            label: valueSnippet,
-            description: fieldAlias(field),
-            snippet: valueSnippet,
-            icon: fieldTypeToIconName(field),
-            filterDescription: true,
-        });
-    }
-    _getDomainDictionary(field) {
-        if (!isDomainsCapableLayer(this._source)) {
-            return null;
-        }
-        // Note we have multiple scenarios:
-        // - Layers without subtypes or feature types: We will check if the field has a domain
-        // - Layers with only subtypes: We will parse the subtypes metadata and create a dictionary
-        // - Layers with only feature types: We will parse the feature types metadata
-        // - Layers with both subtypes and feature types: we will actually use the subtypes metadata
-        // Summary, we will always use the subtypes metadata if available.
-        if (isSubtypeFieldCapableLayer(this._source) && !!this._source.subtypeField) {
-            return this._getSubtypeDomainDictionary(field);
-        }
-        if (isFeatureTypesCapableLayer(this._source) && !!this._source.typeIdField) {
-            return this._getFeatureTypeDomainDictionary(field);
-        }
-        return this._getFieldDomainDictionary(field);
-    }
-    _getSubtypeDomainDictionary(field) {
-        // Should be tested before calling this function
-        if (!isSubtypeFieldCapableLayer(this._source)) {
-            return null;
-        }
-        // If the source has a subtype field but doesn't have subtypes, it is certainly a subtype sublayer
-        if (!isSubtypesCapableLayer(this._source)) {
-            // For the subtype field there is no domain
-            if (field.name === this._source.subtypeField) {
-                return null;
-            }
-            // For the other fields, we will use the getFieldDomain function
-            return this._getFieldDomainDictionary(field);
-        }
-        // The code here shoud be executed for layers that have subtypes
-        // Sepcial case for the subtype field
-        if (field.name === this._source.subtypeField) {
-            const domainDictionary = this._createDomainDictionary(field);
-            domainDictionary.icon = "subtype";
-            domainDictionary.variables.push(this._getTypeOrSubtypeDomainGroup(this._source.subtypes, field));
-            return domainDictionary;
-        }
-        // Check if all the domains for the field in the types are inherited.
-        // If it is we can simplify the structure by avoiding splitting in subtypes
-        if (areAllDomainsInherited(this._source.subtypes, field)) {
-            return this._getFieldDomainDictionary(field);
-        }
-        // We have domains per subtype
-        // We need to go thru each types and create a dictionary.
-        const domainValuesBySubtypeGroup = this._getDomainValuesGroup(this._source.subtypes, field);
-        if (!domainValuesBySubtypeGroup) {
-            return null;
-        }
-        const domainDictionary = this._createDomainDictionary(field);
-        domainDictionary.variables.push(domainValuesBySubtypeGroup);
-        return domainDictionary;
-    }
-    _getFeatureTypeDomainDictionary(field) {
-        // SHould be tested before calling this function
-        if (!isFeatureTypesCapableLayer(this._source)) {
-            return null;
-        }
-        // Special case for the type id field
-        if (field.name === this._source.typeIdField) {
-            const domainDictionary = this._createDomainDictionary(field);
-            domainDictionary.variables.push(this._getTypeOrSubtypeDomainGroup(this._source.types, field));
-            return domainDictionary;
-        }
-        // Check if all the domains for the field in the types are inherited.
-        // If it is we can simplify the structure by avoiding splitting in subtypes
-        if (areAllDomainsInherited(this._source.types, field)) {
-            return this._getFieldDomainDictionary(field);
-        }
-        // We have domains per feature type
-        // We need to go thru each types and create a dictionary.
-        const domainValuesByFeatureTypeGroup = this._getDomainValuesGroup(this._source.types, field);
-        if (!domainValuesByFeatureTypeGroup) {
-            return null;
-        }
-        const domainDictionary = this._createDomainDictionary(field);
-        domainDictionary.variables.push(domainValuesByFeatureTypeGroup);
-        return domainDictionary;
-    }
-    _getFieldDomainDictionary(field) {
-        // SHould be tested before calling this function
-        if (!isDomainsCapableLayer(this._source)) {
-            return null;
-        }
-        const fieldDomain = this._source.getFieldDomain(field.name);
-        if (!isCodedValueDomainInstance(fieldDomain)) {
-            return null;
-        }
-        const domainValuesGroup = this._getCodedValueDomainGroup(fieldDomain, {
-            code: "domainvalues",
-        });
-        const domainDictionary = this._createDomainDictionary(field);
-        domainDictionary.variables.push(domainValuesGroup);
-        return domainDictionary;
-    }
-    _getTypeOrSubtypeDomainGroup(types, field) {
-        // Try the coded domain first
-        if (isCodedValueDomainInstance(field.domain)) {
-            return this._getCodedValueDomainGroup(field.domain, { code: "subtypes" });
-        }
-        // No coded domain, we will manufacture it
-        const values = types?.map((t) => {
-            const label = isSubtypeInstance(t) ? t.code : t.id;
-            return new ValueVariable({
-                profile: this._profile,
-                label: `${label}`,
-                description: t.name,
-                snippet: `"${label}"`,
-            });
-        }) ?? [];
-        return new GroupOfVariables(this._profile, { code: "subtypes" }, values);
-    }
-    _getCodedValueDomainGroup(domain, label) {
-        const values = domain.codedValues.map((v) => new ValueVariable({
-            profile: this._profile,
-            label: `${v.code}`,
-            description: v.name,
-            snippet: `"${v.code}"`,
-            filterDescription: true,
-        }));
-        return new GroupOfVariables(this._profile, label, values);
-    }
-    _getDomainValuesGroup(types, field) {
-        const variables = [];
-        if (!types || types.length === 0) {
-            return null;
-        }
-        types.forEach((type) => {
-            let domain = type.domains?.[field.name];
-            if (!domain) {
-                return;
-            }
-            if (isInheritedDomainInstance(domain)) {
-                domain = field.domain;
-                return;
-            }
-            if (!isCodedValueDomainInstance(domain)) {
-                return;
-            }
-            const alias = fieldAlias(field);
-            const domainValuesGroup = this._getCodedValueDomainGroup(domain, {
-                code: "domainvaluesfortypeformat",
-                formatValues: {
-                    fieldName: alias,
-                    typeName: type.name,
-                },
-            });
-            const id = isSubtypeInstance(type) ? type.code : type.id;
-            const label = `${id}`;
-            const snippet = `"${id}""`;
-            const subtypeDictionary = new DictionaryVariable(this, {
-                profile: this._profile,
-                label,
-                snippet,
-                description: type.name,
-                declaration: { name: alias },
-            });
-            subtypeDictionary.variables = [domainValuesGroup];
-            variables.push(subtypeDictionary);
-        });
-        if (!variables.length) {
-            return null;
-        }
-        return new GroupOfVariables(this._profile, { code: "domainvaluesbysubtypes" }, variables);
-    }
-    _createDomainDictionary(field) {
-        // Create the domain dictionary.
-        // The dictionary will have a header group and a value group.
-        // At this point we are only creating the header group in the dictionary.
-        const valueSnippet = this._getValueSnippet(field);
-        const alias = fieldAlias(field);
-        const domainDictionary = new DictionaryVariable(this, {
-            profile: this._profile,
-            label: valueSnippet,
-            description: alias,
-            snippet: valueSnippet,
-            icon: "form-dropdown",
-            declaration: { name: field.name },
-        });
-        // Add the header group
-        const headerGroup = new GroupOfVariables(this._profile, alias, [
-            new ValueVariable({
-                profile: this._profile,
-                label: valueSnippet,
-                description: "",
-                snippet: valueSnippet,
-            }),
-        ]);
-        domainDictionary.variables = [headerGroup];
-        // Add the SubtypeName or DomainName snippet if available
-        const subtypeOrDomainNameSnippet = this._getSubtypeOrDomainNameSnippet(field);
-        if (subtypeOrDomainNameSnippet) {
-            headerGroup.variables.push(new ValueVariable({
-                profile: this._profile,
-                label: subtypeOrDomainNameSnippet,
-                description: "",
-                snippet: subtypeOrDomainNameSnippet,
-            }));
-        }
-        return domainDictionary;
-    }
-    async _getRelationshipsProperty() {
-        // We need the data store to find the relationship feature layers
-        if (!this.relationshipsProperties?.exposeRelationships || !this._profile?.supportFeatureSetFunctions) {
-            return null;
-        }
-        const source = this._source;
-        if (!isRelationshipsCapableLayer(source)) {
-            return null;
-        }
-        const relationshipsGroup = new GroupOfVariables(this._profile, { code: "relationships" });
-        const relationshipItems = await Promise.all(source.relationships.map(async (relationship) => {
-            const relatedLayer = await getRelatedFeatureLayer(source, relationship);
-            if (!isQueryableLayerInstance(relatedLayer)) {
-                return null;
-            }
-            if (relationship.relatedTableId === this.relationshipsProperties?.sourceTableId) {
-                // We don't want to show the reverse relationship
-                return null;
-            }
-            const snippet = `FeatureSetByRelationshipName(${this.snippet}, "${relationship.name}")`;
-            return new FeatureSetVariable(this, {
-                profile: this._profile,
-                declaration: { definition: relatedLayer },
-                label: relatedLayer.title,
-                description: "",
-                nonInteractive: true,
-            }, [new ValueVariable({ profile: this._profile, label: snippet, description: "", snippet })], { exposeRelationships: true, sourceTableId: source.layerId });
-        }));
-        relationshipsGroup.variables = relationshipItems.filter(isNotNull);
-        if (!relationshipsGroup.variables.length) {
-            return null;
-        }
-        return relationshipsGroup;
-    }
-}
-class FeatureVariable extends SourceBasedVariable {
-    constructor(owner, props) {
-        super(owner, props, { exposeRelationships: true });
-        this.type = "feature";
-    }
-    get title() {
-        if (isTitleCapableSource(this._source)) {
-            return this._source.title ?? "";
-        }
-        return { code: "feature" };
-    }
-    async _loadSource() {
-        if (this.loaded) {
-            return this._source;
-        }
-        try {
-            this._source = await supportedSourceFromDefinition(this._definition);
-            if (!this._source) {
-                throw new Error("Invalid definition");
-            }
-            // The title group and snippet
-            const title = isTitleCapableSource(this._source) ? this._source.title ?? "" : "";
-            this.variables.push(new GroupOfVariables(this._profile, title, [
-                new ValueVariable({
-                    profile: this._profile,
-                    label: this.snippet,
-                    description: "",
-                    snippet: this.snippet,
-                }),
-            ]));
-            // The collection of feature attribute values
-            const valuesGroup = new GroupOfVariables(this._profile, { code: "values" });
-            this.variables.push(valuesGroup);
-            // Add the geometry if it's a feature layer and not a table
-            if (isTableCapableLayer(this._source) && !this._source.isTable) {
-                const snippet = `Geometry(${this.snippet})`;
-                const geometryProperty = new ValueVariable({
-                    profile: this._profile,
-                    declaration: { name: snippet },
-                    label: snippet,
-                    description: "Geometry",
-                    snippet,
-                    icon: "shapes",
-                    filterDescription: true,
-                });
-                valuesGroup.variables.push(geometryProperty);
-            }
-            this._source.fields.sort(sortFields(this._source)).forEach((field) => {
-                valuesGroup.variables.push(this._getFieldProperty(field));
-            });
-            // The relatonships
-            const relationshipsGroup = await this._getRelationshipsProperty();
-            if (relationshipsGroup) {
-                this.variables.push(relationshipsGroup);
-            }
-        }
-        catch (error) {
-            console.error("Error with definition", error, this._definition);
-            this._source = null;
-        }
-        finally {
-            this._loaded = true;
-        }
-        return this._source;
-    }
-    toProfileVariableDefinition() {
-        return { type: this.type, name: "", ...this.declaration, definition: this._definition };
-    }
-}
-class FeatureSetVariable extends SourceBasedVariable {
-    constructor(owner, props, featureSetSnippets = [], 
-    // Relationships for feature set if only supported if the feature set is actually
-    // representing a relationsip feature layer for a feature source.
-    relationshipProps) {
-        super(owner, props, relationshipProps);
-        this.featureSetSnippets = featureSetSnippets;
-        this.type = "featureSet";
-    }
-    get title() {
-        if (isTitleCapableSource(this._source)) {
-            return this._source.title ?? "";
-        }
-        return { code: "featureset" };
-    }
-    async _loadSource() {
-        if (this.loaded) {
-            return this._source;
-        }
-        try {
-            this._source = await supportedSourceFromDefinition(this._definition);
-            if (!this._source) {
-                throw new Error("Invalid definition");
-            }
-            // The title group and snippet
-            this.variables.push(new GroupOfVariables(this._profile, this.title, this.featureSetSnippets));
-            // Add the fields
-            const fieldsGroup = new GroupOfVariables(this._profile, { code: "fields" });
-            this.variables.push(fieldsGroup);
-            fieldsGroup.variables = this._source.fields
-                .sort(sortFields(this._source))
-                .map((field) => this._getFieldProperty(field));
-            // Add the relationships if enabled
-            const relationshipsGroup = await this._getRelationshipsProperty();
-            if (relationshipsGroup) {
-                this.variables.push(relationshipsGroup);
-            }
-        }
-        catch (error) {
-            console.error("Error with definition", error, this._definition);
-            this._source = null;
-        }
-        finally {
-            this._loaded = true;
-        }
-        return this._source;
-    }
-    toProfileVariableDefinition() {
-        return { type: this.type, name: "", ...this.declaration, definition: this._definition };
-    }
-}
-class FeatureSetCollectionVariable extends CollectionBasedVariable {
-    constructor(owner, props) {
-        super(owner, props);
-        this.type = "featureSetCollection";
-        this._featureSetCollections = null;
-        this._loaded = false;
-        this._definition = props.declaration?.definition;
-    }
-    get informationUrl() {
-        if (!this.loaded || !this._featureSetCollections) {
-            return null;
-        }
-        if (typeof this._featureSetCollections.source !== "string") {
-            return portalItemPageUrl(getMapPortalItem(this._featureSetCollections.source));
-        }
-        // const firstLayer = this._featureSetCollection.layers[0] ?? this._featureSetCollection.tables[0];
-        // if (!firstLayer) {
-        return null;
-        // }
-        // return `${firstLayer.url}`;
-    }
-    get informationType() {
-        if (!this.loaded || !this._featureSetCollections) {
-            return "";
-        }
-        if (typeof this._featureSetCollections.source === "string") {
-            return this._profile?.intlStrings.featureservice ?? "featureservice";
-        }
-        if (isWebSceneInstance(this._featureSetCollections.source)) {
-            return this._profile?.intlStrings.webscene ?? "webscene";
-        }
-        if (isWebMapInstance(this._featureSetCollections.source)) {
-            return this._profile?.intlStrings.webmap ?? "webmap";
-        }
-        return this._profile?.intlStrings.map ?? "map";
-    }
-    async loadSource() {
-        if (isNotNull(this._loadPromise) && isNotUndefined(this._loadPromise)) {
-            return await this._loadPromise;
-        }
-        this._loadPromise = this._loadSource();
-        return await this._loadPromise;
-    }
-    async _loadSource() {
-        if (this.loaded) {
-            return this._featureSetCollections;
-        }
-        try {
-            this._featureSetCollections = await this._featureSetCollectionsFromDefinition();
-            if (!this._featureSetCollections) {
-                throw new Error("Invalid definition");
-            }
-            // Create the group for the header
-            const groupLabel = typeof this._featureSetCollections.source === "string"
-                ? { code: this._featureSetCollections.source.endsWith("FeatureServer") ? "featureservice" : "mapservice" }
-                : {
-                    code: "webmapformat",
-                    formatValues: {
-                        webMapTitle: getMapPortalItem(this._featureSetCollections.source)?.title || "Untitled map",
-                    },
-                };
-            const headerGroup = new GroupOfVariables(this._profile, groupLabel, [
-                new ValueVariable({
-                    profile: this._profile,
-                    label: this.snippet,
-                    description: "",
-                    snippet: this.snippet,
-                }),
-            ]);
-            // Creates the groups for the layer and tables
-            const layersGroup = new GroupOfVariables(this._profile, { code: "layers" }, this._featureSetCollections.layers);
-            const tablesGroup = new GroupOfVariables(this._profile, { code: "tables" }, this._featureSetCollections.tables);
-            this.variables.push(headerGroup, layersGroup, tablesGroup);
-        }
-        catch (error) {
-            console.error("Error with definition", error, this._definition);
-            this._featureSetCollections = null;
-        }
-        finally {
-            this._loaded = true;
-        }
-        return this._featureSetCollections;
-    }
-    async _featureSetCollectionsFromDefinition() {
-        if (!this._definition) {
-            return null;
-        }
-        if (isMapInstance(this._definition)) {
-            return await this._featureSetCollectionFromMap(this._definition);
-        }
-        if (isUrlDefinition(this._definition)) {
-            return await this._featureSetCollectionFromUrl(this._definition.url);
-        }
-        if (isPortalItemDefinition(this._definition)) {
-            // Preload the portal item so we can discover if are dealing with a Web Map
-            // or Feature Service
-            return await this._featureSetCollectionFromPortalItem(this._definition.portalItem);
-        }
-        return null;
-    }
-    async _featureSetCollectionFromMap(map) {
-        if (isLoadableMapInstance(map)) {
-            // Make sure the map is loaded
-            await map.loadAll();
-        }
-        // Until jsapi fix a bug we have to load the table separately
-        await Promise.all(map.tables.map(async (t) => (await t.load())));
-        return {
-            layers: this._convertWebMapLayersToVariables(map.layers),
-            tables: this._convertWebMapLayersToVariables(map.tables, true),
-            source: map,
-        };
-    }
-    async _featureSetCollectionFromPortalItem(definition) {
-        const portalItem = await newPortalPortalItem(definition);
-        await portalItem.load();
-        switch (portalItem.type) {
-            case "Web Map": {
-                const webMap = await newWebMap({ portalItem });
-                return await this._featureSetCollectionFromMap(webMap);
-            }
-            case "Web Scene": {
-                const webScene = await newWebScene({ portalItem });
-                return await this._featureSetCollectionFromMap(webScene);
-            }
-            case "Feature Service":
-                return await this._featureSetCollectionFromUrl(portalItem.url);
-            default:
-                console.error("Unsupported portal item", definition);
-                return null;
-        }
-    }
-    async _featureSetCollectionFromUrl(url) {
-        let processedUrl = url.replace(/\/featureserver\/[0-9]*/iu, "/FeatureServer");
-        processedUrl = processedUrl.replace(/\/mapserver\/[0-9]*/iu, "/MapServer");
-        processedUrl = processedUrl.split("?")[0];
-        if (!processedUrl) {
-            return null;
-        }
-        const metadata = await serviceMetaData(processedUrl);
-        const layersPromise = Promise.all(metadata.layers.map(async (layerInfo) => {
-            const featureLayer = await newLayersFeatureLayer({ url: `${processedUrl}/${layerInfo.id}` });
-            await featureLayer.load();
-            return this._createFeatureSetVariable(featureLayer);
-        }));
-        const tablesPromise = Promise.all(metadata.tables.map(async (layerInfo) => {
-            const table = await newLayersFeatureLayer({ url: `${processedUrl}/${layerInfo.id}` });
-            await table.load();
-            return this._createFeatureSetVariable(table);
-        }));
-        const [layers, tables] = await Promise.all([layersPromise, tablesPromise]);
-        return { layers, tables, source: processedUrl };
-    }
-    _convertWebMapLayersToVariables(layers, filteringTables = false) {
-        const layerVariables = [];
-        layers
-            .toArray()
-            .reverse()
-            .forEach((layer) => {
-            if (isQueryableLayerInstance(layer)) {
-                layerVariables.push(this._createFeatureSetVariable(layer, true));
-                return;
-            }
-            if (isGroupLayerInstance(layer)) {
-                const groupLayerVariables = filteringTables
-                    ? this._convertWebMapLayersToVariables(layer.allTables, true)
-                    : this._convertWebMapLayersToVariables(layer.allLayers);
-                layerVariables.push(...groupLayerVariables);
-            }
-        });
-        return layerVariables;
-    }
-    _createFeatureSetVariable(featureLayer, isFromWebMap = false) {
-        return new FeatureSetVariable(this, {
-            profile: this._profile,
-            declaration: { name: featureLayer.title, definition: featureLayer },
-            label: isFromWebMap
-                ? featureLayer.title
-                : featureLayer.sourceJSON.name ?? featureLayer.title,
-            description: "",
-            nonInteractive: true,
-        }, this._makeFeatureSetSnippets(featureLayer, isFromWebMap));
-    }
-    _makeFeatureSetSnippets(featureLayer, isFromWebMap = false) {
-        if (!this._profile?.supportFeatureSetFunctions) {
-            return [];
-        }
-        if (isFromWebMap) {
-            const snippetById = `FeatureSetById(${this.snippet}, "${featureLayer.id}")`;
-            const snippetByName = `FeatureSetByName(${this.snippet}, "${featureLayer.title}")`;
-            return [
-                new ValueVariable({ profile: this._profile, label: snippetById, description: "", snippet: snippetById }),
-                new ValueVariable({ profile: this._profile, label: snippetByName, description: "", snippet: snippetByName }),
-            ];
-        }
-        else {
-            const snippetById = `FeatureSetById(${this.snippet}, "${featureLayer.layerId}")`;
-            return [new ValueVariable({ profile: this._profile, label: snippetById, description: "", snippet: snippetById })];
-        }
-    }
-    toProfileVariableDefinition() {
-        return { type: this.type, name: "", ...this.declaration, definition: this._definition };
-    }
-}
-/**
- * The EditorProfile is an object that represents an Arcade Profile.
- * It is used to display the profile in the editor.
- * It takes an IEditorProfile as a definition and a locale.
- * A EditorPofile instance
- * Some of the variables in the profile are based on layers, web maps, or feature services.
- * They need to be loaded asynchronously to get the metadata necessary for validation and completion.
- */
-class EditorProfile extends DictionaryVariable {
-    constructor(definition, intlStrings, locale = "en") {
-        // Delay the load of the variable declarations so we have a `this`
-        super(undefined, {
-            profile: null,
-            declaration: { properties: [] },
-        });
-        this.definition = definition;
-        this.intlStrings = intlStrings;
-        this.locale = locale;
-        this.variables = [];
-        // We are the root
-        this._profile = this;
-        // Now that `this` is defined, we can load the variables
-        this.loadPropertyDeclarations(definition?.variables);
-    }
-    /**
-     * Returns true if the profile supports feature set functions for snippets.
-     */
-    get supportFeatureSetFunctions() {
-        return this.definition?.bundles?.includes("data-access") ?? false;
-    }
-    /**
-     * Returns the language service profile. It is different than the editor profile as it is optimized for Monaco.
-     */
-    async toLSProfile() {
-        const { apiVersion, bundles, hiddenApiItems } = this.definition ?? {};
-        const variables = await variablesToLSVariable(this.dictionaryVariables);
-        return { apiVersion, bundles, variables, hiddenApiItems: hiddenApiItems?.map((s) => s.toLowerCase()) };
-    }
-    /**
-     * Returns the EditorProfile as a json. The EditorProfile may have been updated. This function allows to
-     * get the new json representing mutations.
-     */
-    toEditorProfileDefinition() {
-        return {
-            ...this.definition,
-            variables: this.dictionaryVariables.map((variable) => variable.toProfileVariableDefinition()),
-        };
-    }
-}
-//#endregion
-
-function isFeatureDefinition(item) {
-    return isUrlDefinition(item) || isFieldsDefinition(item) || isFeatureLayerItemDefinition(item);
-}
-function isFeatureSetDefinition(item) {
-    return isUrlDefinition(item) || isFieldsDefinition(item) || isFeatureLayerItemDefinition(item);
-}
-function isFeatureSetCollectionDefinition(item) {
-    return isPortalItemDefinition(item) || isMapInstance(item) || isSupportedServiceUrlDefinition(item);
-}
+// #endregion
+// #region predefined profile to editor profile definition
 /**
  * Get a PredefinedProfile for a locale. If not already loaded then fetch it.
  * If the locale doesn't exist or the locale profile file doesn't exist then returns
@@ -1461,136 +275,7 @@ async function convertToEditorProfileDefinition(predefinedProfile, locale = "en"
     }
     return editorProfile;
 }
-
-/**
- * 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 import('./arcade-mode.js');
-}
-
-// this file contains the building blocks for a language default provider
-const defaultContext = {
-    locale: "en",
-};
-class LanguageDefaultsBase {
-    constructor() {
-        // #endregion
-        // #region Protected properties
-        this._onDidChange = new Emitter();
-        this._profileMap = new Map();
-        this._apiContextMap = new Map();
-        this._onModelContextDidChange = new Emitter();
-        this._onDidModelContextChangeTimeout = -1;
-        // #endregion
-    }
-    // #endregion
-    // #region Protected methods
-    _fireModelContextDidChange(key) {
-        if (this._onDidModelContextChangeTimeout !== -1) {
-            return;
-        }
-        this._onDidModelContextChangeTimeout = window.setTimeout(() => {
-            this._onDidModelContextChangeTimeout = -1;
-            this._onModelContextDidChange.fire(key);
-        }, 0);
-    }
-    _getApiKey(modelId) {
-        if (!Uri.isUri(modelId)) {
-            modelId = Uri.parse(modelId);
-        }
-        return modelId.toString();
-    }
-    // #endregion
-    // #region Public methods
-    get onDidChange() {
-        return this._onDidChange.event;
-    }
-    get languageOptions() {
-        return this._languageOptions;
-    }
-    /**
-     * Dispose the editor profile for the given model id.
-     * It is the responsibility of the caller that created the editor profile to dispose it.
-     * @param modelId The model id for which to dispose the editor profile.
-     */
-    disposeEditorProfileForModel(modelId) {
-        const key = this._getApiKey(modelId);
-        this._profileMap.delete(key);
-    }
-    /**
-     * Dispose the api context for the given model id.
-     * @param modelId The model id for which to dispose the api context.
-     */
-    disposeApiContextForModel(modelId) {
-        const key = this._getApiKey(modelId);
-        if (this._apiContextMap.delete(key)) {
-            this._fireModelContextDidChange(key);
-        }
-    }
-    /**
-     * Returns the editor profile for the given model id.
-     * @param modelId The model id for which to get the editor profile.
-     * @returns The editor profile for the model.
-     */
-    getEditorProfileForModel(modelId) {
-        return this._profileMap.get(this._getApiKey(modelId));
-    }
-    /**
-     * Returns the API context for the given model id.
-     * Returns the default context if the model has no context.
-     * @param modelId The model id for which to get the API context.
-     * @returns The API context for the model.
-     */
-    getApiContextForModel(contextId) {
-        return this._apiContextMap.get(this._getApiKey(contextId)) ?? defaultContext;
-    }
-    /**
-     * Set or update api context for the given model id.
-     * @param modelId The model id for which to set the context.
-     * @param apiContext The api context to set.
-     */
-    updateApiContextForModel(modelId, apiContext) {
-        const key = this._getApiKey(modelId);
-        const currentApiContext = this._apiContextMap.get(key) ?? {};
-        this._apiContextMap.set(key, { ...currentApiContext, ...apiContext });
-        this._fireModelContextDidChange(key);
-    }
-    get onModelContextDidChange() {
-        return this._onModelContextDidChange.event;
-    }
-    get languageId() {
-        return this._languageId;
-    }
-}
+// #endregion
 
 const arcadeLanguageId = "arcade";
 class ArcadeLanguageServiceDefaults extends LanguageDefaultsBase {
@@ -1614,15 +299,15 @@ class ArcadeLanguageServiceDefaults extends LanguageDefaultsBase {
         if (isPredefinedProfile(definition)) {
             definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
         }
-        const intlStrings = await fetchT9NStringsBundle(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
-        if (!intlStrings) {
+        const profileStrings = await fetchT9nStringsBundle(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
+        if (!profileStrings) {
             throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
         }
-        this.disposeEditorProfileForModel(modelId);
+        this.disposeForModel(modelId);
         const key = this._getApiKey(modelId);
-        const editorProfile = new EditorProfile(definition, intlStrings);
+        const editorProfile = new EditorProfile(definition, profileStrings);
         this._profileMap.set(key, editorProfile);
-        const apiProfile = await editorProfile.toLSProfile();
+        const apiProfile = await arcadeEditorToApiProfile(editorProfile);
         this.updateApiContextForModel(modelId, {
             locale: apiContext.locale,
             profile: apiProfile,