botframework-webchat-core 4.18.1 → 4.19.0

package/src/reducers/activities/sort/property/ReceivedAt.ts

@@ -0,0 +1,45 @@
+import { number, object, parse, safeParse, type InferOutput } from 'valibot';
+import type { Activity } from '../types';
+
+const ReceivedAtSchema = number();
+
+type ReceivedAt = InferOutput<typeof ReceivedAtSchema>;
+
+const ActivityWithReceivedAtSchema = object({
+  channelData: object({
+    'webchat:internal:received-at': ReceivedAtSchema
+  })
+});
+
+function getReceivedAtFromActivity(activity: Readonly<Activity>): ReceivedAt {
+  return parse(ActivityWithReceivedAtSchema, activity).channelData['webchat:internal:received-at'];
+}
+
+function queryReceivedAtFromActivity(activity: Readonly<Activity>): ReceivedAt | undefined {
+  const result = safeParse(ActivityWithReceivedAtSchema, activity);
+
+  return result.success ? result.output.channelData['webchat:internal:received-at'] : undefined;
+}
+
+function setReceivedAtInActivity(activity: Readonly<Activity>, value: ReceivedAt | undefined): Activity {
+  const nextChannelData = { ...activity.channelData };
+
+  if (typeof value === 'undefined') {
+    delete (nextChannelData as any)['webchat:internal:received-at'];
+  } else {
+    nextChannelData['webchat:internal:received-at'] = parse(ReceivedAtSchema, value);
+  }
+
+  return {
+    ...activity,
+    channelData: nextChannelData as any
+  };
+}
+
+export {
+  getReceivedAtFromActivity,
+  queryReceivedAtFromActivity,
+  ReceivedAtSchema,
+  setReceivedAtInActivity,
+  type ReceivedAt
+};

package/src/reducers/activities/sort/property/SendStatus.ts

@@ -0,0 +1,51 @@
+import { object, parse, picklist, safeParse, type InferOutput } from 'valibot';
+import type { Activity } from '../types';
+
+const SendStatusSchema = picklist(
+  ['sending', 'send failed', 'sent'],
+  'Send status must be either "sending", "send failed" or "sent"'
+);
+
+type SendStatus = InferOutput<typeof SendStatusSchema>;
+
+const OutgoingActivityWithSendStatusSchema = object({
+  channelData: object(
+    {
+      'webchat:send-status': SendStatusSchema
+    },
+    '"channelData" must be an object'
+  )
+});
+
+function getSendStatusFromOutgoingActivity(activity: Activity): SendStatus {
+  return parse(OutgoingActivityWithSendStatusSchema, activity).channelData['webchat:send-status'];
+}
+
+function querySendStatusFromOutgoingActivity(activity: Activity): SendStatus | undefined {
+  const result = safeParse(OutgoingActivityWithSendStatusSchema, activity);
+
+  return result.success ? result.output.channelData['webchat:send-status'] : undefined;
+}
+
+function setSendStatusInOutgoingActivity(activity: Activity, value: SendStatus | undefined): Activity {
+  const nextChannelData = { ...activity.channelData };
+
+  if (typeof value === 'undefined') {
+    delete (nextChannelData as any)['webchat:send-status'];
+  } else {
+    nextChannelData['webchat:send-status'] = value;
+  }
+
+  return {
+    ...activity,
+    channelData: nextChannelData as any
+  };
+}
+
+export {
+  getSendStatusFromOutgoingActivity,
+  querySendStatusFromOutgoingActivity,
+  SendStatusSchema,
+  setSendStatusInOutgoingActivity,
+  type SendStatus
+};

package/src/reducers/activities/sort/queryLocalIdByActivityId.ts

@@ -0,0 +1,6 @@
+import type { LocalId } from './property/LocalId';
+import type { State } from './types';
+
+export default function queryLocalIdAByActivityId(state: State, activityId: string): LocalId | undefined {
+  return state.activityIdToLocalIdMap.get(activityId);
+}

package/src/reducers/activities/sort/queryLocalIdByClientActivityId.ts

@@ -0,0 +1,6 @@
+import type { LocalId } from './property/LocalId';
+import type { State } from './types';
+
+export default function queryLocalIdAByClientActivityId(state: State, clientActivityId: string): LocalId | undefined {
+  return state.clientActivityIdToLocalIdMap.get(clientActivityId);
+}

package/src/reducers/activities/sort/types.ts

@@ -0,0 +1,80 @@
+import type { Tagged } from 'type-fest';
+import type { WebChatActivity } from '../../../types/WebChatActivity';
+import type { LocalId } from './property/LocalId';
+
+type Activity = WebChatActivity;
+
+type HowToGroupingId = Tagged<string, 'how to grouping id'>;
+type LivestreamSessionId = Tagged<string, 'livestream session id'>;
+
+type HowToGroupingEntry = {
+  readonly howToGroupingId: HowToGroupingId;
+  readonly logicalTimestamp: number | undefined;
+  readonly type: 'how to grouping';
+};
+
+type LivestreamSessionEntry = {
+  readonly livestreamSessionId: LivestreamSessionId;
+  readonly logicalTimestamp: number | undefined;
+  readonly type: 'livestream session';
+};
+
+type ActivityEntry = {
+  readonly activityLocalId: LocalId;
+  readonly logicalTimestamp: number | undefined;
+  readonly type: 'activity';
+};
+
+type HowToGroupingMapPartEntry = (ActivityEntry | LivestreamSessionEntry) & {
+  readonly position: number | undefined;
+};
+type HowToGroupingMapEntry = {
+  readonly logicalTimestamp: number | undefined;
+  readonly partList: readonly HowToGroupingMapPartEntry[];
+};
+type HowToGroupingMap = ReadonlyMap<HowToGroupingId, HowToGroupingMapEntry>;
+
+type SortedChatHistoryEntry = ActivityEntry | LivestreamSessionEntry | HowToGroupingEntry;
+type SortedChatHistory = readonly SortedChatHistoryEntry[];
+
+type LivestreamSessionMapEntryActivityEntry = ActivityEntry & { readonly sequenceNumber: number };
+
+type LivestreamSessionMapEntry = {
+  readonly activities: readonly LivestreamSessionMapEntryActivityEntry[];
+  readonly finalized: boolean;
+  readonly logicalTimestamp: number | undefined;
+};
+type LivestreamSessionMap = ReadonlyMap<LivestreamSessionId, LivestreamSessionMapEntry>;
+
+type ActivityMapEntry = ActivityEntry & { readonly activity: Activity };
+type ActivityMap = ReadonlyMap<LocalId, ActivityMapEntry>;
+
+type State = {
+  readonly activityIdToLocalIdMap: Map<string, LocalId>;
+  readonly activityMap: ActivityMap;
+  readonly clientActivityIdToLocalIdMap: Map<string, LocalId>;
+  readonly howToGroupingMap: HowToGroupingMap;
+  readonly livestreamSessionMap: LivestreamSessionMap;
+  readonly sortedChatHistoryList: SortedChatHistory;
+  readonly sortedActivities: readonly Activity[];
+};
+
+export {
+  type Activity,
+  type ActivityEntry,
+  type ActivityMap,
+  type ActivityMapEntry,
+  type HowToGroupingEntry,
+  type HowToGroupingId,
+  type HowToGroupingMap,
+  type HowToGroupingMapEntry,
+  type HowToGroupingMapPartEntry,
+  type LivestreamSessionEntry,
+  type LivestreamSessionId,
+  type LivestreamSessionMap,
+  type LivestreamSessionMapEntry,
+  type LivestreamSessionMapEntryActivityEntry,
+  type SortedChatHistory,
+  type SortedChatHistoryEntry,
+  type State
+};

package/src/reducers/activities/sort/updateActivityChannelData.ts

@@ -0,0 +1,101 @@
+import { check, parse, pipe, string, type GenericSchema } from 'valibot';
+import { getLocalIdFromActivity, type LocalId } from './property/LocalId';
+import type { Activity, ActivityMapEntry, State } from './types';
+
+const channelDataNameSchema: GenericSchema<
+  Exclude<string, 'state' | 'streamId' | 'streamSequence' | 'streamType' | `webchat:${string}`>
+> = pipe(
+  string(),
+  check(
+    value =>
+      value !== 'state' &&
+      value !== 'streamId' &&
+      value !== 'streamSequence' &&
+      value !== 'streamType' &&
+      !value.startsWith('webchat:'),
+    'name must not be a reserved'
+  )
+);
+
+/**
+ * Updates activity channel data.
+ *
+ * Note: after channel data is updated, it will not update to a new position.
+ *       Do not use this function for updating channel data that would affect position, such as `streamSequence`.
+ *
+ * @param state
+ * @param activityLocalId
+ * @param name
+ * @param value
+ * @returns
+ */
+function updateActivityChannelDataInternalSkipNameCheck(
+  state: State,
+  activityLocalId: LocalId,
+  name: string,
+  value: unknown
+): State {
+  const activityEntry = state.activityMap.get(activityLocalId);
+
+  if (!activityEntry) {
+    throw new Error(`botframework-webchat: no activity found with internal ID ${activityLocalId}`);
+  }
+
+  // TODO: [P0] We will freeze activity in future.
+  const nextActivity: Activity = {
+    ...activityEntry.activity,
+    channelData: {
+      ...activityEntry.activity.channelData,
+      [name]: value
+    } as any
+  };
+
+  const nextActivityMap = new Map(state.activityMap).set(
+    activityLocalId,
+    Object.freeze({ ...activityEntry, activity: nextActivity } satisfies ActivityMapEntry)
+  );
+
+  const nextSortedActivities = Array.from(state.sortedActivities);
+
+  const existingActivityIndex = nextSortedActivities.findIndex(
+    activity => getLocalIdFromActivity(activity) === activityLocalId
+  );
+
+  if (!~existingActivityIndex) {
+    throw new Error(`botframework-webchat: no activity found in sortedActivities with internal ID ${activityLocalId}`);
+  }
+
+  nextSortedActivities[+existingActivityIndex] = nextActivity;
+
+  return Object.freeze({
+    ...state,
+    activityMap: Object.freeze(nextActivityMap),
+    sortedActivities: Object.freeze(nextSortedActivities)
+  } satisfies State);
+}
+
+/**
+ * Update activity channel data.
+ *
+ * @deprecated Channel data update is being deprecated, please use a custom state management solution instead.
+ * @param state
+ * @param activityLocalId
+ * @param name
+ * @param value
+ * @returns
+ */
+function updateActivityChannelData(state: State, activityLocalId: LocalId, name: string, value: unknown): State {
+  if (name.startsWith('webchat:')) {
+    throw new Error('botframework-webchat: custom channel data name must not use prefix "webchat:"');
+  }
+
+  return updateActivityChannelDataInternalSkipNameCheck(
+    state,
+    activityLocalId,
+    parse(channelDataNameSchema, name),
+    value
+  );
+}
+
+export default updateActivityChannelData;
+export { updateActivityChannelDataInternalSkipNameCheck };

package/src/reducers/activities/sort/updateSendState.ts

@@ -0,0 +1,22 @@
+import type { LocalId } from './property/LocalId';
+import type { State } from './types';
+import { updateActivityChannelDataInternalSkipNameCheck } from './updateActivityChannelData';
+
+/**
+ * @deprecated Channel data update is obsoleted, re-upsert instead.
+ * @param state
+ * @param activityLocalId
+ * @param sendState
+ * @returns
+ */
+export default function updateSendState(
+  state: State,
+  activityLocalId: LocalId,
+  sendState: 'sending' | 'send failed' | 'sent'
+): State {
+  state = updateActivityChannelDataInternalSkipNameCheck(state, activityLocalId, 'state', sendState);
+
+  state = updateActivityChannelDataInternalSkipNameCheck(state, activityLocalId, 'webchat:send-status', sendState);
+
+  return state;
+}