@arcgis/coding-components 5.1.0-next.54 → 5.1.0-next.56

package/dist/chunks/postgres.js

@@ -0,0 +1,209 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+const E = {
+  id: "postgres",
+  keywords: [
+    "ALL",
+    "ANALYSE",
+    "ANALYZE",
+    "AND",
+    "ANY",
+    "ARRAY",
+    "AS",
+    "ASC",
+    "ASYMMETRIC",
+    "AUTHORIZATION",
+    "BETWEEN",
+    "BINARY",
+    "BOTH",
+    "CASE",
+    "CAST",
+    "CHECK",
+    "COLLATE",
+    "COLLATION",
+    "COLUMN",
+    "CONCURRENTLY",
+    "CONSTRAINT",
+    "CREATE",
+    "CROSS",
+    "CURRENT_CATALOG",
+    "CURRENT_DATE",
+    "CURRENT_ROLE",
+    "CURRENT_SCHEMA",
+    "CURRENT_TIME",
+    "CURRENT_TIMESTAMP",
+    "CURRENT_USER",
+    "DEFAULT",
+    "DEFERRABLE",
+    "DESC",
+    "DISTINCT",
+    "DO",
+    "ELSE",
+    "END",
+    "EXCEPT",
+    "FALSE",
+    "FETCH",
+    "FOR",
+    "FOREIGN",
+    "FREEZE",
+    "FROM",
+    "FULL",
+    "GRANT",
+    "GROUP",
+    "HAVING",
+    "ILIKE",
+    "IN",
+    "INITIALLY",
+    "INNER",
+    "INTERSECT",
+    "INTO",
+    "IS",
+    "ISNULL",
+    "JOIN",
+    "LATERAL",
+    "LEADING",
+    "LEFT",
+    "LIKE",
+    "LIMIT",
+    "LOCALTIME",
+    "LOCALTIMESTAMP",
+    "NATURAL",
+    "NEW",
+    "NOT",
+    "NOTNULL",
+    "NULL",
+    "OFF",
+    "OFFSET",
+    "OLD",
+    "ON",
+    "ONLY",
+    "OR",
+    "ORDER",
+    "OUTER",
+    "OVER",
+    "OVERLAPS",
+    "PLACING",
+    "PRIMARY",
+    "REFERENCES",
+    "RETURNING",
+    "RIGHT",
+    "SELECT",
+    "SESSION_USER",
+    "SIMILAR",
+    "SOME",
+    "SYMMETRIC",
+    "TABLE",
+    "THEN",
+    "TO",
+    "TRAILING",
+    "TRUE",
+    "UNION",
+    "UNIQUE",
+    "USER",
+    "USING",
+    "VARIADIC",
+    "VERBOSE",
+    "WHEN",
+    "WHERE",
+    "WINDOW",
+    "WITH",
+    "CMAX",
+    "CMIN",
+    "CTID",
+    "TABLEOID",
+    "XMAX",
+    "XMIN"
+  ],
+  functions: [
+    "UPPER",
+    "LOWER",
+    "CONCAT",
+    "ASCII",
+    "CHAR_LENGTH",
+    "OCTET_LENGTH",
+    "CHR",
+    "LTRIM",
+    "RTRIM",
+    "SUBSTRING",
+    "SOUNDEX",
+    "REPLACE",
+    "TRIM",
+    "CEILING",
+    "FLOOR",
+    "ROUND",
+    "LN",
+    "LOG",
+    "MOD",
+    "POWER",
+    "SIGN",
+    "TRUNC",
+    "ASIN",
+    "ACOS",
+    "ATAN",
+    "TO_HEX",
+    "SIN",
+    "COS",
+    "TAN",
+    "EXTRACT",
+    "BIT_LENGTH",
+    "POSITION",
+    "ABS",
+    "VARIANCE",
+    "STDDEV",
+    "AVG",
+    "COUNT",
+    "MAX",
+    "MIN",
+    "SUM",
+    "COALESCE",
+    "CONVERT",
+    "CAST",
+    "CURRENT_USER",
+    "CURRENT_TIME",
+    "CURRENT_DATE",
+    "CURRENT_TIMESTAMP",
+    "STDDEV_POP",
+    "STDDEV_SAMP",
+    "VAR_POP",
+    "VAR_SAMP",
+    "NULLIF",
+    "PERCENTILE_CONT",
+    "PERCENTILE_DISC",
+    "CUME_DIST",
+    "FIRST_VALUE",
+    "LAST_VALUE",
+    "LEAD",
+    "LAG",
+    "PERCENT_RANK",
+    "RANK",
+    "NTILE",
+    "DENSE_RANK",
+    "ROW_NUMBER",
+    "STRING_AGG",
+    "GROUPING SETS",
+    "CUBE",
+    "ROLLUP",
+    "REGR_INTERCEPT",
+    "REGR_R2",
+    "REGR_SLOPE"
+  ],
+  operators: ["||"],
+  specialChars: {
+    likeWildcardAny: "%",
+    likeWildcardOne: "_",
+    identifierQuote: {
+      start: '"',
+      end: '"'
+    },
+    escapeKey: {
+      start: "'",
+      end: null
+    },
+    escapeClause: {
+      keyword: "ESCAPE",
+      suffix: ""
+    }
+  }
+};
+export {
+  E as postgresDialect
+};

package/dist/chunks/setup-monaco-theme.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import { Uri as p, languages as a } from "monaco-editor";
+import { Uri as p, languages as s } from "monaco-editor";
 import "monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js";
 import "monaco-editor/esm/vs/editor/standalone/common/standaloneTheme.js";
 import "monaco-editor/esm/vs/platform/hover/browser/hover.js";
@@ -8,12 +8,18 @@ import "monaco-editor/esm/vs/base/browser/dom.js";
 import "monaco-editor/esm/vs/editor/browser/editorDom.js";
 import "monaco-editor/esm/vs/editor/browser/controller/mouseTarget.js";
 import { b as t } from "./arcade-defaults.js";
-import { a as f } from "./arcade-service-accessors.js";
+import { a as l } from "./arcade-service-accessors.js";
 import { i as d } from "./monaco-importer.js";
-import { a as n } from "./sql-expr-defaults.js";
-import { g as l } from "./sql-expr-service-accessors.js";
+import { a } from "./sql-expr-defaults.js";
+import { g as f } from "./sql-expr-service-accessors.js";
 import { t as h } from "./monaco-theme.js";
-const k = ["arcade", "arcgis-sql-expression"], i = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map();
+const k = [
+  "arcade",
+  "arcgis-sql-expression",
+  "sql-layer-sql-server",
+  "sql-layer-postgres",
+  "sql-layer-bigquery"
+], i = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map();
 function c(e) {
   let r = g.get(e);
   return r || (r = Promise.withResolvers(), g.set(e, r)), r;
@@ -34,45 +40,45 @@ async function $(e) {
     return;
   (await d()).createModel("", e, p.parse("")).dispose();
 }
-a.register({
+s.register({
   id: t.languageId,
   aliases: ["Arcade", "arcade"],
   extensions: [".arc"],
   mimetypes: ["application/arcade"]
 });
-a.onLanguage(
+s.onLanguage(
   t.languageId,
   m(t.languageId, () => {
-    f().then((e) => {
+    l().then((e) => {
       e.setupMode(t), u(t.languageId);
     }).catch((e) => {
       throw e;
     });
   })
 );
-a.register({
-  id: n.languageId,
+s.register({
+  id: a.languageId,
   aliases: ["EsiSqlExpression", "sql-expression"],
   extensions: [".sql-expression"],
   mimetypes: ["application/sql-expression"]
 });
-a.onLanguage(
-  n.languageId,
-  m(n.languageId, () => {
-    l().then((e) => {
-      e.setupMode(n), u(n.languageId);
+s.onLanguage(
+  a.languageId,
+  m(a.languageId, () => {
+    f().then((e) => {
+      e.setupMode(a), u(a.languageId);
     }).catch((e) => {
       throw e;
     });
   })
 );
-w();
-function w() {
+y();
+function y() {
   d().then((e) => {
     ["light", "dark"].forEach((r) => {
-      const s = r === "light" ? "vs" : "vs-dark", o = h[`${r}-theme`];
-      e.defineTheme(s, {
-        base: s,
+      const n = r === "light" ? "vs" : "vs-dark", o = h[`${r}-theme`];
+      e.defineTheme(n, {
+        base: n,
         inherit: !0,
         rules: [
           { token: "comment.arcgis", foreground: o.comment },
@@ -91,6 +97,8 @@ function w() {
   });
 }
 export {
+  m as a,
+  u as m,
   $ as s,
   _ as w
 };

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

@@ -1,6 +1,7 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import { i as c, b as u, f as y, L as m, E as g } from "./language-defaults-base.js";
-import { CompletionItemKind as h, InsertTextFormat as P, InsertTextMode as F } from "vscode-languageserver-types";
+import { i as c, b as u } from "./utils.js";
+import { CompletionItemKind as y, InsertTextFormat as m, InsertTextMode as g } from "vscode-languageserver-types";
+import { f as h, L as P, E as F } from "./language-defaults-base.js";
 import { fetchT9nStringsBundle as M } from "@arcgis/toolkit/intl";
 import { g as b } from "./runtime.js";
 const x = (r) => {
@@ -17,9 +18,9 @@ function A(r) {
     label: t,
     detail: t,
     insertText: t,
-    insertTextMode: F.asIs,
-    insertTextFormat: P.PlainText,
-    kind: h.Field
+    insertTextMode: g.asIs,
+    insertTextFormat: m.PlainText,
+    kind: y.Field
   }, s = {
     name: t,
     description: i,
@@ -29,7 +30,7 @@ function A(r) {
   };
   if (!e || !("fields" in e))
     return s;
-  const [a, l] = y(e.fields, i);
+  const [a, l] = h(e.fields, i);
   return s.properties = a, o.documentation = { kind: "markdown", value: l }, s;
 }
 const T = {
@@ -70,7 +71,7 @@ function E(r) {
   }), i;
 }
 const d = "arcgis-sql-expression";
-class w extends m {
+class w extends P {
   constructor() {
     super(d, {
       apiPath: "./assets/sql-language/api",
@@ -96,7 +97,7 @@ class w extends m {
     if (!o)
       throw new Error(`Failed to load the language bundle for ${e.locale}`);
     this.disposeForModel(t);
-    const s = this._getApiKey(t), a = new g(i, o);
+    const s = this._getApiKey(t), a = new F(i, o);
     this._modelToProfileMap.set(s, a);
     const l = x(a);
     this.updateApiContextForModel(t, {
@@ -107,11 +108,11 @@ class w extends m {
     p && this.updateFeatureLayerForModel(t, p.definition);
   }
 }
-const n = new w(), q = {
+const n = new w(), I = {
   setProfileForModel: n.setProfileForModel.bind(n),
   getApiLibraryForModel: n.getApiLibraryForModel.bind(n)
 };
 export {
   n as a,
-  q as s
+  I as s
 };

package/dist/chunks/sql-layer-defaults.js

@@ -0,0 +1,231 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { fetchT9nStringsBundle as v } from "@arcgis/toolkit/intl";
+import { g as L } from "./runtime.js";
+import { a as q, D as P, b as C, q as T, n as w, c as M, e as F, L as V, h as $, E as k, i as _ } from "./language-defaults-base.js";
+import x from "@arcgis/core/portal/Portal.js";
+import { l as A } from "./utils.js";
+function y(t) {
+  for (const e of t) {
+    if (e instanceof C)
+      return e;
+    if (e.isCollection && "variables" in e) {
+      const o = y(
+        e.variables.filter(
+          (a) => a.type !== "group"
+        )
+      );
+      if (o)
+        return o;
+    }
+  }
+}
+function S(t, e) {
+  return `${t}:${e}`;
+}
+function B(t) {
+  if (t) {
+    for (const e of t)
+      if (e.type === "dataCatalogDatastore")
+        return e.definition;
+  }
+}
+async function N(t) {
+  const e = new x({ url: t.portal.url });
+  return await e.load(), new P({
+    itemId: t.id,
+    serviceUrl: t.serviceUrl,
+    portal: e
+  });
+}
+async function E(t) {
+  return A(t) ? await N(t) : t;
+}
+function I(t, e, o) {
+  let a = `**${t}**`;
+  return e.type && (a += `  
+${e.type}`), o && (a += `  
+Datastore: ${o}`), { value: a };
+}
+function W(t, e) {
+  let o = `**${t.name}**`;
+  return t.serverType && (o += `  
+${t.serverType}`), o += `  
+Nullable: ${t.nullable ? "yes" : "no"}`, o += `  
+Table: ${e}`, { value: o };
+}
+function U(t, e, o) {
+  return t.map((a) => {
+    const r = T(a.name, o);
+    return {
+      name: a.name,
+      normalizedName: w(a.name),
+      quotedName: r === a.name ? void 0 : r,
+      dataType: a.serverType,
+      nullable: a.nullable,
+      completionLabel: a.name,
+      insertText: r,
+      detail: [a.serverType, a.nullable ? "nullable" : "not null"].filter(Boolean).join(" | "),
+      documentation: W(a, e)
+    };
+  });
+}
+function z(t, e, o, a) {
+  const r = M(t.name, a), s = t.name.split("."), n = F(t.name);
+  return {
+    id: S(e, t.name),
+    name: t.name,
+    normalizedName: w(t.name),
+    quotedName: r === t.name ? void 0 : r,
+    description: t.type,
+    schema: s.length >= 2 ? s.at(-2) : void 0,
+    catalog: s.length >= 3 ? s.at(-3) : void 0,
+    completionLabel: t.name,
+    insertText: r,
+    detail: [t.type, o].filter(Boolean).join(" | "),
+    documentation: I(n, t, o),
+    columns: []
+  };
+}
+async function K(t, e) {
+  const o = y(t.dictionaryVariables);
+  if (!o)
+    return { tables: [] };
+  await o.loadSource();
+  const a = o.datastoreInfo, r = a?.datastoreId;
+  if (!r)
+    return { tables: [] };
+  const s = o.tableVariables.map(
+    (n) => z(n.datasetInfo, r, a?.name, e)
+  );
+  return {
+    datastore: {
+      id: r,
+      displayName: a?.name,
+      databasePlatform: a?.databasePlatform
+    },
+    tables: s
+  };
+}
+async function R(t) {
+  const e = B(t?.variables);
+  if (!e)
+    return q(void 0);
+  const a = await (await E(e)).fetchInfo();
+  return q(a.databasePlatform);
+}
+class j extends V {
+  /**
+   * Per-model update chaining to serialize profile updates. see arcade-defaults for rationale.
+   */
+  #e = /* @__PURE__ */ new Map();
+  /**
+   * Per-model, per-table column load caching to avoid redundant loads when multiple requests for the same table(s) are made before the first load completes.
+   */
+  #t = /* @__PURE__ */ new Map();
+  #a;
+  constructor(e) {
+    super(e, {
+      apiPath: "./assets/sql-layer/api",
+      apiPrefix: "sql-layer-api.t9n."
+    });
+    const o = _(e);
+    this.dialectId = o;
+  }
+  getWorkerHostExtension() {
+    return {
+      getSqlLayerDialectSpec: async () => await this.getDialectSpec(),
+      getSqlLayerColumnsForModel: async (e, o) => await this._loadSqlLayerColumnsForModel(e, o)
+    };
+  }
+  async getDialectSpec() {
+    return this.#a ??= $(this.languageId), await this.#a;
+  }
+  disposeForModel(e) {
+    this.#t.delete(this._getApiKey(e)), super.disposeForModel(e);
+  }
+  async setProfileForModel(e, o, a) {
+    const r = this._getApiKey(e), n = (this.#e.get(r) || Promise.resolve()).then(async () => {
+      const f = await v(
+        a.locale,
+        L("./assets/editor-profile/t9n"),
+        "messages."
+      );
+      if (!f)
+        throw new Error(`Failed to load the language bundle for ${a.locale}`);
+      this.disposeForModel(e);
+      const u = new k(o, f, a.locale);
+      this._modelToProfileMap.set(r, u);
+      const g = await K(u, await this.getDialectSpec());
+      this.updateApiContextForModel(e, {
+        locale: a.locale,
+        snippets: a.snippets,
+        sqlProfile: g
+      });
+    }), l = n.finally(() => {
+      this.#e.get(r) === l && this.#e.delete(r);
+    });
+    return this.#e.set(r, l), await n;
+  }
+  async _loadSqlLayerColumnsForModel(e, o) {
+    if (!o.length)
+      return [];
+    const a = this._getApiKey(e), r = this.getApiContextForModel(e), s = r.sqlProfile, n = this._modelToProfileMap.get(a), l = n ? y(n.dictionaryVariables) : void 0;
+    if (!s || !l)
+      return [];
+    await l.loadSource();
+    const u = l.datastoreInfo?.datastoreId;
+    if (!u)
+      return [];
+    const g = new Map(
+      l.tableVariables.map((i) => [
+        S(u, i.datasetInfo.name),
+        i
+      ])
+    );
+    let d = this.#t.get(a);
+    d || (d = /* @__PURE__ */ new Map(), this.#t.set(a, d));
+    const h = await Promise.all(
+      o.map(async (i) => {
+        const b = s.tables.find((c) => c.id === i);
+        if (b?.columns.length)
+          return { tableId: i, columns: b.columns };
+        let m = d.get(i);
+        return m || (m = (async () => {
+          const c = g.get(i);
+          return c ? (await c.loadSource(), U(
+            c.fieldInfos,
+            c.datasetInfo.name,
+            await this.getDialectSpec()
+          )) : [];
+        })(), d.set(i, m)), { tableId: i, columns: await m };
+      })
+    ), D = this._mergeLoadedColumns(s, h);
+    return D !== s && this.updateApiContextForModel(e, { ...r, sqlProfile: D }), h;
+  }
+  _mergeLoadedColumns(e, o) {
+    const a = new Map(o.map((n) => [n.tableId, n.columns]));
+    let r = !1;
+    const s = e.tables.map((n) => n.columns.length || !a.has(n.id) ? n : (r = !0, {
+      ...n,
+      columns: a.get(n.id) ?? n.columns
+    }));
+    return r ? { ...e, tables: s } : e;
+  }
+}
+const p = /* @__PURE__ */ new Map();
+function X(t) {
+  let e = p.get(t);
+  return e || (e = new j(t), p.set(t, e)), e;
+}
+function Y(t) {
+  return p.get(t);
+}
+function Z() {
+  return [...p.values()];
+}
+export {
+  R as a,
+  Y as b,
+  X as c,
+  Z as g
+};