@flowselections/admin-installatietechniek 1.0.1

package/dist-lib/lib/admin.functions.js

@@ -0,0 +1,410 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getRequestHost } from "@tanstack/react-start/server";
+import { z } from "zod";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { requireAdmin, requireUserAdmin } from "../lib/admin.server";
+const APP_ROLES = ["admin", "planner", "monteur", "administratie"];
+const roleSchema = z.enum(["admin", "planner", "monteur", "administratie"]);
+const permissionSchema = z.enum(["none", "view", "edit"]);
+const syncModulesInput = z.object({
+    shellId: z.string().trim().min(1).max(100).optional(),
+    modules: z
+        .array(z.object({
+        id: z.string().trim().min(1).max(100),
+        name: z.string().trim().min(1).max(120),
+    }))
+        .max(200),
+});
+const setUserPermissionInput = z.object({
+    userId: z.string().uuid(),
+    moduleId: z.string().min(1),
+    permission: z.union([permissionSchema, z.literal("inherit")]),
+});
+const userPermissionsInput = z.object({
+    userId: z.string().uuid(),
+});
+const assignRoleInput = z.object({
+    userId: z.string().uuid(),
+    role: roleSchema,
+});
+const removeRoleInput = z.object({
+    userId: z.string().uuid(),
+    role: roleSchema,
+});
+const setPermissionInput = z.object({
+    role: roleSchema,
+    moduleId: z.string().min(1),
+    permission: permissionSchema,
+});
+const inviteUserInput = z.object({
+    email: z.string().trim().email().max(255),
+    displayName: z.string().trim().min(1).max(100),
+    role: roleSchema,
+});
+const deleteUserInput = z.object({
+    userId: z.string().uuid(),
+});
+const createTestUserInput = z.object({
+    displayName: z.string().trim().min(1).max(100),
+    role: roleSchema,
+    email: z.string().trim().email().max(255).optional(),
+});
+function uniqueRoles(roles) {
+    return Array.from(new Set(roles));
+}
+export const getUsersWithRoles = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { isAdmin } = await requireUserAdmin(context);
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const [{ data: profiles, error: profilesError }, { data: roles, error: rolesError }, { data: authList, error: authError }] = await Promise.all([
+        supabaseAdmin
+            .from("profiles")
+            .select("id, email, display_name")
+            .order("email", { ascending: true }),
+        supabaseAdmin
+            .from("user_roles")
+            .select("id, user_id, role")
+            .order("created_at", { ascending: false }),
+        supabaseAdmin.auth.admin.listUsers({ page: 1, perPage: 1000 }),
+    ]);
+    if (profilesError)
+        throw profilesError;
+    if (rolesError)
+        throw rolesError;
+    if (authError)
+        throw authError;
+    const safeProfiles = Array.isArray(profiles) ? profiles : [];
+    const safeRoles = Array.isArray(roles) ? roles : [];
+    const safeAuthUsers = Array.isArray(authList?.users) ? authList.users : [];
+    const confirmedById = new Map();
+    const isTestById = new Map();
+    for (const u of safeAuthUsers) {
+        confirmedById.set(u.id, Boolean(u.email_confirmed_at));
+        const meta = (u.user_metadata ?? {});
+        isTestById.set(u.id, Boolean(meta.is_test_account));
+    }
+    const rolesByUser = new Map();
+    for (const role of safeRoles) {
+        const list = rolesByUser.get(role.user_id) ?? [];
+        list.push(role);
+        rolesByUser.set(role.user_id, list);
+    }
+    return {
+        users: safeProfiles.map((profile) => ({
+            id: profile.id,
+            email: profile.email ?? "-",
+            displayName: profile.display_name ?? "-",
+            roles: uniqueRoles((rolesByUser.get(profile.id)?.map((r) => r.role) ?? [])),
+            emailConfirmed: confirmedById.get(profile.id) ?? false,
+            isTestAccount: isTestById.get(profile.id) ?? false,
+        })),
+        availableRoles: isAdmin ? APP_ROLES : APP_ROLES.filter((r) => r !== "admin"),
+        isAdmin,
+    };
+});
+export const assignRole = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => assignRoleInput.parse(data))
+    .handler(async ({ context, data }) => {
+    const { isAdmin } = await requireUserAdmin(context);
+    if (!isAdmin && data.role === "admin") {
+        throw new Error("Alleen een admin kan de adminrol toekennen.");
+    }
+    // Schrijft via de user-scoped client: RLS op user_roles is nu de echte gate.
+    const { data: existing, error: checkError } = await context.supabase
+        .from("user_roles")
+        .select("id")
+        .eq("user_id", data.userId)
+        .eq("role", data.role)
+        .maybeSingle();
+    if (checkError)
+        throw checkError;
+    if (existing) {
+        throw new Error(`Gebruiker heeft de rol '${data.role}' al.`);
+    }
+    const { error } = await context.supabase
+        .from("user_roles")
+        .insert({ user_id: data.userId, role: data.role });
+    if (error)
+        throw error;
+    return { ok: true };
+});
+export const removeRole = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => removeRoleInput.parse(data))
+    .handler(async ({ context, data }) => {
+    const { isAdmin } = await requireUserAdmin(context);
+    if (!isAdmin && data.role === "admin") {
+        throw new Error("Alleen een admin kan de adminrol verwijderen.");
+    }
+    if (data.role === "admin" && data.userId === context.userId) {
+        throw new Error("Je kunt je eigen adminrol niet verwijderen.");
+    }
+    // Delete via user-scoped client (RLS gate). De DB-trigger
+    // `prevent_last_admin_delete` is het definitieve vangnet voor de laatste admin.
+    const { error } = await context.supabase
+        .from("user_roles")
+        .delete()
+        .eq("user_id", data.userId)
+        .eq("role", data.role);
+    if (error)
+        throw error;
+    return { ok: true };
+});
+/**
+ * Registreert de modules die de shell heeft geladen. Modules die niet in de
+ * lijst voorkomen blijven bestaan maar worden op inactief gezet.
+ */
+export const syncModuleRegistry = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => syncModulesInput.parse(data))
+    .handler(async ({ context, data }) => {
+    await requireAdmin(context);
+    const modules = Array.isArray(data.modules) ? data.modules : [];
+    if (modules.length === 0)
+        return { ok: true, count: 0 };
+    const now = new Date().toISOString();
+    const { error } = await context.supabase.from("module_registry").upsert(modules.map((m) => ({
+        module_id: m.id,
+        name: m.name,
+        shell_id: data.shellId ?? null,
+        is_active: true,
+        last_seen_at: now,
+    })), { onConflict: "module_id" });
+    if (error)
+        throw error;
+    // Modules van deze shell die niet meer geleverd worden → inactief.
+    if (data.shellId) {
+        const ids = modules.map((m) => m.id);
+        const { error: deactivateError } = await context.supabase
+            .from("module_registry")
+            .update({ is_active: false })
+            .eq("shell_id", data.shellId)
+            .not("module_id", "in", `(${ids.map((i) => `"${i}"`).join(",")})`);
+        if (deactivateError)
+            throw deactivateError;
+    }
+    return { ok: true, count: modules.length };
+});
+export const getModulePermissions = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    await requireAdmin(context);
+    const [{ data, error }, { data: registry, error: registryError }] = await Promise.all([
+        context.supabase.from("module_permissions").select("role, module_id, permission"),
+        context.supabase
+            .from("module_registry")
+            .select("module_id, name, is_active")
+            .order("name", { ascending: true }),
+    ]);
+    if (error)
+        throw error;
+    if (registryError)
+        throw registryError;
+    const safe = Array.isArray(data) ? data : [];
+    const safeRegistry = Array.isArray(registry) ? registry : [];
+    return {
+        roles: APP_ROLES,
+        modules: safeRegistry
+            .filter((row) => row.is_active)
+            .map((row) => ({
+            id: row.module_id,
+            name: row.name,
+        })),
+        permissions: safe.map((row) => ({
+            role: row.role,
+            moduleId: row.module_id,
+            permission: row.permission,
+        })),
+    };
+});
+export const getUserModulePermissions = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => userPermissionsInput.parse(data))
+    .handler(async ({ context, data }) => {
+    await requireUserAdmin(context);
+    const [{ data: overrides, error }, { data: registry, error: registryError }] = await Promise.all([
+        context.supabase
+            .from("user_module_permissions")
+            .select("module_id, permission")
+            .eq("user_id", data.userId),
+        context.supabase
+            .from("module_registry")
+            .select("module_id, name, is_active")
+            .order("name", { ascending: true }),
+    ]);
+    if (error)
+        throw error;
+    if (registryError)
+        throw registryError;
+    const safeOverrides = Array.isArray(overrides) ? overrides : [];
+    const safeRegistry = Array.isArray(registry) ? registry : [];
+    return {
+        modules: safeRegistry
+            .filter((row) => row.is_active)
+            .map((row) => ({
+            id: row.module_id,
+            name: row.name,
+        })),
+        overrides: safeOverrides.map((row) => ({
+            moduleId: row.module_id,
+            permission: row.permission,
+        })),
+    };
+});
+export const setUserModulePermission = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => setUserPermissionInput.parse(data))
+    .handler(async ({ context, data }) => {
+    await requireUserAdmin(context);
+    if (data.permission === "inherit") {
+        const { error } = await context.supabase
+            .from("user_module_permissions")
+            .delete()
+            .eq("user_id", data.userId)
+            .eq("module_id", data.moduleId);
+        if (error)
+            throw error;
+        return { ok: true };
+    }
+    const { error } = await context.supabase.from("user_module_permissions").upsert({
+        user_id: data.userId,
+        module_id: data.moduleId,
+        permission: data.permission,
+        updated_at: new Date().toISOString(),
+    }, { onConflict: "user_id,module_id" });
+    if (error)
+        throw error;
+    return { ok: true };
+});
+export const setModulePermission = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => setPermissionInput.parse(data))
+    .handler(async ({ context, data }) => {
+    await requireAdmin(context);
+    // Upsert via user-scoped client — RLS write-policy op module_permissions
+    // vereist admin (via JWT-claim of has_role-fallback).
+    const { error } = await context.supabase
+        .from("module_permissions")
+        .upsert({
+        role: data.role,
+        module_id: data.moduleId,
+        permission: data.permission,
+    }, { onConflict: "role,module_id" });
+    if (error)
+        throw error;
+    return { ok: true };
+});
+export const inviteUser = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => inviteUserInput.parse(data))
+    .handler(async ({ context, data }) => {
+    const { isAdmin } = await requireUserAdmin(context);
+    if (!isAdmin && data.role === "admin") {
+        throw new Error("Alleen een admin kan een account met de adminrol aanmaken.");
+    }
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    let redirectTo;
+    try {
+        const host = getRequestHost();
+        if (host) {
+            const proto = host.startsWith("localhost") ? "http" : "https";
+            redirectTo = `${proto}://${host}/reset-wachtwoord`;
+        }
+    }
+    catch {
+        redirectTo = undefined;
+    }
+    const { data: invited, error: inviteError } = await supabaseAdmin.auth.admin.inviteUserByEmail(data.email, {
+        data: { display_name: data.displayName },
+        redirectTo,
+    });
+    if (inviteError || !invited?.user) {
+        const msg = inviteError?.message ?? "Uitnodigen mislukt";
+        throw new Error(/already|exists|registered/i.test(msg) ? "Deze gebruiker bestaat al." : msg);
+    }
+    const userId = invited.user.id;
+    const { error: profileError } = await supabaseAdmin
+        .from("profiles")
+        .upsert({ id: userId, email: data.email, display_name: data.displayName }, { onConflict: "id" });
+    if (profileError)
+        throw profileError;
+    const { error: roleError } = await supabaseAdmin
+        .from("user_roles")
+        .upsert({ user_id: userId, role: data.role }, { onConflict: "user_id,role", ignoreDuplicates: true });
+    if (roleError)
+        throw roleError;
+    return { ok: true, userId };
+});
+export const deleteUser = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => deleteUserInput.parse(data))
+    .handler(async ({ context, data }) => {
+    const { isAdmin } = await requireUserAdmin(context);
+    if (data.userId === context.userId) {
+        throw new Error("Je kunt je eigen account niet verwijderen.");
+    }
+    if (!isAdmin) {
+        const { data: targetRoles, error: targetError } = await context.supabase
+            .from("user_roles")
+            .select("role")
+            .eq("user_id", data.userId);
+        if (targetError)
+            throw targetError;
+        const safeTargetRoles = Array.isArray(targetRoles) ? targetRoles : [];
+        if (safeTargetRoles.some((r) => r.role === "admin")) {
+            throw new Error("Alleen een admin kan een adminaccount verwijderen.");
+        }
+    }
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { error } = await supabaseAdmin.auth.admin.deleteUser(data.userId);
+    if (error)
+        throw error;
+    return { ok: true };
+});
+function generatePassword(length = 16) {
+    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789!@#$%*";
+    const bytes = new Uint8Array(length);
+    crypto.getRandomValues(bytes);
+    let out = "";
+    for (let i = 0; i < length; i++)
+        out += alphabet[bytes[i] % alphabet.length];
+    return out;
+}
+export const createTestUser = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => createTestUserInput.parse(data))
+    .handler(async ({ context, data }) => {
+    const { isAdmin } = await requireUserAdmin(context);
+    if (!isAdmin && data.role === "admin") {
+        throw new Error("Alleen een admin kan een account met de adminrol aanmaken.");
+    }
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const email = data.email?.trim() ||
+        `test-${Date.now()}-${Math.floor(Math.random() * 1000)}@test.local`;
+    const password = generatePassword(16);
+    const { data: created, error: createError } = await supabaseAdmin.auth.admin.createUser({
+        email,
+        password,
+        email_confirm: true,
+        user_metadata: { display_name: data.displayName, is_test_account: true },
+    });
+    if (createError || !created?.user) {
+        const msg = createError?.message ?? "Aanmaken mislukt";
+        throw new Error(/already|exists|registered/i.test(msg) ? "Deze gebruiker bestaat al." : msg);
+    }
+    const userId = created.user.id;
+    // Trigger vult profiles al; toch upsert voor zekerheid (idempotent).
+    const { error: profileError } = await supabaseAdmin
+        .from("profiles")
+        .upsert({ id: userId, email, display_name: data.displayName }, { onConflict: "id" });
+    if (profileError)
+        throw profileError;
+    const { error: roleError } = await supabaseAdmin
+        .from("user_roles")
+        .upsert({ user_id: userId, role: data.role }, { onConflict: "user_id,role", ignoreDuplicates: true });
+    if (roleError)
+        throw roleError;
+    return { ok: true, userId, email, password };
+});

package/dist-lib/lib/admin.server.d.ts

@@ -0,0 +1,29 @@
+import type { Database } from "../integrations/supabase/types";
+type AppRole = Database["public"]["Enums"]["app_role"];
+/**
+ * Leest de `user_roles` claim uit het access-token in de Authorization header.
+ * Retourneert een lege array als de claim ontbreekt (bijv. oude sessies die nog
+ * geen refresh hebben gehad na het activeren van de custom_access_token_hook).
+ */
+export declare function readJwtUserRoles(): AppRole[];
+/**
+ * Adminguard die eerst de JWT-claim probeert (0 round-trips) en dan pas
+ * terugvalt op de `has_role` RPC voor sessies zonder claim.
+ */
+export declare function requireAdmin(context: {
+    supabase: any;
+    userId: string;
+}): Promise<void>;
+/**
+ * Guard voor gebruikersbeheer: admin OF administratie mag hier bij.
+ * Geeft terug of de aanvrager volledig admin is, zodat aanroepers de
+ * adminrol kunnen afschermen voor administratie.
+ */
+export declare function requireUserAdmin(context: {
+    supabase: any;
+    userId: string;
+}): Promise<{
+    isAdmin: boolean;
+}>;
+export {};
+//# sourceMappingURL=admin.server.d.ts.map

package/dist-lib/lib/admin.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.server.d.ts","sourceRoot":"","sources":["../../src/lib/admin.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,KAAK,OAAO,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,EAAE,CAoB5C;AAgBD;;;GAGG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAG5F;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACzC,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAI/B"}

package/dist-lib/lib/admin.server.js

@@ -0,0 +1,63 @@
+// Server-only helpers voor de admin-module. Nooit importeren vanuit client-code.
+import { getRequestHeader } from "@tanstack/react-start/server";
+/**
+ * Leest de `user_roles` claim uit het access-token in de Authorization header.
+ * Retourneert een lege array als de claim ontbreekt (bijv. oude sessies die nog
+ * geen refresh hebben gehad na het activeren van de custom_access_token_hook).
+ */
+export function readJwtUserRoles() {
+    try {
+        const authHeader = getRequestHeader("authorization");
+        if (!authHeader?.startsWith("Bearer "))
+            return [];
+        const token = authHeader.slice("Bearer ".length);
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return [];
+        // base64url decode
+        const payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padded = payload + "===".slice((payload.length + 3) % 4);
+        const json = typeof atob === "function"
+            ? atob(padded)
+            : Buffer.from(padded, "base64").toString("utf-8");
+        const claims = JSON.parse(json);
+        const roles = claims?.user_roles;
+        if (!Array.isArray(roles))
+            return [];
+        return roles.filter((r) => typeof r === "string");
+    }
+    catch {
+        return [];
+    }
+}
+async function hasRole(context, role) {
+    const roles = readJwtUserRoles();
+    if (roles.includes(role))
+        return true;
+    const { data, error } = await context.supabase.rpc("has_role", {
+        _user_id: context.userId,
+        _role: role,
+    });
+    return !error && Boolean(data);
+}
+/**
+ * Adminguard die eerst de JWT-claim probeert (0 round-trips) en dan pas
+ * terugvalt op de `has_role` RPC voor sessies zonder claim.
+ */
+export async function requireAdmin(context) {
+    if (await hasRole(context, "admin"))
+        return;
+    throw new Error("Adminrechten vereist");
+}
+/**
+ * Guard voor gebruikersbeheer: admin OF administratie mag hier bij.
+ * Geeft terug of de aanvrager volledig admin is, zodat aanroepers de
+ * adminrol kunnen afschermen voor administratie.
+ */
+export async function requireUserAdmin(context) {
+    if (await hasRole(context, "admin"))
+        return { isAdmin: true };
+    if (await hasRole(context, "administratie"))
+        return { isAdmin: false };
+    throw new Error("Adminrechten vereist");
+}

package/dist-lib/lib/moduleDiscovery.d.ts

@@ -0,0 +1,10 @@
+export interface DiscoveredModule {
+    id: string;
+    name: string;
+}
+/**
+ * Leidt de modulelijst af uit de routeboom van de draaiende shell.
+ * Geen hardcoded modules: elke shell levert automatisch zijn eigen set.
+ */
+export declare function useDiscoveredModules(): DiscoveredModule[];
+//# sourceMappingURL=moduleDiscovery.d.ts.map

package/dist-lib/lib/moduleDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleDiscovery.d.ts","sourceRoot":"","sources":["../../src/lib/moduleDiscovery.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAiBD;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,gBAAgB,EAAE,CAqCzD"}

package/dist-lib/lib/moduleDiscovery.js

@@ -0,0 +1,54 @@
+import { useMemo } from "react";
+import { useRouter } from "@tanstack/react-router";
+const EXCLUDED_SEGMENTS = new Set([
+    "api",
+    "login",
+    "logout",
+    "auth",
+    "reset-wachtwoord",
+    "instellingen",
+]);
+function prettify(segment) {
+    const cleaned = segment.replace(/[-_]+/g, " ").trim();
+    if (!cleaned)
+        return segment;
+    return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+}
+/**
+ * Leidt de modulelijst af uit de routeboom van de draaiende shell.
+ * Geen hardcoded modules: elke shell levert automatisch zijn eigen set.
+ */
+export function useDiscoveredModules() {
+    const router = useRouter();
+    const routesById = (router?.routesById ?? {});
+    const ids = Object.keys(routesById).sort().join("|");
+    return useMemo(() => {
+        const found = new Map();
+        for (const routeId of Object.keys(routesById)) {
+            // Alleen routes binnen de beveiligde shell-omgeving.
+            if (!routeId.startsWith("/_authenticated/"))
+                continue;
+            const path = routeId.slice("/_authenticated/".length);
+            const segments = path.split("/").filter(Boolean);
+            const first = segments[0];
+            if (!first)
+                continue;
+            if (first.startsWith("$") || first.startsWith("_"))
+                continue;
+            if (EXCLUDED_SEGMENTS.has(first))
+                continue;
+            const route = routesById[routeId];
+            const title = route?.options?.staticData?.title;
+            const isTopLevel = segments.length === 1 || (segments.length === 2 && segments[1] === "index");
+            const existing = found.get(first);
+            // Titel van de bovenliggende route wint van die van detailroutes.
+            if (!existing || (isTopLevel && typeof title === "string" && title.trim())) {
+                found.set(first, (isTopLevel && title?.trim()) || existing || prettify(first));
+            }
+        }
+        return Array.from(found.entries())
+            .map(([id, name]) => ({ id, name }))
+            .sort((a, b) => a.name.localeCompare(b.name, "nl"));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [ids]);
+}

package/dist-lib/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist-lib/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist-lib/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist-lib/lib/validationSchemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const bugReportSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+export declare const ALLOWED_FILE_TYPES: string[];
+export declare function validateFileUpload(file: File): {
+    valid: boolean;
+    error?: string;
+};
+//# sourceMappingURL=validationSchemas.d.ts.map

package/dist-lib/lib/validationSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationSchemas.d.ts","sourceRoot":"","sources":["../../src/lib/validationSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;;;iBAGtB,CAAC;AAEH,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,eAAO,MAAM,kBAAkB,UAK9B,CAAC;AAIF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAQjF"}

package/dist-lib/lib/validationSchemas.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const loginSchema = z.object({
+    email: z.string().email("Ongeldig e-mailadres"),
+    password: z.string().min(6, "Wachtwoord moet minimaal 6 tekens bevatten"),
+});
+export const bugReportSchema = z.object({
+    title: z.string().min(1, "Titel is verplicht").max(200),
+    description: z.string().min(1, "Beschrijving is verplicht").max(5000),
+});
+export const ALLOWED_FILE_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "application/pdf",
+];
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+export function validateFileUpload(file) {
+    if (!ALLOWED_FILE_TYPES.includes(file.type)) {
+        return { valid: false, error: "Bestandstype niet toegestaan" };
+    }
+    if (file.size > MAX_FILE_SIZE) {
+        return { valid: false, error: "Bestand is te groot (max 10MB)" };
+    }
+    return { valid: true };
+}

package/dist-lib/styles.css

@@ -0,0 +1 @@
+@source "./";