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

package/dist/components/markdown.js

@@ -1,7 +1,7 @@
 /*!
  * 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.2
+ * v4.31.0-next.21
  */
 import { editor } from 'monaco-editor';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';

package/dist/components/sql-expr-defaults.js

@@ -0,0 +1,196 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
+ * v4.31.0-next.21
+ */
+import { f as fieldsToProfileValues, i as isPredefinedProfile, b as isFeatureSetDefinition, L as LanguageDefaultsBase, E as EditorProfile } from './language-defaults-base.js';
+import { InsertTextMode, InsertTextFormat, CompletionItemKind } from 'vscode-languageserver-types';
+import { f as fetchT9nStringsBundle } from './index2.js';
+import { Uri } from 'monaco-editor';
+import { getArcgisAssetPath as getAssetPath } from "./arcgis-assets.js";
+
+// #region convert editor profile to apiProfile
+/**
+ * Converts an editor profile to an api profile.
+ * The api profile is an optimized version of the editor profile designed for minimal data transfer between the main thread and the worker.
+ */
+const sqlExprEditorToApiProfile = (editorProfile) => {
+    const { apiVersion, bundles, hiddenApiItems } = editorProfile.toEditorProfileDefinition();
+    const variable = editorProfile.variables[0];
+    if (!variable || !(variable.type === "featureSet")) {
+        throw Error("No variable found in the editor profile");
+    }
+    const hydratedVariable = variableToApiProfile(variable);
+    return {
+        apiVersion,
+        bundles,
+        variables: [hydratedVariable],
+        hiddenApiItems: hiddenApiItems?.map((s) => s.toLowerCase()),
+    };
+};
+function variableToApiProfile(variable) {
+    const { name } = variable;
+    const description = variable.getDescription();
+    const { definition } = variable.toProfileVariableDefinition();
+    const resultCompletion = {
+        label: name,
+        detail: name,
+        insertText: name,
+        insertTextMode: InsertTextMode.asIs,
+        insertTextFormat: InsertTextFormat.PlainText,
+        kind: CompletionItemKind.Field,
+    };
+    const result = {
+        name,
+        description,
+        type: "dictionary",
+        properties: [],
+        completion: resultCompletion,
+    };
+    // No fields or definition, then it will be a feature without any known fields
+    if (!definition || !("fields" in definition)) {
+        return result;
+    }
+    // Create properties for the fields
+    // Also improve the feature completion documentation
+    // TODO: should we add aliases to completion? what about domains?
+    const [properties, featureCompletionDescription] = fieldsToProfileValues(definition.fields, description);
+    result.properties = properties;
+    resultCompletion.documentation = { kind: "markdown", value: featureCompletionDescription };
+    return result;
+}
+const tempHardcodedProfile = {
+    en: {
+        id: "field-calculation",
+        variables: [
+            {
+                name: "$layer",
+                type: "featureSet",
+                description: "The layer being calculated.",
+            },
+        ],
+    },
+};
+async function getSdkPredefinedProfile(locale = "en") {
+    return await Promise.resolve(tempHardcodedProfile[locale]);
+}
+async function convertToEditorProfileDefinition(predefinedProfile, locale = "en") {
+    if (!isPredefinedProfile(predefinedProfile)) {
+        return undefined;
+    }
+    const sdkPredefinedProfile = await getSdkPredefinedProfile(locale);
+    if (!sdkPredefinedProfile) {
+        return undefined;
+    }
+    //
+    const editorProfile = {
+        variables: [],
+        hiddenApiItems: predefinedProfile.hiddenApiItems?.map((s) => s.toLowerCase()),
+    };
+    // Merge the SDK variables' definitions/properties with the predefined profile definitions.
+    sdkPredefinedProfile.variables.forEach((sdkVariable) => {
+        // Don't include disabled variables
+        if (predefinedProfile.disabledVariables?.includes(sdkVariable.name)) {
+            return;
+        }
+        // Try to get a definition from the predefined profile.
+        const definition = predefinedProfile.definitions[sdkVariable.name];
+        switch (sdkVariable.type) {
+            case "featureSet":
+                if (isFeatureSetDefinition(definition)) {
+                    return editorProfile.variables.push({ ...sdkVariable, type: sdkVariable.type, definition });
+                }
+                return;
+            default:
+                throw Error(`sdkVariable type not supported (yet) type: ${sdkVariable.type}`);
+        }
+    });
+    return editorProfile;
+}
+// #endregion
+// #region profile utils
+/**
+ * util to retrieve fields from the $layer variable in the api context.
+ */
+const getFieldsFromLayerVariable = (profile) => {
+    if (profile.variables) {
+        const layerVar = profile.variables.find((variable) => variable.name === "$layer" && variable.type === "dictionary");
+        return layerVar.properties ?? [];
+    }
+    return [];
+};
+// #endregion
+
+/**
+ * Returns the sql-expression worker for the model.
+ * Example:
+ * ```ts
+ * const sqlExpressionWorker = await getSqlExpressionWorker(model.uri);
+ * ```
+ * @returns sql-expression worker
+ */
+async function getSqlExprWorker(uri) {
+    const mode = await getMode();
+    return await mode.getSqlExprWorker(uri);
+}
+/**
+ * Request the sql-expression mode
+ * @returns sql-expression mode module
+ */
+async function getMode() {
+    return await import('./sql-expr-mode.js');
+}
+
+const languageId = "arcgis-sql-expression";
+class SqlExprDefaults extends LanguageDefaultsBase {
+    constructor() {
+        super(...arguments);
+        this._languageId = languageId;
+        this._languageOptions = {};
+        this._layerMap = new Map();
+    }
+    // TODO: try to rely on editor profile instance instead of storing a feature layer
+    updateFeatureLayerForModel(modelId, layer) {
+        const key = this._getApiKey(modelId);
+        this._layerMap.set(key, layer);
+    }
+    setLanguageOptions(languageOptions) {
+        this._languageOptions = languageOptions;
+    }
+    getFeatureLayerForModel(modelId) {
+        const key = this._getApiKey(modelId);
+        return this._layerMap.get(key);
+    }
+    async setProfileForModel(modelId, definition, apiContext = { locale: "en" }) {
+        // for now, it can ONLY be a predefined profile
+        if (isPredefinedProfile(definition)) {
+            definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
+        }
+        // FIXME: using arcades intlStrings for now...
+        const intlStrings = await fetchT9nStringsBundle(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
+        if (!intlStrings) {
+            throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
+        }
+        this.disposeForModel(modelId);
+        const key = this._getApiKey(modelId);
+        const editorProfile = new EditorProfile(definition, intlStrings);
+        this._profileMap.set(key, editorProfile);
+        const apiProfile = sqlExprEditorToApiProfile(editorProfile);
+        this.updateApiContextForModel(modelId, {
+            locale: apiContext.locale,
+            profile: apiProfile,
+        });
+        const layer = definition?.variables?.find((variable) => variable.name === "$layer");
+        if (layer) {
+            this.updateFeatureLayerForModel(modelId, layer.definition);
+        }
+    }
+    async getApiLibrary(modelId) {
+        const uri = Uri.parse(modelId);
+        const worker = await getSqlExprWorker(uri);
+        return await worker.getApiLibrary(this.getApiContextForModel(uri));
+    }
+}
+const sqlExprDefaults = new SqlExprDefaults();
+
+export { getFieldsFromLayerVariable as a, getMode as g, sqlExprDefaults as s };