@arcgis/coding-components 4.31.0-next.76 → 4.31.0-next.78

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

@@ -1,1352 +0,0 @@
-/*!
- * 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.76
- */
-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, n as normalizeLocale } from './index2.js';
-import { InsertTextMode, InsertTextFormat, CompletionItemKind, MarkupKind } from 'vscode-languageserver-types';
-import { Emitter, editor, Uri } from 'monaco-editor';
-import { getArcgisAssetPath as getAssetPath } from "./arcgis-assets.js";
-
-//#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
-
-async function d(t,i){try{let n=await t,e=new Map,o=new Map,a=[],r=D(i);return n.forEach(p=>{let c=[];p.items.forEach(s=>h(c,o,e,r,s)),c.length&&a.push({...p,items:c});}),{categories:a,functionDefinitions:e,constantDefinitions:o}}catch(n){return console.error(n),{categories:[],functionDefinitions:new Map,constantDefinitions:new Map}}}function D(t){let{profile:{apiVersion:i,bundles:n,hiddenApiItems:e=[]}={}}=t,o=y(i),a=Array.isArray(n)&&n.length>0?new Set(["core",...n]):void 0;return r=>M(o,r.sinceVersion)&&(!a||a.has(r.bundle))&&!e.includes(r.name)}function h(t,i,n,e,o){if(Array.isArray(o)){o.forEach(a=>A(t,n,e,a));return}o.type==="constant"?k(t,i,e,o):A(t,n,e,o);}function A(t,i,n,e){if(!n(e))return;e.disableDocumentation||t.push(e);let{completion:{label:o}}=e,a=o.toLowerCase(),r=i.get(a);r||(r={type:"functionDefinition",key:a,overloads:[]},i.set(a,r)),r.overloads.push(e);}function k(t,i,n,e){if(!n(e))return;t.push(e);let{completion:{label:o}}=e,a=o.toLowerCase();i.set(a,e);let[r,p]=e.completion.label.split(".");if(!p)return;let c=r.toLowerCase(),s=i.get(c);s||(s={type:"namespace",key:c,members:[],completion:{label:r,detail:r,insertText:r,insertTextMode:InsertTextMode.adjustIndentation,insertTextFormat:InsertTextFormat.PlainText,kind:CompletionItemKind.Enum}},i.set(c,s));let l=structuredClone(e);l.name=p,l.completion.label=p,l.completion.insertText=p,l.completion.kind=CompletionItemKind.Constant,s.members.push(l),s.completion.documentation=s.members.reduce((u,m)=>(u.value=`${u.value}${u.value?`
-
-`:""}**${m.completion.label}**: ${m.description}`,u),{kind:MarkupKind.Markdown,value:""});}function y(t){if(!t||typeof t!="string")return null;let i=t.split(".").map(o=>Number.parseInt(o));if(i.some(Number.isNaN))return console.error("Invalid API version string",t),null;let[n,e]=i.slice(0,2);return {major:n,minor:e}}function M(t,i){if(!t)return !0;let n=y(i);return n?t.major>n.major?!1:t.minor===void 0||n.minor===void 0?!0:n.minor<=t.minor:!0}
-
-// this file contains the building blocks for a language default provider
-const defaultContext = {
-    locale: "en",
-};
-class LanguageDefaultsBase {
-    // #endregion
-    constructor(languageId, _apiConfig) {
-        this.languageId = languageId;
-        this._apiConfig = _apiConfig;
-        // #region Protected properties
-        this._onDidChange = new Emitter();
-        this._modelToProfileMap = new Map();
-        this._modelToApiContextMap = new Map();
-        this._localeToApiLibraryPromiseMap = new Map();
-        this._onModelContextDidChange = new Emitter();
-        this._onDidModelContextChangeTimeout = -1;
-        /**
-         * The worker host is used by the worker to invoke methods on the main thread.
-         */
-        this.workerHost = {
-            getApiLibrary: async (locale) => await this.getApiLibrary(locale),
-        };
-        editor.onWillDisposeModel((model) => {
-            this.disposeForModel(model.uri);
-        });
-    }
-    // #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;
-    }
-    /**
-     * Dispose any cached resources for the model
-     */
-    disposeForModel(modelId) {
-        const key = this._getApiKey(modelId);
-        this._modelToProfileMap.delete(key);
-        if (this._modelToApiContextMap.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._modelToProfileMap.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._modelToApiContextMap.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._modelToApiContextMap.get(key) ?? {};
-        this._modelToApiContextMap.set(key, { ...currentApiContext, ...apiContext });
-        this._fireModelContextDidChange(key);
-    }
-    get onModelContextDidChange() {
-        return this._onModelContextDidChange.event;
-    }
-    /**
-     * Gets the API library for the given model id.
-     * @param modelId The model id for which to get the API library.
-     * @returns The API library for the model.
-     */
-    async getApiLibraryForModel(modelId) {
-        const apiContext = this.getApiContextForModel(modelId);
-        const apiLibraryPromise = this.getApiLibrary(apiContext.locale ?? "en");
-        return (await d(apiLibraryPromise, apiContext)).categories;
-    }
-    // #endregion
-    //#region Private methods
-    async fetchApiLibrary(locale) {
-        try {
-            const { apiPath, apiPrefix } = this._apiConfig;
-            const url = getAssetPath(`${apiPath}/${apiPrefix}${locale}.json`);
-            const response = await fetch(url);
-            if (response.ok) {
-                return await response.json();
-            }
-            return [];
-        }
-        catch {
-            return [];
-        }
-    }
-    async getApiLibrary(locale) {
-        const normalizedLocale = normalizeLocale(locale);
-        if (!this._localeToApiLibraryPromiseMap.has(normalizedLocale)) {
-            // Make this atomic to avoid multiple fetches
-            this._localeToApiLibraryPromiseMap.set(normalizedLocale, this.fetchApiLibrary(normalizedLocale));
-        }
-        return (await this._localeToApiLibraryPromiseMap.get(normalizedLocale)) ?? [];
-    }
-}
-
-export { EditorProfile as E, LanguageDefaultsBase as L, isFeatureSetCollectionDefinition as a, isFeatureSetDefinition as b, isFeatureDefinition as c, fieldsToProfileValues as f, isPredefinedProfile as i };