@patternfly/chatbot 1.0.0

package/dist/cjs/tracking/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var tracking_registry_1 = require("./tracking_registry");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(tracking_registry_1).default; } });
+__exportStar(require("./tracking_registry"), exports);

package/dist/cjs/tracking/posthog_tracking_provider.d.ts

@@ -0,0 +1,9 @@
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+import { InitProps, TrackingSpi } from './tracking_spi';
+export declare class PosthogTrackingProvider implements TrackingSpi, TrackingApi {
+    private verbose;
+    initialize(props: InitProps): void;
+    identify(userID: string, userProperties?: TrackingEventProperties): void;
+    trackPageView(url: string | undefined): void;
+    trackSingleItem(item: string, properties?: TrackingEventProperties): void;
+}

package/dist/cjs/tracking/posthog_tracking_provider.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PosthogTrackingProvider = void 0;
+const posthog_js_1 = require("posthog-js");
+class PosthogTrackingProvider {
+    constructor() {
+        this.verbose = false;
+    }
+    initialize(props) {
+        this.verbose = props.verbose;
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.log('PosthogProvider initialize');
+        }
+        const posthogKey = props.posthogKey;
+        posthog_js_1.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, userProperties = {}) {
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.log('PosthogProvider userID: ' + userID);
+        }
+        posthog_js_1.posthog.identify(userID, userProperties);
+    }
+    trackPageView(url) {
+        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, properties) {
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.log('PosthogProvider: trackSingleItem ' + item, properties);
+        }
+        posthog_js_1.posthog.capture(item, { properties });
+    }
+}
+exports.PosthogTrackingProvider = PosthogTrackingProvider;

package/dist/cjs/tracking/segment_tracking_provider.d.ts

@@ -0,0 +1,10 @@
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+import { InitProps, TrackingSpi } from './tracking_spi';
+export declare class SegmentTrackingProvider implements TrackingSpi, TrackingApi {
+    private analytics;
+    private verbose;
+    initialize(props: InitProps): void;
+    identify(userID: string, userProperties?: TrackingEventProperties): void;
+    trackPageView(url: string | undefined): void;
+    trackSingleItem(item: string, properties?: TrackingEventProperties): void;
+}

package/dist/cjs/tracking/segment_tracking_provider.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentTrackingProvider = void 0;
+const analytics_next_1 = require("@segment/analytics-next");
+class SegmentTrackingProvider {
+    constructor() {
+        this.verbose = false;
+    }
+    initialize(props) {
+        this.verbose = props.verbose;
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.log('SegmentProvider initialize');
+        }
+        const segmentKey = props.segmentKey;
+        // 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;
+        this.analytics = analytics_next_1.AnalyticsBrowser.load({
+            writeKey: segmentKey,
+            cdnURL: props.segmentCdn
+        }, {
+            integrations: Object.assign({}, integrations)
+        });
+    }
+    identify(userID, userProperties = {}) {
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.log('SegmentProvider userID: ' + userID);
+        }
+        if (this.analytics) {
+            this.analytics.identify(userID, userProperties);
+        }
+    }
+    trackPageView(url) {
+        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, properties) {
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.log('SegmentProvider: trackSingleItem ' + item, properties);
+        }
+        if (this.analytics) {
+            this.analytics.track(item, { properties });
+        }
+    }
+}
+exports.SegmentTrackingProvider = SegmentTrackingProvider;

package/dist/cjs/tracking/trackingProviderProxy.d.ts

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

package/dist/cjs/tracking/trackingProviderProxy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TrackingProviderProxy {
+    constructor(providers) {
+        this.providers = [];
+        this.providers = providers;
+    }
+    identify(userID, userProperties = {}) {
+        for (const provider of this.providers) {
+            provider.identify(userID, userProperties);
+        }
+    }
+    trackSingleItem(eventName, properties) {
+        for (const provider of this.providers) {
+            provider.trackSingleItem(eventName, properties);
+        }
+    }
+    trackPageView(url) {
+        for (const provider of this.providers) {
+            provider.trackPageView(url);
+        }
+    }
+}
+exports.default = TrackingProviderProxy;

package/dist/cjs/tracking/tracking_api.d.ts

@@ -0,0 +1,8 @@
+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/dist/cjs/tracking/tracking_api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/tracking/tracking_registry.d.ts

@@ -0,0 +1,4 @@
+import { InitProps } from './tracking_spi';
+import { TrackingApi } from './tracking_api';
+export declare const getTrackingProviders: (initProps: InitProps) => TrackingApi;
+export default getTrackingProviders;

package/dist/cjs/tracking/tracking_registry.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrackingProviders = void 0;
+const tracking_spi_1 = require("./tracking_spi");
+const trackingProviderProxy_1 = __importDefault(require("./trackingProviderProxy"));
+const console_tracking_provider_1 = require("./console_tracking_provider");
+const segment_tracking_provider_1 = require("./segment_tracking_provider");
+const posthog_tracking_provider_1 = require("./posthog_tracking_provider");
+const umami_tracking_provider_1 = require("./umami_tracking_provider");
+const getTrackingProviders = (initProps) => {
+    const providers = [];
+    if (initProps.activeProviders) {
+        let tmpProps = 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;
+            if (tmpString && tmpString.indexOf(',') !== -1) {
+                tmpProps = tmpString.split(',');
+            }
+            else {
+                tmpProps = [tmpString];
+            }
+        }
+        tmpProps.forEach((provider) => {
+            switch (tracking_spi_1.Providers[provider]) {
+                case tracking_spi_1.Providers.Segment:
+                    providers.push(new segment_tracking_provider_1.SegmentTrackingProvider());
+                    break;
+                case tracking_spi_1.Providers.Umami:
+                    providers.push(new umami_tracking_provider_1.UmamiTrackingProvider());
+                    break;
+                case tracking_spi_1.Providers.Posthog:
+                    providers.push(new posthog_tracking_provider_1.PosthogTrackingProvider());
+                    break;
+                case tracking_spi_1.Providers.Console:
+                    providers.push(new console_tracking_provider_1.ConsoleTrackingProvider());
+                    break;
+                case tracking_spi_1.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_1.default(providers);
+};
+exports.getTrackingProviders = getTrackingProviders;
+exports.default = exports.getTrackingProviders;

package/dist/cjs/tracking/tracking_spi.d.ts

@@ -0,0 +1,19 @@
+import { TrackingApi } from './tracking_api';
+export declare enum Providers {
+    None = 0,
+    Segment = 1,
+    Umami = 2,
+    Posthog = 3,
+    Console = 4
+}
+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: (props: InitProps) => void;
+}

package/dist/cjs/tracking/tracking_spi.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Providers = void 0;
+var Providers;
+(function (Providers) {
+    Providers[Providers["None"] = 0] = "None";
+    Providers[Providers["Segment"] = 1] = "Segment";
+    Providers[Providers["Umami"] = 2] = "Umami";
+    Providers[Providers["Posthog"] = 3] = "Posthog";
+    Providers[Providers["Console"] = 4] = "Console";
+})(Providers || (exports.Providers = Providers = {}));

package/dist/cjs/tracking/umami_tracking_provider.d.ts

@@ -0,0 +1,18 @@
+import { InitProps, TrackingSpi } from './tracking_spi';
+import { TrackingApi, TrackingEventProperties } from './tracking_api';
+declare global {
+    interface Window {
+        umami: any;
+    }
+}
+export declare class UmamiTrackingProvider implements TrackingSpi, TrackingApi {
+    private verbose;
+    private websiteId;
+    private queue;
+    initialize(props: InitProps): void;
+    identify(userID: string, userProperties?: TrackingEventProperties): void;
+    trackPageView(url: string | undefined): void;
+    trackSingleItem(item: string, properties?: TrackingEventProperties): void;
+    flushQueue(): void;
+    log(msg: string): void;
+}

package/dist/cjs/tracking/umami_tracking_provider.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UmamiTrackingProvider = void 0;
+class UmamiTrackingProvider {
+    constructor() {
+        this.verbose = false;
+        this.queue = [];
+    }
+    initialize(props) {
+        this.verbose = props.verbose;
+        this.log('UmamiProvider initialize');
+        this.websiteId = props.umamiKey;
+        const hostUrl = props.umamiHostUrl;
+        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, userProperties = {}) {
+        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) {
+        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, properties) {
+        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() {
+        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) {
+        if (this.verbose) {
+            // eslint-disable-next-line no-console
+            console.debug('UmamiProvider: ', msg);
+        }
+    }
+}
+exports.UmamiTrackingProvider = UmamiTrackingProvider;