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

package/dist/components/language-defaults-base.js

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