@arcgis/coding-components 4.29.0-beta.11 → 4.29.0-beta.111

package/dist/components/arcade-defaults.js

@@ -1,403 +1,394 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0-beta.111
+ */
 import { Emitter, Uri } from 'monaco-editor';
-import { CompletionItemKind, InsertTextMode, InsertTextFormat } from 'vscode-languageserver-types';
-import { i as importPortalPortalItem, a as importLayersFeatureLayer, b as importWebMap, s as supportedFields, c as importRequest, f as fieldTypeToIconName, d as fieldTypeToArcadeType } from './fields.js';
+import { InsertTextMode, InsertTextFormat, CompletionItemKind } from 'vscode-languageserver-types';
+import { i as importLayersFeatureLayer, a as importRequest, s as supportedFields, n 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 { Q, G, q, B, x, N } from './index2.js';
+import { Y, e as ee, Z, K, E, N } from './index2.js';
 import { getAssetPath } from '@stencil/core/internal/client';
 
-async function newPortalItem(definition) {
-  const PortalItem = await importPortalPortalItem();
-  return new PortalItem(definition);
-}
+//#region core adapter fix
 async function newFeatureLayer(definition) {
-  const FeatureLayer = await importLayersFeatureLayer();
-  // Fix title for the layer. Instead of defaulting to the map viewer style.
-  return new FeatureLayer({ ...definition, sublayerTitleMode: "service-name" });
-}
-async function newWebMap(definition) {
-  const WebMap = await importWebMap();
-  return new WebMap(definition);
+    const FeatureLayer = await importLayersFeatureLayer();
+    // Fix title for the layer. Instead of defaulting to the map viewer style.
+    return new FeatureLayer({ ...definition, sublayerTitleMode: "service-name" });
 }
+//#endregion
+//#region Type Guards
 function isSupportedLayerInstance(item) {
-  return (!!item &&
-    typeof item === "object" &&
-    typeof item.declaredClass === "string" &&
-    item.declaredClass.startsWith("esri.layers."));
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        item.declaredClass.startsWith("esri.layers."));
 }
 function isFeatureSetInstance(item) {
-  return (!!item &&
-    typeof item === "object" &&
-    typeof item.declaredClass === "string" &&
-    item.declaredClass === "esri.rest.support.FeatureSet");
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        item.declaredClass === "esri.rest.support.FeatureSet");
+}
+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 isFeatureLayerInstance(item) {
-  return (!!item &&
-    typeof item === "object" &&
-    typeof item.declaredClass === "string" &&
-    item.declaredClass === "esri.layers.FeatureLayer");
+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" &&
-    typeof item.declaredClass === "string" &&
-    item.declaredClass === "esri.layers.GroupLayer");
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        item.declaredClass === "esri.layers.GroupLayer");
 }
-function isWebMapInstance(item) {
-  return (!!item && typeof item === "object" && typeof item.declaredClass === "string" && item.declaredClass === "esri.WebMap");
+function isMapInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        (item.declaredClass === "esri.WebMap" || item.declaredClass === "esri.WebScene"));
 }
 function isPortalItemDefinition(item) {
-  return !!item && typeof item === "object" && item.portalItem != null;
+    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
 }
 function isFeatureLayerItemDefinition(item) {
-  return !!item && typeof item === "object" && item.portalItem != null;
+    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
 }
 function isFieldsDefinition(item) {
-  return !!item && typeof item === "object" && Array.isArray(item.fields) && !("declaredClass" in item);
+    return (!!item && typeof item === "object" && "fields" in item && Array.isArray(item.fields) && !("declaredClass" in item));
 }
 function isUrlDefinition(item) {
-  return !!item && typeof item === "object" && typeof item.url === "string" && !("declaredClass" in item);
+    return (!!item && typeof item === "object" && "url" in item && typeof item.url === "string" && !("declaredClass" in item));
+}
+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" &&
-    typeof item.id === "string" &&
-    typeof item.definitions === "object" &&
-    !Array.isArray(item.definitions));
+    return (!!item &&
+        typeof item === "object" &&
+        "id" in item &&
+        typeof item.id === "string" &&
+        "definitions" in item &&
+        typeof item.definitions === "object" &&
+        !Array.isArray(item.definitions));
 }
-
-function resolveIntlPath(dictionary, path) {
-  if (!dictionary) {
-    return "";
-  }
-  const pathSegments = path.split(".");
-  let pathSegment = pathSegments.shift();
-  let entry = dictionary;
-  while (entry && pathSegment) {
-    // @ts-expect-error
-    entry = entry[pathSegment];
-    pathSegment = pathSegments.shift();
-  }
-  return typeof entry === "string" ? entry : path;
+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 isTypesCapabaleLayer(item) {
-  return !!item?.typeIdField;
+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 typeof item?.getFieldDomain === "function";
+    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 Array.isArray(item?.relationships) && typeof item?.url === "string";
+    return (isLayerIdCapableSource(item) &&
+        "relationships" in item &&
+        "url" in item &&
+        Array.isArray(item.relationships) &&
+        typeof item.url === "string");
 }
 function isTableCapableLayer(item) {
-  return typeof item?.isTable === "boolean";
+    return !!item && typeof item === "object" && "isTable" in item && typeof item.isTable === "boolean";
 }
 function isLoadableSource(item) {
-  return typeof item?.load === "function";
+    return !!item && typeof item === "object" && "load" in item && typeof item.load === "function";
 }
 //#endregion
-//#region Support Functions
-async function getRelatedFeatureLayer(layer, relationship) {
-  if (!relationship) {
-    return null;
-  }
-  const url = `${layer.url}/${relationship.relatedTableId}`;
-  const relatedFeatureLayer = await supportedSourceFromDefinition({ url });
-  if (!isFeatureLayerInstance(relatedFeatureLayer)) {
-    return null;
-  }
-  return relatedFeatureLayer;
+//#region Service Metadata
+async function supportedSourceFromDefinition(definition) {
+    if (!definition) {
+        return null;
+    }
+    let source = null;
+    if (isSupportedLayerInstance(definition) || isFeatureSetInstance(definition) || isFieldsDefinition(definition)) {
+        source = definition;
+    }
+    else {
+        source = await newFeatureLayer(definition);
+    }
+    if (isLoadableSource(source)) {
+        await source.load();
+    }
+    return source;
 }
-function sortFields(layer) {
-  return (firstField, secondField) => {
-    if (firstField.type === "oid") {
-      return -1;
-    }
-    if (secondField.type === "oid") {
-      return 1;
-    }
-    if (isTypesCapabaleLayer(layer)) {
-      if (firstField.name === layer.typeIdField) {
-        return -1;
-      }
-      if (secondField.name === layer.typeIdField) {
-        return 1;
-      }
-    }
-    return firstField.name.localeCompare(secondField.name, "en", { sensitivity: "base" });
-  };
+async function serviceMetaData(url) {
+    url += "/layers";
+    const request = await importRequest();
+    const response = await request(url, { responseType: "json", query: { f: "json" } });
+    const data = {
+        layers: response.data?.layers ?? [],
+        tables: response.data?.tables ?? []
+    };
+    const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
+    const layers = filterFeatureLayerInfos(data.layers, queryCapability);
+    const tables = filterFeatureLayerInfos(data.tables, queryCapability);
+    return { layers, tables };
 }
-function getSubtypesProperties(profile, types, field) {
-  // Try the coded domain first
-  const group = getDomainValuesProperties(profile, field.domain, { code: "subtypes" });
-  if (group) {
-    return group;
-  }
-  // No coded domain for the subtypes, we will manufacture it
-  const values = types.map((t) => new ValueVariable({ profile, label: `${t.id}`, description: t.name, snippet: `"${t.id}"` }));
-  return new GroupOfVariables(profile, { code: "subtypes" }, values);
+function filterFeatureLayerInfos(layers, queryCapability) {
+    return layers.filter((layer) => {
+        if (layer.type !== "Feature Layer" && layer.type !== "Table") {
+            return false;
+        }
+        const capabilities = layer.capabilities
+            ? layer.capabilities
+                .toLowerCase()
+                .split(",")
+                .map((value) => value.trim())
+            : [];
+        return capabilities.includes(queryCapability);
+    });
 }
-function getDomainValuesProperties(profile, domain, label) {
-  if (!domain || domain.type !== "coded-value") {
-    return null;
-  }
-  const values = domain.codedValues.map((v) => new ValueVariable({
-    profile,
-    label: `${v.code}`,
-    description: v.name,
-    snippet: `"${v.code}"`,
-    filterDescription: true
-  }));
-  return new GroupOfVariables(profile, label, values);
+//#endregion
+
+//#endregion
+//#region Support functions
+async function getRelatedFeatureLayer(layer, relationship) {
+    const relatedFeatureLayer = await newFeatureLayer({ url: `${layer.url}/${relationship.relatedTableId}` });
+    await relatedFeatureLayer.load();
+    return relatedFeatureLayer;
 }
-function getDomainValuesBySubtypeGroup(profile, types, field) {
-  const variables = [];
-  types.forEach((t) => {
-    let domain = t.domains?.[field.name];
-    if (!domain) {
-      return;
-    }
-    if (domain.type === "inherited") {
-      domain = field.domain;
-      return;
-    }
-    const domainValuesGroup = getDomainValuesProperties(profile, domain, {
-      code: "domainvaluesfortypeformat",
-      formatValues: {
-        fieldName: field.alias ?? field.name,
-        typeName: t.name
-      }
-    });
-    if (!domainValuesGroup) {
-      return;
-    }
-    const label = `${t.id}`;
-    const snippet = `"${t.id}""`;
-    const subtypeDictionary = new DictionaryVariable({ profile, label, snippet });
-    subtypeDictionary.variables = [domainValuesGroup];
-    variables.push(subtypeDictionary);
-  });
-  if (!variables.length) {
-    return null;
-  }
-  return new GroupOfVariables(profile, { code: "domainvaluesbysubtypes" }, variables);
+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 = new RegExp(/^[a-z_$][a-z0-9_$]*$/gi);
+const validIdentifierExpr = /^[a-z_$][a-z0-9_$]*$/giu;
 function getMemberExpressionProperty(prop, includeDot = true) {
-  if (prop.match(validIdentifierExpr)) {
-    return `${includeDot ? "." : ""}${prop}`;
-  }
-  return `["${prop}"]`;
+    if (prop.match(validIdentifierExpr)) {
+        return `${includeDot ? "." : ""}${prop}`;
+    }
+    return `["${prop}"]`;
 }
 function assembleMemberExpression(obj, prop) {
-  if (!obj) {
-    return prop;
-  }
-  return `${obj}${getMemberExpressionProperty(prop)}`;
-}
-//#endregion
-//#region Sources
-async function supportedSourceFromDefinition(definition) {
-  if (!definition) {
-    return null;
-  }
-  let source = null;
-  if (isSupportedLayerInstance(definition) || isFeatureSetInstance(definition) || isFieldsDefinition(definition)) {
-    source = definition;
-  }
-  else {
-    source = await newFeatureLayer(definition);
-    if (!isFeatureLayerInstance(source)) {
-      console.error("Invalid FeatureSetDefinition", definition);
-      return null;
-    }
-  }
-  if (!source) {
-    console.error("Invalid FeatureSetDefinition", definition);
-    return null;
-  }
-  if (isLoadableSource(source)) {
-    await source.load();
-  }
-  return source;
-}
-async function serviceMetaData(url) {
-  url += "/layers";
-  const request = await importRequest();
-  const response = await request(url, { responseType: "json", query: { f: "json" } });
-  const data = {
-    layers: response.data?.layers ?? [],
-    tables: response.data?.tables ?? []
-  };
-  const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
-  const layers = filterFeatureLayerInfos(data.layers, queryCapability);
-  const tables = filterFeatureLayerInfos(data.tables, queryCapability);
-  return { layers, tables };
-}
-function filterFeatureLayerInfos(layers, queryCapability) {
-  return layers.filter((layer) => {
-    if (layer.type !== "Feature Layer" && layer.type !== "Table") {
-      return false;
-    }
-    const capabilities = layer.capabilities
-      ? layer.capabilities
-        .toLowerCase()
-        .split(",")
-        .map((value) => value.trim())
-      : [];
-    return capabilities.includes(queryCapability);
-  });
+    if (!obj) {
+        return prop;
+    }
+    return `${obj}${getMemberExpressionProperty(prop)}`;
 }
 //#endregion
-//#region Functions to Editor Variables to a language service variables
+//#region Editor Profile to Language Service Profile functions
 async function variablesToLSVariable(editorVariables, kind = CompletionItemKind.Variable) {
-  if (!editorVariables) {
-    return [];
-  }
-  const properties = await Promise.all(editorVariables.map(async (editorVariable) => {
-    switch (editorVariable.type) {
-      case "dictionary":
-        return dictionaryToLSDictionary(editorVariable, kind);
-      case "feature":
-        return featureToLSFeature(editorVariable, kind);
-      default:
-        return variableToLSVariable(editorVariable, kind);
-    }
-  }));
-  return properties.filter((p) => p);
+    return await Promise.all(editorVariables.map(async (editorVariable) => {
+        switch (editorVariable.type) {
+            case "dictionary":
+                return await dictionaryToLSDictionary(editorVariable, kind);
+            case "feature":
+                return await featureToLSFeature(editorVariable, kind);
+            default:
+                return variableToLSVariable(editorVariable, kind);
+        }
+    }));
 }
 function variableToLSVariable(editorVariable, kind) {
-  const { name, type } = editorVariable;
-  const description = editorVariable.getDescription();
-  return {
-    name,
-    description,
-    type,
-    completion: {
-      label: name,
-      detail: name,
-      insertText: name,
-      insertTextMode: InsertTextMode.asIs,
-      insertTextFormat: InsertTextFormat.PlainText,
-      kind,
-      documentation: { kind: "markdown", value: description }
-    }
-  };
+    const { name, type } = editorVariable;
+    const description = editorVariable.getDescription();
+    return {
+        name,
+        description,
+        type,
+        completion: {
+            label: name,
+            detail: name,
+            insertText: name,
+            insertTextMode: InsertTextMode.asIs,
+            insertTextFormat: InsertTextFormat.PlainText,
+            kind,
+            documentation: { kind: "markdown", value: description }
+        }
+    };
 }
 async function featureToLSFeature(editorFeature, kind) {
-  // Get the source for the definition
-  const source = await editorFeature.loadSource();
-  const { name } = editorFeature;
-  const description = editorFeature.getDescription();
-  const resultCompletion = {
-    label: name,
-    detail: name,
-    insertText: name,
-    insertTextMode: InsertTextMode.asIs,
-    insertTextFormat: InsertTextFormat.PlainText,
-    kind
-  };
-  const result = {
-    name,
-    description,
-    type: "dictionary",
-    properties: [],
-    completion: resultCompletion
-  };
-  // No source definition, then it will be a feature without any known fields
-  if (!source) {
-    return result;
-  }
-  // 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}** (${field.alias ?? field.name})  \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);
-    fieldProfileValues.push({
-      name: field.name,
-      description: field.alias || field.name,
-      type,
-      completion: {
-        label: field.name,
-        detail: field.alias || field.name,
-        insertText,
+    // Get the source for the definition
+    const source = await editorFeature.loadSource();
+    const { name } = editorFeature;
+    const description = editorFeature.getDescription();
+    const resultCompletion = {
+        label: name,
+        detail: name,
+        insertText: name,
         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 }
-      }
+        kind
+    };
+    const result = {
+        name,
+        description,
+        type: "dictionary",
+        properties: [],
+        completion: resultCompletion
+    };
+    // No source definition, then it will be a feature without any known fields
+    if (!source) {
+        return result;
+    }
+    // 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];
-  resultCompletion.documentation = { kind: "markdown", value: featureCompletionDescription };
-  return result;
+    result.properties = [...fieldProfileValues, ...aliasProfileValues];
+    resultCompletion.documentation = { kind: "markdown", value: featureCompletionDescription };
+    return result;
 }
 async function dictionaryToLSDictionary(editorDictionary, kind) {
-  const { name, dictionaryVariables: variables } = editorDictionary;
-  const description = editorDictionary.getDescription();
-  const completionDescription = variables.reduce((previous, p) => {
-    if (previous !== "") {
-      previous += "  \n  \n";
-    }
-    previous += `**${p.name}**  \n${p.type}`;
-    const description = p.getDescription();
-    if (description) {
-      previous += `  \n${description}`;
-    }
-    return previous;
-  }, description ?? "");
-  return {
-    name,
-    description,
-    type: "dictionary",
-    properties: await variablesToLSVariable(variables, CompletionItemKind.Field),
-    completion: {
-      label: name,
-      detail: name,
-      insertText: name,
-      insertTextMode: InsertTextMode.asIs,
-      insertTextFormat: InsertTextFormat.PlainText,
-      kind,
-      documentation: { kind: "markdown", value: completionDescription }
-    }
-  };
+    const { name, dictionaryVariables: variables } = editorDictionary;
+    const description = editorDictionary.getDescription();
+    const completionDescription = variables.reduce((previous, p) => {
+        if (previous !== "") {
+            previous += "  \n  \n";
+        }
+        previous += `**${p.name}**  \n${p.type}`;
+        const description = p.getDescription();
+        if (description) {
+            previous += `  \n${description}`;
+        }
+        return previous;
+    }, description);
+    return {
+        name,
+        description,
+        type: "dictionary",
+        properties: await variablesToLSVariable(variables, CompletionItemKind.Field),
+        completion: {
+            label: name,
+            detail: name,
+            insertText: name,
+            insertTextMode: InsertTextMode.asIs,
+            insertTextFormat: InsertTextFormat.PlainText,
+            kind,
+            documentation: { kind: "markdown", value: completionDescription }
+        }
+    };
 }
 /**
  * Represents a item in the EditorProfile. The profile is converted into an optimized way for
@@ -405,107 +396,107 @@ async function dictionaryToLSDictionary(editorDictionary, kind) {
  * 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 q(this._label);
-    }
-    return B(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 B(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());
-  }
+    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 Z(this._label);
+        }
+        return K(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 K(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;
-  }
+    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 resolveIntlPath(this._profile?.intlStrings, this.type.toLowerCase()) ?? "";
-    }
-    return super.getDescription();
-  }
-  toProfileVariableDefinition() {
-    return { type: this.type, name: "", ...this.declaration };
-  }
+    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 resolveIntlPath(this._profile?.intlStrings, this.type.toLowerCase()) ?? "";
-    }
-    return super.getDescription();
-  }
-  toProfileVariableDefinition() {
-    return { type: this.type, elementType: this.elementType, name: "", ...this.declaration };
-  }
+    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
@@ -514,595 +505,762 @@ class ArrayVariable extends VariableBase {
  * collection is ready or not.
  */
 class CollectionBasedVariable extends VariableBase {
-  constructor(props) {
-    super(props);
-    this.isCollection = true;
-    this._loaded = true;
+    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;
+    }
     /**
-     * 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.
+     * Returns true if the collection has been loaded
      */
-    this.variables = [];
-  }
-  /**
-   * Returns true if the collection has been loaded
-   */
-  get loaded() {
-    return this._loaded;
-  }
-  /**
-   * Loads the items if the collection is asynchronous.
-   * If the colleciton is synchronous then the function is a no-op.
-   */
-  async loadSource() {
-    return;
-  }
-  /**
-   * Returns an url to the associated information
-   */
-  get informationUrl() {
-    return null;
-  }
-  get informationType() {
-    return "";
-  }
+    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;
-  }
+    constructor(profile, label, variables = []) {
+        super(profile, label);
+        this.variables = variables;
+        this.type = "group";
+        this.isCollection = true;
+    }
+    passFilter() {
+        return true;
+    }
 }
 class DictionaryVariable extends CollectionBasedVariable {
-  constructor(props) {
-    super(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)];
-    }
-  }
-  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 "geometry":
-        return new ValueVariable({ profile: this._profile, declaration, label: snippet, snippet });
-      case "feature":
-        return new FeatureVariable({ profile: this._profile, declaration, label: snippet, snippet });
-      case "featureSet":
-        return new FeatureSetVariable({ profile: this._profile, declaration, label: snippet, snippet }, [
-          new ValueVariable({ profile: this._profile, label: snippet, description: "", snippet })
-        ]);
-      case "featureSetCollection":
-        return new FeatureSetCollectionVariable({
-          profile: this._profile,
-          declaration,
-          label: snippet,
-          snippet
-        });
-      case "dictionary":
-        return new DictionaryVariable({
-          profile: this._profile,
-          declaration,
-          label: snippet,
-          snippet
-        });
-      case "array":
-        return new ArrayVariable({
-          profile: this._profile,
-          declaration,
-          label: snippet,
-          snippet
+    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);
+            }
         });
-      default:
-        console.error("Invalid profile variable", declaration);
-        return null;
+        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())
+        };
     }
-  }
-  toProfileVariableDefinition() {
-    return {
-      type: this.type,
-      name: "",
-      ...this.declaration,
-      properties: this.dictionaryVariables.map((variable) => variable.toProfileVariableDefinition())
-    };
-  }
 }
 class SourceBasedVariable extends CollectionBasedVariable {
-  constructor(props, relationshipsProperties) {
-    super(props);
-    this.relationshipsProperties = relationshipsProperties;
-    this._source = null;
-    this._loaded = false;
-    this._definition = props?.declaration?.definition;
-  }
-  get title() {
-    return this._source?.title ?? "";
-  }
-  get url() {
-    return this._definition?.url ?? "";
-  }
-  get informationUrl() {
-    if (!this.loaded) {
-      return null;
-    }
-    const url = this._source?.url;
-    if (!url) {
-      return null;
-    }
-    const layerId = this._source?.layerId ?? "";
-    return `${url}/${layerId}`;
-  }
-  get informationType() {
-    return this._profile?.intlStrings?.layer ?? "layer";
-  }
-  loadSource() {
-    if (Q(this._loadPromise) && G(this._loadPromise)) {
-      return this._loadPromise;
-    }
-    this._loadPromise = this._loadSource();
-    return this._loadPromise;
-  }
-  _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._getSubtypesOrDomainValuesDictionary(field);
-    if (subtypesOrDomainValuesDictionary) {
-      return subtypesOrDomainValuesDictionary;
-    }
-    // Create the value property
-    const valueSnippet = this.type === "feature" ? assembleMemberExpression(this.snippet, field.name) : field.name;
-    return new ValueVariable({
-      profile: this._profile,
-      label: valueSnippet,
-      description: field.alias ?? field.name,
-      snippet: valueSnippet,
-      icon: fieldTypeToIconName(field),
-      filterDescription: true
-    });
-  }
-  _getSubtypesOrDomainValuesDictionary(field) {
-    if (!isDomainsCapableLayer(this._source)) {
-      return null;
-    }
-    // Create the domain dictionary, we may not use it
-    const valueSnippet = this.type === "feature" ? assembleMemberExpression(this.snippet, field.name) : field.name;
-    const domainDictionary = new DictionaryVariable({
-      profile: this._profile,
-      label: valueSnippet,
-      description: field.alias ?? field.name,
-      snippet: valueSnippet,
-      icon: "form-dropdown"
-    });
-    // Add the header group
-    const headerGroup = new GroupOfVariables(this._profile, field.alias ?? field.name, [
-      new ValueVariable({
-        profile: this._profile,
-        label: valueSnippet,
-        description: "",
-        snippet: valueSnippet
-      })
-    ]);
-    domainDictionary.variables = [headerGroup];
-    // If it is the subtype field then get its coded domain values
-    if (isTypesCapabaleLayer(this._source) && field.name === this._source.typeIdField) {
-      const subtypesGroup = getSubtypesProperties(this._profile, this._source.types, field);
-      domainDictionary.variables.push(subtypesGroup);
-      return domainDictionary;
-    }
-    // Since its' not the subtype field then add the snippet for the domain name
-    if (this.type === "feature") {
-      const domainNameSnippet = `DomainName(${this.snippet}, "${field.name}")`;
-      headerGroup.variables.push(new ValueVariable({
-        profile: this._profile,
-        label: domainNameSnippet,
-        description: "",
-        snippet: domainNameSnippet
-      }));
-    }
-    if (isTypesCapabaleLayer(this._source)) {
-      // 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
-      const allInherited = this._source.types.every((t) => t.domains?.[field.name]?.type === "inherited");
-      if (!allInherited) {
+    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 (Y(this._loadPromise) && ee(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.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 = getDomainValuesBySubtypeGroup(this._profile, this._source.types, field);
+        const domainValuesBySubtypeGroup = this._getDomainValuesGroup(this._source.subtypes, field);
         if (!domainValuesBySubtypeGroup) {
-          return null;
+            return null;
         }
+        const domainDictionary = this._createDomainDictionary(field);
         domainDictionary.variables.push(domainValuesBySubtypeGroup);
         return domainDictionary;
-      }
     }
-    // Either we have types but all the domains are inherited or we don't have types
-    const domainValuesGroup = getDomainValuesProperties(this._profile, this._source.getFieldDomain?.(field.name), {
-      code: "domainvalues"
-    });
-    if (!domainValuesGroup) {
-      return null;
-    }
-    domainDictionary.variables.push(domainValuesGroup);
-    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 (!isFeatureLayerInstance(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({
-        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(Q);
-    if (!relationshipsGroup.variables.length) {
-      return null;
+    _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(Y);
+        if (!relationshipsGroup.variables.length) {
+            return null;
+        }
+        return relationshipsGroup;
     }
-    return relationshipsGroup;
-  }
 }
 class FeatureVariable extends SourceBasedVariable {
-  constructor(props) {
-    super(props, { exposeRelationships: true });
-    this.type = "feature";
-  }
-  get title() {
-    if (isSupportedLayerInstance(this._source)) {
-      return this._source.title;
-    }
-    return { code: "feature" };
-  }
-  async _loadSource() {
-    if (this.loaded) {
-      return this._source;
+    constructor(owner, props) {
+        super(owner, props, { exposeRelationships: true });
+        this.type = "feature";
+    }
+    get title() {
+        if (isSupportedLayerInstance(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 = isSupportedLayerInstance(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 (e) {
+            console.error("Loading issue", e, this);
+            this._source = null;
+        }
+        finally {
+            this._loaded = true;
+        }
+        return this._source;
+    }
+    toProfileVariableDefinition() {
+        return { type: this.type, name: "", ...this.declaration, definition: this._definition };
     }
-    try {
-      this._source = await supportedSourceFromDefinition(this._definition);
-      if (!this._source) {
-        throw new Error("Invalid definition");
-      }
-      // The title group and snippet
-      const title = isSupportedLayerInstance(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 (e) {
-      console.error("Loading issue", e, this);
-      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(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(props, relationshipProps);
-    this.featureSetSnippets = featureSetSnippets;
-    this.type = "featureSet";
-  }
-  get title() {
-    if (isSupportedLayerInstance(this._source)) {
-      return this._source.title;
-    }
-    return { code: "featureset" };
-  }
-  async _loadSource() {
-    if (this.loaded) {
-      return this._source;
+    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 (isSupportedLayerInstance(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 (e) {
+            console.error("Loading issue", e, this);
+            this._source = null;
+        }
+        finally {
+            this._loaded = true;
+        }
+        return this._source;
+    }
+    toProfileVariableDefinition() {
+        return { type: this.type, name: "", ...this.declaration, definition: this._definition };
     }
-    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 (e) {
-      console.error("Loading issue", e, this);
-      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(props) {
-    super(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(this._featureSetCollections.source.portalItem);
-    }
-    // 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?.webmap ?? "webmap";
-    }
-    return this._profile?.intlStrings?.featureservice ?? "featureservice";
-  }
-  async loadSource() {
-    if (Q(this._loadPromise) && G(this._loadPromise)) {
-      return this._loadPromise;
-    }
-    this._loadPromise = this._loadSource();
-    return this._loadPromise;
-  }
-  async _loadSource() {
-    if (this.loaded) {
-      return this._featureSetCollections;
+    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(this._featureSetCollections.source.portalItem);
+        }
+        // const firstLayer = this._featureSetCollection.layers[0] ?? this._featureSetCollection.tables[0];
+        // if (!firstLayer) {
+        return null;
+        // }
+        // return `${firstLayer.url}`;
     }
-    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: this._featureSetCollections.source.portalItem?.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 (e) {
-      console.error("Loading issue", e, this);
-      this._featureSetCollections = null;
-    }
-    finally {
-      this._loaded = true;
-    }
-    return this._featureSetCollections;
-  }
-  async _featureSetCollectionsFromDefinition() {
-    if (!this._definition) {
-      return null;
-    }
-    if (isWebMapInstance(this._definition)) {
-      return this._featureSetCollectionFromWebMap(this._definition);
-    }
-    if (isSupportedLayerInstance(this._definition)) {
-      return 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 this._featureSetCollectionFromPortalItem(this._definition.portalItem);
-    }
-    if (isUrlDefinition(this._definition)) {
-      // Assume that the url is pointing to a feature server
-      return this._featureSetCollectionFromUrl(this._definition.url);
-    }
-    return null;
-  }
-  async _featureSetCollectionFromWebMap(definition) {
-    const webMap = isWebMapInstance(definition) ? definition : await newWebMap({ portalItem: definition });
-    await webMap.loadAll();
-    // Until jsapi fix a bug we have to load the table separately
-    await Promise.all(webMap.tables.map(async (t) => t.load()));
-    return {
-      layers: this._convertWebMapLayersToVariables(webMap.layers),
-      tables: this._convertWebMapLayersToVariables(webMap.tables, true),
-      source: webMap
-    };
-  }
-  async _featureSetCollectionFromPortalItem(definition) {
-    const portalItem = await newPortalItem(definition);
-    await portalItem.load();
-    switch (portalItem.type) {
-      case "Web Map":
-        return this._featureSetCollectionFromWebMap(portalItem);
-      case "Feature Service":
-        return this._featureSetCollectionFromUrl(portalItem.url);
-      default:
-        console.error("Unsupported portal item", definition);
+    get informationType() {
+        if (!this.loaded || !this._featureSetCollections) {
+            return "";
+        }
+        if (typeof this._featureSetCollections.source !== "string") {
+            return this._profile?.intlStrings.webmap ?? "webmap";
+        }
+        return this._profile?.intlStrings.featureservice ?? "featureservice";
+    }
+    async loadSource() {
+        if (Y(this._loadPromise) && ee(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: this._featureSetCollections.source.portalItem.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 (e) {
+            console.error("Loading issue", e, this);
+            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 (isSupportedLayerInstance(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);
+        }
+        if (isUrlDefinition(this._definition)) {
+            // Assume that the url is pointing to a feature server
+            return await this._featureSetCollectionFromUrl(this._definition.url);
+        }
         return null;
     }
-  }
-  async _featureSetCollectionFromUrl(url) {
-    url = url.replace(/\/featureserver\/[0-9]*/i, "/FeatureServer");
-    url = url.replace(/\/mapserver\/[0-9]*/i, "/MapServer");
-    url = url.split("?")[0];
-    const metadata = await serviceMetaData(url);
-    const layersPromise = Promise.all(metadata.layers.map(async (layerInfo) => {
-      const fl = await newFeatureLayer({ url: `${url}/${layerInfo.id}` });
-      await fl.load();
-      return this._createFeatureSetVariable(fl);
-    }));
-    const tablesPromise = Promise.all(metadata.tables.map(async (layerInfo) => {
-      const fl = await newFeatureLayer({ url: `${url}/${layerInfo.id}` });
-      await fl.load();
-      return this._createFeatureSetVariable(fl);
-    }));
-    const [layers, tables] = await Promise.all([layersPromise, tablesPromise]);
-    return { layers, tables, source: url };
-  }
-  _convertWebMapLayersToVariables(layers, filteringTables = false) {
-    const layerVariables = [];
-    layers
-      .toArray()
-      .reverse()
-      .forEach((layer) => {
-      if (isFeatureLayerInstance(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({
-      profile: this._profile,
-      declaration: { definition: featureLayer },
-      label: 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 })
-      ];
+    async _featureSetCollectionFromMap(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
+        };
     }
-    else {
-      const snippetById = `FeatureSetById(${this.snippet}, "${featureLayer.layerId}")`;
-      return [new ValueVariable({ profile: this._profile, label: snippetById, description: "", snippet: snippetById })];
+    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 newFeatureLayer({ url: `${processedUrl}/${layerInfo.id}` });
+            await featureLayer.load();
+            return this._createFeatureSetVariable(featureLayer);
+        }));
+        const tablesPromise = Promise.all(metadata.tables.map(async (layerInfo) => {
+            const table = await newFeatureLayer({ 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: 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 };
     }
-  }
-  toProfileVariableDefinition() {
-    return { type: this.type, name: "", ...this.declaration, definition: this._definition };
-  }
 }
 /**
  * The EditorProfile is an object that represents an Arcade Profile.
@@ -1113,64 +1271,64 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
  * 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({
-      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())
-    };
-  }
+    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 (isSupportedLayerInstance(item) ||
-    isFeatureSetInstance(item) ||
-    isUrlDefinition(item) ||
-    isFieldsDefinition(item) ||
-    isFeatureLayerItemDefinition(item));
+    return (isSupportedLayerInstance(item) ||
+        isFeatureSetInstance(item) ||
+        isUrlDefinition(item) ||
+        isFieldsDefinition(item) ||
+        isFeatureLayerItemDefinition(item));
 }
 function isFeatureSetDefinition(item) {
-  return (isFeatureLayerInstance(item) ||
-    isFeatureSetInstance(item) ||
-    isUrlDefinition(item) ||
-    isFieldsDefinition(item) ||
-    isFeatureLayerItemDefinition(item));
+    return (isQueryableLayerInstance(item) ||
+        isFeatureSetInstance(item) ||
+        isUrlDefinition(item) ||
+        isFieldsDefinition(item) ||
+        isFeatureLayerItemDefinition(item));
 }
 function isFeatureSetCollectionDefinition(item) {
-  return isPortalItemDefinition(item) || isWebMapInstance(item) || isFeatureSetDefinition(item);
+    return isPortalItemDefinition(item) || isMapInstance(item) || isFeatureSetDefinition(item);
 }
 /**
  * Get a PredefinedProfile for a locale. If not already loaded then fetch it.
@@ -1178,26 +1336,26 @@ function isFeatureSetCollectionDefinition(item) {
  * the english version of the profile.
  */
 async function getSdkPredefinedProfiles(locale = "en") {
-  const profiles = sdkPredefinedProfilesMap.get(locale);
-  if (profiles) {
-    return profiles;
-  }
-  if (!x.has(locale)) {
-    return getSdkPredefinedProfiles("en");
-  }
-  try {
-    const response = await fetch(getAssetPath(`./assets/arcade-language/profiles/arcade-profiles.t9n.${locale}.json`));
-    if (response.ok) {
-      return cacheSdkPredefinedProfiles(locale, await response.json());
-    }
-    if (locale === "en") {
-      return null;
-    }
-    return getSdkPredefinedProfiles("en");
-  }
-  catch (e) {
-    return null;
-  }
+    const profiles = sdkPredefinedProfilesMap.get(locale);
+    if (profiles) {
+        return profiles;
+    }
+    if (!E.has(locale)) {
+        return await getSdkPredefinedProfiles("en");
+    }
+    try {
+        const response = await fetch(getAssetPath(`./assets/arcade-language/profiles/arcade-profiles.t9n.${locale}.json`));
+        if (response.ok) {
+            return cacheSdkPredefinedProfiles(locale, (await response.json()));
+        }
+        if (locale === "en") {
+            return null;
+        }
+        return await getSdkPredefinedProfiles("en");
+    }
+    catch {
+        return null;
+    }
 }
 const sdkPredefinedProfilesMap = new Map();
 /**
@@ -1205,237 +1363,234 @@ const sdkPredefinedProfilesMap = new Map();
  * Map of profiles per locale.
  */
 function cacheSdkPredefinedProfiles(locale, profiles) {
-  const map = new Map();
-  profiles.forEach((profile) => {
-    map.set(profile.id, profile);
-  });
-  sdkPredefinedProfilesMap.set(locale, map);
-  return map;
+    const map = new Map();
+    profiles.forEach((profile) => {
+        map.set(profile.id, profile);
+    });
+    sdkPredefinedProfilesMap.set(locale, map);
+    return map;
 }
 async function getSdkPredefinedProfile(id, locale = "en") {
-  const profiles = await getSdkPredefinedProfiles(locale);
-  return profiles?.get(id) ?? null;
+    const profiles = await getSdkPredefinedProfiles(locale);
+    return profiles?.get(id) ?? null;
 }
-function isExtendedPredefinedProfileDefinition(predefinedProfileDefinition) {
-  return Array.isArray(predefinedProfileDefinition?.additionalVariables);
+function isExtendedPredefinedProfileDefinition(item) {
+    return !!item && typeof item === "object" && "additionalVariables" in item && Array.isArray(item.additionalVariables);
 }
 function convertApiVariables(variables) {
-  if (!variables) {
-    return [];
-  }
-  return variables.map(convertApiVariable);
+    return variables.map(convertApiVariable);
 }
 function convertApiVariable(variable) {
-  switch (variable.type) {
-    case "dictionary":
-      return {
-        ...variable,
-        type: variable.type,
-        properties: convertApiVariables(variable.properties)
-      };
-    case "array": {
-      return {
-        ...variable,
-        type: variable.type,
-        elementType: { type: "number", name: "number" }
-      };
-    }
-    default:
-      return { ...variable, type: variable.type };
-  }
+    switch (variable.type) {
+        case "dictionary":
+            return {
+                ...variable,
+                type: variable.type,
+                properties: convertApiVariables(variable.properties)
+            };
+        case "array": {
+            return {
+                ...variable,
+                type: variable.type,
+                elementType: { type: "number", name: "number" }
+            };
+        }
+        default:
+            return { ...variable, type: variable.type };
+    }
 }
 async function convertToEditorProfileDefinition(predefinedProfile, locale = "en") {
-  if (!isPredefinedProfile(predefinedProfile)) {
-    return undefined;
-  }
-  const sdkPredefinedProfile = await getSdkPredefinedProfile(predefinedProfile.id, locale);
-  if (!sdkPredefinedProfile) {
-    return undefined;
-  }
-  const editorProfile = {
-    bundles: [...sdkPredefinedProfile.bundles],
-    variables: [],
-    hiddenApiItems: predefinedProfile.hiddenApiItems?.map((s) => s.toLowerCase())
-  };
-  // Merge the SDK variables' definitions/properties with the predefined profile definitions.
-  sdkPredefinedProfile.variables.forEach((sdkVariable) => {
-    // Don't include disabled variables
-    if (predefinedProfile.disabledVariables?.includes(sdkVariable.name)) {
-      return;
-    }
-    // Try to get a definition from the predefined profile.
-    const definition = predefinedProfile.definitions[sdkVariable.name];
-    // Note: Something is weird with TS. The sdkVariables are being casted to the wrong type
-    // despite the type checking from the switch statement.
-    switch (sdkVariable.type) {
-      case "dictionary":
-        // For dictionary, we support properties overrride
-        return editorProfile.variables.push(convertApiVariable({
-          ...sdkVariable,
-          type: sdkVariable.type,
-          properties: Array.isArray(definition) ? [...definition] : sdkVariable.properties
-        }));
-      case "feature":
-        if (isFeatureDefinition(definition)) {
-          return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
-        }
-        return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type });
-      case "featureSet":
-        if (isFeatureSetDefinition(definition)) {
-          return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
-        }
-        return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type });
-      case "featureSetCollection":
-        if (isFeatureSetCollectionDefinition(definition)) {
-          return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
-        }
-        return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type });
-      default:
-        return editorProfile.variables.push(convertApiVariable(sdkVariable));
-    }
-  });
-  if (isExtendedPredefinedProfileDefinition(predefinedProfile)) {
-    editorProfile.variables.push(...(predefinedProfile.additionalVariables ?? []));
-  }
-  return editorProfile;
+    if (!isPredefinedProfile(predefinedProfile)) {
+        return undefined;
+    }
+    const sdkPredefinedProfile = await getSdkPredefinedProfile(predefinedProfile.id, locale);
+    if (!sdkPredefinedProfile) {
+        return undefined;
+    }
+    const editorProfile = {
+        bundles: [...sdkPredefinedProfile.bundles],
+        variables: [],
+        hiddenApiItems: predefinedProfile.hiddenApiItems?.map((s) => s.toLowerCase())
+    };
+    // Merge the SDK variables' definitions/properties with the predefined profile definitions.
+    sdkPredefinedProfile.variables.forEach((sdkVariable) => {
+        // Don't include disabled variables
+        if (predefinedProfile.disabledVariables?.includes(sdkVariable.name)) {
+            return;
+        }
+        // Try to get a definition from the predefined profile.
+        const definition = predefinedProfile.definitions[sdkVariable.name];
+        // Note: Something is weird with TS. The sdkVariables are being casted to the wrong type
+        // despite the type checking from the switch statement.
+        switch (sdkVariable.type) {
+            case "dictionary":
+                // For dictionary, we support properties overrride
+                return editorProfile.variables.push(convertApiVariable({
+                    ...sdkVariable,
+                    type: sdkVariable.type,
+                    properties: Array.isArray(definition) ? [...definition] : sdkVariable.properties
+                }));
+            case "feature":
+                if (isFeatureDefinition(definition)) {
+                    return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
+                }
+                return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type });
+            case "featureSet":
+                if (isFeatureSetDefinition(definition)) {
+                    return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
+                }
+                return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type });
+            case "featureSetCollection":
+                if (isFeatureSetCollectionDefinition(definition)) {
+                    return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
+                }
+                return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type });
+            default:
+                return editorProfile.variables.push(convertApiVariable(sdkVariable));
+        }
+    });
+    if (isExtendedPredefinedProfileDefinition(predefinedProfile)) {
+        editorProfile.variables.push(...(predefinedProfile.additionalVariables ?? []));
+    }
+    return editorProfile;
 }
 
 const arcadeLanguageId = "arcade";
 const defaultContext = {
-  locale: "en"
+    locale: "en"
 };
 class ArcadeLanguageServiceDefaults {
-  constructor() {
-    this._languageId = arcadeLanguageId;
-    this._languageOptions = {};
-    this._onDidChange = new Emitter();
-    this._profileMap = new Map();
-    this._apiContextMap = new Map();
-    this._onModelContextDidChange = new Emitter();
-    this._onDidModelContextChangeTimeout = -1;
-  }
-  get onDidChange() {
-    return this._onDidChange.event;
-  }
-  get onModelContextDidChange() {
-    return this._onModelContextDidChange.event;
-  }
-  get languageId() {
-    return this._languageId;
-  }
-  get languageOptions() {
-    return this._languageOptions;
-  }
-  _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();
-  }
-  /**
-   * 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 (isPredefinedProfile(definition)) {
-      definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
-    }
-    const intlStrings = await N(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
-    if (!intlStrings) {
-      throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
-    }
-    this.disposeEditorProfileForModel(modelId);
-    const key = this._getApiKey(modelId);
-    const editorProfile = new EditorProfile(definition, intlStrings);
-    this._profileMap.set(key, editorProfile);
-    const apiProfile = await editorProfile.toLSProfile();
-    this.updateApiContextForModel(modelId, {
-      locale: apiContext.locale,
-      profile: apiProfile,
-      snippets: apiContext.snippets
-    });
-  }
-  /**
-   * 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);
-  }
-  /**
-   * 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);
-  }
+    constructor() {
+        this._languageId = arcadeLanguageId;
+        this._languageOptions = {};
+        this._onDidChange = new Emitter();
+        this._profileMap = new Map();
+        this._apiContextMap = new Map();
+        this._onModelContextDidChange = new Emitter();
+        this._onDidModelContextChangeTimeout = -1;
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    get onModelContextDidChange() {
+        return this._onModelContextDidChange.event;
+    }
+    get languageId() {
+        return this._languageId;
+    }
+    get languageOptions() {
+        return this._languageOptions;
+    }
+    _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();
+    }
+    /**
+     * 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 (isPredefinedProfile(definition)) {
+            definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
+        }
+        const intlStrings = await N(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
+        if (!intlStrings) {
+            throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
+        }
+        this.disposeEditorProfileForModel(modelId);
+        const key = this._getApiKey(modelId);
+        const editorProfile = new EditorProfile(definition, intlStrings);
+        this._profileMap.set(key, editorProfile);
+        const apiProfile = await editorProfile.toLSProfile();
+        this.updateApiContextForModel(modelId, {
+            locale: apiContext.locale,
+            profile: apiProfile,
+            snippets: apiContext.snippets
+        });
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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);
+    }
 }
 const arcadeDefaults = new ArcadeLanguageServiceDefaults();
 const arcade = {
-  setProfileForModel: arcadeDefaults.setProfileForModel.bind(arcadeDefaults)
+    setProfileForModel: arcadeDefaults.setProfileForModel.bind(arcadeDefaults)
 };
 
 export { arcade as a, arcadeDefaults as b };