@hywax/cms 0.0.2 → 0.0.4

package/dist/runtime/components/UploraImage.vue.d.ts

@@ -0,0 +1,34 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ImgHTMLAttributes } from 'vue';
+import type { ComponentConfig, ImageFormat, ImageSize } from '../types';
+import theme from '#build/cms/uplora-image';
+export type UploraImage = ComponentConfig<typeof theme, AppConfig, 'uploraImage'>;
+export interface UploraImageProps {
+    id: string;
+    alt: string;
+    formats?: ImageFormat[];
+    sizes?: ImageSize[];
+    lqip?: string;
+    loading?: 'lazy' | 'eager';
+    preload?: boolean | {
+        fetchPriority: 'auto' | 'high' | 'low';
+    };
+    nonce?: string;
+    imgAttrs?: ImgHTMLAttributes;
+    class?: any;
+    ui?: UploraImage['slots'];
+}
+export interface UploraImageEmits {
+    load: [Event];
+    error: [string | Event];
+}
+declare const _default: import("vue").DefineComponent<UploraImageProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (args_0: string | Event) => any;
+    load: (args_0: Event) => any;
+}, string, import("vue").PublicProps, Readonly<UploraImageProps> & Readonly<{
+    onError?: ((args_0: string | Event) => any) | undefined;
+    onLoad?: ((args_0: Event) => any) | undefined;
+}>, {
+    loading: "lazy" | "eager";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/prose/UploraImage.vue

@@ -6,8 +6,7 @@
 
 <script>
 import theme from "#build/cms/prose/uplora-image";
-import { useAppConfig } from "#imports";
-import { computed } from "vue";
+import { computed, useAppConfig } from "#imports";
 import { tv } from "../../utils/tv";
 </script>
 

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

@@ -0,0 +1,14 @@
+import type { AvailableRouterMethod, NitroFetchRequest } from 'nitropack';
+import type { AsyncData, FetchResult, UseFetchOptions } from 'nuxt/app';
+import type { DefaultAsyncDataValue } from 'nuxt/app/defaults';
+import type { FetchError } from 'ofetch';
+import type { Ref } from 'vue';
+type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
+type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
+/**
+ * На данный момент нет возможности использовать `useFetch` со своим $fetch,
+ * поэтому приходится использовать костыль.
+ * https://github.com/nuxt/nuxt/issues/14736
+ */
+export declare function useApi<ResT = void, ErrorT = FetchError, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DefaultAsyncDataValue>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | DefaultAsyncDataValue>;
+export {};

package/dist/runtime/composables/useApi.js

@@ -0,0 +1,16 @@
+import { useFetch, useNuxtApp } from "#imports";
+import { defu } from "defu";
+export function useApi(request, opts) {
+  const $api = useNuxtApp().$api;
+  return useFetch(
+    request,
+    defu(
+      {
+        $fetch: $api
+      },
+      {
+        ...opts
+      }
+    )
+  );
+}

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

@@ -0,0 +1,12 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+import type { SEO } from '../types';
+interface SEOStats {
+    progress: number;
+    color: 'error' | 'warning' | 'success';
+}
+interface UseSEOStatsReturn {
+    title: ComputedRef<SEOStats>;
+    description: ComputedRef<SEOStats>;
+}
+export declare function useSEOStats(options: MaybeRefOrGetter<SEO>): UseSEOStatsReturn;
+export {};

package/dist/runtime/composables/useSeoStats.js

@@ -0,0 +1,44 @@
+import { computed, toValue } from "#imports";
+function computeScore(length, recommendedLength, maxLength) {
+  if (length === 0) {
+    return 0;
+  }
+  if (length < recommendedLength) {
+    return length / recommendedLength * 100;
+  }
+  if (length > maxLength) {
+    return Math.max(0, 100 - (length - maxLength) / maxLength * 100);
+  }
+  return 100;
+}
+function computeColor(score) {
+  if (score < 30) {
+    return "error";
+  }
+  if (score < 70) {
+    return "warning";
+  }
+  return "success";
+}
+export function useSEOStats(options) {
+  const title = computed(() => {
+    const value = toValue(options);
+    const score = computeScore(value.title.length, 45, 60);
+    return {
+      progress: Math.round(score),
+      color: computeColor(score)
+    };
+  });
+  const description = computed(() => {
+    const value = toValue(options);
+    const score = computeScore(value.description.length, 130, 160);
+    return {
+      progress: Math.round(score),
+      color: computeColor(score)
+    };
+  });
+  return {
+    title,
+    description
+  };
+}

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

@@ -0,0 +1,6 @@
+declare const _default: import("#app").Plugin<{
+    api: import("nitropack/types").$Fetch<unknown, import("nitropack/types").NitroFetchRequest>;
+}> & import("#app").ObjectPlugin<{
+    api: import("nitropack/types").$Fetch<unknown, import("nitropack/types").NitroFetchRequest>;
+}>;
+export default _default;

package/dist/runtime/plugins/api.js

@@ -0,0 +1,23 @@
+import { defineNuxtPlugin, useAppConfig, useToast } from "#imports";
+export default defineNuxtPlugin({
+  name: "cms-api",
+  async setup() {
+    const toast = useToast();
+    const appConfig = useAppConfig();
+    const api = $fetch.create({
+      async onResponseError({ response }) {
+        toast.add({
+          title: "\u041E\u0448\u0438\u0431\u043A\u0430",
+          description: response._data.message ?? "\u0427\u0442\u043E-\u0442\u043E \u043F\u043E\u0448\u043B\u043E \u043D\u0435 \u0442\u0430\u043A",
+          color: "error",
+          icon: appConfig.ui.icons.close
+        });
+      }
+    });
+    return {
+      provide: {
+        api
+      }
+    };
+  }
+});

package/dist/runtime/server/errors/InternalHttpError.d.ts

@@ -0,0 +1,4 @@
+export declare class InternalHttpError extends Error {
+    httpCodeString: string;
+    constructor(httpCodeString: string);
+}

package/dist/runtime/server/errors/InternalHttpError.js

@@ -0,0 +1,6 @@
+export class InternalHttpError extends Error {
+  constructor(httpCodeString) {
+    super("Internal Error");
+    this.httpCodeString = httpCodeString;
+  }
+}

package/dist/runtime/server/errors/TimeoutError.d.ts

@@ -0,0 +1,2 @@
+export declare class TimeoutError extends Error {
+}

package/dist/runtime/server/errors/TimeoutError.js

@@ -0,0 +1,2 @@
+export class TimeoutError extends Error {
+}

package/dist/runtime/server/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './InternalHttpError';
+export * from './TimeoutError';

package/dist/runtime/server/errors/index.js

@@ -0,0 +1,2 @@
+export * from "./InternalHttpError.js";
+export * from "./TimeoutError.js";

package/dist/runtime/server/types/errors.d.ts

@@ -0,0 +1,8 @@
+export type ErrorMapCodes = Record<string, string>;
+export interface CustomError {
+    statusCode: number;
+    message: string;
+    data?: {
+        [key: string]: unknown;
+    };
+}

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

@@ -0,0 +1 @@
+export * from './errors';

package/dist/runtime/server/types/index.js

@@ -0,0 +1 @@
+export * from "./errors.js";

package/dist/runtime/server/utils/errors.d.ts

@@ -0,0 +1,8 @@
+import type { CustomError, ErrorMapCodes } from '../types';
+import { H3Error } from 'h3';
+import { InternalHttpError } from '../errors';
+export declare function parseErrorString(errorString: string): CustomError;
+export declare function errorServerResolver(error: unknown, errorMap?: ErrorMapCodes): H3Error<{
+    [key: string]: unknown;
+}>;
+export declare function createServerError(errorString: string): InternalHttpError;

package/dist/runtime/server/utils/errors.js

@@ -0,0 +1,57 @@
+import { HTTP_CODE_BAD_REQUEST, HTTP_CODE_INTERNAL_SERVER_ERROR, HTTP_CODE_REQUEST_TIMEOUT, HTTP_CODE_UNAUTHORIZED } from "#cms/http-codes";
+import { consola } from "consola";
+import { defu } from "defu";
+import { createError, H3Error } from "h3";
+import { z } from "zod";
+import { InternalHttpError, TimeoutError } from "../errors/index.js";
+const defaultHttpCodes = {
+  DEFAULT: HTTP_CODE_INTERNAL_SERVER_ERROR,
+  ZOD: HTTP_CODE_BAD_REQUEST,
+  DB: HTTP_CODE_INTERNAL_SERVER_ERROR,
+  ERROR_UNAUTHORIZED: HTTP_CODE_UNAUTHORIZED,
+  TIMEOUT: HTTP_CODE_REQUEST_TIMEOUT
+};
+function extractHttpCodeString(error, errorMap = {}) {
+  errorMap = defu(errorMap, defaultHttpCodes);
+  if (error instanceof InternalHttpError) {
+    return error.httpCodeString;
+  } else if (error instanceof z.ZodError) {
+    return errorMap.ZOD;
+  } else if (error instanceof TimeoutError) {
+    return errorMap.TIMEOUT;
+  } else if (error instanceof H3Error && error.cause instanceof InternalHttpError) {
+    return error.cause.httpCodeString;
+  } else if (error instanceof Error) {
+    if ("query" in error && "params" in error && Array.isArray(error.params)) {
+      const errorMaybeCode2 = `DB_${error.cause?.code}`;
+      return errorMap[errorMaybeCode2] ?? errorMap.DB;
+    }
+    const normalizedMessage = error.message.trim().replaceAll(" ", "_").toUpperCase();
+    const errorMaybeCode = `ERROR_${normalizedMessage}`;
+    return errorMap[errorMaybeCode] ?? errorMap.DEFAULT;
+  }
+  return errorMap.DEFAULT;
+}
+export function parseErrorString(errorString) {
+  const [code, message] = errorString.split(":");
+  if (!code || !message) {
+    throw new Error("Invalid error string");
+  }
+  return {
+    statusCode: Number.parseInt(code, 10),
+    message: message.trim()
+  };
+}
+export function errorServerResolver(error, errorMap) {
+  const httpCodeString = extractHttpCodeString(error, errorMap);
+  const parsedHttpCode = parseErrorString(httpCodeString);
+  consola.error({
+    code: parsedHttpCode.statusCode,
+    message: parsedHttpCode.message,
+    error
+  });
+  return createError(parsedHttpCode);
+}
+export function createServerError(errorString) {
+  return new InternalHttpError(errorString);
+}

package/dist/runtime/server/utils/httpHandler.d.ts

@@ -0,0 +1,10 @@
+import type { EventHandler, EventHandlerRequest, EventHandlerResponse } from 'h3';
+import type { ErrorMapCodes } from '../types';
+export interface EventHandlerOptions {
+    errorMap?: ErrorMapCodes;
+}
+/**
+ * Функция для определения обработчика HTTP-запросов.
+ * Обрабатывает, H3-обработчик и ловит, обрабатывает ошибки.
+ */
+export declare function defineHttpHandler<Request extends EventHandlerRequest, Response extends EventHandlerResponse>(handler: EventHandler<Request, Response | Promise<Response>>, options?: EventHandlerOptions): EventHandler<Request, Promise<Response>>;

package/dist/runtime/server/utils/httpHandler.js

@@ -0,0 +1,15 @@
+import { eventHandler } from "h3";
+import { errorServerResolver } from "./errors.js";
+export function defineHttpHandler(handler, options) {
+  return eventHandler(async (event) => {
+    try {
+      return await handler(event);
+    } catch (e) {
+      let error = e;
+      if (error.cause?.data instanceof Error) {
+        error = error.cause?.data;
+      }
+      throw errorServerResolver(error, options?.errorMap);
+    }
+  });
+}

package/dist/runtime/server/utils/pagination.d.ts

@@ -0,0 +1,11 @@
+import type { KeysMatching, Pagination } from '../../types';
+export declare function extractPaginationData<T extends {
+    total: number;
+}>(data: T[]): {
+    items: Omit<T, 'total'>[];
+    pagination: Pagination;
+};
+export declare function extractPaginationData<T extends object, K extends KeysMatching<T, number>>(data: T[], key: K): {
+    items: Omit<T, K>[];
+    pagination: Pagination;
+};

package/dist/runtime/server/utils/pagination.js

@@ -0,0 +1,12 @@
+export function extractPaginationData(data, key) {
+  if (!data.length) {
+    return { items: [], pagination: { total: 0 } };
+  }
+  const totalKey = key ?? "total";
+  const total = Number(data[0]?.[totalKey]) || 0;
+  const items = data.map(({ [totalKey]: _, ...item }) => item);
+  return {
+    items,
+    pagination: { total }
+  };
+}

package/dist/runtime/server/utils/timeout.d.ts

@@ -0,0 +1,7 @@
+import { TimeoutError } from '../errors/TimeoutError';
+interface TryWithTimeoutOptions {
+    timeout?: number;
+    timeoutMessage?: string;
+}
+export declare function tryWithTimeout<T>(promise: Promise<T>, options: TryWithTimeoutOptions): Promise<T | TimeoutError>;
+export {};

package/dist/runtime/server/utils/timeout.js

@@ -0,0 +1,9 @@
+import { TimeoutError } from "../errors/TimeoutError.js";
+export function tryWithTimeout(promise, options) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new TimeoutError(options?.timeoutMessage)), options?.timeout ?? 1e3)
+    )
+  ]);
+}

package/dist/runtime/server/utils/validation.d.ts

@@ -0,0 +1,3 @@
+import type { PaginationQuery, PaginationQueryRaw, SortQuery, SortQueryRaw } from '../../types';
+export declare function getValidatedSort<T extends string[]>(query: SortQueryRaw, availableColumns: readonly [...T]): SortQuery<T[number]>;
+export declare function getValidatedPagination(query: PaginationQueryRaw): PaginationQuery;

package/dist/runtime/server/utils/validation.js

@@ -0,0 +1,26 @@
+import { HTTP_CODE_BAD_REQUEST } from "#cms/http-codes";
+import { InternalHttpError } from "../errors/InternalHttpError.js";
+export function getValidatedSort(query, availableColumns) {
+  if (!query.sortColumn || !availableColumns.includes(query.sortColumn)) {
+    throw new InternalHttpError(HTTP_CODE_BAD_REQUEST);
+  }
+  const sortType = query.sortType === "asc" ? "asc" : "desc";
+  const sortColumn = query.sortColumn;
+  return {
+    sortType,
+    sortColumn
+  };
+}
+export function getValidatedPagination(query) {
+  const perPage = Number(query.perPage);
+  if (!Number.isInteger(perPage) || perPage < 1 || perPage > 100) {
+    throw new InternalHttpError(HTTP_CODE_BAD_REQUEST);
+  }
+  const page = Number(query.page) || 1;
+  const pageOffset = (page - 1) * perPage;
+  return {
+    page,
+    perPage,
+    pageOffset
+  };
+}

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

@@ -0,0 +1,48 @@
+import type { ImageExtension, ImageMimeType } from '@uplora/formats';
+export type ImageFormat = ImageExtension;
+/**
+ * Размер изображения
+ */
+export interface ImageSize {
+    /**
+     * Ширина
+     *
+     * @example 1024
+     */
+    width?: number;
+    /**
+     * Высота
+     *
+     * @example 1024
+     */
+    height?: number;
+    /**
+     * Описание размера
+     *
+     * @example 2x, 512px
+     */
+    descriptor: string;
+}
+/**
+ * Источник изображения
+ */
+export interface ImageSource {
+    /**
+     * Image URL
+     *
+     * @example https://uplora.ru/fgu1yd2ncj05iogcooz31u55
+     */
+    img: string;
+    /**
+     * Image srcset
+     *
+     * @example https://uplora.ru/fgu1yd2ncj05iogcooz31u55/-/format/jpg 1x, https://uplora.ru/fgu1yd2ncj05iogcooz31u55/-/format/jpg 2x
+     */
+    srcset?: string;
+    /**
+     * Image mime type
+     *
+     * @example image/jpeg
+     */
+    type?: ImageMimeType;
+}

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

@@ -1,2 +1,6 @@
 export * from '../components/ButtonClear.vue';
+export * from '../components/UploraImage.vue';
+export * from './image';
+export * from './query';
+export * from './seo';
 export * from './utils';

package/dist/runtime/types/index.js

@@ -1,2 +1,6 @@
 export * from "../components/ButtonClear.vue";
+export * from "../components/UploraImage.vue";
+export * from "./image.js";
+export * from "./query.js";
+export * from "./seo.js";
 export * from "./utils.js";

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

@@ -0,0 +1,20 @@
+export interface SortQueryRaw {
+    sortColumn?: string;
+    sortType?: string;
+}
+export interface SortQuery<K = string> {
+    sortColumn: K;
+    sortType: 'asc' | 'desc';
+}
+export interface Pagination {
+    total: number;
+}
+export interface PaginationQueryRaw {
+    page?: string;
+    perPage?: string;
+}
+export interface PaginationQuery {
+    page: number;
+    perPage: number;
+    pageOffset: number;
+}

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

@@ -0,0 +1,4 @@
+export interface SEO {
+    title: string;
+    description: string;
+}

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

@@ -1,3 +1,6 @@
 import type { AcceptableValue as _AcceptableValue } from 'reka-ui';
-export type AcceptableValue = Exclude<_AcceptableValue, Record<string, any>>;
 export * from './tv';
+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];

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

@@ -0,0 +1 @@
+export declare function createAvatarByName(name?: string): string;

package/dist/runtime/utils/avatar.js

@@ -0,0 +1,9 @@
+import { initials } from "@dicebear/collection";
+import { createAvatar } from "@dicebear/core";
+export function createAvatarByName(name = "Anonymous") {
+  const avatar = createAvatar(initials, {
+    seed: name,
+    backgroundType: ["gradientLinear"]
+  });
+  return avatar.toDataUri();
+}

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

@@ -0,0 +1,4 @@
+export declare function labelsToDictionary<T extends Record<any, string>>(labels: T): Array<{
+    value: T[keyof T];
+    label: string;
+}>;

package/dist/runtime/utils/dictionaries.js

@@ -0,0 +1,6 @@
+export function labelsToDictionary(labels) {
+  return Object.entries(labels).map(([value, label]) => ({
+    value,
+    label
+  }));
+}

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

@@ -0,0 +1,30 @@
+import type { Filters } from '@uplora/serializer';
+import type { ImageFormat, ImageSize, ImageSource } from '../types';
+/**
+ * Создает функцию для получения URL изображения из Uplora
+ */
+export declare function createUploraImageResolver(): (id: string, filters?: Filters) => string;
+export interface BuildUploraImageOptions {
+    id: string;
+    formats?: ImageFormat[];
+    sizes?: ImageSize[];
+}
+export interface BuildUploraImageReturn {
+    img: string;
+    original: string;
+    sources: ImageSource[];
+    srcset?: string;
+}
+/**
+ * Создает URL изображения из Uplora
+ */
+export declare function buildUploraImage(options: BuildUploraImageOptions): BuildUploraImageReturn;
+export interface GenerateImageSizesOptions {
+    width: number;
+    minWidth?: number;
+    step?: number;
+}
+/**
+ * Генерирует размеры изображения
+ */
+export declare function generateImageSizes(options: GenerateImageSizesOptions): ImageSize[];

package/dist/runtime/utils/image.js

@@ -0,0 +1,81 @@
+import { useRuntimeConfig } from "#imports";
+import { imagesExtensionsToMimeTypes } from "@uplora/formats";
+import { serialize } from "@uplora/serializer";
+export function createUploraImageResolver() {
+  const runtimeConfig = useRuntimeConfig();
+  const { fluxorUrl } = runtimeConfig.public;
+  return (id, filters) => {
+    const serializeFilters = filters ? serialize(filters) : "";
+    return `${fluxorUrl}/${id}${serializeFilters ? `/${serializeFilters}` : ""}`;
+  };
+}
+export function buildUploraImage(options) {
+  const resolver = createUploraImageResolver();
+  const original = resolver(options.id);
+  const sizes = options.sizes ?? [{ descriptor: "1x" }];
+  const sources = [];
+  function makeSrcset(format) {
+    if (sizes && sizes.length > 1) {
+      return sizes.map((size) => `${resolver(options.id, { resize: { width: size.width, height: size.height }, format })} ${size.descriptor}`).join(", ");
+    }
+    return null;
+  }
+  if (options.formats) {
+    for (const format of options.formats) {
+      const srcset = makeSrcset(format);
+      sources.push({
+        img: resolver(options.id, {
+          resize: {
+            width: sizes[0]?.width,
+            height: sizes[0]?.height
+          },
+          format
+        }),
+        ...srcset ? { srcset } : {},
+        type: imagesExtensionsToMimeTypes[format]
+      });
+    }
+  } else {
+    const srcset = makeSrcset();
+    sources.push({
+      img: resolver(options.id, {
+        resize: {
+          width: sizes[0]?.width,
+          height: sizes[0]?.height
+        }
+      }),
+      ...srcset ? { srcset } : {}
+    });
+  }
+  return {
+    img: original,
+    original,
+    ...sources.length > 0 ? {
+      img: sources[0]?.img,
+      srcset: sources[0]?.srcset
+    } : {},
+    sources
+  };
+}
+export function generateImageSizes(options) {
+  const { width, minWidth = 640, step = 0.7 } = options;
+  const sizes = [];
+  let currentWidth = width;
+  while (true) {
+    const normalizedWidth = Math.round(currentWidth);
+    sizes.push({
+      width: normalizedWidth,
+      descriptor: `${Math.round(normalizedWidth * step)}w`
+    });
+    currentWidth *= step;
+    if (currentWidth < minWidth) {
+      const normalizedWidth2 = Math.round(currentWidth);
+      sizes.push({
+        width: normalizedWidth2,
+        descriptor: `${Math.round(normalizedWidth2 * step)}w`
+      });
+      break;
+    }
+  }
+  return sizes;
+}

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

@@ -1 +1,4 @@
-export {};
+export * from './avatar';
+export * from './dictionaries';
+export * from './image';
+export * from './slugify';

package/dist/runtime/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./avatar.js";
+export * from "./dictionaries.js";
+export * from "./image.js";
+export * from "./slugify.js";