@nascentdigital/funnel-services 4.4.18

package/dist/consent/CookieConsent.js

@@ -0,0 +1,161 @@
+'use client';
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieConsent = CookieConsent;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+const rxjs_1 = require("rxjs");
+const Consent = __importStar(require("vanilla-cookieconsent"));
+const ip_1 = require("../ip");
+// components
+function CookieConsent({ consentAction, copy }) {
+    // bind hooks
+    const ip = (0, ip_1.useIpAddress)();
+    const language = (0, client_1.useLanguage)();
+    // bind consent plugin
+    (0, react_1.useEffect)(() => {
+        // skip if ip isn't resolved
+        if (ip === undefined) {
+            return;
+        }
+        // mount
+        const mount = async () => {
+            console.debug('[CookieConsent] mounting plugin');
+            await Consent.run(createConsentConfig({ ip, consentAction, copy, language }));
+        };
+        mount().catch(console.error);
+    }, [ip, consentAction, copy, language]);
+    // helpers
+    const onShowDialog = () => {
+        Consent.show(true);
+    };
+    // render
+    return ((0, jsx_runtime_1.jsx)("div", { children: (0, jsx_runtime_1.jsx)("button", { onClick: onShowDialog, children: copy.cta }) }));
+}
+// extension
+const _consentState$ = new rxjs_1.BehaviorSubject(undefined);
+(function (CookieConsent) {
+    // methods
+    function state$() {
+        return _consentState$
+            .pipe((0, rxjs_1.filter)(funnel_core_1.Value.isDefined));
+    }
+    CookieConsent.state$ = state$;
+})(CookieConsent || (exports.CookieConsent = CookieConsent = {}));
+function createConsentConfig({ ip, consentAction, copy, language }) {
+    const syncConsent = async (log) => {
+        console.debug('[CookieConsent] syncing consent');
+        // update global state
+        const preferences = Consent.getUserPreferences();
+        const state = {
+            categories: [
+                ...preferences.acceptedCategories.map(category => ({
+                    category: category,
+                    accepted: true
+                })),
+                ...preferences.rejectedCategories.map(category => ({
+                    category: category,
+                    accepted: false
+                }))
+            ],
+            services: [
+                ...Object.entries(preferences.acceptedServices)
+                    .flatMap(([category, services]) => services.map(service => ({
+                    category: category,
+                    service: service,
+                    accepted: true
+                }))),
+                ...Object.entries(preferences.rejectedServices)
+                    .flatMap(([category, services]) => services.map(service => ({
+                    category: category,
+                    service: service,
+                    accepted: false
+                })))
+            ]
+        };
+        _consentState$.next(state);
+        // log (if required)
+        if (log) {
+            await logConsent(preferences, state);
+        }
+    };
+    const logConsent = async (preferences, state) => {
+        // create consent payload
+        const cookie = Consent.getCookie();
+        const consent = Object.assign({ ip: ip !== null && ip !== void 0 ? ip : undefined, url: window.location.href, userId: cookie.consentId, choice: preferences.acceptType }, state);
+        // submit consent
+        try {
+            console.debug('[CookieConsent] updating consent', consent);
+            await consentAction(consent);
+            console.debug('[CookieConsent] consent captured');
+        }
+        catch (e) {
+            console.error('[CookieConsent] failed to capture consent', e);
+        }
+    };
+    // return configuration
+    return {
+        // bind categories
+        categories: funnel_core_1.ConsentCategory.values.reduce((categories, category) => {
+            // setup services
+            const services = funnel_core_1.ConsentService.groupedValues[category].reduce((services, service) => {
+                // bind service
+                services[service] = {};
+                // keep reducing
+                return services;
+            }, {});
+            // bind category
+            categories[category] = category === 'necessary'
+                ? { enabled: true, readOnly: true, services }
+                : { services };
+            // keep reducing
+            return categories;
+        }, {}),
+        // callbacks
+        onFirstConsent: () => syncConsent(true),
+        onConsent: () => syncConsent(false),
+        onChange: () => syncConsent(true),
+        // copy
+        language: {
+            default: language,
+            translations: {
+                [language]: copy
+            }
+        }
+    };
+}

package/dist/consent/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CookieConsent';
+export * from './ConsentData';

package/dist/consent/index.js

@@ -0,0 +1,18 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CookieConsent"), exports);
+__exportStar(require("./ConsentData"), exports);

package/dist/identity/actions.d.ts

@@ -0,0 +1,4 @@
+import { Profile } from './api';
+export declare namespace IdentityActions {
+    function setProfileData(key: string, value: unknown): Promise<Readonly<Profile.Data>>;
+}

package/dist/identity/actions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityActions = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const api_1 = require("./api");
+// actions
+var IdentityActions;
+(function (IdentityActions) {
+    async function setProfileData(key, value) {
+        'use server';
+        // get current profile
+        const profile = await api_1.ProfileService.get().current();
+        if (!profile) {
+            throw new funnel_core_1.IllegalStateError('Cannot get current profile');
+        }
+        // update profile
+        await profile.set(key, value);
+        // return latest profile data
+        return profile.data;
+    }
+    IdentityActions.setProfileData = setProfileData;
+})(IdentityActions || (exports.IdentityActions = IdentityActions = {}));

package/dist/identity/api/Identity.d.ts

@@ -0,0 +1,11 @@
+import { Tagged } from 'type-fest';
+export interface Identity {
+    id: Identity.Id;
+    level: Identity.Level;
+    name?: string;
+    email?: string;
+}
+export declare namespace Identity {
+    type Id = Tagged<string, 'funnel.Identity.Id'>;
+    type Level = 'unidentified' | 'identified' | 'authenticated' | 'verified';
+}

package/dist/identity/api/Identity.js

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

package/dist/identity/api/IdentityService.d.ts

@@ -0,0 +1,9 @@
+import type { Identity } from './Identity';
+export interface IdentityService {
+    current(): Promise<Identity | undefined>;
+}
+export declare namespace IdentityService {
+    function tryGet(): IdentityService | undefined;
+    function get(): IdentityService;
+    function set(identityService: IdentityService): void;
+}

package/dist/identity/api/IdentityService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityService = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var IdentityService;
+(function (IdentityService) {
+    function tryGet() {
+        return _identityService;
+    }
+    IdentityService.tryGet = tryGet;
+    function get() {
+        // throw if not set
+        if (!_identityService) {
+            throw new funnel_core_1.IllegalStateError('Attempt to access Identity service before first call to IdentityService.set()');
+        }
+        // return
+        return _identityService;
+    }
+    IdentityService.get = get;
+    function set(identityService) {
+        _identityService = identityService;
+    }
+    IdentityService.set = set;
+})(IdentityService || (exports.IdentityService = IdentityService = {}));
+// storage
+let _identityService = undefined;

package/dist/identity/api/Profile.d.ts

@@ -0,0 +1,10 @@
+import type { Identity } from './Identity';
+export interface Profile extends Identity {
+    data: Readonly<Profile.Data>;
+    get<TValue>(key: string): TValue;
+    set<TValue>(key: string, value: TValue): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare namespace Profile {
+    type Data = Record<string, unknown>;
+}

package/dist/identity/api/Profile.js

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

package/dist/identity/api/ProfileService.d.ts

@@ -0,0 +1,12 @@
+import type { Identity } from './Identity';
+import type { Profile } from './Profile';
+export interface ProfileService {
+    current(): Promise<Profile | undefined>;
+    all(): Promise<Profile[]>;
+    get(id: Identity.Id): Promise<Profile>;
+}
+export declare namespace ProfileService {
+    function tryGet(): ProfileService | undefined;
+    function get(): ProfileService;
+    function set(profileService: ProfileService): void;
+}

package/dist/identity/api/ProfileService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileService = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// extension
+var ProfileService;
+(function (ProfileService) {
+    function tryGet() {
+        return _profileService;
+    }
+    ProfileService.tryGet = tryGet;
+    function get() {
+        // throw if not set
+        if (!_profileService) {
+            throw new funnel_core_1.IllegalStateError('Attempt to access Profile service before first call to ProfileService.set()');
+        }
+        // return
+        return _profileService;
+    }
+    ProfileService.get = get;
+    function set(profileService) {
+        _profileService = profileService;
+    }
+    ProfileService.set = set;
+})(ProfileService || (exports.ProfileService = ProfileService = {}));
+// storage
+let _profileService = undefined;

package/dist/identity/api/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Identity';
+export * from './IdentityService';
+export * from './Profile';
+export * from './ProfileService';

package/dist/identity/api/index.js

@@ -0,0 +1,20 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Identity"), exports);
+__exportStar(require("./IdentityService"), exports);
+__exportStar(require("./Profile"), exports);
+__exportStar(require("./ProfileService"), exports);

package/dist/identity/auth0/Auth0IdentityService.d.ts

@@ -0,0 +1,9 @@
+import { Identity, IdentityService } from '../api';
+export declare class Auth0IdentityService implements IdentityService {
+    private _client;
+    constructor(args: Auth0IdentityService.ConstructorArgs);
+    current(): Promise<Identity | undefined>;
+}
+export declare namespace Auth0IdentityService {
+    type ConstructorArgs = {};
+}

package/dist/identity/auth0/Auth0IdentityService.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0IdentityService = void 0;
+const server_1 = require("@auth0/nextjs-auth0/server");
+// service
+class Auth0IdentityService {
+    constructor(args) {
+        this._client = new server_1.Auth0Client();
+    }
+    async current() {
+        // get current session
+        const session = await this._client.getSession();
+        // bail if no session or user
+        if (!session || !session.user) {
+            return undefined;
+        }
+        // return identity
+        const { user } = session;
+        return {
+            id: user.sub,
+            level: 'authenticated',
+            name: user.name,
+            email: user.email
+        };
+    }
+}
+exports.Auth0IdentityService = Auth0IdentityService;

package/dist/identity/auth0/Auth0Profile.d.ts

@@ -0,0 +1,30 @@
+import { ManagementClient } from 'auth0';
+import { Identity, Profile } from '../api';
+export declare class Auth0Profile implements Profile {
+    readonly brand: string;
+    readonly id: Identity.Id;
+    readonly level: Identity.Level;
+    readonly name?: string;
+    readonly email?: string;
+    private _data;
+    private readonly _managementClient;
+    constructor(args: Auth0Profile.ConstructorArgs);
+    get data(): Readonly<Profile.Data>;
+    private get dataKeyPrefix();
+    get<TValue>(key: string): TValue;
+    set<TValue>(key: string, value: TValue): Promise<void>;
+    delete(key: string): Promise<void>;
+    private brandDataKey;
+    private profileDataForBrand;
+}
+export declare namespace Auth0Profile {
+    type ConstructorArgs = {
+        brand: string;
+        id: Identity.Id;
+        level: Identity.Level;
+        name?: string;
+        email?: string;
+        data?: Profile.Data;
+        managementClient: ManagementClient;
+    };
+}

package/dist/identity/auth0/Auth0Profile.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0Profile = void 0;
+// class
+class Auth0Profile {
+    constructor(args) {
+        this.brand = args.brand;
+        this.id = args.id;
+        this.level = args.level;
+        this.name = args.name;
+        this.email = args.email;
+        this._data = this.profileDataForBrand(args.data);
+        this._managementClient = args.managementClient;
+    }
+    get data() {
+        return this._data;
+    }
+    get dataKeyPrefix() {
+        return `nd-${this.brand}-`;
+    }
+    get(key) {
+        // create branded key
+        const brandedKey = this.brandDataKey(key);
+        // return value
+        return this._data[brandedKey];
+    }
+    async set(key, value) {
+        // create branded key
+        const brandedKey = this.brandDataKey(key);
+        // update user's metadata
+        const result = await this._managementClient.users.update(this.id, {
+            app_metadata: { [brandedKey]: value }
+        });
+        // update local state
+        this._data = this.profileDataForBrand(result.app_metadata);
+    }
+    async delete(key) {
+        // set value to null to delete
+        await this.set(key, null);
+    }
+    brandDataKey(key) {
+        return `${this.dataKeyPrefix}${key}`;
+    }
+    profileDataForBrand(data) {
+        // return empty object if nothing
+        if (!data) {
+            return {};
+        }
+        // get key prefix to filter properties
+        const keyPrefix = this.dataKeyPrefix;
+        // return new object with only properties that start with prefix
+        return Object.fromEntries(Object.entries(data)
+            .filter(([key]) => key.startsWith(keyPrefix))
+            .map(([key, value]) => [key.slice(keyPrefix.length), value]));
+    }
+}
+exports.Auth0Profile = Auth0Profile;

package/dist/identity/auth0/Auth0ProfileService.d.ts

@@ -0,0 +1,21 @@
+import { ManagementClient } from 'auth0';
+import { AsyncReturnType } from 'type-fest';
+import { Identity, Profile, ProfileService } from '../api';
+export declare class Auth0ProfileService implements ProfileService {
+    readonly brand: string;
+    private readonly _managementClient;
+    constructor(args: Auth0ProfileService.ConstructorArgs);
+    current(): Promise<Profile | undefined>;
+    all(): Promise<Profile[]>;
+    get(id: Identity.Id): Promise<Profile>;
+}
+export declare namespace Auth0ProfileService {
+    type ConstructorArgs = {
+        brand: string;
+        domain: string;
+        clientId: string;
+        clientSecret: string;
+    };
+    type Auth0UserData = AsyncReturnType<ManagementClient['users']['get']>;
+    function getLevel(data: Auth0UserData): Identity.Level;
+}

package/dist/identity/auth0/Auth0ProfileService.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0ProfileService = void 0;
+const auth0_1 = require("auth0");
+const api_1 = require("../api");
+const Auth0Profile_1 = require("./Auth0Profile");
+// service
+class Auth0ProfileService {
+    constructor(args) {
+        // set instance variables
+        this.brand = args.brand;
+        this._managementClient = new auth0_1.ManagementClient({
+            domain: args.domain,
+            clientId: args.clientId,
+            clientSecret: args.clientSecret
+        });
+    }
+    async current() {
+        // get current identity if any
+        const identity = await api_1.IdentityService.get().current();
+        // bail if there is no identity
+        if (!identity) {
+            return undefined;
+        }
+        // get profile based on identity
+        return this.get(identity.id);
+    }
+    async all() {
+        // get first page
+        // FIXME: handle pagination
+        const page = await this._managementClient.users.list({
+            per_page: 100
+        });
+        // create profile instances
+        return page.data.map(user => new Auth0Profile_1.Auth0Profile({
+            brand: this.brand,
+            id: user.user_id,
+            level: Auth0ProfileService.getLevel(user),
+            name: user.name,
+            email: user.email,
+            data: user.app_metadata,
+            managementClient: this._managementClient
+        }));
+    }
+    async get(id) {
+        // fetch user by id
+        const user = await this._managementClient.users.get(id);
+        // create new profile
+        return new Auth0Profile_1.Auth0Profile({
+            brand: this.brand,
+            id,
+            level: Auth0ProfileService.getLevel(user),
+            name: user.name,
+            email: user.email,
+            data: user.app_metadata,
+            managementClient: this._managementClient
+        });
+    }
+}
+exports.Auth0ProfileService = Auth0ProfileService;
+// extension
+(function (Auth0ProfileService) {
+    function getLevel(data) {
+        return data.email_verified || data.phone_verified
+            ? 'verified'
+            : 'authenticated';
+    }
+    Auth0ProfileService.getLevel = getLevel;
+})(Auth0ProfileService || (exports.Auth0ProfileService = Auth0ProfileService = {}));

package/dist/identity/auth0/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Auth0IdentityService';
+export * from './Auth0ProfileService';

package/dist/identity/auth0/index.js

@@ -0,0 +1,18 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Auth0IdentityService"), exports);
+__exportStar(require("./Auth0ProfileService"), exports);

package/dist/identity/client/ClientProfile.d.ts

@@ -0,0 +1,27 @@
+import { Identity, Profile } from '../api';
+export declare class ClientProfile implements Profile {
+    readonly brand: string;
+    readonly id: Identity.Id;
+    readonly level: Identity.Level;
+    readonly name?: string;
+    readonly email?: string;
+    private _data;
+    private readonly _onSetProfileData;
+    constructor(args: ClientProfile.ConstructorArgs);
+    get data(): Readonly<Profile.Data>;
+    get<TValue>(key: string): TValue;
+    set<TValue>(key: string, value: TValue): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare namespace ClientProfile {
+    type ConstructorArgs = {
+        brand: string;
+        id: Identity.Id;
+        level: Identity.Level;
+        name?: string;
+        email?: string;
+        data?: Profile.Data;
+        onSetProfileData: SetProfileDataMethod;
+    };
+    type SetProfileDataMethod = (key: string, value: unknown) => Promise<Readonly<Profile.Data>>;
+}

package/dist/identity/client/ClientProfile.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientProfile = void 0;
+// class
+class ClientProfile {
+    constructor(args) {
+        var _a;
+        this.brand = args.brand;
+        this.id = args.id;
+        this.level = args.level;
+        this.name = args.name;
+        this.email = args.email;
+        this._data = (_a = args.data) !== null && _a !== void 0 ? _a : {};
+        this._onSetProfileData = args.onSetProfileData;
+    }
+    get data() {
+        return this._data;
+    }
+    get(key) {
+        return this._data[key];
+    }
+    async set(key, value) {
+        // update profile and update data
+        this._data = await this._onSetProfileData(key, value);
+    }
+    async delete(key) {
+        // set value to null to delete
+        await this.set(key, null);
+    }
+}
+exports.ClientProfile = ClientProfile;

package/dist/identity/client/IdentityContainer.d.ts

@@ -0,0 +1,12 @@
+import { PropsWithChildren } from 'react';
+import { Identity, Profile } from '../api';
+import { ClientProfile } from './ClientProfile';
+export declare function IdentityContainer({ brand, identity, profileData, onSetProfileData, children }: IdentityContainer.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace IdentityContainer {
+    type Props = PropsWithChildren & {
+        brand: string;
+        identity?: Identity;
+        profileData?: Profile.Data;
+        onSetProfileData: ClientProfile.SetProfileDataMethod;
+    };
+}