@arcgis/coding-components 1.0.0-beta.9 → 4.28.0-beta.0

package/dist/components/fields.js

@@ -0,0 +1,125 @@
+const amd = "define" in window && typeof window.define === "function" && "amd" in window.define;
+function requireModule(modulePath) {
+    return new Promise((resolve) => window.require([modulePath], (moduleDefault) => {
+        resolve(moduleDefault);
+    }));
+}
+async function importLayersFeatureLayer() {
+    if (amd) {
+        return requireModule("esri/layers/FeatureLayer");
+    }
+    const module = await import('@arcgis/core/layers/FeatureLayer.js');
+    return module.default;
+}
+async function importPortalPortalItem() {
+    if (amd) {
+        return requireModule("esri/portal/PortalItem");
+    }
+    const module = await import('@arcgis/core/portal/PortalItem.js');
+    return module.default;
+}
+async function importWebMap() {
+    if (amd) {
+        return requireModule("esri/WebMap");
+    }
+    const module = await import('@arcgis/core/WebMap.js');
+    return module.default;
+}
+async function importArcade() {
+    if (amd) {
+        return requireModule("esri/arcade");
+    }
+    const module = await import('@arcgis/core/arcade.js');
+    return module;
+}
+async function importRequest() {
+    if (amd) {
+        return requireModule("esri/request");
+    }
+    const module = await import('@arcgis/core/request.js');
+    return module.default;
+}
+
+/**
+ * Returns an icon name for the field type
+ */
+function fieldTypeToIconName(field) {
+  switch (field?.type) {
+    case "oid":
+      return "key";
+    case "small-integer":
+    case "big-integer":
+    case "integer":
+    case "single":
+    case "double":
+    case "long":
+      return "number";
+    case "global-id":
+    case "guid":
+      return "key";
+    case "string":
+      return "string";
+    case "date":
+      return "date-time";
+    case "date-only":
+      return "calendar";
+    case "time-only":
+      return "clock";
+    case "timestamp-offset":
+      return "time-zone";
+    default:
+      return "cube";
+  }
+}
+/**
+ * Returns the Arcade type for the given field.
+ */
+function fieldTypeToArcadeType(field) {
+  switch (field?.type) {
+    case "small-integer":
+    case "integer":
+    case "big-integer":
+    case "single":
+    case "double":
+    case "long":
+    case "oid":
+      return "number";
+    case "global-id":
+    case "guid":
+    case "string":
+      return "text";
+    case "date":
+      return "date";
+    case "date-only":
+      return "dateOnly";
+    case "time-only":
+      return "time";
+    default:
+      return "text";
+  }
+}
+function supportedFields(fields) {
+  return (fields ?? []).filter((field) => {
+    switch (field.type) {
+      case "string":
+      case "small-integer":
+      case "integer":
+      case "big-integer":
+      case "single":
+      case "double":
+      case "long":
+      case "date":
+      case "date-only":
+      case "time-only":
+      case "timestamp-offset":
+      case "oid":
+      case "guid":
+      case "global-id":
+        return true;
+      default:
+        return false;
+    }
+  });
+}
+
+export { importLayersFeatureLayer as a, importWebMap as b, importRequest as c, fieldTypeToArcadeType as d, importArcade as e, fieldTypeToIconName as f, importPortalPortalItem as i, supportedFields as s };

package/dist/components/index.js

@@ -1,14 +1,8 @@
 export { setAssetPath, setNonce, setPlatformOptions } from '@stencil/core/internal/client';
-import { a as arcadeDefaults } from './arcade-defaults.js';
+export { a as arcade } from './arcade-defaults.js';
 export { ArcgisArcadeApi, defineCustomElement as defineCustomElementArcgisArcadeApi } from './arcgis-arcade-api.js';
 export { ArcgisArcadeEditor, defineCustomElement as defineCustomElementArcgisArcadeEditor } from './arcgis-arcade-editor.js';
 export { ArcgisArcadeResults, defineCustomElement as defineCustomElementArcgisArcadeResults } from './arcgis-arcade-results.js';
 export { ArcgisArcadeSuggestions, defineCustomElement as defineCustomElementArcgisArcadeSuggestions } from './arcgis-arcade-suggestions.js';
 export { ArcgisArcadeVariables, defineCustomElement as defineCustomElementArcgisArcadeVariables } from './arcgis-arcade-variables.js';
 export { ArcgisCodeEditor, defineCustomElement as defineCustomElementArcgisCodeEditor } from './arcgis-code-editor.js';
-
-const arcade = {
-  setProfileForModel: arcadeDefaults.setProfileForModel.bind(arcadeDefaults)
-};
-
-export { arcade };

package/dist/components/index2.js

@@ -1,43 +1,293 @@
-const amd = "define" in window && typeof window.define === "function" && "amd" in window.define;
-function requireModule(modulePath) {
-    return new Promise((resolve) => window.require([modulePath], (moduleDefault) => {
-        resolve(moduleDefault);
-    }));
-}
-async function importLayersFeatureLayer() {
-    if (amd) {
-        return requireModule("esri/layers/FeatureLayer");
+// src/deferred.ts
+var Deferred = class {
+  /**
+   * Creates a new deferred promise.
+   */
+  constructor() {
+    this.resolve = () => void 0;
+    this.reject = () => void 0;
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+};
+
+// src/dom.ts
+function inTargetElement(element, targetElement) {
+  let currentElement = element;
+  while (currentElement) {
+    if (currentElement === targetElement) {
+      return true;
+    }
+    if (!currentElement.parentNode) {
+      return false;
+    }
+    if (currentElement.parentNode instanceof ShadowRoot) {
+      currentElement = currentElement.parentNode.host;
+    } else {
+      currentElement = currentElement.parentNode;
     }
-    const module = await import('@arcgis/core/layers/FeatureLayer.js');
-    return module.default;
+  }
+  return false;
 }
-async function importPortalPortalItem() {
-    if (amd) {
-        return requireModule("esri/portal/PortalItem");
+function observeAncestorsMutation(element, attributeFilter, callback = () => void 0) {
+  if (!attributeFilter || attributeFilter.length <= 0) {
+    return void 0;
+  }
+  const mutationObserver = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (inTargetElement(element, mutation.target)) {
+        callback();
+      }
     }
-    const module = await import('@arcgis/core/portal/PortalItem.js');
-    return module.default;
+  });
+  mutationObserver.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter,
+    subtree: true
+  });
+  return mutationObserver;
 }
-async function importWebMap() {
-    if (amd) {
-        return requireModule("esri/WebMap");
+function closestElement(base, selector) {
+  let currentElement = base;
+  while (currentElement) {
+    const element = currentElement.closest(selector);
+    if (element) {
+      return element;
     }
-    const module = await import('@arcgis/core/WebMap.js');
-    return module.default;
+    const rootElement = currentElement.getRootNode();
+    if (rootElement === document) {
+      return null;
+    }
+    currentElement = rootElement.host;
+  }
+  return null;
+}
+function getElementTheme(base) {
+  const themeElt = closestElement(base, ":is(.calcite-mode-light, .calcite-mode-dark)");
+  return themeElt && themeElt.classList.contains("calcite-mode-dark") ? "dark" : "light";
+}
+function getElementAttribute(el, prop, fallbackValue) {
+  const closest = closestElement(el, `[${prop}]`);
+  return closest?.getAttribute(prop) ?? fallbackValue;
 }
-async function importArcade() {
-    if (amd) {
-        return requireModule("esri/arcade");
+function isElement(ref) {
+  return ref.nodeType === Node.ELEMENT_NODE;
+}
+function setFocus(ref, selector = "") {
+  if (!isElement(ref)) {
+    return false;
+  }
+  if (ref.matches(selector)) {
+    setTimeout(() => ref?.setFocus(), 0);
+    return true;
+  }
+  for (let i = 0; i < ref.children.length; i++) {
+    if (setFocus(ref.children[i], selector)) {
+      return true;
+    }
+  }
+  const shadowRoot = ref.shadowRoot;
+  if (shadowRoot) {
+    for (let i = 0; i < shadowRoot.children.length; i++) {
+      if (setFocus(shadowRoot.children[i], selector)) {
+        return true;
+      }
     }
-    const module = await import('@arcgis/core/arcade.js');
-    return module;
+  }
+  return false;
 }
-async function importRequest() {
-    if (amd) {
-        return requireModule("esri/request");
+function setFocusOnElement(ref, selector) {
+  if (!ref || !ref.shadowRoot) {
+    return;
+  }
+  if (ref.hasAttribute("hydrated") || ref.hasAttribute("calcite-hydrated")) {
+    setFocus(ref, selector);
+    return;
+  }
+  const mutationObserver = new MutationObserver(() => {
+    mutationObserver.disconnect();
+    setFocus(ref, selector);
+  });
+  mutationObserver.observe(ref, {
+    attributes: true,
+    attributeFilter: ["hydrated", "calcite-hydrated"]
+  });
+}
+
+// src/guid.ts
+function gen(count) {
+  let out = "";
+  for (let i = 0; i < count; i++) {
+    out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
+  }
+  return out;
+}
+function generateGuid() {
+  return [gen(2), gen(1), gen(1), gen(1), gen(3)].join("-");
+}
+
+// src/intl.ts
+var SupportedLocales = /* @__PURE__ */ new Set([
+  "ar",
+  "bg",
+  "bs",
+  "ca",
+  "cs",
+  "da",
+  "de",
+  "el",
+  "en",
+  "es",
+  "et",
+  "fi",
+  "fr",
+  "he",
+  "hr",
+  "hu",
+  "id",
+  "it",
+  "ja",
+  "ko",
+  "lt",
+  "lv",
+  "nl",
+  "nb",
+  "pl",
+  "pt-BR",
+  "pt-PT",
+  "ro",
+  "ru",
+  "sk",
+  "sl",
+  "sr",
+  "sv",
+  "th",
+  "tr",
+  "uk",
+  "vi",
+  "zh-CN",
+  "zh-HK",
+  "zh-TW"
+]);
+var t9nStringsCache = /* @__PURE__ */ new Map();
+async function fetchT9NStringsBundle(locale, assetsPath, prefix = "") {
+  const filePath = `${assetsPath}/${prefix}${locale}.json`;
+  if (t9nStringsCache.has(filePath)) {
+    return t9nStringsCache.get(filePath);
+  }
+  try {
+    const response = await fetch(filePath);
+    if (response.ok) {
+      const stringBundle2 = await response.json();
+      t9nStringsCache.set(filePath, stringBundle2);
+      return stringBundle2;
     }
-    const module = await import('@arcgis/core/request.js');
-    return module.default;
+    if (locale === "en") {
+      t9nStringsCache.set(filePath, void 0);
+      return void 0;
+    }
+    const stringBundle = await fetchT9NStringsBundle("en", assetsPath, prefix);
+    t9nStringsCache.set(filePath, stringBundle);
+    return stringBundle;
+  } catch (e) {
+    t9nStringsCache.set(filePath, void 0);
+    return void 0;
+  }
+}
+function getElementLocale(el) {
+  const lang = getElementAttribute(el, "lang", navigator?.language || "en");
+  if (SupportedLocales.has(lang)) {
+    return lang;
+  }
+  const rootCode = lang.slice(0, 2);
+  return SupportedLocales.has(rootCode) ? rootCode : "en";
+}
+var observersMap = /* @__PURE__ */ new WeakMap();
+var assetsPathMap = /* @__PURE__ */ new WeakMap();
+var t9nStringsMap = /* @__PURE__ */ new WeakMap();
+async function startLocaleObserver(component, assetsPath, callback) {
+  assetsPathMap.set(component, assetsPath);
+  observersMap.set(
+    component,
+    observeAncestorsMutation(component._hostElt, ["lang"], () => {
+      updateComponentLocateState(component, callback);
+    })
+  );
+  await updateComponentLocateState(component, callback);
+}
+function stopLocaleObserver(component) {
+  observersMap.get(component)?.disconnect();
+  observersMap.delete(component);
+  assetsPathMap.delete(component);
+}
+async function updateComponentLocateState(component, callback) {
+  const locale = getElementLocale(component._hostElt);
+  if (locale === component._locale) {
+    return;
+  }
+  let t9nStrings = t9nStringsMap.get(component);
+  if (!t9nStrings) {
+    const assetsPath = assetsPathMap.get(component) ?? "";
+    const assetName = component._hostElt.tagName.toLowerCase().replace("arcgis-", "");
+    const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
+    const prefix = `${assetName}.t9n.`;
+    component._locale = locale;
+    t9nStrings = await fetchT9NStringsBundle(component._locale, t9nAssetsPath, prefix);
+  }
+  component._t9nStrings = t9nStrings;
+  await callback?.call(component);
+}
+
+// src/strings.ts
+var doubleQuote = '"';
+var singleQuote = "'";
+function repeatString(value, n) {
+  return new Array(n + 1).join(value);
+}
+function quoteString(value) {
+  let quote = doubleQuote;
+  let alternateQuote = singleQuote;
+  const avoidEscape = value.indexOf(quote) >= 0 && value.indexOf(alternateQuote) < 0;
+  if (avoidEscape) {
+    alternateQuote = doubleQuote;
+    quote = singleQuote;
+  }
+  const alternateEscape = new RegExp("(^|[^\\\\])((?:\\\\{2})*)((?:\\\\" + alternateQuote + ")+)", "g");
+  value = value.replace(
+    alternateEscape,
+    (_, boundaryChar, leadingEscapedSlashes, escapedQuoteChars) => (
+      // We divide the escapedQuoteChars by 2 since there are 2 characters in each escaped part ('\\"'.length === 2)
+      boundaryChar + leadingEscapedSlashes + repeatString(alternateQuote, escapedQuoteChars.length / 2)
+    )
+  );
+  const quoteEscape = new RegExp("(^|[^\\\\])((?:\\\\{2})*)(" + quote + "+)", "g");
+  value = value.replace(
+    quoteEscape,
+    (_, boundaryChar, leadingEscapedSlashes, quoteChars) => boundaryChar + leadingEscapedSlashes + repeatString("\\" + quote, quoteChars.length)
+  );
+  return quote + value + quote;
+}
+function createFilterExpression(filterWord) {
+  const sanitizedWord = filterWord ? filterWord.replaceAll(/[-[\]/{}()*+?.\\^$|]/g, "\\$&") : "^.*$";
+  return new RegExp(sanitizedWord, "i");
+}
+function setValuesInString(message, values = {}) {
+  return (message ?? "").replace(/\{(.*?)\}/g, (match, valueName) => {
+    return values[valueName] ?? match;
+  });
+}
+function addLTRMark(value) {
+  return "\u200E" + (value ?? "") + "\u200E";
+}
+
+// src/type-guards.ts
+function isNotNull(item) {
+  return item !== null;
+}
+function isNotUndefined(item) {
+  return item !== void 0;
 }
 
-export { importLayersFeatureLayer as a, importWebMap as b, importRequest as c, importArcade as d, importPortalPortalItem as i };
+export { Deferred as D, SupportedLocales as S, isNotUndefined as a, addLTRMark as b, getElementTheme as c, startLocaleObserver as d, stopLocaleObserver as e, fetchT9NStringsBundle as f, generateGuid as g, setFocusOnElement as h, isNotNull as i, createFilterExpression as j, observeAncestorsMutation as o, quoteString as q, setValuesInString as s };

package/dist/components/markdown.js

@@ -47,7 +47,7 @@ function commonjsRequire () {
 
 var marked_umd = createCommonjsModule(function (module, exports) {
 /**
- * marked v5.1.1 - a markdown parser
+ * marked v5.1.2 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */