@nasa-terra/components 0.0.137 → 0.0.139

package/dist/chunks/chunk.OOZ35KRV.js

@@ -0,0 +1,458 @@
+import {
+  TimeSeriesController
+} from "./chunk.EIND5KV5.js";
+import {
+  time_series_styles_default
+} from "./chunk.RQEPF7OZ.js";
+import {
+  getFetchVariableTask
+} from "./chunk.RO4MUFVF.js";
+import {
+  extractHarmonyError,
+  formatHarmonyErrorMessage
+} from "./chunk.ESNQNQUJ.js";
+import {
+  TerraPlotToolbar
+} from "./chunk.FCVMQBC6.js";
+import {
+  TerraPlot
+} from "./chunk.IG5E3PNG.js";
+import {
+  AuthController
+} from "./chunk.DHM36JBP.js";
+import {
+  TerraLoader
+} from "./chunk.XE4T3WTA.js";
+import {
+  TerraButton
+} from "./chunk.X4T5FEVN.js";
+import {
+  formatDate
+} from "./chunk.Y4QEHGFE.js";
+import {
+  TerraIcon
+} from "./chunk.MJAA2EKQ.js";
+import {
+  TerraAlert
+} from "./chunk.ZPH3RFHS.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.R4VDG6AK.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/time-series/time-series.component.ts
+import { html } from "lit";
+import { property, query, state } from "lit/decorators.js";
+import { TaskStatus } from "@lit/task";
+import { cache } from "lit/directives/cache.js";
+var _timeSeriesController, _handleQuotaError, _confirmDataPointWarning, confirmDataPointWarning_fn, _cancelDataPointWarning, cancelDataPointWarning_fn, _abortDataLoad, abortDataLoad_fn, _handleComponentLeave, handleComponentLeave_fn, _getYAxisLabel, getYAxisLabel_fn, _hasNoData, hasNoData_fn, _isVariableNotFound, isVariableNotFound_fn, _getErrorMessage, getErrorMessage_fn, _handlePlotRelayout, handlePlotRelayout_fn;
+var TerraTimeSeries = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _confirmDataPointWarning);
+    __privateAdd(this, _cancelDataPointWarning);
+    /**
+     * aborts the underlying data loading task, which cancels the network request
+     */
+    __privateAdd(this, _abortDataLoad);
+    __privateAdd(this, _handleComponentLeave);
+    __privateAdd(this, _getYAxisLabel);
+    __privateAdd(this, _hasNoData);
+    __privateAdd(this, _isVariableNotFound);
+    __privateAdd(this, _getErrorMessage);
+    __privateAdd(this, _handlePlotRelayout);
+    __privateAdd(this, _timeSeriesController, void 0);
+    this.showCitation = false;
+    this.disableAutoFetch = false;
+    this.quotaExceededOpen = false;
+    this.timeSeriesError = null;
+    this.showDataPointWarning = false;
+    this.estimatedDataPoints = 0;
+    this._authController = new AuthController(this);
+    this._fetchVariableTask = getFetchVariableTask(this);
+    __privateAdd(this, _handleQuotaError, (event) => {
+      const { status, code, message, context } = event.detail;
+      this.timeSeriesError = {
+        code: code || String(status),
+        message,
+        context
+      };
+      if (status === 429) {
+        this.quotaExceededOpen = true;
+      }
+    });
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.addEventListener(
+      "terra-time-series-error",
+      __privateGet(this, _handleQuotaError)
+    );
+    __privateSet(this, _timeSeriesController, new TimeSeriesController(this));
+  }
+  updated(changedProps) {
+    super.updated(changedProps);
+    const taskStatus = __privateGet(this, _timeSeriesController).task.status;
+    if (taskStatus === TaskStatus.PENDING && this.timeSeriesError) {
+      this.timeSeriesError = null;
+    }
+    if (taskStatus === TaskStatus.ERROR && !this.timeSeriesError) {
+      const taskError = __privateGet(this, _timeSeriesController).task.error;
+      if (taskError) {
+        const errorDetails = extractHarmonyError(taskError);
+        if (errorDetails.isCancellation) {
+          return;
+        }
+        this.timeSeriesError = {
+          code: errorDetails.code,
+          message: errorDetails.message,
+          context: errorDetails.context
+        };
+      }
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.removeEventListener(
+      "terra-time-series-error",
+      __privateGet(this, _handleQuotaError)
+    );
+  }
+  render() {
+    var _a, _b, _c;
+    return html`
+            <div class="plot-container" @mouseleave=${__privateMethod(this, _handleComponentLeave, handleComponentLeave_fn)}>
+                ${this.quotaExceededOpen ? html`
+                          <terra-alert
+                              variant="warning"
+                              duration="10000"
+                              open=${this.quotaExceededOpen}
+                              closable
+                              @terra-after-hide=${() => this.quotaExceededOpen = false}
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-exclamation-triangle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              You've exceeded your request quota. Please
+                              <a
+                                  href="https://disc.gsfc.nasa.gov/information/documents?title=Contact%20Us"
+                                  >contact the help desk</a
+                              >
+                              for further assistance.
+                          </terra-alert>
+                      ` : ""}
+                ${cache(
+      this.catalogVariable ? html`<terra-plot-toolbar
+                              .catalogVariable=${this.catalogVariable}
+                              .plot=${this.plot}
+                              .timeSeriesData=${(_a = __privateGet(this, _timeSeriesController).lastTaskValue) != null ? _a : __privateGet(this, _timeSeriesController).emptyPlotData}
+                              .location=${this.location}
+                              .startDate=${this.startDate}
+                              .endDate=${this.endDate}
+                              .cacheKey=${__privateGet(this, _timeSeriesController).getCacheKey()}
+                              .variableEntryId=${this.variableEntryId}
+                              .showCitation=${this.showCitation}
+                          >
+                              <slot name="help-links" slot="help-links"></slot>
+                          </terra-plot-toolbar>` : html`<div class="spacer"></div>`
+    )}
+                ${__privateMethod(this, _hasNoData, hasNoData_fn).call(this) ? html`
+                          <terra-alert
+                              class="no-data-alert"
+                              variant="warning"
+                              open
+                              closable
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-information-circle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              We couldn't find available data for your selection. Try
+                              widening your area or changing the date range to find
+                              more results.
+                          </terra-alert>
+                      ` : ""}
+                ${__privateMethod(this, _isVariableNotFound, isVariableNotFound_fn).call(this) ? html`
+                          <terra-alert
+                              class="no-data-alert"
+                              variant="danger"
+                              open
+                              closable
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-exclamation-triangle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              The selected variable was not found in the catalog
+                          </terra-alert>
+                      ` : ""}
+                ${this.timeSeriesError ? html`
+                          <terra-alert
+                              class="error-alert"
+                              variant="danger"
+                              open
+                              closable
+                              @terra-after-hide=${() => this.timeSeriesError = null}
+                          >
+                              <terra-icon
+                                  slot="icon"
+                                  name="outline-exclamation-triangle"
+                                  library="heroicons"
+                              ></terra-icon>
+                              ${__privateMethod(this, _getErrorMessage, getErrorMessage_fn).call(this, this.timeSeriesError)}
+                          </terra-alert>
+                      ` : ""}
+
+                <terra-plot
+                    exportparts="base:plot__base, plot-title:plot__title"
+                    .data=${(_b = __privateGet(this, _timeSeriesController).lastTaskValue) != null ? _b : __privateGet(this, _timeSeriesController).emptyPlotData}
+                    .layout="${{
+      xaxis: {
+        title: "Time",
+        showgrid: false,
+        zeroline: false,
+        range: (
+          // manually set the range as we may adjust it when we fetch new data as a user pans/zooms the plot
+          this.startDate && this.endDate ? [this.startDate, this.endDate] : void 0
+        )
+      },
+      yaxis: {
+        title: __privateMethod(this, _getYAxisLabel, getYAxisLabel_fn).call(this),
+        showline: false
+      },
+      title: {
+        text: this.catalogVariable && this.location ? `${this.catalogVariable.dataProductShortName} @ ${this.location}` : null
+      }
+    }}"
+                    .config=${{
+      displayModeBar: true,
+      displaylogo: false,
+      modeBarButtonsToRemove: ["toImage", "zoom2d", "resetScale2d"],
+      responsive: true
+    }}
+                    @terra-plot-relayout=${__privateMethod(this, _handlePlotRelayout, handlePlotRelayout_fn)}
+                ></terra-plot>
+            </div>
+
+            <dialog
+                ?open=${__privateGet(this, _timeSeriesController).task.status === TaskStatus.PENDING || this._fetchVariableTask.status === TaskStatus.PENDING}
+            >
+                <terra-loader indeterminate></terra-loader>
+
+                ${__privateGet(this, _timeSeriesController).task.status === TaskStatus.PENDING ? html`<p>
+                          Plotting ${(_c = this.catalogVariable) == null ? void 0 : _c.dataFieldId}&hellip;
+                      </p>` : html`<p>Preparing plot&hellip;</p>`}
+
+                <terra-button @click=${__privateMethod(this, _abortDataLoad, abortDataLoad_fn)}>Cancel</terra-button>
+            </dialog>
+
+            <dialog ?open=${this.showDataPointWarning} class="quota-dialog">
+                <h2>This is a large request</h2>
+
+                <p>
+                    You are requesting approximately
+                    ${this.estimatedDataPoints.toLocaleString()} data points.
+                </p>
+
+                <p>
+                    Requesting large amounts of data may cause you to reach your
+                    monthly quota limit.
+                </p>
+
+                <p>Would you still like to proceed with this request?</p>
+
+                <div class="dialog-buttons">
+                    <terra-button
+                        @click=${__privateMethod(this, _cancelDataPointWarning, cancelDataPointWarning_fn)}
+                        variant="default"
+                    >
+                        Cancel
+                    </terra-button>
+
+                    <terra-button
+                        @click=${__privateMethod(this, _confirmDataPointWarning, confirmDataPointWarning_fn)}
+                        variant="primary"
+                    >
+                        Proceed
+                    </terra-button>
+                </div>
+            </dialog>
+        `;
+  }
+};
+_timeSeriesController = new WeakMap();
+_handleQuotaError = new WeakMap();
+_confirmDataPointWarning = new WeakSet();
+confirmDataPointWarning_fn = function() {
+  __privateGet(this, _timeSeriesController).confirmDataPointWarning();
+  __privateGet(this, _timeSeriesController).task.run();
+};
+_cancelDataPointWarning = new WeakSet();
+cancelDataPointWarning_fn = function() {
+  this.showDataPointWarning = false;
+};
+_abortDataLoad = new WeakSet();
+abortDataLoad_fn = function() {
+  var _a;
+  console.log("Aborting data load");
+  (_a = __privateGet(this, _timeSeriesController).task) == null ? void 0 : _a.abort("Cancelled time series request");
+};
+_handleComponentLeave = new WeakSet();
+handleComponentLeave_fn = function(event) {
+  var _a;
+  const relatedTarget = event.relatedTarget;
+  if (!this.contains(relatedTarget)) {
+    (_a = this.plotToolbar) == null ? void 0 : _a.closeMenu();
+  }
+};
+_getYAxisLabel = new WeakSet();
+getYAxisLabel_fn = function() {
+  if (!this.catalogVariable) {
+    return;
+  }
+  return [this.catalogVariable.dataFieldUnits].filter(Boolean).join(", ");
+};
+_hasNoData = new WeakSet();
+hasNoData_fn = function() {
+  var _a;
+  const taskStatus = __privateGet(this, _timeSeriesController).task.status;
+  if (taskStatus !== TaskStatus.COMPLETE) {
+    return false;
+  }
+  const plotData = (_a = __privateGet(this, _timeSeriesController).lastTaskValue) != null ? _a : __privateGet(this, _timeSeriesController).emptyPlotData;
+  if (plotData.length === 0) {
+    return true;
+  }
+  const firstSeries = plotData[0];
+  const x = "x" in firstSeries ? firstSeries.x : void 0;
+  const y = "y" in firstSeries ? firstSeries.y : void 0;
+  if (!x || !y || Array.isArray(x) && x.length === 0 || Array.isArray(y) && y.length === 0) {
+    return true;
+  }
+  return false;
+};
+_isVariableNotFound = new WeakSet();
+isVariableNotFound_fn = function() {
+  const variableTaskStatus = this._fetchVariableTask.status;
+  if (variableTaskStatus !== TaskStatus.COMPLETE) {
+    return false;
+  }
+  const hasVariableRequest = Boolean(
+    this.variableEntryId || this.collection && this.variable
+  );
+  return hasVariableRequest && !this.catalogVariable;
+};
+_getErrorMessage = new WeakSet();
+getErrorMessage_fn = function(error) {
+  return formatHarmonyErrorMessage(error);
+};
+_handlePlotRelayout = new WeakSet();
+handlePlotRelayout_fn = function(e) {
+  if (this.disableAutoFetch) {
+    return;
+  }
+  let changed = false;
+  if (e.detail.xAxisMin) {
+    this.startDate = formatDate(e.detail.xAxisMin);
+    changed = true;
+  }
+  if (e.detail.xAxisMax) {
+    this.endDate = formatDate(e.detail.xAxisMax);
+    changed = true;
+  }
+  if (changed) {
+    this.dispatchEvent(
+      new CustomEvent("terra-date-range-change", {
+        detail: {
+          startDate: this.startDate,
+          endDate: this.endDate
+        },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+};
+TerraTimeSeries.styles = [component_styles_default, time_series_styles_default];
+TerraTimeSeries.dependencies = {
+  "terra-plot": TerraPlot,
+  "terra-loader": TerraLoader,
+  "terra-icon": TerraIcon,
+  "terra-button": TerraButton,
+  "terra-alert": TerraAlert,
+  "terra-plot-toolbar": TerraPlotToolbar
+};
+__decorateClass([
+  property({ attribute: "variable-entry-id", reflect: true })
+], TerraTimeSeries.prototype, "variableEntryId", 2);
+__decorateClass([
+  property({ reflect: true })
+], TerraTimeSeries.prototype, "collection", 2);
+__decorateClass([
+  property({ reflect: true })
+], TerraTimeSeries.prototype, "variable", 2);
+__decorateClass([
+  property({
+    attribute: "start-date",
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "startDate", 2);
+__decorateClass([
+  property({
+    attribute: "end-date",
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "endDate", 2);
+__decorateClass([
+  property({
+    reflect: true
+  })
+], TerraTimeSeries.prototype, "location", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "show-citation" })
+], TerraTimeSeries.prototype, "showCitation", 2);
+__decorateClass([
+  property({ attribute: "application-citation" })
+], TerraTimeSeries.prototype, "applicationCitation", 2);
+__decorateClass([
+  property({ type: Boolean, attribute: "disable-auto-fetch" })
+], TerraTimeSeries.prototype, "disableAutoFetch", 2);
+__decorateClass([
+  property({ attribute: "bearer-token", reflect: false })
+], TerraTimeSeries.prototype, "bearerToken", 2);
+__decorateClass([
+  query("terra-plot")
+], TerraTimeSeries.prototype, "plot", 2);
+__decorateClass([
+  query("terra-plot-toolbar")
+], TerraTimeSeries.prototype, "plotToolbar", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "catalogVariable", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "quotaExceededOpen", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "timeSeriesError", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "showDataPointWarning", 2);
+__decorateClass([
+  state()
+], TerraTimeSeries.prototype, "estimatedDataPoints", 2);
+
+export {
+  TerraTimeSeries
+};

package/dist/chunks/chunk.OQMU445F.js

@@ -0,0 +1,229 @@
+import {
+  data_subsetter_history_styles_default
+} from "./chunk.7674U7FT.js";
+import {
+  TerraDataSubsetter
+} from "./chunk.VVQDHS65.js";
+import {
+  TerraDialog
+} from "./chunk.WP3THC5K.js";
+import {
+  DataSubsetterHistoryController
+} from "./chunk.WVJDTT7W.js";
+import {
+  AuthController
+} from "./chunk.DHM36JBP.js";
+import {
+  TerraIcon
+} from "./chunk.MJAA2EKQ.js";
+import {
+  TerraElement,
+  component_styles_default
+} from "./chunk.R4VDG6AK.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod
+} from "./chunk.SHKVBVTI.js";
+
+// src/components/data-subsetter-history/data-subsetter-history.component.ts
+import { property, query, state } from "lit/decorators.js";
+import { html, nothing } from "lit";
+var _controller, _renderHistoryItems, renderHistoryItems_fn, _handleHistoryItemClick, handleHistoryItemClick_fn;
+var TerraDataSubsetterHistory = class extends TerraElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _renderHistoryItems);
+    __privateAdd(this, _handleHistoryItemClick);
+    this.label = "History";
+    this.alwaysShow = true;
+    this.collapsed = true;
+    this.hideCancelled = true;
+    __privateAdd(this, _controller, new DataSubsetterHistoryController(this));
+    this._authController = new AuthController(this);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.addController(__privateGet(this, _controller));
+  }
+  toggleCollapsed() {
+    this.collapsed = !this.collapsed;
+  }
+  render() {
+    const jobs = __privateGet(this, _controller).jobs;
+    const hasJobs = jobs && jobs.jobs.length > 0;
+    if (!hasJobs) {
+      return nothing;
+    }
+    return html`
+            <div class="${this.collapsed ? "collapsed" : ""}">
+                <div class="history-header" @click=${this.toggleCollapsed}>
+                    <span>${this.label}</span>
+                </div>
+
+                <div class="history-panel">
+                    ${hasJobs ? html`
+                              <div class="history-link-row">
+                                  <label>
+                                      <input
+                                          type="checkbox"
+                                          .checked=${this.hideCancelled}
+                                          @change=${(e) => {
+      this.hideCancelled = e.target.checked;
+    }}
+                                      />
+                                      Hide Cancelled
+                                  </label>
+
+                                  <a
+                                      href="https://harmony.earthdata.nasa.gov/workflow-ui"
+                                      target="_blank"
+                                      rel="noopener noreferrer"
+                                      class="history-link"
+                                  >
+                                      View all
+                                      <terra-icon
+                                          name="outline-arrow-top-right-on-square"
+                                          library="heroicons"
+                                          size="32px"
+                                      ></terra-icon>
+                                  </a>
+                              </div>
+                          ` : nothing}
+
+                    <div class="history-list">
+                        ${jobs ? hasJobs ? __privateMethod(this, _renderHistoryItems, renderHistoryItems_fn).call(this, jobs) : html`<div class="history-alert-message">
+                                      You haven't made any requests yet.<br />
+                                      Get started by
+                                      <a
+                                          href="#"
+                                          class="history-alert-link"
+                                          @click=${(e) => {
+      var _a;
+      e.preventDefault();
+      this.selectedJob = void 0;
+      (_a = this.dialog) == null ? void 0 : _a.show();
+    }}
+                                      >
+                                          creating your first request!</a
+                                      >.
+                                  </div>` : html`<div class="history-alert-message">
+                                  Retrieving your requests....
+                              </div>`}
+                    </div>
+                </div>
+            </div>
+
+            <terra-dialog part="dialog" width="1500px">
+                <terra-data-subsetter
+                    .jobId=${this.selectedJob}
+                    .bearerToken=${this.bearerToken}
+                ></terra-data-subsetter>
+            </terra-dialog>
+        `;
+  }
+};
+_controller = new WeakMap();
+_renderHistoryItems = new WeakSet();
+renderHistoryItems_fn = function(subsetJobs) {
+  const filteredJobs = subsetJobs.jobs.slice().filter((job) => {
+    if (this.hideCancelled) {
+      return job.status !== "canceled" /* CANCELED */;
+    }
+    return true;
+  }).sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+  if (!filteredJobs.length) {
+    return html`
+                <div class="history-alert-message">
+                    There are no active requests to show.<br />
+                    If you'd like, you can
+                    <a
+                        href="#"
+                        class="history-alert-link"
+                        @click=${(e) => {
+      var _a;
+      e.preventDefault();
+      this.selectedJob = void 0;
+      (_a = this.dialog) == null ? void 0 : _a.show();
+    }}
+                    >
+                        create a new request.</a
+                    >
+                </div>
+            `;
+  }
+  return filteredJobs.map((job) => {
+    var _a;
+    let fillColor = "#0066cc";
+    if (job.status === "successful" /* SUCCESSFUL */ || job.status === "complete_with_errors" /* COMPLETE_WITH_ERRORS */ || job.status === "running_with_errors" /* RUNNING_WITH_ERRORS */) {
+      fillColor = "#28a745";
+    } else if (job.status === "failed" /* FAILED */) {
+      fillColor = "#dc3545";
+    } else if (job.status === "canceled" /* CANCELED */) {
+      fillColor = "#ffc107";
+    }
+    const progressLabel = job.status === "failed" /* FAILED */ || job.status === "canceled" /* CANCELED */ ? job.status : `${job.progress}%`;
+    const progress = job.status === "failed" /* FAILED */ || job.status === "canceled" /* CANCELED */ ? 100 : job.progress;
+    return html`
+                <div
+                    class="history-item"
+                    @click=${__privateMethod(this, _handleHistoryItemClick, handleHistoryItemClick_fn).bind(this, job)}
+                >
+                    <div class="item-header">
+                        <span class="item-title">
+                            ${((_a = job.labels) == null ? void 0 : _a.length) ? job.labels.join(" ") : job.request.split(".nasa.gov").pop()}
+                        </span>
+                    </div>
+
+                    <div class="progress-bar">
+                        <div
+                            class="progress-fill"
+                            style="width: ${progress}%; background-color: ${fillColor}"
+                        >
+                            ${progressLabel}
+                        </div>
+                    </div>
+                </div>
+            `;
+  });
+};
+_handleHistoryItemClick = new WeakSet();
+handleHistoryItemClick_fn = function(job) {
+  var _a;
+  this.selectedJob = job.jobID;
+  (_a = this.dialog) == null ? void 0 : _a.show();
+};
+TerraDataSubsetterHistory.dependencies = {
+  "terra-icon": TerraIcon,
+  "terra-data-subsetter": TerraDataSubsetter,
+  "terra-dialog": TerraDialog
+};
+TerraDataSubsetterHistory.styles = [component_styles_default, data_subsetter_history_styles_default];
+__decorateClass([
+  property()
+], TerraDataSubsetterHistory.prototype, "label", 2);
+__decorateClass([
+  property({ attribute: "bearer-token" })
+], TerraDataSubsetterHistory.prototype, "bearerToken", 2);
+__decorateClass([
+  property({ attribute: "always-show", type: Boolean })
+], TerraDataSubsetterHistory.prototype, "alwaysShow", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "collapsed", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "selectedJob", 2);
+__decorateClass([
+  state()
+], TerraDataSubsetterHistory.prototype, "hideCancelled", 2);
+__decorateClass([
+  query('[part~="dialog"]')
+], TerraDataSubsetterHistory.prototype, "dialog", 2);
+
+export {
+  TerraDataSubsetterHistory
+};