itube-specs 0.0.195 → 0.0.205

package/components/page-components/f-chips-panel.vue

@@ -44,7 +44,7 @@
 </template>
 
 <script setup lang="ts">
-import { IChipsItem } from '@arkadykid/test/types';
+import type { IChipsItem } from '../../types';
 
 const props = defineProps<{
   items?: IChipsItem[];

package/components/page-components/f-filter-button.vue

@@ -0,0 +1,68 @@
+<template>
+  <FButton
+      class="f-filter-button"
+      :size="size"
+      :theme="theme"
+      aria-label="Filter"
+      :title="t('filter')"
+      @click="emit('update:modelValue', true)"
+  >
+    <FIcon name="adjustments-horizontal" size="16"/>
+    <span class="_from-sm"
+    >{{ buttonName }}
+      </span>
+    <FIcon
+        class="f-filter-button__icon _to-sm"
+        name="chevron-down"
+        size="16"
+        :class="{'--open': modelValue}"
+    />
+    <FIcon
+        v-if="count > 0"
+        class="f-filter-button__reset _from-sm"
+        name="close"
+        size="16"
+        aria-label="reset-filter"
+        role="button"
+        @click.stop="resetFilter"
+    />
+    <span
+        v-if="count > 0"
+        class="f-filter-button__mobile-count _to-sm"
+    >{{ mobileCount }}</span>
+  </FButton>
+</template>
+
+<script setup lang="ts">
+import type { ButtonSizes, ButtonThemes } from '~';
+
+const props = defineProps<{
+  count: number
+  modelValue: boolean
+  size?: ButtonSizes
+  theme?: ButtonThemes
+}>()
+
+const emit = defineEmits<{
+  (eventName: 'update:modelValue', value: Boolean): void
+}>()
+
+const { t } = useI18n()
+
+const buttonName = computed(() => {
+  return props.count > 0 ? t('plural.item', props.count) : t('filter');
+})
+
+function resetFilter() {
+  router.push({
+    query: {}
+  })
+}
+
+const mobileCount = computed(() => props.count > 9 ? '9+' : props.count);
+
+const router = useRouter()
+</script>
+
+<style scoped lang="scss">
+</style>

package/components/page-components/f-filter-chips.vue

@@ -0,0 +1,32 @@
+<template>
+  <FChipsPanel v-if="items.length > 0">
+    <FChips
+        v-for="(item, index) in items"
+        class="f-filter-chips"
+        with-close
+        :index="`f-filter-page-chips${index}`"
+        bright
+        :item="item"
+        @click="onChipsClick(item)"
+    ></FChips>
+  </FChipsPanel>
+</template>
+
+<script setup lang="ts">
+import type { IChipsItem } from '../../types';
+
+defineProps<{
+  items: IChipsItem[]
+}>();
+
+const emit = defineEmits<{
+  (eventName: 'click', eventValue: IChipsItem): void
+}>()
+
+function onChipsClick(item: IChipsItem) {
+  emit('click', item)
+}
+</script>
+
+<style scoped lang="scss">
+</style>

package/components/page-components/f-filter-model-chips.vue

@@ -0,0 +1,89 @@
+<template>
+  <FFilterChips
+      :items="chipsItems"
+      @click="(e: IChipsItem)=> onChipsClick(e)"
+  />
+</template>
+
+<script setup lang="ts">
+import type { IChipsItem, IModelFilter } from '../../types';
+import type { LocationQueryValue } from '#vue-router';
+import { useRoute, useRouter } from '#vue-router';
+import { getMonth } from '../../runtime';
+
+const props = defineProps<{
+  filters: IModelFilter[]
+}>();
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+
+const chipsItems = computed(() => {
+  const queryItems = Object.keys(route.query)
+      .filter(item => item.startsWith('filter'))
+      .map(item => item.replace('filter_', '')
+          .replace(/_/g, ' '));
+
+  const groups = Object.values(
+      queryItems.reduce((acc: Record<string, string[]>, str: string) => {
+        const parts = str.split(' ');
+        const last = parts.at(-1);
+        const key = ['from', 'to'].includes(last)
+            ? parts.slice(0, -1).join(' ')
+            : str;
+
+        acc[ key ] ??= [];
+
+        if (last === 'from') acc[ key ].unshift(str);
+        else acc[ key ].push(str);
+
+        return acc;
+      }, {})
+  )
+
+  const title = (item: string, index: number) => {
+    const filter = props.filters.find(filter => {
+      return filter.name === `${item.replace(/ /g, '_')
+          .replace('_from', '')
+          .replace('_to', '')
+      }`
+    });
+    const defaultValue = index === 0 ? filter?.options[ 0 ] : filter?.options[ filter.options.length - 1 ]
+    const value: LocationQueryValue | LocationQueryValue[] = route.query[ `filter_${item.replace(/ /g, '_')}` ];
+    if (item.split(' ').some(item => item === 'month')) {
+      return getMonth(t, Number(value) - 1 || Number(defaultValue) - 1)
+    }
+    return value || Number(defaultValue) - 1;
+  }
+
+  const text = (item: string[]) => [...new Set(item.map((subItem, index) => title(subItem, index)))].join(' - ');
+
+  const chipsTitle = ((item: string[]) => {
+    const key = Array.isArray(item) ? item[0].replace(' from', '') : item;
+    const convertedKey = props.filters.find(item => item.name.replace(/_/g, ' ') === key)?.title;
+    const textValue = `${convertedKey}: ${text(item)}`;
+    return textValue.length > 30 ? text(item) : textValue;
+  })
+
+  return groups.map((item) => ({
+    title: chipsTitle(item),
+    value: item.map(subItem => `filter_${subItem.replace(/ /g, '_')}`),
+  }));
+})
+
+function onChipsClick(item: IChipsItem) {
+  const query = { ...route.query };
+  if (Array.isArray(item.value) && item.value.length > 1) {
+    item.value.forEach((text: string) => {
+      delete query[ `${text}` ]
+    })
+  } else {
+    delete query[ `${item.value}` ]
+  }
+  router.replace({ query });
+}
+</script>
+
+<style scoped lang="scss">
+</style>

package/components/page-components/f-filter-page.vue

@@ -0,0 +1,229 @@
+<template>
+  <div class="f-filter-page">
+    <div class="f-filter-page__items-wrapper">
+      <details
+          v-for="(group, index) in groups"
+          :key="`filter-group-${index}`"
+          class="f-filter-page__group"
+          :open="index === 0 || activeGroup === index + 1"
+      >
+        <summary
+            v-if="filters.length > 0"
+            class="f-filter-page__group-title"
+        >
+          {{ group?.title }}
+          <FIcon
+              class="f-filter-page__group-title-icon"
+              size="32"
+              name="chevron-down"
+          />
+        </summary>
+        <div class="f-filter-page__items">
+          <template v-for="(item, subIndex) in filters">
+            <ClientOnly>
+              <FSlider
+                  v-if="(item.kind === 'range') && (item.group.name === group?.name)"
+                  :min="getRangeInfo(item.options)?.min"
+                  :max="getRangeInfo(item.options)?.max"
+                  :step="getRangeInfo(item.options)?.step"
+                  :model-value="[
+                        minRangeValue(item),
+                        maxRangeValue(item)
+                      ]"
+                  :title="item.title"
+                  :key="`model-filter-range-${subIndex}`"
+                  :active="isActiveSelect(item.name)"
+                  :format="formatterSlider(item.options)"
+                  :between="betweenText(item.options, getRangeInfo(item.options)?.min, getRangeInfo(item.options)?.max)"
+                  @update:model-value="val => updateRangeFilter(item, val)"
+              />
+            </ClientOnly>
+            <FSelect
+                v-if="(item.kind === 'select') && (item.group.name === group?.name)"
+                :name="item.name"
+                :model-value="getSelectValue(item.name)"
+                :items="selectItems(item)"
+                :count="getCount(item)"
+                :active="isActiveSelect(item.name)"
+                :key="`model-filter-select-${subIndex}`"
+                :label="item.title"
+                @update:model-value="val => updateSelectFilter(item.name, val)"
+            />
+          </template>
+        </div>
+      </details>
+    </div>
+    <div class="f-filter-page__footer _from-sm">
+      <p class="f-filter-page__footer-results">
+        <FIcon name="filter" size="24"/>
+        <span class="f-filter-page__footer-text">{{ `${count} ${t('results_found')}` }}</span>
+      </p>
+      <div class="f-filter-page__footer-buttons">
+        <FButton
+            wide
+            class="f-filter-page__reset"
+            :disabled="!isFiltered"
+            @click="onResetClick"
+            theme="secondary"
+        >{{ t('reset_all') }}
+        </FButton>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { IModelFilter, IModelFilterOptions } from '../../types';
+
+import { useRoute, useRouter } from 'vue-router';
+import { getMonth } from '../../runtime';
+
+const props = defineProps<{
+  filters: IModelFilter[]
+  count: number
+}>();
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+
+const activeGroup = computed(() => Number(route.query[ 'group' ]));
+
+const groups = computed(() => {
+  const uniqueNames = [...new Set(props.filters.map(item => item.group.title))];
+  return uniqueNames.map(name => {
+    return props.filters.find(filter => filter.group.title === name)?.group;
+  }).sort((a, b) => a?.order - b?.order)
+});
+
+const isFiltered = computed(() => Object.keys(route.query).some(item => item.startsWith('filter')));
+
+function selectItems(item: IModelFilter) {
+  return [
+    ...item.options.map(item => ({
+      value: item.name,
+      title: `${item.title} (${item.quantity})`,
+    }))
+  ]
+}
+
+function onResetClick() {
+  router.replace({ query: {} });
+}
+
+function getRangeInfo(options: { name: string; quantity: number; title: string }[]): {
+  min: number,
+  step: number,
+  max: number
+} | null {
+  const numericValues = options
+      .map(opt => Number(opt.name))
+      .filter(v => !isNaN(v))
+      .sort((a, b) => a - b);
+
+  if (numericValues.length === 0) {
+    return null;
+  }
+
+  const min = numericValues[ 0 ] || 0;
+  const max = numericValues[ numericValues.length - 1 ] || 100;
+  const step = numericValues.length > 1 ? 1 : 0;
+
+  return { min, step, max };
+}
+
+function updateRangeFilter(item: IModelFilter, val: string[] | number[]) {
+  const rangeInfo = getRangeInfo(item.options);
+  if (!rangeInfo) return;
+  const [from, to] = val;
+  const query = { ...route.query };
+
+  query[ `filter_${item.name}_from` ] = from;
+  query[ `filter_${item.name}_to` ] = to;
+
+  if (from === rangeInfo.min && to === rangeInfo.max) {
+    delete query[ `filter_${item.name}_from` ];
+    delete query[ `filter_${item.name}_to` ];
+  }
+
+  router.replace({ query });
+}
+
+function updateSelectFilter(name: string, val: any) {
+  const query = { ...route.query };
+
+  if (!val || val === 'all') {
+    delete query[ `filter_${name}` ];
+  } else {
+    query[ `filter_${name}` ] = val;
+  }
+
+  router.replace({ query });
+}
+
+function isActiveSelect(name: string) {
+  const baseName = name.replace(/_(from|to)$/, '');
+  return Object.keys(route.query).some(key => key.startsWith(`filter_${baseName}`));
+}
+
+function getSelectValue(name: string) {
+  const value = route.query[ `filter_${name}` ];
+  if (value) {
+    return value;
+  }
+  const filter = props.filters.find(f => f.name === name);
+  if (filter && filter.options.length > 0) {
+    return filter.options[ 0 ].name;
+  }
+  return null;
+}
+
+function getRangeValue(name: string, defaultValue: number | undefined) {
+  const value = route.query[ `filter_${name}` ];
+  if (value !== undefined) {
+    return Number(value);
+  } else {
+    return defaultValue;
+  }
+}
+
+function getCount(item: IModelFilter) {
+  const selectedValue = getSelectValue(item.name);
+  const targetValue = selectedValue !== null && selectedValue !== undefined && selectedValue !== '' ? selectedValue : 'all';
+  return props.filters.find(subitem => subitem.name === item.name)?.options.find(subitem => subitem.name === targetValue)?.quantity;
+}
+
+function minRangeValue(item: IModelFilter) {
+  return getRangeValue(`${item.name}_from`, getRangeInfo(item.options)?.min)
+}
+
+function maxRangeValue(item: IModelFilter) {
+  return getRangeValue(`${item.name}_to`, getRangeInfo(item.options)?.max)
+}
+
+function isSliderHasTitle(options: IModelFilterOptions[] | undefined): boolean | undefined {
+  return options && options[ 0 ] && isNaN(Number(options[ 0 ].title));
+}
+
+function formatterSlider(options: IModelFilterOptions[]) {
+  return (event: number) => {
+    if (isSliderHasTitle(options)) {
+      return getMonth(t, Math.round(event - 1));
+    } else {
+      return Math.round(event);
+    }
+  }
+}
+
+function betweenText(options: IModelFilterOptions[], min: number | undefined, max: number | undefined): string[] | undefined {
+  if (isSliderHasTitle(options)) {
+    const getText = (number: number | undefined): string | undefined => {
+      return options.find((item: IModelFilterOptions) => Number(item.name) === number)?.title;
+    }
+    return [getText(min) || '', getText(max) || ''];
+  }
+}
+</script>
+
+<style scoped lang="scss">
+</style>

package/components/page-components/f-filter-popup.vue

@@ -0,0 +1,166 @@
+<template>
+  <FPopup
+      v-model="isOpen"
+      v-if="isOpen"
+      sheet
+      @close="closePopup"
+  >
+    <template #title>{{ filterTitle }}</template>
+
+    <template #fixedContent>
+      <div class="f-filter-popup__main-filters">
+        <FSelect
+            name="duration"
+            v-model="durationValue"
+            :items="durationItems"
+            :placeholder="t('duration')"
+            icon="tape"
+        />
+        <FSelect
+            name="added"
+            v-model="addedValue"
+            :items="addedItems"
+            :placeholder="t('added')"
+            icon="clock"
+        />
+      </div>
+    </template>
+
+    <div class="f-filter-popup__filters">
+      <template
+          v-for="(item, index) in scheme"
+          :key="`scheme-${index}`"
+      >
+        <FInput
+            v-if="item.type === 'input'"
+            v-model="filterValue[item.title]"
+            :label="item?.label"
+        />
+        <FSelect
+            v-if="item.type === 'select'"
+            :name="item.title"
+            v-model="filterValue[item.title]"
+            :items="item.items"
+            :label="item?.label"
+            :placeholder="item.placeholder"
+        />
+      </template>
+    </div>
+
+    <template #footer>
+      <div class="f-filter-popup__buttons">
+        <FButton
+            theme="secondary"
+            wide
+            :disabled="!isFiltered"
+            @click="reset"
+        >{{ t('reset_all') }}
+        </FButton>
+        <FButton
+            wide
+            @click="saveResult"
+        >{{ t('apply') }}
+        </FButton>
+      </div>
+    </template>
+  </FPopup>
+</template>
+
+<script setup lang="ts">
+import type { FilterSchemeType, ISelectItem } from '../../types';
+
+const { t } = useI18n()
+
+const props = defineProps<{
+  addedItems: ISelectItem[]
+  durationItems: ISelectItem[]
+  modelValue: boolean
+  scheme: FilterSchemeType
+  count: number
+}>()
+
+const durationValue = ref('');
+const addedValue = ref('');
+const filterValue = ref({} as Record<string, string>);
+
+const route = useRoute();
+
+const categoriesFromQuery = route.query.categories
+  ? (typeof route.query.categories === 'string'
+    ? route.query.categories.split(',')
+    : route.query.categories.flatMap(cat => cat.split(',')))
+  : [];
+
+categoriesFromQuery.forEach(str => {
+  const [key, ...rest] = str.split('_');
+  if (key && rest.length > 0) {
+    filterValue.value[key] = rest.join('_');
+  }
+});
+
+durationValue.value = route.query['duration'] as string || '';
+addedValue.value = route.query['added'] as string || '';
+
+const emit = defineEmits<{
+  (eventName: 'update:modelValue', value: boolean): void
+}>()
+
+const isOpen = ref(props.modelValue)
+
+function closePopup() {
+  isOpen.value = false;
+  emit('update:modelValue', isOpen.value)
+}
+
+const router = useRouter();
+
+function saveResult() {
+  const oldQuery = { ...route.query };
+  delete oldQuery['page'];
+
+  const mainFiltersValue = {
+    ...(durationValue.value ? { duration: durationValue.value } : {}),
+    ...(addedValue.value ? { added: addedValue.value } : {})
+  };
+
+  const preserved = {
+    ...mainFiltersValue,
+    ...(oldQuery.sort ? { sort: oldQuery.sort } : {}),
+    ...(oldQuery.page ? { page: oldQuery.page } : {})
+  };
+
+  const categories = Object.entries(filterValue.value)
+    .filter(([, value]) => typeof value === 'string' && value.length > 0)
+    .map(([key, value]) => `${key}_${value}`);
+
+  const categoriesString = categories.join(',');
+
+  router.push({
+    query: {
+      ...preserved,
+      categories: categories.length ? categoriesString : undefined,
+    }
+  });
+
+  closePopup();
+}
+
+function reset() {
+  closePopup();
+  router.push({
+    query: {
+      categories: null,
+    }
+  });
+}
+
+const filterTitle = computed(() => {
+  const hasDuration = durationValue.value ? 1 : 0;
+  const hasAdded = addedValue.value ? 1 : 0;
+  const count = Object.keys(filterValue.value).length + hasAdded + hasDuration;
+  const filterText = count > 1 ? t('filters') : t('filter');
+  return count > 0 ? `${filterText}: ${count}` : t('filter')
+})
+
+const isFiltered = computed(() => !!route.query['categories']);
+</script>

package/components/page-components/f-filter-videos-chips.vue

@@ -0,0 +1,96 @@
+<template>
+  <FFilterChips
+      :items="chipsItems"
+      @click="(e: IChipsItem) => onChipsClick(e)"
+  />
+</template>
+
+<script setup lang="ts">
+import type { IChipsItem, ISelectItem } from '../../types';
+
+const route = useRoute();
+const router = useRouter();
+
+const props = defineProps<{
+  addedItems: ISelectItem[]
+  durationItems: ISelectItem[]
+}>()
+
+const chipsItems = computed(() => {
+  const items: IChipsItem[] = [];
+
+  // categories
+  const categoriesParam = route.query.categories;
+  if (categoriesParam) {
+    const categories = Array.isArray(categoriesParam)
+        ? categoriesParam.flatMap(c => c.split(','))
+        : categoriesParam.split(',');
+    categories.forEach(cat => {
+      const title = cat.split('_')[1] ?? cat;
+      items.push({
+        title,
+        value: cat,
+        key: 'categories'
+      });
+    });
+  }
+
+  // duration
+  const durationParam = route.query.duration;
+  if (durationParam) {
+    const title = props.durationItems.find(item => item.value === durationParam)?.title;
+    items.push({
+      title: `${title}`,
+      value: String(durationParam),
+      key: 'duration'
+    });
+  }
+
+  // added
+  const addedParam = route.query.added;
+  if (addedParam) {
+    const title = props.addedItems.find(item => item.value === addedParam)?.title;
+    items.push({
+      title: `${title}`,
+      value: String(addedParam),
+      key: 'added'
+    });
+  }
+
+  return items;
+});
+
+function onChipsClick(item: IChipsItem & { key?: string }) {
+  const query = { ...route.query };
+
+  if (item.key === 'categories') {
+    const categoriesParam = route.query.categories;
+    if (!categoriesParam) return;
+
+    const categories = Array.isArray(categoriesParam)
+        ? categoriesParam.flatMap(c => c.split(','))
+        : categoriesParam.split(',');
+
+    const updatedCategories = categories.filter(cat => cat !== item.value);
+
+    if (updatedCategories.length > 0) {
+      query.categories = updatedCategories.join(',');
+    } else {
+      delete query.categories;
+    }
+  }
+
+  if (item.key === 'duration') {
+    delete query.duration;
+  }
+
+  if (item.key === 'added') {
+    delete query.added;
+  }
+
+  router.replace({ query });
+}
+</script>
+
+<style scoped lang="scss">
+</style>

package/components/page-components/f-filter.vue

@@ -0,0 +1,72 @@
+<template>
+  <div class="f-filter">
+    <FFilterButton
+        :count="filterCount"
+        v-model="filterOpen"
+        :theme="buttonTheme"
+        :size="buttonSize"
+    />
+
+    <transition>
+      <FFilterPopup
+          v-if="filterOpen"
+          v-model="filterOpen"
+          :scheme="scheme"
+          :count="filterCount"
+          :duration-items="durationItems"
+          :added-items="addedItems"
+      />
+    </transition>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { ButtonSizes, ButtonThemes, FilterSchemeType } from '../../types';
+import type { LocationQuery } from '#vue-router';
+import type { ISelectItem } from '../../types';
+
+const route = useRoute();
+const filterOpen = ref(false);
+
+defineProps<{
+  scheme: FilterSchemeType
+  addedItems: ISelectItem[]
+  durationItems: ISelectItem[]
+  buttonSize?: ButtonSizes
+  buttonTheme?: ButtonThemes
+}>()
+
+function getFilteredQuery(query: LocationQuery) {
+  const result: string[] = [];
+
+  const categoriesRaw = query[ 'categories' ];
+  if (categoriesRaw) {
+    if (Array.isArray(categoriesRaw)) {
+      categoriesRaw.forEach(item => {
+        if (typeof item === 'string') {
+          result.push(...item.split(',').filter(Boolean));
+        }
+      });
+    } else if (typeof categoriesRaw === 'string') {
+      result.push(...categoriesRaw.split(',').filter(Boolean));
+    }
+  }
+
+  ['duration', 'added'].forEach(key => {
+    const val = query[ key ];
+    if (typeof val === 'string' && val.length > 0) {
+      result.push(val);
+    }
+  });
+
+  return result;
+}
+
+const filterCount = ref(0);
+
+filterCount.value = getFilteredQuery(route.query).length
+
+watch(() => route.query, (value) => {
+  filterCount.value = getFilteredQuery(value).length
+})
+</script>

package/components/page-components/f-model-filters.vue

@@ -0,0 +1,84 @@
+<template>
+  <FFilterModelChips :filters="data.filters"/>
+  <FFilterPage
+      class="f-model-filters__filters _from-sm"
+      :filters="data.filters"
+      :count="data.total"
+      :class="{'_loading': status === 'pending'}"
+  />
+  <transition>
+    <FPopup
+        v-if="model"
+        v-model="model"
+        sheet
+        class="f-model-filters__popup"
+    >
+      <template #title>{{ popupTitle }}</template>
+      <FFilterPage
+          class="f-model-filters__filters _to-sm"
+          :filters="data.filters"
+          :count="data.total"
+          :class="{'_loading': status === 'pending'}"
+      />
+      <template #footer>
+        <div class="f-model-filters__footer-buttons _to-sm">
+          <FButton
+              wide
+              class="f-model-filters__reset"
+              :disabled="!isFiltered"
+              @click="onResetClick"
+              theme="secondary"
+          >{{ t('reset_all') }}
+          </FButton>
+          <FButton
+              wide
+              class="_to-sm"
+              @click="onShowClick"
+          >{{ `${t('show_results')} (${data.total})` }}
+          </FButton>
+        </div>
+      </template>
+    </FPopup>
+  </transition>
+</template>
+
+<script setup lang="ts">
+import type { IModelCard, PaginatedResponse } from '../../types';
+
+const props = defineProps<{
+  data: PaginatedResponse<IModelCard>,
+  status: string,
+  filterCount: number,
+}>()
+
+const model = defineModel<boolean>();
+
+const { t } = useI18n();
+
+const router = useRouter();
+const route = useRoute();
+
+function onResetClick() {
+  router.replace({ query: {} });
+}
+
+const emit = defineEmits<{
+  (eventName: 'update:modelValue', value: boolean): void
+}>()
+
+function onShowClick() {
+  emit('update:modelValue', false);
+  document.documentElement.querySelector('#anchor')?.scrollIntoView({ behavior: 'smooth' });
+}
+
+const isFiltered = computed(() => Object.keys(route.query).some(item => item.startsWith('filter')));
+
+const popupTitle = computed(() => {
+  const countText = props.filterCount ? `: ${props.filterCount}` : '';
+  const filterText = props.filterCount > 1 ? t('filters') : t('filter');
+  return `${filterText}${countText}`;
+})
+</script>
+
+<style scoped lang="scss">
+</style>

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.195",
+  "version": "0.0.205",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {
-    "public": "npm version patch && npm publish --access public"
+    "prepublish": "npm install && npx nuxi prepare"
   },
   "exports": {
     ".": {