V1

node_modules/vuetify/es5/components/VStepper/VStepper.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VStepper/VStepper.sass");
+
+var _registrable = require("../../mixins/registrable");
+
+var _proxyable = _interopRequireDefault(require("../../mixins/proxyable"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _console = require("../../util/console");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var baseMixins = (0, _mixins.default)((0, _registrable.provide)('stepper'), _proxyable.default, _themeable.default);
+/* @vue/component */
+
+var _default = baseMixins.extend({
+  name: 'v-stepper',
+  provide: function provide() {
+    return {
+      stepClick: this.stepClick,
+      isVertical: this.vertical
+    };
+  },
+  props: {
+    altLabels: Boolean,
+    nonLinear: Boolean,
+    vertical: Boolean
+  },
+  data: function data() {
+    var data = {
+      isBooted: false,
+      steps: [],
+      content: [],
+      isReverse: false
+    };
+    data.internalLazyValue = this.value != null ? this.value : (data[0] || {}).step || 1;
+    return data;
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-stepper--is-booted': this.isBooted,
+        'v-stepper--vertical': this.vertical,
+        'v-stepper--alt-labels': this.altLabels,
+        'v-stepper--non-linear': this.nonLinear
+      }, this.themeClasses);
+    }
+  },
+  watch: {
+    internalValue: function internalValue(val, oldVal) {
+      this.isReverse = Number(val) < Number(oldVal);
+      oldVal && (this.isBooted = true);
+      this.updateView();
+    }
+  },
+  created: function created() {
+    /* istanbul ignore next */
+    if (this.$listeners.input) {
+      (0, _console.breaking)('@input', '@change', this);
+    }
+  },
+  mounted: function mounted() {
+    this.updateView();
+  },
+  methods: {
+    register: function register(item) {
+      if (item.$options.name === 'v-stepper-step') {
+        this.steps.push(item);
+      } else if (item.$options.name === 'v-stepper-content') {
+        item.isVertical = this.vertical;
+        this.content.push(item);
+      }
+    },
+    unregister: function unregister(item) {
+      if (item.$options.name === 'v-stepper-step') {
+        this.steps = this.steps.filter(function (i) {
+          return i !== item;
+        });
+      } else if (item.$options.name === 'v-stepper-content') {
+        item.isVertical = this.vertical;
+        this.content = this.content.filter(function (i) {
+          return i !== item;
+        });
+      }
+    },
+    stepClick: function stepClick(step) {
+      var _this = this;
+
+      this.$nextTick(function () {
+        return _this.internalValue = step;
+      });
+    },
+    updateView: function updateView() {
+      for (var index = this.steps.length; --index >= 0;) {
+        this.steps[index].toggle(this.internalValue);
+      }
+
+      for (var _index = this.content.length; --_index >= 0;) {
+        this.content[_index].toggle(this.internalValue, this.isReverse);
+      }
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      staticClass: 'v-stepper',
+      class: this.classes
+    }, this.$slots.default);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VStepper.js.map

node_modules/vuetify/es5/components/VStepper/VStepperContent.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _transitions = require("../transitions");
+
+var _registrable = require("../../mixins/registrable");
+
+var _helpers = require("../../util/helpers");
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Components
+// Mixins
+// Helpers
+// Utilities
+var baseMixins = (0, _mixins.default)((0, _registrable.inject)('stepper', 'v-stepper-content', 'v-stepper'));
+/* @vue/component */
+
+var _default = baseMixins.extend().extend({
+  name: 'v-stepper-content',
+  inject: {
+    isVerticalProvided: {
+      from: 'isVertical'
+    }
+  },
+  props: {
+    step: {
+      type: [Number, String],
+      required: true
+    }
+  },
+  data: function data() {
+    return {
+      height: 0,
+      // Must be null to allow
+      // previous comparison
+      isActive: null,
+      isReverse: false,
+      isVertical: this.isVerticalProvided
+    };
+  },
+  computed: {
+    computedTransition: function computedTransition() {
+      // Fix for #8978
+      var reverse = this.$vuetify.rtl ? !this.isReverse : this.isReverse;
+      return reverse ? _transitions.VTabReverseTransition : _transitions.VTabTransition;
+    },
+    styles: function styles() {
+      if (!this.isVertical) return {};
+      return {
+        height: (0, _helpers.convertToUnit)(this.height)
+      };
+    }
+  },
+  watch: {
+    isActive: function isActive(current, previous) {
+      // If active and the previous state
+      // was null, is just booting up
+      if (current && previous == null) {
+        this.height = 'auto';
+        return;
+      }
+
+      if (!this.isVertical) return;
+      if (this.isActive) this.enter();else this.leave();
+    }
+  },
+  mounted: function mounted() {
+    this.$refs.wrapper.addEventListener('transitionend', this.onTransition, false);
+    this.stepper && this.stepper.register(this);
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.$refs.wrapper.removeEventListener('transitionend', this.onTransition, false);
+    this.stepper && this.stepper.unregister(this);
+  },
+  methods: {
+    onTransition: function onTransition(e) {
+      if (!this.isActive || e.propertyName !== 'height') return;
+      this.height = 'auto';
+    },
+    enter: function enter() {
+      var _this = this;
+
+      var scrollHeight = 0; // Render bug with height
+
+      requestAnimationFrame(function () {
+        scrollHeight = _this.$refs.wrapper.scrollHeight;
+      });
+      this.height = 0; // Give the collapsing element time to collapse
+
+      setTimeout(function () {
+        return _this.isActive && (_this.height = scrollHeight || 'auto');
+      }, 450);
+    },
+    leave: function leave() {
+      var _this2 = this;
+
+      this.height = this.$refs.wrapper.clientHeight;
+      setTimeout(function () {
+        return _this2.height = 0;
+      }, 10);
+    },
+    toggle: function toggle(step, reverse) {
+      this.isActive = step.toString() === this.step.toString();
+      this.isReverse = reverse;
+    }
+  },
+  render: function render(h) {
+    var contentData = {
+      staticClass: 'v-stepper__content'
+    };
+    var wrapperData = {
+      staticClass: 'v-stepper__wrapper',
+      style: this.styles,
+      ref: 'wrapper'
+    };
+
+    if (!this.isVertical) {
+      contentData.directives = [{
+        name: 'show',
+        value: this.isActive
+      }];
+    }
+
+    var wrapper = h('div', wrapperData, [this.$slots.default]);
+    var content = h('div', contentData, [wrapper]);
+    return h(this.computedTransition, {
+      on: this.$listeners
+    }, [content]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VStepperContent.js.map

node_modules/vuetify/es5/components/VStepper/VStepperStep.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _VIcon = _interopRequireDefault(require("../VIcon"));
+
+var _colorable = _interopRequireDefault(require("../../mixins/colorable"));
+
+var _registrable = require("../../mixins/registrable");
+
+var _ripple = _interopRequireDefault(require("../../directives/ripple"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Components
+// Mixins
+// Directives
+// Utilities
+var baseMixins = (0, _mixins.default)(_colorable.default, (0, _registrable.inject)('stepper', 'v-stepper-step', 'v-stepper'));
+/* @vue/component */
+
+var _default2 = baseMixins.extend().extend({
+  name: 'v-stepper-step',
+  directives: {
+    ripple: _ripple.default
+  },
+  inject: ['stepClick'],
+  props: {
+    color: {
+      type: String,
+      default: 'primary'
+    },
+    complete: Boolean,
+    completeIcon: {
+      type: String,
+      default: '$complete'
+    },
+    editable: Boolean,
+    editIcon: {
+      type: String,
+      default: '$edit'
+    },
+    errorIcon: {
+      type: String,
+      default: '$error'
+    },
+    rules: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    step: [Number, String]
+  },
+  data: function data() {
+    return {
+      isActive: false,
+      isInactive: true
+    };
+  },
+  computed: {
+    classes: function classes() {
+      return {
+        'v-stepper__step--active': this.isActive,
+        'v-stepper__step--editable': this.editable,
+        'v-stepper__step--inactive': this.isInactive,
+        'v-stepper__step--error error--text': this.hasError,
+        'v-stepper__step--complete': this.complete
+      };
+    },
+    hasError: function hasError() {
+      return this.rules.some(function (validate) {
+        return validate() !== true;
+      });
+    }
+  },
+  mounted: function mounted() {
+    this.stepper && this.stepper.register(this);
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.stepper && this.stepper.unregister(this);
+  },
+  methods: {
+    click: function click(e) {
+      e.stopPropagation();
+      this.$emit('click', e);
+
+      if (this.editable) {
+        this.stepClick(this.step);
+      }
+    },
+    genIcon: function genIcon(icon) {
+      return this.$createElement(_VIcon.default, icon);
+    },
+    genLabel: function genLabel() {
+      return this.$createElement('div', {
+        staticClass: 'v-stepper__label'
+      }, this.$slots.default);
+    },
+    genStep: function genStep() {
+      var color = !this.hasError && (this.complete || this.isActive) ? this.color : false;
+      return this.$createElement('span', this.setBackgroundColor(color, {
+        staticClass: 'v-stepper__step__step'
+      }), this.genStepContent());
+    },
+    genStepContent: function genStepContent() {
+      var children = [];
+
+      if (this.hasError) {
+        children.push(this.genIcon(this.errorIcon));
+      } else if (this.complete) {
+        if (this.editable) {
+          children.push(this.genIcon(this.editIcon));
+        } else {
+          children.push(this.genIcon(this.completeIcon));
+        }
+      } else {
+        children.push(String(this.step));
+      }
+
+      return children;
+    },
+    toggle: function toggle(step) {
+      this.isActive = step.toString() === this.step.toString();
+      this.isInactive = Number(step) < Number(this.step);
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      staticClass: 'v-stepper__step',
+      class: this.classes,
+      directives: [{
+        name: 'ripple',
+        value: this.editable
+      }],
+      on: {
+        click: this.click
+      }
+    }, [this.genStep(), this.genLabel()]);
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VStepperStep.js.map

node_modules/vuetify/es5/components/VStepper/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VStepper", {
+  enumerable: true,
+  get: function get() {
+    return _VStepper.default;
+  }
+});
+Object.defineProperty(exports, "VStepperStep", {
+  enumerable: true,
+  get: function get() {
+    return _VStepperStep.default;
+  }
+});
+Object.defineProperty(exports, "VStepperContent", {
+  enumerable: true,
+  get: function get() {
+    return _VStepperContent.default;
+  }
+});
+exports.default = exports.VStepperItems = exports.VStepperHeader = void 0;
+
+var _helpers = require("../../util/helpers");
+
+var _VStepper = _interopRequireDefault(require("./VStepper"));
+
+var _VStepperStep = _interopRequireDefault(require("./VStepperStep"));
+
+var _VStepperContent = _interopRequireDefault(require("./VStepperContent"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var VStepperHeader = (0, _helpers.createSimpleFunctional)('v-stepper__header');
+exports.VStepperHeader = VStepperHeader;
+var VStepperItems = (0, _helpers.createSimpleFunctional)('v-stepper__items');
+exports.VStepperItems = VStepperItems;
+var _default = {
+  $_vuetify_subcomponents: {
+    VStepper: _VStepper.default,
+    VStepperContent: _VStepperContent.default,
+    VStepperStep: _VStepperStep.default,
+    VStepperHeader: VStepperHeader,
+    VStepperItems: VStepperItems
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VStepper/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VStepper/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;;;AAEA,IAAM,cAAc,GAAG,qCAAuB,mBAAvB,CAAvB;;AACA,IAAM,aAAa,GAAG,qCAAuB,kBAAvB,CAAtB;;eAUe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,QAAQ,EAAR,iBADuB;AAEvB,IAAA,eAAe,EAAf,wBAFuB;AAGvB,IAAA,YAAY,EAAZ,qBAHuB;AAIvB,IAAA,cAAc,EAAd,cAJuB;AAKvB,IAAA,aAAa,EAAb;AALuB;AADZ,C","sourcesContent":["import { createSimpleFunctional } from '../../util/helpers'\nimport VStepper from './VStepper'\nimport VStepperStep from './VStepperStep'\nimport VStepperContent from './VStepperContent'\n\nconst VStepperHeader = createSimpleFunctional('v-stepper__header')\nconst VStepperItems = createSimpleFunctional('v-stepper__items')\n\nexport {\n  VStepper,\n  VStepperContent,\n  VStepperStep,\n  VStepperHeader,\n  VStepperItems,\n}\n\nexport default {\n  $_vuetify_subcomponents: {\n    VStepper,\n    VStepperContent,\n    VStepperStep,\n    VStepperHeader,\n    VStepperItems,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}