botframework-webchat-core 4.18.2 → 4.19.0

package/src/types/internal/GlobalScopeClock.ts

@@ -1,24 +1,24 @@
 export type GlobalScopeClock = {
   // eslint-disable-next-line no-restricted-globals
-  cancelAnimationFrame?: typeof cancelAnimationFrame;
+  cancelAnimationFrame?: typeof cancelAnimationFrame | undefined;
   // eslint-disable-next-line no-restricted-globals
-  cancelIdleCallback?: typeof cancelIdleCallback;
+  cancelIdleCallback?: typeof cancelIdleCallback | undefined;
   // eslint-disable-next-line no-restricted-globals
-  clearImmediate?: typeof clearImmediate;
+  clearImmediate?: typeof clearImmediate | undefined;
   // eslint-disable-next-line no-restricted-globals
-  clearInterval: typeof clearInterval;
+  clearInterval?: typeof clearInterval | undefined;
   // eslint-disable-next-line no-restricted-globals
-  clearTimeout: typeof clearTimeout;
+  clearTimeout?: typeof clearTimeout | undefined;
   // eslint-disable-next-line no-restricted-globals
   Date: typeof Date;
   // eslint-disable-next-line no-restricted-globals
-  requestAnimationFrame?: typeof requestAnimationFrame;
+  requestAnimationFrame?: typeof requestAnimationFrame | undefined;
   // eslint-disable-next-line no-restricted-globals
-  requestIdleCallback?: typeof requestIdleCallback;
+  requestIdleCallback?: typeof requestIdleCallback | undefined;
   // eslint-disable-next-line no-restricted-globals
-  setImmediate?: typeof setImmediate;
+  setImmediate?: typeof setImmediate | undefined;
   // eslint-disable-next-line no-restricted-globals
-  setInterval: typeof setInterval;
+  setInterval?: typeof setInterval | undefined;
   // eslint-disable-next-line no-restricted-globals
-  setTimeout: typeof setTimeout;
+  setTimeout?: typeof setTimeout | undefined;
 };

package/src/types/internal/ReduxState.ts

@@ -1,4 +1,5 @@
 import type sendBoxAttachments from '../../reducers/sendBoxAttachments';
+import type { State } from '../../reducers/activities/sort/types';
 import type { WebChatActivity } from '../WebChatActivity';
 import type { Notification } from './Notification';
 
@@ -7,6 +8,7 @@ type ReduxState = {
   activities: WebChatActivity[];
   clockSkewAdjustment: number;
   dictateState: string;
+  groupedActivities: State;
   language: string;
   notifications: { [key: string]: Notification };
   sendBoxAttachments: ReturnType<typeof sendBoxAttachments>;

package/src/types/internal/WebChatOutgoingActivity.ts

@@ -8,7 +8,7 @@ type OutgoingEventActivityEssence = {
 };
 
 type OutgoingMessageActivityEssence = {
-  attachments?: {}[];
+  attachments?: Record<any, unknown>[];
   channelData: {
     attachmentSizes?: number[];
     messageBack?: { displayText: string };

package/src/utils/dateToLocaleISOString.chatham.spec.js

@@ -1,12 +1,11 @@
 /**
- * @jest-environment ../../../__tests__/setup/jestNodeEnvironmentWithTimezone.js
+ * @jest-environment ../../../__tests__/unit.setup/JestNodeEnvironmentWithTimeZone.js
  * @timezone Pacific/Chatham
  */
 
 import dateToLocaleISOString from './dateToLocaleISOString';
 
 test('formatting a time in Chatham Islands timezone', () => {
-  // eslint-disable-next-line no-magic-numbers
   const date = new Date(Date.UTC(2000, 0, 1, 0, 12, 34, 567));
   const actual = dateToLocaleISOString(date);
 

package/src/utils/dateToLocaleISOString.japan.spec.js

@@ -1,12 +1,11 @@
 /**
- * @jest-environment ../../../__tests__/setup/jestNodeEnvironmentWithTimezone.js
+ * @jest-environment ../../../__tests__/unit.setup/JestNodeEnvironmentWithTimeZone.js
  * @timezone Asia/Tokyo
  */
 
 import dateToLocaleISOString from './dateToLocaleISOString';
 
 test('formatting a time in Japan timezone', () => {
-  // eslint-disable-next-line no-magic-numbers
   const date = new Date(Date.UTC(2000, 0, 1, 0, 12, 34, 567));
   const actual = dateToLocaleISOString(date);
 

package/src/utils/dateToLocaleISOString.newfoundland.spec.js

@@ -1,12 +1,11 @@
 /**
- * @jest-environment ../../../__tests__/setup/jestNodeEnvironmentWithTimezone.js
+ * @jest-environment ../../../__tests__/unit.setup/JestNodeEnvironmentWithTimeZone.js
  * @timezone America/St_Johns
  */
 
 import dateToLocaleISOString from './dateToLocaleISOString';
 
 test('formatting a time in Cananda, Newfoundland timezone', () => {
-  // eslint-disable-next-line no-magic-numbers
   const date = new Date(Date.UTC(2000, 0, 1, 0, 12, 34, 567));
   const actual = dateToLocaleISOString(date);
 

package/src/utils/dateToLocaleISOString.pacific.spec.js

@@ -1,12 +1,11 @@
 /**
- * @jest-environment ../../../__tests__/setup/jestNodeEnvironmentWithTimezone.js
+ * @jest-environment ../../../__tests__/unit.setup/JestNodeEnvironmentWithTimeZone.js
  * @timezone America/Los_Angeles
  */
 
 import dateToLocaleISOString from './dateToLocaleISOString';
 
 test('formatting a time in Pacific Standard Time timezone', () => {
-  // eslint-disable-next-line no-magic-numbers
   const date = new Date(Date.UTC(2000, 0, 1, 0, 12, 34, 567));
   const actual = dateToLocaleISOString(date);
 

package/src/utils/dateToLocaleISOString.utc.spec.js

@@ -1,12 +1,11 @@
 /**
- * @jest-environment ../../../__tests__/setup/jestNodeEnvironmentWithTimezone.js
+ * @jest-environment ../../../__tests__/unit.setup/JestNodeEnvironmentWithTimeZone.js
  * @timezone Etc/UTC
  */
 
 import dateToLocaleISOString from './dateToLocaleISOString';
 
 test('formatting a time in UTC timezone', () => {
-  // eslint-disable-next-line no-magic-numbers
   const date = new Date(Date.UTC(2000, 0, 1, 0, 12, 34, 567));
   const actual = dateToLocaleISOString(date);
 
@@ -14,7 +13,6 @@ test('formatting a time in UTC timezone', () => {
 });
 
 test('formatting a time in UTC timezone with zero milliseconds', () => {
-  // eslint-disable-next-line no-magic-numbers
   const date = new Date(Date.UTC(2000, 0, 1, 0, 12, 34, 0));
   const actual = dateToLocaleISOString(date);
 

package/src/utils/deleteKey.ts

@@ -1,4 +1,4 @@
-import isForbiddenPropertyName from './isForbiddenPropertyName';
+import { isForbiddenPropertyName } from '@msinternal/botframework-webchat-base/utils';
 
 export default function deleteKey<TMap, TKey extends keyof TMap>(map: TMap, ...keys: TKey[]): Omit<TMap, TKey> {
   if (!map) {

package/src/utils/getActivityLivestreamingMetadata.spec.ts

@@ -0,0 +1,297 @@
+import { type ArraySlice } from 'type-fest';
+
+import { type WebChatActivity } from '../types/WebChatActivity';
+import getActivityLivestreamingMetadata from './getActivityLivestreamingMetadata';
+
+function injectInto<T>(
+  where: 'channelData' | 'entities',
+  metadata: T,
+  activity: Partial<WebChatActivity>
+): WebChatActivity {
+  return {
+    ...(where === 'entities' ? { entities: [{ ...metadata, type: 'streaminfo' }] } : { channelData: metadata }),
+    ...activity
+  } as WebChatActivity;
+}
+
+describe.each([['channelData' as const], ['entities' as const]])('using %s', where => {
+  let inject: (...args: ArraySlice<Parameters<typeof injectInto>, 1>) => ReturnType<typeof injectInto>;
+
+  beforeEach(() => {
+    inject = injectInto.bind(undefined, where);
+  });
+
+  describe.each([['with "streamId"' as const], ['without "streamId"' as const]])('activity %s', variant => {
+    describe('activity with "streamType" of "streaming"', () => {
+      let activity: WebChatActivity;
+
+      beforeEach(() => {
+        activity = inject(
+          {
+            ...(variant === 'with "streamId"' ? { streamId: 'a-00001' } : {}),
+            streamSequence: 1,
+            streamType: 'streaming'
+          },
+          {
+            id: 'a-00002',
+            text: 'Hello, World!',
+            type: 'typing'
+          }
+        );
+      });
+
+      test('should return type of "interim activity"', () =>
+        expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('type', 'interim activity'));
+      test('should return sequence number', () =>
+        expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sequenceNumber', 1));
+
+      if (variant === 'with "streamId"') {
+        test('should return session ID with value from "channelData.streamId"', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sessionId', 'a-00001'));
+      } else {
+        test('should return session ID with value of "activity.id"', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sessionId', 'a-00002'));
+      }
+    });
+
+    describe('activity with "streamType" of "informative message"', () => {
+      let activity: WebChatActivity;
+
+      beforeEach(() => {
+        activity = inject(
+          {
+            ...(variant === 'with "streamId"' ? { streamId: 'a-00001' } : {}),
+            streamSequence: 1,
+            streamType: 'informative'
+          },
+          {
+            id: 'a-00002',
+            text: 'Hello, World!',
+            type: 'typing'
+          }
+        );
+      });
+
+      test('should return type of "informative message"', () =>
+        expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('type', 'informative message'));
+      test('should return sequence number', () =>
+        expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sequenceNumber', 1));
+
+      if (variant === 'with "streamId"') {
+        test('should return session ID with value from "channelData.streamId"', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sessionId', 'a-00001'));
+      } else {
+        test('should return session ID with value of "activity.id"', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sessionId', 'a-00002'));
+      }
+    });
+
+    describe('activity with "streamType" of "final"', () => {
+      let activity: WebChatActivity;
+
+      beforeEach(() => {
+        activity = inject(
+          {
+            ...(variant === 'with "streamId"' ? { streamId: 'a-00001' } : {}),
+            streamType: 'final'
+          },
+          {
+            id: 'a-00002',
+            text: 'Hello, World!',
+            type: 'message'
+          }
+        );
+      });
+
+      if (variant === 'with "streamId"') {
+        test('should return type of "final activity"', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('type', 'final activity'));
+        test('should return sequence number of Infinity', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sequenceNumber', Infinity));
+        test('should return session ID', () =>
+          expect(getActivityLivestreamingMetadata(activity)).toHaveProperty('sessionId', 'a-00001'));
+      } else {
+        // Final activity must have "streamId". Final activity without "streamId" is not a valid livestream activity.
+        test('should return undefined', () => expect(getActivityLivestreamingMetadata(activity)).toBeUndefined());
+      }
+    });
+  });
+
+  test('activity with "streamType" of "streaming" without critical fields should return undefined', () =>
+    expect(
+      getActivityLivestreamingMetadata(
+        inject(
+          {
+            streamType: 'streaming'
+          },
+          {
+            type: 'typing'
+          }
+        )
+      )
+    ).toBeUndefined());
+
+  test.each([
+    ['integer', 1, true],
+    ['zero', 0, false],
+    ['decimal', 1.234, false]
+  ])('activity with %s "streamSequence" should return undefined', (_, streamSequence, isValid) => {
+    const activity = inject(
+      {
+        streamId: 'a-00001',
+        streamSequence,
+        streamType: 'streaming'
+      },
+      {
+        id: 'a-00002',
+        text: '',
+        type: 'typing'
+      }
+    );
+
+    if (isValid) {
+      expect(getActivityLivestreamingMetadata(activity)).toBeTruthy();
+    } else {
+      expect(getActivityLivestreamingMetadata(activity)).toBeUndefined();
+    }
+  });
+
+  describe('"typing" activity with "streamType" of "final"', () => {
+    test('should return undefined if "text" field is defined', () =>
+      expect(
+        getActivityLivestreamingMetadata(
+          inject(
+            {
+              streamId: 'a-00001',
+              streamType: 'final'
+            },
+            {
+              id: 'a-00002',
+              text: 'Final "typing" activity, must not have "text".',
+              type: 'typing'
+            }
+          )
+        )
+      ).toBeUndefined());
+
+    test('should return truthy if "text" field is not defined', () =>
+      expect(
+        getActivityLivestreamingMetadata(
+          inject(
+            {
+              streamId: 'a-00001',
+              streamType: 'final'
+            },
+            {
+              id: 'a-00002',
+              // Final activity can be "typing" if it does not have "text".
+              type: 'typing'
+            }
+          )
+        )
+      ).toHaveProperty('type', 'final activity'));
+  });
+
+  test('activity with "streamType" of "streaming" without "content" should return type of "contentless"', () =>
+    expect(
+      getActivityLivestreamingMetadata(
+        inject(
+          {
+            streamSequence: 1,
+            streamType: 'streaming'
+          },
+          {
+            id: 'a-00001',
+            type: 'typing'
+          }
+        )
+      )
+    ).toHaveProperty('type', 'contentless'));
+});
+
+test('invalid activity should return undefined', () =>
+  expect(getActivityLivestreamingMetadata('invalid' as any)).toBeUndefined());
+
+test('should prefer channelData over entities', () =>
+  expect(
+    getActivityLivestreamingMetadata({
+      channelData: {
+        streamId: 'a-channelData',
+        streamSequence: 2,
+        streamType: 'streaming'
+      },
+      entities: [
+        {
+          streamId: 'a-entities',
+          streamSequence: 2,
+          streamType: 'streaming',
+          type: 'streaminfo'
+        }
+      ],
+      id: 'a-00002',
+      type: 'typing'
+    } as any)
+  ).toHaveProperty('sessionId', 'a-channelData'));
+
+test('should prefer first entity', () =>
+  expect(
+    getActivityLivestreamingMetadata({
+      entities: [
+        {
+          streamId: 'a-first',
+          streamSequence: 2,
+          streamType: 'streaming',
+          type: 'streaminfo'
+        },
+        {
+          streamId: 'a-second',
+          streamSequence: 2,
+          streamType: 'streaming',
+          type: 'streaminfo'
+        }
+      ],
+      id: 'a-00002',
+      type: 'typing'
+    } as any)
+  ).toHaveProperty('sessionId', 'a-first'));
+
+test('channelData-based livestreaming metadata should be harmony with other entities', () =>
+  expect(
+    getActivityLivestreamingMetadata({
+      channelData: {
+        streamSequence: 1,
+        streamType: 'streaming'
+      },
+      entities: [
+        {
+          '@context': 'https://schema.org',
+          '@id': '',
+          '@type': 'Message',
+          type: 'https://schema.org/Message'
+        }
+      ],
+      id: 'a-00001',
+      type: 'typing'
+    } as any)
+  ).toHaveProperty('sequenceNumber', 1));
+
+test('entity-based livestreaming metadata should be harmony with other entities', () =>
+  expect(
+    getActivityLivestreamingMetadata({
+      entities: [
+        {
+          '@context': 'https://schema.org',
+          '@id': '',
+          '@type': 'Message',
+          type: 'https://schema.org/Message'
+        },
+        {
+          streamSequence: 1,
+          streamType: 'streaming',
+          type: 'streaminfo'
+        }
+      ],
+      id: 'a-00001',
+      type: 'typing'
+    } as any)
+  ).toHaveProperty('sequenceNumber', 1));

package/src/utils/getActivityLivestreamingMetadata.ts

@@ -0,0 +1,197 @@
+import {
+  any,
+  array,
+  check,
+  findItem,
+  integer,
+  is,
+  literal,
+  minValue,
+  nonEmpty,
+  number,
+  object,
+  optional,
+  pipe,
+  safeParse,
+  string,
+  transform,
+  undefinedable,
+  union,
+  type ErrorMessage,
+  type ObjectEntries,
+  type ObjectIssue,
+  type ObjectSchema
+} from 'valibot';
+
+import { type WebChatActivity } from '../types/WebChatActivity';
+import getOrgSchemaMessage from './getOrgSchemaMessage';
+
+const EMPTY_ARRAY = Object.freeze([]);
+
+const streamSequenceSchema = pipe(number(), integer(), minValue(1));
+
+function eitherChannelDataOrEntities<
+  TActivityEntries extends ObjectEntries,
+  TActivityMessage extends ErrorMessage<ObjectIssue> | undefined,
+  TMetadataEntries extends ObjectEntries,
+  TMetadataMessage extends ErrorMessage<ObjectIssue> | undefined
+>(
+  activitySchema: ObjectSchema<TActivityEntries, TActivityMessage>,
+  metadataSchema: ObjectSchema<TMetadataEntries, TMetadataMessage>
+) {
+  const metadataInEntitiesSchema = object({
+    ...metadataSchema.entries,
+    type: literal('streaminfo')
+  });
+
+  return union([
+    object({
+      ...activitySchema.entries,
+      channelData: metadataSchema
+    }),
+    pipe(
+      object({
+        ...activitySchema.entries,
+        // We use `findItem`/`filterItem` than `variant`/`someItem` because the output of the latter is an union type.
+        // Consider `{ type: string } | { streamId: string; type: 'streaminfo' }`, it turns into `{ type: string }` immediately.
+
+        // TODO: [P2] valibot@1.1.0 did not infer output type for `filterItem()`, only infer for `findItem()`.
+        //       Bump valibot@latest and see if they solved the issue.
+        entities: pipe(
+          array(any()),
+          findItem(value => is(metadataInEntitiesSchema, value)),
+          check(value => !!value)
+        )
+      }),
+      // This is quite hacky, we should not mutate the parse output to ease metadata extractions.
+      transform(({ entities, ...value }) => ({ ...value, streamInfoEntity: entities! }))
+    )
+  ]);
+}
+
+const livestreamingActivitySchema = union([
+  // Interim.
+  eitherChannelDataOrEntities(
+    object({
+      attachments: optional(array(any()), EMPTY_ARRAY),
+      id: string(),
+      // "text" is optional. If not set or empty, it presents a contentless activity.
+      text: optional(undefinedable(string())),
+      type: literal('typing')
+    }),
+    object({
+      // "streamId" is optional for the very first activity in the session.
+      streamId: optional(undefinedable(string())),
+      streamSequence: streamSequenceSchema,
+      streamType: literal('streaming')
+    })
+  ),
+  // Informative message.
+  eitherChannelDataOrEntities(
+    object({
+      attachments: optional(array(any()), EMPTY_ARRAY),
+      id: string(),
+      // Informative may not have "text", but should have abstract instead (checked later)
+      text: optional(undefinedable(string())),
+      type: literal('typing'),
+      entities: optional(array(any()), EMPTY_ARRAY)
+    }),
+    object({
+      // "streamId" is optional for the very first activity in the session.
+      streamId: optional(undefinedable(string())),
+      streamSequence: streamSequenceSchema,
+      streamType: literal('informative')
+    })
+  ),
+  // Conclude with a message.
+  eitherChannelDataOrEntities(
+    object({
+      attachments: optional(array(any()), EMPTY_ARRAY),
+      id: string(),
+      // If "text" is empty, it represents "regretting" the livestream.
+      text: optional(undefinedable(string())),
+      type: literal('message')
+    }),
+    object({
+      // "streamId" is required for the final activity in the session.
+      // The final activity must not be the sole activity in the session.
+      streamId: pipe(string(), nonEmpty()),
+      streamType: literal('final')
+    })
+  ),
+  // Conclude without a message.
+  eitherChannelDataOrEntities(
+    object({
+      attachments: optional(array(any()), EMPTY_ARRAY),
+      id: string(),
+      // If "text" is not set or empty, it represents "regretting" the livestream.
+      text: optional(undefinedable(literal(''))),
+      type: literal('typing')
+    }),
+    object({
+      // "streamId" is required for the final activity in the session.
+      // The final activity must not be the sole activity in the session.
+      streamId: pipe(string(), nonEmpty()),
+      streamType: literal('final')
+    })
+  )
+]);
+
+/**
+ * Gets the livestreaming metadata of the activity, or `undefined` if the activity is not participating in a livestreaming session.
+ *
+ * - `sessionId` - ID of the livestreaming session
+ * - `sequenceNumber` - sequence number of the activity
+ * - `type`
+ *   - `"contentless"` - ongoing but no content, should show indicator
+ *   - `"interim activity"` - current response, could be partial-from-start, or complete response.
+ *     More activities are expected. Future interim activities always replace past interim activities, enable erasing or backtracking response.
+ *   - `"informative message"` - optional side-channel informative message describing the current response, e.g. "Searching your document library".
+ *     Always replace past informative messages. May interleave with interim activities.
+ *   - `"final activity"` - complete-and-final response, always replace past interim activities and remove all informative messages.
+ *     This activity indicates end of the session, all future activities must be ignored.
+ *   - `undefined` - not part of a livestream session or the activity is not valid
+ *
+ * @returns {object} Livestreaming metadata of the activity, or `undefined` if the activity is not participating in a livestreaming session.
+ */
+export default function getActivityLivestreamingMetadata(activity: WebChatActivity):
+  | Readonly<{
+      sessionId: string;
+      sequenceNumber: number;
+      type: 'contentless' | 'final activity' | 'informative message' | 'interim activity';
+    }>
+  | undefined {
+  const result = safeParse(livestreamingActivitySchema, activity);
+
+  if (result.success) {
+    const { output } = result;
+    const livestreamMetadata = 'channelData' in output ? output.channelData : output.streamInfoEntity;
+
+    // If the activity is the first in the session, session ID should be the activity ID.
+    const sessionId = livestreamMetadata.streamId || output.id;
+
+    return Object.freeze(
+      livestreamMetadata.streamType === 'final'
+        ? {
+            sequenceNumber: Infinity,
+            sessionId,
+            type: 'final activity'
+          }
+        : {
+            sequenceNumber: livestreamMetadata.streamSequence,
+            sessionId,
+            type: !(
+              output.text ||
+              output.attachments?.length ||
+              ('entities' in output && getOrgSchemaMessage(output.entities)?.abstract[0])
+            )
+              ? 'contentless'
+              : livestreamMetadata.streamType === 'informative'
+                ? 'informative message'
+                : 'interim activity'
+          }
+    );
+  }
+
+  return undefined;
+}

package/src/utils/getOrgSchemaMessage.spec.ts

@@ -1,3 +1,6 @@
+import { expect, test } from '@jest/globals';
+import { parse } from 'valibot';
+import { orgSchemaCreativeWorkSchema } from '@msinternal/botframework-webchat-core-json-ld';
 import getOrgSchemaMessage from './getOrgSchemaMessage';
 
 test('should get message', () => {
@@ -8,7 +11,7 @@ test('should get message', () => {
     type: 'https://schema.org/Message'
   };
 
-  expect(getOrgSchemaMessage([expected])).toEqual(expected);
+  expect(getOrgSchemaMessage([expected])).toEqual(parse(orgSchemaCreativeWorkSchema, expected));
 });
 
 test('should not get message without @id of empty string', () => {