abckit 0.0.1

package/dist/runtime/composables/useAuth.js

@@ -0,0 +1,41 @@
+import { navigateTo } from "#app";
+import { adminClient } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/vue";
+const authClient = createAuthClient({
+  plugins: [adminClient()]
+});
+export function useAuth() {
+  const session = authClient.useSession();
+  const isLoading = computed(() => session.value.isPending);
+  const isAuthenticated = computed(() => !!session.value.data?.user);
+  const user = computed(() => session.value.data?.user || null);
+  function login(returnTo) {
+    const query = returnTo ? `?return_to=${encodeURIComponent(returnTo)}` : "";
+    navigateTo(`/auth/login${query}`);
+  }
+  function register(returnTo) {
+    const query = returnTo ? `?return_to=${encodeURIComponent(returnTo)}` : "";
+    navigateTo(`/auth/register${query}`);
+  }
+  async function logout() {
+    await authClient.signOut();
+    navigateTo("/");
+  }
+  async function refreshSession() {
+    const result = await authClient.getSession({ fetchOptions: { cache: "no-store" } });
+    return result;
+  }
+  return {
+    session,
+    isLoading,
+    isAuthenticated,
+    user,
+    login,
+    register,
+    logout,
+    refreshSession,
+    authClient
+  };
+}
+export const { signIn, signUp, signOut, useSession, getSession } = authClient;
+export { authClient };

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

@@ -0,0 +1,55 @@
+import type { NuxtLinkProps } from 'nuxt/app';
+import type { MaybeRefOrGetter } from 'vue';
+interface NuxtUIBreadcrumbItem extends NuxtLinkProps {
+    label: string;
+    labelClass?: string;
+    icon?: string;
+    iconClass?: string;
+    as?: string;
+    type?: 'button' | 'submit' | 'reset';
+    disabled?: boolean;
+    active?: boolean;
+    exact?: boolean;
+    exactQuery?: boolean;
+    exactMatch?: boolean;
+    inactiveClass?: string;
+    [key: string]: any;
+}
+export interface BreadcrumbItemProps extends NuxtUIBreadcrumbItem {
+    current?: boolean;
+    ariaCurrent?: 'page' | 'step' | 'location' | 'date' | 'time' | boolean | 'true' | 'false';
+    to?: string;
+    ariaLabel?: string;
+    separator?: boolean | string;
+    class?: (string | string[] | undefined)[] | string;
+    _props?: {
+        first: boolean;
+        last: boolean;
+    };
+}
+export interface BreadcrumbProps {
+    path?: MaybeRefOrGetter<string>;
+    id?: string;
+    append?: MaybeRefOrGetter<BreadcrumbItemProps[]>;
+    prepend?: MaybeRefOrGetter<BreadcrumbItemProps[]>;
+    overrides?: MaybeRefOrGetter<(BreadcrumbItemProps | false | undefined)[]>;
+    ariaLabel?: string;
+    hideCurrent?: MaybeRefOrGetter<boolean>;
+    hideRoot?: MaybeRefOrGetter<boolean>;
+    hideNonExisting?: MaybeRefOrGetter<boolean>;
+    rootSegment?: string;
+    trailingSlash?: boolean;
+}
+export type ResolvedBreadcrumbProps = {
+    [key in keyof BreadcrumbProps]: BreadcrumbProps[key] extends MaybeRefOrGetter<infer T> ? T : BreadcrumbProps[key];
+};
+export declare function isPathFile(path: string): boolean;
+export declare function fixSlashes(trailingSlash: boolean | undefined, pathOrUrl: string): string;
+export declare function pathBreadcrumbSegments(path: string, rootNode?: string): string[];
+/**
+ * Generate an automatic breadcrumb list that helps users to navigate between pages.
+ * Supports hierarchical overrides and integrates with Nuxt I18n (optional).
+ */
+export declare function useBreadcrumbItems(_options?: BreadcrumbProps): import("vue").ComputedRef<BreadcrumbItemProps[]>;
+export declare function defineBreadcrumb(): void;
+export {};

package/dist/runtime/composables/useBreadcrumbItems.js

@@ -0,0 +1,256 @@
+import { defu } from "defu";
+import { useNuxtApp, useRoute, useRouter, useState } from "nuxt/app";
+import { hasTrailingSlash, parseURL, stringifyParsedURL, withoutTrailingSlash, withTrailingSlash } from "ufo";
+import {
+  computed,
+  getCurrentInstance,
+  inject,
+  onScopeDispose,
+  onUnmounted,
+  provide,
+  ref,
+  toRaw,
+  toValue,
+  watch
+} from "vue";
+const fileExtensions = [
+  "jpg",
+  "jpeg",
+  "png",
+  "gif",
+  "bmp",
+  "webp",
+  "svg",
+  "ico",
+  "pdf",
+  "doc",
+  "docx",
+  "xls",
+  "xlsx",
+  "ppt",
+  "pptx",
+  "txt",
+  "md",
+  "zip",
+  "rar",
+  "7z",
+  "tar",
+  "gz",
+  "mp3",
+  "wav",
+  "flac",
+  "ogg",
+  "mp4",
+  "avi",
+  "mkv",
+  "mov",
+  "html",
+  "css",
+  "js",
+  "json",
+  "xml",
+  "tsx",
+  "jsx",
+  "ts",
+  "vue"
+];
+export function isPathFile(path) {
+  const lastSegment = path.split("/").pop();
+  const ext = (lastSegment || path).match(/\.[0-9a-z]+$/i)?.[0];
+  return ext ? fileExtensions.includes(ext.replace(".", "")) : false;
+}
+export function fixSlashes(trailingSlash, pathOrUrl) {
+  const $url = parseURL(pathOrUrl);
+  if (isPathFile($url.pathname))
+    return pathOrUrl;
+  const fixedPath = trailingSlash ? withTrailingSlash($url.pathname) : withoutTrailingSlash($url.pathname);
+  return `${$url.protocol ? `${$url.protocol}//` : ""}${$url.host || ""}${fixedPath}${$url.search || ""}${$url.hash || ""}`;
+}
+export function pathBreadcrumbSegments(path, rootNode = "/") {
+  const startNode = parseURL(path);
+  const appendsTrailingSlash = hasTrailingSlash(startNode.pathname);
+  const stepNode = (node, nodes = []) => {
+    const fullPath = stringifyParsedURL(node);
+    const currentPathName = node.pathname || "/";
+    nodes.push(fullPath || "/");
+    if (currentPathName !== rootNode && currentPathName !== "/") {
+      node.pathname = currentPathName.substring(0, currentPathName.lastIndexOf("/"));
+      if (appendsTrailingSlash)
+        node.pathname = withTrailingSlash(node.pathname.substring(0, node.pathname.lastIndexOf("/")));
+      stepNode(node, nodes);
+    }
+    return nodes;
+  };
+  return stepNode(startNode).reverse();
+}
+function withoutQuery(path) {
+  return path.split("?")[0];
+}
+function titleCase(s) {
+  return s.replaceAll("-", " ").replace(/\w\S*/g, (w) => w.charAt(0).toUpperCase() + w.substr(1).toLowerCase());
+}
+const BreadcrumbCtx = Symbol("BreadcrumbCtx");
+export function useBreadcrumbItems(_options = {}) {
+  const nuxtApp = useNuxtApp();
+  const vm = getCurrentInstance();
+  const id = `${_options.id || "breadcrumb"}`;
+  const uid = `${vm?.uid || 0}`;
+  const parentChain = [];
+  let parent = vm?.parent;
+  while (parent) {
+    parentChain.push(parent.uid || 0);
+    parent = parent.parent;
+  }
+  const pauseUpdates = ref(import.meta.client && nuxtApp.isHydrating);
+  let stateRef = null;
+  if (vm) {
+    stateRef = inject(BreadcrumbCtx, null);
+    if (!stateRef) {
+      stateRef = ref({});
+      provide(BreadcrumbCtx, stateRef);
+    }
+    const state = stateRef.value;
+    state[uid] = _options;
+    stateRef.value = state;
+    onUnmounted(() => {
+      const state2 = toRaw(stateRef.value);
+      delete state2[uid];
+      stateRef.value = state2;
+    });
+    if (import.meta.client) {
+      const hooks = [];
+      hooks.push(nuxtApp.hooks.hook("page:start", () => {
+        pauseUpdates.value = true;
+      }));
+      hooks.push(nuxtApp.hooks.hook("page:finish", () => {
+        if (!nuxtApp.isHydrating)
+          pauseUpdates.value = false;
+      }));
+      hooks.push(nuxtApp.hooks.hook("app:error", () => {
+        pauseUpdates.value = false;
+      }));
+      hooks.push(nuxtApp.hooks.hook("app:suspense:resolve", () => {
+        pauseUpdates.value = false;
+      }));
+      onScopeDispose(() => {
+        hooks.forEach((hook) => hook?.());
+        hooks.length = 0;
+      });
+    }
+  }
+  const route = useRoute();
+  const router = useRouter();
+  const hasI18n = !!nuxtApp.$i18n;
+  const i18n = hasI18n ? nuxtApp.$i18n : null;
+  const lastBreadcrumbs = useState(`breadcrumb:${id}`, () => []);
+  const items = computed(() => {
+    if (import.meta.client && pauseUpdates.value) {
+      return lastBreadcrumbs.value;
+    }
+    const state = toValue(stateRef) || {};
+    const optionStack = [...parentChain, uid].map((parentId) => state[parentId]).filter(Boolean);
+    const flatOptions = optionStack.reduce((acc, _cur) => {
+      const cur = {};
+      Object.entries(_cur).forEach(([key, value]) => {
+        cur[key] = toValue(value);
+      });
+      acc.hideRoot = cur.hideRoot ?? acc.hideRoot;
+      acc.hideCurrent = cur.hideCurrent ?? acc.hideCurrent;
+      acc.hideNonExisting = cur.hideNonExisting ?? acc.hideNonExisting;
+      acc.trailingSlash = cur.trailingSlash ?? acc.trailingSlash;
+      acc.rootSegment = acc.rootSegment || cur.rootSegment;
+      acc.path = acc.path || cur.path;
+      acc.overrides = acc.overrides || [];
+      const overrides = toRaw(toValue(cur.overrides));
+      if (overrides) {
+        overrides.forEach((item, index) => {
+          if (item !== void 0) {
+            acc.overrides[index] = toRaw(toValue(item));
+          }
+        });
+      }
+      const prepend = toRaw(toValue(cur.prepend));
+      const append = toRaw(toValue(cur.append));
+      if (prepend?.length) {
+        acc.prepend = [...acc.prepend || [], ...prepend.map((m) => toRaw(toValue(m)))].filter(Boolean);
+      }
+      if (append?.length) {
+        acc.append = [...acc.append || [], ...append.map((m) => toRaw(toValue(m)))].filter(Boolean);
+      }
+      return acc;
+    }, {});
+    let rootNode = flatOptions.rootSegment || "/";
+    if (i18n?.strategy) {
+      const strategy = toValue(i18n.strategy);
+      const locale = toValue(i18n.locale);
+      const defaultLocale = toValue(i18n.defaultLocale);
+      if (strategy === "prefix" || strategy !== "no_prefix" && defaultLocale !== locale) {
+        rootNode = `${rootNode}${locale}`;
+      }
+    }
+    const current = withoutQuery(withoutTrailingSlash(flatOptions.path || toRaw(route)?.path || rootNode)) || "";
+    const segments = pathBreadcrumbSegments(current, rootNode).map((path, index) => {
+      const override = flatOptions.overrides?.[index];
+      if (override === false)
+        return false;
+      return {
+        to: path,
+        _index: index,
+        _override: override
+      };
+    });
+    segments.unshift(...flatOptions.prepend || []);
+    segments.push(...flatOptions.append || []);
+    return segments.filter(Boolean).map((item) => {
+      const resolvedRoute = item.to ? router.resolve(item.to)?.matched?.at(-1) : null;
+      let autoLabel = titleCase(String((item.to || "").split("/").pop()));
+      let autoAriaLabel = "";
+      if (resolvedRoute) {
+        const routeMeta = resolvedRoute?.meta || {};
+        const routeName = String(resolvedRoute.name).split("___")?.[0];
+        if (routeName === "index")
+          autoLabel = "Home";
+        autoLabel = routeMeta.breadcrumbLabel || routeMeta.breadcrumbTitle || routeMeta.title || autoLabel;
+        if (i18n?.t) {
+          try {
+            autoLabel = i18n.t(`breadcrumb.items.${routeName}.label`, autoLabel, { missingWarn: false });
+            autoAriaLabel = i18n.t(`breadcrumb.items.${routeName}.ariaLabel`, autoAriaLabel, { missingWarn: false });
+          } catch {
+          }
+        }
+        if (routeMeta.breadcrumb) {
+          item = defu(routeMeta.breadcrumb, { to: item.to });
+        }
+      } else if (flatOptions.hideNonExisting) {
+        return false;
+      }
+      const override = item._override;
+      if (override) {
+        item = defu(override, item);
+      }
+      delete item._index;
+      delete item._override;
+      item.label = item.label || autoLabel;
+      item.ariaLabel = item.ariaLabel || autoAriaLabel || item.label;
+      item.current = item.current || item.to === current;
+      if (flatOptions.hideCurrent && item.current)
+        return false;
+      return item;
+    }).map((m) => {
+      if (m && m.to) {
+        m.to = fixSlashes(flatOptions.trailingSlash, m.to);
+        if (m.to === rootNode && flatOptions.hideRoot)
+          return false;
+      }
+      return m;
+    }).filter(Boolean);
+  });
+  watch(items, (newItems) => {
+    if (!pauseUpdates.value) {
+      lastBreadcrumbs.value = newItems;
+    }
+  }, { immediate: true, flush: "sync" });
+  return items;
+}
+export function defineBreadcrumb() {
+}

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

@@ -0,0 +1,10 @@
+export type ImageSize = 'raw' | 'xs' | 'sm' | 'md' | 'lg' | 'thumbnails' | 'thumbnails2' | '2k' | 'profile50' | 'profile75';
+export declare function useImageUrl(): {
+    getImageUrl: (imageKey: string | null | undefined, size?: ImageSize) => string;
+    getAvailableSizes: () => {
+        path: string;
+        description: string;
+        key: ImageSize;
+    }[];
+    getCustomImageUrl: (imageKey: string | null | undefined, params: string) => string;
+};

package/dist/runtime/composables/useImageUrl.js

@@ -0,0 +1,100 @@
+const imageSizes = {
+  "raw": {
+    path: "skip_processing:jpg:png:gif,default=resizing_type:fit",
+    description: "Original image without processing"
+  },
+  "xs": {
+    path: "s:100:100/rt:fill/sh:0.2",
+    description: "Extra small (100x100)"
+  },
+  "sm": {
+    path: "s:250:250/rt:fill/sh:0.3",
+    description: "Small (250x250)"
+  },
+  "md": {
+    path: "s:500:500/rt:fill/sh:0.5",
+    description: "Medium (500x500)"
+  },
+  "lg": {
+    path: "s:1000:1000/rt:fill/sh:0.7",
+    description: "Large (1000x1000)"
+  },
+  "thumbnails": {
+    path: "s:525:175/sh:0.5",
+    description: "Thumbnail (525x175)"
+  },
+  "thumbnails2": {
+    path: "s:1050:350/sh:0.3",
+    description: "Large thumbnail (1050x350)"
+  },
+  "2k": {
+    path: "s:2000:2000/sh:1",
+    description: "2K resolution (2000x2000)"
+  },
+  "profile50": {
+    path: "s:100:100/rt:fill/f:avif",
+    description: "Profile small AVIF (100x100)"
+  },
+  "profile75": {
+    path: "s:150:150/rt:fill/f:avif",
+    description: "Profile medium AVIF (150x150)"
+  }
+};
+export function useImageUrl() {
+  const config = useRuntimeConfig();
+  const imgproxyConfig = config.public.imgproxy;
+  const s3StaticUrl = imgproxyConfig.storageUrl;
+  const cdnDomains = imgproxyConfig.cdnDomains;
+  function extractKeyFromUrl(url) {
+    try {
+      const parsedUrl = new URL(url);
+      if (cdnDomains.includes(parsedUrl.host)) {
+        return parsedUrl.pathname.slice(1);
+      }
+    } catch {
+    }
+    return null;
+  }
+  function getImageUrl(imageKey, size = "lg") {
+    if (!imageKey) {
+      return "";
+    }
+    let key = imageKey;
+    if (imageKey.startsWith("http://") || imageKey.startsWith("https://")) {
+      const extractedKey = extractKeyFromUrl(imageKey);
+      if (extractedKey) {
+        key = extractedKey;
+      } else {
+        return imageKey;
+      }
+    }
+    const basePath = size === "raw" ? "/unsafe/raw/plain/" : `/unsafe/${size}/plain/`;
+    return new URL(key, `${s3StaticUrl}${basePath}`).toString();
+  }
+  function getAvailableSizes() {
+    return Object.entries(imageSizes).map(([key, config2]) => ({
+      key,
+      ...config2
+    }));
+  }
+  function getCustomImageUrl(imageKey, params) {
+    if (!imageKey) {
+      return "";
+    }
+    let key = imageKey;
+    if (imageKey.startsWith("http://") || imageKey.startsWith("https://")) {
+      const extractedKey = extractKeyFromUrl(imageKey);
+      if (extractedKey) {
+        key = extractedKey;
+      } else {
+        return imageKey;
+      }
+    }
+    return new URL(key, `${s3StaticUrl}/unsafe/${params}/plain/`).toString();
+  }
+  return {
+    getImageUrl,
+    getAvailableSizes,
+    getCustomImageUrl
+  };
+}

package/dist/runtime/error.d.vue.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    error: {
+        statusCode: number;
+        statusMessage?: string;
+        message?: string;
+        stack?: string;
+    };
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;