@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/UserContext-DqWeZkUZ.d.ts

@@ -0,0 +1,100 @@
+import React__default from 'react';
+import { UserContext as UserContext$1, FieldValue } from '@almadar/core';
+
+/**
+ * UserContext
+ *
+ * React context for providing user data throughout the application.
+ * Enables @user bindings in S-expressions for role-based UI and permissions.
+ *
+ * Usage:
+ * ```tsx
+ * // In App.tsx or layout
+ * <UserProvider user={{ id: '123', role: 'admin', permissions: ['read', 'write'] }}>
+ *   <App />
+ * </UserProvider>
+ *
+ * // In components - access via hook
+ * const { user, hasRole, hasPermission } = useUser();
+ * if (hasRole('admin')) { ... }
+ * if (hasPermission('delete')) { ... }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * User data for `@user` bindings — the canonical `UserContext` from
+ * `@almadar/core`, kept under this name for existing consumers. Declaring the
+ * shape locally let it drift from the type both execution paths resolve against.
+ */
+type UserData = UserContext$1;
+/**
+ * User context value.
+ */
+interface UserContextValue {
+    /** Current user data (null if not logged in) */
+    user: UserData | null;
+    /** Check if user is logged in */
+    isLoggedIn: boolean;
+    /** Check if user has a specific role */
+    hasRole: (role: string) => boolean;
+    /** Check if user has a specific permission */
+    hasPermission: (permission: string) => boolean;
+    /** Check if user has any of the specified roles */
+    hasAnyRole: (roles: string[]) => boolean;
+    /** Check if user has all of the specified permissions */
+    hasAllPermissions: (permissions: string[]) => boolean;
+    /** Get a user field by path (for @user.field bindings) */
+    getUserField: (path: string) => FieldValue | undefined;
+}
+declare const UserContext: React__default.Context<UserContextValue | null>;
+interface UserProviderProps {
+    /** User data (null if not logged in) */
+    user?: UserData | null;
+    /** Children to render */
+    children: React__default.ReactNode;
+}
+/**
+ * Provider component that provides user context to the application.
+ *
+ * Provides RBAC helpers and field access for @user bindings.
+ */
+declare function UserProvider({ user, children, }: UserProviderProps): React__default.ReactElement;
+/**
+ * Hook to access the user context.
+ *
+ * Returns default values if used outside of UserProvider (for resilience).
+ *
+ * @example
+ * ```tsx
+ * function AdminPanel() {
+ *   const { user, hasRole, hasPermission } = useUser();
+ *
+ *   if (!hasRole('admin') && !hasPermission('admin:access')) {
+ *     return <AccessDenied />;
+ *   }
+ *
+ *   return <div>Welcome, {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function useUser(): UserContextValue;
+/**
+ * Hook to check if user has a specific role.
+ * Convenience wrapper around useUser().hasRole().
+ */
+declare function useHasRole(role: string): boolean;
+/**
+ * Hook to check if user has a specific permission.
+ * Convenience wrapper around useUser().hasPermission().
+ */
+declare function useHasPermission(permission: string): boolean;
+/**
+ * Hook to get user data for @user bindings in S-expressions.
+ * Returns the user data object compatible with EvaluationContext.user
+ */
+declare function useUserForEvaluation(): UserData | undefined;
+
+export { UserContext as U, UserProvider as c, useHasRole as e, useUser as f, useUserForEvaluation as g, useHasPermission as u };
+export type { UserContextValue as a, UserData as b, UserProviderProps as d };

package/dist/auth/browser/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@almadar/shell-browser/auth';
+import '@almadar/shell-browser/storage';

package/dist/auth/browser/index.js

@@ -0,0 +1 @@
+export * from '@almadar/shell-browser/auth';

package/dist/auth/react/index.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode, ReactElement } from 'react';
+import { ViewerAuthority, UserContext } from '@almadar/core';
+import { BrowserAuth, SignedInUser } from '@almadar/shell-browser/auth';
+export { BrowserAuth, SignedInUser } from '@almadar/shell-browser/auth';
+
+/** The provider's resolved viewer authority — `@almadar/core`'s {@link ViewerAuthority}. */
+type AuthAuthority = ViewerAuthority;
+interface AuthContextValue {
+    /** The sign-in surface, or null when the app has no auth configured. */
+    auth: BrowserAuth | null;
+    user: SignedInUser | null;
+    authority: AuthAuthority;
+    /** An interactive auth action (or the initial connect) is in flight. */
+    loading: boolean;
+    /** The last interactive action's failure; a valid session survives it. */
+    error: string | null;
+    clearError(): void;
+    signInWithGoogle(): Promise<void>;
+    signInWithEmail(email: string, password: string): Promise<void>;
+    signUpWithEmail(email: string, password: string, displayName?: string): Promise<void>;
+    sendSignInLinkToEmail(email: string, returnUrl: string): Promise<void>;
+    isSignInWithEmailLink(link: string): boolean;
+    signInWithEmailLink(email: string, link: string): Promise<void>;
+    signInWithCustomToken(customToken: string): Promise<void>;
+    signOut(): Promise<void>;
+}
+interface AuthProviderProps {
+    /** Connects the app's sign-in surface; resolves null when the app has no auth configured. */
+    connect: () => Promise<BrowserAuth | null>;
+    children: ReactNode;
+}
+declare function AuthProvider({ connect, children }: AuthProviderProps): ReactElement;
+/** The provider's value, or undefined outside an AuthProvider (an app with no sign-in surface). */
+declare function useOptionalAuth(): AuthContextValue | undefined;
+declare function useAuth(): AuthContextValue;
+interface DevPersonas {
+    /** The app's `[identity]` rows; empty when the server offers no dev personas (no Auth emulator). */
+    personas: UserContext[];
+    signInAs(id: string): Promise<void>;
+}
+/**
+ * The dev persona roster a program's `std-dev-personas` hooks offer (`personas`, `persona-sign-in`; they
+ * answer only while the server runs on the Auth emulator), and sign-in as one of them: a real emulated
+ * user, so `@user` resolves as in production.
+ */
+declare function useDevPersonas(apiBase: string): DevPersonas;
+
+export { AuthProvider, useAuth, useDevPersonas, useOptionalAuth };
+export type { AuthAuthority, AuthContextValue, AuthProviderProps, DevPersonas };

package/dist/auth/react/index.js

@@ -0,0 +1,119 @@
+import '../../chunk-G7DCAZ22.js';
+import { createContext, useState, useEffect, useCallback, useMemo, useContext } from 'react';
+import { z } from 'zod';
+import { FieldValueSchema } from '@almadar/core';
+import { jsx } from 'react/jsx-runtime';
+
+var AuthContext = createContext(void 0);
+var NOT_CONFIGURED = "Sign-in is not configured for this app";
+function AuthProvider({ connect, children }) {
+  const [auth, setAuth] = useState(null);
+  const [user, setUser] = useState(null);
+  const [authority, setAuthority] = useState("pending");
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let unsubscribe;
+    let cancelled = false;
+    connect().then((connected) => {
+      if (cancelled) return;
+      setAuth(connected);
+      if (connected === null) {
+        setAuthority("unavailable");
+        setLoading(false);
+        return;
+      }
+      unsubscribe = connected.onUserChanged(
+        (next) => {
+          setUser(next);
+          setAuthority(next === null ? "anonymous" : "authenticated");
+          setLoading(false);
+        },
+        (err) => {
+          setUser(null);
+          setAuthority("failed");
+          setError(err.message);
+          setLoading(false);
+        }
+      );
+    }).catch((err) => {
+      if (cancelled) return;
+      setAuthority("failed");
+      setError(err.message);
+      setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+      unsubscribe?.();
+    };
+  }, [connect]);
+  const run = useCallback(async (action) => {
+    if (auth === null) {
+      setError(NOT_CONFIGURED);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      await action(auth);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setLoading(false);
+    }
+  }, [auth]);
+  const value = useMemo(() => ({
+    auth,
+    user,
+    authority,
+    loading,
+    error,
+    clearError: () => setError(null),
+    signInWithGoogle: () => run((a) => a.signInWithGoogle()),
+    signInWithEmail: (email, password) => run((a) => a.signInWithEmail(email, password)),
+    signUpWithEmail: (email, password, displayName) => run((a) => a.signUpWithEmail(email, password, displayName)),
+    sendSignInLinkToEmail: (email, returnUrl) => run((a) => a.sendSignInLinkToEmail(email, returnUrl)),
+    isSignInWithEmailLink: (link) => auth?.isSignInWithEmailLink(link) ?? false,
+    signInWithEmailLink: (email, link) => run((a) => a.signInWithEmailLink(email, link)),
+    signInWithCustomToken: (customToken) => run((a) => a.signInWithCustomToken(customToken)),
+    signOut: () => run((a) => a.signOut())
+  }), [auth, user, authority, loading, error, run]);
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
+}
+function useOptionalAuth() {
+  return useContext(AuthContext);
+}
+function useAuth() {
+  const value = useContext(AuthContext);
+  if (value === void 0) throw new Error("useAuth must be used within an AuthProvider");
+  return value;
+}
+var PersonasSchema = z.object({
+  success: z.literal(true),
+  personas: z.array(z.object({ id: z.string() }).catchall(FieldValueSchema.optional()))
+});
+var SignInSchema = z.object({ success: z.literal(true), customToken: z.string() });
+function useDevPersonas(apiBase) {
+  const { signInWithCustomToken } = useAuth();
+  const [personas, setPersonas] = useState([]);
+  useEffect(() => {
+    let cancelled = false;
+    void fetch(`${apiBase}/api/hooks/personas`, { method: "POST", headers: { "Content-Type": "application/json" }, body: "{}" }).then(async (res) => res.ok ? PersonasSchema.parse(await res.json()).personas : []).then((list) => {
+      if (!cancelled) setPersonas(list);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [apiBase]);
+  const signInAs = useCallback(async (id) => {
+    const res = await fetch(`${apiBase}/api/hooks/persona-sign-in`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id })
+    });
+    await signInWithCustomToken(SignInSchema.parse(await res.json()).customToken);
+  }, [apiBase, signInWithCustomToken]);
+  return { personas, signInAs };
+}
+
+export { AuthProvider, useAuth, useDevPersonas, useOptionalAuth };