@sfinges/sf-conversation 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,88 @@
1
+ import { OnDestroy } from '@angular/core';
2
+ import { MenuItem } from 'primeng/api';
3
+ import { ConversationItem, ConversationStore } from '../../state/conversation.store';
4
+ import { MessageSegment } from '../../utils/mention.util';
5
+ import * as i0 from "@angular/core";
6
+ interface MessageView {
7
+ item: ConversationItem;
8
+ author: string;
9
+ segments: MessageSegment[];
10
+ /** Antes de este mensaje va la marca "Mensajes nuevos". */
11
+ divider: boolean;
12
+ }
13
+ /**
14
+ * Panel lateral con la conversación de una entidad (un crédito, una solicitud).
15
+ *
16
+ * No bloquea la pantalla en escritorio y ocupa toda la pantalla en el celular. Pide los mensajes al
17
+ * abrirse, de 30 en 30 hacia atrás. Los permisos los decide el front con `canView` y `canPost`; el
18
+ * que los hace cumplir es el APIM.
19
+ */
20
+ export declare class ConversationPanelComponent implements OnDestroy {
21
+ /** Tipo de entidad que entiende el servicio, por ejemplo el de un crédito o una solicitud. */
22
+ readonly entityType: import("@angular/core").InputSignal<string>;
23
+ readonly entityId: import("@angular/core").InputSignalWithTransform<string, string | number>;
24
+ /** Puede leer la conversación. Sin esto el panel no se abre. */
25
+ readonly canView: import("@angular/core").InputSignal<boolean>;
26
+ /** Puede escribir, editar y borrar lo propio. Sin esto el panel es de solo lectura. */
27
+ readonly canPost: import("@angular/core").InputSignal<boolean>;
28
+ /** Abierto o cerrado. Admite `[(visible)]`. */
29
+ readonly visible: import("@angular/core").ModelSignal<boolean>;
30
+ /** Emite cuando el panel se abre o se cierra, para que el front oculte lo que estorbe. */
31
+ readonly openChange: import("@angular/core").OutputEmitterRef<boolean>;
32
+ protected readonly store: ConversationStore;
33
+ private readonly names;
34
+ private readonly document;
35
+ private readonly injector;
36
+ private readonly scroller;
37
+ private readonly composer;
38
+ private readonly actionsMenu;
39
+ protected readonly isOpen: import("@angular/core").Signal<boolean>;
40
+ protected readonly isMobile: import("@angular/core").WritableSignal<boolean>;
41
+ protected readonly drawerStyle: import("@angular/core").Signal<{
42
+ width: string;
43
+ maxWidth: string;
44
+ } | undefined>;
45
+ protected readonly maxLength = 4000;
46
+ protected readonly titleId: string;
47
+ protected readonly menuItems: import("@angular/core").WritableSignal<MenuItem[]>;
48
+ protected readonly editingKey: import("@angular/core").WritableSignal<string | null>;
49
+ protected readonly editText: import("@angular/core").WritableSignal<string>;
50
+ protected readonly saving: import("@angular/core").WritableSignal<boolean>;
51
+ protected readonly confirmDeleteKey: import("@angular/core").WritableSignal<string | null>;
52
+ protected readonly deleting: import("@angular/core").WritableSignal<boolean>;
53
+ protected readonly view: import("@angular/core").Signal<MessageView[]>;
54
+ private wasOpen;
55
+ private openerElement;
56
+ private nearBottom;
57
+ private lastScroller;
58
+ private lastSeenKey;
59
+ private pendingPrepend;
60
+ constructor();
61
+ ngOnDestroy(): void;
62
+ protected close(): void;
63
+ protected onDrawerVisibleChange(visible: boolean): void;
64
+ protected onShown(): void;
65
+ protected onScroll(): void;
66
+ protected loadOlder(): void;
67
+ protected openActions(event: Event, item: ConversationItem): void;
68
+ protected canAct(item: ConversationItem): boolean;
69
+ protected startEdit(item: ConversationItem): void;
70
+ protected onEditKeydown(event: KeyboardEvent, item: ConversationItem): void;
71
+ protected saveEdit(item: ConversationItem): Promise<void>;
72
+ protected askDelete(item: ConversationItem): void;
73
+ protected confirmDelete(item: ConversationItem): Promise<void>;
74
+ /**
75
+ * Cierra la edición o la confirmación de borrado. Con `item`, el foco vuelve a ese mensaje (a su
76
+ * botón de acciones, o al mensaje si ya no tiene) para no perderse en `body`.
77
+ */
78
+ protected cancelMessageActions(item?: ConversationItem): void;
79
+ protected messageId(item: ConversationItem): string;
80
+ protected editId(item: ConversationItem): string;
81
+ private adjustScroll;
82
+ private restoreFocus;
83
+ private focusById;
84
+ private watchViewport;
85
+ static ɵfac: i0.ɵɵFactoryDeclaration<ConversationPanelComponent, never>;
86
+ static ɵcmp: i0.ɵɵComponentDeclaration<ConversationPanelComponent, "lib-conversation-panel", never, { "entityType": { "alias": "entityType"; "required": true; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": true; "isSignal": true; }; "canView": { "alias": "canView"; "required": true; "isSignal": true; }; "canPost": { "alias": "canPost"; "required": true; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "openChange": "openChange"; }, never, never, true, never>;
87
+ }
88
+ export {};
@@ -0,0 +1,13 @@
1
+ import { InjectionToken } from '@angular/core';
2
+ /**
3
+ * Devuelve el token de usuario vigente del front, sin el prefijo `Bearer`. Puede ser asíncrona
4
+ * (por ejemplo, si el front renueva el token antes de entregarlo). Sin sesión devuelve `null`.
5
+ */
6
+ export type ConversationAccessTokenFactory = () => string | null | undefined | Promise<string | null | undefined>;
7
+ /**
8
+ * Token de usuario para lo que no pasa por los interceptores de `HttpClient`: la negociación y el
9
+ * WebSocket del canal en vivo (`provideConversationRealtime`). El adaptador lo pide en cada
10
+ * conexión y reconexión, así que debe devolver siempre el token vigente, no uno guardado al
11
+ * arrancar.
12
+ */
13
+ export declare const CONVERSATION_ACCESS_TOKEN: InjectionToken<ConversationAccessTokenFactory>;
@@ -0,0 +1,24 @@
1
+ import { InjectionToken } from '@angular/core';
2
+ import { Observable } from 'rxjs';
3
+ import { ConversationUser, ConversationUserRef } from '../models/conversation.model';
4
+ /**
5
+ * Los usuarios del negocio, para poner nombres y para mencionar. El token solo trae el documento
6
+ * (`tdoc`, `ndoc`) y el servicio no guarda nombres: cada front los resuelve con la lista de
7
+ * usuarios que ya tiene.
8
+ *
9
+ * Si el front no lo provee, el panel muestra el documento en lugar del nombre y no ofrece
10
+ * menciones.
11
+ */
12
+ export interface ConversationDirectory {
13
+ /**
14
+ * Nombres de varios usuarios a la vez. Los que no se encuentren se omiten de la respuesta.
15
+ * El panel pide cada usuario una sola vez mientras está abierto.
16
+ */
17
+ resolveUsers(users: ConversationUserRef[]): Observable<ConversationUser[]>;
18
+ /**
19
+ * Usuarios para mencionar que coinciden con lo escrito después de `@`. `query` puede venir
20
+ * vacío, justo después de escribir `@`. El panel muestra los primeros ocho resultados.
21
+ */
22
+ searchUsers(query: string): Observable<ConversationUser[]>;
23
+ }
24
+ export declare const CONVERSATION_DIRECTORY: InjectionToken<ConversationDirectory>;
@@ -0,0 +1,31 @@
1
+ import { EnvironmentProviders } from '@angular/core';
2
+ import { Observable } from 'rxjs';
3
+ import { ConversationListQuery, ConversationMessage, ConversationNewMessage, ConversationPage, ConversationUnread } from '../models/conversation.model';
4
+ import { ConversationGateway } from './conversation.port';
5
+ import * as i0 from "@angular/core";
6
+ /**
7
+ * Implementación de `ConversationGateway` contra la v2 de la API `notifications` del APIM.
8
+ *
9
+ * No pone el token ni la llave de suscripción: eso lo hace el interceptor del front, igual que
10
+ * con las demás rutas v2. El tenant sale del token, por eso no hay `idKatios` en la ruta.
11
+ */
12
+ export declare class ConversationHttpService implements ConversationGateway {
13
+ private readonly http;
14
+ private readonly baseUrl;
15
+ listMessages(entityType: string, entityId: string, query?: ConversationListQuery): Observable<ConversationPage>;
16
+ postMessage(entityType: string, entityId: string, message: ConversationNewMessage): Observable<ConversationMessage>;
17
+ editMessage(messageId: number, body: string): Observable<ConversationMessage | null>;
18
+ deleteMessage(messageId: number): Observable<unknown>;
19
+ markRead(entityType: string, entityId: string, lastReadMessageId: number): Observable<unknown>;
20
+ unreadSummary(entityType: string, entityIds: string[]): Observable<ConversationUnread[]>;
21
+ private entityPath;
22
+ private messagesPath;
23
+ private url;
24
+ static ɵfac: i0.ɵɵFactoryDeclaration<ConversationHttpService, never>;
25
+ static ɵprov: i0.ɵɵInjectableDeclaration<ConversationHttpService>;
26
+ }
27
+ /**
28
+ * Atajo para el caso común: `CONVERSATION_SERVICE` con `ConversationHttpService` sobre la URL dada.
29
+ * El front sigue necesitando `provideHttpClient(...)` con su interceptor de token.
30
+ */
31
+ export declare function provideConversationHttp(apiUrl: string): EnvironmentProviders;
@@ -0,0 +1,29 @@
1
+ import { InjectionToken } from '@angular/core';
2
+ import { Observable } from 'rxjs';
3
+ import { ConversationEvent } from '../models/conversation.model';
4
+ /**
5
+ * Canal opcional de mensajes en vivo. La librería trae uno listo sobre Azure SignalR Service
6
+ * (`provideConversationRealtime()`, ver `ConversationSignalRService`); un front con otro transporte
7
+ * puede implementar este puerto por su cuenta.
8
+ *
9
+ * Sin él la librería funciona igual: el panel pide lo nuevo (`afterId`) al abrirse y cada vez que
10
+ * la pestaña del navegador vuelve a estar visible.
11
+ */
12
+ export interface ConversationRealtime {
13
+ /**
14
+ * Cambios de cualquier conversación a la que el canal esté unido. El panel filtra los de su
15
+ * entidad, así que se puede reenviar todo lo que llega del hub.
16
+ */
17
+ readonly events$: Observable<ConversationEvent>;
18
+ /**
19
+ * Emite cada vez que la conexión se recupera después de caerse. El panel abierto pide entonces
20
+ * los mensajes posteriores al último que tiene. Si el canal no lo expone, lo perdido mientras
21
+ * estuvo caída llega cuando la persona vuelva a la pestaña o reabra el panel.
22
+ */
23
+ readonly reconnected$?: Observable<void>;
24
+ /** Se une al grupo de la conversación. El panel lo llama al abrirse. */
25
+ join(entityType: string, entityId: string): Promise<void> | void;
26
+ /** Sale del grupo. El panel lo llama al cerrarse o al cambiar de entidad. */
27
+ leave(entityType: string, entityId: string): Promise<void> | void;
28
+ }
29
+ export declare const CONVERSATION_REALTIME: InjectionToken<ConversationRealtime>;
@@ -0,0 +1,110 @@
1
+ import { EnvironmentProviders, OnDestroy } from '@angular/core';
2
+ import { HubConnection, IHttpConnectionOptions } from '@microsoft/signalr';
3
+ import { ConversationEvent } from '../models/conversation.model';
4
+ import { ConversationRealtime } from './conversation-realtime.port';
5
+ import * as i0 from "@angular/core";
6
+ /** Evento de cliente que envía el servicio con cada cambio de una conversación. */
7
+ export declare const CONVERSATION_MESSAGE_EVENT = "CONVERSATION_MESSAGE";
8
+ /** Tras cerrar el último panel, la conexión sigue abierta este tiempo por si se abre otro. */
9
+ export declare const CONVERSATION_IDLE_DISCONNECT_MS = 60000;
10
+ /**
11
+ * Una unión pedida mientras la conexión se recupera espera como mucho este tiempo. Después se
12
+ * rechaza y el panel sigue sin canal (pide lo nuevo al volver a la pestaña).
13
+ */
14
+ export declare const CONVERSATION_JOIN_TIMEOUT_MS = 15000;
15
+ /**
16
+ * Una conexión que duró al menos esto se considera estable: si se cae después, se reintenta de
17
+ * inmediato. Si se cae antes, cada intento espera más (evita conectar y caer en bucle).
18
+ */
19
+ export declare const CONVERSATION_STABLE_CONNECTION_MS = 60000;
20
+ /**
21
+ * Pausas entre intentos (reconectar, volver a unirse a un grupo): rápido al principio y después
22
+ * cada minuto, sin rendirse mientras haya un panel abierto. Al cerrarse el último, se detiene.
23
+ */
24
+ export declare const CONVERSATION_RECONNECT_DELAYS_MS: readonly number[];
25
+ /**
26
+ * Canal en vivo listo sobre Azure SignalR Service en modo serverless (TFNBXNotifications):
27
+ *
28
+ * - Conecta al hub `conversations` de la misma API (`<CONVERSATION_API_URL>conversations`): el
29
+ * cliente de SignalR llama solo a `POST conversations/negotiate`, que devuelve la URL y el token
30
+ * de Azure SignalR. El token del front entra por `CONVERSATION_ACCESS_TOKEN`, porque ni la
31
+ * negociación hecha por SignalR ni el WebSocket pasan por los interceptores de `HttpClient`.
32
+ * - Se une y sale de cada conversación con `POST conversations/{tipo}/{id}/join|leave` y el
33
+ * `connectionId`. Estas sí van por `HttpClient`, con el interceptor del front, como el resto de
34
+ * la API. Las de un mismo grupo salen en orden, una después de la otra.
35
+ * - Conecta con el primer panel que se abre y desconecta un minuto después de cerrarse el último.
36
+ * Al reconectar (cambia el `connectionId`) vuelve a unirse a los grupos abiertos y emite
37
+ * `reconnected$`, para que el panel pida lo que se perdió. Si una de esas uniones falla, la
38
+ * reintenta mientras el panel siga abierto.
39
+ * - La conexión, sus pings y los temporizadores corren fuera de la zona de Angular; solo los
40
+ * eventos para los paneles vuelven a ella.
41
+ */
42
+ export declare class ConversationSignalRService implements ConversationRealtime, OnDestroy {
43
+ private readonly http;
44
+ private readonly zone;
45
+ private readonly baseUrl;
46
+ private readonly accessToken;
47
+ private readonly eventsSubject;
48
+ private readonly reconnectedSubject;
49
+ private readonly groups;
50
+ /** La última operación pendiente de cada grupo: unirse y salir se encadenan por grupo. */
51
+ private readonly queues;
52
+ /** Uniones que esperan a que termine una reconexión en curso. */
53
+ private waiters;
54
+ private connection;
55
+ private starting;
56
+ private stopping;
57
+ private stopRequested;
58
+ private idleTimer;
59
+ private restartTimer;
60
+ private connectedAt;
61
+ private closeStreak;
62
+ private destroyed;
63
+ readonly events$: import("rxjs").Observable<ConversationEvent>;
64
+ readonly reconnected$: import("rxjs").Observable<void>;
65
+ join(entityType: string, entityId: string): Promise<void>;
66
+ leave(entityType: string, entityId: string): Promise<void>;
67
+ ngOnDestroy(): void;
68
+ /**
69
+ * Crea la conexión. Las pruebas la reemplazan por una falsa; un front no necesita tocarla.
70
+ */
71
+ protected createConnection(url: string, options: IHttpConnectionOptions): HubConnection;
72
+ /** Une la conexión vigente al grupo. Si la conexión cambió mientras tanto, repite con la nueva. */
73
+ private joinGroup;
74
+ /** Conecta si hace falta y devuelve el `connectionId` vigente. */
75
+ private connected;
76
+ private waitForReconnect;
77
+ private buildConnection;
78
+ /** Vuelve a unir los grupos abiertos a la conexión nueva y después avisa a los paneles. */
79
+ private rejoinAll;
80
+ private rejoin;
81
+ private scheduleRejoin;
82
+ /**
83
+ * La conexión se cerró: por `stop()` o porque el servidor la cerró sin permitir reconectar.
84
+ * En el segundo caso, si hay paneles abiertos, se vuelve a conectar desde cero.
85
+ */
86
+ private handleClose;
87
+ private scheduleRestart;
88
+ private scheduleIdleStop;
89
+ private stop;
90
+ /** Encadena la operación detrás de la anterior del mismo grupo, para que lleguen en orden. */
91
+ private enqueue;
92
+ private post;
93
+ private forget;
94
+ private currentConnectionId;
95
+ private notifyReconnected;
96
+ private resolveWaiters;
97
+ private rejectWaiters;
98
+ private clearRetry;
99
+ private cancelIdleStop;
100
+ private cancelRestart;
101
+ private url;
102
+ static ɵfac: i0.ɵɵFactoryDeclaration<ConversationSignalRService, never>;
103
+ static ɵprov: i0.ɵɵInjectableDeclaration<ConversationSignalRService>;
104
+ }
105
+ /**
106
+ * Canal en vivo listo: `CONVERSATION_REALTIME` con `ConversationSignalRService`. Usa la URL de
107
+ * `CONVERSATION_API_URL` (la pone `provideConversationHttp`) y el token de
108
+ * `CONVERSATION_ACCESS_TOKEN`, que el front provee. Si falta alguno, el panel funciona sin canal.
109
+ */
110
+ export declare function provideConversationRealtime(): EnvironmentProviders;
@@ -0,0 +1,38 @@
1
+ import { InjectionToken } from '@angular/core';
2
+ import { Observable } from 'rxjs';
3
+ import { ConversationListQuery, ConversationMessage, ConversationNewMessage, ConversationPage, ConversationUnread } from '../models/conversation.model';
4
+ /**
5
+ * Las operaciones de la conversación. La librería nunca llama al API por su cuenta: usa lo que el
6
+ * front provee en `CONVERSATION_SERVICE`. `ConversationHttpService` es la implementación lista
7
+ * contra la v2 de `notifications`; un front puede poner otra (un mock, una fachada propia).
8
+ *
9
+ * Los errores deben llegar como `HttpErrorResponse` (o con `status` y `error.code`): la librería
10
+ * los clasifica para decirle a la persona qué pasó. Un 403 con `code: NOT_AUTHOR` es del
11
+ * servicio (el mensaje es de otro); cualquier otro 403 es que al perfil le falta la opción.
12
+ */
13
+ export interface ConversationGateway {
14
+ /** Una página del hilo, del más nuevo al más viejo. Un hilo que no existe responde vacío. */
15
+ listMessages(entityType: string, entityId: string, query?: ConversationListQuery): Observable<ConversationPage>;
16
+ /**
17
+ * Guarda un mensaje y crea el hilo si falta. Con un `clientMessageId` repetido el servicio
18
+ * devuelve el que ya existía, así que reintentar con el mismo id es seguro.
19
+ */
20
+ postMessage(entityType: string, entityId: string, message: ConversationNewMessage): Observable<ConversationMessage>;
21
+ /**
22
+ * Cambia el texto de un mensaje propio. Si la respuesta trae el mensaje, la librería lo usa;
23
+ * si no trae cuerpo, actualiza el que tiene en pantalla.
24
+ */
25
+ editMessage(messageId: number, body: string): Observable<ConversationMessage | null>;
26
+ /** Borrado lógico de un mensaje propio. */
27
+ deleteMessage(messageId: number): Observable<unknown>;
28
+ /** Mueve hacia adelante hasta dónde leyó el usuario. Un valor menor que el guardado se ignora. */
29
+ markRead(entityType: string, entityId: string, lastReadMessageId: number): Observable<unknown>;
30
+ /** No leídos y fecha del último mensaje de varias entidades del mismo tipo, en una llamada. */
31
+ unreadSummary(entityType: string, entityIds: string[]): Observable<ConversationUnread[]>;
32
+ }
33
+ export declare const CONVERSATION_SERVICE: InjectionToken<ConversationGateway>;
34
+ /**
35
+ * URL base de la API para `ConversationHttpService`, hasta la versión incluida
36
+ * (por ejemplo `https://<apim>/notifications/v2/`). Las rutas se arman relativas a ella.
37
+ */
38
+ export declare const CONVERSATION_API_URL: InjectionToken<string>;
@@ -0,0 +1,73 @@
1
+ /**
2
+ * Contrato de datos de la conversación, igual al que devuelve la v2 de la API `notifications`.
3
+ *
4
+ * El tenant no aparece en ninguna parte: sale del token que pone el interceptor del front.
5
+ */
6
+ /** Un usuario, tal como lo identifica el token: tipo y número de documento. */
7
+ export interface ConversationUserRef {
8
+ tdoc: string;
9
+ ndoc: string;
10
+ }
11
+ /** Un usuario con el nombre que muestra el front que aloja la librería. */
12
+ export interface ConversationUser extends ConversationUserRef {
13
+ /** Nombre visible. Es también el texto que queda en el mensaje al mencionarlo (`@nombre`). */
14
+ name: string;
15
+ /** Dato secundario para distinguir homónimos en la lista de menciones (cargo, oficina, correo). */
16
+ detail?: string;
17
+ }
18
+ /**
19
+ * Origen del mensaje. En la fase 1 todo es `app`; `whatsapp` y `system` llegan en fases
20
+ * siguientes. Se deja abierto para que un valor nuevo del backend no rompa la compilación.
21
+ */
22
+ export type ConversationMessageSource = 'app' | 'whatsapp' | 'system' | (string & {});
23
+ export interface ConversationMessage {
24
+ id: number;
25
+ /** El uuid con que el front lo envió. Con él se reconoce el eco del mensaje propio. */
26
+ clientMessageId: string | null;
27
+ source: ConversationMessageSource;
28
+ author: ConversationUserRef;
29
+ /** Texto plano. Vacío cuando el mensaje está borrado. */
30
+ body: string;
31
+ mentions: ConversationUserRef[];
32
+ /** ISO 8601 en UTC. */
33
+ createdAt: string;
34
+ editedAt: string | null;
35
+ deleted: boolean;
36
+ /** Lo calcula el servicio con el token: el mensaje es de quien pregunta. */
37
+ mine: boolean;
38
+ }
39
+ /** Una página de mensajes, del más nuevo al más viejo, y hasta dónde leyó el usuario. */
40
+ export interface ConversationPage {
41
+ messages: ConversationMessage[];
42
+ lastReadMessageId: number | null;
43
+ }
44
+ export interface ConversationListQuery {
45
+ /** Mensajes anteriores a este id: para ir hacia atrás. */
46
+ beforeId?: number;
47
+ /** Mensajes posteriores a este id: para traer lo nuevo. */
48
+ afterId?: number;
49
+ limit?: number;
50
+ }
51
+ export interface ConversationNewMessage {
52
+ /** uuid que genera la librería. Reenviarlo con el mismo id no duplica el mensaje. */
53
+ clientMessageId: string;
54
+ body: string;
55
+ mentions: ConversationUserRef[];
56
+ }
57
+ export interface ConversationUnread {
58
+ entityId: string;
59
+ unread: number;
60
+ lastMessageAt: string | null;
61
+ }
62
+ export type ConversationChange = 'created' | 'edited' | 'deleted';
63
+ /** Un cambio en una conversación, tal como llega por el canal de tiempo real. */
64
+ export interface ConversationEvent {
65
+ idKatios: string;
66
+ entityType: string;
67
+ entityId: string;
68
+ change: ConversationChange;
69
+ /** Sin `mine`: el servicio no sabe quién lo recibe. El panel lo deduce de lo que ya tenía. */
70
+ message: Omit<ConversationMessage, 'mine'> & {
71
+ mine?: boolean;
72
+ };
73
+ }
@@ -0,0 +1,22 @@
1
+ import { ConversationUser, ConversationUserRef } from '../models/conversation.model';
2
+ import * as i0 from "@angular/core";
3
+ /**
4
+ * Nombres de los usuarios que aparecen en el hilo. Pide cada usuario una sola vez al
5
+ * `CONVERSATION_DIRECTORY` y lo guarda mientras viva el panel.
6
+ */
7
+ export declare class ConversationUserNames {
8
+ private readonly directory;
9
+ private readonly destroyRef;
10
+ private readonly requested;
11
+ private readonly names;
12
+ /** Mapa `tdoc:ndoc` → nombre. Es una señal: la vista se repinta cuando llega un nombre. */
13
+ readonly resolved: import("@angular/core").Signal<ReadonlyMap<string, string>>;
14
+ /** Pide los nombres que todavía no se han pedido. */
15
+ ensure(users: readonly ConversationUserRef[]): void;
16
+ /** Guarda nombres que ya se conocen, como los de las personas elegidas al mencionar. */
17
+ remember(users: readonly ConversationUser[]): void;
18
+ /** El nombre, o el documento mientras no haya nombre. */
19
+ label(user: ConversationUserRef, names?: ReadonlyMap<string, string>): string;
20
+ static ɵfac: i0.ɵɵFactoryDeclaration<ConversationUserNames, never>;
21
+ static ɵprov: i0.ɵɵInjectableDeclaration<ConversationUserNames>;
22
+ }
@@ -0,0 +1,86 @@
1
+ import { ConversationMessage, ConversationUser, ConversationUserRef } from '../models/conversation.model';
2
+ import * as i0 from "@angular/core";
3
+ export type ConversationItemStatus = 'sent' | 'sending' | 'failed';
4
+ /** Un mensaje en pantalla: los del servicio y los propios que todavía no confirma. */
5
+ export interface ConversationItem extends Omit<ConversationMessage, 'id'> {
6
+ /** `null` mientras el mensaje propio no lo confirma el servicio. */
7
+ id: number | null;
8
+ /** Clave estable para la vista: no cambia cuando el mensaje pendiente queda confirmado. */
9
+ key: string;
10
+ status: ConversationItemStatus;
11
+ /** Por qué falló el envío, para mostrarlo junto al mensaje. */
12
+ error: string | null;
13
+ }
14
+ export type ConversationLoadStatus = 'idle' | 'loading' | 'ready' | 'error';
15
+ /** Tamaño de página: de 30 en 30 hacia atrás. */
16
+ export declare const CONVERSATION_PAGE_SIZE = 30;
17
+ /**
18
+ * Estado de una conversación abierta: la lista, la paginación hacia atrás, el envío optimista,
19
+ * los mensajes en vivo y hasta dónde leyó la persona. Vive con el panel (provider del componente).
20
+ */
21
+ export declare class ConversationStore {
22
+ private readonly gateway;
23
+ private readonly realtime;
24
+ private readonly names;
25
+ private readonly destroyRef;
26
+ readonly items: import("@angular/core").WritableSignal<ConversationItem[]>;
27
+ readonly status: import("@angular/core").WritableSignal<ConversationLoadStatus>;
28
+ readonly loadError: import("@angular/core").WritableSignal<string | null>;
29
+ readonly hasOlder: import("@angular/core").WritableSignal<boolean>;
30
+ readonly olderStatus: import("@angular/core").WritableSignal<"error" | "idle" | "loading">;
31
+ /** `lastReadMessageId` al abrir: de ahí sale la marca "Mensajes nuevos". */
32
+ readonly lastReadAtOpen: import("@angular/core").WritableSignal<number | null>;
33
+ /** Error de una acción sobre un mensaje (editar, borrar), para mostrarlo en el panel. */
34
+ readonly notice: import("@angular/core").WritableSignal<string | null>;
35
+ /** Borrador del campo de texto. Sobrevive a cerrar y abrir el panel de la misma entidad. */
36
+ readonly draft: import("@angular/core").WritableSignal<string>;
37
+ /** Personas elegidas en la lista de menciones mientras se escribe el borrador. */
38
+ readonly draftMentions: import("@angular/core").WritableSignal<ConversationUser[]>;
39
+ /** Hay canal en vivo y el panel ya está unido al grupo. */
40
+ readonly live: import("@angular/core").WritableSignal<boolean>;
41
+ private entity;
42
+ private session;
43
+ private sessionId;
44
+ private lastMarkedRead;
45
+ private markReadDeferred;
46
+ /** Abre (o reabre) la conversación de una entidad. */
47
+ open(entityType: string, entityId: string): void;
48
+ /** Cierra la conversación: sale del grupo en vivo y corta lo que estuviera pidiendo. */
49
+ close(): void;
50
+ retryLoad(): void;
51
+ loadOlder(): void;
52
+ /**
53
+ * Trae lo posterior al último mensaje que hay en pantalla. Si llega una página completa puede
54
+ * haber más, así que se recarga la primera página en lugar de dejar un hueco.
55
+ */
56
+ refreshNewer(): void;
57
+ /** La pestaña del navegador volvió a estar visible. */
58
+ onVisible(): void;
59
+ send(body: string, mentions: ConversationUserRef[]): void;
60
+ /** Reenvía un mensaje que falló, con el mismo `clientMessageId`: el servicio no lo duplica. */
61
+ retrySend(key: string): void;
62
+ /** Quita de la lista un mensaje que no se pudo enviar. */
63
+ discard(key: string): void;
64
+ /** Cambia el texto de un mensaje propio. Resuelve `true` si quedó guardado. */
65
+ edit(item: ConversationItem, body: string): Promise<boolean>;
66
+ /** Borrado lógico de un mensaje propio. Resuelve `true` si quedó borrado. */
67
+ remove(item: ConversationItem): Promise<boolean>;
68
+ dismissNotice(): void;
69
+ private load;
70
+ private applyFirstPage;
71
+ private post;
72
+ private run;
73
+ private connectRealtime;
74
+ private applyEvent;
75
+ /** Lleva `lastReadMessageId` hasta el mensaje más nuevo, si la persona lo puede estar viendo. */
76
+ private markReadLatest;
77
+ private upsertMany;
78
+ private patch;
79
+ private toItem;
80
+ private resolveNames;
81
+ private isCurrent;
82
+ private endSession;
83
+ private reset;
84
+ static ɵfac: i0.ɵɵFactoryDeclaration<ConversationStore, never>;
85
+ static ɵprov: i0.ɵɵInjectableDeclaration<ConversationStore>;
86
+ }
@@ -0,0 +1,8 @@
1
+ /** Qué estaba haciendo la persona cuando falló, para que el mensaje lo nombre. */
2
+ export type ConversationAction = 'load' | 'send' | 'edit' | 'delete';
3
+ /**
4
+ * Traduce un error del puerto a una frase para la persona. Nunca muestra el texto técnico del
5
+ * backend. Distingue el 403 del servicio (`NOT_AUTHOR`) del 403 del APIM (al perfil le falta la
6
+ * opción), como pide el contrato de la v2.
7
+ */
8
+ export declare function describeConversationError(error: unknown, action: ConversationAction): string;
@@ -0,0 +1,21 @@
1
+ import { ConversationUserRef } from '../models/conversation.model';
2
+ /** Un trozo del texto de un mensaje: texto corriente o una mención. */
3
+ export interface MessageSegment {
4
+ text: string;
5
+ mention: boolean;
6
+ }
7
+ export declare function userKey(user: ConversationUserRef): string;
8
+ /**
9
+ * Parte el texto en trozos para resaltar las menciones sin `[innerHTML]`: la plantilla pinta cada
10
+ * trozo con interpolación. Solo se resaltan los nombres de `mentions` del mensaje; un `@` escrito a
11
+ * mano que no corresponde a una mención queda como texto.
12
+ */
13
+ export declare function splitMentions(body: string, mentionNames: readonly string[]): MessageSegment[];
14
+ /**
15
+ * La mención que se está escribiendo justo antes del cursor: `@` al inicio o después de un
16
+ * espacio, seguido de lo que va del nombre (sin espacios). `null` si no hay ninguna.
17
+ */
18
+ export declare function mentionQueryAt(text: string, caret: number): {
19
+ start: number;
20
+ query: string;
21
+ } | null;
@@ -0,0 +1,5 @@
1
+ /**
2
+ * uuid v4 para `clientMessageId`. `crypto.randomUUID` solo existe en contextos seguros (https o
3
+ * localhost); en otro caso se arma con `crypto.getRandomValues`, que está en todos los navegadores.
4
+ */
5
+ export declare function createClientMessageId(): string;
package/package.json CHANGED
@@ -1,6 +1,30 @@
1
1
  {
2
2
  "name": "@sfinges/sf-conversation",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
3
+ "version": "0.1.0",
4
+ "publishConfig": {
5
+ "access": "public"
6
+ },
7
+ "peerDependencies": {
8
+ "@angular/common": "^19.2.0",
9
+ "@angular/core": "^19.2.0",
10
+ "@microsoft/signalr": "^8.0.0 || ^9.0.0 || ^10.0.0",
11
+ "primeng": "^19.1.4",
12
+ "primeicons": "^7.0.0",
13
+ "rxjs": "^7.8.0"
14
+ },
15
+ "dependencies": {
16
+ "tslib": "^2.3.0"
17
+ },
18
+ "sideEffects": false,
19
+ "module": "fesm2022/sfinges-sf-conversation.mjs",
20
+ "typings": "index.d.ts",
21
+ "exports": {
22
+ "./package.json": {
23
+ "default": "./package.json"
24
+ },
25
+ ".": {
26
+ "types": "./index.d.ts",
27
+ "default": "./fesm2022/sfinges-sf-conversation.mjs"
28
+ }
29
+ }
6
30
  }
@@ -0,0 +1,16 @@
1
+ /**
2
+ * Superficie pública de sf-conversation. Los fronts importan solo de aquí.
3
+ *
4
+ * La librería no conoce al front que la usa: el contexto entra por inputs, los datos por
5
+ * `CONVERSATION_SERVICE`, lo nuevo en vivo por `CONVERSATION_REALTIME` (opcional) y los nombres
6
+ * por `CONVERSATION_DIRECTORY`.
7
+ */
8
+ export * from './lib/models/conversation.model';
9
+ export * from './lib/gateways/conversation.port';
10
+ export * from './lib/gateways/conversation-realtime.port';
11
+ export * from './lib/gateways/conversation-directory.port';
12
+ export * from './lib/gateways/conversation-access-token.port';
13
+ export * from './lib/gateways/conversation-http.service';
14
+ export * from './lib/gateways/conversation-signalr.service';
15
+ export * from './lib/components/conversation-panel/conversation-panel.component';
16
+ export * from './lib/components/conversation-button/conversation-button.component';