@arcgis/coding-components 4.29.0-beta.92 → 4.29.0-beta.94

package/dist/components/arcade-defaults.js

@@ -1,8 +1,13 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0-beta.94
+ */
 import { Emitter, Uri } from 'monaco-editor';
-import { CompletionItemKind, InsertTextMode, InsertTextFormat } from 'vscode-languageserver-types';
+import { InsertTextMode, InsertTextFormat, CompletionItemKind } from 'vscode-languageserver-types';
 import { i as importPortalPortalItem, a as importLayersFeatureLayer, b as importWebMap, s as supportedFields, n as newWebScene, c as importRequest, f as fieldTypeToIconName, d as fieldTypeToArcadeType } from './fields.js';
 import { p as portalItemPageUrl } from './utilities.js';
-import { V, X, G, D, E, N } from './index2.js';
+import { Z, e as ee, J, I, E, N } from './index2.js';
 import { getAssetPath } from '@stencil/core/internal/client';
 
 async function newPortalItem(definition) {
@@ -42,6 +47,13 @@ function isQueryableLayerInstance(item) {
         "queryFeatures" in item &&
         typeof item.queryFeatures === "function");
 }
+function isSubtypeSublayerInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        item.declaredClass === "esri.layers.support.SubtypeSublayer");
+}
 function isGroupLayerInstance(item) {
     return (!!item &&
         typeof item === "object" &&
@@ -68,6 +80,24 @@ function isFieldsDefinition(item) {
 function isUrlDefinition(item) {
     return (!!item && typeof item === "object" && "url" in item && typeof item.url === "string" && !("declaredClass" in item));
 }
+function isSubtypeInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        item.declaredClass === "esri.layers.support.Subtype");
+}
+function isCodedValueDomainInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        item.declaredClass === "esri.layers.support.CodedValueDomain");
+}
+function isInheritedDomainInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        item.declaredClass === "esri.layers.support.InheritedDomain");
+}
 function isPredefinedProfile(item) {
     return (!!item &&
         typeof item === "object" &&
@@ -78,29 +108,29 @@ function isPredefinedProfile(item) {
         !Array.isArray(item.definitions));
 }
 
-function resolveIntlPath(dictionary, path) {
-    if (!dictionary) {
-        return "";
-    }
-    const pathSegments = path.split(".");
-    let pathSegment = pathSegments.shift();
-    let entry = dictionary;
-    while (entry && pathSegment) {
-        // @ts-expect-error
-        entry = entry[pathSegment];
-        pathSegment = pathSegments.shift();
-    }
-    return typeof entry === "string" ? entry : path;
+function isTitleCapableSource(item) {
+    return !!item && typeof item === "object" && "title" in item && typeof item.title === "string";
+}
+function isUrlCapableSource(item) {
+    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
+}
+function isLayerIdCapableSource(item) {
+    return !!item && typeof item === "object" && "layerId" in item && typeof item.layerId === "number";
 }
-function isTypesCapabaleLayer(item) {
-    return !!item && typeof item === "object" && "typeIdField" in item;
+function isFeatureTypesCapableLayer(item) {
+    return !!item && typeof item === "object" && "typeIdField" in item && "types" in item;
 }
 function isDomainsCapableLayer(item) {
     return !!item && typeof item === "object" && "getFieldDomain" in item && typeof item.getFieldDomain === "function";
 }
+function isSubtypeFieldCapableLayer(item) {
+    return !!item && typeof item === "object" && "subtypeField" in item;
+}
+function isSubtypesCapableLayer(item) {
+    return isSubtypeFieldCapableLayer(item) && "subtypes" in item;
+}
 function isRelationshipsCapableLayer(item) {
-    return (!!item &&
-        typeof item === "object" &&
+    return (isLayerIdCapableSource(item) &&
         "relationships" in item &&
         "url" in item &&
         Array.isArray(item.relationships) &&
@@ -127,7 +157,23 @@ function sortFields(layer) {
         if (secondField.type === "oid") {
             return 1;
         }
-        if (isTypesCapabaleLayer(layer)) {
+        if (isSubtypeSublayerInstance(layer)) {
+            if (firstField.name === layer.parent.subtypeField) {
+                return -1;
+            }
+            if (secondField.name === layer.parent.subtypeField) {
+                return 1;
+            }
+        }
+        if (isSubtypeFieldCapableLayer(layer)) {
+            if (firstField.name === layer.subtypeField) {
+                return -1;
+            }
+            if (secondField.name === layer.subtypeField) {
+                return 1;
+            }
+        }
+        if (isFeatureTypesCapableLayer(layer)) {
             if (firstField.name === layer.typeIdField) {
                 return -1;
             }
@@ -138,20 +184,19 @@ function sortFields(layer) {
         return firstField.name.localeCompare(secondField.name, "en", { sensitivity: "base" });
     };
 }
-function getSubtypesProperties(profile, types, field) {
+function getTypeOrSubtypeDomainGroup(profile, types, field) {
     // Try the coded domain first
-    const group = getDomainValuesProperties(profile, field.domain, { code: "subtypes" });
-    if (group) {
-        return group;
-    }
-    // No coded domain for the subtypes, we will manufacture it
-    const values = types.map((t) => new ValueVariable({ profile, label: `${t.id}`, description: t.name, snippet: `"${t.id}"` }));
+    if (isCodedValueDomainInstance(field.domain)) {
+        return getCodedValueDomainGroup(profile, 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, label: `${label}`, description: t.name, snippet: `"${label}"` });
+    }) ?? [];
     return new GroupOfVariables(profile, { code: "subtypes" }, values);
 }
-function getDomainValuesProperties(profile, domain, label) {
-    if (!domain || domain.type !== "coded-value") {
-        return null;
-    }
+function getCodedValueDomainGroup(profile, domain, label) {
     const values = domain.codedValues.map((v) => new ValueVariable({
         profile,
         label: `${v.code}`,
@@ -161,29 +206,33 @@ function getDomainValuesProperties(profile, domain, label) {
     }));
     return new GroupOfVariables(profile, label, values);
 }
-function getDomainValuesBySubtypeGroup(profile, types, field) {
+function getDomainValuesGroup(profile, types, field) {
     const variables = [];
-    types.forEach((t) => {
-        let domain = t.domains[field.name];
+    if (!types || types.length === 0) {
+        return null;
+    }
+    types.forEach((type) => {
+        let domain = type.domains[field.name];
         if (!domain) {
             return;
         }
-        if (domain.type === "inherited") {
+        if (isInheritedDomainInstance(domain)) {
             domain = field.domain;
             return;
         }
-        const domainValuesGroup = getDomainValuesProperties(profile, domain, {
+        if (!isCodedValueDomainInstance(domain)) {
+            return;
+        }
+        const domainValuesGroup = getCodedValueDomainGroup(profile, domain, {
             code: "domainvaluesfortypeformat",
             formatValues: {
                 fieldName: field.alias ?? field.name,
-                typeName: t.name
+                typeName: type.name
             }
         });
-        if (!domainValuesGroup) {
-            return;
-        }
-        const label = `${t.id}`;
-        const snippet = `"${t.id}""`;
+        const id = isSubtypeInstance(type) ? type.code : type.id;
+        const label = `${id}`;
+        const snippet = `"${id}""`;
         const subtypeDictionary = new DictionaryVariable({ profile, label, snippet });
         subtypeDictionary.variables = [domainValuesGroup];
         variables.push(subtypeDictionary);
@@ -193,6 +242,9 @@ function getDomainValuesBySubtypeGroup(profile, types, field) {
     }
     return new GroupOfVariables(profile, { code: "domainvaluesbysubtypes" }, variables);
 }
+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) {
@@ -255,10 +307,7 @@ function filterFeatureLayerInfos(layers, queryCapability) {
 //#endregion
 //#region Functions to Editor Variables to a language service variables
 async function variablesToLSVariable(editorVariables, kind = CompletionItemKind.Variable) {
-    if (!editorVariables) {
-        return [];
-    }
-    const properties = await Promise.all(editorVariables.map(async (editorVariable) => {
+    return await Promise.all(editorVariables.map(async (editorVariable) => {
         switch (editorVariable.type) {
             case "dictionary":
                 return await dictionaryToLSDictionary(editorVariable, kind);
@@ -268,7 +317,6 @@ async function variablesToLSVariable(editorVariables, kind = CompletionItemKind.
                 return variableToLSVariable(editorVariable, kind);
         }
     }));
-    return properties.filter((p) => p);
 }
 function variableToLSVariable(editorVariable, kind) {
     const { name, type } = editorVariable;
@@ -386,7 +434,7 @@ async function dictionaryToLSDictionary(editorDictionary, kind) {
             previous += `  \n${description}`;
         }
         return previous;
-    }, description ?? "");
+    }, description);
     return {
         name,
         description,
@@ -427,9 +475,9 @@ class ProfileItemBase {
             // 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 G(this._label);
+            return J(this._label);
         }
-        return D(this._profile?.intlStrings[this._label.code], this._label.formatValues);
+        return I(this._profile?.intlStrings[this._label.code], this._label.formatValues);
     }
     /**
      * Returns the description string.
@@ -441,7 +489,7 @@ class ProfileItemBase {
         if (typeof this.description === "string") {
             return this.description;
         }
-        return D(this._profile?.intlStrings[this.description.code ?? ""], this.description.formatValues);
+        return I(this._profile?.intlStrings[this.description.code], this.description.formatValues);
     }
     /**
      * Returns true if the item pass the filter test
@@ -464,7 +512,7 @@ class VariableBase extends ProfileItemBase {
         super(props.profile, props.label, props.description ?? props.declaration?.description);
         this.declaration = props.declaration ?? {};
         this.name = props.declaration?.name ?? "";
-        this.snippet = props.snippet || "";
+        this.snippet = props.snippet ?? "";
         this.nonInteractive = props.nonInteractive ?? false;
         this.filterDescription = props.filterDescription ?? false;
         this.icon = props.icon;
@@ -482,7 +530,7 @@ class ValueVariable extends VariableBase {
     }
     getDescription() {
         if (this.description == null) {
-            return resolveIntlPath(this._profile?.intlStrings, this.type.toLowerCase()) ?? "";
+            return this._profile?.intlStrings[this.type.toLowerCase()] ?? "";
         }
         return super.getDescription();
     }
@@ -503,7 +551,7 @@ class ArrayVariable extends VariableBase {
     }
     getDescription() {
         if (this.description == null) {
-            return resolveIntlPath(this._profile?.intlStrings, this.type.toLowerCase()) ?? "";
+            return this._profile?.intlStrings[this.type.toLowerCase()] ?? "";
         }
         return super.getDescription();
     }
@@ -518,8 +566,8 @@ class ArrayVariable extends VariableBase {
  * collection is ready or not.
  */
 class CollectionBasedVariable extends VariableBase {
-    constructor(props) {
-        super(props);
+    constructor() {
+        super(...arguments);
         this.isCollection = true;
         this._loaded = true;
         /**
@@ -655,42 +703,53 @@ class SourceBasedVariable extends CollectionBasedVariable {
         this._definition = props.declaration?.definition;
     }
     get title() {
-        return this._source?.title ?? "";
+        return isTitleCapableSource(this._source) ? this._source.title : "";
     }
     get url() {
-        return this._definition?.url ?? "";
+        return isUrlCapableSource(this._source) ? this._source.url : "";
     }
     get informationUrl() {
         if (!this.loaded) {
             return null;
         }
-        const url = this._source?.url;
-        if (!url) {
+        if (!this.url) {
             return null;
         }
-        const layerId = this._source?.layerId ?? "";
-        return `${url}/${layerId}`;
+        return isLayerIdCapableSource(this._source) ? `${this.url}/${this._source.layerId}` : this.url;
     }
     get informationType() {
         return this._profile?.intlStrings.layer ?? "layer";
     }
     async loadSource() {
-        if (V(this._loadPromise) && X(this._loadPromise)) {
+        if (Z(this._loadPromise) && ee(this._loadPromise)) {
             return await this._loadPromise;
         }
         this._loadPromise = this._loadSource();
         return await this._loadPromise;
     }
+    _getValueSnippet(field) {
+        // If the source is a feature, then we want to assemble the snippet ($feature) with the field name as a member expression
+        return this.type === "feature" ? assembleMemberExpression(this.snippet, field.name) : field.name;
+    }
+    _getSubtypeOrDomainNameSnippet(field) {
+        if (this.type !== "feature") {
+            return null;
+        }
+        if (isSubtypeFieldCapableLayer(this._source) && field.name === this._source.subtypeField) {
+            return `SubtypeName(${this.snippet})`;
+        }
+        return `DomainName(${this.snippet}, "${field.name}")`;
+    }
     _getFieldProperty(field) {
         // Check if the field is the type id field or of the field has a coded domain.
         // If it has then the property will be an exanpdable property (dictionary).
         // Otherwise just return a simple value property.
-        const subtypesOrDomainValuesDictionary = this._getSubtypesOrDomainValuesDictionary(field);
+        const subtypesOrDomainValuesDictionary = this._getDomainDictionary(field);
         if (subtypesOrDomainValuesDictionary) {
             return subtypesOrDomainValuesDictionary;
         }
         // Create the value property
-        const valueSnippet = this.type === "feature" ? assembleMemberExpression(this.snippet, field.name) : field.name;
+        const valueSnippet = this._getValueSnippet(field);
         return new ValueVariable({
             profile: this._profile,
             label: valueSnippet,
@@ -700,12 +759,107 @@ class SourceBasedVariable extends CollectionBasedVariable {
             filterDescription: true
         });
     }
-    _getSubtypesOrDomainValuesDictionary(field) {
+    _getDomainDictionary(field) {
         if (!isDomainsCapableLayer(this._source)) {
             return null;
         }
-        // Create the domain dictionary, we may not use it
-        const valueSnippet = this.type === "feature" ? assembleMemberExpression(this.snippet, field.name) : field.name;
+        // Note we have multiple scenarios:
+        // - Layers without subtypes or feature types: We will check if the field has a domain
+        // - Layers with only subtypes: We will parse the subtypes metadata and create a dictionary
+        // - Layers with only feature types: We will parse the feature types metadata
+        // - Layers with both subtypes and feature types: we will actually use the subtypes metadata
+        // Summary, we will always use the subtypes metadata if available.
+        if (isSubtypeFieldCapableLayer(this._source) && !!this._source.subtypeField) {
+            return this._getSubtypeDomainDictionary(field);
+        }
+        if (isFeatureTypesCapableLayer(this._source) && !!this._source.typeIdField) {
+            return this._getFeatureTypeDomainDictionary(field);
+        }
+        return this._getFieldDomainDictionary(field);
+    }
+    _getSubtypeDomainDictionary(field) {
+        // Should be tested before calling this function
+        if (!isSubtypeFieldCapableLayer(this._source)) {
+            return null;
+        }
+        // If the source has a subtype field but doesn't have subtypes, it is certainly a subtype sublayer
+        if (!isSubtypesCapableLayer(this._source)) {
+            // For the subtype field there is no domain
+            if (field.name === this._source.subtypeField) {
+                return null;
+            }
+            // For the other fields, we will use the getFieldDomain function
+            return this._getFieldDomainDictionary(field);
+        }
+        // The code here shoud be executed for layers that have subtypes
+        // Sepcial case for the subtype field
+        if (field.name === this._source.subtypeField) {
+            const domainDictionary = this._createDomainDictionary(field);
+            domainDictionary.variables.push(getTypeOrSubtypeDomainGroup(this._profile, 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 = getDomainValuesGroup(this._profile, 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(getTypeOrSubtypeDomainGroup(this._profile, 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 = getDomainValuesGroup(this._profile, 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 = getCodedValueDomainGroup(this._profile, fieldDomain, {
+            code: "domainvalues"
+        });
+        const domainDictionary = this._createDomainDictionary(field);
+        domainDictionary.variables.push(domainValuesGroup);
+        return domainDictionary;
+    }
+    _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 domainDictionary = new DictionaryVariable({
             profile: this._profile,
             label: valueSnippet,
@@ -723,45 +877,16 @@ class SourceBasedVariable extends CollectionBasedVariable {
             })
         ]);
         domainDictionary.variables = [headerGroup];
-        // If it is the subtype field then get its coded domain values
-        if (isTypesCapabaleLayer(this._source) && field.name === this._source.typeIdField) {
-            const subtypesGroup = getSubtypesProperties(this._profile, this._source.types, field);
-            domainDictionary.variables.push(subtypesGroup);
-            return domainDictionary;
-        }
-        // Since its' not the subtype field then add the snippet for the domain name
-        if (this.type === "feature") {
-            const domainNameSnippet = `DomainName(${this.snippet}, "${field.name}")`;
+        // Add the SubtypeName or DomainName snippet if available
+        const subtypeOrDomainNameSnippet = this._getSubtypeOrDomainNameSnippet(field);
+        if (subtypeOrDomainNameSnippet) {
             headerGroup.variables.push(new ValueVariable({
                 profile: this._profile,
-                label: domainNameSnippet,
+                label: subtypeOrDomainNameSnippet,
                 description: "",
-                snippet: domainNameSnippet
+                snippet: subtypeOrDomainNameSnippet
             }));
         }
-        if (isTypesCapabaleLayer(this._source)) {
-            // Check if all the domains for the field in the types are inherited.
-            // If it is we can simplify the structure by avoiding splitting in subtypes
-            const allInherited = this._source.types.every((t) => t.domains[field.name].type === "inherited");
-            if (!allInherited) {
-                // We have domains per subtype
-                // We need to go thru each types and create a dictionary.
-                const domainValuesBySubtypeGroup = getDomainValuesBySubtypeGroup(this._profile, this._source.types, field);
-                if (!domainValuesBySubtypeGroup) {
-                    return null;
-                }
-                domainDictionary.variables.push(domainValuesBySubtypeGroup);
-                return domainDictionary;
-            }
-        }
-        // Either we have types but all the domains are inherited or we don't have types
-        const domainValuesGroup = getDomainValuesProperties(this._profile, this._source.getFieldDomain(field.name), {
-            code: "domainvalues"
-        });
-        if (!domainValuesGroup) {
-            return null;
-        }
-        domainDictionary.variables.push(domainValuesGroup);
         return domainDictionary;
     }
     async _getRelationshipsProperty() {
@@ -792,7 +917,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
                 nonInteractive: true
             }, [new ValueVariable({ profile: this._profile, label: snippet, description: "", snippet })], { exposeRelationships: true, sourceTableId: source.layerId });
         }));
-        relationshipsGroup.variables = relationshipItems.filter(V);
+        relationshipsGroup.variables = relationshipItems.filter(Z);
         if (!relationshipsGroup.variables.length) {
             return null;
         }
@@ -950,7 +1075,7 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         return this._profile?.intlStrings.featureservice ?? "featureservice";
     }
     async loadSource() {
-        if (V(this._loadPromise) && X(this._loadPromise)) {
+        if (Z(this._loadPromise) && ee(this._loadPromise)) {
             return await this._loadPromise;
         }
         this._loadPromise = this._loadSource();
@@ -971,7 +1096,7 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
                 : {
                     code: "webmapformat",
                     formatValues: {
-                        webMapTitle: this._featureSetCollections.source.portalItem.title ?? "Untitled map"
+                        webMapTitle: this._featureSetCollections.source.portalItem.title || "Untitled map"
                     }
                 };
             const headerGroup = new GroupOfVariables(this._profile, groupLabel, [
@@ -1048,22 +1173,25 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         }
     }
     async _featureSetCollectionFromUrl(url) {
-        url = url.replace(/\/featureserver\/[0-9]*/iu, "/FeatureServer");
-        url = url.replace(/\/mapserver\/[0-9]*/iu, "/MapServer");
-        url = url.split("?")[0];
-        const metadata = await serviceMetaData(url);
+        let processedUrl = url.replace(/\/featureserver\/[0-9]*/iu, "/FeatureServer");
+        processedUrl = processedUrl.replace(/\/mapserver\/[0-9]*/iu, "/MapServer");
+        processedUrl = processedUrl.split("?")[0];
+        if (!processedUrl) {
+            return null;
+        }
+        const metadata = await serviceMetaData(processedUrl);
         const layersPromise = Promise.all(metadata.layers.map(async (layerInfo) => {
-            const featureLayer = await newFeatureLayer({ url: `${url}/${layerInfo.id}` });
+            const featureLayer = await newFeatureLayer({ url: `${processedUrl}/${layerInfo.id}` });
             await featureLayer.load();
             return this._createFeatureSetVariable(featureLayer);
         }));
         const tablesPromise = Promise.all(metadata.tables.map(async (layerInfo) => {
-            const table = await newFeatureLayer({ url: `${url}/${layerInfo.id}` });
+            const table = await newFeatureLayer({ url: `${processedUrl}/${layerInfo.id}` });
             await table.load();
             return this._createFeatureSetVariable(table);
         }));
         const [layers, tables] = await Promise.all([layersPromise, tablesPromise]);
-        return { layers, tables, source: url };
+        return { layers, tables, source: processedUrl };
     }
     _convertWebMapLayersToVariables(layers, filteringTables = false) {
         const layerVariables = [];
@@ -1198,7 +1326,7 @@ async function getSdkPredefinedProfiles(locale = "en") {
     try {
         const response = await fetch(getAssetPath(`./assets/arcade-language/profiles/arcade-profiles.t9n.${locale}.json`));
         if (response.ok) {
-            return cacheSdkPredefinedProfiles(locale, await response.json());
+            return cacheSdkPredefinedProfiles(locale, (await response.json()));
         }
         if (locale === "en") {
             return null;
@@ -1226,13 +1354,10 @@ async function getSdkPredefinedProfile(id, locale = "en") {
     const profiles = await getSdkPredefinedProfiles(locale);
     return profiles?.get(id) ?? null;
 }
-function isExtendedPredefinedProfileDefinition(predefinedProfileDefinition) {
-    return Array.isArray(predefinedProfileDefinition?.additionalVariables);
+function isExtendedPredefinedProfileDefinition(item) {
+    return !!item && typeof item === "object" && "additionalVariables" in item && Array.isArray(item.additionalVariables);
 }
 function convertApiVariables(variables) {
-    if (!variables) {
-        return [];
-    }
     return variables.map(convertApiVariable);
 }
 function convertApiVariable(variable) {