@atlaskit/teams-app-internal-analytics 1.0.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @atlaskit/teams-app-internal-analytics

package/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions and limitations under the
+License.

package/README.md

@@ -0,0 +1,189 @@
+# Teams App Internal Analytics
+
+A comprehensive analytics package for the Teams app and People & Teams platform packages. This
+package provides type-safe analytics event definitions, context providers, and testing utilities for
+tracking user interactions and system behaviors.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Architecture](#architecture)
+- [Adding New Events](#adding-new-events)
+- [Analytics Context](#analytics-context)
+- [Testing Analytics](#testing-analytics)
+
+## Overview
+
+This package implements a structured analytics system that is:
+
+- **Type-safe**: All events and attributes are strongly typed
+- **Declarative**: Events are defined in YAML specification files
+- **Hierarchical**: Supports nested analytics contexts for rich metadata
+- **Testable**: Comprehensive testing utilities included
+- **Channel-specific**: Events are fired to the dedicated `peopleTeams` analytics channel
+
+## Architecture
+
+```
+analytics.spec.yaml          ← Event definitions (YAML)
+        ↓
+   Code Generation           ← Generates TypeScript types & hooks
+        ↓
+Generated Files:
+├── analytics.types.ts       ← Type definitions for events
+├── create-event-payload.ts  ← Event payload creation logic
+└── use-analytics-events.ts  ← React hook for firing events
+        ↓
+	Consumers		     	 ← Use hook to fire analytics events
+        ↓
+Analytics Listeners          ← Events sent to 'peopleTeams' channel
+```
+
+## Adding New Events
+
+1. **Define the event** in `analytics.spec.yaml`:
+
+[Event definition file specification](https://hello.atlassian.net/wiki/spaces/SMRT/pages/742668844/RFC+-+Analytic+Definition+File#Event-definition----Context)
+
+```yaml
+- button clicked (addUserToTeam):
+    type: ui
+    description: description of when this event fires
+    attributes:
+      <<: *PackageMetaDataContext
+      newAttribute:
+        type: string
+        description: description of the new attribute
+```
+
+2. **Regenerate types**:
+
+```bash
+yarn analytics:codegen
+```
+
+3. **Use the new event**:
+
+```tsx
+import React from 'react';
+import { useAnalyticsEvents } from '@atlaskit/teams-app-internal-analytics';
+
+function TeamMemberButton() {
+	const { fireEvent } = useAnalyticsEvents();
+
+	const handleClick = () => {
+		fireEvent('ui.button.clicked.addUserToTeam', {
+			testAttribute: 'memberInvite',
+		});
+	};
+
+	return <button onClick={handleClick}>Invite Member</button>;
+}
+```
+
+### Event Naming Convention
+
+Events follow this naming pattern:
+
+- **UI Events**: `ui.[actionSubject].[action].[actionSubjectId]`
+- **Track Events**: `track.[actionSubject].[action].[actionSubjectId]`
+- **Operational Events**: `operational.[actionSubject].[action].[actionSubjectId]`
+- **Screen Events**: `screen.[screenName].viewed`
+
+## Analytics Context
+
+The `PeopleTeamsAnalyticsContext` provides hierarchical metadata that is automatically included in
+all events fired by child components.
+
+### Nested Contexts
+
+```tsx
+<PeopleTeamsAnalyticsContext
+	data={{
+		source: 'teamsApp',
+		attributes: { consumer: 'web' },
+	}}
+>
+	<PeopleTeamsAnalyticsContext
+		data={{
+			source: 'teamsProfilePage',
+			attributes: { teamId: 'team-123' },
+		}}
+	>
+		<TeamProfile />
+	</PeopleTeamsAnalyticsContext>
+</PeopleTeamsAnalyticsContext>
+```
+
+**Resulting event payload:**
+
+```json
+{
+	"eventType": "ui",
+	"actionSubject": "button",
+	"action": "clicked",
+	"actionSubjectId": "analyticsExample",
+	"source": "teamsProfilePage",
+	"attributes": {
+		"packageName": "@atlassian/team-profile",
+		"packageVersion": "X.X.X",
+		"consumer": "web",
+		"teamId": "team-123",
+		"testAttribute": "yourValue",
+		"sourceHierarchy": "teamsApp.teamsProfilePage"
+	}
+}
+```
+
+### Context Priority
+
+When contexts are nested, there is a priority system to ensure the correct metadata is appended to
+events sent to GASv3. Duplicate data is resolved in the following order:
+
+1. **Event data** (highest priority)
+2. **Inner context data**
+3. **Outer context data**
+
+**Note**: Context `attributes` are only appended to events when they come from the `peopleTeamsCtx`
+namespace, such as the `TeamsAppAnalyticsContext` from this package. Other event payload properties
+like `source` will append to all events regardless of the context namespace.
+
+## Testing Analytics
+
+This package includes testing utilities that help you verify analytics events are sent correctly to
+GASv3. These utilities use the processing logic from `PeopleTeamsAnalyticsListener`, ensuring that
+event payloads (including all provided contexts) match the expected outcome.
+
+### Basic Test Setup
+
+```tsx
+import {
+	createMockAnalyticsClient,
+	renderWithAnalyticsListener,
+} from '@atlaskit/teams-app-internal-analytics/test-utils';
+
+const mockClient = createMockAnalyticsClient();
+
+test('should fire analytics event on button click', async () => {
+	const { user, mockClient, expectEventToBeFired } = renderWithAnalyticsListener(
+		<PeopleTeamsAnalyticsContext data={{ source: 'teamsApp' }}>
+			<ButtonWithAnalytics testId="analytics-button" />
+		</PeopleTeamsAnalyticsContext>,
+		{ mockClient },
+	);
+
+	// Trigger the event
+	await user.click(screen.getByTestId('analytics-button'));
+
+	// Verify the event was fired correctly
+	expectEventToBeFired('ui', {
+		actionSubject: 'button',
+		action: 'clicked',
+		actionSubjectId: 'analyticsExample',
+		source: 'teamsApp',
+		attributes: expect.objectContaining({
+			testAttribute: 'expectedValue',
+		}),
+	});
+});
+```

package/analytics.spec.yaml

@@ -0,0 +1,42 @@
+context:
+  PackageMetaData: &PackageMetaDataContext
+    packageName:
+      type: string
+      description: name of the package the event was fired from
+    packageVersion:
+      type: string
+      description: version of the package the event was fired from
+
+events:
+  - button clicked (analyticsExample):
+      type: ui
+      description: fired when the teams-app-internal-analytics example button is clicked
+      attributes:
+        <<: *PackageMetaDataContext
+        testAttribute:
+          type: string
+          description: test attribute
+  - automation triggered (analyticsExample):
+      type: track
+      description: fired when the teams-app-internal-analytics example button is clicked
+      attributes:
+        <<: *PackageMetaDataContext
+        testAttribute:
+          type: string
+          description: test attribute
+  - automation fired (analyticsExample):
+      type: operational
+      description: fired when the teams-app-internal-analytics example button is clicked
+      attributes:
+        <<: *PackageMetaDataContext
+        testAttribute:
+          type: string
+          description: test attribute
+  - analyticsExampleScreen viewed:
+      type: screen
+      description: fired when the teams-app-internal-analytics example is viewed
+      attributes:
+        <<: *PackageMetaDataContext
+        testAttribute:
+          type: string
+          description: test attribute

package/dist/cjs/common/test-utils/index.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderWithAnalyticsListener = exports.createMockAnalyticsClient = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _userEvent = _interopRequireDefault(require("@testing-library/user-event"));
+var _analyticsListeners = _interopRequireWildcard(require("@atlaskit/analytics-listeners"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Creates a mock analytics client for testing
+ */
+var createMockAnalyticsClient = exports.createMockAnalyticsClient = function createMockAnalyticsClient() {
+  return {
+    sendUIEvent: jest.fn(),
+    sendOperationalEvent: jest.fn(),
+    sendTrackEvent: jest.fn(),
+    sendScreenEvent: jest.fn()
+  };
+};
+
+/**
+ * Test utility for testing analytics payloads end-to-end.
+ * Renders children with analytics listener and provides mock client for event verification.
+ *
+ * @example
+ * ```tsx
+ * const { user, mockClient, expectEventToBeFired } = renderWithAnalyticsListener({
+ *   children: (
+ *     <PeopleTeamsAnalyticsContext data={{ source: 'teamsApp' }}>
+ *       <ButtonWithAnalytics eventType="ui" testId="button-with-analytics"/>
+ *     </PeopleTeamsAnalyticsContext>
+ *   )
+ * });
+ *
+ * // Test triggers event however it needs to
+ * const button = screen.getByTestId('button-with-analytics');
+ * await act(() => user.click(button));
+ *
+ * // Option 1: Use the helper function
+ * expectEventToBeFired('ui', {
+ *   action: 'clicked',
+ *   source: 'teamsApp',
+ *   attributes: expect.objectContaining({
+ *     packageName: expect.any(String)
+ *   })
+ * });
+ *
+ * // Option 2: Use mockClient directly for more control
+ * expect(mockClient.sendUIEvent).toHaveBeenCalledWith(
+ *   expect.objectContaining({ source: 'teamsApp' })
+ * );
+ * ```
+ */
+var renderWithAnalyticsListener = exports.renderWithAnalyticsListener = function renderWithAnalyticsListener(ui, options) {
+  var _ref = options || {},
+    setup = _ref.setup,
+    providedMockClient = _ref.mockClient;
+  if (setup) {
+    setup();
+  }
+  var mockClient = providedMockClient || createMockAnalyticsClient();
+  var user = _userEvent.default.setup();
+  var renderResult = (0, _react2.render)( /*#__PURE__*/_react.default.createElement(_analyticsListeners.default, {
+    excludedChannels: Object.values(_analyticsListeners.FabricChannel).filter(function (channel) {
+      return channel !== _analyticsListeners.FabricChannel.peopleTeams;
+    }),
+    client: mockClient
+  }, ui));
+  var expectEventToBeFired = function expectEventToBeFired(eventType, expectedPayload) {
+    var getMockForEventType = function getMockForEventType(type) {
+      switch (type) {
+        case 'ui':
+          return mockClient.sendUIEvent;
+        case 'operational':
+          return mockClient.sendOperationalEvent;
+        case 'track':
+          return mockClient.sendTrackEvent;
+        case 'screen':
+          return mockClient.sendScreenEvent;
+        default:
+          throw new Error("Unsupported event type: ".concat(type));
+      }
+    };
+    var targetMock = getMockForEventType(eventType);
+    expect(targetMock).toHaveBeenCalledWith(expect.objectContaining(_objectSpread(_objectSpread({}, expectedPayload), {}, {
+      attributes: expect.objectContaining(expectedPayload.attributes || {})
+    })));
+  };
+  return _objectSpread(_objectSpread({}, renderResult), {}, {
+    user: user,
+    mockClient: mockClient,
+    expectEventToBeFired: expectEventToBeFired
+  });
+};

package/dist/cjs/common/utils/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EVENT_CHANNEL = void 0;
+var EVENT_CHANNEL = exports.EVENT_CHANNEL = 'peopleTeams';

package/dist/cjs/common/utils/generated/analytics.types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/common/utils/generated/create-event-payload.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+/**
+ * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
+ *
+ * Generates Typescript types for analytics events from analytics.spec.yaml
+ *
+ * @codegen <<SignedSource::050566410df453c9b1ba071c6805ead2>>
+ * @codegenCommand yarn workspace @atlassian/analytics-tooling run analytics:codegen teams-app-internal-analytics
+ */
+
+var createEventPayload = function createEventPayload(eventKey) {
+  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    _ref[_key - 1] = arguments[_key];
+  }
+  var attributes = _ref[0];
+  var _eventKey$split = eventKey.split('.'),
+    _eventKey$split2 = (0, _slicedToArray2.default)(_eventKey$split, 4),
+    eventType = _eventKey$split2[0],
+    actionSubject = _eventKey$split2[1],
+    action = _eventKey$split2[2],
+    actionSubjectId = _eventKey$split2[3];
+  if (eventType === 'screen') {
+    return {
+      eventType: eventType,
+      name: actionSubject,
+      action: 'viewed',
+      attributes: attributes
+    };
+  }
+  return {
+    eventType: eventType,
+    actionSubject: actionSubject,
+    action: action,
+    actionSubjectId: actionSubjectId,
+    attributes: attributes
+  };
+};
+var _default = exports.default = createEventPayload;

package/dist/cjs/common/utils/generated/use-analytics-events.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnalyticsEvents = void 0;
+var _react = require("react");
+var _analyticsNext = require("@atlaskit/analytics-next");
+var _constants = require("../constants");
+var _createEventPayload = _interopRequireDefault(require("./create-event-payload"));
+/**
+ * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
+ *
+ * Generates Typescript types for analytics events from analytics.spec.yaml
+ *
+ * @codegen <<SignedSource::d01fef63886f2825ffbc3a0ec1ca7534>>
+ * @codegenCommand yarn workspace @atlassian/analytics-tooling run analytics:codegen teams-app-internal-analytics
+ */
+
+var useAnalyticsEvents = exports.useAnalyticsEvents = function useAnalyticsEvents() {
+  var _useAnalyticsNextEven = (0, _analyticsNext.useAnalyticsEvents)(),
+    createAnalyticsEvent = _useAnalyticsNextEven.createAnalyticsEvent;
+  var fireEvent = (0, _react.useCallback)(function () {
+    var event = createAnalyticsEvent(_createEventPayload.default.apply(void 0, arguments));
+    event.fire(_constants.EVENT_CHANNEL);
+  }, [createAnalyticsEvent]);
+  return {
+    fireEvent: fireEvent
+  };
+};

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TeamsAppAnalyticsContext", {
+  enumerable: true,
+  get: function get() {
+    return _analyticsContext.TeamsAppAnalyticsContext;
+  }
+});
+Object.defineProperty(exports, "useAnalyticsEvents", {
+  enumerable: true,
+  get: function get() {
+    return _useAnalyticsEvents.useAnalyticsEvents;
+  }
+});
+var _analyticsContext = require("./ui/analytics-context");
+var _useAnalyticsEvents = require("./common/utils/generated/use-analytics-events");

package/dist/cjs/ui/analytics-context/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TeamsAppAnalyticsContext = TeamsAppAnalyticsContext;
+exports.defaultAnalyticsContextData = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _react = _interopRequireWildcard(require("react"));
+var _analyticsNamespacedContext = require("@atlaskit/analytics-namespaced-context");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var defaultAnalyticsContextData = exports.defaultAnalyticsContextData = {
+  packageName: "@atlaskit/teams-app-internal-analytics",
+  packageVersion: "0.0.0"
+};
+function TeamsAppAnalyticsContext(_ref) {
+  var data = _ref.data,
+    children = _ref.children;
+  var analyticsContextData = (0, _react.useMemo)(function () {
+    if ((0, _typeof2.default)(data) === 'object') {
+      return _objectSpread(_objectSpread({}, defaultAnalyticsContextData), data);
+    }
+    return defaultAnalyticsContextData;
+  }, [data]);
+  return /*#__PURE__*/_react.default.createElement(_analyticsNamespacedContext.PeopleTeamsAnalyticsContext, {
+    data: analyticsContextData
+  }, children);
+}

package/dist/es2019/common/test-utils/index.js

@@ -0,0 +1,89 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import FabricAnalyticsListeners, { FabricChannel } from '@atlaskit/analytics-listeners';
+/**
+ * Creates a mock analytics client for testing
+ */
+export const createMockAnalyticsClient = () => ({
+  sendUIEvent: jest.fn(),
+  sendOperationalEvent: jest.fn(),
+  sendTrackEvent: jest.fn(),
+  sendScreenEvent: jest.fn()
+});
+
+/**
+ * Test utility for testing analytics payloads end-to-end.
+ * Renders children with analytics listener and provides mock client for event verification.
+ *
+ * @example
+ * ```tsx
+ * const { user, mockClient, expectEventToBeFired } = renderWithAnalyticsListener({
+ *   children: (
+ *     <PeopleTeamsAnalyticsContext data={{ source: 'teamsApp' }}>
+ *       <ButtonWithAnalytics eventType="ui" testId="button-with-analytics"/>
+ *     </PeopleTeamsAnalyticsContext>
+ *   )
+ * });
+ *
+ * // Test triggers event however it needs to
+ * const button = screen.getByTestId('button-with-analytics');
+ * await act(() => user.click(button));
+ *
+ * // Option 1: Use the helper function
+ * expectEventToBeFired('ui', {
+ *   action: 'clicked',
+ *   source: 'teamsApp',
+ *   attributes: expect.objectContaining({
+ *     packageName: expect.any(String)
+ *   })
+ * });
+ *
+ * // Option 2: Use mockClient directly for more control
+ * expect(mockClient.sendUIEvent).toHaveBeenCalledWith(
+ *   expect.objectContaining({ source: 'teamsApp' })
+ * );
+ * ```
+ */
+export const renderWithAnalyticsListener = (ui, options) => {
+  const {
+    setup,
+    mockClient: providedMockClient
+  } = options || {};
+  if (setup) {
+    setup();
+  }
+  const mockClient = providedMockClient || createMockAnalyticsClient();
+  const user = userEvent.setup();
+  const renderResult = render( /*#__PURE__*/React.createElement(FabricAnalyticsListeners, {
+    excludedChannels: Object.values(FabricChannel).filter(channel => channel !== FabricChannel.peopleTeams),
+    client: mockClient
+  }, ui));
+  const expectEventToBeFired = (eventType, expectedPayload) => {
+    const getMockForEventType = type => {
+      switch (type) {
+        case 'ui':
+          return mockClient.sendUIEvent;
+        case 'operational':
+          return mockClient.sendOperationalEvent;
+        case 'track':
+          return mockClient.sendTrackEvent;
+        case 'screen':
+          return mockClient.sendScreenEvent;
+        default:
+          throw new Error(`Unsupported event type: ${type}`);
+      }
+    };
+    const targetMock = getMockForEventType(eventType);
+    expect(targetMock).toHaveBeenCalledWith(expect.objectContaining({
+      ...expectedPayload,
+      attributes: expect.objectContaining(expectedPayload.attributes || {})
+    }));
+  };
+  return {
+    ...renderResult,
+    user,
+    mockClient,
+    expectEventToBeFired
+  };
+};

package/dist/es2019/common/utils/constants.js

@@ -0,0 +1 @@
+export const EVENT_CHANNEL = 'peopleTeams';

package/dist/es2019/common/utils/generated/create-event-payload.js

@@ -0,0 +1,28 @@
+/**
+ * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
+ *
+ * Generates Typescript types for analytics events from analytics.spec.yaml
+ *
+ * @codegen <<SignedSource::050566410df453c9b1ba071c6805ead2>>
+ * @codegenCommand yarn workspace @atlassian/analytics-tooling run analytics:codegen teams-app-internal-analytics
+ */
+
+const createEventPayload = (eventKey, ...[attributes]) => {
+  const [eventType, actionSubject, action, actionSubjectId] = eventKey.split('.');
+  if (eventType === 'screen') {
+    return {
+      eventType,
+      name: actionSubject,
+      action: 'viewed',
+      attributes: attributes
+    };
+  }
+  return {
+    eventType,
+    actionSubject,
+    action,
+    actionSubjectId,
+    attributes: attributes
+  };
+};
+export default createEventPayload;

package/dist/es2019/common/utils/generated/use-analytics-events.js

@@ -0,0 +1,24 @@
+/**
+ * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
+ *
+ * Generates Typescript types for analytics events from analytics.spec.yaml
+ *
+ * @codegen <<SignedSource::d01fef63886f2825ffbc3a0ec1ca7534>>
+ * @codegenCommand yarn workspace @atlassian/analytics-tooling run analytics:codegen teams-app-internal-analytics
+ */
+import { useCallback } from 'react';
+import { useAnalyticsEvents as useAnalyticsNextEvents } from '@atlaskit/analytics-next';
+import { EVENT_CHANNEL } from '../constants';
+import createEventPayload from './create-event-payload';
+export const useAnalyticsEvents = () => {
+  const {
+    createAnalyticsEvent
+  } = useAnalyticsNextEvents();
+  const fireEvent = useCallback((...params) => {
+    const event = createAnalyticsEvent(createEventPayload(...params));
+    event.fire(EVENT_CHANNEL);
+  }, [createAnalyticsEvent]);
+  return {
+    fireEvent
+  };
+};

package/dist/es2019/index.js

@@ -0,0 +1,2 @@
+export { TeamsAppAnalyticsContext } from './ui/analytics-context';
+export { useAnalyticsEvents } from './common/utils/generated/use-analytics-events';

package/dist/es2019/ui/analytics-context/index.js

@@ -0,0 +1,23 @@
+import React, { useMemo } from 'react';
+import { PeopleTeamsAnalyticsContext } from '@atlaskit/analytics-namespaced-context';
+export const defaultAnalyticsContextData = {
+  packageName: "@atlaskit/teams-app-internal-analytics",
+  packageVersion: "0.0.0"
+};
+export function TeamsAppAnalyticsContext({
+  data,
+  children
+}) {
+  const analyticsContextData = useMemo(() => {
+    if (typeof data === 'object') {
+      return {
+        ...defaultAnalyticsContextData,
+        ...data
+      };
+    }
+    return defaultAnalyticsContextData;
+  }, [data]);
+  return /*#__PURE__*/React.createElement(PeopleTeamsAnalyticsContext, {
+    data: analyticsContextData
+  }, children);
+}