@grafana/scenes 8.17.0 → 8.18.0

package/dist/index.js

@@ -4805,10 +4805,35 @@ SceneDataLayerSet.Component = ({ model }) => {
   return /* @__PURE__ */ React__default.default.createElement(React__default.default.Fragment, null, layers.map((layer) => /* @__PURE__ */ React__default.default.createElement(layer.Component, { model: layer, key: layer.state.key })));
 };
 
+function isSystemTransformationsProvider(o) {
+  return typeof o === "object" && o !== null && "isSystemTransformationsProvider" in o;
+}
+function toSystemTransformation(transformation, position, origin) {
+  if (typeof transformation === "function") {
+    return { operator: transformation, topic: data.DataTopic.Series, origin, position };
+  }
+  return { ...transformation, origin, position };
+}
+function freezeResolved(resolved) {
+  Object.freeze(resolved.prepend);
+  Object.freeze(resolved.append);
+  return Object.freeze(resolved);
+}
+
+const NO_SERIES = [];
+const NO_SYSTEM_TRANSFORMATIONS = { prepend: [], append: [] };
+freezeResolved(NO_SYSTEM_TRANSFORMATIONS);
+Object.freeze(NO_SERIES);
+
 class SceneDataTransformer extends SceneObjectBase {
   constructor(state) {
     super(state);
     this._results = new rxjs.ReplaySubject(1);
+    /**
+     * Whether a previous activation already ran a pass, which is what makes the provider found on this one a
+     * *change* rather than a first discovery. Not carried over by clone, unlike `_prevDataFromSource`.
+     */
+    this._hasActivatedBefore = false;
     /**
      * Scan transformations for variable usage and re-process transforms when a variable values change
      */
@@ -4824,15 +4849,50 @@ class SceneDataTransformer extends SceneObjectBase {
   activationHandler() {
     const sourceData = this.getSourceData();
     this._subs.add(sourceData.subscribeToState((state) => this.transform(state.data)));
+    const providerChanged = this._discoverProvider();
     if (sourceData.state.data) {
-      this.transform(sourceData.state.data);
+      this.transform(sourceData.state.data, providerChanged);
     }
+    this._hasActivatedBefore = true;
     return () => {
       if (this._transformSub) {
         this._transformSub.unsubscribe();
       }
     };
   }
+  /**
+   * Checks the parent for system transformation provider.
+   * Reports whether what the pipeline should run has changed since the last pass, so the caller can force one.
+   */
+  _discoverProvider() {
+    const previous = this._provider;
+    const provider = this.parent;
+    if (!isSystemTransformationsProvider(provider)) {
+      this._provider = void 0;
+      this._resolvedSystem = void 0;
+      return this._hasActivatedBefore && previous !== void 0;
+    }
+    this._provider = provider;
+    this._resolvedSystem = void 0;
+    if (this._hasActivatedBefore && previous !== provider) {
+      return true;
+    }
+    return this._systemChangedSinceLastPass();
+  }
+  /**
+   * Whether the provider resolves to something other than what the last pass ran.
+   *
+   * The provider instance being unchanged is not enough to conclude the pipeline is unchanged: nothing
+   * was watching while this was inactive, so a plugin that finished importing in that window resolves
+   * differently now. Source frames usually survive a re-activation unchanged, so without this the pass
+   * is skipped as already transformed and state.data keeps frames the reported pipeline never produced.
+   */
+  _systemChangedSinceLastPass() {
+    if (!this._lastPassSystem) {
+      return false;
+    }
+    return !lodash.isEqual(this._lastPassSystem, this.getResolvedSystemTransformations());
+  }
   getSourceData() {
     if (this.state.$data) {
       if (this.state.$data instanceof SceneDataLayerSet) {
@@ -4857,9 +4917,79 @@ class SceneDataTransformer extends SceneObjectBase {
     }
     return true;
   }
+  /**
+   * @internal
+   * Whether the pass behind the current state.data applied any system transformations. A provider that has
+   * stopped contributing still needs one more pass to take them back out.
+   */
+  hasAppliedSystemTransformations() {
+    const last = this._lastPassSystem;
+    return last !== void 0 && (last.prepend.length > 0 || last.append.length > 0);
+  }
   reprocessTransformations() {
+    this._resolvedSystem = void 0;
     this.transform(this.getSourceData().state.data, true);
   }
+  /**
+   * The system transformations for the given source frames.
+   * Public because provider output never reaches state, so this is the only way for readers
+   * (the transformations editor, the inspect data tab) to see what the pipeline is running.
+   */
+  getResolvedSystemTransformations(series) {
+    const provider = this._provider;
+    if (!provider) {
+      return NO_SYSTEM_TRANSFORMATIONS;
+    }
+    const frames = series != null ? series : this._sourceSeriesOrNone();
+    const memo = this._resolvedSystem;
+    if (memo && memo.series === frames) {
+      return memo.resolved;
+    }
+    const { prepend = [], append = [] } = this._resolveProvider(provider, frames);
+    const resolved = freezeResolved({
+      prepend: prepend.map((t) => toSystemTransformation(t, "prepend", provider.origin)),
+      append: append.map((t) => toSystemTransformation(t, "append", provider.origin))
+    });
+    this._resolvedSystem = { series: frames, resolved };
+    return resolved;
+  }
+  /**
+   * The source frames to resolve a provider against when the caller did not supply their own.
+   *
+   * Mirrors getSourceData's precondition: reading what is running must not throw for a transformer that is not wired.
+   * Since every VizPanel is a provider, a panel without `$data` would throw.
+   */
+  _sourceSeriesOrNone() {
+    var _a, _b, _c;
+    if (!this.state.$data && !((_a = this.parent) == null ? void 0 : _a.parent)) {
+      return NO_SERIES;
+    }
+    return (_c = (_b = this.getSourceData().state.data) == null ? void 0 : _b.series) != null ? _c : NO_SERIES;
+  }
+  _resolveProvider(provider, series) {
+    var _a;
+    try {
+      return (_a = provider.getSystemTransformations({ series })) != null ? _a : {};
+    } catch (err) {
+      console.error(`Error resolving system transformations for origin '${provider.origin}': `, err);
+      return {};
+    }
+  }
+  /**
+   * The system transformations to run for the given source frames.
+   */
+  _systemTransformationsFor(series) {
+    return this._provider ? this.getResolvedSystemTransformations(series) : NO_SYSTEM_TRANSFORMATIONS;
+  }
+  /**
+   * Places the user configured transformations between the system tiers, in prepend, user, append order.
+   */
+  _withSystemTransformations(system, transformations) {
+    if (system.prepend.length === 0 && system.append.length === 0) {
+      return transformations;
+    }
+    return [...system.prepend, ...transformations, ...system.append];
+  }
   /**
    * S3.1: Calculate transformation complexity metrics
    */
@@ -4894,6 +5024,7 @@ class SceneDataTransformer extends SceneObjectBase {
     const clone = super.clone(withState);
     if (this._prevDataFromSource) {
       clone["_prevDataFromSource"] = this._prevDataFromSource;
+      clone["_lastPassSystem"] = this._lastPassSystem;
     }
     return clone;
   }
@@ -4933,15 +5064,21 @@ class SceneDataTransformer extends SceneObjectBase {
     return false;
   }
   transform(data$1, force = false) {
-    var _a;
+    var _a, _b;
     const timestamp = performance.now();
     const profiler = findPanelProfiler(this);
     const transformStartTime = performance.now();
     let transformationId;
     let endTransformCallback = null;
-    if (this.state.transformations.length === 0 || !data$1) {
+    const system = data$1 ? this._systemTransformationsFor(data$1.series) : NO_SYSTEM_TRANSFORMATIONS;
+    const transformations = data$1 ? this._withSystemTransformations(system, this.state.transformations) : [];
+    if (transformations.length === 0 || !data$1) {
+      (_a = this._transformSub) == null ? void 0 : _a.unsubscribe();
       this._prevDataFromSource = data$1;
-      this.setState({ data: data$1 });
+      this._lastPassSystem = system;
+      if (data$1 !== this.state.data) {
+        this.setState({ data: data$1 });
+      }
       if (data$1) {
         this._results.next({ origin: this, data: data$1 });
       }
@@ -4951,7 +5088,7 @@ class SceneDataTransformer extends SceneObjectBase {
       return;
     }
     if (profiler) {
-      const transformationTypes = this.state.transformations.map((t) => {
+      const transformationTypes = transformations.map((t) => {
         if ("id" in t) {
           return t.id;
         } else {
@@ -4959,10 +5096,13 @@ class SceneDataTransformer extends SceneObjectBase {
         }
       }).join("+");
       transformationId = transformationTypes || "no-transforms";
-      const metrics = this._calculateTransformationMetrics(data$1, this.state.transformations);
+      const metrics = this._calculateTransformationMetrics(data$1, transformations);
       endTransformCallback = profiler.onDataTransformStart(timestamp, transformationId, metrics);
     }
-    const interpolatedTransformations = this._interpolateVariablesInTransformationConfigs(data$1);
+    const interpolatedTransformations = this._withSystemTransformations(
+      system,
+      this._interpolateVariablesInTransformationConfigs(data$1, this.state.transformations)
+    );
     const seriesTransformations = this._filterAndPrepareTransformationsByTopic(
       interpolatedTransformations,
       (transformation) => {
@@ -4991,7 +5131,7 @@ class SceneDataTransformer extends SceneObjectBase {
       }
     };
     const seriesStream = data.transformDataFrame(seriesTransformations, data$1.series, ctx);
-    const annotationsStream = data.transformDataFrame(annotationsTransformations, (_a = data$1.annotations) != null ? _a : []);
+    const annotationsStream = data.transformDataFrame(annotationsTransformations, (_b = data$1.annotations) != null ? _b : []);
     let series = [];
     let annotations = [];
     this._transformSub = rxjs.forkJoin([seriesStream, annotationsStream]).pipe(
@@ -5042,21 +5182,21 @@ class SceneDataTransformer extends SceneObjectBase {
       this.setState({ data: transformedData });
       this._results.next({ origin: this, data: transformedData });
       this._prevDataFromSource = data$1;
+      this._lastPassSystem = system;
     });
   }
-  _interpolateVariablesInTransformationConfigs(data) {
+  _interpolateVariablesInTransformationConfigs(data, transformations) {
     var _a;
-    const transformations = this.state.transformations;
     if (this._variableDependency.getNames().size === 0) {
       return transformations;
     }
-    const onlyObjects = transformations.every((t) => typeof t === "object");
-    if (onlyObjects) {
+    const isInterpolatable = (t) => typeof t === "object" && !("operator" in t);
+    if (transformations.every(isInterpolatable)) {
       return JSON.parse(sceneGraph.interpolate(this, JSON.stringify(transformations), (_a = data.request) == null ? void 0 : _a.scopedVars));
     }
     return transformations.map((t) => {
       var _a2;
-      return typeof t === "object" ? JSON.parse(sceneGraph.interpolate(this, JSON.stringify(t), (_a2 = data.request) == null ? void 0 : _a2.scopedVars)) : t;
+      return isInterpolatable(t) ? JSON.parse(sceneGraph.interpolate(this, JSON.stringify(t), (_a2 = data.request) == null ? void 0 : _a2.scopedVars)) : t;
     });
   }
   _filterAndPrepareTransformationsByTopic(interpolatedTransformations, transformationFilter) {
@@ -5083,6 +5223,16 @@ class VizPanel extends SceneObjectBase {
       }
     });
     this._structureRev = 0;
+    /**
+     * @internal
+     * Marks this panel as a SystemTransformationsProvider; not for app code.
+     */
+    this.isSystemTransformationsProvider = true;
+    /**
+     * @internal
+     * Identifies this panel's tier in its data pipeline; not for app code.
+     */
+    this.origin = "plugin";
     this.onTimeRangeChange = (timeRange) => {
       const sceneTimeRange = sceneGraph.getTimeRange(this);
       sceneTimeRange.onTimeRangeChange({
@@ -5271,16 +5421,9 @@ class VizPanel extends SceneObjectBase {
       endPluginLoadCallback == null ? void 0 : endPluginLoadCallback(plugin, true);
       this._pluginLoaded(plugin, overwriteOptions, overwriteFieldConfig, isAfterPluginChange);
     } else {
-      const { importPanelPlugin } = runtime.getPluginImportUtils();
       try {
         const endPluginLoadCallback = profiler == null ? void 0 : profiler.onPluginLoadStart(pluginId);
-        const panelPromise = importPanelPlugin(pluginId);
-        const queryControler = sceneGraph.getQueryController(this);
-        if (queryControler && queryControler.state.enableProfiling) {
-          wrapPromiseInStateObservable(panelPromise).pipe(registerQueryWithController({ type: `VizPanel/loadPlugin/${pluginId}`, origin: this })).subscribe(() => {
-          });
-        }
-        const result = await panelPromise;
+        const result = await this._importPlugin(pluginId);
         endPluginLoadCallback == null ? void 0 : endPluginLoadCallback(result, false);
         this._pluginLoaded(result, overwriteOptions, overwriteFieldConfig, isAfterPluginChange);
       } catch (err) {
@@ -5291,6 +5434,24 @@ class VizPanel extends SceneObjectBase {
       }
     }
   }
+  /**
+   * The only place the plugin is imported. Concurrent callers (_loadPlugin, getPluginAsync) share one import,
+   * and a rejection stays cached so a plugin that fails to load is not retried on every call.
+   */
+  _importPlugin(pluginId) {
+    var _a;
+    if (((_a = this._pluginImport) == null ? void 0 : _a.pluginId) === pluginId) {
+      return this._pluginImport.promise;
+    }
+    const promise = runtime.getPluginImportUtils().importPanelPlugin(pluginId);
+    const queryControler = sceneGraph.getQueryController(this);
+    if (queryControler && queryControler.state.enableProfiling) {
+      wrapPromiseInStateObservable(promise).pipe(registerQueryWithController({ type: `VizPanel/loadPlugin/${pluginId}`, origin: this })).subscribe(() => {
+      });
+    }
+    this._pluginImport = { pluginId, promise };
+    return promise;
+  }
   getLegacyPanelId() {
     var _a, _b;
     const parts = (_b = (_a = this.state.key) == null ? void 0 : _a.split("/")) != null ? _b : [];
@@ -5359,6 +5520,11 @@ class VizPanel extends SceneObjectBase {
       pluginVersion: currentVersion,
       pluginId: plugin.meta.id
     });
+    if (this.state.applyPluginTransformations && // does panel support system transformations?
+    $data instanceof SceneDataTransformer && $data.isActive && // the plugin supplies a provider method, or a previous one did and its transformations must come back out
+    (pluginProvidesSystemTransformations(plugin) || $data.hasAppliedSystemTransformations())) {
+      $data.reprocessTransformations();
+    }
     if (plugin.meta.skipDataQuery) {
       const sceneTimeRange = sceneGraph.getTimeRange(this);
       this._subs.add(sceneTimeRange.subscribeToState(() => this.forceRender()));
@@ -5367,9 +5533,50 @@ class VizPanel extends SceneObjectBase {
   _getPluginVersion(plugin) {
     return plugin && plugin.meta.info.version ? plugin.meta.info.version : runtime.config.buildInfo.version;
   }
+  /**
+   * The plugin this panel has adopted, or undefined while it is still loading.
+   */
   getPlugin() {
     return this._plugin;
   }
+  /**
+   * The plugin for the current state.pluginId, importing it if it is not loaded yet. Rejects when
+   * the import does, like the host's importPanelPlugin.
+   *
+   * Unlike getPlugin this does not return undefined merely because the import has not finished, and
+   * it does not wait on the panel being activated. It does not adopt what it resolves: option
+   * migrations and the state write stay with _loadPlugin, on the render and viz change paths.
+   */
+  getPluginAsync() {
+    const resolved = this._resolvePluginSync();
+    return resolved ? Promise.resolve(resolved) : this._importPlugin(this.state.pluginId);
+  }
+  /**
+   * The plugin for the current state.pluginId when it is available without importing: the one this
+   * panel adopted, or one already in the host's cache.
+   */
+  _resolvePluginSync() {
+    var _a;
+    const { pluginId } = this.state;
+    return ((_a = this._plugin) == null ? void 0 : _a.meta.id) === pluginId ? this._plugin : loadPanelPluginSync(pluginId);
+  }
+  /**
+   * @internal
+   * Called by the SceneDataTransformer that discovered this panel with the frames about to enter the pipeline.
+   */
+  getSystemTransformations({ series }) {
+    if (series.length === 0) {
+      return {};
+    }
+    const plugin = this._pluginForTransformations();
+    return plugin ? getPluginSystemTransformations(plugin, { series }) : {};
+  }
+  /**
+   * The plugin that contributes the transformations for this panel.
+   */
+  _pluginForTransformations() {
+    return this.state.applyPluginTransformations ? this._resolvePluginSync() : void 0;
+  }
   getPanelContext() {
     var _a;
     (_a = this._panelContext) != null ? _a : this._panelContext = this.buildPanelContext();
@@ -5523,6 +5730,23 @@ function getPanelPluginNotFound(id) {
   };
   return plugin;
 }
+function pluginProvidesSystemTransformations(plugin) {
+  return typeof plugin.getSystemTransformations === "function";
+}
+function getPluginSystemTransformations(plugin, ctx) {
+  var _a;
+  if (!pluginProvidesSystemTransformations(plugin)) {
+    return {};
+  }
+  const { prepend = [], append = [] } = (_a = plugin.getSystemTransformations(ctx)) != null ? _a : {};
+  return { prepend: prepend.filter(appliesToSeriesTopic), append: append.filter(appliesToSeriesTopic) };
+}
+function appliesToSeriesTopic(transformation) {
+  if (typeof transformation === "function") {
+    return true;
+  }
+  return transformation.topic == null || transformation.topic === data.DataTopic.Series;
+}
 
 function findPanelProfiler(sceneObject) {
   try {
@@ -19071,6 +19295,7 @@ exports.isDataRequestEnricher = isDataRequestEnricher;
 exports.isFiltersRequestEnricher = isFiltersRequestEnricher;
 exports.isGroupByFilter = isGroupByFilter;
 exports.isSceneObject = isSceneObject;
+exports.isSystemTransformationsProvider = isSystemTransformationsProvider;
 exports.loadResources = loadResources;
 exports.performanceUtils = index$1;
 exports.registerQueryWithController = registerQueryWithController;