@tylertech/forge 2.0.0 → 2.1.0

package/dist/esm/chunks/chunk.FBUQQD2T.js

@@ -0,0 +1,732 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import {
+  STEP_CONSTANTS,
+  StepComponent
+} from "./chunk.J6LOWXOG.js";
+import {
+  getEventPath
+} from "./chunk.EY57VTRF.js";
+import {
+  Platform
+} from "./chunk.BYN27JXZ.js";
+import {
+  BaseAdapter
+} from "./chunk.KZATVOA6.js";
+import {
+  FoundationProperty
+} from "./chunk.MMIZOYAS.js";
+import {
+  COMPONENT_NAME_PREFIX,
+  CustomElement
+} from "./chunk.35U3UPDV.js";
+import {
+  BaseComponent
+} from "./chunk.VK6LIH3B.js";
+import {
+  attachShadowTemplate,
+  defineCustomElement,
+  getShadowElement
+} from "./chunk.K2PCTUVN.js";
+import {
+  ensureChildren,
+  getActiveElement,
+  toggleClass
+} from "./chunk.4JURZYE4.js";
+import {
+  coerceBoolean,
+  isDefined,
+  isNumber
+} from "./chunk.MEFT5FQC.js";
+import {
+  __decorateClass,
+  __spreadValues
+} from "./chunk.LM5TVNZY.js";
+
+// dist/build/lib/staging/src/stepper/stepper/stepper-constants.ts
+var elementName = `${COMPONENT_NAME_PREFIX}stepper`;
+var classes = {
+  STEPPER: "forge-stepper",
+  LINEAR: "forge-stepper--linear",
+  ALTERNATIVE: "forge-stepper--alternative",
+  CLUSTERED: "forge-stepper--clustered",
+  FIXED: "forge-stepper--fixed",
+  ALIGN_LEFT: "forge-stepper--align-left",
+  ALIGN_CENTER: "forge-stepper--align-center",
+  ALIGN_RIGHT: "forge-stepper--align-right",
+  VERTICAL: "forge-stepper--vertical",
+  FOCUSED: "forge-stepper--focused"
+};
+var selectors = {
+  STEPPER: `.${classes.STEPPER}`
+};
+var attributes = {
+  SELECTED_INDEX: "selected-index",
+  LINEAR: "linear",
+  ALTERNATIVE: "alternative",
+  LAYOUT_MODE: "layout-mode",
+  LAYOUT_ALIGN: "layout-align",
+  DISABLED: "disabled",
+  VERTICAL: "vertical"
+};
+var strings = {
+  ARROW_LEFT_KEY: "ArrowLeft",
+  ARROW_RIGHT_KEY: "ArrowRight",
+  ARROW_UP_KEY: "ArrowUp",
+  ARROW_DOWN_KEY: "ArrowDown",
+  END_KEY: "End",
+  ENTER_KEY: "Enter",
+  HOME_KEY: "Home",
+  SPACE_KEY: "Space",
+  TAB_KEY: "Tab"
+};
+var numbers = {
+  ARROW_LEFT_KEYCODE: 37,
+  ARROW_RIGHT_KEYCODE: 39,
+  END_KEYCODE: 35,
+  HOME_KEYCODE: 36,
+  ENTER_KEYCODE: 13,
+  SPACE_KEYCODE: 32
+};
+var ACCEPTABLE_KEYS = [
+  strings.ARROW_LEFT_KEY,
+  strings.ARROW_RIGHT_KEY,
+  strings.ARROW_DOWN_KEY,
+  strings.ARROW_UP_KEY,
+  strings.END_KEY,
+  strings.HOME_KEY,
+  strings.ENTER_KEY,
+  strings.SPACE_KEY,
+  strings.TAB_KEY
+];
+var KEYCODE_MAP = {
+  [numbers.ARROW_LEFT_KEYCODE]: strings.ARROW_LEFT_KEY,
+  [numbers.ARROW_RIGHT_KEYCODE]: strings.ARROW_RIGHT_KEY,
+  [numbers.END_KEYCODE]: strings.END_KEY,
+  [numbers.HOME_KEYCODE]: strings.HOME_KEY,
+  [numbers.ENTER_KEYCODE]: strings.ENTER_KEY,
+  [numbers.SPACE_KEYCODE]: strings.SPACE_KEY
+};
+var STEPPER_CONSTANTS = {
+  elementName,
+  classes,
+  selectors,
+  attributes,
+  numbers,
+  strings,
+  ACCEPTABLE_KEYS,
+  KEYCODE_MAP
+};
+
+// dist/build/lib/staging/src/stepper/core/stepper-utils.ts
+var StepperUtils = class {
+  static createStepElement(step, index, stepperConfig) {
+    const stepElement = document.createElement(STEP_CONSTANTS.elementName);
+    stepElement.index = index;
+    stepElement.completed = step.completed || false;
+    stepElement.editable = step.editable || false;
+    stepElement.selected = stepperConfig.selectedIndex === index;
+    stepElement.alternative = stepperConfig.alternative;
+    stepElement.error = step.error || false;
+    stepElement.disabled = step.disabled || false;
+    stepElement.vertical = step.vertical || false;
+    stepElement.ignoreUserExpansion = step.ignoreUserExpansion || false;
+    stepElement.expanded = step.expanded || false;
+    if (stepperConfig.linear && index > stepperConfig.selectedIndex) {
+      stepElement.tabIndex = -1;
+    }
+    stepElement.textContent = step.label;
+    if (step.optionalLabel) {
+      stepElement.appendChild(this.createStepOptionalLabel(step.optionalLabel));
+    }
+    return stepElement;
+  }
+  static createStepOptionalLabel(labelText) {
+    const label = document.createElement("span");
+    label.slot = "optional";
+    label.textContent = labelText || "";
+    return label;
+  }
+  static setLinearState(stepperElement, isLinear) {
+    let hasLinearClass = stepperElement.classList.contains(STEPPER_CONSTANTS.classes.LINEAR);
+    if (hasLinearClass && !isLinear) {
+      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.LINEAR);
+      hasLinearClass = false;
+    }
+    if (!hasLinearClass && isLinear) {
+      stepperElement.classList.add(STEPPER_CONSTANTS.classes.LINEAR);
+    }
+  }
+  static setAlternativeState(stepperElement, isAlternative) {
+    let hasAlternativeClass = stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALTERNATIVE);
+    if (hasAlternativeClass && !isAlternative) {
+      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALTERNATIVE);
+      hasAlternativeClass = false;
+    }
+    if (!hasAlternativeClass && isAlternative) {
+      stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALTERNATIVE);
+    }
+  }
+  static setLayoutMode(stepperElement, mode) {
+    switch (mode) {
+      case "clustered":
+        if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.FIXED)) {
+          stepperElement.classList.remove(STEPPER_CONSTANTS.classes.FIXED);
+        }
+        stepperElement.classList.add(STEPPER_CONSTANTS.classes.CLUSTERED);
+        break;
+      case "fixed":
+        if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.CLUSTERED)) {
+          stepperElement.classList.remove(STEPPER_CONSTANTS.classes.CLUSTERED);
+        }
+        stepperElement.classList.add(STEPPER_CONSTANTS.classes.FIXED);
+        break;
+    }
+  }
+  static setLayoutAlign(stepperElement, mode) {
+    if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALIGN_LEFT)) {
+      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALIGN_LEFT);
+    }
+    if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALIGN_CENTER)) {
+      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALIGN_CENTER);
+    }
+    if (stepperElement.classList.contains(STEPPER_CONSTANTS.classes.ALIGN_RIGHT)) {
+      stepperElement.classList.remove(STEPPER_CONSTANTS.classes.ALIGN_RIGHT);
+    }
+    switch (mode) {
+      case "left":
+        stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALIGN_LEFT);
+        break;
+      case "center":
+        stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALIGN_CENTER);
+        break;
+      case "right":
+        stepperElement.classList.add(STEPPER_CONSTANTS.classes.ALIGN_RIGHT);
+        break;
+    }
+  }
+  static createSteps(stepperConfiguration) {
+    const steps = [];
+    stepperConfiguration.steps.forEach((step, index) => {
+      const stepElement = StepperUtils.createStepElement(step, index, stepperConfiguration);
+      steps.push(stepElement);
+    });
+    steps[0].setAttribute(STEP_CONSTANTS.attributes.FIRST, "");
+    steps[steps.length - 1].setAttribute(STEP_CONSTANTS.attributes.LAST, "");
+    return steps;
+  }
+};
+
+// dist/build/lib/staging/src/stepper/stepper/stepper-adapter.ts
+var StepperAdapter = class extends BaseAdapter {
+  constructor(component) {
+    super(component);
+    this._rootElement = getShadowElement(component, STEPPER_CONSTANTS.selectors.STEPPER);
+    this._slotElement = this._rootElement.querySelector("slot");
+  }
+  initializeAccessibility() {
+    if (!this._component.hasAttribute("role")) {
+      this._component.setAttribute("role", "tablist");
+    }
+  }
+  patchSafari() {
+    this._applyToSteps((s) => s.setAttribute("safari", ""));
+  }
+  addSlotChangeListener(listener) {
+    this._slotElement.addEventListener("slotchange", listener);
+  }
+  removeSlotChangeListener(listener) {
+    this._slotElement.addEventListener("slotchange", listener);
+  }
+  getLastStep() {
+    const steps = this._getSteps();
+    return steps.item(steps.length - 1);
+  }
+  setSelected(step) {
+    this._getSteps().forEach((s) => {
+      if (s === step) {
+        s.selected = true;
+      } else {
+        s.selected = false;
+      }
+    });
+  }
+  assignIndices() {
+    const steps = this._getSteps();
+    steps.forEach((tab, index) => {
+      tab.index = index;
+    });
+  }
+  assignFirstLastStep() {
+    const steps = this._getSteps();
+    if (steps && steps.length > 1) {
+      steps[0].setAttribute("first", "");
+      steps[steps.length - 1].setAttribute("last", "");
+    }
+  }
+  setLayoutAlign(layoutAlign) {
+    StepperUtils.setLayoutAlign(this._rootElement, layoutAlign);
+  }
+  setLayoutMode(layoutMode) {
+    StepperUtils.setLayoutMode(this._rootElement, layoutMode);
+    this._applyToSteps((s) => s.setAttribute(STEP_CONSTANTS.attributes.CLUSTERED, ""));
+  }
+  setAlternativeState(alternative) {
+    StepperUtils.setAlternativeState(this._rootElement, alternative);
+    this._applyToSteps((step) => step.alternative = alternative);
+  }
+  setVertical(vertical) {
+    toggleClass(this._rootElement, vertical, STEPPER_CONSTANTS.classes.VERTICAL);
+    this._applyToSteps((step) => step.vertical = vertical);
+  }
+  setLinearState(linear) {
+    StepperUtils.setLinearState(this._rootElement, linear);
+  }
+  removeRootListener(event, listener) {
+    this._rootElement.removeEventListener("click", listener);
+  }
+  addRootListener(event, listener) {
+    this._rootElement.addEventListener(event, listener);
+  }
+  setSelectedByIndex(index) {
+    this._applyToSteps((step) => {
+      if (step.selected && step.index !== index) {
+        step.selected = false;
+      }
+      if (step.index === index) {
+        step.selected = true;
+      }
+    });
+  }
+  applyConfiguredSteps(steps) {
+    this._component.querySelectorAll(STEP_CONSTANTS.elementName).forEach((n) => {
+      this._component.removeChild(n);
+    });
+    steps.forEach((s) => this._component.appendChild(s));
+  }
+  tryGetFocusedStep() {
+    let focusedStep = void 0;
+    const activeElement = getActiveElement();
+    this._applyToSteps((step) => {
+      if (activeElement === getShadowElement(step, STEP_CONSTANTS.selectors.STEP)) {
+        focusedStep = step;
+      }
+    });
+    return focusedStep;
+  }
+  getFocusedOrSelectedStep() {
+    let focusedStep = this.tryGetFocusedStep();
+    if (!focusedStep) {
+      focusedStep = this._getSteps()[0];
+      focusedStep.focus();
+    }
+    return focusedStep;
+  }
+  getStep(index) {
+    let realIndex = 0;
+    const steps = this._getSteps();
+    if (index < 0) {
+      return steps.item(steps.length - 1);
+    }
+    if (steps.length > index) {
+      realIndex = index;
+    }
+    return steps.item(realIndex);
+  }
+  toggleDisabled(disabled) {
+    this._applyToSteps((s) => s.disabled = disabled);
+  }
+  toggleRootClass(className, show) {
+    toggleClass(this._rootElement, show, className);
+  }
+  isStepperFocused() {
+    return this._rootElement.classList.contains(STEPPER_CONSTANTS.classes.FOCUSED);
+  }
+  setStepsListener(event, listener) {
+    this._applyToSteps((s) => s.addEventListener(event, listener));
+  }
+  removeStepsListener(event, listener) {
+    this._applyToSteps((s) => s.removeEventListener(event, listener));
+  }
+  _applyToSteps(action) {
+    this._getSteps().forEach(action);
+  }
+  _getSteps() {
+    return this._component.querySelectorAll(STEP_CONSTANTS.elementName);
+  }
+};
+
+// dist/build/lib/staging/src/stepper/stepper/stepper-foundation.ts
+var StepperFoundation = class {
+  constructor(_adapter) {
+    this._adapter = _adapter;
+    this._steps = [];
+    this._selectedIndex = 0;
+    this._linear = false;
+    this._alternative = false;
+    this._layoutMode = "fixed";
+    this._layoutAlign = "center";
+    this._initialize = false;
+    this._clickListener = (event) => this._handleClick(event);
+    this._keyListener = (event) => this._onKeydown(event);
+    this._stepFocusListener = () => this._onStepFocus();
+    this._stepBlurListener = () => this._onStepBlur();
+    this._stepExpandedContentFocusInListener = (event) => this._onStepExpandedContentFocusIn(event);
+    this._stepExpandedContentFocusOutListener = (event) => this._onStepExpandedContentFocusOut(event);
+    this._slotChangeListener = (event) => this._onSlotChange(event);
+  }
+  initialize() {
+    this._adapter.initializeAccessibility();
+    this._adapter.assignIndices();
+    this._adapter.setLinearState(this._linear);
+    this._adapter.setAlternativeState(this._alternative);
+    this._adapter.setLayoutAlign(this._layoutAlign);
+    this._adapter.setLayoutMode(this._layoutMode);
+    this._adapter.addRootListener("click", this._clickListener);
+    this._adapter.addHostListener("keydown", this._keyListener);
+    this._adapter.assignFirstLastStep();
+    this._adapter.addRootListener(STEP_CONSTANTS.events.EXPANDED_CONTENT_FOCUSIN, this._stepExpandedContentFocusInListener);
+    this._adapter.addRootListener(STEP_CONSTANTS.events.EXPANDED_CONTENT_FOCUSOUT, this._stepExpandedContentFocusOutListener);
+    this._applySelectedIndex();
+    this._patchBrowser();
+    this._adapter.setStepsListener("blur", this._stepBlurListener);
+    this._adapter.setStepsListener("focus", this._stepFocusListener);
+    if (!this._initialize) {
+      this._adapter.addSlotChangeListener(this._slotChangeListener);
+    }
+    this._initialize = true;
+  }
+  disconnect() {
+    this._adapter.removeRootListener("click", this._clickListener);
+    this._adapter.removeHostListener("keydown", this._keyListener);
+    this._adapter.removeSlotChangeListener(this._slotChangeListener);
+    this._adapter.removeStepsListener("blur", this._stepBlurListener);
+    this._adapter.removeStepsListener("focus", this._stepFocusListener);
+  }
+  get steps() {
+    return JSON.parse(JSON.stringify(this._steps));
+  }
+  set steps(value) {
+    if (Array.isArray(value) && value.length > 0) {
+      this._steps = [...value.map((s) => __spreadValues({}, s))];
+    } else {
+      this._steps = [];
+      return;
+    }
+    this._renderConfiguration();
+  }
+  get selectedIndex() {
+    return this._selectedIndex;
+  }
+  set selectedIndex(value) {
+    if (!isDefined(value)) {
+      value = 0;
+    } else if (!isNumber(value)) {
+      const v = Number(value);
+      value = !isNaN(v) ? v : 0;
+    }
+    if (this._selectedIndex !== value) {
+      this._selectedIndex = value;
+      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.SELECTED_INDEX, this._selectedIndex.toString());
+      this._applySelectedIndex();
+    }
+  }
+  get linear() {
+    return this._linear;
+  }
+  set linear(value) {
+    value = Boolean(value);
+    if (this._linear !== value) {
+      this._linear = value;
+      this._adapter.setLinearState(this._linear);
+      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.LINEAR, this._linear.toString());
+    }
+  }
+  get alternative() {
+    return this._alternative;
+  }
+  set alternative(value) {
+    value = Boolean(value);
+    if (this._alternative !== value) {
+      this._alternative = value;
+      this._adapter.setAlternativeState(this._alternative);
+      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.ALTERNATIVE, this._alternative.toString());
+    }
+  }
+  get layoutMode() {
+    return this._layoutMode;
+  }
+  set layoutMode(value) {
+    if (!/^(fixed|clustered)$/.test(value)) {
+      return;
+    }
+    if (this._layoutMode !== value) {
+      this._layoutMode = value;
+      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.LAYOUT_MODE, this._layoutMode);
+      this._adapter.setLayoutMode(this._layoutMode);
+    }
+  }
+  get layoutAlign() {
+    return this._layoutAlign;
+  }
+  set layoutAlign(value) {
+    if (!/^(left|center|right)$/.test(value)) {
+      return;
+    }
+    if (this._layoutAlign !== value) {
+      this._layoutAlign = value;
+      this._adapter.setLayoutAlign(this._layoutAlign);
+      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.LAYOUT_ALIGN, this._layoutAlign);
+    }
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  set disabled(value) {
+    if (value !== this._disabled) {
+      this._disabled = value;
+      this._applyDisabled();
+    }
+  }
+  get vertical() {
+    return this._vertical;
+  }
+  set vertical(value) {
+    if (value !== this._vertical) {
+      this._vertical = value;
+      this._applyVertical();
+      this._adapter.toggleHostAttribute(STEPPER_CONSTANTS.attributes.VERTICAL, this._vertical);
+    }
+  }
+  _applyVertical() {
+    this._adapter.setVertical(this._vertical);
+  }
+  _applyDisabled() {
+    if (this._disabled) {
+      this._adapter.setHostAttribute(STEPPER_CONSTANTS.attributes.DISABLED, "disabled");
+    } else {
+      this._adapter.removeHostAttribute(STEPPER_CONSTANTS.attributes.DISABLED);
+    }
+    this._adapter.toggleDisabled(this._disabled);
+  }
+  _applySelectedIndex() {
+    this._adapter.setSelectedByIndex(this._selectedIndex);
+  }
+  _handleClick(event) {
+    event.preventDefault();
+    if (this._linear) {
+      return;
+    }
+    const eventPath = getEventPath(event);
+    const stepRoot = eventPath.find((el) => el.classList && el.classList.contains(STEP_CONSTANTS.classes.STEP));
+    const step = eventPath.find((el) => el.localName === STEP_CONSTANTS.elementName);
+    if (stepRoot && step && !step.selected && !step.disabled && this._adapter.emitHostEvent(STEP_CONSTANTS.events.SELECT, step.index, true, true)) {
+      this._adapter.setSelected(step);
+      this.selectedIndex = step.index;
+    }
+  }
+  _renderConfiguration() {
+    const steps = StepperUtils.createSteps({
+      steps: this._steps,
+      selectedIndex: this._selectedIndex,
+      alternative: this._alternative,
+      layoutAlign: this._layoutAlign,
+      layoutMode: this._layoutMode,
+      linear: this._linear
+    });
+    this.disconnect();
+    this._adapter.applyConfiguredSteps(steps);
+    this.initialize();
+  }
+  _onKeydown(event) {
+    if (this._linear) {
+      return;
+    }
+    const key = this._getKeyFromEvent(event);
+    if (!this._adapter.isStepperFocused()) {
+      return;
+    }
+    if (!key) {
+      return;
+    }
+    if ([STEP_CONSTANTS.strings.HOME_KEY, STEP_CONSTANTS.strings.END_KEY, STEP_CONSTANTS.strings.ARROW_DOWN_KEY, STEPPER_CONSTANTS.strings.ARROW_UP_KEY].includes(key)) {
+      event.preventDefault();
+    }
+    const step = this._vertical ? this._determineVerticalMoveTarget(key) : this._determineMoveTarget(key);
+    if (step) {
+      this._moveFocusTo(step);
+    }
+  }
+  _moveFocusTo(step) {
+    getShadowElement(step, STEP_CONSTANTS.selectors.STEP).focus();
+  }
+  _getKeyFromEvent(evt) {
+    if (STEPPER_CONSTANTS.ACCEPTABLE_KEYS.includes(evt.key)) {
+      return evt.key;
+    }
+    return STEPPER_CONSTANTS.KEYCODE_MAP[evt.keyCode];
+  }
+  _determineMoveTarget(key) {
+    const step = this._adapter.getFocusedOrSelectedStep();
+    if (step) {
+      switch (key) {
+        case STEPPER_CONSTANTS.strings.ARROW_RIGHT_KEY:
+          return this._adapter.getStep(step.index + 1);
+        case STEPPER_CONSTANTS.strings.ARROW_LEFT_KEY:
+          return this._adapter.getStep(step.index - 1);
+        case STEPPER_CONSTANTS.strings.HOME_KEY:
+          return this._adapter.getStep(0);
+        case STEPPER_CONSTANTS.strings.END_KEY:
+          return this._adapter.getLastStep();
+      }
+    }
+    return step;
+  }
+  _determineVerticalMoveTarget(key) {
+    const step = this._adapter.getFocusedOrSelectedStep();
+    if (step) {
+      switch (key) {
+        case STEPPER_CONSTANTS.strings.ARROW_DOWN_KEY:
+          return this._adapter.getStep(step.index + 1);
+        case STEPPER_CONSTANTS.strings.ARROW_UP_KEY:
+          return this._adapter.getStep(step.index - 1);
+        case STEPPER_CONSTANTS.strings.HOME_KEY:
+          return this._adapter.getStep(0);
+        case STEPPER_CONSTANTS.strings.END_KEY:
+          return this._adapter.getLastStep();
+      }
+    }
+    return step;
+  }
+  _onSlotChange(event) {
+    this.disconnect();
+    this.initialize();
+  }
+  _onStepExpandedContentFocusIn(event) {
+    const step = this._adapter.getStep(event.detail.index + 1);
+    if (step) {
+      step.setStepTabIndex(0);
+    }
+    event.detail.setStepTabIndex(0);
+  }
+  _onStepExpandedContentFocusOut(event) {
+    const focusOutStep = event.target;
+    const step = this._adapter.getStep(focusOutStep.index + 1);
+    if (step) {
+      step.setStepTabIndex(-1);
+    }
+    focusOutStep.setStepTabIndex(-1);
+  }
+  _onStepFocus() {
+    this._adapter.toggleRootClass(STEPPER_CONSTANTS.classes.FOCUSED, true);
+  }
+  _onStepBlur() {
+    this._adapter.toggleRootClass(STEPPER_CONSTANTS.classes.FOCUSED, false);
+  }
+  _patchBrowser() {
+    if (new Platform().SAFARI()) {
+      this._adapter.patchSafari();
+    }
+  }
+};
+
+// dist/build/lib/staging/src/stepper/stepper/stepper.ts
+var template = '<template><div class="forge-stepper" part="root"><slot></slot></div></template>';
+var styles = ".forge-stepper{display:-webkit-box;display:flex;-webkit-box-align:center;align-items:center;white-space:nowrap;overflow:hidden}.forge-stepper:not(.forge-stepper--vertical) ::slotted(*){display:-webkit-box;display:flex;-webkit-box-align:center;align-items:center;position:relative;min-width:112px}.forge-stepper--fixed ::slotted(*){-webkit-box-flex:1;flex:1}.forge-stepper--alternative{-webkit-box-align:start;align-items:flex-start}.forge-stepper--alternative ::slotted(*){min-width:160px}.forge-stepper--align-left{-webkit-box-pack:start;justify-content:flex-start}.forge-stepper--align-center{-webkit-box-pack:center;justify-content:center}.forge-stepper--align-right{-webkit-box-pack:end;justify-content:flex-end}:host{display:block}:host([hidden]){display:none}:host([vertical]) .forge-stepper{display:unset;-webkit-box-align:unset;align-items:unset;white-space:unset;overflow:unset}";
+var StepperComponent = class extends BaseComponent {
+  constructor() {
+    super();
+    attachShadowTemplate(this, template, styles);
+    this._foundation = new StepperFoundation(new StepperAdapter(this));
+  }
+  static get observedAttributes() {
+    return [
+      STEPPER_CONSTANTS.attributes.SELECTED_INDEX,
+      STEPPER_CONSTANTS.attributes.LINEAR,
+      STEPPER_CONSTANTS.attributes.ALTERNATIVE,
+      STEPPER_CONSTANTS.attributes.LAYOUT_MODE,
+      STEPPER_CONSTANTS.attributes.LAYOUT_ALIGN,
+      STEPPER_CONSTANTS.attributes.DISABLED,
+      STEPPER_CONSTANTS.attributes.VERTICAL
+    ];
+  }
+  async connectedCallback() {
+    await ensureChildren(this);
+    this._foundation.initialize();
+  }
+  disconnectedCallback() {
+    this._foundation.disconnect();
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    switch (name) {
+      case STEPPER_CONSTANTS.attributes.SELECTED_INDEX:
+        this.selectedIndex = Number(newValue) || 0;
+        break;
+      case STEPPER_CONSTANTS.attributes.LINEAR:
+        this.linear = coerceBoolean(newValue);
+        break;
+      case STEPPER_CONSTANTS.attributes.ALTERNATIVE:
+        this.alternative = coerceBoolean(newValue);
+        break;
+      case STEPPER_CONSTANTS.attributes.LAYOUT_MODE:
+        this.layoutMode = newValue;
+        break;
+      case STEPPER_CONSTANTS.attributes.LAYOUT_ALIGN:
+        this.layoutAlign = newValue;
+        break;
+      case STEPPER_CONSTANTS.attributes.DISABLED:
+        this.disabled = coerceBoolean(newValue);
+        break;
+      case STEPPER_CONSTANTS.attributes.VERTICAL:
+        this.vertical = coerceBoolean(newValue);
+        break;
+    }
+  }
+};
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "steps", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "selectedIndex", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "linear", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "alternative", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "layoutMode", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "layoutAlign", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "disabled", 2);
+__decorateClass([
+  FoundationProperty()
+], StepperComponent.prototype, "vertical", 2);
+StepperComponent = __decorateClass([
+  CustomElement({
+    name: STEPPER_CONSTANTS.elementName,
+    dependencies: [StepComponent]
+  })
+], StepperComponent);
+
+// dist/build/lib/staging/src/stepper/stepper/index.ts
+function defineStepperComponent() {
+  defineCustomElement(StepperComponent);
+}
+
+export {
+  STEPPER_CONSTANTS,
+  StepperAdapter,
+  StepperFoundation,
+  StepperComponent,
+  defineStepperComponent
+};
+//# sourceMappingURL=chunk.FBUQQD2T.js.map