svelte-firekit 0.0.10 → 0.0.12

package/dist/components/nav/nav-main.svelte

@@ -0,0 +1,70 @@
+<script lang="ts">
+  import * as Collapsible from "../ui/collapsible/index.js";
+  import * as Sidebar from "../ui/sidebar/index.js";
+  import { navMain } from "../../config.js";
+  import ChevronRight from "lucide-svelte/icons/chevron-right";
+</script>
+
+{#if navMain}
+  {#each navMain as nav}
+    <Sidebar.Group>
+      <Sidebar.GroupLabel class="capitalize">{nav.title}</Sidebar.GroupLabel>
+      <Sidebar.Menu>
+        {#each nav.items as mainItem (mainItem.title)}
+          {#if mainItem.items && mainItem.items.length > 0}
+            <Collapsible.Root class="group/collapsible">
+              {#snippet child({ props })}
+                <Sidebar.MenuItem {...props}>
+                  <Collapsible.Trigger>
+                    {#snippet child({ props })}
+                      <Sidebar.MenuButton {...props}>
+                        {#snippet tooltipContent()}
+                          {mainItem.title}
+                        {/snippet}
+                        {#if mainItem.icon}
+                          <mainItem.icon />
+                        {/if}
+                        <span>{mainItem.title}</span>
+                        <ChevronRight
+                          class="ml-auto transition-transform duration-200 group-data-[state=open]/collapsible:rotate-90"
+                        />
+                      </Sidebar.MenuButton>
+                    {/snippet}
+                  </Collapsible.Trigger>
+                  <Collapsible.Content>
+                    {#if mainItem.items}
+                      <Sidebar.MenuSub>
+                        {#each mainItem.items as subItem (subItem.title)}
+                          <Sidebar.MenuSubItem>
+                            <Sidebar.MenuSubButton>
+                              {#snippet child({ props })}
+                                <a href={subItem.href} {...props}>
+                                  <span>{subItem.title}</span>
+                                </a>
+                              {/snippet}
+                            </Sidebar.MenuSubButton>
+                          </Sidebar.MenuSubItem>
+                        {/each}
+                      </Sidebar.MenuSub>
+                    {/if}
+                  </Collapsible.Content>
+                </Sidebar.MenuItem>
+              {/snippet}
+            </Collapsible.Root>
+          {:else}
+            <Sidebar.MenuItem>
+              <Sidebar.MenuButton>
+                {#snippet child({ props })}
+                  <a href={mainItem.href} {...props}>
+                    <mainItem.icon />
+                    <span>{mainItem.title}</span>
+                  </a>
+                {/snippet}
+              </Sidebar.MenuButton>
+            </Sidebar.MenuItem>
+          {/if}
+        {/each}
+      </Sidebar.Menu>
+    </Sidebar.Group>
+  {/each}
+{/if}

package/dist/components/nav/nav-main.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const NavMain: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type NavMain = InstanceType<typeof NavMain>;
+export default NavMain;

package/dist/components/ui/badge/badge.svelte

@@ -0,0 +1,49 @@
+<script lang="ts" module>
+	import { type VariantProps, tv } from "tailwind-variants";
+	export const badgeVariants = tv({
+		base: "focus:ring-ring inline-flex select-none items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-offset-2",
+		variants: {
+			variant: {
+				default:
+					"bg-primary text-primary-foreground hover:bg-primary/80 border-transparent shadow",
+				secondary:
+					"bg-secondary text-secondary-foreground hover:bg-secondary/80 border-transparent",
+				destructive:
+					"bg-destructive text-destructive-foreground hover:bg-destructive/80 border-transparent shadow",
+				outline: "text-foreground",
+			},
+		},
+		defaultVariants: {
+			variant: "default",
+		},
+	});
+
+	export type BadgeVariant = VariantProps<typeof badgeVariants>["variant"];
+</script>
+
+<script lang="ts">
+	import type { WithElementRef } from "bits-ui";
+	import type { HTMLAnchorAttributes } from "svelte/elements";
+	import { cn } from "../../../utils.js";
+
+	let {
+		ref = $bindable(null),
+		href,
+		class: className,
+		variant = "default",
+		children,
+		...restProps
+	}: WithElementRef<HTMLAnchorAttributes> & {
+		variant?: BadgeVariant;
+	} = $props();
+</script>
+
+<svelte:element
+	this={href ? "a" : "span"}
+	bind:this={ref}
+	{href}
+	class={cn(badgeVariants({ variant, className }))}
+	{...restProps}
+>
+	{@render children?.()}
+</svelte:element>

package/dist/components/ui/badge/badge.svelte.d.ts

@@ -0,0 +1,59 @@
+import { type VariantProps } from "tailwind-variants";
+export declare const badgeVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}, undefined, "focus:ring-ring inline-flex select-none items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-offset-2", import("tailwind-variants/dist/config").TVConfig<{
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}, {
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}>, {
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}, undefined, "focus:ring-ring inline-flex select-none items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-offset-2", import("tailwind-variants/dist/config").TVConfig<{
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}, {
+    variant: {
+        default: string;
+        secondary: string;
+        destructive: string;
+        outline: string;
+    };
+}>, unknown, unknown, undefined>>;
+export type BadgeVariant = VariantProps<typeof badgeVariants>["variant"];
+import type { HTMLAnchorAttributes } from "svelte/elements";
+declare const Badge: import("svelte").Component<HTMLAnchorAttributes & {
+    ref?: HTMLElement | null | undefined;
+} & {
+    variant?: BadgeVariant;
+}, {}, "ref">;
+export default Badge;

package/dist/components/ui/badge/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Badge } from "./badge.svelte";
+export { badgeVariants, type BadgeVariant } from "./badge.svelte";

package/dist/components/ui/badge/index.js

@@ -0,0 +1,2 @@
+export { default as Badge } from "./badge.svelte";
+export { badgeVariants } from "./badge.svelte";

package/dist/components/ui/collapsible/index.d.ts

@@ -0,0 +1,5 @@
+import { Collapsible as CollapsiblePrimitive } from "bits-ui";
+declare const Root: typeof CollapsiblePrimitive.Root;
+declare const Trigger: typeof CollapsiblePrimitive.Trigger;
+declare const Content: typeof CollapsiblePrimitive.Content;
+export { Root, Content, Trigger, Root as Collapsible, Content as CollapsibleContent, Trigger as CollapsibleTrigger, };

package/dist/components/ui/collapsible/index.js

@@ -0,0 +1,7 @@
+import { Collapsible as CollapsiblePrimitive } from "bits-ui";
+const Root = CollapsiblePrimitive.Root;
+const Trigger = CollapsiblePrimitive.Trigger;
+const Content = CollapsiblePrimitive.Content;
+export { Root, Content, Trigger, 
+//
+Root as Collapsible, Content as CollapsibleContent, Trigger as CollapsibleTrigger, };

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { NavGroup } from "./types/nav";
+export declare const navMain: NavGroup[];

package/dist/config.js

@@ -0,0 +1,28 @@
+import { CircleUserRound, BookOpen, Bot, Settings2, SquareTerminal, ChartPie, Frame, Map, User, LayoutDashboard, StickyNote, } from "lucide-svelte";
+export const navMain = [
+    {
+        title: "Platform",
+        items: [
+            {
+                title: "Dashboard",
+                href: "/dashboard",
+                icon: LayoutDashboard,
+            },
+            {
+                title: "Posts",
+                href: "/posts",
+                icon: StickyNote,
+            },
+        ],
+    },
+    //   {
+    //     title: "Account",
+    //     items: [
+    //       {
+    //         title: "Profile",
+    //         href: "/account/profile",
+    //         icon: User,
+    //       },
+    //     ],
+    //   },
+];

package/dist/firebase/auth/auth-guard.svelte.d.ts

@@ -1,31 +1 @@
-import type { DocumentData } from "firebase/firestore";
-import { firekitUser } from "./user.svelte.js";
-interface GuardConfig {
-    authRequired?: boolean;
-    redirectTo?: string;
-    requiredClaims?: string[];
-    requiredData?: (data: DocumentData | null) => boolean;
-    allowIf?: (user: typeof firekitUser) => boolean;
-    redirectParams?: Record<string, string>;
-}
-export declare class FirekitAuthGuard {
-    private static instance;
-    private _loading;
-    private _error;
-    private _lastValidationTime;
-    private readonly VALIDATION_THROTTLE;
-    private constructor();
-    static getInstance(): FirekitAuthGuard;
-    private shouldThrottleValidation;
-    private handleRedirect;
-    private validateClaims;
-    validateAuth({ authRequired, redirectTo, requiredClaims, requiredData, allowIf, redirectParams }?: GuardConfig): Promise<boolean>;
-    requireAuth(redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    requireNoAuth(redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    requireClaims(claims: string[], redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    requireData(validator: (data: DocumentData | null) => boolean, redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    get loading(): boolean;
-    get error(): Error | null;
-}
-export declare const firekitAuthGuard: FirekitAuthGuard;
 export {};

package/dist/firebase/auth/auth-guard.svelte.js

@@ -1,103 +1,119 @@
-import { browser } from "$app/environment";
-import { goto } from "$app/navigation";
-import { firekitUser } from "./user.svelte.js";
-export class FirekitAuthGuard {
-    static instance;
-    _loading = $state(true);
-    _error = $state(null);
-    _lastValidationTime = 0;
-    VALIDATION_THROTTLE = 1000; // 1 second
-    constructor() { }
-    static getInstance() {
-        if (!FirekitAuthGuard.instance) {
-            FirekitAuthGuard.instance = new FirekitAuthGuard();
-        }
-        return FirekitAuthGuard.instance;
-    }
-    shouldThrottleValidation() {
-        const now = Date.now();
-        if (now - this._lastValidationTime < this.VALIDATION_THROTTLE) {
-            return true;
-        }
-        this._lastValidationTime = now;
-        return false;
-    }
-    async handleRedirect(redirectTo, params) {
-        const url = new URL(redirectTo, window.location.origin);
-        if (params) {
-            Object.entries(params).forEach(([key, value]) => {
-                url.searchParams.append(key, value);
-            });
-        }
-        await goto(url.toString());
-    }
-    async validateClaims(requiredClaims, userClaims) {
-        if (!requiredClaims.length)
-            return true;
-        if (!userClaims)
-            return false;
-        return requiredClaims.every(claim => userClaims[claim]);
-    }
-    async validateAuth({ authRequired = true, redirectTo = '/login', requiredClaims = [], requiredData, allowIf, redirectParams } = {}) {
-        if (!browser)
-            return true;
-        if (this.shouldThrottleValidation())
-            return true;
-        try {
-            this._loading = true;
-            this._error = null;
-            await firekitUser.waitForInit();
-            const isAuthenticated = firekitUser.isLoggedIn;
-            if (authRequired && !isAuthenticated) {
-                await this.handleRedirect(redirectTo, {
-                    ...redirectParams,
-                    returnTo: window.location.pathname
-                });
-                return false;
-            }
-            if (allowIf && !allowIf(firekitUser)) {
-                await this.handleRedirect(redirectTo, redirectParams);
-                return false;
-            }
-            if (requiredClaims.length > 0) {
-                const userClaims = await firekitUser.user?.getIdTokenResult();
-                const hasClaims = await this.validateClaims(requiredClaims, userClaims?.claims);
-                if (!hasClaims) {
-                    await this.handleRedirect(redirectTo, redirectParams);
-                    return false;
-                }
-            }
-            if (requiredData && !requiredData(firekitUser.data)) {
-                await this.handleRedirect(redirectTo, redirectParams);
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            this._error = error instanceof Error ? error : new Error(String(error));
-            return false;
-        }
-        finally {
-            this._loading = false;
-        }
-    }
-    async requireAuth(redirectTo = '/login', redirectParams) {
-        return this.validateAuth({ authRequired: true, redirectTo, redirectParams });
-    }
-    async requireNoAuth(redirectTo = '/dashboard', redirectParams) {
-        return this.validateAuth({ authRequired: false, redirectTo, redirectParams });
-    }
-    async requireClaims(claims, redirectTo = '/login', redirectParams) {
-        return this.validateAuth({ requiredClaims: claims, redirectTo, redirectParams });
-    }
-    async requireData(validator, redirectTo = '/login', redirectParams) {
-        return this.validateAuth({ requiredData: validator, redirectTo, redirectParams });
-    }
-    get loading() {
-        return this._loading;
-    }
-    get error() {
-        return this._error;
-    }
-}
-export const firekitAuthGuard = FirekitAuthGuard.getInstance();
+"use strict";
+// import { browser } from "$app/environment";
+// import { goto } from "$app/navigation";
+// import type { DocumentData } from "firebase/firestore";
+// import { firekitUser } from "./user.svelte.js";
+// type UserClaims = Record<string, any>;
+// interface GuardConfig {
+//     authRequired?: boolean;
+//     redirectTo?: string;
+//     requiredClaims?: string[];
+//     requiredData?: (data: DocumentData | null) => boolean;
+//     allowIf?: (user: typeof firekitUser) => boolean;
+//     redirectParams?: Record<string, string>;
+// }
+// export class FirekitAuthGuard {
+//     private static instance: FirekitAuthGuard;
+//     private _loading = $state(true);
+//     private _error = $state<Error | null>(null);
+//     private _lastValidationTime = 0;
+//     private readonly VALIDATION_THROTTLE = 1000; // 1 second
+//     private constructor() { }
+//     static getInstance(): FirekitAuthGuard {
+//         if (!FirekitAuthGuard.instance) {
+//             FirekitAuthGuard.instance = new FirekitAuthGuard();
+//         }
+//         return FirekitAuthGuard.instance;
+//     }
+//     private shouldThrottleValidation(): boolean {
+//         const now = Date.now();
+//         if (now - this._lastValidationTime < this.VALIDATION_THROTTLE) {
+//             return true;
+//         }
+//         this._lastValidationTime = now;
+//         return false;
+//     }
+//     private async handleRedirect(redirectTo: string, params?: Record<string, string>): Promise<void> {
+//         const url = new URL(redirectTo, window.location.origin);
+//         if (params) {
+//             Object.entries(params).forEach(([key, value]) => {
+//                 url.searchParams.append(key, value);
+//             });
+//         }
+//         await goto(url.toString());
+//     }
+//     private async validateClaims(requiredClaims: string[], userClaims?: UserClaims): Promise<boolean> {
+//         if (!requiredClaims.length) return true;
+//         if (!userClaims) return false;
+//         return requiredClaims.every(claim => userClaims[claim]);
+//     }
+//     async validateAuth({
+//         authRequired = true,
+//         redirectTo = '/login',
+//         requiredClaims = [],
+//         requiredData,
+//         allowIf,
+//         redirectParams
+//     }: GuardConfig = {}): Promise<boolean> {
+//         if (!browser) return true;
+//         if (this.shouldThrottleValidation()) return true;
+//         try {
+//             this._loading = true;
+//             this._error = null;
+//             await firekitUser.waitForInit();
+//             const isAuthenticated = firekitUser.isLoggedIn;
+//             if (authRequired && !isAuthenticated) {
+//                 await this.handleRedirect(redirectTo, {
+//                     ...redirectParams,
+//                     returnTo: window.location.pathname
+//                 });
+//                 return false;
+//             }
+//             if (allowIf && !allowIf(firekitUser)) {
+//                 await this.handleRedirect(redirectTo, redirectParams);
+//                 return false;
+//             }
+//             if (requiredClaims.length > 0) {
+//                 const userClaims = await firekitUser.user?.getIdTokenResult();
+//                 const hasClaims = await this.validateClaims(requiredClaims, userClaims?.claims);
+//                 if (!hasClaims) {
+//                     await this.handleRedirect(redirectTo, redirectParams);
+//                     return false;
+//                 }
+//             }
+//             if (requiredData && !requiredData(firekitUser.data)) {
+//                 await this.handleRedirect(redirectTo, redirectParams);
+//                 return false;
+//             }
+//             return true;
+//         } catch (error) {
+//             this._error = error instanceof Error ? error : new Error(String(error));
+//             return false;
+//         } finally {
+//             this._loading = false;
+//         }
+//     }
+//     async requireAuth(redirectTo = '/login', redirectParams?: Record<string, string>) {
+//         return this.validateAuth({ authRequired: true, redirectTo, redirectParams });
+//     }
+//     async requireNoAuth(redirectTo = '/dashboard', redirectParams?: Record<string, string>) {
+//         return this.validateAuth({ authRequired: false, redirectTo, redirectParams });
+//     }
+//     async requireClaims(claims: string[], redirectTo = '/login', redirectParams?: Record<string, string>) {
+//         return this.validateAuth({ requiredClaims: claims, redirectTo, redirectParams });
+//     }
+//     async requireData(
+//         validator: (data: DocumentData | null) => boolean,
+//         redirectTo = '/login',
+//         redirectParams?: Record<string, string>
+//     ) {
+//         return this.validateAuth({ requiredData: validator, redirectTo, redirectParams });
+//     }
+//     get loading() {
+//         return this._loading;
+//     }
+//     get error() {
+//         return this._error;
+//     }
+// }
+// export const firekitAuthGuard = FirekitAuthGuard.getInstance();

package/dist/firebase/auth/auth-manager.svelte.d.ts

@@ -0,0 +1,73 @@
+import { type User } from "firebase/auth";
+import { type DocumentData } from "firebase/firestore";
+type UserClaims = Record<string, any>;
+interface UserData extends DocumentData {
+    displayName?: string;
+    email?: string;
+    photoURL?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isProfileComplete?: boolean;
+    role?: string;
+    settings?: Record<string, any>;
+    [key: string]: any;
+}
+interface GuardConfig {
+    authRequired?: boolean;
+    redirectTo?: string;
+    requiredClaims?: string[];
+    requiredData?: (data: DocumentData | null) => boolean;
+    allowIf?: (manager: FirekitAuthManager) => boolean;
+    redirectParams?: Record<string, string>;
+}
+export declare class FirekitAuthManager {
+    private static instance;
+    private _user;
+    private _userData;
+    private _claims;
+    private _initialized;
+    private _initPromise;
+    private _loading;
+    private _error;
+    private _lastValidationTime;
+    private readonly VALIDATION_THROTTLE;
+    readonly isLoggedIn: boolean;
+    readonly uid: string | undefined;
+    readonly email: string | null | undefined;
+    readonly displayName: string | null | undefined;
+    readonly photoURL: string | null | undefined;
+    readonly emailVerified: boolean | undefined;
+    readonly claims: UserClaims;
+    readonly data: UserData | null;
+    readonly initialized: boolean;
+    private constructor();
+    static getInstance(): FirekitAuthManager;
+    private initialize;
+    waitForInit(): Promise<void>;
+    private loadUserData;
+    private loadUserClaims;
+    get user(): User | null | undefined;
+    updateEmailUser(email: string): Promise<void>;
+    updatePassword(password: string): Promise<void>;
+    updateProfileInfo({ displayName, photoURL, }: {
+        displayName?: string;
+        photoURL?: string;
+    }): Promise<void>;
+    updateUserData(data: Partial<UserData>): Promise<void>;
+    saveUserData(data: UserData): Promise<void>;
+    hasRequiredClaims(requiredClaims: string[]): boolean;
+    isAdmin(): boolean;
+    isPremium(): boolean;
+    private shouldThrottleValidation;
+    private handleRedirect;
+    private validateClaims;
+    validateAuth({ authRequired, redirectTo, requiredClaims, requiredData, allowIf, redirectParams, }?: GuardConfig): Promise<boolean>;
+    requireAuth(redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
+    requireNoAuth(redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
+    requireClaims(claims: string[], redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
+    requireData(validator: (data: DocumentData | null) => boolean, redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
+    get loading(): boolean;
+    get error(): Error | null;
+}
+export declare const firekitAuthManager: FirekitAuthManager;
+export {};