@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/types/Tracker.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/app-integration.d.ts

@@ -0,0 +1,10 @@
+import type { AltEventHandler, SDKConfigInput } from './Tracker';
+declare global {
+    interface Window {
+        __nativeJwe__?: string;
+        hermesJwe?: string;
+        pulseEventHandler?: AltEventHandler;
+    }
+}
+export declare function getDefaultNativeJwe(config: SDKConfigInput): string | undefined;
+export declare function getDefaultAltHandler(config: SDKConfigInput): AltEventHandler | undefined;

package/dist/types/builders/actor.d.ts

@@ -0,0 +1,39 @@
+import type { TrackerEventInput } from './events';
+/**
+ * generateActorSDRN
+ * Generates a well-formed sdrn for an actor, based on id, realm inputs
+ * @param id String
+ * @param realm String Realm is not required, so, without a fully formed "@id" in the actors input object, the "realm"
+ * part of the sdrn is flagged with "__REALM_NOT_SET__", for early noticing implementation/integration errors.
+ * @internal
+ */
+export declare function generateActorSDRN(id: string | number, realm?: string): string;
+/**
+ * @interface
+ */
+export type ActorInput = {
+    id?: string | number | undefined;
+    realm?: string;
+    [k: string | number]: unknown | undefined;
+};
+/**
+ * @interface
+ */
+export type Actor = {
+    '@id': string;
+    'spt:userId': string;
+};
+/**
+ * Type guard to check if the input is an ActorInput
+ * @param input
+ * @internal
+ */
+export declare function isActorInput(input: unknown): input is ActorInput;
+/**
+ * Function to generate a builder for Actor objects.
+ */
+export default function actor<G extends Pick<TrackerEventInput, 'actor'>>(input?: G): Actor | undefined;
+/**
+ * @internal
+ */
+export declare const defaultValue: () => undefined;

package/dist/types/builders/consent-manager.d.ts

@@ -0,0 +1,49 @@
+import { type Consents } from './consents';
+declare global {
+    interface Window {
+        _tcf_: ConsentManager;
+    }
+}
+/**
+ * Represents the value of a consent.
+ * 1 means granted, 0 means denied, and null means user has not made a choice yet.
+ * TODO: Replace with proper types when available from sourcepoint package. (Current exported types are unusable)
+ */
+export type ConsentState = '0' | '1' | null;
+/**
+ * Represents the categories for which consent can be given.
+ * TODO: Replace with proper types when available from sourcepoint package. (Current exported types are unusable)
+ */
+export type ConsentCategory = 'CMP:advertising' | 'CMP:analytics' | 'CMP:marketing' | 'CMP:personalisation' | 'CMP:performance_marketing';
+export interface ConsentManager {
+    getCachedOrDefaultConsentsForPulse: () => Consents;
+    getConsentedToAllSync: () => boolean | null;
+    getPermissionSync: (consentCategory: ConsentCategory) => ConsentState;
+    isConsentedToAll: (callback: (value: boolean) => void) => () => void;
+    showPrivacyManager: () => void;
+    subscribe: (consentCategory: ConsentCategory, callback: (value: ConsentState) => void) => () => void;
+    subscribeAny: (callback: () => void) => () => void;
+}
+/**
+ * Fallback if TCF fails to initialize
+ * These should always be "unknown" since we don't know the user's choice
+ * @returns
+ */
+export declare function getFallbackConsents(): Consents;
+/**
+ * Returns the consent manager (`_tcf_`), if available.
+ * It will await "cmp:loaded" event if the consent manager is not available yet and return it when it is.
+ * @returns The consent manager object.
+ * @example
+ * const manager = await consentManager();
+ */
+export declare const consentManager: () => Promise<ConsentManager>;
+/**
+ * Waits for user to reply to consents, then retrieves the cached or default consents for Pulse from the consent manager.
+ * Only needed if you want to wait for user to respond to consents rather than sending events with default consent
+ * WARNING: Do not use this without analytics consent being activated in TCF or it will never resolve for users without cached consents!
+ * @returns A promise with the cached or default consents for Pulse.
+ * @example
+ * const getConsentsWaitForAnalyticsPromise = getConsentsWaitForAnalytics();
+ */
+export declare const getConsentsWaitForAnalytics: (callback?: (consents: Consents) => void) => Promise<Consents>;

package/dist/types/builders/consents.d.ts

@@ -0,0 +1,107 @@
+import type { TrackerEventInput } from './events';
+/**
+ * @enum ConsentCategory
+ */
+export declare enum ConsentsCategory {
+    CMP_ANALYTICS = "CMP_ANALYTICS",
+    CMP_MARKETING = "CMP_MARKETING",
+    CMP_ADVERTISING = "CMP_ADVERTISING",
+    CMP_PERSONALIZATION = "CMP_PERSONALIZATION"
+}
+export declare const ConsentsSourceValues: readonly ["default", "cmp", "cache"];
+export type ConsentsSource = (typeof ConsentsSourceValues)[number];
+export declare const ConsentsPurposeCategoryStatusValues: readonly ["accepted", "rejected", "unknown"];
+export type ConsentsPurposeCategoryStatus = (typeof ConsentsPurposeCategoryStatusValues)[number];
+export interface ConsentsBase {
+    source?: ConsentsSource;
+}
+export interface ConsentsPurposeCategory {
+    status: ConsentsPurposeCategoryStatus;
+    optIn?: boolean;
+}
+export interface ConsentsPurposes {
+    purposes: Record<ConsentsCategory, ConsentsPurposeCategory>;
+}
+/**
+ * @deprecated
+ */
+export interface ConsentsPurposesCategoryLegacy {
+    optIn: boolean;
+}
+/**
+ * @deprecated
+ */
+export interface ConsentsPurposesLegacy {
+    purposes: Record<ConsentsCategory, ConsentsPurposesCategoryLegacy>;
+}
+/**
+ * @deprecated
+ */
+export type ConsentsLegacy = ConsentsBase & ConsentsPurposesLegacy;
+export type Consents = ConsentsBase & ConsentsPurposes;
+/**
+ * @deprecated
+ */
+export type ConsentsInput = {
+    purposes: ConsentedToPurposeInput;
+    source?: ConsentsSource;
+};
+/**
+ * @deprecated
+ */
+export type ConsentCategory = ConsentsCategory;
+/**
+ * @deprecated
+ */
+export type ConsentPurposeCategory = ConsentsPurposeCategory;
+/**
+ * @deprecated
+ */
+export type ConsentedToPurposeInput = {
+    [K in ConsentCategory]?: ConsentPurposeCategory | ConsentsPurposesCategoryLegacy;
+};
+/**
+ * @deprecated
+ */
+export type ConsentsOutput = Consents | ConsentsLegacy;
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns The resolved consents and whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export declare function applyAdvertisingConsent(consents?: Consents | ConsentsLegacy | Promise<Consents>, requireAdvertisingOptIn?: boolean | Promise<boolean>): Promise<boolean>;
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns The resolved consents and whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export declare function applyAdvertisingConsentSync(consents?: Consents, requireAdvertisingOptIn?: boolean): boolean;
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export declare function resolveIncludeAdvertising(consents?: Consents | ConsentsLegacy | Promise<Consents>, requireAdvertisingOptIn?: boolean | Promise<boolean>): Promise<boolean>;
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export declare function resolveIncludeAdvertisingSync(consents?: Consents | ConsentsLegacy, requireAdvertisingOptIn?: boolean): boolean;
+/**
+ * Builds a consents object from input.
+ * @param input
+ */
+export default function consents(input?: Pick<TrackerEventInput, 'consents'>): Consents | ConsentsLegacy | undefined;

package/dist/types/builders/device-browser.d.ts

@@ -0,0 +1,6 @@
+import { type DeviceInput } from './device-node';
+import type { TrackerEventInput } from './events';
+export * from './device-node';
+export declare function getXEnvironmentId(): string | undefined;
+export declare const defaultValue: () => Omit<DeviceInput, 'id'>;
+export default function (input?: Pick<TrackerEventInput, 'device'>): import("./device-node").Device | undefined;

package/dist/types/builders/device-node.d.ts

@@ -0,0 +1,65 @@
+import type { TrackerEventInput } from './events';
+/**
+ * Generate a well-formed environment SDRN from an ID
+ * @param id
+ * @internal
+ */
+export declare function generateEnvironmentSDRN(id: string): string;
+/**
+ * Input expected from the developer to transform into an Event Device
+ * The values in `id` and `additionalIds` will be transformed to a valid ID
+ * according to schema. Other values are passed on as is, including additional fields.
+ * @see Device
+ * @interface
+ */
+export type DeviceInput = {
+    id: string;
+    additionalIds?: Array<string>;
+    acceptLanguage?: string;
+    screenSize?: string;
+    userAgent?: string;
+    deviceType?: string;
+    viewportSize?: string;
+    localStorageEnabled?: boolean;
+    xEnvironmentId?: string | undefined;
+    [k: string]: unknown | undefined;
+};
+/**
+ * The schema (event-formats) representation of a Device
+ * @interface
+ */
+export type Device = {
+    '@type': 'Device';
+    environmentId: string;
+    additionalEnvironmentIds?: Array<string>;
+    acceptLanguage?: string;
+    screenSize?: string;
+    userAgent?: string;
+    deviceType?: string;
+    viewportSize?: string;
+    localStorageEnabled?: boolean;
+};
+/**
+ * Generate a device representation
+ *
+ * Several default values are used in a browser environment: acceptLanguage,
+ * screenSize, userAgent, deviceType, viewportSize, localStorageEnabled. See
+ * (device-browser.js)[device-browser.js] for implementation details.
+ *
+ * The browser implementation will also read the required values from the
+ * `_pulse2cookie` and if needed sync with CIS. Note that *this is not
+ * implemented for Node.js environments*. There are no default values in
+ * Node.js.
+ *
+ * @internal
+ */
+export declare const device: (defaultValueHandler: () => unknown) => (input?: Pick<TrackerEventInput, "device">) => Device | undefined;
+/**
+ * @internal
+ */
+export declare const defaultValue: () => {};
+/**
+ * Builder for Device objects.
+ */
+declare const _default: (input?: Pick<TrackerEventInput, "device">) => Device | undefined;
+export default _default;

package/dist/types/builders/device.d.ts

@@ -0,0 +1,2 @@
+export * from './device-node';
+export { default } from './device-node';

package/dist/types/builders/events-anonymous-browser.d.ts

@@ -0,0 +1 @@
+export { anonymousEngagementEvent, anonymousTrackerEvent } from './events-anonymous-node';

package/dist/types/builders/events-anonymous-node.d.ts

@@ -0,0 +1,82 @@
+import type { LeaveEngagement } from '../leaveTracking/types';
+import type { Consents, ConsentsInput, ConsentsLegacy } from './consents';
+import type { EventParams } from './events';
+import type { ExperimentMetadata } from './experimentMetadata';
+import type { ExperimentInput } from './experiments';
+import type { AnonymousObjectInput } from './objects/objects-anonymous-node';
+import type { OriginInput } from './origin';
+import type { ProviderInput } from './provider';
+import type { TrackerInput } from './trackerBuilder';
+export type AnonymousTrackerEventInput = {
+    type?: string;
+    consents?: Consents | ConsentsLegacy | ConsentsInput;
+    engagement?: LeaveEngagement;
+    experimentMetadata?: ExperimentMetadata;
+    experiments?: ExperimentInput[];
+    intent?: string;
+    object?: AnonymousObjectInput;
+    origin?: OriginInput;
+    pageViewId?: string;
+    provider?: ProviderInput;
+    schema?: string;
+    target?: Partial<AnonymousObjectInput>;
+    tracker?: TrackerInput;
+    isAnonymous?: true;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Add default values to AnonymousTrackerEventInput.
+ */
+declare function trackerAnonymousEventInput(eventInput?: AnonymousTrackerEventInput): AnonymousTrackerEventInput;
+export declare function anonymousTrackerEvent({ eventInput, sdkConfig }?: EventParams<AnonymousTrackerEventInput>): {
+    [k: string]: any;
+} & {
+    '@type': string;
+    schema: string;
+    consents: Consents | ConsentsLegacy | undefined;
+    experiments: import("./experiments").Experiment[] | undefined;
+    experimentMetadata: ExperimentMetadata | undefined;
+    object: Record<string, unknown> | undefined;
+    origin: {
+        '@type'?: string | undefined;
+        '@id'?: string | number | undefined;
+    } & {
+        [k: string]: unknown;
+        url?: string;
+    };
+    provider: import("./provider").Provider;
+    target: Record<string, unknown> | undefined;
+    tracker: import("./tracker-node").Tracker;
+    isAnonymous: boolean;
+};
+export declare namespace anonymousTrackerEvent {
+    var defaults: typeof trackerAnonymousEventInput;
+}
+export declare function anonymousEngagementEvent({ eventInput, sdkConfig }?: EventParams<AnonymousTrackerEventInput>): {
+    [k: string]: any;
+} & {
+    '@type': string;
+    schema: string;
+    consents: Consents | ConsentsLegacy | undefined;
+    experiments: import("./experiments").Experiment[] | undefined;
+    experimentMetadata: ExperimentMetadata | undefined;
+    object: Record<string, unknown> | undefined;
+    origin: {
+        '@type'?: string | undefined;
+        '@id'?: string | number | undefined;
+    } & {
+        [k: string]: unknown;
+        url?: string;
+    };
+    provider: import("./provider").Provider;
+    target: Record<string, unknown> | undefined;
+    tracker: import("./tracker-node").Tracker;
+    isAnonymous: boolean;
+} & {
+    schema: string;
+    '@type': string;
+};
+export declare namespace anonymousEngagementEvent {
+    var defaults: typeof trackerAnonymousEventInput;
+}
+export {};

package/dist/types/builders/events-anonymous.d.ts

@@ -0,0 +1 @@
+export * from './events-anonymous-node';

package/dist/types/builders/events-browser.d.ts

@@ -0,0 +1 @@
+export { engagementEvent, identityEvent, routableEvent, trackerEvent } from './events-node';

package/dist/types/builders/events-node.d.ts

@@ -0,0 +1,130 @@
+import type { LeaveEngagement } from '../leaveTracking/types';
+import type { SDKState } from '../Tracker';
+import type { ActorInput } from './actor';
+import type { Consents, ConsentsInput, ConsentsLegacy } from './consents';
+import type { DeviceInput } from './device';
+import type { ExperimentMetadata } from './experimentMetadata';
+import type { ExperimentInput } from './experiments';
+import type { LocationInput } from './location';
+import type { ObjectInput } from './objects/objects';
+import type { OriginInput } from './origin';
+import type { ProviderInput } from './provider';
+import type { TrackerInput } from './trackerBuilder';
+export declare const DEFAULT_SCHEMA_LOCATION = "schema.schibsted.com";
+/** */
+export type RoutableEventInput = {
+    schema?: string;
+    actor?: ActorInput;
+    provider?: ProviderInput;
+};
+type Config = Partial<Pick<SDKState, 'pageViewId' | 'schemaLocation'>>;
+export type EventParams<T> = {
+    sdkConfig?: Config;
+    eventInput?: T;
+};
+/**
+ * Default values:
+ *
+ * `type`: 'View'
+ */
+export type TrackerEventInput = {
+    type?: string;
+    actor?: ActorInput;
+    consents?: Consents | ConsentsLegacy | ConsentsInput;
+    device?: DeviceInput;
+    engagement?: LeaveEngagement;
+    experimentMetadata?: ExperimentMetadata;
+    experiments?: ExperimentInput[];
+    intent?: string;
+    location?: LocationInput;
+    object?: ObjectInput;
+    origin?: OriginInput;
+    pageViewId?: string;
+    provider?: ProviderInput;
+    schema?: string;
+    target?: Partial<ObjectInput>;
+    tracker?: TrackerInput;
+    [k: string]: unknown | undefined;
+};
+export type IdentityEventInput = Record<string, unknown>;
+declare function routableEventDefaults(eventInput?: RoutableEventInput): RoutableEventInput;
+/**
+ * Implements https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/events/base-routable-event.json
+ */
+export declare function routableEvent({ eventInput, sdkConfig }?: EventParams<RoutableEventInput>): RoutableEventInput & {
+    schema: string;
+    provider: import("./provider").Provider;
+    actor: import("./actor").Actor | undefined;
+};
+export declare namespace routableEvent {
+    var defaults: typeof routableEventDefaults;
+}
+/**
+ * Add default value to TrackerEventInput.
+ */
+declare function trackerEventInput(eventInput?: TrackerEventInput): TrackerEventInput;
+/**
+ * Implements https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/events/tracker-event.json
+ */
+export declare function trackerEvent({ eventInput, sdkConfig }?: EventParams<TrackerEventInput>): {
+    [k: string]: any;
+} & {
+    '@type': string;
+    pageViewId: string | undefined;
+    schema: string;
+    actor: import("./actor").Actor | undefined;
+    consents: Consents | ConsentsLegacy | undefined;
+    experiments: import("./experiments").Experiment[] | undefined;
+    experimentMetadata: ExperimentMetadata | undefined;
+    device: import("./device-node").Device | undefined;
+    location: import("./location").Location | undefined;
+    object: Record<string, unknown> | undefined;
+    origin: {
+        '@type'?: string | undefined;
+        '@id'?: string | number | undefined;
+    } & {
+        [k: string]: unknown;
+        url?: string;
+    };
+    provider: import("./provider").Provider;
+    target: Record<string, unknown> | undefined;
+    tracker: import("./tracker-node").Tracker;
+};
+export declare namespace trackerEvent {
+    var defaults: typeof trackerEventInput;
+}
+export declare function engagementEvent({ eventInput, sdkConfig }?: EventParams<TrackerEventInput>): {
+    [k: string]: any;
+} & {
+    '@type': string;
+    pageViewId: string | undefined;
+    schema: string;
+    actor: import("./actor").Actor | undefined;
+    consents: Consents | ConsentsLegacy | undefined;
+    experiments: import("./experiments").Experiment[] | undefined;
+    experimentMetadata: ExperimentMetadata | undefined;
+    device: import("./device-node").Device | undefined;
+    location: import("./location").Location | undefined;
+    object: Record<string, unknown> | undefined;
+    origin: {
+        '@type'?: string | undefined;
+        '@id'?: string | number | undefined;
+    } & {
+        [k: string]: unknown;
+        url?: string;
+    };
+    provider: import("./provider").Provider;
+    target: Record<string, unknown> | undefined;
+    tracker: import("./tracker-node").Tracker;
+} & {
+    schema: string;
+    '@type': string;
+};
+export declare namespace engagementEvent {
+    var defaults: typeof trackerEventInput;
+}
+export declare function identityEvent({ eventInput }?: EventParams<IdentityEventInput>): IdentityEventInput;
+export declare namespace identityEvent {
+    var defaults: () => {};
+}
+export {};

package/dist/types/builders/events.d.ts

@@ -0,0 +1 @@
+export * from './events-node';

package/dist/types/builders/experimentMetadata.d.ts

@@ -0,0 +1,25 @@
+import type { TrackerEventInput } from './events';
+/** */
+export type ExperimentError = {
+    message?: string;
+    status?: number;
+};
+/** */
+export type ExperimentMetadata = {
+    requestTimestamp?: string;
+    assignmentId?: string;
+    errors?: Array<ExperimentError>;
+    [k: string]: unknown | undefined;
+};
+/** */
+export type ExperimentMetadataInput = {
+    errors: Array<ExperimentError>;
+    assignmentId: string;
+    requestTimestamp: string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Format experiment metadata
+ */
+export default function experimentMetadata(input?: Pick<TrackerEventInput, 'experimentMetadata'>): ExperimentMetadata | undefined;
+export declare function defaultValue(): undefined;

package/dist/types/builders/experiments.d.ts

@@ -0,0 +1,24 @@
+import type { TrackerEventInput } from './events';
+/**
+ * The necessary values to construct a valid "sdrn" for experiment.
+ * Additional properties are allowed.
+ */
+export type ExperimentInput = {
+    id?: string | number;
+    platform?: string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * What is expected to be included in the output Event.
+ * Additional properties are allowed.
+ * */
+export type Experiment = {
+    '@id': string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Experiments builder
+ * @param input A full Pulse Event, from where the "experiments" property is parsed.
+ */
+export default function experiments(input?: Pick<TrackerEventInput, 'experiments'>): Experiment[] | undefined;
+export declare const defaultValue: () => undefined;

package/dist/types/builders/index.d.ts

@@ -0,0 +1,23 @@
+export type { ActorInput } from './actor';
+export * as actor from './actor';
+export type { ConsentCategory, ConsentedToPurposeInput, ConsentPurposeCategory, Consents, ConsentsInput, ConsentsOutput, } from './consents';
+export * as consents from './consents';
+export type { DeviceInput } from './device';
+export * as device from './device';
+export * as events from './events';
+export type { ExperimentMetadataInput } from './experimentMetadata';
+export * as experimentMetadata from './experimentMetadata';
+export type { ExperimentInput } from './experiments';
+export * as experiments from './experiments';
+export type { LocationInput } from './location';
+export * as location from './location';
+export type { ObjectInput } from './objects/objects';
+export * as objects from './objects/objects';
+export type { OriginInput } from './origin';
+export * as origin from './origin';
+export type { ProviderInput } from './provider';
+export * as provider from './provider';
+export type { Session } from './session';
+export { default as session } from './session';
+export type { TrackerInput } from './trackerBuilder';
+export * as tracker from './trackerBuilder';

package/dist/types/builders/location.d.ts

@@ -0,0 +1,34 @@
+import type { TrackerEventInput } from './events';
+declare const LOCATION_TYPE = "GeoCoordinates";
+/**
+ * @typedef LocationInput
+ */
+export type LocationInput = {
+    latitude?: number | string;
+    longitude?: number | string;
+    altitude?: number;
+    [k: string]: unknown | undefined;
+};
+/**
+ * @typedef Location
+ */
+export type Location = {
+    '@type': typeof LOCATION_TYPE;
+    latitude?: string;
+    longitude?: string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Create a valid Location object according to schema. Will create the
+ * required '@type' field, and reduce `latitude` and `longitude` accuracy
+ * to 3 decimal places.
+ *
+ * "altitude" is dropped from the result.
+ *
+ * Other input will be merged with the object as is.
+ *
+ * @see https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/objects/GeoCoordinates.json
+ */
+export default function location(input?: Pick<TrackerEventInput, 'location'>): Location | undefined;
+export declare function defaultValue(): undefined;
+export {};

package/dist/types/builders/objects/objects-anonymous-browser.d.ts

@@ -0,0 +1,11 @@
+export * from './objects-anonymous-node';
+export { default } from './objects-anonymous-node';
+export declare const defaultValue: () => {
+    name?: undefined;
+    url?: undefined;
+    id?: undefined;
+} | {
+    name: string;
+    url: string | undefined;
+    id: string | undefined;
+};