@arcgis/coding-components 4.29.0-beta.99 → 4.29.0

package/dist/components/arcade-defaults.js

@@ -1,28 +1,23 @@
 /*!
  * 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.99
+ * v4.29.0
  */
 import { Emitter, Uri } from 'monaco-editor';
 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 { i as importLayersFeatureLayer, a as importRequest, s as supportedFields, n as newPortalPortalItem, b as newWebScene, c as newWebMap, f as fieldAlias, d as fieldTypeToIconName, e as fieldTypeToArcadeType } from './fields.js';
 import { p as portalItemPageUrl } from './utilities.js';
-import { Y, e as ee, Z, K, E, N } from './index2.js';
+import { e as ee, t as te, G, Z, E, v } from './index2.js';
 import { getAssetPath } from '@stencil/core/internal/client';
 
-async function newPortalItem(definition) {
-    const PortalItem = await importPortalPortalItem();
-    return new PortalItem(definition);
-}
+//#region core adapter fix
 async function newFeatureLayer(definition) {
     const FeatureLayer = await importLayersFeatureLayer();
     // Fix title for the layer. Instead of defaulting to the map viewer style.
     return new FeatureLayer({ ...definition, sublayerTitleMode: "service-name" });
 }
-async function newWebMap(definition) {
-    const WebMap = await importWebMap();
-    return new WebMap(definition);
-}
+//#endregion
+//#region Type Guards
 function isSupportedLayerInstance(item) {
     return (!!item &&
         typeof item === "object" &&
@@ -107,7 +102,6 @@ function isPredefinedProfile(item) {
         typeof item.definitions === "object" &&
         !Array.isArray(item.definitions));
 }
-
 function isTitleCapableSource(item) {
     return !!item && typeof item === "object" && "title" in item && typeof item.title === "string";
 }
@@ -143,7 +137,54 @@ function isLoadableSource(item) {
     return !!item && typeof item === "object" && "load" in item && typeof item.load === "function";
 }
 //#endregion
-//#region Support Functions
+//#region Service Metadata
+async function supportedSourceFromDefinition(definition) {
+    if (!definition) {
+        return null;
+    }
+    let source = null;
+    if (isSupportedLayerInstance(definition) || isFeatureSetInstance(definition) || isFieldsDefinition(definition)) {
+        source = definition;
+    }
+    else {
+        source = await newFeatureLayer(definition);
+    }
+    if (isLoadableSource(source)) {
+        await source.load();
+    }
+    return source;
+}
+async function serviceMetaData(url) {
+    url += "/layers";
+    const request = await importRequest();
+    const response = await request(url, { responseType: "json", query: { f: "json" } });
+    const data = {
+        layers: response.data?.layers ?? [],
+        tables: response.data?.tables ?? []
+    };
+    const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
+    const layers = filterFeatureLayerInfos(data.layers, queryCapability);
+    const tables = filterFeatureLayerInfos(data.tables, queryCapability);
+    return { layers, tables };
+}
+function filterFeatureLayerInfos(layers, queryCapability) {
+    return layers.filter((layer) => {
+        if (layer.type !== "Feature Layer" && layer.type !== "Table") {
+            return false;
+        }
+        const capabilities = layer.capabilities
+            ? layer.capabilities
+                .toLowerCase()
+                .split(",")
+                .map((value) => value.trim())
+            : [];
+        return capabilities.includes(queryCapability);
+    });
+}
+//#endregion
+
+//#endregion
+//#region Support functions
 async function getRelatedFeatureLayer(layer, relationship) {
     const relatedFeatureLayer = await newFeatureLayer({ url: `${layer.url}/${relationship.relatedTableId}` });
     await relatedFeatureLayer.load();
@@ -184,66 +225,8 @@ function sortFields(layer) {
         return firstField.name.localeCompare(secondField.name, "en", { sensitivity: "base" });
     };
 }
-function getTypeOrSubtypeDomainGroup(profile, types, field) {
-    // Try the coded domain first
-    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 getCodedValueDomainGroup(profile, domain, label) {
-    const values = domain.codedValues.map((v) => new ValueVariable({
-        profile,
-        label: `${v.code}`,
-        description: v.name,
-        snippet: `"${v.code}"`,
-        filterDescription: true
-    }));
-    return new GroupOfVariables(profile, label, values);
-}
-function getDomainValuesGroup(profile, 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 domainValuesGroup = getCodedValueDomainGroup(profile, domain, {
-            code: "domainvaluesfortypeformat",
-            formatValues: {
-                fieldName: field.alias ?? field.name,
-                typeName: type.name
-            }
-        });
-        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);
-    });
-    if (!variables.length) {
-        return null;
-    }
-    return new GroupOfVariables(profile, { code: "domainvaluesbysubtypes" }, variables);
-}
 function areAllDomainsInherited(types, field) {
-    return types?.every((type) => type.domains[field.name]?.type === "inherited") ?? false;
+    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;
@@ -260,52 +243,7 @@ function assembleMemberExpression(obj, prop) {
     return `${obj}${getMemberExpressionProperty(prop)}`;
 }
 //#endregion
-//#region Sources
-async function supportedSourceFromDefinition(definition) {
-    if (!definition) {
-        return null;
-    }
-    let source = null;
-    if (isSupportedLayerInstance(definition) || isFeatureSetInstance(definition) || isFieldsDefinition(definition)) {
-        source = definition;
-    }
-    else {
-        source = await newFeatureLayer(definition);
-    }
-    if (isLoadableSource(source)) {
-        await source.load();
-    }
-    return source;
-}
-async function serviceMetaData(url) {
-    url += "/layers";
-    const request = await importRequest();
-    const response = await request(url, { responseType: "json", query: { f: "json" } });
-    const data = {
-        layers: response.data?.layers ?? [],
-        tables: response.data?.tables ?? []
-    };
-    const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
-    const layers = filterFeatureLayerInfos(data.layers, queryCapability);
-    const tables = filterFeatureLayerInfos(data.tables, queryCapability);
-    return { layers, tables };
-}
-function filterFeatureLayerInfos(layers, queryCapability) {
-    return layers.filter((layer) => {
-        if (layer.type !== "Feature Layer" && layer.type !== "Table") {
-            return false;
-        }
-        const capabilities = layer.capabilities
-            ? layer.capabilities
-                .toLowerCase()
-                .split(",")
-                .map((value) => value.trim())
-            : [];
-        return capabilities.includes(queryCapability);
-    });
-}
-//#endregion
-//#region Functions to Editor Variables to a language service variables
+//#region Editor Profile to Language Service Profile functions
 async function variablesToLSVariable(editorVariables, kind = CompletionItemKind.Variable) {
     return await Promise.all(editorVariables.map(async (editorVariable) => {
         switch (editorVariable.type) {
@@ -373,20 +311,21 @@ async function featureToLSFeature(editorFeature, kind) {
         if (featureCompletionDescription) {
             featureCompletionDescription += "  \n  \n";
         }
-        featureCompletionDescription += `**${field.name}** (${field.alias ?? field.name})  \n${field.type}`;
+        featureCompletionDescription += `**${field.name}** (${fieldAlias(field)})  \n${field.type}`;
         if (field.description) {
             featureCompletionDescription += `  \n'${field.description}`;
         }
         // The property for the field
         const type = fieldTypeToArcadeType(field);
         const insertText = getMemberExpressionProperty(field.name, false);
+        const description = fieldAlias(field);
         fieldProfileValues.push({
             name: field.name,
-            description: field.alias || field.name,
+            description,
             type,
             completion: {
                 label: field.name,
-                detail: field.alias || field.name,
+                detail: description,
                 insertText,
                 insertTextMode: InsertTextMode.asIs,
                 insertTextFormat: InsertTextFormat.PlainText,
@@ -475,9 +414,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 Z(this._label);
+            return G(this._label);
         }
-        return K(this._profile?.intlStrings[this._label.code], this._label.formatValues);
+        return Z(this._profile?.intlStrings[this._label.code], this._label.formatValues);
     }
     /**
      * Returns the description string.
@@ -489,7 +428,7 @@ class ProfileItemBase {
         if (typeof this.description === "string") {
             return this.description;
         }
-        return K(this._profile?.intlStrings[this.description.code], this.description.formatValues);
+        return Z(this._profile?.intlStrings[this.description.code], this.description.formatValues);
     }
     /**
      * Returns true if the item pass the filter test
@@ -566,8 +505,9 @@ class ArrayVariable extends VariableBase {
  * collection is ready or not.
  */
 class CollectionBasedVariable extends VariableBase {
-    constructor() {
-        super(...arguments);
+    constructor(owner, props) {
+        super(props);
+        this.owner = owner;
         this.isCollection = true;
         this._loaded = true;
         /**
@@ -577,19 +517,21 @@ class CollectionBasedVariable extends VariableBase {
          */
         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;
     }
-    /**
-     * Loads the items if the collection is asynchronous.
-     * If the colleciton is synchronous then the function is a no-op.
-     */
-    async loadSource() {
-        return;
-    }
     /**
      * Returns an url to the associated information
      */
@@ -612,8 +554,8 @@ class GroupOfVariables extends ProfileItemBase {
     }
 }
 class DictionaryVariable extends CollectionBasedVariable {
-    constructor(props) {
-        super(props);
+    constructor(owner, props) {
+        super(owner, props);
         this.type = "dictionary";
         /**
          * The variables that the dictionary holds. It is different than the variables.
@@ -627,6 +569,9 @@ class DictionaryVariable extends CollectionBasedVariable {
             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;
@@ -651,23 +596,26 @@ class DictionaryVariable extends CollectionBasedVariable {
             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({ profile: this._profile, declaration, label: snippet, snippet });
+                return new FeatureVariable(this, { profile: this._profile, declaration, label: snippet, snippet });
             case "featureSet":
-                return new FeatureSetVariable({ profile: this._profile, declaration, label: snippet, snippet }, [
+                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({
+                return new FeatureSetCollectionVariable(this, {
                     profile: this._profile,
                     declaration,
                     label: snippet,
                     snippet
                 });
             case "dictionary":
-                return new DictionaryVariable({
+                return new DictionaryVariable(this, {
                     profile: this._profile,
                     declaration,
                     label: snippet,
@@ -681,7 +629,7 @@ class DictionaryVariable extends CollectionBasedVariable {
                     snippet
                 });
             default:
-                console.error("Invalid profile variable", declaration);
+                console.error("Editor profile: Invalid profile variable", declaration);
                 return null;
         }
     }
@@ -695,8 +643,8 @@ class DictionaryVariable extends CollectionBasedVariable {
     }
 }
 class SourceBasedVariable extends CollectionBasedVariable {
-    constructor(props, relationshipsProperties) {
-        super(props);
+    constructor(owner, props, relationshipsProperties) {
+        super(owner, props);
         this.relationshipsProperties = relationshipsProperties;
         this._source = null;
         this._loaded = false;
@@ -721,7 +669,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         return this._profile?.intlStrings.layer ?? "layer";
     }
     async loadSource() {
-        if (Y(this._loadPromise) && ee(this._loadPromise)) {
+        if (ee(this._loadPromise) && te(this._loadPromise)) {
             return await this._loadPromise;
         }
         this._loadPromise = this._loadSource();
@@ -753,7 +701,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         return new ValueVariable({
             profile: this._profile,
             label: valueSnippet,
-            description: field.alias ?? field.name,
+            description: fieldAlias(field),
             snippet: valueSnippet,
             icon: fieldTypeToIconName(field),
             filterDescription: true
@@ -795,7 +743,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         // 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));
+            domainDictionary.variables.push(this._getTypeOrSubtypeDomainGroup(this._source.subtypes, field));
             return domainDictionary;
         }
         // Check if all the domains for the field in the types are inherited.
@@ -805,7 +753,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         }
         // 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);
+        const domainValuesBySubtypeGroup = this._getDomainValuesGroup(this._source.subtypes, field);
         if (!domainValuesBySubtypeGroup) {
             return null;
         }
@@ -821,7 +769,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         // 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));
+            domainDictionary.variables.push(this._getTypeOrSubtypeDomainGroup(this._source.types, field));
             return domainDictionary;
         }
         // Check if all the domains for the field in the types are inherited.
@@ -831,7 +779,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         }
         // 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);
+        const domainValuesByFeatureTypeGroup = this._getDomainValuesGroup(this._source.types, field);
         if (!domainValuesByFeatureTypeGroup) {
             return null;
         }
@@ -848,27 +796,99 @@ class SourceBasedVariable extends CollectionBasedVariable {
         if (!isCodedValueDomainInstance(fieldDomain)) {
             return null;
         }
-        const domainValuesGroup = getCodedValueDomainGroup(this._profile, fieldDomain, {
+        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 domainDictionary = new DictionaryVariable({
+        const alias = fieldAlias(field);
+        const domainDictionary = new DictionaryVariable(this, {
             profile: this._profile,
             label: valueSnippet,
-            description: field.alias ?? field.name,
+            description: alias,
             snippet: valueSnippet,
-            icon: "form-dropdown"
+            icon: "form-dropdown",
+            declaration: { name: field.name }
         });
         // Add the header group
-        const headerGroup = new GroupOfVariables(this._profile, field.alias ?? field.name, [
+        const headerGroup = new GroupOfVariables(this._profile, alias, [
             new ValueVariable({
                 profile: this._profile,
                 label: valueSnippet,
@@ -909,7 +929,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
                 return null;
             }
             const snippet = `FeatureSetByRelationshipName(${this.snippet}, "${relationship.name}")`;
-            return new FeatureSetVariable({
+            return new FeatureSetVariable(this, {
                 profile: this._profile,
                 declaration: { definition: relatedLayer },
                 label: relatedLayer.title,
@@ -917,7 +937,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(Y);
+        relationshipsGroup.variables = relationshipItems.filter(ee);
         if (!relationshipsGroup.variables.length) {
             return null;
         }
@@ -925,8 +945,8 @@ class SourceBasedVariable extends CollectionBasedVariable {
     }
 }
 class FeatureVariable extends SourceBasedVariable {
-    constructor(props) {
-        super(props, { exposeRelationships: true });
+    constructor(owner, props) {
+        super(owner, props, { exposeRelationships: true });
         this.type = "feature";
     }
     get title() {
@@ -994,11 +1014,11 @@ class FeatureVariable extends SourceBasedVariable {
     }
 }
 class FeatureSetVariable extends SourceBasedVariable {
-    constructor(props, featureSetSnippets = [], 
+    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(props, relationshipProps);
+        super(owner, props, relationshipProps);
         this.featureSetSnippets = featureSetSnippets;
         this.type = "featureSet";
     }
@@ -1045,8 +1065,8 @@ class FeatureSetVariable extends SourceBasedVariable {
     }
 }
 class FeatureSetCollectionVariable extends CollectionBasedVariable {
-    constructor(props) {
-        super(props);
+    constructor(owner, props) {
+        super(owner, props);
         this.type = "featureSetCollection";
         this._featureSetCollections = null;
         this._loaded = false;
@@ -1075,7 +1095,7 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         return this._profile?.intlStrings.featureservice ?? "featureservice";
     }
     async loadSource() {
-        if (Y(this._loadPromise) && ee(this._loadPromise)) {
+        if (ee(this._loadPromise) && te(this._loadPromise)) {
             return await this._loadPromise;
         }
         this._loadPromise = this._loadSource();
@@ -1096,7 +1116,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, [
@@ -1154,7 +1174,7 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         };
     }
     async _featureSetCollectionFromPortalItem(definition) {
-        const portalItem = await newPortalItem(definition);
+        const portalItem = await newPortalPortalItem(definition);
         await portalItem.load();
         switch (portalItem.type) {
             case "Web Map": {
@@ -1213,9 +1233,9 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         return layerVariables;
     }
     _createFeatureSetVariable(featureLayer, isFromWebMap = false) {
-        return new FeatureSetVariable({
+        return new FeatureSetVariable(this, {
             profile: this._profile,
-            declaration: { definition: featureLayer },
+            declaration: { name: featureLayer.title, definition: featureLayer },
             label: featureLayer.title,
             description: "",
             nonInteractive: true
@@ -1253,7 +1273,7 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
 class EditorProfile extends DictionaryVariable {
     constructor(definition, intlStrings, locale = "en") {
         // Delay the load of the variable declarations so we have a `this`
-        super({
+        super(undefined, {
             profile: null,
             declaration: { properties: [] }
         });
@@ -1491,7 +1511,7 @@ class ArcadeLanguageServiceDefaults {
         if (isPredefinedProfile(definition)) {
             definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
         }
-        const intlStrings = await N(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
+        const intlStrings = await v(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
         if (!intlStrings) {
             throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
         }