@arcgis/coding-components 4.29.0-beta.11 → 4.29.0-beta.111

package/dist/components/arcade-contribution.js

@@ -1,60 +1,65 @@
+/*!
+ * 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.111
+ */
 import { languages } from 'monaco-editor';
 import { b as arcadeDefaults } from './arcade-defaults.js';
-import { c as importRequest } from './fields.js';
-import { D, V } from './index2.js';
+import { a as importRequest } from './fields.js';
+import { s as se, o as oe } from './index2.js';
 
 function isMonacoEnvironmentSetup() {
-  return !!self.MonacoEnvironment?.getWorkerUrl;
+    return !!globalThis.MonacoEnvironment?.getWorkerUrl;
 }
 const additionalLanguageWorkersMap = new Map();
 function getAssetsPath() {
-  return self.MonacoEnvironment?.assetsPath;
+    return globalThis.MonacoEnvironment?.assetsPath;
 }
 function setupMonacoEnvironment(assetsPath) {
-  //
-  // Check if the worker loading logic has already been defined.
-  if (isMonacoEnvironmentSetup()) {
-    return;
-  }
-  // Since we are using workers, monaco needs to find them.
-  // Using the global MonacoEnvironment.
-  self.MonacoEnvironment = {
-    assetsPath,
-    getWorker: async (_, languageId) => {
-      // Manufacture the url for the web worker
-      let url = additionalLanguageWorkersMap.get(languageId) ?? `${assetsPath}/code-editor/editor.worker.js`;
-      switch (languageId) {
-        case "json":
-          url = `${assetsPath}/code-editor/json.worker.js`;
-          break;
-        case "css":
-          url = `${assetsPath}/code-editor/css.worker.js`;
-          break;
-        case "html":
-          url = `${assetsPath}/code-editor/html.worker.js`;
-          break;
-        case "typescript":
-        case "javascript":
-          url = `${assetsPath}/code-editor/ts.worker.js`;
-          break;
-        case "arcade":
-          url = `${assetsPath}/code-editor/arcade.worker.js`;
-          break;
-      }
-      // If we have a relative path or we are on same orgin, we can use the default js implementation
-      if (!D(url) || V(url, location.href, true)) {
-        return new Worker(url, { name: languageId });
-      }
-      // For cross orgin, we will load the worker code as a string and manufacture a blob
-      const esriRequest = await importRequest();
-      const response = await esriRequest(url, {
-        responseType: "text"
-      });
-      return new Worker(URL.createObjectURL(new Blob([response.data], {
-        type: "text/javascript"
-      })));
+    //
+    // Check if the worker loading logic has already been defined.
+    if (isMonacoEnvironmentSetup()) {
+        return;
     }
-  };
+    // Since we are using workers, monaco needs to find them.
+    // Using the global MonacoEnvironment.
+    globalThis.MonacoEnvironment = {
+        assetsPath,
+        getWorker: async (_, languageId) => {
+            // Manufacture the url for the web worker
+            let url = additionalLanguageWorkersMap.get(languageId) ?? `${assetsPath}/code-editor/editor.worker.js`;
+            switch (languageId) {
+                case "json":
+                    url = `${assetsPath}/code-editor/json.worker.js`;
+                    break;
+                case "css":
+                    url = `${assetsPath}/code-editor/css.worker.js`;
+                    break;
+                case "html":
+                    url = `${assetsPath}/code-editor/html.worker.js`;
+                    break;
+                case "typescript":
+                case "javascript":
+                    url = `${assetsPath}/code-editor/ts.worker.js`;
+                    break;
+                case "arcade":
+                    url = `${assetsPath}/code-editor/arcade.worker.js`;
+                    break;
+            }
+            // If we have a relative path or we are on same orgin, we can use the default js implementation
+            if (!se(url) || oe(url, globalThis.location.href, true)) {
+                return new Worker(url, { name: languageId });
+            }
+            // For cross orgin, we will load the worker code as a string and manufacture a blob
+            const esriRequest = await importRequest();
+            const response = await esriRequest(url, {
+                responseType: "text"
+            });
+            return new Worker(URL.createObjectURL(new Blob([response.data], {
+                type: "text/javascript"
+            })));
+        }
+    };
 }
 
 /**
@@ -69,8 +74,8 @@ function setupMonacoEnvironment(assetsPath) {
  * ```
  */
 async function getArcadeDiagnosticService() {
-  const mode = await getMode();
-  return mode.getArcadeDiagnosticService();
+    const mode = await getMode();
+    return mode.getArcadeDiagnosticService();
 }
 /**
  * Returns the arcade worker for the model.
@@ -81,31 +86,36 @@ async function getArcadeDiagnosticService() {
  * @returns arcade worker
  */
 async function getArcadeWorker(uri) {
-  const mode = await getMode();
-  return mode.getArcadeWorker(uri);
+    const mode = await getMode();
+    return await mode.getArcadeWorker(uri);
 }
 /**
  * Request the arcade mode
  * @returns mode for arcade
  */
-function getMode() {
-  return import('./arcade-mode.js');
+async function getMode() {
+    return await import('./arcade-mode.js');
 }
 // Register the language in Monaco
 languages.register({
-  id: arcadeDefaults.languageId,
-  aliases: ["Arcade", "arcade"],
-  extensions: [".arc"],
-  mimetypes: ["application/arcade"]
+    id: arcadeDefaults.languageId,
+    aliases: ["Arcade", "arcade"],
+    extensions: [".arc"],
+    mimetypes: ["application/arcade"]
 });
 // An event emitted when a language is first time needed
-languages.onLanguage(arcadeDefaults.languageId, async () => {
-  // Setup the assets path on the arcadeDefaults
-  arcadeDefaults.setLanguageOptions({ assetsPath: `${getAssetsPath() ?? "."}/arcade-language` });
-  // Async import the language mode
-  const mode = await getMode();
-  // Setup the language mode
-  mode.setupMode(arcadeDefaults);
+languages.onLanguage(arcadeDefaults.languageId, () => {
+    // Setup the assets path on the arcadeDefaults
+    arcadeDefaults.setLanguageOptions({ assetsPath: `${getAssetsPath() ?? "."}/arcade-language` });
+    // Async import the language mode
+    getMode()
+        .then((mode) => {
+        // Setup the language mode
+        mode.setupMode(arcadeDefaults);
+    })
+        .catch((err) => {
+        throw err;
+    });
 });
 
-export { getArcadeWorker as a, getArcadeDiagnosticService as g, setupMonacoEnvironment as s };
+export { getArcadeDiagnosticService as a, getArcadeWorker as g, setupMonacoEnvironment as s };