@nasa-terra/components 0.0.0

package/dist/chunks/chunk.MDRUDBRH.js

@@ -0,0 +1,43 @@
+import {
+  library_default_default
+} from "./chunk.XTCYIPKA.js";
+import {
+  library_heroicons_default
+} from "./chunk.UCNEPIMI.js";
+
+// src/components/icon/library.ts
+var registry = [library_default_default, library_heroicons_default];
+var watchedIcons = [];
+function watchIcon(icon) {
+  watchedIcons.push(icon);
+}
+function unwatchIcon(icon) {
+  watchedIcons = watchedIcons.filter((el) => el !== icon);
+}
+function getIconLibrary(name) {
+  return registry.find((lib) => lib.name === name);
+}
+function registerIconLibrary(name, options) {
+  unregisterIconLibrary(name);
+  registry.push({
+    name,
+    resolver: options.resolver,
+    mutator: options.mutator
+  });
+  watchedIcons.forEach((icon) => {
+    if (icon.library === name) {
+      icon.setIcon();
+    }
+  });
+}
+function unregisterIconLibrary(name) {
+  registry = registry.filter((lib) => lib.name !== name);
+}
+
+export {
+  watchIcon,
+  unwatchIcon,
+  getIconLibrary,
+  registerIconLibrary,
+  unregisterIconLibrary
+};

package/dist/chunks/chunk.MWHQHPUM.js

@@ -0,0 +1,54 @@
+import {
+  cherryPickDocInfo
+} from "./chunk.UU46CLE7.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk.RYPAZDXE.js";
+
+// src/components/variable-combobox/variable-combobox.controller.ts
+import { Task, TaskStatus } from "@lit/task";
+var apiError = new Error(
+  "Failed to fetch the data required to make a list of searchable items."
+);
+var _apiTask;
+var FetchController = class {
+  constructor(host) {
+    __privateAdd(this, _apiTask, void 0);
+    __privateSet(this, _apiTask, new Task(host, {
+      task: async () => {
+        const response = await fetch("http://localhost:9000/variables");
+        if (!response.ok) {
+          throw apiError;
+        }
+        const {
+          response: { docs }
+        } = await response.json();
+        return cherryPickDocInfo(docs);
+      },
+      args: () => []
+    }));
+  }
+  get taskComplete() {
+    return __privateGet(this, _apiTask).taskComplete;
+  }
+  get value() {
+    return __privateGet(this, _apiTask).value;
+  }
+  get taskStatus() {
+    const readableStatus = Object.entries(TaskStatus).reduce((accumulator, [key, value]) => {
+      accumulator[value] = key;
+      return accumulator;
+    }, {});
+    return readableStatus[__privateGet(this, _apiTask).status];
+  }
+  render(renderFunctions) {
+    return __privateGet(this, _apiTask).render(renderFunctions);
+  }
+};
+_apiTask = new WeakMap();
+
+export {
+  FetchController
+};

package/dist/chunks/chunk.N2DS7NLI.js

@@ -0,0 +1,102 @@
+// src/components/chip/chip.styles.ts
+import { css } from "lit";
+var chip_styles_default = css`
+    .chip {
+        display: inline-flex;
+        flex-direction: row;
+        background-color: #ffffff;
+        border: blue;
+        cursor: default;
+        outline: #0090f0;
+        outline-style: solid;
+        outline-width: 2px;
+        border-radius: 2px;
+        padding: 0;
+        margin: 5px;
+        font-weight: bold;
+        color: #909090;
+        font-family: 'Open Sans', sans-serif;
+        white-space: nowrap;
+        align-items: center;
+        vertical-align: middle;
+        text-decoration: none;
+        justify-content: center;
+    }
+    .chip--small {
+        height: 22px;
+        font-size: 11px;
+    }
+    .chip--medium {
+        height: 30px;
+        font-size: 15px;
+    }
+
+    .chip--large {
+        height: 38px;
+        font-size: 20px;
+    }
+    .chip-content {
+        cursor: inherit;
+        display: flex;
+        align-items: center;
+        user-select: none;
+        white-space: nowrap;
+    }
+    .chip-content--small {
+        padding-left: 8px;
+        padding-right: 8px;
+    }
+    .chip-content--medium {
+        padding-left: 12px;
+        padding-right: 12px;
+    }
+    .chip-content--large {
+        padding-left: 15px;
+        padding-right: 15px;
+    }
+    .chip-svg {
+        color: #888888;
+        cursor: pointer;
+        height: auto;
+        fill: currentColor;
+        display: inline-block;
+        transition: fill 200ms cubic-bezier(0.4, 0, 0.2, 1) 0ms;
+        user-select: none;
+        flex-shrink: 0;
+    }
+    .chip-svg--small {
+        margin: 3px 3px 0px -6px;
+        width: 0.75em;
+        height: 0.75em;
+        font-size: 20px;
+    }
+    .chip-svg--medium {
+        margin: 4px 4px 0px -8px;
+        width: 1em;
+        height: 1em;
+        font-size: 24px;
+    }
+
+    .chip-svg--large {
+        margin: 6px 6px 0px -12px;
+        width: 1.4em;
+        height: 1.4em;
+        font-size: 24px;
+    }
+    .chip-svg:hover {
+        visibility: 'visible';
+        filter: invert(100%);
+    }
+    .chip-close {
+        padding: 0;
+        border: 0;
+        background: none;
+        box-shadow: none;
+        text-align: center;
+        vertical-align: middle;
+    }
+`;
+
+export {
+  chip_styles_default
+};

package/dist/chunks/chunk.NQKBKXPW.js

@@ -0,0 +1,33 @@
+// src/utilities/base-path.ts
+var basePath = "";
+function setBasePath(path) {
+  basePath = path;
+}
+function getBasePath(subpath = "") {
+  if (!basePath) {
+    const scripts = [
+      ...document.getElementsByTagName("script")
+    ];
+    const configScript = scripts.find(
+      (script) => script.hasAttribute("data-terra-ui-components")
+    );
+    if (configScript) {
+      setBasePath(configScript.getAttribute("data-terra-ui-components"));
+    } else {
+      const fallbackScript = scripts.find((s) => {
+        return /terra-ui-components(\.min)?\.js($|\?)/.test(s.src) || /terra-ui-components-autoloader(\.min)?\.js($|\?)/.test(s.src);
+      });
+      let path = "";
+      if (fallbackScript) {
+        path = fallbackScript.getAttribute("src");
+      }
+      setBasePath(path.split("/").slice(0, -1).join("/"));
+    }
+  }
+  return basePath.replace(/\/$/, "") + (subpath ? `/${subpath.replace(/^\//, "")}` : ``);
+}
+
+export {
+  setBasePath,
+  getBasePath
+};

package/dist/chunks/chunk.NYBJ252W.js

@@ -0,0 +1,318 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk.RYPAZDXE.js";
+
+// src/internal/form.ts
+var formCollections = /* @__PURE__ */ new WeakMap();
+var reportValidityOverloads = /* @__PURE__ */ new WeakMap();
+var checkValidityOverloads = /* @__PURE__ */ new WeakMap();
+var userInteractedControls = /* @__PURE__ */ new WeakSet();
+var interactions = /* @__PURE__ */ new WeakMap();
+var FormControlController = class {
+  constructor(host, options) {
+    this.handleFormData = (event) => {
+      const disabled = this.options.disabled(this.host);
+      const name = this.options.name(this.host);
+      const value = this.options.value(this.host);
+      const isButton = this.host.tagName.toLowerCase() === "terra-button";
+      if (this.host.isConnected && !disabled && !isButton && typeof name === "string" && name.length > 0 && typeof value !== "undefined") {
+        if (Array.isArray(value)) {
+          ;
+          value.forEach((val) => {
+            event.formData.append(
+              name,
+              val.toString()
+            );
+          });
+        } else {
+          event.formData.append(
+            name,
+            value.toString()
+          );
+        }
+      }
+    };
+    this.handleFormSubmit = (event) => {
+      var _a;
+      const disabled = this.options.disabled(this.host);
+      const reportValidity = this.options.reportValidity;
+      if (this.form && !this.form.noValidate) {
+        (_a = formCollections.get(this.form)) == null ? void 0 : _a.forEach((control) => {
+          this.setUserInteracted(control, true);
+        });
+      }
+      if (this.form && !this.form.noValidate && !disabled && !reportValidity(this.host)) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+    };
+    this.handleFormReset = () => {
+      this.options.setValue(this.host, this.options.defaultValue(this.host));
+      this.setUserInteracted(this.host, false);
+      interactions.set(this.host, []);
+    };
+    this.handleInteraction = (event) => {
+      const emittedEvents = interactions.get(this.host);
+      if (!emittedEvents.includes(event.type)) {
+        emittedEvents.push(event.type);
+      }
+      if (emittedEvents.length === this.options.assumeInteractionOn.length) {
+        this.setUserInteracted(this.host, true);
+      }
+    };
+    this.checkFormValidity = () => {
+      if (this.form && !this.form.noValidate) {
+        const elements = this.form.querySelectorAll("*");
+        for (const element of elements) {
+          if (typeof element.checkValidity === "function") {
+            if (!element.checkValidity()) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    };
+    this.reportFormValidity = () => {
+      if (this.form && !this.form.noValidate) {
+        const elements = this.form.querySelectorAll("*");
+        for (const element of elements) {
+          if (typeof element.reportValidity === "function") {
+            if (!element.reportValidity()) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    };
+    ;
+    (this.host = host).addController(this);
+    this.options = __spreadValues({
+      form: (input) => {
+        const formId = input.form;
+        if (formId) {
+          const root = input.getRootNode();
+          const form = root.querySelector(`#${formId}`);
+          if (form) {
+            return form;
+          }
+        }
+        return input.closest("form");
+      },
+      name: (input) => input.name,
+      value: (input) => input.value,
+      defaultValue: (input) => input.defaultValue,
+      disabled: (input) => {
+        var _a;
+        return (_a = input.disabled) != null ? _a : false;
+      },
+      reportValidity: (input) => typeof input.reportValidity === "function" ? input.reportValidity() : true,
+      checkValidity: (input) => typeof input.checkValidity === "function" ? input.checkValidity() : true,
+      setValue: (input, value) => input.value = value,
+      assumeInteractionOn: ["terra-input"]
+    }, options);
+  }
+  hostConnected() {
+    const form = this.options.form(this.host);
+    if (form) {
+      this.attachForm(form);
+    }
+    interactions.set(this.host, []);
+    this.options.assumeInteractionOn.forEach((event) => {
+      this.host.addEventListener(event, this.handleInteraction);
+    });
+  }
+  hostDisconnected() {
+    this.detachForm();
+    interactions.delete(this.host);
+    this.options.assumeInteractionOn.forEach((event) => {
+      this.host.removeEventListener(event, this.handleInteraction);
+    });
+  }
+  hostUpdated() {
+    const form = this.options.form(this.host);
+    if (!form) {
+      this.detachForm();
+    }
+    if (form && this.form !== form) {
+      this.detachForm();
+      this.attachForm(form);
+    }
+    if (this.host.hasUpdated) {
+      this.setValidity(this.host.validity.valid);
+    }
+  }
+  attachForm(form) {
+    if (form) {
+      this.form = form;
+      if (formCollections.has(this.form)) {
+        formCollections.get(this.form).add(this.host);
+      } else {
+        formCollections.set(this.form, /* @__PURE__ */ new Set([this.host]));
+      }
+      this.form.addEventListener("formdata", this.handleFormData);
+      this.form.addEventListener("submit", this.handleFormSubmit);
+      this.form.addEventListener("reset", this.handleFormReset);
+      if (!reportValidityOverloads.has(this.form)) {
+        reportValidityOverloads.set(this.form, this.form.reportValidity);
+        this.form.reportValidity = () => this.reportFormValidity();
+      }
+      if (!checkValidityOverloads.has(this.form)) {
+        checkValidityOverloads.set(this.form, this.form.checkValidity);
+        this.form.checkValidity = () => this.checkFormValidity();
+      }
+    } else {
+      this.form = void 0;
+    }
+  }
+  detachForm() {
+    if (!this.form)
+      return;
+    const formCollection = formCollections.get(this.form);
+    if (!formCollection) {
+      return;
+    }
+    formCollection.delete(this.host);
+    if (formCollection.size <= 0) {
+      this.form.removeEventListener("formdata", this.handleFormData);
+      this.form.removeEventListener("submit", this.handleFormSubmit);
+      this.form.removeEventListener("reset", this.handleFormReset);
+      if (reportValidityOverloads.has(this.form)) {
+        this.form.reportValidity = reportValidityOverloads.get(this.form);
+        reportValidityOverloads.delete(this.form);
+      }
+      if (checkValidityOverloads.has(this.form)) {
+        this.form.checkValidity = checkValidityOverloads.get(this.form);
+        checkValidityOverloads.delete(this.form);
+      }
+      this.form = void 0;
+    }
+  }
+  setUserInteracted(el, hasInteracted) {
+    if (hasInteracted) {
+      userInteractedControls.add(el);
+    } else {
+      userInteractedControls.delete(el);
+    }
+    el.requestUpdate();
+  }
+  doAction(type, submitter) {
+    if (this.form) {
+      const button = document.createElement("button");
+      button.type = type;
+      button.style.position = "absolute";
+      button.style.width = "0";
+      button.style.height = "0";
+      button.style.clipPath = "inset(50%)";
+      button.style.overflow = "hidden";
+      button.style.whiteSpace = "nowrap";
+      if (submitter) {
+        button.name = submitter.name;
+        button.value = submitter.value;
+        [
+          "formaction",
+          "formenctype",
+          "formmethod",
+          "formnovalidate",
+          "formtarget"
+        ].forEach((attr) => {
+          if (submitter.hasAttribute(attr)) {
+            button.setAttribute(attr, submitter.getAttribute(attr));
+          }
+        });
+      }
+      this.form.append(button);
+      button.click();
+      button.remove();
+    }
+  }
+  /** Returns the associated `<form>` element, if one exists. */
+  getForm() {
+    var _a;
+    return (_a = this.form) != null ? _a : null;
+  }
+  /** Resets the form, restoring all the control to their default value */
+  reset(submitter) {
+    this.doAction("reset", submitter);
+  }
+  /** Submits the form, triggering validation and form data injection. */
+  submit(submitter) {
+    this.doAction("submit", submitter);
+  }
+  /**
+   * Synchronously sets the form control's validity. Call this when you know the future validity but need to update
+   * the host element immediately, i.e. before Lit updates the component in the next update.
+   */
+  setValidity(isValid) {
+    const host = this.host;
+    const hasInteracted = Boolean(userInteractedControls.has(host));
+    const required = Boolean(host.required);
+    host.toggleAttribute("data-required", required);
+    host.toggleAttribute("data-optional", !required);
+    host.toggleAttribute("data-invalid", !isValid);
+    host.toggleAttribute("data-valid", isValid);
+    host.toggleAttribute("data-user-invalid", !isValid && hasInteracted);
+    host.toggleAttribute("data-user-valid", isValid && hasInteracted);
+  }
+  /**
+   * Updates the form control's validity based on the current value of `host.validity.valid`. Call this when anything
+   * that affects constraint validation changes so the component receives the correct validity states.
+   */
+  updateValidity() {
+    const host = this.host;
+    this.setValidity(host.validity.valid);
+  }
+  /**
+   * Dispatches a non-bubbling, cancelable custom event of type `terra-invalid`.
+   * If the `terra-invalid` event will be cancelled then the original `invalid`
+   * event (which may have been passed as argument) will also be cancelled.
+   * If no original `invalid` event has been passed then the `terra-invalid`
+   * event will be cancelled before being dispatched.
+   */
+  emitInvalidEvent(originalInvalidEvent) {
+    const slInvalidEvent = new CustomEvent(
+      "terra-invalid",
+      {
+        bubbles: false,
+        composed: false,
+        cancelable: true,
+        detail: {}
+      }
+    );
+    if (!originalInvalidEvent) {
+      slInvalidEvent.preventDefault();
+    }
+    if (!this.host.dispatchEvent(slInvalidEvent)) {
+      originalInvalidEvent == null ? void 0 : originalInvalidEvent.preventDefault();
+    }
+  }
+};
+var validValidityState = Object.freeze({
+  badInput: false,
+  customError: false,
+  patternMismatch: false,
+  rangeOverflow: false,
+  rangeUnderflow: false,
+  stepMismatch: false,
+  tooLong: false,
+  tooShort: false,
+  typeMismatch: false,
+  valid: true,
+  valueMissing: false
+});
+var valueMissingValidityState = Object.freeze(__spreadProps(__spreadValues({}, validValidityState), {
+  valid: false,
+  valueMissing: true
+}));
+var customErrorValidityState = Object.freeze(__spreadProps(__spreadValues({}, validValidityState), {
+  valid: false,
+  customError: true
+}));
+
+export {
+  formCollections,
+  FormControlController,
+  validValidityState
+};

package/dist/chunks/chunk.NZYKW5Y7.js

@@ -0,0 +1,11 @@
+import {
+  TerraTimeSeries
+} from "./chunk.SZQ6DLHF.js";
+
+// src/components/time-series/time-series.ts
+var time_series_default = TerraTimeSeries;
+TerraTimeSeries.define("terra-time-series");
+
+export {
+  time_series_default
+};

package/dist/chunks/chunk.OIDMX5LU.js

@@ -0,0 +1,10 @@
+// src/utilities/date.ts
+import { isValid } from "date-fns";
+function isValidDate(date) {
+  const parsedDate = Date.parse(date);
+  return !isNaN(parsedDate) && isValid(parsedDate);
+}
+
+export {
+  isValidDate
+};

package/dist/chunks/chunk.OQE2USZJ.js

@@ -0,0 +1,41 @@
+import {
+  formCollections
+} from "./chunk.NYBJ252W.js";
+
+// src/utilities/form.ts
+function serialize(form) {
+  const formData = new FormData(form);
+  const object = {};
+  formData.forEach((value, key) => {
+    if (Reflect.has(object, key)) {
+      const entry = object[key];
+      if (Array.isArray(entry)) {
+        entry.push(value);
+      } else {
+        object[key] = [object[key], value];
+      }
+    } else {
+      object[key] = value;
+    }
+  });
+  return object;
+}
+function getFormControls(form) {
+  const rootNode = form.getRootNode();
+  const allNodes = [...rootNode.querySelectorAll("*")];
+  const formControls = [...form.elements];
+  const collection = formCollections.get(form);
+  const TerraFormControls = collection ? Array.from(collection) : [];
+  return [...formControls, ...TerraFormControls].sort((a, b) => {
+    if (allNodes.indexOf(a) < allNodes.indexOf(b))
+      return -1;
+    if (allNodes.indexOf(a) > allNodes.indexOf(b))
+      return 1;
+    return 0;
+  });
+}
+
+export {
+  serialize,
+  getFormControls
+};