@lenne.tech/nuxt-extensions 1.0.0

package/dist/runtime/composables/use-lt-auth-client.js

@@ -0,0 +1,27 @@
+import { useNuxtApp } from "#imports";
+import { createLtAuthClient } from "../lib/auth-client.js";
+let authClientInstance = null;
+export function useLtAuthClient() {
+  if (!authClientInstance) {
+    try {
+      const nuxtApp = useNuxtApp();
+      const config = nuxtApp.$config?.public?.ltExtensions?.auth || {};
+      authClientInstance = createLtAuthClient({
+        baseURL: config.baseURL,
+        basePath: config.basePath,
+        twoFactorRedirectPath: config.twoFactorRedirectPath,
+        enableAdmin: config.enableAdmin,
+        enableTwoFactor: config.enableTwoFactor,
+        enablePasskey: config.enablePasskey
+      });
+    } catch {
+      authClientInstance = createLtAuthClient();
+    }
+  }
+  return authClientInstance;
+}
+export const ltAuthClient = {
+  get instance() {
+    return useLtAuthClient();
+  }
+};

package/dist/runtime/composables/use-lt-file.d.ts

@@ -0,0 +1,27 @@
+/**
+ * File Utilities Composable
+ *
+ * Provides helper functions for working with files:
+ * - File info fetching from server
+ * - URL generation for file access
+ * - File size and duration formatting
+ */
+import type { UseLtFileReturn } from '../types/index.js';
+/**
+ * File utilities composable
+ *
+ * @returns File utility functions
+ *
+ * @example
+ * ```typescript
+ * const { formatFileSize, getFileUrl, getDownloadUrl } = useLtFile();
+ *
+ * // Format file size
+ * console.log(formatFileSize(1024)); // "1 KB"
+ *
+ * // Get file URLs
+ * const viewUrl = getFileUrl('abc123');
+ * const downloadUrl = getDownloadUrl('abc123', 'document.pdf');
+ * ```
+ */
+export declare function useLtFile(): UseLtFileReturn;

package/dist/runtime/composables/use-lt-file.js

@@ -0,0 +1,60 @@
+import { useRuntimeConfig } from "#imports";
+export function useLtFile() {
+  const config = useRuntimeConfig();
+  function getFileApiBase() {
+    return config.public.ltExtensions?.tus?.defaultEndpoint?.replace("/upload", "") || "/files";
+  }
+  function isValidMongoID(id) {
+    return /^[a-f\d]{24}$/i.test(id);
+  }
+  async function getFileInfo(id) {
+    if (!id) {
+      return null;
+    }
+    if (!isValidMongoID(id)) {
+      return id;
+    }
+    try {
+      const apiBase = getFileApiBase();
+      const response = await $fetch(`${apiBase}/info/${id}`, {
+        credentials: "include",
+        method: "GET"
+      });
+      return response;
+    } catch (error) {
+      console.error("Error fetching file info:", error);
+      return null;
+    }
+  }
+  function getFileUrl(id) {
+    const apiBase = getFileApiBase();
+    return `${apiBase}/${id}`;
+  }
+  function getDownloadUrl(id, filename) {
+    const apiBase = getFileApiBase();
+    const base = `${apiBase}/download/${id}`;
+    return filename ? `${base}?filename=${encodeURIComponent(filename)}` : base;
+  }
+  function formatFileSize(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+  }
+  function formatDuration(seconds) {
+    if (seconds < 60) return `${seconds}s`;
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
+    return `${hours}h ${minutes}m`;
+  }
+  return {
+    formatDuration,
+    formatFileSize,
+    getDownloadUrl,
+    getFileInfo,
+    getFileUrl,
+    isValidMongoID
+  };
+}

package/dist/runtime/composables/use-lt-share.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Web Share API Composable
+ *
+ * Provides a unified sharing API with:
+ * - Native Web Share API on supported devices
+ * - Clipboard fallback with toast notification
+ * - i18n support with German fallback
+ */
+/**
+ * Return type for useLtShare composable
+ */
+export interface UseLtShareReturn {
+    /** Share content using native API or clipboard fallback */
+    share: (title?: string, text?: string, url?: string) => Promise<void>;
+}
+/**
+ * Web Share composable with clipboard fallback
+ *
+ * @returns Share function
+ *
+ * @example
+ * ```typescript
+ * const { share } = useLtShare();
+ *
+ * // Share current page
+ * await share('Check this out!', 'Amazing content', window.location.href);
+ *
+ * // Share with defaults (uses current URL)
+ * await share();
+ * ```
+ */
+export declare function useLtShare(): UseLtShareReturn;

package/dist/runtime/composables/use-lt-share.js

@@ -0,0 +1,52 @@
+import { useNuxtApp, useRoute } from "#imports";
+export function useLtShare() {
+  const route = useRoute();
+  const nuxtApp = useNuxtApp();
+  function t(key, germanFallback) {
+    const i18n = nuxtApp.$i18n;
+    if (!i18n?.t) {
+      return germanFallback;
+    }
+    return i18n.t(key);
+  }
+  async function share(title, text, url) {
+    if (!import.meta.client) {
+      return;
+    }
+    if (window?.navigator?.share) {
+      try {
+        await window.navigator.share({
+          text: text ?? window.location.origin,
+          title,
+          url: url ?? route.fullPath
+        });
+      } catch (error) {
+        console.error("Error sharing:", error);
+      }
+    } else {
+      try {
+        await navigator.clipboard.writeText(url ?? window.location.origin);
+        const useToast = nuxtApp.$useToast || globalThis.useToast;
+        if (typeof useToast === "function") {
+          try {
+            const toast = useToast();
+            toast.add({
+              color: "success",
+              description: t("lt.share.copiedDescription", "Der Link wurde in die Zwischenablage kopiert."),
+              title: t("lt.share.copied", "Link kopiert")
+            });
+          } catch {
+            console.debug("Link copied to clipboard");
+          }
+        } else {
+          console.debug("Link copied to clipboard");
+        }
+      } catch (error) {
+        console.error("Error copying to clipboard:", error);
+      }
+    }
+  }
+  return {
+    share
+  };
+}

package/dist/runtime/composables/use-lt-tus-upload.d.ts

@@ -0,0 +1,32 @@
+/**
+ * TUS Protocol Upload Composable
+ *
+ * Provides resumable file uploads using the TUS protocol.
+ * Supports pause/resume, parallel uploads, and progress tracking.
+ *
+ * @see https://tus.io/
+ */
+import type { LtUploadOptions, UseLtTusUploadReturn } from '../types/index.js';
+/**
+ * TUS Upload composable with pause/resume support
+ *
+ * @param defaultOptions - Default options for all uploads
+ * @returns Upload management functions and state
+ *
+ * @example
+ * ```typescript
+ * const { addFiles, uploads, totalProgress, isUploading } = useLtTusUpload({
+ *   endpoint: '/api/files/upload',
+ *   onSuccess: (item) => console.log('Uploaded:', item.url),
+ * });
+ *
+ * // Add files from input
+ * function handleFileSelect(event: Event) {
+ *   const input = event.target as HTMLInputElement;
+ *   if (input.files) {
+ *     addFiles(Array.from(input.files));
+ *   }
+ * }
+ * ```
+ */
+export declare function useLtTusUpload(defaultOptions?: LtUploadOptions): UseLtTusUploadReturn;

package/dist/runtime/composables/use-lt-tus-upload.js

@@ -0,0 +1,236 @@
+import { computed, ref, useRuntimeConfig } from "#imports";
+let tusModule = null;
+async function getTusModule() {
+  if (!tusModule) {
+    try {
+      tusModule = await import("tus-js-client");
+    } catch {
+      throw new Error(
+        "[useLtTusUpload] tus-js-client is not installed. Please install it: npm install tus-js-client"
+      );
+    }
+  }
+  return tusModule;
+}
+export function useLtTusUpload(defaultOptions = {}) {
+  const config = useRuntimeConfig();
+  const tusConfig = config.public.ltExtensions?.tus;
+  const uploadItems = ref(/* @__PURE__ */ new Map());
+  const tusUploads = ref(/* @__PURE__ */ new Map());
+  const defaultConfig = {
+    autoStart: true,
+    chunkSize: tusConfig?.defaultChunkSize || 5 * 1024 * 1024,
+    // 5MB chunks
+    endpoint: tusConfig?.defaultEndpoint || "/files/upload",
+    parallelUploads: 3,
+    retryDelays: [0, 1e3, 3e3, 5e3, 1e4],
+    ...defaultOptions
+  };
+  const uploads = computed(() => Array.from(uploadItems.value.values()));
+  const isUploading = computed(() => uploads.value.some((u) => u.status === "uploading"));
+  const totalProgress = computed(() => {
+    const items = uploads.value;
+    if (items.length === 0) {
+      return { bytesTotal: 0, bytesUploaded: 0, percentage: 0, remainingTime: 0, speed: 0 };
+    }
+    const bytesUploaded = items.reduce((acc, i) => acc + i.progress.bytesUploaded, 0);
+    const bytesTotal = items.reduce((acc, i) => acc + i.progress.bytesTotal, 0);
+    const speed = items.reduce((acc, i) => acc + i.progress.speed, 0);
+    return {
+      bytesTotal,
+      bytesUploaded,
+      percentage: bytesTotal > 0 ? Math.round(bytesUploaded / bytesTotal * 100) : 0,
+      remainingTime: speed > 0 ? Math.ceil((bytesTotal - bytesUploaded) / speed) : 0,
+      speed
+    };
+  });
+  function generateId() {
+    return `upload_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  }
+  function createSpeedTracker() {
+    let lastBytes = 0;
+    let lastTime = Date.now();
+    let smoothedSpeed = 0;
+    return (bytesUploaded) => {
+      const now = Date.now();
+      const timeDiff = (now - lastTime) / 1e3;
+      const bytesDiff = bytesUploaded - lastBytes;
+      if (timeDiff > 0) {
+        const currentSpeed = bytesDiff / timeDiff;
+        smoothedSpeed = smoothedSpeed === 0 ? currentSpeed : smoothedSpeed * 0.7 + currentSpeed * 0.3;
+      }
+      lastBytes = bytesUploaded;
+      lastTime = now;
+      return Math.round(smoothedSpeed);
+    };
+  }
+  function updateItem(id, updates) {
+    const item = uploadItems.value.get(id);
+    if (item) {
+      const newMap = new Map(uploadItems.value);
+      newMap.set(id, { ...item, ...updates });
+      uploadItems.value = newMap;
+    }
+  }
+  async function createTusUpload(item, options) {
+    const tus = await getTusModule();
+    const speedTracker = createSpeedTracker();
+    return new tus.Upload(item.file, {
+      chunkSize: options.chunkSize || defaultConfig.chunkSize,
+      endpoint: options.endpoint || defaultConfig.endpoint,
+      headers: options.headers,
+      metadata: {
+        filename: item.file.name,
+        filetype: item.file.type,
+        ...options.metadata,
+        ...item.metadata
+      },
+      onBeforeRequest: (req) => {
+        const xhr = req.getUnderlyingObject();
+        xhr.withCredentials = true;
+      },
+      onError: (error) => {
+        updateItem(item.id, {
+          error: error.message,
+          status: "error"
+        });
+        options.onError?.(uploadItems.value.get(item.id), error);
+      },
+      onProgress: (bytesUploaded, bytesTotal) => {
+        const speed = speedTracker(bytesUploaded);
+        const percentage = Math.round(bytesUploaded / bytesTotal * 100);
+        const remainingTime = speed > 0 ? Math.ceil((bytesTotal - bytesUploaded) / speed) : 0;
+        updateItem(item.id, {
+          progress: { bytesTotal, bytesUploaded, percentage, remainingTime, speed }
+        });
+        options.onProgress?.(uploadItems.value.get(item.id));
+      },
+      onShouldRetry: (err) => {
+        const status = err.originalResponse?.getStatus?.();
+        if (status && status >= 400 && status < 500 && status !== 429) {
+          return false;
+        }
+        return true;
+      },
+      onSuccess: () => {
+        const tusUpload = tusUploads.value.get(item.id);
+        const currentItem = uploadItems.value.get(item.id);
+        updateItem(item.id, {
+          completedAt: /* @__PURE__ */ new Date(),
+          progress: { ...currentItem.progress, percentage: 100 },
+          status: "completed",
+          url: tusUpload?.url ?? void 0
+        });
+        options.onSuccess?.(uploadItems.value.get(item.id));
+      },
+      retryDelays: options.retryDelays || defaultConfig.retryDelays
+    });
+  }
+  async function addFiles(files) {
+    const fileArray = Array.isArray(files) ? files : [files];
+    const ids = [];
+    for (const file of fileArray) {
+      const id = generateId();
+      const item = {
+        file,
+        id,
+        metadata: defaultConfig.metadata,
+        progress: { bytesTotal: file.size, bytesUploaded: 0, percentage: 0, remainingTime: 0, speed: 0 },
+        status: "idle"
+      };
+      const newMap = new Map(uploadItems.value);
+      newMap.set(id, item);
+      uploadItems.value = newMap;
+      const tusUpload = await createTusUpload(item, defaultConfig);
+      tusUploads.value.set(id, tusUpload);
+      ids.push(id);
+    }
+    if (defaultConfig.autoStart) {
+      startAll();
+    }
+    return ids;
+  }
+  function startUpload(id) {
+    const item = uploadItems.value.get(id);
+    const tusUpload = tusUploads.value.get(id);
+    if (item && tusUpload && item.status !== "uploading") {
+      updateItem(id, { startedAt: /* @__PURE__ */ new Date(), status: "uploading" });
+      tusUpload.findPreviousUploads().then((previousUploads) => {
+        const previousUpload = previousUploads[0];
+        if (previousUpload) {
+          tusUpload.resumeFromPreviousUpload(previousUpload);
+        }
+        tusUpload.start();
+      });
+    }
+  }
+  function startAll() {
+    const pending = uploads.value.filter((u) => u.status === "idle" || u.status === "paused");
+    const currentlyUploading = uploads.value.filter((u) => u.status === "uploading").length;
+    const limit = (defaultConfig.parallelUploads || 3) - currentlyUploading;
+    pending.slice(0, Math.max(0, limit)).forEach((item) => startUpload(item.id));
+  }
+  function pauseUpload(id) {
+    const tusUpload = tusUploads.value.get(id);
+    if (tusUpload) {
+      tusUpload.abort();
+      updateItem(id, { status: "paused" });
+    }
+  }
+  function pauseAll() {
+    uploads.value.filter((u) => u.status === "uploading").forEach((item) => pauseUpload(item.id));
+  }
+  function resumeUpload(id) {
+    startUpload(id);
+  }
+  function resumeAll() {
+    uploads.value.filter((u) => u.status === "paused").forEach((item) => resumeUpload(item.id));
+  }
+  function cancelUpload(id) {
+    const tusUpload = tusUploads.value.get(id);
+    if (tusUpload) {
+      tusUpload.abort();
+    }
+    tusUploads.value.delete(id);
+    const newMap = new Map(uploadItems.value);
+    newMap.delete(id);
+    uploadItems.value = newMap;
+  }
+  function cancelAll() {
+    uploads.value.forEach((item) => cancelUpload(item.id));
+  }
+  function removeUpload(id) {
+    cancelUpload(id);
+  }
+  function clearCompleted() {
+    uploads.value.filter((u) => u.status === "completed").forEach((item) => removeUpload(item.id));
+  }
+  function retryUpload(id) {
+    const item = uploadItems.value.get(id);
+    if (item && item.status === "error") {
+      updateItem(id, { error: void 0, status: "idle" });
+      startUpload(id);
+    }
+  }
+  function getUpload(id) {
+    return uploadItems.value.get(id);
+  }
+  return {
+    addFiles,
+    cancelAll,
+    cancelUpload,
+    clearCompleted,
+    getUpload,
+    isUploading,
+    pauseAll,
+    pauseUpload,
+    removeUpload,
+    resumeAll,
+    resumeUpload,
+    retryUpload,
+    startAll,
+    startUpload,
+    totalProgress,
+    uploads
+  };
+}