@lenne.tech/nuxt-extensions 1.0.0

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

@@ -0,0 +1,88 @@
+/**
+ * Auth module configuration options
+ */
+export interface LtAuthModuleOptions {
+    /** Auth API base path (default: '/iam' - must match nest-server betterAuth.basePath) */
+    basePath?: string;
+    /** API base URL (default: from env or http://localhost:3000) */
+    baseURL?: string;
+    /** Enable the auth module (default: true) */
+    enabled?: boolean;
+    /** Enable admin plugin (default: true) */
+    enableAdmin?: boolean;
+    /** Enable passkey plugin (default: true) */
+    enablePasskey?: boolean;
+    /** Enable 2FA plugin (default: true) */
+    enableTwoFactor?: boolean;
+    /** Auth interceptor configuration */
+    interceptor?: {
+        /** Enable the auth interceptor plugin (default: true) */
+        enabled?: boolean;
+        /** Paths that should not trigger auto-logout on 401 */
+        publicPaths?: string[];
+    };
+    /** Login page path for redirects (default: '/auth/login') */
+    loginPath?: string;
+    /** 2FA redirect path (default: '/auth/2fa') */
+    twoFactorRedirectPath?: string;
+}
+/**
+ * TUS upload module configuration options
+ */
+export interface LtTusModuleOptions {
+    /** Default chunk size in bytes (default: 5MB) */
+    defaultChunkSize?: number;
+    /** Default TUS upload endpoint (default: '/files/upload') */
+    defaultEndpoint?: string;
+}
+/**
+ * i18n module configuration options
+ */
+export interface LtI18nModuleOptions {
+    /** Automatically merge locale files with @nuxtjs/i18n (default: true) */
+    autoMerge?: boolean;
+}
+/**
+ * Main module options for @lenne.tech/nuxt-extensions
+ */
+export interface LtExtensionsModuleOptions {
+    /** Auth module configuration */
+    auth?: LtAuthModuleOptions;
+    /** i18n configuration */
+    i18n?: LtI18nModuleOptions;
+    /** TUS upload module configuration */
+    tus?: LtTusModuleOptions;
+}
+/**
+ * Public runtime config added by this module
+ */
+export interface LtExtensionsPublicRuntimeConfig {
+    ltExtensions: {
+        auth: {
+            basePath: string;
+            baseURL: string;
+            enabled: boolean;
+            enableAdmin: boolean;
+            enablePasskey: boolean;
+            enableTwoFactor: boolean;
+            interceptor: {
+                enabled: boolean;
+                publicPaths: string[];
+            };
+            loginPath: string;
+            twoFactorRedirectPath: string;
+        };
+        tus: {
+            defaultChunkSize: number;
+            defaultEndpoint: string;
+        };
+    };
+}
+declare module 'nuxt/schema' {
+    interface PublicRuntimeConfig extends LtExtensionsPublicRuntimeConfig {
+    }
+}
+declare module '@nuxt/schema' {
+    interface PublicRuntimeConfig extends LtExtensionsPublicRuntimeConfig {
+    }
+}

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

@@ -0,0 +1,133 @@
+import type { ComputedRef } from 'vue';
+/**
+ * Status of an upload item
+ */
+export type LtUploadStatus = 'completed' | 'error' | 'idle' | 'paused' | 'uploading';
+/**
+ * Progress information for an upload
+ */
+export interface LtUploadProgress {
+    /** Total bytes to upload */
+    bytesTotal: number;
+    /** Bytes already uploaded */
+    bytesUploaded: number;
+    /** Percentage complete (0-100) */
+    percentage: number;
+    /** Estimated remaining time in seconds */
+    remainingTime: number;
+    /** Current upload speed in bytes/second */
+    speed: number;
+}
+/**
+ * Individual upload item with progress tracking
+ */
+export interface LtUploadItem {
+    /** Timestamp when upload completed */
+    completedAt?: Date;
+    /** Error message if upload failed */
+    error?: string;
+    /** The file being uploaded */
+    file: File;
+    /** Unique identifier for this upload */
+    id: string;
+    /** Custom metadata to include with the upload */
+    metadata?: Record<string, string>;
+    /** Current progress information */
+    progress: LtUploadProgress;
+    /** Timestamp when upload started */
+    startedAt?: Date;
+    /** Current status of the upload */
+    status: LtUploadStatus;
+    /** URL of the uploaded file (available after completion) */
+    url?: string;
+}
+/**
+ * Configuration options for TUS uploads
+ */
+export interface LtUploadOptions {
+    /** Automatically start uploads when files are added (default: true) */
+    autoStart?: boolean;
+    /** Chunk size in bytes (default: 5MB) */
+    chunkSize?: number;
+    /** TUS upload endpoint URL */
+    endpoint?: string;
+    /** Additional headers to include with requests */
+    headers?: Record<string, string>;
+    /** Default metadata to include with all uploads */
+    metadata?: Record<string, string>;
+    /** Callback when an upload fails */
+    onError?: (item: LtUploadItem, error: Error) => void;
+    /** Callback when upload progress updates */
+    onProgress?: (item: LtUploadItem) => void;
+    /** Callback when an upload completes successfully */
+    onSuccess?: (item: LtUploadItem) => void;
+    /** Maximum number of concurrent uploads (default: 3) */
+    parallelUploads?: number;
+    /** Retry delays in milliseconds (default: [0, 1000, 3000, 5000, 10000]) */
+    retryDelays?: number[];
+}
+/**
+ * Return type for useLtTusUpload composable
+ */
+export interface UseLtTusUploadReturn {
+    /** Add files to the upload queue, returns array of upload IDs */
+    addFiles: (files: File | File[]) => Promise<string[]>;
+    /** Cancel all uploads */
+    cancelAll: () => void;
+    /** Cancel a specific upload by ID */
+    cancelUpload: (id: string) => void;
+    /** Remove all completed uploads from the list */
+    clearCompleted: () => void;
+    /** Get an upload item by ID */
+    getUpload: (id: string) => LtUploadItem | undefined;
+    /** Pause all active uploads */
+    pauseAll: () => void;
+    /** Pause a specific upload by ID */
+    pauseUpload: (id: string) => void;
+    /** Remove an upload from the list (also cancels if active) */
+    removeUpload: (id: string) => void;
+    /** Resume all paused uploads */
+    resumeAll: () => void;
+    /** Resume a specific upload by ID */
+    resumeUpload: (id: string) => void;
+    /** Retry a failed upload by ID */
+    retryUpload: (id: string) => void;
+    /** Start all idle uploads */
+    startAll: () => void;
+    /** Start a specific upload by ID */
+    startUpload: (id: string) => void;
+    /** Whether any uploads are currently in progress */
+    isUploading: ComputedRef<boolean>;
+    /** Aggregated progress of all uploads */
+    totalProgress: ComputedRef<LtUploadProgress>;
+    /** List of all upload items */
+    uploads: ComputedRef<LtUploadItem[]>;
+}
+/**
+ * File info returned from the server
+ */
+export interface LtFileInfo {
+    [key: string]: unknown;
+    filename: string;
+    id: string;
+    mimetype: string;
+    size: number;
+    url?: string;
+}
+/**
+ * Return type for useLtFile composable
+ */
+export interface UseLtFileReturn {
+    /** Format duration in seconds to human readable string */
+    formatDuration: (seconds: number) => string;
+    /** Format bytes to human readable string (e.g., "1.5 MB") */
+    formatFileSize: (bytes: number) => string;
+    /** Get download URL for a file by ID */
+    getDownloadUrl: (id: string, filename?: string) => string;
+    /** Get file info from the server by ID */
+    getFileInfo: (id: string | undefined) => Promise<LtFileInfo | null | string>;
+    /** Get direct file URL by ID */
+    getFileUrl: (id: string) => string;
+    /** Check if a string is a valid MongoDB ObjectId */
+    isValidMongoID: (id: string) => boolean;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Hashes a string using SHA256
+ * Uses the Web Crypto API which is available in all modern browsers
+ *
+ * @param message - The string to hash
+ * @returns The SHA256 hash as a lowercase hex string (64 characters)
+ *
+ * @example
+ * ```typescript
+ * const hash = await ltSha256('myPassword');
+ * // Returns: 'a5de7...9f' (64 character hex string)
+ * ```
+ */
+export declare function ltSha256(message: string): Promise<string>;
+/**
+ * Converts an ArrayBuffer to a base64url-encoded string
+ * Used for WebAuthn credential responses
+ *
+ * @param buffer - The ArrayBuffer to convert
+ * @returns The base64url-encoded string (no padding)
+ *
+ * @example
+ * ```typescript
+ * const base64 = ltArrayBufferToBase64Url(credential.rawId);
+ * ```
+ */
+export declare function ltArrayBufferToBase64Url(buffer: ArrayBuffer): string;
+/**
+ * Converts a base64url-encoded string to a Uint8Array
+ * Used for WebAuthn challenge decoding
+ *
+ * @param base64url - The base64url-encoded string
+ * @returns The decoded Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const challenge = ltBase64UrlToUint8Array(options.challenge);
+ * ```
+ */
+export declare function ltBase64UrlToUint8Array(base64url: string): Uint8Array;

package/dist/runtime/utils/crypto.js

@@ -0,0 +1,17 @@
+export async function ltSha256(message) {
+  const msgBuffer = new TextEncoder().encode(message);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function ltArrayBufferToBase64Url(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  bytes.forEach((b) => binary += String.fromCharCode(b));
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export function ltBase64UrlToUint8Array(base64url) {
+  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  const paddedBase64 = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  return Uint8Array.from(atob(paddedBase64), (c) => c.charCodeAt(0));
+}

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

@@ -0,0 +1,2 @@
+export { ltArrayBufferToBase64Url, ltBase64UrlToUint8Array, ltSha256 } from './crypto.js';
+export { tw } from './tw.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,2 @@
+export { ltArrayBufferToBase64Url, ltBase64UrlToUint8Array, ltSha256 } from "./crypto.js";
+export { tw } from "./tw.js";

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

@@ -0,0 +1,20 @@
+/**
+ * Tailwind TypeScript helper
+ *
+ * This utility function helps with TypeScript autocomplete when using
+ * Tailwind CSS classes as string literals. It's a no-op at runtime but
+ * provides type information for IDE support.
+ *
+ * @param tailwindClasses - A string or template literal with Tailwind classes
+ * @returns The same string unchanged
+ *
+ * @example
+ * ```typescript
+ * // With IDE plugins, you get autocomplete for Tailwind classes
+ * const buttonClasses = tw`bg-blue-500 hover:bg-blue-700 text-white`;
+ *
+ * // Also works as a regular function
+ * const classes = tw('flex items-center gap-2');
+ * ```
+ */
+export declare const tw: <T extends string | TemplateStringsArray>(tailwindClasses: T) => T;

package/dist/runtime/utils/tw.js

@@ -0,0 +1 @@
+export const tw = (tailwindClasses) => tailwindClasses;

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type LtExtensionsModuleOptions } from '../dist/runtime/types/index.js'
+
+export { type configKey, default, type name, type version } from './module.mjs'

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@lenne.tech/nuxt-extensions",
+  "version": "1.0.0",
+  "description": "Reusable Nuxt 4 composables, components, and Better-Auth integration for lenne.tech projects",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lenneTech/nuxt-extensions.git"
+  },
+  "homepage": "https://github.com/lenneTech/nuxt-extensions#readme",
+  "bugs": {
+    "url": "https://github.com/lenneTech/nuxt-extensions/issues"
+  },
+  "author": "lenne.Tech <info@lenne.tech> (https://lenne.tech)",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepare": "git config core.hooksPath .githooks",
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "build": "nuxt-module-build build",
+    "lint": "oxlint src/",
+    "lint:fix": "oxlint --fix src/",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "release": "npm run lint && npm run test && npm run prepack"
+  },
+  "dependencies": {
+    "@nuxt/kit": "4.2.2"
+  },
+  "peerDependencies": {
+    "@better-auth/passkey": ">=1.0.0",
+    "better-auth": ">=1.0.0",
+    "nuxt": ">=3.0.0",
+    "tus-js-client": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-auth": {
+      "optional": false
+    },
+    "@better-auth/passkey": {
+      "optional": true
+    },
+    "tus-js-client": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@better-auth/passkey": "1.4.10",
+    "@nuxt/devtools": "3.1.1",
+    "@nuxt/module-builder": "1.0.2",
+    "@nuxt/schema": "4.2.2",
+    "@nuxt/test-utils": "3.23.0",
+    "@types/node": "25.0.10",
+    "@vitest/coverage-v8": "3.0.0",
+    "@vue/test-utils": "2.4.6",
+    "better-auth": "1.4.10",
+    "happy-dom": "20.3.7",
+    "nuxt": "4.2.2",
+    "oxlint": "0.17.0",
+    "tus-js-client": "4.3.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.17",
+    "vue-tsc": "3.2.2"
+  },
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "nuxt4",
+    "vue3",
+    "better-auth",
+    "authentication",
+    "passkey",
+    "webauthn",
+    "tus-upload",
+    "file-upload",
+    "lenne-tech"
+  ]
+}