init component

node_modules/buetify/lib/components/steps/BStepItem.d.ts

@@ -0,0 +1,51 @@
+declare const _default: import("vue").DefineComponent<{
+    label: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    step: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    variant: {
+        type: import("vue").PropType<import("../..").ColorVariant>;
+        default: "";
+    };
+    icon: {
+        type: import("vue").PropType<import("vue").Component<any, any, any, Record<string, import("@vue/reactivity").ComputedGetter<any> | import("vue").WritableComputedOptions<any>>, import("vue").MethodOptions>>;
+    };
+    isClickable: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    isCompleted: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    isVisible: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    variant: import("../..").ColorVariant;
+    isVisible: boolean;
+    label: string;
+    isClickable: boolean;
+    isCompleted: boolean;
+} & {
+    icon?: import("vue").ComponentOptions<any, any, any, Record<string, import("@vue/reactivity").ComputedGetter<any> | import("vue").WritableComputedOptions<any>>, import("vue").MethodOptions, any, any, any> | import("vue").FunctionalComponent<any, any> | {
+        new (...args: any[]): any;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } | undefined;
+    step?: string | undefined;
+}>, {
+    variant: import("../..").ColorVariant;
+    isVisible: boolean;
+    isClickable: boolean;
+    isCompleted: boolean;
+}>;
+export default _default;

node_modules/buetify/lib/components/steps/BStepItem.js

@@ -0,0 +1,32 @@
+import { toUndefined } from 'fp-ts/lib/Option';
+import { defineComponent, inject, h, computed, withDirectives, vShow } from 'vue';
+import { BStepItemPropsDefinition, DEFAULT_STEP_INJECTION, STEP_ITEM_NAME, STEPS_SYMBOL } from './shared';
+export default defineComponent({
+  name: STEP_ITEM_NAME,
+  props: BStepItemPropsDefinition,
+
+  setup(props, {
+    slots
+  }) {
+    const injection = inject(STEPS_SYMBOL, DEFAULT_STEP_INJECTION);
+    const index = injection.steps.findIndex(p => p.label === props.label);
+
+    if (index > -1) {
+      injection.steps.splice(index, 1, props);
+    } else {
+      injection.steps.push(props);
+    }
+
+    const isActive = computed(() => toUndefined(injection.activeLabel.value) === props.label);
+    return () => {
+      return withDirectives(h('section', {
+        class: 'step-item',
+        'aria-label': props.label
+      }, slots.default && slots.default({
+        isActive: isActive.value
+      })), [[vShow, isActive.value]]);
+    };
+  }
+
+});
+//# sourceMappingURL=BStepItem.js.map

node_modules/buetify/lib/components/steps/BStepItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/steps/BStepItem.ts"],"names":[],"mappings":"AAAA,SAAS,WAAT,QAA4B,kBAA5B;AACA,SAAS,eAAT,EAA0B,MAA1B,EAAkC,CAAlC,EAAqC,QAArC,EAA+C,cAA/C,EAA+D,KAA/D,QAA4E,KAA5E;AACA,SAAS,wBAAT,EAAmC,sBAAnC,EAA2D,cAA3D,EAA2E,YAA3E,QAA+F,UAA/F;AAEA,eAAe,eAAe,CAAC;AAC7B,EAAA,IAAI,EAAE,cADuB;AAE7B,EAAA,KAAK,EAAE,wBAFsB;;AAG7B,EAAA,KAAK,CAAC,KAAD,EAAQ;AAAE,IAAA;AAAF,GAAR,EAAiB;AACpB,UAAM,SAAS,GAAG,MAAM,CAAC,YAAD,EAAe,sBAAf,CAAxB;AAEA,UAAM,KAAK,GAAG,SAAS,CAAC,KAAV,CAAgB,SAAhB,CAA0B,CAAC,IAAI,CAAC,CAAC,KAAF,KAAY,KAAK,CAAC,KAAjD,CAAd;;AAEA,QAAI,KAAK,GAAG,CAAC,CAAb,EAAgB;AACd,MAAA,SAAS,CAAC,KAAV,CAAgB,MAAhB,CAAuB,KAAvB,EAA8B,CAA9B,EAAiC,KAAjC;AACD,KAFD,MAEO;AACL,MAAA,SAAS,CAAC,KAAV,CAAgB,IAAhB,CAAqB,KAArB;AACD;;AAED,UAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,WAAV,CAAsB,KAAvB,CAAX,KAA6C,KAAK,CAAC,KAA1D,CAAzB;AAEA,WAAO,MAAK;AACV,aAAO,cAAc,CACnB,CAAC,CACC,SADD,EAEC;AACE,QAAA,KAAK,EAAE,WADT;AAEE,sBAAc,KAAK,CAAC;AAFtB,OAFD,EAMC,KAAK,CAAC,OAAN,IAAiB,KAAK,CAAC,OAAN,CAAc;AAAE,QAAA,QAAQ,EAAE,QAAQ,CAAC;AAArB,OAAd,CANlB,CADkB,EASnB,CAAC,CAAC,KAAD,EAAQ,QAAQ,CAAC,KAAjB,CAAD,CATmB,CAArB;AAWD,KAZD;AAaD;;AA7B4B,CAAD,CAA9B","sourcesContent":["import { toUndefined } from 'fp-ts/lib/Option';\nimport { defineComponent, inject, h, computed, withDirectives, vShow } from 'vue';\nimport { BStepItemPropsDefinition, DEFAULT_STEP_INJECTION, STEP_ITEM_NAME, STEPS_SYMBOL } from './shared';\n\nexport default defineComponent({\n  name: STEP_ITEM_NAME,\n  props: BStepItemPropsDefinition,\n  setup(props, { slots }) {\n    const injection = inject(STEPS_SYMBOL, DEFAULT_STEP_INJECTION);\n\n    const index = injection.steps.findIndex(p => p.label === props.label);\n\n    if (index > -1) {\n      injection.steps.splice(index, 1, props);\n    } else {\n      injection.steps.push(props);\n    }\n\n    const isActive = computed(() => toUndefined(injection.activeLabel.value) === props.label);\n\n    return () => {\n      return withDirectives(\n        h(\n          'section',\n          {\n            class: 'step-item',\n            'aria-label': props.label\n          },\n          slots.default && slots.default({ isActive: isActive.value })\n        ),\n        [[vShow, isActive.value]]\n      );\n    };\n  }\n});\n"],"sourceRoot":"","file":"BStepItem.js"}

node_modules/buetify/lib/components/steps/BSteps.d.ts

@@ -0,0 +1,141 @@
+import './steps.sass';
+import { ColorVariant } from '../../types/ColorVariants';
+import { VNode, PropType, ExtractPropTypes } from 'vue';
+export declare type StepsSize = 'is-small' | 'is-medium' | 'is-large' | '';
+export declare type StepsPosition = 'is-right' | '';
+export declare type StepLabelPosition = 'is-right' | 'is-left' | '';
+export declare type StepsMobileMode = 'minimal' | 'compact' | '';
+export declare const BStepsPropsDefinition: {
+    position: {
+        type: PropType<StepsPosition>;
+        default: "";
+    };
+    labelPosition: {
+        type: PropType<StepLabelPosition>;
+        default: string;
+    };
+    variant: {
+        type: PropType<ColorVariant>;
+        default: "";
+    };
+    size: {
+        type: PropType<import("../..").SizeVariant>;
+        default: "";
+    };
+    isAnimated: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    mobileMode: {
+        type: PropType<StepsMobileMode>;
+        default: "minimal";
+    };
+    isRounded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isVertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    themeMap: {
+        type: PropType<import("../..").ThemeColorMap>;
+        required: boolean;
+        default: import("fp-ts/lib/function").Lazy<import("../..").ThemeColorMap>;
+    };
+    isThemeable: {
+        type: PropType<boolean>;
+        required: boolean;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<number>;
+        required: false;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<import("fp-ts/lib/function").FunctionN<[number], void>>;
+        default: import("fp-ts/lib/function").Lazy<import("fp-ts/lib/function").FunctionN<[number], void>>;
+    };
+};
+export declare type BStepsProps = ExtractPropTypes<typeof BStepsPropsDefinition>;
+declare const _default: import("vue").DefineComponent<{
+    position: {
+        type: PropType<StepsPosition>;
+        default: "";
+    };
+    labelPosition: {
+        type: PropType<StepLabelPosition>;
+        default: string;
+    };
+    variant: {
+        type: PropType<ColorVariant>;
+        default: "";
+    };
+    size: {
+        type: PropType<import("../..").SizeVariant>;
+        default: "";
+    };
+    isAnimated: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    mobileMode: {
+        type: PropType<StepsMobileMode>;
+        default: "minimal";
+    };
+    isRounded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isVertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    themeMap: {
+        type: PropType<import("../..").ThemeColorMap>;
+        required: boolean;
+        default: import("fp-ts/lib/function").Lazy<import("../..").ThemeColorMap>;
+    };
+    isThemeable: {
+        type: PropType<boolean>;
+        required: boolean;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<number>;
+        required: false;
+    };
+    'onUpdate:modelValue': {
+        type: PropType<import("fp-ts/lib/function").FunctionN<[number], void>>;
+        default: import("fp-ts/lib/function").Lazy<import("fp-ts/lib/function").FunctionN<[number], void>>;
+    };
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    isThemeable: boolean;
+    themeMap: import("../..").ThemeColorMap;
+    variant: ColorVariant;
+    size: import("../..").SizeVariant;
+    position: StepsPosition;
+    isRounded: boolean;
+    "onUpdate:modelValue": import("fp-ts/lib/function").FunctionN<[number], void>;
+    labelPosition: StepLabelPosition;
+    isAnimated: boolean;
+    mobileMode: StepsMobileMode;
+    isVertical: boolean;
+} & {
+    modelValue?: number | undefined;
+}>, {
+    isThemeable: boolean;
+    themeMap: import("../..").ThemeColorMap;
+    variant: ColorVariant;
+    size: import("../..").SizeVariant;
+    position: StepsPosition;
+    isRounded: boolean;
+    "onUpdate:modelValue": import("fp-ts/lib/function").FunctionN<[number], void>;
+    labelPosition: StepLabelPosition;
+    isAnimated: boolean;
+    mobileMode: StepsMobileMode;
+    isVertical: boolean;
+}>;
+export default _default;

node_modules/buetify/lib/components/steps/BSteps.js

@@ -0,0 +1,156 @@
+import "../../../src/components/steps/steps.sass";
+import { lookup } from 'fp-ts/Array';
+import { pipe } from 'fp-ts/function';
+import { getUseModelPropsDefinition, useModel } from '../../composables/model';
+import { DefaultThemePropsDefinition, useTheme } from '../../composables/theme';
+import { map } from 'fp-ts/lib/Option';
+import { computed, cloneVNode, TransitionGroup, defineComponent, nextTick, h, provide, shallowRef, withDirectives, vShow, shallowReactive } from 'vue';
+import { STEPS_SYMBOL } from './shared';
+export const BStepsPropsDefinition = { ...getUseModelPropsDefinition(),
+  ...DefaultThemePropsDefinition,
+  position: {
+    type: String,
+    default: ''
+  },
+  labelPosition: {
+    type: String,
+    default: ''
+  },
+  variant: {
+    type: String,
+    default: ''
+  },
+  size: {
+    type: String,
+    default: ''
+  },
+  isAnimated: {
+    type: Boolean,
+    default: true
+  },
+  mobileMode: {
+    type: String,
+    default: 'minimal'
+  },
+  isRounded: {
+    type: Boolean,
+    default: true
+  },
+  isVertical: {
+    type: Boolean,
+    default: false
+  }
+};
+
+function getOnStepItemClick(index, model, transition) {
+  return () => {
+    const val = model.modelValue.value || 0;
+
+    if (val !== index) {
+      transition.value = index < val ? 'slide-next' : 'slide-prev';
+      nextTick().then(() => {
+        model.modelValue.value = index;
+      });
+    }
+  };
+}
+
+function getGenerateNavItem(props, model, injection, transition) {
+  return function generateNavItem(step, index) {
+    const currentIndex = model.modelValue.value || 0;
+    const isClickable = step.isClickable ?? index < currentIndex;
+    return withDirectives(h('li', {
+      key: step.label,
+      class: [step.variant || props.variant, 'step-item', {
+        'is-previous': index < currentIndex,
+        'is-active': index === currentIndex
+      }]
+    }, [h('a', {
+      class: ['step-link', {
+        'is-clickable': isClickable
+      }],
+      onClick: isClickable ? getOnStepItemClick(index, model, transition) : undefined
+    }, [h('div', {
+      class: 'step-marker'
+    }, step.icon ? h(step.icon, {
+      size: props.size
+    }) : step.step ?? `${index + 1}`), h('div', {
+      class: 'step-details'
+    }, [h('span', {
+      class: 'step-title'
+    }, step.label)])])]), [[vShow, injection.steps[index]?.isVisible ?? true]]);
+  };
+}
+
+function generateNavHeader(props, model, injection, transition, themeClasses) {
+  return h('nav', {
+    class: ['steps', props.size, props.variant || null, {
+      'is-rounded': props.isRounded,
+      'is-animated': props.isAnimated,
+      'has-label-right': props.labelPosition === 'is-right',
+      'has-label-left': props.labelPosition === 'is-left',
+      'mobile-minimalist': props.mobileMode === 'minimal',
+      'mobile-compact': props.mobileMode === 'compact'
+    }, ...themeClasses]
+  }, h('ul', {
+    class: ['step-items']
+  }, injection.steps.map(getGenerateNavItem(props, model, injection, transition))));
+}
+
+function BStaticStepContent(_, {
+  slots
+}) {
+  return h('div', {
+    class: 'step-content'
+  }, slots.default && slots.default());
+}
+
+export default defineComponent({
+  name: 'b-steps',
+  props: BStepsPropsDefinition,
+
+  setup(props, context) {
+    const {
+      themeClasses
+    } = useTheme(props);
+    const model = useModel(props);
+    const transition = shallowRef('slide-next');
+    const steps = shallowReactive([]);
+    const isTransitioning = shallowRef(false);
+    const activeLabel = computed(() => pipe(steps, lookup(model.modelValue.value || 0), map(p => p.label)));
+    const injection = {
+      activeLabel,
+      steps
+    };
+    provide(STEPS_SYMBOL, injection);
+
+    function onBeforeEnter() {
+      isTransitioning.value = true;
+    }
+
+    function onAfterLeave() {
+      isTransitioning.value = false;
+    }
+
+    return () => {
+      return h('article', {
+        class: ['b-steps', props.size || null, {
+          'is-vertical': props.isVertical,
+          [props.position]: props.position && props.isVertical
+        }]
+      }, [generateNavHeader(props, model, injection, transition, themeClasses.value), props.isAnimated ? h('div', {
+        class: ['step-content', {
+          'is-transitioning': isTransitioning.value
+        }]
+      }, h(TransitionGroup, {
+        onBeforeEnter,
+        onAfterLeave,
+        name: transition.value
+      }, () => context.slots.default && context.slots.default().map((node, index) => cloneVNode(node, {
+        key: steps[index]?.label ?? index
+      })))) : h(BStaticStepContent, () => context.slots.default && context.slots.default())]);
+    };
+  }
+
+});
+//# sourceMappingURL=BSteps.js.map

node_modules/buetify/lib/components/steps/index.d.ts

@@ -0,0 +1,3 @@
+import BStepItem from './BStepItem';
+import BSteps from './BSteps';
+export { BStepItem, BSteps };

node_modules/buetify/lib/components/steps/index.js

@@ -0,0 +1,4 @@
+import BStepItem from './BStepItem';
+import BSteps from './BSteps';
+export { BStepItem, BSteps };
+//# sourceMappingURL=index.js.map

node_modules/buetify/lib/components/steps/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/steps/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAP,MAAsB,aAAtB;AACA,OAAO,MAAP,MAAmB,UAAnB;AAEA,SAAS,SAAT,EAAoB,MAApB","sourcesContent":["import BStepItem from './BStepItem';\nimport BSteps from './BSteps';\n\nexport { BStepItem, BSteps };\n"],"sourceRoot":"","file":"index.js"}

node_modules/buetify/lib/components/steps/shared.d.ts

@@ -0,0 +1,40 @@
+import { Component, ExtractPropTypes, PropType, Ref } from 'vue';
+import { Option } from 'fp-ts/lib/Option';
+import { ColorVariant } from '../../types/ColorVariants';
+export declare const STEPS_SYMBOL: unique symbol;
+export declare const STEP_ITEM_NAME = "b-step-item";
+export interface StepInjection {
+    activeLabel: Ref<Option<string>>;
+    steps: BStepItemProps[];
+}
+export declare const DEFAULT_STEP_INJECTION: StepInjection;
+export declare const BStepItemPropsDefinition: {
+    label: {
+        type: PropType<string>;
+        required: true;
+    };
+    step: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    variant: {
+        type: PropType<ColorVariant>;
+        default: "";
+    };
+    icon: {
+        type: PropType<Component<any, any, any, Record<string, import("@vue/reactivity").ComputedGetter<any> | import("vue").WritableComputedOptions<any>>, import("vue").MethodOptions>>;
+    };
+    isClickable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isCompleted: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    isVisible: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+};
+export declare type BStepItemProps = ExtractPropTypes<typeof BStepItemPropsDefinition>;

node_modules/buetify/lib/components/steps/shared.js

@@ -0,0 +1,38 @@
+import { shallowRef } from 'vue';
+import { none } from 'fp-ts/lib/Option';
+export const STEPS_SYMBOL = Symbol('steps');
+export const STEP_ITEM_NAME = 'b-step-item';
+export const DEFAULT_STEP_INJECTION = {
+  activeLabel: shallowRef(none),
+  steps: []
+};
+export const BStepItemPropsDefinition = {
+  label: {
+    type: String,
+    required: true
+  },
+  step: {
+    type: String,
+    required: false
+  },
+  variant: {
+    type: String,
+    default: ''
+  },
+  icon: {
+    type: [Function, Object]
+  },
+  isClickable: {
+    type: Boolean,
+    default: false
+  },
+  isCompleted: {
+    type: Boolean,
+    default: false
+  },
+  isVisible: {
+    type: Boolean,
+    default: true
+  }
+};
+//# sourceMappingURL=shared.js.map

node_modules/buetify/lib/components/steps/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/steps/shared.ts"],"names":[],"mappings":"AAAA,SAAqD,UAArD,QAAuE,KAAvE;AACA,SAAS,IAAT,QAA6B,kBAA7B;AAGA,OAAO,MAAM,YAAY,GAAG,MAAM,CAAC,OAAD,CAA3B;AAEP,OAAO,MAAM,cAAc,GAAG,aAAvB;AAOP,OAAO,MAAM,sBAAsB,GAAkB;AACnD,EAAA,WAAW,EAAE,UAAU,CAAC,IAAD,CAD4B;AAEnD,EAAA,KAAK,EAAE;AAF4C,CAA9C;AAKP,OAAO,MAAM,wBAAwB,GAAG;AACtC,EAAA,KAAK,EAAE;AACL,IAAA,IAAI,EAAE,MADD;AAEL,IAAA,QAAQ,EAAE;AAFL,GAD+B;AAKtC,EAAA,IAAI,EAAE;AACJ,IAAA,IAAI,EAAE,MADF;AAEJ,IAAA,QAAQ,EAAE;AAFN,GALgC;AAStC,EAAA,OAAO,EAAE;AACP,IAAA,IAAI,EAAE,MADC;AAEP,IAAA,OAAO,EAAE;AAFF,GAT6B;AAatC,EAAA,IAAI,EAAE;AACJ,IAAA,IAAI,EAAE,CAAC,QAAD,EAAW,MAAX;AADF,GAbgC;AAgBtC,EAAA,WAAW,EAAE;AACX,IAAA,IAAI,EAAE,OADK;AAEX,IAAA,OAAO,EAAE;AAFE,GAhByB;AAoBtC,EAAA,WAAW,EAAE;AACX,IAAA,IAAI,EAAE,OADK;AAEX,IAAA,OAAO,EAAE;AAFE,GApByB;AAwBtC,EAAA,SAAS,EAAE;AACT,IAAA,IAAI,EAAE,OADG;AAET,IAAA,OAAO,EAAE;AAFA;AAxB2B,CAAjC","sourcesContent":["import { Component, ExtractPropTypes, PropType, Ref, shallowRef } from 'vue';\nimport { none, Option } from 'fp-ts/lib/Option';\nimport { ColorVariant } from '../../types/ColorVariants';\n\nexport const STEPS_SYMBOL = Symbol('steps');\n\nexport const STEP_ITEM_NAME = 'b-step-item';\n\nexport interface StepInjection {\n  activeLabel: Ref<Option<string>>;\n  steps: BStepItemProps[];\n}\n\nexport const DEFAULT_STEP_INJECTION: StepInjection = {\n  activeLabel: shallowRef(none),\n  steps: []\n};\n\nexport const BStepItemPropsDefinition = {\n  label: {\n    type: String as PropType<string>,\n    required: true as const\n  },\n  step: {\n    type: String,\n    required: false\n  },\n  variant: {\n    type: String as PropType<ColorVariant>,\n    default: '' as const\n  },\n  icon: {\n    type: [Function, Object] as PropType<Component>\n  },\n  isClickable: {\n    type: Boolean as PropType<boolean>,\n    default: false\n  },\n  isCompleted: {\n    type: Boolean as PropType<boolean>,\n    default: false\n  },\n  isVisible: {\n    type: Boolean as PropType<boolean>,\n    default: true\n  }\n};\n\nexport type BStepItemProps = ExtractPropTypes<typeof BStepItemPropsDefinition>;\n"],"sourceRoot":"","file":"shared.js"}