@croct/sdk 0.17.10 → 0.17.11

package/src/schema/tokenSchema.ts

@@ -1,42 +0,0 @@
-import {ObjectType, StringType, NumberType, UnionType, ArrayType} from '../validation';
-
-export const tokenSchema = new ObjectType({
-    required: ['headers', 'payload'],
-    properties: {
-        headers: new ObjectType({
-            required: ['typ', 'alg'],
-            properties: {
-                typ: new StringType(),
-                alg: new StringType(),
-                kid: new StringType(),
-                appId: new StringType({
-                    format: 'uuid',
-                }),
-            },
-        }),
-        payload: new ObjectType({
-            required: ['iss', 'aud', 'iat'],
-            properties: {
-                iss: new StringType(),
-                aud: new UnionType(
-                    new StringType(),
-                    new ArrayType({items: new StringType()}),
-                ),
-                iat: new NumberType({
-                    minimum: 0,
-                }),
-                sub: new StringType({
-                    minLength: 1,
-                }),
-                exp: new NumberType({
-                    minimum: 0,
-                }),
-                jti: new StringType({
-                    format: 'uuid',
-                }),
-            },
-            additionalProperties: true,
-        }),
-        signature: new StringType(),
-    },
-});

package/src/schema/userSchema.ts

@@ -1,184 +0,0 @@
-import {
-    StringType,
-    ObjectType,
-    UnionType,
-    BooleanType,
-    NullType,
-    NumberType,
-    ArrayType,
-} from '../validation';
-import {attributeNameSchema} from './attributeSchema';
-
-export const userProfileSchema = new ObjectType({
-    properties: {
-        firstName: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        lastName: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        birthDate: new StringType({
-            format: 'date',
-        }),
-        gender: new StringType({
-            enumeration: ['male', 'female', 'neutral', 'unknown'],
-        }),
-        email: new StringType({
-            minLength: 1,
-            maxLength: 254,
-        }),
-        alternateEmail: new StringType({
-            minLength: 1,
-            maxLength: 254,
-        }),
-        phone: new StringType({
-            minLength: 1,
-            maxLength: 30,
-        }),
-        alternatePhone: new StringType({
-            minLength: 1,
-            maxLength: 30,
-        }),
-        address: new ObjectType({
-            properties: {
-                street: new StringType({
-                    minLength: 1,
-                    maxLength: 100,
-                }),
-                district: new StringType({
-                    minLength: 1,
-                    maxLength: 100,
-                }),
-                city: new StringType({
-                    minLength: 1,
-                    maxLength: 100,
-                }),
-                region: new StringType({
-                    minLength: 1,
-                    maxLength: 100,
-                }),
-                country: new StringType({
-                    minLength: 1,
-                    maxLength: 100,
-                }),
-                postalCode: new StringType({
-                    minLength: 1,
-                    maxLength: 20,
-                }),
-            },
-        }),
-        avatar: new StringType({
-            maxLength: 500,
-            format: 'url',
-        }),
-        company: new StringType({
-            minLength: 1,
-            maxLength: 200,
-        }),
-        companyUrl: new StringType({
-            maxLength: 200,
-            format: 'url',
-        }),
-        jobTitle: new StringType({
-            minLength: 1,
-            maxLength: 50,
-        }),
-        interests: new ArrayType({
-            maxItems: 30,
-            items: new StringType({
-                minLength: 1,
-                maxLength: 30,
-            }),
-        }),
-        activities: new ArrayType({
-            maxItems: 30,
-            items: new StringType({
-                minLength: 1,
-                maxLength: 30,
-            }),
-        }),
-        custom: new ObjectType({
-            propertyNames: attributeNameSchema,
-            maxProperties: 10,
-            additionalProperties: new UnionType(
-                new BooleanType(),
-                new NullType(),
-                new NumberType(),
-                new StringType({
-                    maxLength: 100,
-                }),
-                new ArrayType({
-                    maxItems: 10,
-                    items: new UnionType(
-                        new BooleanType(),
-                        new NullType(),
-                        new NumberType(),
-                        new StringType({
-                            maxLength: 100,
-                        }),
-                        new ArrayType({
-                            maxItems: 10,
-                            items: new UnionType(
-                                new BooleanType(),
-                                new NullType(),
-                                new NumberType(),
-                                new StringType({
-                                    maxLength: 100,
-                                }),
-                            ),
-                        }),
-                        new ObjectType({
-                            propertyNames: attributeNameSchema,
-                            maxProperties: 10,
-                            additionalProperties: new UnionType(
-                                new BooleanType(),
-                                new NullType(),
-                                new NumberType(),
-                                new StringType({
-                                    maxLength: 100,
-                                }),
-                            ),
-                        }),
-                    ),
-                }),
-                new ObjectType({
-                    propertyNames: attributeNameSchema,
-                    maxProperties: 10,
-                    additionalProperties: new UnionType(
-                        new BooleanType(),
-                        new NullType(),
-                        new NumberType(),
-                        new StringType({
-                            maxLength: 100,
-                        }),
-                        new ArrayType({
-                            maxItems: 10,
-                            items: new UnionType(
-                                new BooleanType(),
-                                new NullType(),
-                                new NumberType(),
-                                new StringType({
-                                    maxLength: 100,
-                                }),
-                            ),
-                        }),
-                        new ObjectType({
-                            propertyNames: attributeNameSchema,
-                            maxProperties: 10,
-                            additionalProperties: new UnionType(
-                                new BooleanType(),
-                                new NullType(),
-                                new NumberType(),
-                                new StringType({
-                                    maxLength: 100,
-                                }),
-                            ),
-                        }),
-                    ),
-                }),
-            ),
-        }),
-    },
-});

package/src/sdk.ts

@@ -1,183 +0,0 @@
-import {Container, DependencyResolver} from './container';
-import {Context, TokenScope} from './context';
-import {Logger} from './logging';
-import {BASE_ENDPOINT_URL, VERSION} from './constants';
-import {sdkConfigurationSchema} from './schema';
-import {formatCause} from './error';
-import {Tracker, TrackingEventProcessor} from './tracker';
-import {Evaluator} from './evaluator';
-import {SdkEventMap} from './sdkEvents';
-import {EventManager} from './eventManager';
-import {CidAssigner} from './cid';
-import {UrlSanitizer} from './tab';
-import {ContentFetcher} from './contentFetcher';
-import {TokenStore} from './token';
-import {CookieCacheConfiguration} from './cache/cookieCache';
-
-export type Configuration = {
-    appId: string,
-    tokenScope: TokenScope,
-    debug: boolean,
-    test: boolean,
-    clientId?: string,
-    baseEndpointUrl?: string,
-    disableCidMirroring: boolean,
-    cidAssignerEndpointUrl?: string,
-    beaconQueueSize?: number,
-    urlSanitizer?: UrlSanitizer,
-    logger?: Logger,
-    eventMetadata?: {[key: string]: string},
-    cookie?: {
-        clientId?: CookieCacheConfiguration,
-        userToken?: CookieCacheConfiguration,
-        previewToken?: CookieCacheConfiguration,
-    },
-    eventProcessor?: DependencyResolver<TrackingEventProcessor>,
-    defaultFetchTimeout?: number,
-    defaultPreferredLocale?: string,
-};
-
-function validateConfiguration(configuration: unknown): asserts configuration is Configuration {
-    if (typeof configuration !== 'object' || configuration === null) {
-        throw new Error('The configuration must be a key-value map.');
-    }
-
-    try {
-        sdkConfigurationSchema.validate(configuration);
-    } catch (violation) {
-        throw new Error(`Invalid configuration: ${formatCause(violation)}`);
-    }
-}
-
-export class Sdk {
-    private container: Container;
-
-    private closed: boolean;
-
-    private constructor(container: Container) {
-        this.container = container;
-    }
-
-    public static init(configuration: Configuration): Sdk {
-        validateConfiguration(configuration);
-
-        const {
-            eventMetadata: customMetadata = {},
-            baseEndpointUrl = BASE_ENDPOINT_URL,
-            cidAssignerEndpointUrl,
-            ...containerConfiguration
-        } = configuration;
-
-        const eventMetadata: {[key: string]: string} = {
-            sdkVersion: VERSION,
-        };
-
-        for (const metadata of Object.keys(customMetadata)) {
-            eventMetadata[`custom_${metadata}`] = customMetadata[metadata];
-        }
-
-        const baseHttpEndpoint = baseEndpointUrl.replace(/\/+$/, '');
-
-        const container = new Container({
-            ...containerConfiguration,
-            evaluationBaseEndpointUrl: baseHttpEndpoint,
-            contentBaseEndpointUrl: baseHttpEndpoint,
-            trackerEndpointUrl: `${baseHttpEndpoint}/client/web/track`,
-            cidAssignerEndpointUrl: cidAssignerEndpointUrl ?? `${baseHttpEndpoint}/client/web/cid`,
-            beaconQueueSize: containerConfiguration.beaconQueueSize ?? 100,
-            eventMetadata: eventMetadata,
-        });
-
-        const logger = container.getLogger();
-        const {appId, tokenScope} = container.getConfiguration();
-
-        logger.debug(
-            '\n\n'
-            + ' ██████ ██████   ██████   ██████ ████████ \n'
-            + '██      ██   ██ ██    ██ ██         ██    \n'
-            + '██      ██████  ██    ██ ██         ██    \n'
-            + '██      ██   ██ ██    ██ ██         ██    \n'
-            + ' ██████ ██   ██  ██████   ██████    ██    \n'
-            + '\n',
-        );
-
-        logger.info(`Initializing SDK v${VERSION}...`);
-        logger.debug(`App ID: ${appId}`);
-
-        const context = container.getContext();
-        const tab = context.getTab();
-        const user = context.getUser();
-
-        logger.debug(`${tab.isNew ? 'New' : 'Current'} tab: ${tab.id}`);
-        logger.debug(`Token scope: ${tokenScope}`);
-        logger.debug(`Current user: ${user !== null ? user : 'anonymous'}`);
-        logger.debug(`Test mode: ${containerConfiguration.test}`);
-        logger.info('⚡ Croct SDK is ready!');
-
-        return new Sdk(container);
-    }
-
-    public get appId(): string {
-        const {appId} = this.container.getConfiguration();
-
-        return appId;
-    }
-
-    public get cidAssigner(): CidAssigner {
-        return this.container.getCidAssigner();
-    }
-
-    public get previewTokenStore(): TokenStore {
-        return this.container.getPreviewTokenStore();
-    }
-
-    public get userTokenStore(): TokenStore {
-        return this.container.getUserTokenStore();
-    }
-
-    public get context(): Context {
-        return this.container.getContext();
-    }
-
-    public get tracker(): Tracker {
-        return this.container.getTracker();
-    }
-
-    public get evaluator(): Evaluator {
-        return this.container.getEvaluator();
-    }
-
-    public get contentFetcher(): ContentFetcher {
-        return this.container.getContentFetcher();
-    }
-
-    public get eventManager(): EventManager<SdkEventMap> {
-        return this.container.getEventManager();
-    }
-
-    public getLogger(...namespace: string[]): Logger {
-        return this.container.getLogger(...namespace);
-    }
-
-    public getTabStorage(namespace: string, ...subnamespace: string[]): Storage {
-        return this.container.getTabStorage(namespace, ...subnamespace);
-    }
-
-    public getBrowserStorage(namespace: string, ...subnamespace: string[]): Storage {
-        return this.container.getBrowserStorage(namespace, ...subnamespace);
-    }
-
-    public async close(): Promise<void> {
-        if (this.closed) {
-            return;
-        }
-
-        const logger = this.getLogger();
-
-        logger.debug('Closing SDK...');
-        this.closed = true;
-        await this.container.dispose();
-
-        logger.info('SDK closed.');
-    }
-}

package/src/sdkEvents.ts

@@ -1,15 +0,0 @@
-import {Token} from './token';
-
-export interface TokenChanged {
-    oldToken: Token|null;
-    newToken: Token|null;
-}
-
-export type SdkEventMap = Record<string, Record<string, unknown>> & {
-    tokenChanged: TokenChanged,
-};
-
-export type SdkEventType = keyof SdkEventMap;
-
-export type SdkEvent<T extends SdkEventType = SdkEventType> =
-    T extends SdkEventType ? SdkEventMap[T] : SdkEventMap[SdkEventType];

package/src/sourceLocation.ts

@@ -1,85 +0,0 @@
-export type Position = {
-    line: number,
-    column: number,
-    index: number,
-};
-
-export type Location = {
-    start: Position,
-    end: Position,
-};
-
-export function getLength(input: string): number {
-    return [...input].length;
-}
-
-export function getLocation(input: string, startIndex: number, endIndex: number): Location {
-    if (startIndex < 0) {
-        throw Error('The start index cannot be negative.');
-    }
-
-    if (endIndex < startIndex) {
-        throw new Error('The end index must greater than or equal to the start index.');
-    }
-
-    let start: Position | undefined;
-    let end: Position | undefined;
-
-    const chars = [...input];
-    let line = 1;
-    let column = 0;
-
-    for (let offset = 0; offset < chars.length; offset++) {
-        const char = chars[offset];
-
-        if (offset === startIndex) {
-            start = {
-                index: offset,
-                line: line,
-                column: column,
-            };
-        }
-
-        if (offset === endIndex) {
-            end = {
-                index: offset,
-                line: line,
-                column: column,
-            };
-
-            break;
-        }
-
-        if (char === '\n') {
-            line += 1;
-            column = 0;
-        } else {
-            column += 1;
-        }
-    }
-
-    if (start === undefined) {
-        start = {
-            index: chars.length,
-            line: line,
-            column: column,
-        };
-    }
-
-    if (end === undefined) {
-        end = {
-            index: chars.length,
-            line: line,
-            column: column,
-        };
-    }
-
-    return {
-        start: start,
-        end: end,
-    };
-}
-
-export function getPosition(input: string, index: number): Position {
-    return getLocation(input, index, index).start;
-}

package/src/tab.ts

@@ -1,148 +0,0 @@
-import {SynchronousEventManager, EventListener} from './eventManager';
-
-export type TabEvent<T = Record<string, unknown>> = CustomEvent<{tab: Tab} & T>;
-export type TabVisibilityChangeEvent = TabEvent<{visible: boolean}>;
-export type TabUrlChangeEvent = TabEvent<{url: string}>;
-
-export type UrlSanitizer = (url: string) => URL;
-
-type TabEventMap = {
-    focus: TabEvent,
-    blur: TabEvent,
-    load: TabEvent,
-    unload: TabEvent,
-    visibilityChange: TabVisibilityChangeEvent,
-    urlChange: TabUrlChangeEvent,
-};
-
-const EventMap: {[key: string]: keyof TabEventMap} = {
-    focus: 'focus',
-    blur: 'blur',
-    beforeunload: 'unload',
-    DOMContentLoaded: 'load',
-    visibilitychange: 'visibilityChange',
-};
-
-export class Tab {
-    public readonly id: string;
-
-    public readonly isNew: boolean;
-
-    public readonly urlSanitizer?: UrlSanitizer;
-
-    private readonly eventManager = new SynchronousEventManager<TabEventMap>();
-
-    public constructor(id: string, isNew: boolean, urlSanitizer?: UrlSanitizer) {
-        this.id = id;
-        this.isNew = isNew;
-        this.urlSanitizer = urlSanitizer;
-
-        this.initialize();
-    }
-
-    private initialize(): void {
-        const listener = (event: Event): void => {
-            this.emit(EventMap[event.type], new CustomEvent(EventMap[event.type], {detail: {tab: this}}));
-        };
-
-        window.addEventListener('focus', listener, true);
-        window.addEventListener('blur', listener, true);
-        window.addEventListener('beforeunload', listener, true);
-        window.addEventListener('DOMContentLoaded', listener, true);
-
-        document.addEventListener(
-            'visibilitychange',
-            () => {
-                this.emit('visibilityChange', new CustomEvent('visibilityChange', {
-                    detail: {
-                        tab: this,
-                        visible: this.isVisible,
-                    },
-                }));
-            },
-            true,
-        );
-
-        Tab.addUrlChangeListener(url => {
-            this.emit('urlChange', new CustomEvent('urlChange', {detail: {tab: this, url: this.sanitizeUrl(url)}}));
-        });
-    }
-
-    public get url(): string {
-        return this.sanitizeUrl(window.location.href);
-    }
-
-    public get title(): string {
-        return document.title;
-    }
-
-    public get referrer(): string {
-        return document.referrer === '' ? '' : this.sanitizeUrl(document.referrer);
-    }
-
-    public get isVisible(): boolean {
-        return document.visibilityState === 'visible';
-    }
-
-    public get document(): Document {
-        return document;
-    }
-
-    public addListener<T extends keyof TabEventMap>(type: T, listener: EventListener<TabEventMap[T]>): void {
-        this.eventManager.addListener(type, listener);
-    }
-
-    public removeListener<T extends keyof TabEventMap>(type: T, listener: EventListener<TabEventMap[T]>): void {
-        this.eventManager.removeListener(type, listener);
-    }
-
-    private sanitizeUrl(url: string): string {
-        const normalized = window.encodeURI(window.decodeURI(url));
-
-        if (this.urlSanitizer !== undefined) {
-            return this.urlSanitizer(normalized).toString();
-        }
-
-        return normalized;
-    }
-
-    private emit<T extends keyof TabEventMap>(type: T, event: TabEventMap[T]): void {
-        this.eventManager.dispatch(type, event);
-    }
-
-    private static addUrlChangeListener(listener: {(url: string): void}): void {
-        let url = window.location.href;
-
-        const updateUrl = (): void => {
-            const currentUrl = window.location.href;
-
-            if (url !== currentUrl) {
-                listener(currentUrl);
-
-                url = currentUrl;
-            }
-        };
-
-        const {pushState} = window.history;
-
-        window.history.pushState = function interceptPushState(...args): any {
-            const result = pushState.apply(window.history, args);
-
-            updateUrl();
-
-            return result;
-        };
-
-        const {replaceState} = window.history;
-
-        window.history.replaceState = function interceptReplaceState(...args): any {
-            const result = replaceState.apply(window.history, args);
-
-            updateUrl();
-
-            return result;
-        };
-
-        window.addEventListener('popstate', updateUrl, true);
-    }
-}

package/src/token/cachedTokenStore.ts

@@ -1,34 +0,0 @@
-import {Token, TokenStore} from './token';
-import {Cache} from '../cache';
-
-export class CachedTokenStore implements TokenStore {
-    private readonly cache: Cache;
-
-    public constructor(cache: Cache) {
-        this.cache = cache;
-    }
-
-    public getToken(): Token | null {
-        const data: string | null = this.cache.get();
-
-        if (data === null) {
-            return null;
-        }
-
-        try {
-            return Token.parse(data);
-        } catch (error) {
-            return null;
-        }
-    }
-
-    public setToken(token: Token | null): void {
-        if (token === null) {
-            this.cache.clear();
-
-            return;
-        }
-
-        this.cache.put(token.toString());
-    }
-}

package/src/token/inMemoryTokenStore.ts

@@ -1,13 +0,0 @@
-import {Token, TokenStore} from './token';
-
-export class InMemoryTokenStore implements TokenStore {
-    private token: Token | null = null;
-
-    public getToken(): Token | null {
-        return this.token;
-    }
-
-    public setToken(token: Token | null): void {
-        this.token = token;
-    }
-}