@hywax/cms 0.0.23 → 1.0.1

package/dist/runtime/composables/useQueryState.d.ts

@@ -0,0 +1,28 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { LocationQueryValue } from 'vue-router';
+type RouteQueryValueRaw = LocationQueryValue | LocationQueryValue[] | undefined;
+type QueryTransformGetter<Default, Value = Default> = (queryOrDefault: Default | RouteQueryValueRaw) => Value;
+type QueryTransform<Default, Value = Default> = QueryTransformGetter<Default, Value> | ({
+    get?: QueryTransformGetter<Default, Value>;
+    set?: (value: Value) => RouteQueryValueRaw;
+});
+interface Transforms<Default> {
+    number: QueryTransformGetter<number | Default>;
+    boolean: QueryTransformGetter<boolean | Default>;
+    date: QueryTransformGetter<string | Default>;
+    dateRange: QueryTransform<{
+        end: string;
+        start: string;
+    } | Default>;
+    arrayString: QueryTransformGetter<any[] extends Default ? Default : string[]>;
+}
+type GetTransform<T> = keyof {
+    [P in keyof Transforms<T> as Transforms<T>[P] extends QueryTransform<any, T> ? P : never]: P;
+};
+export type GetQueryTransforms<T> = {
+    [P in keyof T as T[P] extends Exclude<RouteQueryValueRaw, any[]> ? never : P]: GetTransform<T[P]> | QueryTransform<T[P], T[P]>;
+} & {
+    [P in keyof T as T[P] extends Exclude<RouteQueryValueRaw, any[]> ? P : never]?: GetTransform<T[P]> | QueryTransform<T[P], T[P]>;
+};
+export declare function useQueryState<T extends Record<string, any>>(defaults: MaybeRefOrGetter<T>, stateTransforms: GetQueryTransforms<T>): Ref<T>;
+export {};

package/dist/runtime/composables/useQueryState.js

@@ -0,0 +1,105 @@
+import { useRoute, useRouter } from "#imports";
+import { computed, customRef, reactive, toValue, watch } from "vue";
+import { formatServerDateTime } from "../utils/date.js";
+import { useRouteQuery } from "./useRouteQuery.js";
+const valuesCache = /* @__PURE__ */ new WeakMap();
+const queryTransforms = {
+  number: (val) => val === null || val === void 0 ? val : Number(val),
+  boolean: (val) => val === null || val === void 0 ? val : val === "true" ? true : val === "false" ? false : Boolean(val),
+  date: (val) => val === null || val === void 0 ? val : formatServerDateTime(val),
+  dateRange: {
+    get: (val) => {
+      if (!Array.isArray(val)) {
+        return val;
+      }
+      if (valuesCache.has(val)) {
+        return valuesCache.get(val);
+      }
+      const date = {
+        start: formatServerDateTime(val[0]),
+        end: formatServerDateTime(val[1])
+      };
+      valuesCache.set(val, date);
+      return date;
+    },
+    set: (value) => {
+      if (!value || typeof value !== "object") {
+        return value;
+      }
+      return [value.start, value.end];
+    }
+  },
+  arrayString: (val) => {
+    if (typeof val === "string") {
+      val = [val];
+    }
+    if (!Array.isArray(val)) {
+      return val;
+    }
+    if (valuesCache.has(val)) {
+      return valuesCache.get(val);
+    } else {
+      valuesCache.set(val, val);
+    }
+    return val;
+  }
+};
+export function useQueryState(defaults, stateTransforms) {
+  const route = useRoute();
+  const router = useRouter();
+  const defaultsValue = computed(() => toValue(defaults));
+  const proxy = customRef((track, trigger) => {
+    let queryState = { _initial: true };
+    return {
+      get: () => {
+        track();
+        return queryState;
+      },
+      set: (newValue) => {
+        if (newValue === queryState) {
+          return;
+        }
+        if (typeof newValue !== "object" || newValue === null) {
+          queryState = newValue;
+          return trigger();
+        }
+        const defaultValuesValue = defaultsValue.value;
+        const newQueryState = {};
+        for (const key in newValue) {
+          const query = createQuery(key, defaultValuesValue[key]);
+          const newValueField = newValue[key];
+          if (query.value !== newValueField && !queryState._initial) {
+            query.value = newValueField;
+          }
+          newQueryState[key] = query;
+        }
+        queryState = reactive(newQueryState);
+        trigger();
+      }
+    };
+  });
+  watch(() => toValue(defaults), (value) => {
+    proxy.value = value;
+  }, { immediate: true });
+  function getTransform(key) {
+    if (!stateTransforms[key]) {
+      return void 0;
+    }
+    const transform = stateTransforms[key];
+    if (typeof transform !== "function" && typeof transform !== "string") {
+      return void 0;
+    }
+    if (typeof transform === "string") {
+      return queryTransforms[transform];
+    }
+    return transform;
+  }
+  function createQuery(key, value) {
+    return useRouteQuery(key, value, {
+      transform: getTransform(key),
+      route,
+      router
+    });
+  }
+  return proxy;
+}

package/dist/runtime/composables/useRouteQuery.d.ts

@@ -0,0 +1,37 @@
+import type { MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
+import type { RouteParamValueRaw } from 'vue-router';
+import { useRoute, useRouter } from '#imports';
+/**
+ * Скопировано из vueuse, модифицированно для поддержки не примитивов:
+ * @see https://github.com/vueuse/vueuse/blob/main/packages/router/useRouteQuery/index.ts
+ */
+export type RouteQueryValueRaw = RouteParamValueRaw | string[];
+interface ReactiveRouteOptions {
+    /**
+     * Mode to update the router query, ref is also acceptable
+     *
+     * @default 'replace'
+     */
+    mode?: MaybeRef<'replace' | 'push'>;
+    /**
+     * Route instance, use `useRoute()` if not given
+     */
+    route?: ReturnType<typeof useRoute>;
+    /**
+     * Router instance, use `useRouter()` if not given
+     */
+    router?: ReturnType<typeof useRouter>;
+}
+interface ReactiveRouteOptionsWithTransform<V, R> extends ReactiveRouteOptions {
+    /**
+     * Function to transform data before return, or an object with one or both functions:
+     * `get` to transform data before returning, and `set` to transform data before setting
+     */
+    transform?: ((val: V) => R) | ({
+        get?: (value: V) => R;
+        set?: (value: R) => V;
+    });
+}
+export declare function useRouteQuery(name: string): Ref<undefined | null | string | string[]>;
+export declare function useRouteQuery<T extends RouteQueryValueRaw = RouteQueryValueRaw, K = T>(name: string, defaultValue?: MaybeRefOrGetter<T>, options?: ReactiveRouteOptionsWithTransform<T, K>): Ref<K>;
+export {};

package/dist/runtime/composables/useRouteQuery.js

@@ -0,0 +1,81 @@
+import { useRoute, useRouter } from "#imports";
+import { tryOnScopeDispose } from "@vueuse/core";
+import { customRef, nextTick, toValue, watch } from "vue";
+const _queue = /* @__PURE__ */ new WeakMap();
+export function useRouteQuery(name, defaultValue, options = {}) {
+  const {
+    mode = "replace",
+    route = useRoute(),
+    router = useRouter(),
+    transform
+  } = options;
+  let transformGet = (value) => value;
+  let transformSet = (value) => value;
+  if (typeof transform === "function") {
+    transformGet = transform;
+  } else if (transform) {
+    if (transform.get) {
+      transformGet = transform.get;
+    }
+    if (transform.set) {
+      transformSet = transform.set;
+    }
+  }
+  if (!_queue.has(router)) {
+    _queue.set(router, /* @__PURE__ */ new Map());
+  }
+  const _queriesQueue = _queue.get(router);
+  let query = route.query[name];
+  tryOnScopeDispose(() => {
+    query = void 0;
+  });
+  let _trigger;
+  const proxy = customRef((track, trigger) => {
+    _trigger = trigger;
+    return {
+      get() {
+        track();
+        return transformGet(query !== void 0 ? query : toValue(defaultValue));
+      },
+      set(v) {
+        v = transformSet(v);
+        if (query === v) {
+          return;
+        }
+        query = v === toValue(defaultValue) ? void 0 : v;
+        _queriesQueue.set(name, v === toValue(defaultValue) ? void 0 : v);
+        trigger();
+        nextTick(() => {
+          if (_queriesQueue.size === 0) {
+            return;
+          }
+          const newQueries = Object.fromEntries(_queriesQueue.entries());
+          _queriesQueue.clear();
+          const { params, query: query2, hash } = route;
+          router[toValue(mode)]({
+            params,
+            query: { ...query2, ...newQueries },
+            hash
+          });
+        });
+      }
+    };
+  });
+  watch(
+    () => route.query[name],
+    (v) => {
+      const newQueryValue = transformSet(transformGet(v));
+      if (query === newQueryValue) {
+        return;
+      }
+      if (JSON.stringify(query) === JSON.stringify(newQueryValue)) {
+        query = v;
+        return;
+      }
+      query = v;
+      _trigger();
+    },
+    { flush: "sync" }
+  );
+  return proxy;
+}

package/dist/runtime/composables/useRowSelection.d.ts

@@ -0,0 +1,8 @@
+import type { RowSelectionState } from '@tanstack/vue-table';
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useRowSelection<T extends Record<any, any>, P extends keyof T>(state: MaybeRefOrGetter<RowSelectionState | undefined>, data: MaybeRefOrGetter<T[] | undefined>, key: P): {
+    rowSelection: import("vue").Ref<RowSelectionState | undefined, RowSelectionState | undefined>;
+    getRowId: (originalRow: T, index: number, parent?: import("@tanstack/table-core").Row<T> | undefined) => string;
+    selectedItems: import("vue").ComputedRef<T[]>;
+    selectedIds: import("vue").ComputedRef<T[P][]>;
+};

package/dist/runtime/composables/useRowSelection.js

@@ -0,0 +1,46 @@
+import { useCloned } from "@vueuse/core";
+import clone from "fast-copy";
+import { computed, shallowRef, toValue, triggerRef, watch } from "vue";
+export function useRowSelection(state, data, key) {
+  const { cloned: rowSelection } = useCloned(state, { clone });
+  const getRowId = (row) => {
+    return String(row[key]);
+  };
+  const dataMap = computed(() => {
+    return new Map(
+      toValue(data)?.map((item, index) => [getRowId(item, index), item]) ?? []
+    );
+  });
+  const cache = shallowRef(/* @__PURE__ */ new Map());
+  watch([rowSelection, dataMap], ([rowSelection2, dataMap2]) => {
+    rowSelection2 ??= {};
+    cache.value.keys().forEach((id) => {
+      if (!rowSelection2[id]) {
+        cache.value.delete(id);
+      }
+    });
+    Object.entries(rowSelection2).forEach(([id, selected]) => {
+      if (!selected) {
+        return;
+      }
+      const item = dataMap2.get(id) ?? cache.value.get(id);
+      if (!item) {
+        return console.warn(`Item with id ${id} not found`);
+      }
+      cache.value.set(id, item);
+    });
+    triggerRef(cache);
+  }, { immediate: true });
+  const selectedItems = computed(() => {
+    return cache.value.values().toArray();
+  });
+  const selectedIds = computed(() => {
+    return selectedItems.value.map((item) => item[key]);
+  });
+  return {
+    rowSelection,
+    getRowId,
+    selectedItems,
+    selectedIds
+  };
+}

package/dist/runtime/composables/useTable.d.ts

@@ -1,19 +1,25 @@
 import type { SortingState } from '@tanstack/vue-table';
 import type { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
-import type { PaginationQuery, SortQuery } from '../types';
+import type { PaginationQuery, RequiredOptional, SortQuery } from '../types';
+import type { GetQueryTransforms } from './useQueryState';
+interface UseTableOptions<T> {
+    query?: {
+        enabled?: true | false;
+        transform: GetQueryTransforms<T>;
+    };
+}
 interface UseTableReturn<T> {
-    models: Ref<T>;
-    appliedCount: ComputedRef<number>;
-    applyFilters: () => void;
-    resetFilters: () => void;
+    source: ComputedRef<T>;
+    filters: Ref<T>;
+    updateFilters: (value: Partial<T>) => void;
     sorting: Ref<SortingState>;
     pagination: Ref<PaginationQuery>;
-    filters: Ref<T>;
     query: ComputedRef<T & PaginationQuery & SortQuery | object>;
 }
-interface UseTableOptions<T> {
-    defaultSort?: SortQuery;
-    countFiltersExcept?: Array<keyof T>;
-}
-export default function useTable<T extends object>(initialFilters: MaybeRefOrGetter<T>, options?: UseTableOptions<T>): UseTableReturn<T>;
+export declare function useTableFilters<T extends Record<string, any>>(initialFilters: MaybeRefOrGetter<T>, options?: UseTableOptions<T>): {
+    initial: ComputedRef<T>;
+    filters: Ref<T, T>;
+    updateFilters: (value: Partial<T>) => void;
+};
+export default function useTable<T extends Record<string, any>>(initialFilters: MaybeRefOrGetter<RequiredOptional<T>>, options?: UseTableOptions<RequiredOptional<T>>): UseTableReturn<RequiredOptional<T>>;
 export {};

package/dist/runtime/composables/useTable.js

@@ -1,90 +1,84 @@
-import { computed, reactive, ref, toRaw, toValue, watch } from "#imports";
-import { deepEqual } from "fast-equals";
-function useTableFilters(initialFilters, options) {
+import copy from "fast-copy";
+import { computed, ref, toValue, watch } from "vue";
+import { useQueryState } from "./useQueryState.js";
+export function useTableFilters(initialFilters, options) {
   const initial = computed(() => toValue(initialFilters));
-  const filters = ref(structuredClone(initial.value));
-  const models = ref(structuredClone(initial.value));
-  const applyFilters = () => {
-    filters.value = structuredClone(toRaw(models.value));
-  };
-  const resetFilters = () => {
-    models.value = structuredClone(initial.value);
-    applyFilters();
-  };
-  const appliedCountFields = computed(() => {
-    const fields = Object.keys(initial.value);
-    if (!options?.countFiltersExcept) {
-      return fields;
-    }
-    return fields.filter((key) => {
-      return !options.countFiltersExcept.includes(key);
-    });
-  });
-  const appliedCount = computed(() => {
-    return appliedCountFields.value.reduce((sum, key) => {
-      return deepEqual(filters.value[key], initial.value[key]) ? sum : sum + 1;
-    }, 0);
-  });
+  const filters = options?.query?.enabled ? useQueryState(initial, options.query.transform) : ref(initial.value);
   watch(initial, (initial2) => {
-    filters.value = structuredClone(initial2);
-    models.value = structuredClone(initial2);
+    filters.value = copy(initial2);
   });
+  const updateFilters = (value) => {
+    Object.assign(filters.value, value);
+  };
   return {
+    initial,
     filters,
-    models,
-    appliedCount,
-    applyFilters,
-    resetFilters
+    updateFilters
   };
 }
-function useTableSort(defaultSort) {
-  const state = reactive({ "sort.column": defaultSort?.sortColumn ?? null, "sort.type": defaultSort?.sortType ?? "desc" });
+function useTablePagination(options) {
+  const initialPagination = { page: 1, perPage: 20 };
+  const pagination = options?.query?.enabled ? useQueryState(initialPagination, { page: "number", perPage: "number" }) : ref(initialPagination);
+  watch(() => pagination.value.perPage, () => {
+    if (pagination.value.page !== 1) {
+      pagination.value.page = 1;
+    }
+  });
+  return { pagination };
+}
+function useTableSort(query) {
+  const initialSort = { "sort.column": null, "sort.type": "asc" };
+  const state = query ? useQueryState(initialSort, {}) : ref(initialSort);
   const sort = computed(() => {
-    if (!state["sort.column"]) {
+    if (!state.value["sort.column"]) {
       return null;
     }
-    return { sortColumn: state["sort.column"], sortType: state["sort.type"] };
+    return { sortColumn: state.value["sort.column"], sortType: state.value["sort.type"] };
   });
   const sorting = computed({
-    get: () => state["sort.column"] ? [{ id: state["sort.column"], desc: state["sort.type"] === "desc" }] : [],
+    get: () => {
+      if (!state.value["sort.column"]) {
+        return [];
+      }
+      return [{ id: state.value["sort.column"], desc: state.value["sort.type"] === "desc" }];
+    },
     set: (value) => {
       if (value.length === 0) {
-        state["sort.column"] = null;
-        state["sort.type"] = "asc";
+        state.value = { "sort.column": null, "sort.type": "asc" };
         return;
       }
       const { id, desc } = value[0];
-      state["sort.column"] = id;
-      state["sort.type"] = desc ? "desc" : "asc";
+      state.value = { "sort.column": id, "sort.type": desc ? "desc" : "asc" };
     }
   });
   return { sort, sorting };
 }
 export default function useTable(initialFilters, options) {
-  const { filters, models, appliedCount, applyFilters, resetFilters } = useTableFilters(initialFilters, options);
-  const { sort, sorting } = useTableSort(options?.defaultSort);
-  const pagination = ref({ page: 1, perPage: 20 });
+  const {
+    initial,
+    filters,
+    updateFilters
+  } = useTableFilters(initialFilters, options);
+  const { sorting } = useTableSort(options?.query?.enabled ?? true);
+  const { pagination } = useTablePagination(options);
   const query = computed(() => {
     return {
       ...filters.value,
-      ...sort.value,
+      ...sorting.value,
       ...pagination.value
     };
   });
-  watch([filters, sort, () => pagination.value.perPage], () => {
-    if (pagination.value.page === 1) {
-      return;
+  watch(filters, () => {
+    if (pagination.value.page !== 1) {
+      pagination.value.page = 1;
     }
-    pagination.value.page = 1;
   }, { deep: true });
   return {
-    models,
-    appliedCount,
-    applyFilters,
-    resetFilters,
+    source: initial,
     filters,
     sorting,
     pagination,
+    updateFilters,
     query
   };
 }

package/dist/runtime/composables/useUplora.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncDataRequestStatus } from '#app';
-import type { Ref } from '#imports';
 import type { EventHookOn } from '@vueuse/shared';
+import type { Ref } from 'vue';
 export interface UseUploraUploadOptions {
     accept?: string;
 }

package/dist/runtime/composables/useUplora.js

@@ -1,4 +1,5 @@
-import { createEventHook, useFileDialog, useNuxtApp } from "#imports";
+import { useNuxtApp } from "#imports";
+import { createEventHook, useFileDialog } from "@vueuse/core";
 import { useAsyncHandler } from "./useAsyncHandler.js";
 export function useUploraUpload(options) {
   const { $api } = useNuxtApp();

package/dist/runtime/index.css

@@ -1 +1 @@
-@import "@nuxt/ui-pro";@import "#build/cms.css";@source "./components";@source "./editor";
+@import "@nuxt/ui";@import "#build/cms.css";@source "./components";@source "./editor";

package/dist/runtime/plugins/zod.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/zod.js

@@ -0,0 +1,26 @@
+import { defineNuxtPlugin } from "#imports";
+import { z } from "zod";
+import { ru } from "zod/locales";
+export default defineNuxtPlugin({
+  name: "zod",
+  parallel: true,
+  setup: () => {
+    z.config({
+      ...ru(),
+      customError: (iss) => {
+        if (iss.code === "invalid_type" && (iss.input === void 0 || iss.input === null)) {
+          return "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u043A \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044E.";
+        }
+        if (iss.code === "invalid_value" && (iss.input === void 0 || iss.input === null)) {
+          return "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u043A \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044E.";
+        }
+        if (iss.code === "too_small" && iss.minimum === 1) {
+          return "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u043A \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044E.";
+        }
+        if (iss.code === "custom" && iss.path && iss.path.length > 0) {
+          return "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u043A \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044E.";
+        }
+      }
+    });
+  }
+});

package/dist/runtime/server/api/uplora/[id].delete.d.ts

@@ -1,10 +1,6 @@
 import { z } from 'zod';
 export declare const filesDeleteRouteParamsSchema: z.ZodObject<{
     id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
+}, z.core.$strip>;
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
 export default _default;

package/dist/runtime/tv.d.ts

@@ -1 +1 @@
-export declare const tv: import("tailwind-variants").CreateTV;
+export declare const tv: import("tailwind-variants").TV;

package/dist/runtime/types/date.d.ts

@@ -0,0 +1,5 @@
+export type DateType = string;
+export interface DateRange {
+    start: DateType;
+    end: DateType;
+}

package/dist/runtime/types/index.d.ts

@@ -1,24 +1,6 @@
-export * from '../components/AutocompleteSelect.vue';
-export * from '../components/ButtonClear.vue';
-export * from '../components/ButtonCopy.vue';
-export * from '../components/ButtonDelete.vue';
-export * from '../components/EditorContentFull.vue';
-export * from '../components/EditorContentLight.vue';
-export * from '../components/FormPanel.vue';
-export * from '../components/FormPanelAsideSection.vue';
-export * from '../components/FormPanelSection.vue';
-export * from '../components/InputSeo.vue';
-export * from '../components/InputSlug.vue';
-export * from '../components/InputUploraImage.vue';
-export * from '../components/ModalConfirm.vue';
-export * from '../components/TableCellPreview.vue';
-export * from '../components/TableCellSeo.vue';
-export * from '../components/TableCellUser.vue';
-export * from '../components/TablePanel.vue';
-export * from '../components/TablePanelColumnSorting.vue';
-export * from '../components/TablePanelColumnVisibility.vue';
-export * from '../components/TablePanelFilters.vue';
-export * from '../components/UploraImage.vue';
+export type { FiltersField } from '../components/TableFilters.vue';
+export type { ActionMenuItem } from '../components/TablePanel.vue';
+export * from './date';
 export * from './image';
 export * from './query';
 export * from './seo';

package/dist/runtime/types/index.js

@@ -1,24 +1,4 @@
-export * from "../components/AutocompleteSelect.vue";
-export * from "../components/ButtonClear.vue";
-export * from "../components/ButtonCopy.vue";
-export * from "../components/ButtonDelete.vue";
-export * from "../components/EditorContentFull.vue";
-export * from "../components/EditorContentLight.vue";
-export * from "../components/FormPanel.vue";
-export * from "../components/FormPanelAsideSection.vue";
-export * from "../components/FormPanelSection.vue";
-export * from "../components/InputSeo.vue";
-export * from "../components/InputSlug.vue";
-export * from "../components/InputUploraImage.vue";
-export * from "../components/ModalConfirm.vue";
-export * from "../components/TableCellPreview.vue";
-export * from "../components/TableCellSeo.vue";
-export * from "../components/TableCellUser.vue";
-export * from "../components/TablePanel.vue";
-export * from "../components/TablePanelColumnSorting.vue";
-export * from "../components/TablePanelColumnVisibility.vue";
-export * from "../components/TablePanelFilters.vue";
-export * from "../components/UploraImage.vue";
+export * from "./date.js";
 export * from "./image.js";
 export * from "./query.js";
 export * from "./seo.js";

package/dist/runtime/types/utils.d.ts

@@ -4,3 +4,10 @@ export type AcceptableValue = Exclude<_AcceptableValue, Record<string, any>>;
 export type KeysMatching<T, V> = {
     [K in keyof T]: T[K] extends V ? K : never;
 }[keyof T];
+export type OptionalKeys<T extends object, P extends keyof T> = Omit<T, P> & Partial<Pick<T, P>>;
+export type PickOptional<T> = {
+    [P in keyof T as T extends Record<P, T[P]> ? never : P]: P;
+};
+export type RequiredOptional<T> = T & {
+    [P in keyof Required<PickOptional<T>>]: T[P] | undefined;
+};

package/dist/runtime/utils/date.d.ts

@@ -0,0 +1,9 @@
+import type { DateLike } from '@vueuse/core';
+import type { DateRange } from '../types/date';
+export declare function getPeriod(beforeDays: number, afterDays?: number, fixTime?: boolean): DateRange;
+export declare function getPeriodFromDaysAgo(days: number, fixTime?: boolean): DateRange;
+export declare function getCurrentDayPeriod(): DateRange;
+export declare function formatDateTime(date: DateLike): string;
+export declare function formatDate(date: DateLike): string;
+export declare function formatTime(date: DateLike): string;
+export declare function formatServerDateTime(date: DateLike): string;