@carto/ps-react-ui 4.4.2 → 4.5.0

package/dist/types/widgets/stores/types.d.ts

@@ -29,6 +29,8 @@ export interface WidgetsStoreProps {
     registeredTools?: ToolRegistration[];
     /** Formatter function for widget values */
     formatter?: (value: number) => string;
+    /** Formatter function for widget label/category values */
+    labelFormatter?: (value: string | number) => string | number;
     /** Locale for number formatting (e.g., 'en-US', 'es-ES', 'fr-FR') */
     locale?: string;
 }

package/dist/types/widgets/stores/use-widget-selector.d.ts

@@ -0,0 +1,35 @@
+import { WidgetState } from './types';
+/**
+ * Scoped selector hook for reading a single widget's state from the store.
+ *
+ * Consolidates multiple `useWidgetStore(useShallow(...))` calls into a single
+ * subscription per component. The selector receives only this widget's state
+ * (or undefined if not yet registered), and uses shallow comparison to avoid
+ * re-renders when unrelated properties change.
+ *
+ * @param widgetId - The widget ID to subscribe to.
+ * @param selector - A function that extracts the needed properties from the widget state.
+ *   Must be a stable reference (inline arrow is fine due to useCallback wrapping).
+ *
+ * @example
+ * ```tsx
+ * // Before: 4 separate subscriptions
+ * const title = useWidgetStore(useShallow((s) => s.getWidget(id)?.title))
+ * const collapsed = useWidgetStore(useShallow((s) => s.getWidget(id)?.collapsed))
+ * const disabled = useWidgetStore(useShallow((s) => s.getWidget(id)?.disabled))
+ * const isFetching = useWidgetStore(useShallow((s) => s.getWidget(id)?.isFetching))
+ *
+ * // After: 1 subscription
+ * const { title, collapsed, disabled, isFetching } = useWidgetSelector(id, (w) => ({
+ *   title: w?.title, collapsed: w?.collapsed, disabled: w?.disabled, isFetching: w?.isFetching,
+ * }))
+ *
+ * // With extra dependencies (e.g., index prop):
+ * const value = useWidgetSelector(
+ *   id,
+ *   (w) => (w as MyState | undefined)?.data?.[index]?.value,
+ *   [index],
+ * )
+ * ```
+ */
+export declare function useWidgetSelector<T>(widgetId: string, selector: (widget: WidgetState | undefined) => T): T;

package/dist/types/widgets/stores/widget-store-performance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/widgets/stores/widget-store.d.ts

@@ -1,39 +1,61 @@
-import { WidgetStore } from './types';
+import { WidgetStore, WidgetStoreActions } from './types';
 /**
  * Zustand store for managing widget state across the application.
  *
- * This store provides centralized state management for all widget UI components
+ * Provides centralized state management for all widget UI components, including
+ * data/config transformation pipelines via registered tools.
  *
- * @example
+ * **Performance optimizations:**
+ * - `registerTool` skips the store update when structural properties (order, enabled,
+ *   type, disables) haven't changed — only `fn` and `config` are updated via direct
+ *   mutation, avoiding a new `registeredTools` array reference and WidgetLoader
+ *   pipeline cascades.
+ * - `setToolEnabled` skips the store update when the enabled state is already the
+ *   requested value.
+ * - `executeToolPipeline` / `executeConfigPipeline` skip the final `set()` when
+ *   the transformed data/config is referentially identical to what's already in the store.
+ * - Both pipelines support cancellation — newer executions for the same widget
+ *   automatically cancel in-progress ones.
+ *
+ * @example Reading widget state (prefer useWidgetSelector for performance)
  * ```tsx
- * // Import the store
- * import { useWidgetStore } from '@carto/ps-react-ui/widgets'
- *
- * // Use in a component
- * function MyWidget() {
- *   const setWidget = useWidgetStore((state) => state.setWidget)
- *   const widget = useWidgetStore((state) => state.widgets['my-widget'])
- *
- *   useEffect(() => {
- *     setWidget({
- *       id: 'my-widget',
- *       type: 'formula',
- *       title: 'Total Sales',
- *       isLoading: false,
- *       visible: true,
- *       data: { value: 1000, prefix: '$' }
- *     })
- *   }, [setWidget])
- *
- *   return <div>{widget?.data?.value}</div>
+ * import { useWidgetSelector } from '@carto/ps-react-ui/widgets'
+ *
+ * function MyWidget({ id }: { id: string }) {
+ *   const { title, data } = useWidgetSelector(id, (w) => ({
+ *     title: w?.title,
+ *     data: w?.data,
+ *   }))
+ *   return <div>{title}: {JSON.stringify(data)}</div>
  * }
  * ```
  *
- * @example
+ * @example Writing widget state
  * ```tsx
- * // Get widgets by type
- * const getWidgetsByType = useWidgetStore((state) => state.getWidgetsByType)
- * const formulaWidgets = getWidgetsByType('formula')
+ * import { widgetStoreActions } from '@carto/ps-react-ui/widgets'
+ *
+ * const { setWidget } = widgetStoreActions
+ * setWidget('my-widget', { type: 'formula', isLoading: false, data: { value: 1000 } })
  * ```
  */
 export declare const useWidgetStore: import('node_modules/zustand/esm/react.mjs').UseBoundStore<import('node_modules/zustand/esm/vanilla.mjs').StoreApi<WidgetStore>>;
+/**
+ * Stable references to store actions, accessible without creating a subscription.
+ *
+ * Use this instead of `useWidgetStore((state) => state.setWidget)` to avoid
+ * unnecessary subscriber evaluations. Actions are stable functions that never
+ * change, so subscribing to them wastes cycles on every store update.
+ *
+ * @example
+ * ```tsx
+ * import { widgetStoreActions } from '@carto/ps-react-ui/widgets'
+ *
+ * const { setWidget, registerTool } = widgetStoreActions
+ *
+ * useEffect(() => {
+ *   registerTool(id, { id: 'my-tool', order: 10, enabled: true, fn: (d) => d })
+ *   return () => widgetStoreActions.unregisterTool(id, 'my-tool')
+ * }, [id])
+ * ```
+ */
+export declare const widgetStoreActions: WidgetStoreActions;

package/dist/types/widgets/table/types.d.ts

@@ -75,7 +75,7 @@ export interface TableWidgetConfig {
     /** Enable row selection with checkboxes */
     selectable?: boolean;
     /** Currently selected row IDs */
-    selected: (string | number)[];
+    selected?: (string | number)[];
     /** Pagination and sort mode: local (client-side) or remote (server-side) */
     mode: Mode;
     /** Pagination configuration */

package/dist/types/widgets/utils/chart-config/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared utilities for chart widget configuration
  */
-export { defaultFormatter } from '../formatter';
+export { defaultFormatter, defaultLabelFormatter } from '../formatter';
 export { createChartWidgetConfig } from './config-factory';
 export type { ChartWidgetBaseConfig, CreateChartWidgetConfigParams, } from './config-factory';
 export { flattenObjectArrayToCSV, scatterplotDataToCSV } from './csv-modifiers';

package/dist/types/widgets/utils/chart-config/option-builders.d.ts

@@ -14,10 +14,15 @@ export declare function niceNum(value: number): number;
 /**
  * Builds standard legend configuration for chart widgets
  *
- * @param hasLegend - Whether to show the legend
+ * @param params - Legend configuration parameters
+ * @param params.hasLegend - Whether to show the legend
+ * @param params.labelFormatter - Optional formatter for legend item names
  * @returns Legend configuration object
  */
-export declare function buildLegendConfig(hasLegend: boolean): LegendComponentOption;
+export declare function buildLegendConfig({ hasLegend, labelFormatter, }: {
+    hasLegend: boolean;
+    labelFormatter?: (value: string | number) => string | number;
+}): LegendComponentOption;
 /**
  * Builds standard grid configuration with legend-aware spacing
  *
@@ -49,16 +54,16 @@ export declare function createTooltipPositioner(theme: Theme): (point: [number,
  */
 export declare function createAxisLabelFormatter(formatter?: (value: number) => string): ((value: number) => string) | undefined;
 /**
- * Applies formatter to xAxis configuration
- * Only applies to single axis objects (not arrays) with type 'value'
+ * Applies labelFormatter to xAxis configuration
+ * Applies to any xAxis regardless of axis type (category, value, etc.)
  *
  * @param xAxis - Existing xAxis configuration
- * @param formatter - Optional formatter function from widget config
- * @returns Updated xAxis configuration or undefined if no changes needed
+ * @param labelFormatter - Optional labelFormatter function from widget config
+ * @returns Updated xAxis configuration
  */
-export declare function applyXAxisFormatter(xAxis: unknown, formatter?: (value: number) => string): {
+export declare function applyXAxisFormatter(xAxis: unknown, formatter?: (value: string | number) => string | number): {
     axisLabel: {
-        formatter: ((value: number) => string) | undefined;
+        formatter: ((value: string | number) => string) | undefined;
     };
     type?: string;
 };

package/dist/types/widgets/utils/formatter.d.ts

@@ -1 +1,2 @@
 export declare const defaultFormatter: (value: number) => string;
+export declare const defaultLabelFormatter: (value: string | number) => string | number;

package/dist/types/widgets/utils/index.d.ts

@@ -1,4 +1,4 @@
-export { defaultFormatter } from './formatter';
+export { defaultFormatter, defaultLabelFormatter } from './formatter';
 export { createChartWidgetConfig } from './chart-config';
 export type { ChartWidgetBaseConfig, CreateChartWidgetConfigParams, } from './chart-config';
 export { flattenObjectArrayToCSV, scatterplotDataToCSV } from './chart-config';

package/dist/use-widget-ref-BFazQvJK.js

@@ -0,0 +1,22 @@
+import { c as l } from "react/compiler-runtime";
+import { useRef as c, useEffect as i } from "react";
+import { w as m } from "./widget-store-CIrb9RKP.js";
+function R(t) {
+  const e = l(4), n = c(null), s = c(null);
+  let o, r;
+  e[0] !== t ? (o = () => {
+    n.current && m.setWidget(t, {
+      refUI: n,
+      instance: s
+    });
+  }, r = [t], e[0] = t, e[1] = o, e[2] = r) : (o = e[1], r = e[2]), i(o, r);
+  let f;
+  return e[3] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel") ? (f = {
+    ref: n,
+    instance: s
+  }, e[3] = f) : f = e[3], f;
+}
+export {
+  R as u
+};
+//# sourceMappingURL=use-widget-ref-BFazQvJK.js.map

package/dist/use-widget-ref-BFazQvJK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-widget-ref-BFazQvJK.js","sources":["../src/hooks/use-widget-ref.ts"],"sourcesContent":["import { useEffect, useRef } from 'react'\nimport { widgetStoreActions } from '../widgets/stores/widget-store'\n\n/**\n * Registers a DOM element ref and an ECharts instance ref with the widget store.\n * This allows other parts of the application (e.g., screenshot export) to access the widget's DOM element.\n *\n * @param widgetId - The widget ID to register the refs under.\n * @returns An object with `ref` (DOM element) and `instance` (ECharts instance) refs.\n *\n * @example\n * ```tsx\n * function MyWidget({ id }: { id: string }) {\n *   const { ref } = useWidgetRef<HTMLDivElement>(id)\n *\n *   return <div ref={ref}>Widget content</div>\n * }\n * ```\n */\nexport function useWidgetRef<T extends HTMLElement = HTMLElement>(\n  widgetId: string,\n) {\n  const ref = useRef<T | null>(null)\n  const instance = useRef<echarts.ECharts | null>(null)\n\n  useEffect(() => {\n    if (ref.current) {\n      widgetStoreActions.setWidget(widgetId, { refUI: ref, instance: instance })\n    }\n  }, [widgetId])\n\n  return { ref, instance }\n}\n"],"names":["useWidgetRef","widgetId","$","_c","ref","useRef","instance","t0","t1","current","widgetStoreActions","setWidget","refUI","useEffect","t2","Symbol","for"],"mappings":";;;AAmBO,SAAAA,EAAAC,GAAA;AAAA,QAAAC,IAAAC,EAAA,CAAA,GAGLC,IAAYC,EAAiB,IAAI,GACjCC,IAAiBD,EAA+B,IAAI;AAAC,MAAAE,GAAAC;AAAA,EAAAN,SAAAD,KAE3CM,IAAAA,MAAA;AACR,IAAIH,EAAGK,WACLC,EAAkBC,UAAWV,GAAU;AAAA,MAAAW,OAASR;AAAAA,MAAGE,UAAAA;AAAAA,IAAAA,CAAsB;AAAA,EAC1E,GACAE,IAAA,CAACP,CAAQ,GAACC,OAAAD,GAAAC,OAAAK,GAAAL,OAAAM,MAAAD,IAAAL,EAAA,CAAA,GAAAM,IAAAN,EAAA,CAAA,IAJbW,EAAUN,GAIPC,CAAU;AAAC,MAAAM;AAAA,SAAAZ,EAAA,CAAA,MAAAa,uBAAAC,IAAA,2BAAA,KAEPF,IAAA;AAAA,IAAAV,KAAAA;AAAAA,IAAAE,UAAAA;AAAAA,EAAAA,GAAiBJ,OAAAY,KAAAA,IAAAZ,EAAA,CAAA,GAAjBY;AAAiB;"}

package/dist/use-widget-selector-DqRmWQ1K.js

@@ -0,0 +1,12 @@
+import { c as i } from "react/compiler-runtime";
+import { u as m } from "./widget-store-CIrb9RKP.js";
+import { useShallow as s } from "zustand/shallow";
+function a(r, e) {
+  const o = i(3);
+  let t;
+  return o[0] !== e || o[1] !== r ? (t = (u) => e(u.widgets[r]), o[0] = e, o[1] = r, o[2] = t) : t = o[2], m(s(t));
+}
+export {
+  a as u
+};
+//# sourceMappingURL=use-widget-selector-DqRmWQ1K.js.map

package/dist/use-widget-selector-DqRmWQ1K.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-widget-selector-DqRmWQ1K.js","sources":["../src/widgets/stores/use-widget-selector.ts"],"sourcesContent":["import { useWidgetStore } from './widget-store'\nimport type { WidgetState } from './types'\nimport { useShallow } from 'zustand/shallow'\n\n/**\n * Scoped selector hook for reading a single widget's state from the store.\n *\n * Consolidates multiple `useWidgetStore(useShallow(...))` calls into a single\n * subscription per component. The selector receives only this widget's state\n * (or undefined if not yet registered), and uses shallow comparison to avoid\n * re-renders when unrelated properties change.\n *\n * @param widgetId - The widget ID to subscribe to.\n * @param selector - A function that extracts the needed properties from the widget state.\n *   Must be a stable reference (inline arrow is fine due to useCallback wrapping).\n *\n * @example\n * ```tsx\n * // Before: 4 separate subscriptions\n * const title = useWidgetStore(useShallow((s) => s.getWidget(id)?.title))\n * const collapsed = useWidgetStore(useShallow((s) => s.getWidget(id)?.collapsed))\n * const disabled = useWidgetStore(useShallow((s) => s.getWidget(id)?.disabled))\n * const isFetching = useWidgetStore(useShallow((s) => s.getWidget(id)?.isFetching))\n *\n * // After: 1 subscription\n * const { title, collapsed, disabled, isFetching } = useWidgetSelector(id, (w) => ({\n *   title: w?.title, collapsed: w?.collapsed, disabled: w?.disabled, isFetching: w?.isFetching,\n * }))\n *\n * // With extra dependencies (e.g., index prop):\n * const value = useWidgetSelector(\n *   id,\n *   (w) => (w as MyState | undefined)?.data?.[index]?.value,\n *   [index],\n * )\n * ```\n */\nexport function useWidgetSelector<T>(\n  widgetId: string,\n  selector: (widget: WidgetState | undefined) => T,\n): T {\n  return useWidgetStore(\n    useShallow((state: { widgets: Record<string, WidgetState> }) =>\n      selector(state.widgets[widgetId]),\n    ),\n  )\n}\n"],"names":["useWidgetSelector","widgetId","selector","$","_c","t0","state","widgets","useWidgetStore","useShallow"],"mappings":";;;AAqCO,SAAAA,EAAAC,GAAAC,GAAA;AAAA,QAAAC,IAAAC,EAAA,CAAA;AAAA,MAAAC;AAAA,SAAAF,EAAA,CAAA,MAAAD,KAAAC,SAAAF,KAKQI,IAAAC,CAAAA,MACTJ,EAASI,EAAKC,QAASN,CAAQ,CAAC,GAACE,OAAAD,GAAAC,OAAAF,GAAAE,OAAAE,KAAAA,IAAAF,EAAA,CAAA,GAF9BK,EACLC,EAAWJ,CAEX,CACF;AAAC;"}

package/dist/widget-store-CIrb9RKP.js

@@ -0,0 +1,263 @@
+import { create as y } from "zustand";
+const b = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), u = y()((T, p) => ({
+  // State
+  widgets: {},
+  // Actions
+  /** Merges partial state into the widget entry. Creates the widget if it doesn't exist. */
+  setWidget: (e, o) => {
+    T((s) => {
+      const t = s.widgets[e] ?? {};
+      return {
+        widgets: {
+          ...s.widgets,
+          [e]: {
+            ...t,
+            ...o,
+            id: e
+          }
+        }
+      };
+    });
+  },
+  removeWidget: (e) => T((o) => {
+    const s = {
+      ...o.widgets
+    };
+    return delete s[e], {
+      widgets: s
+    };
+  }),
+  clearWidgets: () => T({
+    widgets: {}
+  }),
+  getWidget: (e) => p().widgets[e],
+  /**
+   * Registers a transformation tool for a widget's data or config pipeline.
+   *
+   * **No-op optimization:** When a tool with the same `id` already exists and its
+   * structural properties (`order`, `enabled`, `type`, `disables`) are unchanged,
+   * only `fn` and `config` are updated via direct mutation — no store update is
+   * triggered. This allows action components to include all reactive dependencies
+   * in their `useEffect` arrays without causing WidgetLoader pipeline cascades.
+   */
+  registerTool: (e, o) => {
+    const t = p().widgets[e]?.registeredTools?.find((n) => n.id === o.id);
+    if (t?.order === o.order && t.enabled === o.enabled && t.type === o.type && t.disables === o.disables) {
+      t.fn = o.fn, o.config && (t.config = o.config);
+      return;
+    }
+    T((n) => {
+      const g = n.widgets[e] ?? {}, c = (g.registeredTools ?? []).filter((f) => f.id !== o.id);
+      return {
+        widgets: {
+          ...n.widgets,
+          [e]: {
+            ...g,
+            id: e,
+            registeredTools: [...c, o]
+          }
+        }
+      };
+    });
+  },
+  unregisterTool: (e, o) => T((s) => {
+    const t = s.widgets[e];
+    if (!t) return s;
+    const g = (t.registeredTools ?? []).filter((d) => d.id !== o);
+    return {
+      widgets: {
+        ...s.widgets,
+        [e]: {
+          ...t,
+          registeredTools: g
+        }
+      }
+    };
+  }),
+  updateToolConfig: (e, o, s) => T((t) => {
+    const n = t.widgets[e];
+    if (!n) return t;
+    const d = (n.registeredTools ?? []).map((c) => c.id === o ? {
+      ...c,
+      config: {
+        ...c.config,
+        ...s
+      }
+    } : c);
+    return {
+      widgets: {
+        ...t.widgets,
+        [e]: {
+          ...n,
+          registeredTools: d
+        }
+      }
+    };
+  }),
+  /**
+   * Updates a tool's enabled state.
+   *
+   * **No-op optimization:** Skips the store update if the tool already has the
+   * requested enabled value.
+   */
+  setToolEnabled: (e, o, s) => {
+    const t = p().widgets[e];
+    t && t.registeredTools?.find((g) => g.id === o)?.enabled === s || T((n) => {
+      const g = n.widgets[e];
+      if (!g) return n;
+      const c = (g.registeredTools ?? []).map((f) => f.id === o ? {
+        ...f,
+        enabled: s
+      } : f);
+      return {
+        widgets: {
+          ...n.widgets,
+          [e]: {
+            ...g,
+            registeredTools: c
+          }
+        }
+      };
+    });
+  },
+  /**
+   * Executes the data transformation pipeline for a widget.
+   *
+   * Filters to enabled data-type tools (respecting `disables`), sorts by `order`,
+   * and chains their `fn` calls. Supports async tools.
+   *
+   * **Cancellation:** Newer executions for the same widget automatically cancel
+   * in-progress ones via a version counter.
+   *
+   * **No-op optimization:** Skips the final `set()` if the transformed data is
+   * referentially identical (`Object.is`) to what's already in the store.
+   */
+  executeToolPipeline: async (e, o) => {
+    const s = p().widgets[e];
+    if (!s) return;
+    const t = (b.get(e) ?? 0) + 1;
+    b.set(e, t);
+    const n = s, g = /* @__PURE__ */ new Set();
+    for (const i of n.registeredTools ?? [])
+      i.enabled && i.disables && i.disables.forEach((l) => g.add(l));
+    const d = [...n.registeredTools ?? []].filter((i) => (i.type ?? "data") === "data" && i.enabled && !g.has(i.id)).sort((i, l) => i.order - l.order);
+    let c = o;
+    for (const i of d) {
+      if (b.get(e) !== t)
+        return;
+      try {
+        c = await i.fn(c, i.config);
+      } catch (l) {
+        console.error(`Tool ${i.id} failed for widget ${e}:`, l);
+      }
+    }
+    const f = p().widgets[e];
+    if (f && Object.is(f.data, c)) {
+      b.get(e) === t && b.delete(e);
+      return;
+    }
+    T((i) => {
+      const l = i.widgets[e];
+      return l ? {
+        widgets: {
+          ...i.widgets,
+          [e]: {
+            ...l,
+            data: c
+          }
+        }
+      } : i;
+    }), b.get(e) === t && b.delete(e);
+  },
+  /**
+   * Executes the config transformation pipeline for a widget.
+   *
+   * Filters to enabled config-type tools (respecting `disables`), sorts by `order`,
+   * and chains their `fn` calls. The transformed config is spread into the widget state.
+   *
+   * **Cancellation:** Newer executions for the same widget automatically cancel
+   * in-progress ones via a version counter.
+   *
+   * **No-op optimization:** Skips the final `set()` when the config object is unchanged
+   * and all its properties already match what's in the store.
+   */
+  executeConfigPipeline: async (e, o) => {
+    const s = p().widgets[e];
+    if (!s) return;
+    const t = (w.get(e) ?? 0) + 1;
+    w.set(e, t);
+    const n = /* @__PURE__ */ new Set();
+    for (const r of s.registeredTools ?? [])
+      r.enabled && r.disables && r.disables.forEach((a) => n.add(a));
+    const g = [...s.registeredTools ?? []].filter((r) => r.type === "config" && r.enabled && !n.has(r.id)).sort((r, a) => r.order - a.order);
+    let d = o;
+    for (const r of g) {
+      if (w.get(e) !== t)
+        return;
+      try {
+        d = await r.fn(d, r.config);
+      } catch (a) {
+        console.error(`Config tool ${r.id} failed for widget ${e}:`, a);
+      }
+    }
+    const c = o, f = d, i = p().widgets[e], l = i?._lastConfig, W = {};
+    for (const r of Object.keys(f)) {
+      const a = !Object.is(f[r], c[r]), C = !l || !(r in l), m = !C && Object.is(i[r], l[r]);
+      (a || C || m) && (W[r] = f[r]);
+    }
+    const S = Object.keys(W).some((r) => !Object.is(i?.[r], W[r])), h = !Object.is(d, l);
+    if (!S && !h) {
+      w.get(e) === t && w.delete(e);
+      return;
+    }
+    T((r) => {
+      const a = r.widgets[e];
+      return a ? {
+        widgets: {
+          ...r.widgets,
+          [e]: {
+            ...a,
+            ...W,
+            _lastConfig: d
+          }
+        }
+      } : r;
+    }), w.get(e) === t && w.delete(e);
+  }
+})), P = {
+  get setWidget() {
+    return u.getState().setWidget;
+  },
+  get removeWidget() {
+    return u.getState().removeWidget;
+  },
+  get clearWidgets() {
+    return u.getState().clearWidgets;
+  },
+  get getWidget() {
+    return u.getState().getWidget;
+  },
+  get registerTool() {
+    return u.getState().registerTool;
+  },
+  get unregisterTool() {
+    return u.getState().unregisterTool;
+  },
+  get updateToolConfig() {
+    return u.getState().updateToolConfig;
+  },
+  get setToolEnabled() {
+    return u.getState().setToolEnabled;
+  },
+  get executeToolPipeline() {
+    return u.getState().executeToolPipeline;
+  },
+  get executeConfigPipeline() {
+    return u.getState().executeConfigPipeline;
+  }
+};
+export {
+  u,
+  P as w
+};
+//# sourceMappingURL=widget-store-CIrb9RKP.js.map

package/dist/widget-store-CIrb9RKP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-store-CIrb9RKP.js","sources":["../src/widgets/stores/widget-store.ts"],"sourcesContent":["import { create } from 'zustand'\nimport type {\n  WidgetState,\n  WidgetStore,\n  ToolRegistration,\n  WidgetStoreActions,\n} from './types'\n\n// Track active pipeline executions for cancellation\nconst activePipelines = new Map<string, number>()\nconst activeConfigPipelines = new Map<string, number>()\n\n/**\n * Zustand store for managing widget state across the application.\n *\n * Provides centralized state management for all widget UI components, including\n * data/config transformation pipelines via registered tools.\n *\n * **Performance optimizations:**\n * - `registerTool` skips the store update when structural properties (order, enabled,\n *   type, disables) haven't changed — only `fn` and `config` are updated via direct\n *   mutation, avoiding a new `registeredTools` array reference and WidgetLoader\n *   pipeline cascades.\n * - `setToolEnabled` skips the store update when the enabled state is already the\n *   requested value.\n * - `executeToolPipeline` / `executeConfigPipeline` skip the final `set()` when\n *   the transformed data/config is referentially identical to what's already in the store.\n * - Both pipelines support cancellation — newer executions for the same widget\n *   automatically cancel in-progress ones.\n *\n * @example Reading widget state (prefer useWidgetSelector for performance)\n * ```tsx\n * import { useWidgetSelector } from '@carto/ps-react-ui/widgets'\n *\n * function MyWidget({ id }: { id: string }) {\n *   const { title, data } = useWidgetSelector(id, (w) => ({\n *     title: w?.title,\n *     data: w?.data,\n *   }))\n *   return <div>{title}: {JSON.stringify(data)}</div>\n * }\n * ```\n *\n * @example Writing widget state\n * ```tsx\n * import { widgetStoreActions } from '@carto/ps-react-ui/widgets'\n *\n * const { setWidget } = widgetStoreActions\n * setWidget('my-widget', { type: 'formula', isLoading: false, data: { value: 1000 } })\n * ```\n */\nexport const useWidgetStore = create<WidgetStore>()((set, get) => ({\n  // State\n  widgets: {},\n\n  // Actions\n\n  /** Merges partial state into the widget entry. Creates the widget if it doesn't exist. */\n  setWidget: (id, widget) => {\n    set((state) => {\n      const prev = state.widgets[id] ?? ({} as WidgetStore['widgets'][string])\n      return {\n        widgets: {\n          ...state.widgets,\n          [id]: {\n            ...prev,\n            ...widget,\n            id,\n          },\n        },\n      }\n    })\n  },\n\n  removeWidget: (id) =>\n    set((state) => {\n      const widgets = { ...state.widgets }\n\n      delete widgets[id]\n\n      return { widgets }\n    }),\n\n  clearWidgets: () =>\n    set({\n      widgets: {},\n    }),\n\n  getWidget: <T extends WidgetState>(id: string) => {\n    return get().widgets[id] as T | undefined\n  },\n\n  /**\n   * Registers a transformation tool for a widget's data or config pipeline.\n   *\n   * **No-op optimization:** When a tool with the same `id` already exists and its\n   * structural properties (`order`, `enabled`, `type`, `disables`) are unchanged,\n   * only `fn` and `config` are updated via direct mutation — no store update is\n   * triggered. This allows action components to include all reactive dependencies\n   * in their `useEffect` arrays without causing WidgetLoader pipeline cascades.\n   */\n  registerTool: (widgetId: string, tool: ToolRegistration) => {\n    const current = get().widgets[widgetId]\n    const existingTool = current?.registeredTools?.find(\n      (t: ToolRegistration) => t.id === tool.id,\n    )\n\n    // No-op: structural properties unchanged — update fn/config via direct mutation.\n    // Safe because fn and config are only consumed imperatively during pipeline execution.\n    if (\n      existingTool?.order === tool.order &&\n      existingTool.enabled === tool.enabled &&\n      existingTool.type === tool.type &&\n      existingTool.disables === tool.disables\n    ) {\n      existingTool.fn = tool.fn\n      if (tool.config) existingTool.config = tool.config\n      return\n    }\n\n    set((state) => {\n      const widget = state.widgets[widgetId] ?? ({} as WidgetState)\n      const registeredTools = widget.registeredTools ?? []\n\n      // Remove existing tool with same id if present\n      const filteredTools = registeredTools.filter(\n        (t: ToolRegistration) => t.id !== tool.id,\n      )\n\n      return {\n        widgets: {\n          ...state.widgets,\n          [widgetId]: {\n            ...widget,\n            id: widgetId,\n            registeredTools: [...filteredTools, tool],\n          },\n        },\n      }\n    })\n  },\n\n  unregisterTool: (widgetId: string, toolId: string) =>\n    set((state) => {\n      const current = state.widgets[widgetId]\n      if (!current) return state\n\n      const registeredTools = current.registeredTools ?? []\n      const filteredTools = registeredTools.filter(\n        (t: ToolRegistration) => t.id !== toolId,\n      )\n\n      return {\n        widgets: {\n          ...state.widgets,\n          [widgetId]: {\n            ...current,\n            registeredTools: filteredTools,\n          },\n        },\n      }\n    }),\n\n  updateToolConfig: (\n    widgetId: string,\n    toolId: string,\n    config: Record<string, unknown>,\n  ) =>\n    set((state) => {\n      const current = state.widgets[widgetId]\n      if (!current) return state\n\n      const registeredTools = current.registeredTools ?? []\n      const updatedTools = registeredTools.map((tool: ToolRegistration) =>\n        tool.id === toolId\n          ? {\n              ...tool,\n              config: { ...tool.config, ...config },\n            }\n          : tool,\n      )\n\n      return {\n        widgets: {\n          ...state.widgets,\n          [widgetId]: {\n            ...current,\n            registeredTools: updatedTools,\n          },\n        },\n      }\n    }),\n\n  /**\n   * Updates a tool's enabled state.\n   *\n   * **No-op optimization:** Skips the store update if the tool already has the\n   * requested enabled value.\n   */\n  setToolEnabled: (widgetId: string, toolId: string, enabled: boolean) => {\n    const current = get().widgets[widgetId]\n    if (current) {\n      const tool = current.registeredTools?.find(\n        (t: ToolRegistration) => t.id === toolId,\n      )\n      if (tool?.enabled === enabled) return\n    }\n\n    set((state) => {\n      const widget = state.widgets[widgetId]\n      if (!widget) return state\n\n      const registeredTools = widget.registeredTools ?? []\n      const updatedTools = registeredTools.map((tool: ToolRegistration) =>\n        tool.id === toolId ? { ...tool, enabled } : tool,\n      )\n\n      return {\n        widgets: {\n          ...state.widgets,\n          [widgetId]: {\n            ...widget,\n            registeredTools: updatedTools,\n          },\n        },\n      }\n    })\n  },\n\n  /**\n   * Executes the data transformation pipeline for a widget.\n   *\n   * Filters to enabled data-type tools (respecting `disables`), sorts by `order`,\n   * and chains their `fn` calls. Supports async tools.\n   *\n   * **Cancellation:** Newer executions for the same widget automatically cancel\n   * in-progress ones via a version counter.\n   *\n   * **No-op optimization:** Skips the final `set()` if the transformed data is\n   * referentially identical (`Object.is`) to what's already in the store.\n   */\n  executeToolPipeline: async (widgetId: string, sourceData: unknown) => {\n    const widget = get().widgets[widgetId]\n    if (!widget) return\n\n    // Cancel any in-progress pipeline for this widget\n    const currentExecution = (activePipelines.get(widgetId) ?? 0) + 1\n    activePipelines.set(widgetId, currentExecution)\n\n    const widgetWithTools = widget\n\n    // Build set of tool IDs that should be disabled\n    const disabledToolIds = new Set<string>()\n    for (const tool of widgetWithTools.registeredTools ?? []) {\n      if (tool.enabled && tool.disables) {\n        tool.disables.forEach((id) => disabledToolIds.add(id))\n      }\n    }\n\n    // Sort tools by order and filter enabled data-only tools, excluding disabled tools\n    const sortedTools = [...(widgetWithTools.registeredTools ?? [])]\n      .filter(\n        (tool) =>\n          (tool.type ?? 'data') === 'data' &&\n          tool.enabled &&\n          !disabledToolIds.has(tool.id),\n      )\n      .sort((a, b) => a.order - b.order)\n\n    // Execute pipeline - handle both sync and async tools\n    let transformedData = sourceData\n    for (const tool of sortedTools) {\n      // Check if this execution was cancelled\n      if (activePipelines.get(widgetId) !== currentExecution) {\n        return\n      }\n\n      try {\n        // Call tool function (may return Promise or direct value)\n        transformedData = await tool.fn(transformedData, tool.config)\n      } catch (error) {\n        // eslint-disable-next-line no-console\n        console.error(`Tool ${tool.id} failed for widget ${widgetId}:`, error)\n        // Continue with current data to prevent one tool from breaking all\n      }\n    }\n\n    // Skip store update if data hasn't changed (e.g., passthrough pipeline with no tools)\n    const widgetAfter = get().widgets[widgetId]\n    if (widgetAfter && Object.is(widgetAfter.data, transformedData)) {\n      if (activePipelines.get(widgetId) === currentExecution) {\n        activePipelines.delete(widgetId)\n      }\n      return\n    }\n\n    // Single store update with final transformed data\n    set((state) => {\n      const currentWidget = state.widgets[widgetId]\n      if (!currentWidget) return state\n\n      return {\n        widgets: {\n          ...state.widgets,\n          [widgetId]: {\n            ...currentWidget,\n            data: transformedData,\n          },\n        },\n      }\n    })\n\n    // Clean up tracking\n    if (activePipelines.get(widgetId) === currentExecution) {\n      activePipelines.delete(widgetId)\n    }\n  },\n\n  /**\n   * Executes the config transformation pipeline for a widget.\n   *\n   * Filters to enabled config-type tools (respecting `disables`), sorts by `order`,\n   * and chains their `fn` calls. The transformed config is spread into the widget state.\n   *\n   * **Cancellation:** Newer executions for the same widget automatically cancel\n   * in-progress ones via a version counter.\n   *\n   * **No-op optimization:** Skips the final `set()` when the config object is unchanged\n   * and all its properties already match what's in the store.\n   */\n  executeConfigPipeline: async (widgetId: string, baseConfig: object) => {\n    const widget = get().widgets[widgetId]\n    if (!widget) return\n\n    // Cancel any in-progress config pipeline for this widget\n    const currentExecution = (activeConfigPipelines.get(widgetId) ?? 0) + 1\n    activeConfigPipelines.set(widgetId, currentExecution)\n\n    // Build set of tool IDs that should be disabled (cross-type disabling works)\n    const disabledToolIds = new Set<string>()\n    for (const tool of widget.registeredTools ?? []) {\n      if (tool.enabled && tool.disables) {\n        tool.disables.forEach((id) => disabledToolIds.add(id))\n      }\n    }\n\n    // Filter to config tools only, sort by order\n    const sortedTools = [...(widget.registeredTools ?? [])]\n      .filter(\n        (tool) =>\n          tool.type === 'config' &&\n          tool.enabled &&\n          !disabledToolIds.has(tool.id),\n      )\n      .sort((a, b) => a.order - b.order)\n\n    // Chain config tools\n    let transformedConfig: unknown = baseConfig\n    for (const tool of sortedTools) {\n      if (activeConfigPipelines.get(widgetId) !== currentExecution) {\n        return\n      }\n\n      try {\n        transformedConfig = await tool.fn(transformedConfig, tool.config)\n      } catch (error) {\n        // eslint-disable-next-line no-console\n        console.error(\n          `Config tool ${tool.id} failed for widget ${widgetId}:`,\n          error,\n        )\n      }\n    }\n\n    // Build a patch that only includes properties the pipeline should set.\n    // A property is applied when:\n    //   1. A config tool explicitly changed it (transformedConfig[k] !== baseConfig[k])\n    //   2. First pipeline run for this widget (no _lastConfig yet)\n    //   3. The widget value still matches what the pipeline last set — meaning the\n    //      user hasn't modified it via setWidget, so it's safe to overwrite.\n    // A property is SKIPPED when the widget value differs from _lastConfig,\n    // meaning the user (or a hook) changed it since the last pipeline run.\n    const base = baseConfig as Record<string, unknown>\n    const result = transformedConfig as Record<string, unknown>\n    const widgetNow = get().widgets[widgetId] as unknown as Record<\n      string,\n      unknown\n    >\n    const lastConfig = widgetNow?._lastConfig as\n      | Record<string, unknown>\n      | undefined\n\n    const patch: Record<string, unknown> = {}\n    for (const key of Object.keys(result)) {\n      const toolChanged = !Object.is(result[key], base[key])\n      const isFirstRun = !lastConfig || !(key in lastConfig)\n      const userUnmodified =\n        !isFirstRun && Object.is(widgetNow[key], lastConfig[key])\n\n      if (toolChanged || isFirstRun || userUnmodified) {\n        patch[key] = result[key]\n      }\n    }\n\n    // Skip store update if every patch value already matches the widget\n    const hasChanges = Object.keys(patch).some(\n      (k) => !Object.is(widgetNow?.[k], patch[k]),\n    )\n    const configRefChanged = !Object.is(transformedConfig, lastConfig)\n\n    if (!hasChanges && !configRefChanged) {\n      if (activeConfigPipelines.get(widgetId) === currentExecution) {\n        activeConfigPipelines.delete(widgetId)\n      }\n      return\n    }\n\n    // Apply the patch and store the pipeline output for next run's comparison\n    set((state) => {\n      const currentWidget = state.widgets[widgetId]\n      if (!currentWidget) return state\n\n      return {\n        widgets: {\n          ...state.widgets,\n          [widgetId]: {\n            ...currentWidget,\n            ...patch,\n            _lastConfig: transformedConfig,\n          },\n        },\n      }\n    })\n\n    if (activeConfigPipelines.get(widgetId) === currentExecution) {\n      activeConfigPipelines.delete(widgetId)\n    }\n  },\n}))\n\n/**\n * Stable references to store actions, accessible without creating a subscription.\n *\n * Use this instead of `useWidgetStore((state) => state.setWidget)` to avoid\n * unnecessary subscriber evaluations. Actions are stable functions that never\n * change, so subscribing to them wastes cycles on every store update.\n *\n * @example\n * ```tsx\n * import { widgetStoreActions } from '@carto/ps-react-ui/widgets'\n *\n * const { setWidget, registerTool } = widgetStoreActions\n *\n * useEffect(() => {\n *   registerTool(id, { id: 'my-tool', order: 10, enabled: true, fn: (d) => d })\n *   return () => widgetStoreActions.unregisterTool(id, 'my-tool')\n * }, [id])\n * ```\n */\nexport const widgetStoreActions: WidgetStoreActions = {\n  get setWidget() {\n    return useWidgetStore.getState().setWidget\n  },\n  get removeWidget() {\n    return useWidgetStore.getState().removeWidget\n  },\n  get clearWidgets() {\n    return useWidgetStore.getState().clearWidgets\n  },\n  get getWidget() {\n    return useWidgetStore.getState().getWidget\n  },\n  get registerTool() {\n    return useWidgetStore.getState().registerTool\n  },\n  get unregisterTool() {\n    return useWidgetStore.getState().unregisterTool\n  },\n  get updateToolConfig() {\n    return useWidgetStore.getState().updateToolConfig\n  },\n  get setToolEnabled() {\n    return useWidgetStore.getState().setToolEnabled\n  },\n  get executeToolPipeline() {\n    return useWidgetStore.getState().executeToolPipeline\n  },\n  get executeConfigPipeline() {\n    return useWidgetStore.getState().executeConfigPipeline\n  },\n} as WidgetStoreActions\n"],"names":["activePipelines","Map","activeConfigPipelines","useWidgetStore","create","set","get","widgets","setWidget","id","widget","state","prev","removeWidget","clearWidgets","getWidget","registerTool","widgetId","tool","existingTool","registeredTools","find","t","order","enabled","type","disables","fn","config","filteredTools","filter","unregisterTool","toolId","current","updateToolConfig","updatedTools","map","setToolEnabled","executeToolPipeline","sourceData","currentExecution","widgetWithTools","disabledToolIds","Set","forEach","add","sortedTools","has","sort","a","b","transformedData","error","console","widgetAfter","Object","is","data","delete","currentWidget","executeConfigPipeline","baseConfig","transformedConfig","base","result","widgetNow","lastConfig","_lastConfig","patch","key","keys","toolChanged","isFirstRun","userUnmodified","hasChanges","some","k","configRefChanged","widgetStoreActions","getState"],"mappings":"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"}