@exegia/corpora-ui 0.19.0 → 0.21.0

package/dist-lib/components/user-avatar/index.d.ts

@@ -0,0 +1,18 @@
+import { AudioWave } from './audio-wave';
+import { UserAvatar } from './component';
+import { Fallback } from './fallback';
+export { AudioWave } from './audio-wave';
+export { UserAvatar } from './component';
+export { Fallback } from './fallback';
+export { PresenceBadge } from './presence-badge';
+export { initialsFrom } from './utils';
+export { useUserAvatar } from './use-user-avatar';
+export type { UseUserAvatarOptions, UserAvatarBinding } from './use-user-avatar';
+export { useUserAvatarActions, useUserAvatarState } from './use-user-avatar-state';
+export { DEFAULT_BEZEL_ANGLE, removeUserAvatarInstance, resetUserAvatarAtom, setUserAvatarBezelAngleAtom, setUserAvatarPresenceAtom, toggleUserAvatarPresenceAtom, userAvatarBezelAngleAtom, userAvatarIsOnlineAtom, userAvatarPresenceAtom, userAvatarStateAtom, } from './user-avatar-atom';
+export type * from './type';
+export declare const Avatar: {
+    AudioWave: typeof AudioWave;
+    Component: typeof UserAvatar;
+    Fallback: typeof Fallback;
+};

package/dist-lib/components/user-avatar/presence-badge.d.ts

@@ -0,0 +1,16 @@
+import { UserPresence } from './type';
+/**
+ * Corner dot naming whether the person is reachable. Sits on the avatar
+ * frame, outside the clipped circle, with a background-coloured ring so it
+ * reads against any image. Colour is not the only signal: `offline` is a
+ * hollow ring, `online` a filled dot, and the label is spelled out for AT.
+ *
+ * `lightAngle` (degrees clockwise from 12) lays a faint sheen across the dot
+ * from that side — the same angle the avatar's bezel is lit from, so the two
+ * highlights agree and the badge reads as a bead sitting in the same light.
+ */
+export declare function PresenceBadge({ presence, lightAngle, className, }: {
+    presence: UserPresence;
+    lightAngle?: number;
+    className?: string;
+}): import("react").JSX.Element;

package/dist-lib/components/user-avatar/type.d.ts

@@ -0,0 +1,71 @@
+import { AvatarPrimitive } from '../ui/avatar';
+import type * as React from "react";
+export type ImageStatus = Parameters<NonNullable<AvatarPrimitive.Image.Props["onLoadingStatusChange"]>>[0];
+/** Whether the person is reachable right now — drawn as the corner badge. */
+export type UserPresence = "online" | "offline";
+/** Key for one avatar's state in the store. Any stable string; `useUserAvatar`
+ * generates one when the component does not name itself. */
+export type UserAvatarInstanceId = string;
+export interface UserAvatarProps extends Omit<AvatarPrimitive.Root.Props, "children"> {
+    /** Image URL. Without one the initials show immediately — no skeleton. */
+    src?: string;
+    /** Drives the initials, and the alt text unless `alt` overrides it. */
+    name?: string;
+    /** Overrides the initials derived from `name`. */
+    initials?: string;
+    /**
+     * Alt text for the image. Pass "" when adjacent text already names the
+     * person — the image is then decorative.
+     */
+    alt?: string;
+    /**
+     * Force the skeleton, for when the identity itself is still being fetched.
+     * Omitted, it follows the image: a passed `src` skeletons until it resolves.
+     */
+    loading?: boolean;
+    /**
+     * Corner badge: a green dot for `online`, a hollow grey ring for `offline`.
+     * Omitted, no badge — unless the avatar is driven by id and something set
+     * its presence in the store. Controlled when passed.
+     */
+    presence?: UserPresence;
+    /**
+     * Embossed rim whose highlight follows the pointer, so the avatar reads as
+     * a lit bezel rather than a flat disc. Light and dark aware; static under
+     * reduced motion. On by default — pass `false` for a flat disc.
+     */
+    bezel?: boolean;
+    /**
+     * Name this avatar's slice of the store so `useUserAvatarState(id)` /
+     * `useUserAvatarActions(id)` can read or drive it from anywhere under
+     * `ExegiaProvider`. Unnamed avatars key off `useId` and are dropped on
+     * unmount.
+     */
+    avatarId?: UserAvatarInstanceId;
+}
+/** Everything the store knows about one avatar. */
+export interface UserAvatarState {
+    presence: UserPresence | null;
+    /** Bezel light direction in degrees, clockwise from 12 o'clock. Continuous
+     * (may leave [0, 360)) so the rim's CSS rotation never spins the long way;
+     * `((a % 360) + 360) % 360` if you need it normalised. */
+    bezelAngle: number;
+    imageStatus: ImageStatus;
+}
+/** Write-only handles onto one avatar. Nothing here re-renders the caller. */
+export interface UserAvatarActions {
+    setPresence: (presence: UserPresence | null) => void;
+    togglePresence: () => void;
+    setBezelAngle: (angle: number) => void;
+    reset: () => void;
+}
+/** @internal Which fields the mounted component controls from props. The
+ * store must never overwrite a controlled value. */
+export interface UserAvatarConfig {
+    controlsPresence: boolean;
+}
+export interface IAudioWaveProps {
+    className?: string;
+    children?: React.ReactNode;
+    volume?: number;
+}

package/dist-lib/components/user-avatar/use-user-avatar-state.d.ts

@@ -0,0 +1,26 @@
+import { UserAvatarActions, UserAvatarInstanceId, UserAvatarState } from './type';
+/**
+ * Read the avatar registered under `avatarId` from anywhere below
+ * `ExegiaProvider` — no props, no ref, no provider of its own.
+ *
+ * ```tsx
+ * const { presence } = useUserAvatarState("me")
+ * ```
+ *
+ * Returns the whole state object, so the caller re-renders on any change —
+ * including every bezel frame while a pointer moves. A component that only
+ * cares about presence should subscribe to that atom instead:
+ * `useAtomValue(userAvatarPresenceAtom("me"))`.
+ */
+export declare function useUserAvatarState(avatarId: UserAvatarInstanceId): UserAvatarState;
+/**
+ * Write-only handles onto the avatar registered under `avatarId`. Nothing
+ * here subscribes, so a presence indicator elsewhere in the app can flip
+ * the badge without re-rendering when the avatar changes.
+ *
+ * ```tsx
+ * const { setPresence } = useUserAvatarActions("me")
+ * socket.on("presence", (p) => setPresence(p))
+ * ```
+ */
+export declare function useUserAvatarActions(avatarId: UserAvatarInstanceId): UserAvatarActions;

package/dist-lib/components/user-avatar/use-user-avatar.d.ts

@@ -0,0 +1,32 @@
+import { ImageStatus, UserAvatarInstanceId, UserPresence } from './type';
+import * as React from "react";
+export interface UseUserAvatarOptions {
+    avatarId?: UserAvatarInstanceId;
+    /** Controlled presence. `undefined` leaves the store in charge. */
+    presence?: UserPresence;
+    /** Track the pointer for the bezel highlight. */
+    bezel: boolean;
+    /** Only meaningful with an image — no image, no status to track. */
+    hasImage: boolean;
+}
+export interface UserAvatarBinding {
+    avatarId: UserAvatarInstanceId;
+    presence: UserPresence | null;
+    bezelAngle: number;
+    imageStatus: ImageStatus;
+    /** Hand to the image's `onLoadingStatusChange`. Stable. */
+    setImageStatus: (status: ImageStatus) => void;
+    /** Attach to the avatar root — the bezel is lit relative to its centre. */
+    ref: React.RefObject<HTMLElement | null>;
+}
+/**
+ * Binds one avatar to its slice of the store: projects the controlled
+ * `presence` prop, tracks the image status, and — while `bezel` is on —
+ * follows the pointer with a rAF-coalesced `pointermove` listener that turns
+ * the pointer's bearing from the avatar's centre into `bezelAngle`.
+ *
+ * Unnamed avatars key off `useId` and are dropped from the store on unmount;
+ * a named `avatarId` outlives its component so a presence set elsewhere
+ * survives a remount.
+ */
+export declare function useUserAvatar(options: UseUserAvatarOptions): UserAvatarBinding;

package/dist-lib/components/user-avatar/user-avatar-atom.d.ts

@@ -0,0 +1,55 @@
+import { UserAvatarConfig, UserAvatarInstanceId, UserAvatarState, UserPresence } from './type';
+/** Light from the top-left, the classic emboss, until a pointer moves. */
+export declare const DEFAULT_BEZEL_ANGLE = 315;
+type Family<AtomType> = ((id: UserAvatarInstanceId) => AtomType) & {
+    remove: (id: UserAvatarInstanceId) => void;
+};
+/** `null` = no badge. */
+export declare const userAvatarPresenceAtom: Family<import('jotai').PrimitiveAtom<UserPresence | null> & {
+    init: UserPresence | null;
+}>;
+/** Degrees clockwise from 12 o'clock — where the bezel highlight sits. */
+export declare const userAvatarBezelAngleAtom: Family<import('jotai').PrimitiveAtom<number> & {
+    init: number;
+}>;
+export declare const userAvatarImageStatusAtom: Family<import('jotai').PrimitiveAtom<import('@base-ui/react').ImageLoadingStatus> & {
+    init: import('@base-ui/react').ImageLoadingStatus;
+}>;
+/** @internal Which fields the mounted component controls from props. */
+export declare const userAvatarConfigAtom: Family<import('jotai').PrimitiveAtom<UserAvatarConfig> & {
+    init: UserAvatarConfig;
+}>;
+export declare const userAvatarIsOnlineAtom: Family<import('jotai').Atom<boolean>>;
+/** Whole-state read for callers that want the object; field atoms above are
+ * cheaper for components that watch one thing. */
+export declare const userAvatarStateAtom: Family<import('jotai').Atom<UserAvatarState>>;
+/** Inert while a `presence` prop controls the avatar — the prop is truth. */
+export declare const setUserAvatarPresenceAtom: Family<import('jotai').WritableAtom<null, [presence: UserPresence | null], void> & {
+    init: null;
+}>;
+/** online ⇄ offline; a badge-less avatar comes online. */
+export declare const toggleUserAvatarPresenceAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Stored as given — continuous, not wrapped into [0, 360): the rim is
+ * rotated with a CSS transition, and an unwrapped angle is what lets a
+ * 359° → 1° move take the short way round. Written on every pointer frame,
+ * so it stays a bare set — no config gate, no side effects. */
+export declare const setUserAvatarBezelAngleAtom: Family<import('jotai').WritableAtom<null, [angle: number], void> & {
+    init: null;
+}>;
+/** @internal Reported by the image element; drives the skeleton. */
+export declare const setUserAvatarImageStatusAtom: Family<import('jotai').WritableAtom<null, [status: import('@base-ui/react').ImageLoadingStatus], void> & {
+    init: null;
+}>;
+/** @internal Projection of the mounted component's controlled props. */
+export declare const projectUserAvatarPropsAtom: Family<import('jotai').WritableAtom<null, [config: UserAvatarConfig, presence: UserPresence | null | undefined], void> & {
+    init: null;
+}>;
+export declare const resetUserAvatarAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Forget an avatar entirely — every family drops the key so the store can
+ * release its state. Call on teardown of a named instance. */
+export declare function removeUserAvatarInstance(id: UserAvatarInstanceId): void;
+export {};

package/dist-lib/components/user-avatar/utils.d.ts

@@ -0,0 +1,2 @@
+/** "Jenny Hamilton" → "JH", "luna" → "L". */
+export declare function initialsFrom(name: string): string;

package/dist-lib/index.d.ts

@@ -22,8 +22,11 @@ export * from './components/ui/spinner';
 export * from './components/ui/textarea';
 export * from './components/composed/password-input';
 export * from './components/composed/social-providers';
-export * from './components/composed/user-avatar';
+export * from './components/composed/tree';
+export { DEFAULT_BEZEL_ANGLE, PresenceBadge, UserAvatar, initialsFrom, removeUserAvatarInstance, resetUserAvatarAtom, setUserAvatarBezelAngleAtom, setUserAvatarPresenceAtom, toggleUserAvatarPresenceAtom, useUserAvatar, useUserAvatarActions, useUserAvatarState, userAvatarBezelAngleAtom, userAvatarIsOnlineAtom, userAvatarPresenceAtom, userAvatarStateAtom, } from './components/user-avatar';
+export type { UseUserAvatarOptions, UserAvatarActions, UserAvatarBinding, UserAvatarInstanceId, UserAvatarProps, UserAvatarState, UserPresence, } from './components/user-avatar';
 export * from './components/blocks/auth/auth-shell';
+export * from './components/blocks/auth/auth-state';
 export * from './components/blocks/auth/code-auth-block';
 export * from './components/blocks/auth/forgot-password-block';
 export * from './components/blocks/auth/linked-accounts-block';
@@ -39,8 +42,9 @@ export * from './components/blocks/shell';
 export { default as ShellLayout } from './components/blocks/shell';
 export * from './components/blocks/scaffold';
 export { default as Layout } from './components/blocks/layout';
-export * from './components/blocks/profile/profile-card-block';
+export * from './components/blocks/profile';
 export * from './components/motion/shared-layout-bg';
+export * from './state';
 export { AnimatedPanel as AnimatedSidebar, AnimatedPanelProvider as AnimatedSidebarProvider, AnimatedPanelTrigger as AnimatedSidebarTrigger, AnimatedPanelInset as AnimatedSidebarInset, } from './components/blocks/shell';
 export * from './lib/auth-accent';
 export * from './lib/ease';