feat: allow for custom non-message data storage in MessageComposer

MartinCupela · MartinCupela · commit d87590e481a9 · 2025-04-29T18:04:44.000+02:00
diff --git a/src/custom_types.ts b/src/custom_types.ts
@@ -9,3 +9,4 @@ export interface CustomPollData {}
 export interface CustomReactionData {}
 export interface CustomUserData {}
 export interface CustomThreadData {}
+export interface CustomMessageComposerData {}
diff --git a/src/index.ts b/src/index.ts
@@ -35,6 +35,7 @@ export type {
   CustomCommandData,
   CustomEventData,
   CustomMemberData,
+  CustomMessageComposerData,
   CustomMessageData,
   CustomPollOptionData,
   CustomPollData,
diff --git a/src/messageComposer/CustomDataManager.ts b/src/messageComposer/CustomDataManager.ts
@@ -1,9 +1,15 @@
-import type { CustomMessageData, DraftMessage, LocalMessage } from '..';
 import { StateStore } from '..';
+import type {
+  CustomMessageComposerData,
+  CustomMessageData,
+  DraftMessage,
+  LocalMessage,
+} from '..';
 import type { MessageComposer } from './messageComposer';
 
 export type CustomDataManagerState = {
-  data: CustomMessageData;
+  message: CustomMessageData;
+  custom: CustomMessageComposerData;
 };
 
 export type CustomDataManagerOptions = {
@@ -12,8 +18,9 @@ export type CustomDataManagerOptions = {
 };
 
 const initState = (options: CustomDataManagerOptions): CustomDataManagerState => {
-  if (!options) return { data: {} as CustomMessageData };
-  return { data: {} as CustomMessageData };
+  if (!options)
+    return { message: {} as CustomMessageData, custom: {} as CustomMessageComposerData };
+  return { message: {} as CustomMessageData, custom: {} as CustomMessageComposerData };
 };
 
 export class CustomDataManager {
@@ -25,23 +32,36 @@ export class CustomDataManager {
     this.state = new StateStore<CustomDataManagerState>(initState({ composer, message }));
   }
 
-  get data() {
-    return this.state.getLatestValue().data;
+  get customMessageData() {
+    return this.state.getLatestValue().message;
   }
 
-  isDataEqual = (
+  get customComposerData() {
+    return this.state.getLatestValue().custom;
+  }
+
+  isMessageDataEqual = (
     nextState: CustomDataManagerState,
     previousState?: CustomDataManagerState,
-  ) => JSON.stringify(nextState.data) === JSON.stringify(previousState?.data);
+  ) => JSON.stringify(nextState.message) === JSON.stringify(previousState?.message);
 
   initState = ({ message }: { message?: DraftMessage | LocalMessage } = {}) => {
     this.state.next(initState({ composer: this.composer, message }));
   };
 
-  setData(data: Partial<CustomMessageData>) {
+  setMessageData(data: Partial<CustomMessageData>) {
+    this.state.partialNext({
+      message: {
+        ...this.state.getLatestValue().message,
+        ...data,
+      },
+    });
+  }
+
+  setCustomData(data: Partial<CustomMessageComposerData>) {
     this.state.partialNext({
-      data: {
-        ...this.state.getLatestValue().data,
+      custom: {
+        ...this.state.getLatestValue().custom,
         ...data,
       },
     });
diff --git a/src/messageComposer/index.ts b/src/messageComposer/index.ts
@@ -1,6 +1,7 @@
 export * from './attachmentIdentity';
 export * from './attachmentManager';
 export * from './configuration';
+export * from './CustomDataManager';
 export * from './fileUtils';
 export * from './linkPreviewsManager';
 export * from './messageComposer';
diff --git a/src/messageComposer/messageComposer.ts b/src/messageComposer/messageComposer.ts
@@ -511,7 +511,7 @@ export class MessageComposer {
     this.customDataManager.state.subscribe((nextValue, previousValue) => {
       if (
         typeof previousValue !== 'undefined' &&
-        !this.customDataManager.isDataEqual(nextValue, previousValue)
+        !this.customDataManager.isMessageDataEqual(nextValue, previousValue)
       ) {
         this.logStateUpdateTimestamp();
       }
diff --git a/src/messageComposer/middleware/messageComposer/customData.ts b/src/messageComposer/middleware/messageComposer/customData.ts
@@ -11,7 +11,7 @@ export const createCustomDataCompositionMiddleware = (composer: MessageComposer)
     input,
     nextHandler,
   }: MiddlewareHandlerParams<MessageComposerMiddlewareValueState>) => {
-    const data = composer.customDataManager.data;
+    const data = composer.customDataManager.customMessageData;
     if (!data) return nextHandler(input);
 
     return nextHandler({
@@ -39,7 +39,7 @@ export const createDraftCustomDataCompositionMiddleware = (
     input,
     nextHandler,
   }: MiddlewareHandlerParams<MessageDraftComposerMiddlewareValueState>) => {
-    const data = composer.customDataManager.data;
+    const data = composer.customDataManager.customMessageData;
     if (!data) return nextHandler(input);
 
     return nextHandler({
diff --git a/test/unit/MessageComposer/CustomDataManager.test.ts b/test/unit/MessageComposer/CustomDataManager.test.ts
@@ -33,7 +33,7 @@ describe('CustomDataManager', () => {
 
   describe('constructor', () => {
     it('should initialize with empty data', () => {
-      expect(customDataManager.data).toEqual({});
+      expect(customDataManager.customMessageData).toEqual({});
     });
 
     it('should initialize with message data if provided', () => {
@@ -56,19 +56,19 @@ describe('CustomDataManager', () => {
         message,
       });
 
-      expect(managerWithMessage.data).toEqual({});
+      expect(managerWithMessage.customMessageData).toEqual({});
     });
   });
 
   describe('initState', () => {
     it('should reset state to empty data', () => {
       // Set some data first
-      customDataManager.setData({ test: 'value' });
-      expect(customDataManager.data).toEqual({ test: 'value' });
+      customDataManager.setMessageData({ test: 'value' });
+      expect(customDataManager.customMessageData).toEqual({ test: 'value' });
 
       // Reset state
       customDataManager.initState();
-      expect(customDataManager.data).toEqual({});
+      expect(customDataManager.customMessageData).toEqual({});
     });
 
     it('should reset state with message data if provided', () => {
@@ -87,42 +87,45 @@ describe('CustomDataManager', () => {
       };
 
       customDataManager.initState({ message });
-      expect(customDataManager.data).toEqual({});
+      expect(customDataManager.customMessageData).toEqual({});
     });
   });
 
   describe('setCustomData', () => {
     it('should update data with new values', () => {
-      customDataManager.setData({ field1: 'value1' });
-      expect(customDataManager.data).toEqual({ field1: 'value1' });
+      customDataManager.setMessageData({ field1: 'value1' });
+      expect(customDataManager.customMessageData).toEqual({ field1: 'value1' });
 
-      customDataManager.setData({ field2: 'value2' });
-      expect(customDataManager.data).toEqual({ field1: 'value1', field2: 'value2' });
+      customDataManager.setMessageData({ field2: 'value2' });
+      expect(customDataManager.customMessageData).toEqual({
+        field1: 'value1',
+        field2: 'value2',
+      });
     });
 
     it('should override existing values', () => {
-      customDataManager.setData({ field1: 'value1' });
-      customDataManager.setData({ field1: 'new-value' });
-      expect(customDataManager.data).toEqual({ field1: 'new-value' });
+      customDataManager.setMessageData({ field1: 'value1' });
+      customDataManager.setMessageData({ field1: 'new-value' });
+      expect(customDataManager.customMessageData).toEqual({ field1: 'new-value' });
     });
   });
 
   describe('isDataEqual', () => {
     it('should return true for equal data', () => {
-      const state1 = { data: { field1: 'value1' } };
-      const state2 = { data: { field1: 'value1' } };
-      expect(customDataManager.isDataEqual(state1, state2)).toBe(true);
+      const state1 = { message: { field1: 'value1' } };
+      const state2 = { message: { field1: 'value1' } };
+      expect(customDataManager.isMessageDataEqual(state1, state2)).toBe(true);
     });
 
     it('should return false for different data', () => {
-      const state1 = { data: { field1: 'value1' } };
-      const state2 = { data: { field1: 'value2' } };
-      expect(customDataManager.isDataEqual(state1, state2)).toBe(false);
+      const state1 = { message: { field1: 'value1' } };
+      const state2 = { message: { field1: 'value2' } };
+      expect(customDataManager.isMessageDataEqual(state1, state2)).toBe(false);
     });
 
     it('should handle undefined previous state', () => {
-      const state1 = { data: { field1: 'value1' } };
-      expect(customDataManager.isDataEqual(state1, undefined)).toBe(false);
+      const state1 = { message: { field1: 'value1' } };
+      expect(customDataManager.isMessageDataEqual(state1, undefined)).toBe(false);
     });
   });
 });
diff --git a/test/unit/MessageComposer/middleware/messageComposer/customData.test.ts b/test/unit/MessageComposer/middleware/messageComposer/customData.test.ts
@@ -29,7 +29,7 @@ describe('Custom Data Middleware', () => {
   describe('createCustomDataCompositionMiddleware', () => {
     it('should initialize with custom data', async () => {
       const data = { key: 'value' };
-      composer.customDataManager.setData(data);
+      composer.customDataManager.setMessageData(data);
       const middleware = createCustomDataCompositionMiddleware(composer);
       const state: MessageComposerMiddlewareValueState = {
         message: { id: '1', type: 'regular' },
@@ -91,7 +91,7 @@ describe('Custom Data Middleware', () => {
   describe('createDraftCustomDataCompositionMiddleware', () => {
     it('should initialize with custom data', async () => {
       const data = { key: 'value' };
-      composer.customDataManager.setData(data);
+      composer.customDataManager.setMessageData(data);
       const middleware = createDraftCustomDataCompositionMiddleware(composer);
       const state: MessageDraftComposerMiddlewareValueState = {
         draft: {

Original file line number	Diff line number	Diff line change
`@@ -511,7 +511,7 @@ export class MessageComposer {`
`511`	`511`	`this.customDataManager.state.subscribe((nextValue, previousValue) => {`
`512`	`512`	`if (`
`513`	`513`	`typeof previousValue !== 'undefined' &&`
`514`		`- !this.customDataManager.isDataEqual(nextValue, previousValue)`
	`514`	`+ !this.customDataManager.isMessageDataEqual(nextValue, previousValue)`
`515`	`515`	`) {`
`516`	`516`	`this.logStateUpdateTimestamp();`
`517`	`517`	`}`