@arcgis/ai-components 5.2.0-next.99 → 6.0.0-next.1

package/dist/chunks/layerStylingState.js

@@ -0,0 +1,907 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import s from "zod";
+import { tool as m } from "@langchain/core/tools";
+import { createRenderer as b } from "@arcgis/core/smartMapping/renderers/pieChart.js";
+import { getSchemesByTag as S, getSchemes as T } from "@arcgis/core/smartMapping/symbology/pieChart.js";
+import { getBackgroundColorTheme as w } from "@arcgis/core/views/support/colorUtils.js";
+import { sendUXSuggestion as h } from "../orchestrator/signals.js";
+import { createAgeRenderer as z, createContinuousRenderer as R } from "@arcgis/core/smartMapping/renderers/color.js";
+import { getSchemesByTag as f } from "@arcgis/core/smartMapping/symbology/color.js";
+import { createContinuousRenderer as v } from "@arcgis/core/smartMapping/renderers/univariateColorSize.js";
+import { createRenderer as C } from "@arcgis/core/smartMapping/renderers/dotDensity.js";
+import { getSchemesByTag as $ } from "@arcgis/core/smartMapping/symbology/dotDensity.js";
+import { createRenderer as E } from "@arcgis/core/smartMapping/renderers/heatmap.js";
+import { getSchemesByTag as O } from "@arcgis/core/smartMapping/symbology/heatmap.js";
+import { createRenderer as D } from "@arcgis/core/smartMapping/renderers/predominance.js";
+import { getSchemesByTag as P } from "@arcgis/core/smartMapping/symbology/predominance.js";
+import { createRenderer as V } from "@arcgis/core/smartMapping/renderers/relationship.js";
+import { getSchemesByTag as A } from "@arcgis/core/smartMapping/symbology/relationship.js";
+import { createAgeRenderer as L, createContinuousRenderer as M } from "@arcgis/core/smartMapping/renderers/size.js";
+import { createRenderer as x } from "@arcgis/core/smartMapping/renderers/type.js";
+import { getSchemesByTag as j } from "@arcgis/core/smartMapping/symbology/type.js";
+import { layerStylingContextRequiredKeys as F } from "../agents/agents/layerStyling/context/layerStylingContext.js";
+import { Annotation as g } from "@langchain/langgraph/web";
+import { a as q } from "./runtime2.js";
+async function K(e) {
+  const { fields: i, layer: r, view: t, styleName: a, colorSchemeTags: n } = e;
+  let l;
+  return n ? l = S({
+    basemapTheme: await w(t),
+    geometryType: r.geometryType,
+    includedTags: n,
+    numColors: Math.min(i.length, 8)
+  })[0] : l = T({
+    basemapTheme: await w(t),
+    geometryType: r.geometryType,
+    numColors: Math.min(i.length, 8)
+  }).primaryScheme, {
+    layer: r,
+    view: t,
+    attributes: i.map((o) => ({
+      field: o,
+      label: r.fields.find((d) => d.name === o)?.alias ?? ""
+    })).slice(0, 8),
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    includeSizeVariable: a.includes("Size"),
+    pieChartScheme: l
+  };
+}
+async function N(e) {
+  return await b(e);
+}
+async function B({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  includeSize: n
+}) {
+  const l = i, o = e?.allLayers.find((p) => p.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const c = {
+    styleName: n ? "chart-size" : "chart",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a
+  };
+  try {
+    const p = await K(c), y = await N(p);
+    return o.renderer = y.renderer, o.visible = !0, `Chart renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (p) {
+    return `Error applying chart renderer: ${p instanceof Error ? p.message : String(p)}`;
+  }
+}
+function u(e) {
+  const r = e?.configurable?.context;
+  if (!r || typeof r != "object")
+    throw new Error("LayerStylingAgent context missing");
+  const t = F.filter((a) => !(a in r));
+  if (t.length)
+    throw new Error(`LayerStylingAgent context missing: ${t.join(", ")}`);
+  return r;
+}
+async function W({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  includeSize: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await B({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    includeSize: t
+  });
+}
+const U = s.object({
+  layerId: s.string().describe("The id of the layer to apply the chart renderer to"),
+  fields: s.array(s.string()).describe("The fields to use for the chart renderer (multiple numeric fields)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  includeSize: s.boolean().optional().describe("Whether to vary the chart size (chart-size)")
+}), cr = m(W, {
+  name: "chart",
+  description: `Label: Charts
+    Description: Show the values of two or more categories as a proportion of the total using a pie chart.
+    Keywords: pie, chart, all categories, breakdown, proportion
+    Example: Show the total number of homes built in each decade using a pie chart for each feature.
+    Fields: This style requires 2-8 number fields.
+
+    Label: Charts and Size
+    Description: Show the values of two or more categories as a proportion of the total using a pie chart and use size to capture the total amount or magnitude.
+    Keywords: pie, chart, all categories, breakdown, proportion, total, amount, how much, sum, graduated size, proportional size
+    Example: Show the total number of homes built in each decade using a pie chart for each feature and vary the size of each chart based on the total of all categories.
+    Fields: This style requires 2-8 number fields.`,
+  schema: U
+});
+function H(e) {
+  const { fields: i, layer: r, view: t, theme: a, colorSchemeTags: n } = e, l = i[0];
+  let o;
+  return n && (o = f({
+    geometryType: r.geometryType,
+    includedTags: n,
+    theme: a || "high-to-low"
+  })[0]), {
+    layer: r,
+    view: t,
+    startTime: l,
+    endTime: /* @__PURE__ */ new Date(),
+    theme: a,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0,
+    colorScheme: o
+  };
+}
+async function k(e) {
+  return await z(e);
+}
+async function I({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  theme: n
+}) {
+  const l = i, o = e?.allLayers.find((c) => c.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const d = {
+    styleName: "color-age",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a,
+    theme: n
+  };
+  try {
+    const c = H(d), p = await k(c);
+    return o.renderer = p.renderer, o.visible = !0, `Color-age renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (c) {
+    return `Error applying color-age renderer: ${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function X({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  theme: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await I({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    theme: t
+  });
+}
+const G = s.object({
+  layerId: s.string().describe("The id of the layer to apply the color-age renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the color-age renderer (temporal/date data)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("Optional theme for the color ramp")
+}), dr = m(X, {
+  name: "color-age",
+  description: `Label: Age (color)
+    Description: Use colors along a continuous color ramp to represent the age of features. Age reflects the length of time from a start date to an end date.
+    Keywords: since, age, how old, how long
+    Example: Show the age of each feature based on its reported date.
+    Fields: This style requires at least one field with a date type.`,
+  schema: G
+});
+function J(e) {
+  const { fields: i, layer: r, view: t, colorSchemeTags: a } = e;
+  let { theme: n } = e, l = i[1];
+  const o = i[0];
+  let d;
+  return a && (d = f({
+    geometryType: r.geometryType,
+    includedTags: a,
+    theme: n || "high-to-low"
+  })[0]), {
+    layer: r,
+    view: t,
+    field: o,
+    normalizationField: l,
+    theme: n,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0,
+    colorScheme: d
+  };
+}
+async function Q(e) {
+  return await R(e);
+}
+async function Y({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  theme: n
+}) {
+  const l = i, o = e?.allLayers.find((c) => c.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const d = {
+    styleName: "color",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a,
+    theme: n
+  };
+  try {
+    const c = J(d), p = await Q(c);
+    return o.renderer = p.renderer, o.visible = !0, `Color renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (c) {
+    return `Error applying color renderer: ${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function Z({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  theme: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await Y({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    theme: t
+  });
+}
+const _ = s.object({
+  layerId: s.string().describe("The id of the layer to apply the color renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the color renderer"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("Optional theme for the color ramp")
+}), pr = m(Z, {
+  name: "color",
+  description: `Label: Counts and Amounts (color)
+    Description: Vary color along a continuous color ramp to represent numeric or ranked data.
+    Keywords: graduated color, choropleth, continuous color, hue, color, gradation, saturation, lightness, percent, rate, ratio, index, how much, increase, decrease
+    Example: Color each feature based on the population density.
+    Fields: This style requires a single field with a number type. A second number field may be specified for normalizing the value of the first field.`,
+  schema: _
+});
+function ee(e) {
+  const { fields: i, layer: r, view: t, colorSchemeTags: a, theme: n } = e;
+  let l, o;
+  const d = i[0];
+  return a && (o = f({
+    geometryType: r.geometryType,
+    includedTags: a,
+    theme: n || "high-to-low"
+  })[0]), {
+    layer: r,
+    view: t,
+    field: d,
+    normalizationField: l,
+    theme: n,
+    colorOptions: {
+      colorScheme: o
+    }
+  };
+}
+async function re(e) {
+  return await v(e);
+}
+async function te({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  theme: n
+}) {
+  const l = i, o = e?.allLayers.find((c) => c.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const d = {
+    styleName: "color-size-univariate",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a,
+    theme: n
+  };
+  try {
+    const c = ee(d), p = await re(c);
+    return o.renderer = p.renderer, o.visible = !0, `Color-size-univariate renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (c) {
+    return `Error applying color-size-univariate renderer: ${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function ae({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  theme: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await te({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    theme: t
+  });
+}
+const oe = s.object({
+  layerId: s.string().describe("The id of the layer to apply the color-size univariate renderer to"),
+  fields: s.array(s.string()).describe("The fields to use for the color-size univariate renderer"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("Optional theme for the color and size ramps")
+}), mr = m(ae, {
+  name: "color-size-univariate",
+  description: `Label: Color and Size (univariate)
+    Description: Vary symbol size and color based on the values of two numeric attributes.
+    Keywords: continuous color, hue, color, size, gradation, saturation, lightness, percent, rate, ratio, index, how much, increase, decrease, amount
+    Example: Color each feature based on the percentage of the population that owns a home and vary the size of each point based on total population.
+    Fields: This style requires at least two fields: one determining the color of each feature, the other determining the size of each feature. Each field may be normalized by an additional normalization field.`,
+  schema: oe
+});
+function ie(e) {
+  const { fields: i, layer: r, view: t, colorSchemeTags: a } = e;
+  let n;
+  return a && (n = $({
+    includedTags: a,
+    numColors: Math.min(i.length, 8)
+  })[0]), {
+    layer: r,
+    view: t,
+    legendOptions: {
+      unit: "units"
+    },
+    attributes: i.map((l) => ({
+      field: l,
+      label: r.fields.find((o) => o.name === l)?.alias ?? ""
+    })).slice(0, 8),
+    outlineOptimizationEnabled: !0,
+    dotDensityScheme: n
+  };
+}
+async function ne(e) {
+  return await C(e);
+}
+async function se({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a
+}) {
+  const n = i, l = e?.allLayers.find((d) => d.id === r);
+  if (!l)
+    return `Could not find layer for id: ${r}`;
+  const o = {
+    styleName: "dot-density",
+    fields: t,
+    layer: l,
+    view: n,
+    colorSchemeTags: a
+  };
+  try {
+    const d = ie(o), c = await ne(d);
+    return l.renderer = c.renderer, l.visible = !0, `Dot Density renderer applied to layer: ${l.title ?? l.id} using fields ${t.join(", ")}`;
+  } catch (d) {
+    return `Error applying dot density renderer: ${d instanceof Error ? d.message : String(d)}`;
+  }
+}
+async function le({
+  layerId: e,
+  fields: i,
+  colorSchemes: r
+}, t) {
+  const { mapView: a } = u(t);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, t), await se({
+    arcgisMap: a.map,
+    arcgisMapView: a,
+    layerId: e,
+    fields: i,
+    colorSchemes: r
+  });
+}
+const ce = s.object({
+  layerId: s.string().describe("The id of the layer to apply the dot density renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the dot density renderer (population or count data)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use")
+}), hr = m(le, {
+  name: "dot-density",
+  description: `Dot Density
+    Use dot density to visualize the distribution of one attribute or compare the density of multiple attributes. This is only valid for polygon layers.
+    **Use cases:**
+    - Population distribution visualization
+    - Comparing multiple categories within areas
+    - Showing spatial distribution patterns
+    **Examples:**
+    - Show the density of the population based on various race/ethnic groups
+    - Visualize distribution of different crops across regions
+    - Display demographic patterns within census tracts
+    **Fields:** Requires 2-8 number fields.
+    **Keywords:** density, how much, how many, total, number, amount`,
+  schema: ce
+});
+function de(e) {
+  const { fields: i, layer: r, view: t, colorSchemeTags: a } = e;
+  let n;
+  const l = i[0];
+  return a && (n = O({
+    includedTags: a,
+    basemap: t.map?.basemap || "topo"
+  })[0]), {
+    layer: r,
+    view: t,
+    field: l,
+    heatmapScheme: n
+  };
+}
+async function pe(e) {
+  return await E(e);
+}
+async function me({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a
+}) {
+  const n = i, l = e?.allLayers.find((d) => d.id === r);
+  if (!l)
+    return `Could not find layer for id: ${r}`;
+  const o = {
+    styleName: "heatmap",
+    fields: t,
+    layer: l,
+    view: n,
+    colorSchemeTags: a
+  };
+  try {
+    const d = de(o), c = await pe(d);
+    return l.renderer = c.renderer, l.visible = !0, `Heatmap renderer applied to layer: ${l.title ?? l.id} using fields ${t.join(", ")}`;
+  } catch (d) {
+    return `Error applying heatmap renderer: ${d instanceof Error ? d.message : String(d)}`;
+  }
+}
+async function he({
+  layerId: e,
+  fields: i,
+  colorSchemes: r
+}, t) {
+  const { mapView: a } = u(t);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, t), await me({
+    arcgisMap: a.map,
+    arcgisMapView: a,
+    layerId: e,
+    fields: i,
+    colorSchemes: r
+  });
+}
+const ue = s.object({
+  layerId: s.string().describe("The id of the layer to apply the heatmap renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the heatmap renderer (typically point density)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use")
+}), ur = m(he, {
+  name: "heatmap",
+  description: `Label: Heat Map
+Description: Show areas of high density with colors that appear to glow hotter. This is only valid for point layers.
+Keywords: density, heatmap, hot spots, pattern, cluster
+Example: Create a heatmap
+Fields: This typically requires zero or one field of type number.`,
+  schema: ue
+});
+function ye(e) {
+  const { fields: i, layer: r, view: t, styleName: a, colorSchemeTags: n } = e;
+  let l;
+  return n && (l = P({
+    geometryType: r.geometryType,
+    includedTags: n,
+    numColors: Math.min(i.length, 10)
+  })[0]), {
+    layer: r,
+    view: t,
+    fields: i.map((o) => ({ name: o })).slice(0, 9),
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    includeSizeVariable: a.includes("Size"),
+    predominanceScheme: l
+  };
+}
+async function ge(e) {
+  return await D(e);
+}
+async function fe({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  includeSize: n
+}) {
+  const l = i, o = e?.allLayers.find((p) => p.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const c = {
+    styleName: n ? "predominance-size" : "predominance",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a
+  };
+  try {
+    const p = ye(c), y = await ge(p);
+    return o.renderer = y.renderer, o.visible = !0, `Predominance renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (p) {
+    return `Error applying predominance renderer: ${p instanceof Error ? p.message : String(p)}`;
+  }
+}
+async function we({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  includeSize: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await fe({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    includeSize: t
+  });
+}
+const be = s.object({
+  layerId: s.string().describe("The id of the layer to apply the predominance renderer to"),
+  fields: s.array(s.string()).describe("The fields to use for the predominance renderer (competing categories)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  includeSize: s.boolean().optional().describe("Whether to include size visualization (predominance-size)")
+}), yr = m(we, {
+  name: "predominance",
+  description: `Label: Predominant category
+    Description: Compare attributes that share a common subject and unit of measurement to see which has the highest value.
+    Keywords: predominant, winner, won, competing, most, most common, most frequent, dominant, prevalent, top
+    Example: Using fields for Corn Acres, Wheat Acres, and Cotton Acres, show the predominant crop harvested in each area.
+    Fields: This style relies on 2-10 number fields.
+
+    Label: Predominant category and Size
+    Description: Compare attributes that share a common subject and unit of measurement to see which has the highest value. Also varies the size of each symbol based on the total of all categories.
+    Keywords: predominant, winner, won, competing, most, most common, most frequent, dominant, prevalent, top, amount, total, how much, proportional size, graduated size, sum
+    Example: Show the predominant crop in each area and vary the size of each symbol based on the total of all categories.
+    Fields: This style relies on 2-10 number fields.`,
+  schema: be
+});
+function Se(e) {
+  const { fields: i, layer: r, view: t, colorSchemeTags: a } = e;
+  let n;
+  const l = {
+    field: i[0]
+  }, o = {
+    field: i[1]
+  };
+  return a && (n = A({
+    geometryType: r.geometryType,
+    includedTags: a
+  })[0]), {
+    layer: r,
+    view: t,
+    field1: l,
+    field2: o,
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    relationshipScheme: n
+  };
+}
+async function Te(e) {
+  return await V(e);
+}
+async function ze({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a
+}) {
+  const n = i, l = e?.allLayers.find((d) => d.id === r);
+  if (!l)
+    return `Could not find layer for id: ${r}`;
+  const o = {
+    styleName: "relationship",
+    fields: t,
+    layer: l,
+    view: n,
+    colorSchemeTags: a
+  };
+  try {
+    const d = Se(o), c = await Te(d);
+    return l.renderer = c.renderer, l.visible = !0, `Relationship renderer applied to layer: ${l.title ?? l.id} using fields ${t.join(", ")}`;
+  } catch (d) {
+    return `Error applying relationship renderer: ${d instanceof Error ? d.message : String(d)}`;
+  }
+}
+async function Re({
+  layerId: e,
+  fields: i,
+  colorSchemes: r
+}, t) {
+  const { mapView: a } = u(t);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, t), await ze({
+    arcgisMap: a.map,
+    arcgisMapView: a,
+    layerId: e,
+    fields: i,
+    colorSchemes: r
+  });
+}
+const ve = s.object({
+  layerId: s.string().describe("The id of the layer to apply the relationship renderer to"),
+  fields: s.array(s.string()).describe("The two fields to use for the relationship renderer (bivariate visualization)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use")
+}), gr = m(Re, {
+  name: "relationship",
+  description: `Label: Relationship
+    Description: Overlays two color ramps to represent the relationship between two numeric attributes.
+    Keywords: relationship, correlation, compare, related, bivariate choropleth, bivariate color
+    Example: Show the relationship between tree height and carbon storage
+    Fields: This style requires two number fields.`,
+  schema: ve
+});
+function Ce(e) {
+  const { fields: i, layer: r, view: t, theme: a } = e, n = i[0];
+  return {
+    layer: r,
+    view: t,
+    startTime: n,
+    endTime: /* @__PURE__ */ new Date(),
+    theme: a,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0
+  };
+}
+async function $e(e) {
+  return await L(e);
+}
+async function Ee({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  theme: n
+}) {
+  const l = i, o = e?.allLayers.find((c) => c.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const d = {
+    styleName: "size-age",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a,
+    theme: n
+  };
+  try {
+    const c = Ce(d), p = await $e(c);
+    return o.renderer = p.renderer, o.visible = !0, `Size-age renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (c) {
+    return `Error applying size-age renderer: ${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function Oe({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  theme: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await Ee({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    theme: t
+  });
+}
+const De = s.object({
+  layerId: s.string().describe("The id of the layer to apply the size-age renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the size-age renderer (temporal data with size)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("Optional theme for the size ramp")
+}), fr = m(Oe, {
+  name: "size-age",
+  description: `Label: Age (size)
+    Description: Vary symbol sizes along a continuous ramp to represent the age of features. Age reflects the length of time from a start date to an end date.
+    Keywords: since, age, how old, how long
+    Example: Change the size of features so older features are larger than new features.
+    Fields: This style requires at least one field with a date type.`,
+  schema: De
+});
+function Pe(e) {
+  const { fields: i, layer: r, view: t } = e;
+  let { theme: a } = e, n = i[1];
+  const l = i[0];
+  return {
+    layer: r,
+    view: t,
+    field: l,
+    normalizationField: n,
+    theme: a,
+    sizeOptimizationEnabled: !0,
+    outlineOptimizationEnabled: !0
+  };
+}
+async function Ve(e) {
+  return await M(e);
+}
+async function Ae({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  theme: n
+}) {
+  const l = i, o = e?.allLayers.find((c) => c.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const d = {
+    styleName: "size",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a,
+    theme: n
+  };
+  try {
+    const c = Pe(d), p = await Ve(c);
+    return o.renderer = p.renderer, o.visible = !0, `Size renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (c) {
+    return `Error applying size renderer: ${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function Le({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  theme: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await Ae({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    theme: t
+  });
+}
+const Me = s.object({
+  layerId: s.string().describe("The id of the layer to apply the size renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the size renderer (numeric data)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("Optional theme for the size ramp")
+}), wr = m(Le, {
+  name: "size",
+  description: `Label: Counts and Amounts (size)
+    Description: Vary symbol sizes along a continuous ramp to represent numeric or ranked data.
+    Keywords: graduated size, proportional size, how much, total, number, amount, size
+    Example: Vary the size of each point based on the total population.
+    Fields: This style requires a single field with a number type. A second number field may be specified for normalizing the value of the first field.
+
+    Label: Continuous Timeline (size)
+    Description: Vary symbol sizes along a continuous ramp to represent dates.
+    Keywords: graduated size, proportional size, classed size, how much, total, number, when
+    Example: Vary the size of each feature based on the date a ticket was completed.
+    Fields: This style requires a single field with a date type.`,
+  schema: Me
+});
+function xe(e) {
+  const { fields: i, layer: r, view: t, colorSchemeTags: a } = e, n = i[0], l = i[1], o = i[2];
+  let d;
+  return a && (d = j({
+    geometryType: r.geometryType,
+    includedTags: a
+  })[0]), {
+    layer: r,
+    view: t,
+    field: n,
+    field2: l,
+    field3: o,
+    outlineOptimizationEnabled: !0,
+    sizeOptimizationEnabled: !0,
+    typeScheme: d
+  };
+}
+async function je(e) {
+  return await x(e);
+}
+async function Fe({
+  arcgisMap: e,
+  arcgisMapView: i,
+  layerId: r,
+  fields: t,
+  colorSchemes: a,
+  theme: n
+}) {
+  const l = i, o = e?.allLayers.find((c) => c.id === r);
+  if (!o)
+    return `Could not find layer for id: ${r}`;
+  const d = {
+    styleName: "type",
+    fields: t,
+    layer: o,
+    view: l,
+    colorSchemeTags: a,
+    theme: n
+  };
+  try {
+    const c = xe(d), p = await je(c);
+    return o.renderer = p.renderer, o.visible = !0, `Type renderer applied to layer: ${o.title ?? o.id} using fields ${t.join(", ")}`;
+  } catch (c) {
+    return `Error applying type renderer: ${c instanceof Error ? c.message : String(c)}`;
+  }
+}
+async function qe({
+  layerId: e,
+  fields: i,
+  colorSchemes: r,
+  theme: t
+}, a) {
+  const { mapView: n } = u(a);
+  return await h({ type: "show-legend", data: { layerIds: [e] } }, a), await Fe({
+    arcgisMap: n.map,
+    arcgisMapView: n,
+    layerId: e,
+    fields: i,
+    colorSchemes: r,
+    theme: t
+  });
+}
+const Ke = s.object({
+  layerId: s.string().describe("The id of the layer to apply the type renderer to"),
+  fields: s.array(s.string()).describe("The field(s) to use for the type renderer (categorical data)"),
+  colorSchemes: s.array(s.string()).optional().describe("Optional color scheme tags to use"),
+  theme: s.enum(["above-and-below", "above", "below", "centered-on", "extremes", "high-to-low"]).optional().describe("Optional theme for the color scheme")
+}), br = m(qe, {
+  name: "type",
+  description: `Label: Types (unique symbols)
+Description: Represent features as categories with different symbol colors or shapes. Examples include type of tree, road class, or province name.
+Keywords: categorical, category, type, unique, discrete, point of interest, region, group
+Example: Color each feature based on the region it belongs to
+Fields: This style requires a single field which may be a string, number, or date type. It is usually a string.`,
+  schema: Ke
+}), Sr = g.Root({
+  ...q(),
+  vectorSearchLayerIds: g(),
+  vectorSearchFieldResults: g(),
+  layerFieldInfo: g(),
+  selectedLayerId: g()
+});
+export {
+  Sr as L,
+  cr as a,
+  dr as b,
+  pr as c,
+  mr as d,
+  hr as e,
+  ur as f,
+  yr as g,
+  gr as h,
+  fr as i,
+  wr as j,
+  br as k
+};