@patternfly/chatbot 1.0.0

package/src/tracking/posthog_tracking_provider.ts

@@ -0,0 +1,49 @@
+import { posthog } from 'posthog-js';
+
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+import { InitProps, TrackingSpi } from './tracking_spi';
+
+export class PosthogTrackingProvider implements TrackingSpi, TrackingApi {
+  private verbose = false;
+
+  initialize(props: InitProps): void {
+    this.verbose = props.verbose;
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('PosthogProvider initialize');
+    }
+    const posthogKey = props.posthogKey as string;
+
+    posthog.init(posthogKey, {
+      // eslint-disable-next-line camelcase
+      api_host: 'https://us.i.posthog.com',
+      // eslint-disable-next-line camelcase
+      person_profiles: 'identified_only' // or 'always' to create profiles for anonymous users as well
+    });
+  }
+
+  identify(userID: string, userProperties: TrackingEventProperties = {}): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('PosthogProvider userID: ' + userID);
+    }
+    posthog.identify(userID, userProperties);
+  }
+
+  trackPageView(url: string | undefined): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('PostHogProvider url ', url);
+    }
+    // TODO posthog seems to record that automatically.
+    //  How to not clash with this here? Just leave as no-op?
+  }
+
+  trackSingleItem(item: string, properties?: TrackingEventProperties): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('PosthogProvider: trackSingleItem ' + item, properties);
+    }
+    posthog.capture(item, { properties });
+  }
+}

package/src/tracking/segment_tracking_provider.ts

@@ -0,0 +1,69 @@
+import { AnalyticsBrowser } from '@segment/analytics-next';
+
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+import { InitProps, TrackingSpi } from './tracking_spi';
+
+export class SegmentTrackingProvider implements TrackingSpi, TrackingApi {
+  private analytics: AnalyticsBrowser | undefined;
+  private verbose = false;
+
+  initialize(props: InitProps): void {
+    this.verbose = props.verbose;
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('SegmentProvider initialize');
+    }
+    const segmentKey = props.segmentKey as string;
+
+    // We need to create an object here, as ts lint is unhappy otherwise
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const integrations = props.segmentIntegrations as any;
+
+    this.analytics = AnalyticsBrowser.load(
+      {
+        writeKey: segmentKey,
+        cdnURL: props.segmentCdn as string
+      },
+
+      {
+        integrations: {
+          ...integrations
+        }
+      }
+    );
+  }
+
+  identify(userID: string, userProperties: TrackingEventProperties = {}): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('SegmentProvider userID: ' + userID);
+    }
+    if (this.analytics) {
+      this.analytics.identify(userID, userProperties);
+    }
+  }
+
+  trackPageView(url: string | undefined): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('SegmentProvider url ', url);
+    }
+    if (this.analytics) {
+      if (url) {
+        this.analytics.page(url);
+      } else {
+        this.analytics.page(); // Uses window.url
+      }
+    }
+  }
+
+  trackSingleItem(item: string, properties?: TrackingEventProperties): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.log('SegmentProvider: trackSingleItem ' + item, properties);
+    }
+    if (this.analytics) {
+      this.analytics.track(item, { properties });
+    }
+  }
+}

package/src/tracking/trackingProviderProxy.ts

@@ -0,0 +1,28 @@
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+class TrackingProviderProxy implements TrackingApi {
+  providers: TrackingApi[] = [];
+
+  constructor(providers: TrackingApi[]) {
+    this.providers = providers;
+  }
+
+  identify(userID: string, userProperties: TrackingEventProperties = {}): void {
+    for (const provider of this.providers) {
+      provider.identify(userID, userProperties);
+    }
+  }
+
+  trackSingleItem(eventName: string, properties?: TrackingEventProperties): void {
+    for (const provider of this.providers) {
+      provider.trackSingleItem(eventName, properties);
+    }
+  }
+
+  trackPageView(url: string | undefined) {
+    for (const provider of this.providers) {
+      provider.trackPageView(url);
+    }
+  }
+}
+
+export default TrackingProviderProxy;

package/src/tracking/tracking_api.ts

@@ -0,0 +1,11 @@
+export interface TrackingEventProperties {
+  [key: string]: string | number | boolean | undefined;
+}
+
+export interface TrackingApi {
+  identify: (userID: string, userProperties: TrackingEventProperties) => void;
+
+  trackPageView: (url: string | undefined) => void;
+
+  trackSingleItem: (eventName: string, properties: TrackingEventProperties | undefined) => void;
+}

package/src/tracking/tracking_registry.ts

@@ -0,0 +1,66 @@
+import { InitProps, Providers, TrackingSpi } from './tracking_spi';
+import { TrackingApi } from './tracking_api';
+import TrackingProviderProxy from './trackingProviderProxy';
+import { ConsoleTrackingProvider } from './console_tracking_provider';
+import { SegmentTrackingProvider } from './segment_tracking_provider';
+import { PosthogTrackingProvider } from './posthog_tracking_provider';
+import { UmamiTrackingProvider } from './umami_tracking_provider';
+
+export const getTrackingProviders = (initProps: InitProps): TrackingApi => {
+  const providers: TrackingSpi[] = [];
+
+  if (initProps.activeProviders) {
+    let tmpProps: string[] = initProps.activeProviders;
+
+    // Theoretically we get an array of provider names, but it could also be a CSV string...
+    if (!Array.isArray(initProps.activeProviders)) {
+      const tmpString = initProps.activeProviders as string;
+      if (tmpString && tmpString.indexOf(',') !== -1) {
+        tmpProps = tmpString.split(',');
+      } else {
+        tmpProps = [tmpString];
+      }
+    }
+
+    tmpProps.forEach((provider) => {
+      switch (Providers[provider]) {
+        case Providers.Segment:
+          providers.push(new SegmentTrackingProvider());
+          break;
+        case Providers.Umami:
+          providers.push(new UmamiTrackingProvider());
+          break;
+        case Providers.Posthog:
+          providers.push(new PosthogTrackingProvider());
+          break;
+        case Providers.Console:
+          providers.push(new ConsoleTrackingProvider());
+          break;
+        case Providers.None: // Do nothing, just a placeholder
+          break;
+        default:
+          if (providers.length > 1) {
+            if (initProps.verbose) {
+              // eslint-disable-next-line no-console
+              console.error("Unknown provider '" + provider);
+            }
+          }
+          break;
+      }
+    });
+  }
+
+  // Initialize them
+  for (const provider of providers) {
+    try {
+      provider.initialize(initProps);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e);
+    }
+  }
+
+  return new TrackingProviderProxy(providers);
+};
+
+export default getTrackingProviders;

package/src/tracking/tracking_spi.ts

@@ -0,0 +1,25 @@
+import { TrackingApi } from './tracking_api';
+
+export enum Providers {
+  None,
+  Segment,
+  Umami,
+  Posthog,
+  Console
+}
+
+export type ProviderAsString = keyof typeof Providers;
+
+export interface BaseProps {
+  verbose: boolean;
+  activeProviders: [ProviderAsString];
+}
+
+export type InitProps = {
+  [key: string]: string | number | boolean;
+} & BaseProps;
+
+export interface TrackingSpi extends TrackingApi {
+  // Initialize the provider
+  initialize: (props: InitProps) => void;
+}

package/src/tracking/umami_tracking_provider.ts

@@ -0,0 +1,110 @@
+import { InitProps, TrackingSpi } from './tracking_spi';
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+
+declare global {
+  interface Window {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    umami: any;
+  }
+}
+
+// Items in a queue.
+// We need to queue up requests until the script is fully loaded
+interface queueT {
+  what: 'i' | 't' | 'p'; // identify, track, pageview
+  name: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  payload?: any;
+}
+
+export class UmamiTrackingProvider implements TrackingSpi, TrackingApi {
+  private verbose = false;
+  private websiteId: string | undefined;
+  private queue: queueT[] = [];
+
+  initialize(props: InitProps): void {
+    this.verbose = props.verbose;
+    this.log('UmamiProvider initialize');
+
+    this.websiteId = props.umamiKey as string;
+    const hostUrl = props.umamiHostUrl as string;
+
+    const script = document.createElement('script');
+    script.src = hostUrl + '/script.js';
+    script.async = true;
+    script.defer = true;
+
+    // Configure Umami properties
+    script.setAttribute('data-website-id', this.websiteId);
+    script.setAttribute('data-host-url', hostUrl);
+    script.setAttribute('data-auto-track', 'false');
+    script.setAttribute('data-exclude-search', 'false');
+
+    // Now get from config, which may override some of the above.
+    const UMAMI_PREFIX = 'umami-';
+    for (const prop in props) {
+      if (prop.startsWith(UMAMI_PREFIX)) {
+        const att = 'data-' + prop.substring(UMAMI_PREFIX.length);
+        const val = props[prop];
+        script.setAttribute(att, String(val));
+      }
+    }
+    script.onload = () => {
+      this.log('UmamiProvider script loaded');
+      this.flushQueue();
+    };
+
+    document.body.appendChild(script);
+  }
+
+  identify(userID: string, userProperties: TrackingEventProperties = {}): void {
+    this.log('UmamiProvider userID: ' + userID + ' => ' + JSON.stringify(userProperties));
+    if (window.umami) {
+      window.umami.identify({ userID, userProperties });
+    } else {
+      this.queue.push({ what: 'i', name: userID, payload: userProperties });
+    }
+  }
+
+  trackPageView(url: string | undefined): void {
+    this.log('UmamiProvider url ' + url);
+    if (window.umami) {
+      window.umami.track({ url, website: this.websiteId });
+    } else {
+      this.queue.push({ what: 'p', name: String(url) });
+    }
+  }
+
+  trackSingleItem(item: string, properties?: TrackingEventProperties): void {
+    this.log('UmamiProvider: trackSingleItem ' + item + JSON.stringify(properties));
+    if (window.umami) {
+      window.umami.track(item, properties);
+    } else {
+      this.queue.push({ what: 't', name: item, payload: properties });
+    }
+  }
+
+  flushQueue(): void {
+    for (const item of this.queue) {
+      this.log('Queue flush ' + JSON.stringify(item));
+      switch (item.what) {
+        case 'i':
+          this.identify(item.name, item.payload);
+          break;
+        case 't':
+          this.trackSingleItem(item.name, item.payload);
+          break;
+        case 'p':
+          this.trackPageView(item.name);
+          break;
+      }
+    }
+  }
+
+  log(msg: string): void {
+    if (this.verbose) {
+      // eslint-disable-next-line no-console
+      console.debug('UmamiProvider: ', msg);
+    }
+  }
+}

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "commonjs"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,73 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es2015" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */,
+    "module": "es2020" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    // "lib": [],                                   /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    "jsx": "react-jsx" /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */,
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    "outDir": "./dist/esm" /* Redirect output structure to the directory. */,
+    "rootDir": "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    "noImplicitAny": false /* Raise error on expressions and declarations with an implied 'any' type. */,
+    // "strictNullChecks": true,                    /* Enable strict null checks. */
+    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
+    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                  /* Ensure overriding members in derived classes are marked with an 'override' modifier. */
+    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
+  },
+  "include": ["./src/*", "./src/**/*", "./cypress/**/*"]
+}