@nascentdigital/funnel-apps 4.4.18

package/dist/react/app/web/AppPage.d.ts

@@ -0,0 +1,13 @@
+import { Transform } from '@nascentdigital/funnel-core';
+import { GetServerSideProps, GetServerSidePropsContext } from 'next';
+import { FunctionComponent, PropsWithChildren } from 'react';
+import { JsonObject } from 'type-fest';
+export declare namespace AppPage {
+    type RenderProps<TData extends JsonObject = {}> = PropsWithChildren & {
+        data: TData;
+    };
+    function authenticated<TData extends JsonObject = {}>(Page: FunctionComponent<RenderProps<TData>>, fetchData?: Transform<GetServerSidePropsContext, TData> | Transform.Async<GetServerSidePropsContext, TData>): {
+        Component: (props: RenderProps<TData>) => import("react/jsx-runtime").JSX.Element;
+        getServerSideProps: GetServerSideProps<RenderProps<TData>>;
+    };
+}

package/dist/react/app/web/AppPage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppPage = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// namespace
+var AppPage;
+(function (AppPage) {
+    // authenticate page
+    function authenticated(Page, fetchData) {
+        // component
+        const Component = (props) => {
+            // render
+            return ((0, jsx_runtime_1.jsx)(Page, Object.assign({}, props)));
+        };
+        // data fetching
+        const getServerSideProps = async (context) => {
+            // access the user session if needed
+            const data = fetchData
+                ? await fetchData(context)
+                : {};
+            // return props
+            return {
+                props: { data }
+            };
+        };
+        // return props
+        return { Component, getServerSideProps };
+    }
+    AppPage.authenticated = authenticated;
+})(AppPage || (exports.AppPage = AppPage = {}));

package/dist/react/app/web/AppRoot.d.ts

@@ -0,0 +1,7 @@
+import type { AppProps } from 'next/app';
+import { BridgeState } from '../../bridge/core';
+import { AppLayout } from './AppLayout';
+export declare namespace AppRoot {
+    type CreateProps<TCustom extends BridgeState.Custom = BridgeState.Custom> = Omit<AppLayout.Props<TCustom>, 'children'>;
+    function create({ SplashScreen, LoginScreen, ErrorScreen, ...bridgeProps }: CreateProps): <TState extends BridgeState = BridgeState>({ Component, pageProps }: AppProps<TState>) => import("react/jsx-runtime").JSX.Element;
+}

package/dist/react/app/web/AppRoot.js

@@ -0,0 +1,43 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppRoot = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("motion/react");
+const router_1 = require("next/router");
+const AppLayout_1 = require("./AppLayout");
+// namespace
+var AppRoot;
+(function (AppRoot) {
+    function create(_a) {
+        var { SplashScreen, LoginScreen, ErrorScreen } = _a, bridgeProps = __rest(_a, ["SplashScreen", "LoginScreen", "ErrorScreen"]);
+        // create component
+        return function ({ Component, pageProps }) {
+            // bind hooks
+            const router = (0, router_1.useRouter)();
+            // render editor layout
+            if (router.pathname === '/editor/[[...path]]') {
+                return ((0, jsx_runtime_1.jsx)(Component, Object.assign({}, pageProps)));
+            }
+            // or app layout
+            else {
+                return ((0, jsx_runtime_1.jsx)(AppLayout_1.AppLayout, Object.assign({ SplashScreen: SplashScreen, LoginScreen: LoginScreen, ErrorScreen: ErrorScreen }, bridgeProps, { children: (0, jsx_runtime_1.jsx)("div", { className: "max-w-dvw min-h-dvh overflow-x-hidden select-none", children: (0, jsx_runtime_1.jsx)(react_1.AnimatePresence, { mode: "wait", children: (0, jsx_runtime_1.jsx)(react_1.motion.div, { className: "will-change-[opacity,filter]", initial: "initial", animate: "animate", exit: "exit", variants: {
+                                    initial: { opacity: 0, filter: 'blur(3px)' },
+                                    animate: { opacity: 1, filter: 'blur(0px)' },
+                                    exit: { opacity: 0, filter: 'blur(3px)' }
+                                }, transition: { duration: 0.2 }, children: (0, jsx_runtime_1.jsx)(Component, Object.assign({}, pageProps)) }, router.pathname) }) }) })));
+            }
+        };
+    }
+    AppRoot.create = create;
+})(AppRoot || (exports.AppRoot = AppRoot = {}));

package/dist/react/app/web/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../domain';
+export * from './App';
+export * from './AppPage';
+export * from './AppRoot';
+export * from './useApp';

package/dist/react/app/web/index.js

@@ -0,0 +1,21 @@
+"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("../domain"), exports);
+__exportStar(require("./App"), exports);
+__exportStar(require("./AppPage"), exports);
+__exportStar(require("./AppRoot"), exports);
+__exportStar(require("./useApp"), exports);

package/dist/react/app/web/useApp.d.ts

@@ -0,0 +1,2 @@
+import { App } from './App';
+export declare function useApp(maybeApp?: App): App;

package/dist/react/app/web/useApp.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useApp = useApp;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const AppContext_1 = require("./AppContext");
+// hook
+function useApp(maybeApp) {
+    // bind memos + hooks
+    const context = (0, react_1.useContext)(AppContext_1.AppContext);
+    const app = maybeApp !== null && maybeApp !== void 0 ? maybeApp : context.app;
+    const touch = (0, hooks_1.useTouch)();
+    // bind worker
+    (0, react_1.useEffect)(() => {
+        // skip if there's no app
+        if (!app) {
+            return;
+        }
+        // bind app
+        const subscriptions = [
+            app.state$.subscribe(() => touch())
+        ];
+        // clear subscription on unmount
+        return () => subscriptions.forEach(subscription => subscription.unsubscribe());
+    }, [app, touch]);
+    // blow up if there's no app
+    if (!app) {
+        throw new funnel_core_1.InvalidOperationError('Cannot access useApp() outside of AppContainer scope');
+    }
+    // return app
+    return app;
+}

package/dist/react/auth0/server/Auth0IdentityService.d.ts

@@ -0,0 +1,25 @@
+import { NextRequest } from 'next/server';
+import { AuthenticatedIdentity, Identity, IdentityService } from '../../identity/server';
+export declare class Auth0IdentityService implements IdentityService {
+    private readonly _domain;
+    private readonly _audience;
+    private readonly _issuer;
+    private readonly _managementClient;
+    constructor(args: Auth0IdentityService.ConstructorArgs);
+    current(request: NextRequest): Promise<Identity>;
+    deleteIdentity(identity: AuthenticatedIdentity): Promise<void>;
+    /**
+     * Verify request using the "Authorization" header
+     * @param request The request to verify
+     * @throws NotAuthenticatedError Missing header or request could not be authorized
+     */
+    private verifyRequest;
+}
+export declare namespace Auth0IdentityService {
+    type ConstructorArgs = {
+        domain: string;
+        audience: string;
+        clientId: string;
+        clientSecret: string;
+    };
+}

package/dist/react/auth0/server/Auth0IdentityService.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0IdentityService = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const auth0_1 = require("auth0");
+const jose_1 = require("jose");
+const server_1 = require("../../identity/server");
+// service
+class Auth0IdentityService {
+    constructor(args) {
+        this._domain = args.domain;
+        this._audience = args.audience;
+        this._issuer = `https://${this._domain}/`;
+        this._managementClient = new auth0_1.ManagementClient({
+            domain: args.domain,
+            clientId: args.clientId,
+            clientSecret: args.clientSecret
+        });
+    }
+    async current(request) {
+        // try to create identity
+        try {
+            // verify jtw from request
+            const payload = await this.verifyRequest(request);
+            // return anonymous identity (if no id)
+            if (!payload.sub) {
+                console.warn('[Auth0IdentityService] JWT has no id (sub), returning anonymous identity');
+                return new server_1.AnonymousIdentity({ id: '' });
+            }
+            // return authenticated identity
+            return new server_1.AuthenticatedIdentity({
+                id: payload.sub,
+                verified: false
+            });
+        }
+        // handle error
+        catch (e) {
+            console.error('[Auth0IdentityService] Failed to get identity from jwt token', e);
+            // rethrow if isometric already
+            if (e instanceof funnel_core_1.IsometricError) {
+                throw e;
+            }
+            // otherwise throw server error
+            else {
+                throw new funnel_core_1.ServerError('Error authenticating request');
+            }
+        }
+    }
+    async deleteIdentity(identity) {
+        await this._managementClient.users.delete(identity.id);
+    }
+    /**
+     * Verify request using the "Authorization" header
+     * @param request The request to verify
+     * @throws NotAuthenticatedError Missing header or request could not be authorized
+     */
+    async verifyRequest(request) {
+        // get authorization header
+        const authHeader = request.headers.get('Authorization');
+        if (!authHeader) {
+            throw new funnel_core_1.NotAuthenticatedError('Missing authorization header');
+        }
+        // get token from authorization header (Bearer <token>)
+        const token = authHeader.split(' ')[1];
+        // remote key set
+        const jwkSet = (0, jose_1.createRemoteJWKSet)(new URL(`${this._issuer}.well-known/jwks.json`));
+        // try to verify the token
+        try {
+            // verify token
+            const result = await (0, jose_1.jwtVerify)(token, jwkSet, {
+                issuer: this._issuer,
+                audience: this._audience,
+            });
+            // return jwt payload
+            return result.payload;
+        }
+        // handle error
+        catch (e) {
+            console.error('[Auth0IdentityService] token verify failed', e);
+            throw new funnel_core_1.NotAuthenticatedError('Invalid token');
+        }
+    }
+}
+exports.Auth0IdentityService = Auth0IdentityService;

package/dist/react/auth0/server/Auth0Profile.d.ts

@@ -0,0 +1,19 @@
+import type { Management, ManagementClient } from 'auth0';
+import { StringKeyOf } from 'type-fest';
+import { Profile } from '../../profile/domain';
+import { Auth0ProfileStore } from './Auth0ProfileStore';
+export declare class Auth0Profile<TStores extends Profile.Stores = Profile.Stores> extends Profile<TStores> {
+    private readonly _managementClient;
+    private readonly _internalStoreKeyPrefix?;
+    constructor({ managementClient, internalStoreKeyPrefix, ...args }: Auth0Profile.ConstructorArgs<TStores>);
+    protected createStore(id: StringKeyOf<TStores>): Auth0ProfileStore;
+    save(): Promise<void>;
+}
+export declare namespace Auth0Profile {
+    type ConstructorArgs<TStores extends Profile.Stores> = Omit<Profile.ConstructorArgs<TStores>, '__editableProps'> & {
+        managementClient: ManagementClient;
+        internalStoreKeyPrefix?: string;
+    };
+    const KeyMapping: Record<Profile.Data.WritableProps, string>;
+    function toProfileData(data: Management.UserResponseSchema): Profile.Data.Core;
+}

package/dist/react/auth0/server/Auth0Profile.js

@@ -0,0 +1,108 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0Profile = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const domain_1 = require("../../profile/domain");
+const Auth0ProfileStore_1 = require("./Auth0ProfileStore");
+// class
+class Auth0Profile extends domain_1.Profile {
+    constructor(_a) {
+        var { managementClient, internalStoreKeyPrefix } = _a, args = __rest(_a, ["managementClient", "internalStoreKeyPrefix"]);
+        // construct base
+        super(Object.assign(Object.assign({}, args), { __editableProps: [
+                'email',
+                'nickname',
+                'name',
+                'firstName',
+                'lastName',
+                'picture'
+            ] }));
+        // initialize instance variables
+        this._managementClient = managementClient;
+        this._internalStoreKeyPrefix = internalStoreKeyPrefix;
+    }
+    createStore(id) {
+        const { _eventBus, identity, _managementClient, _internalStoreKeyPrefix } = this;
+        return new Auth0ProfileStore_1.Auth0ProfileStore({
+            internalKeyPrefix: _internalStoreKeyPrefix,
+            eventBus: _eventBus,
+            identity,
+            managementClient: _managementClient,
+            data: {
+                id,
+                profileId: identity.id
+            }
+        });
+    }
+    async save() {
+        // bail if there is nothing to save
+        if (this._edits.size === 0 && this._deletes.size === 0) {
+            return;
+        }
+        // transform edits
+        const edits = this._edits.entries()
+            .reduce((obj, [key, value]) => {
+            obj[Auth0Profile.KeyMapping[key]] = value;
+            return obj;
+        }, {});
+        // transform deletes
+        const deletes = Array.from(this._deletes)
+            .reduce((obj, id) => {
+            obj[Auth0Profile.KeyMapping[id]] = null;
+            return obj;
+        }, {});
+        // try to save
+        try {
+            // execute update request
+            const updatedData = await this._managementClient.users.update(this.id, Object.assign(Object.assign({}, edits), deletes));
+            // update data
+            this._data = Auth0Profile.toProfileData(updatedData);
+            // TODO: update stores too?
+            // clear changes
+            this._edits.clear();
+            this._deletes.clear();
+            // raise event
+            this.raiseEvent('saved');
+        }
+        // handle error
+        catch (e) {
+            console.error(`Error saving profile "${this.id}"`, e);
+            throw new funnel_core_1.ServerError(`Error saving profile "${this.id}"`);
+        }
+    }
+}
+exports.Auth0Profile = Auth0Profile;
+// extension
+(function (Auth0Profile) {
+    // helpers
+    Auth0Profile.KeyMapping = {
+        email: 'email',
+        nickname: 'nickname',
+        name: 'name',
+        firstName: 'given_name',
+        lastName: 'family_name',
+        picture: 'picture',
+    };
+    function toProfileData(data) {
+        return {
+            email: data.email,
+            nickname: data.nickname,
+            name: data.name,
+            firstName: data.given_name,
+            lastName: data.family_name,
+            picture: data.picture,
+        };
+    }
+    Auth0Profile.toProfileData = toProfileData;
+})(Auth0Profile || (exports.Auth0Profile = Auth0Profile = {}));

package/dist/react/auth0/server/Auth0ProfileFactory.d.ts

@@ -0,0 +1,15 @@
+import { EventBus } from '@nascentdigital/funnel-core';
+import { Management, ManagementClient } from 'auth0';
+import { Identity } from '../../identity/server';
+import { Profile } from '../../profile/server';
+import { Auth0Profile } from './Auth0Profile';
+export declare namespace Auth0ProfileFactory {
+    function create(args: CreateArgs): Auth0Profile<Profile.Stores>;
+    type CreateArgs = {
+        data: Management.UserResponseSchema;
+        managementClient: ManagementClient;
+        identity?: Identity;
+        internalStoreKeyPrefix?: string;
+        eventBus?: EventBus;
+    };
+}

package/dist/react/auth0/server/Auth0ProfileFactory.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0ProfileFactory = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const server_1 = require("../../identity/server");
+const Auth0Profile_1 = require("./Auth0Profile");
+const Auth0ProfileStore_1 = require("./Auth0ProfileStore");
+// factory
+var Auth0ProfileFactory;
+(function (Auth0ProfileFactory) {
+    function create(args) {
+        var _a, _b, _c, _d, _e, _f;
+        const { data, managementClient, internalStoreKeyPrefix } = args;
+        // create identity if needed
+        const identity = (_a = args.identity) !== null && _a !== void 0 ? _a : new server_1.AuthenticatedIdentity({
+            id: (_b = data.user_id) !== null && _b !== void 0 ? _b : '',
+            email: (_c = data.email) !== null && _c !== void 0 ? _c : '',
+            verified: data.email_verified || false,
+            nickname: data.nickname,
+            name: data.name || `${(_d = data.given_name) !== null && _d !== void 0 ? _d : ''} ${(_e = data.family_name) !== null && _e !== void 0 ? _e : ''}`.trim() || undefined
+        });
+        // create profile stores
+        const eventBus = (_f = args.eventBus) !== null && _f !== void 0 ? _f : new funnel_core_1.EventBus();
+        const stores = {};
+        if (data.app_metadata) {
+            Object.entries(data.app_metadata).forEach(([internalStoreKey, storeData]) => {
+                // convert to logical key
+                const externalKey = Auth0ProfileStore_1.Auth0ProfileStore.toExternalKey(internalStoreKey, internalStoreKeyPrefix);
+                // bail if data isn't an object
+                if (!funnel_core_1.Value.isObject(storeData)) {
+                    throw new funnel_core_1.IllegalStateError(`Profile store "${externalKey}" data is not an object`);
+                }
+                // create store
+                stores[externalKey] = new Auth0ProfileStore_1.Auth0ProfileStore({
+                    internalKeyPrefix: internalStoreKeyPrefix,
+                    managementClient: managementClient,
+                    eventBus,
+                    identity,
+                    data: Object.assign(Object.assign({}, storeData), { profileId: identity.id, id: externalKey })
+                });
+            });
+        }
+        // create profile
+        return new Auth0Profile_1.Auth0Profile(Object.assign(Object.assign({ managementClient,
+            internalStoreKeyPrefix,
+            eventBus,
+            identity,
+            stores }, Auth0Profile_1.Auth0Profile.toProfileData(data)), { id: identity.id }));
+    }
+    Auth0ProfileFactory.create = create;
+})(Auth0ProfileFactory || (exports.Auth0ProfileFactory = Auth0ProfileFactory = {}));

package/dist/react/auth0/server/Auth0ProfileManagementService.d.ts

@@ -0,0 +1,17 @@
+import { ProfileManagementService } from '../../profile/server';
+export declare class Auth0ProfileManagementService implements ProfileManagementService {
+    private readonly _managementClient;
+    private readonly _internalStoreKeyPrefix?;
+    constructor(args: Auth0ProfileManagementService.ConstructorArgs);
+    get(args: ProfileManagementService.Get.Args): Promise<ProfileManagementService.Get.Result>;
+    find(args?: ProfileManagementService.Find.Args): Promise<ProfileManagementService.Find.Result>;
+    private createProfile;
+}
+export declare namespace Auth0ProfileManagementService {
+    type ConstructorArgs = {
+        domain: string;
+        clientId: string;
+        clientSecret: string;
+        internalStoreKeyPrefix?: string;
+    };
+}

package/dist/react/auth0/server/Auth0ProfileManagementService.js

@@ -0,0 +1,127 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0ProfileManagementService = void 0;
+const auth0_1 = require("auth0");
+const Auth0Profile_1 = require("./Auth0Profile");
+const Auth0ProfileFactory_1 = require("./Auth0ProfileFactory");
+// class
+class Auth0ProfileManagementService {
+    constructor(args) {
+        this._managementClient = new auth0_1.ManagementClient({
+            domain: args.domain,
+            clientId: args.clientId,
+            clientSecret: args.clientSecret
+        });
+        this._internalStoreKeyPrefix = args.internalStoreKeyPrefix;
+    }
+    async get(args) {
+        // try to fetch data and create profile
+        try {
+            let data;
+            // get by id
+            if (args.id) {
+                data = await this._managementClient.users.get(args.id);
+            }
+            // get by email
+            else if (args.email) {
+                // find by email
+                const result = await this._managementClient.users.listUsersByEmail({ email: args.email.toLowerCase() });
+                // bail if no entry
+                if (result.length === 0) {
+                    return undefined;
+                }
+                // capture first result
+                data = result[0];
+            }
+            // otherwise bail if no arguments
+            else {
+                return undefined;
+            }
+            // create and return profile
+            return this.createProfile(data);
+        }
+        // handle error
+        catch (e) {
+            console.error('[Auth0ProfileManagementService] error getting profile', e);
+        }
+    }
+    async find(args) {
+        // try to find profiles
+        try {
+            // build query string
+            const _a = args !== null && args !== void 0 ? args : {}, { pagination = { page: 1, pageSize: 2 } } = _a, query = __rest(_a, ["pagination"]);
+            const terms = Object.entries(query).map(([key, value]) => {
+                const auth0Key = Auth0Profile_1.Auth0Profile.KeyMapping[key];
+                return `${auth0Key}:"${value}"`;
+            });
+            const queryStr = terms.join(' AND ');
+            // find users
+            const result = await this._managementClient.users.list({
+                q: queryStr,
+                per_page: pagination.pageSize,
+                page: pagination.page - 1,
+                include_totals: true
+            });
+            // return iterator
+            return new Auth0Iterator(result, (data) => this.createProfile(data));
+        }
+        // handle error
+        catch (e) {
+            console.error('[Auth0ProfileManagementService] error finding profile', e);
+            throw e;
+        }
+    }
+    createProfile(data) {
+        return Auth0ProfileFactory_1.Auth0ProfileFactory.create({
+            data,
+            managementClient: this._managementClient,
+            internalStoreKeyPrefix: this._internalStoreKeyPrefix
+        });
+    }
+}
+exports.Auth0ProfileManagementService = Auth0ProfileManagementService;
+// iterator
+class Auth0Iterator {
+    constructor(_auth0Result, _factory) {
+        this._auth0Result = _auth0Result;
+        this._factory = _factory;
+        this.syncState();
+    }
+    get items() {
+        return this._items;
+    }
+    get page() {
+        return this._page;
+    }
+    get pageCount() {
+        return this._pageCount;
+    }
+    get totalItemCount() {
+        return this._totalItemCount;
+    }
+    get hasNextPage() {
+        return this._auth0Result.hasNextPage();
+    }
+    async nextPage() {
+        await this._auth0Result.getNextPage();
+        this.syncState();
+    }
+    syncState() {
+        const { total = 0, limit = 1, start = 0 } = this._auth0Result.response;
+        this._items = this._auth0Result.data.map(data => this._factory(data));
+        this._page = Math.ceil((start + 1) / limit);
+        this._pageCount = total === 0 ? 0 : Math.ceil(total / limit);
+        this._totalItemCount = total;
+    }
+}

package/dist/react/auth0/server/Auth0ProfileServices.d.ts

@@ -0,0 +1,13 @@
+import { ProfileManagementService, ProfileServices, ProfileUserService } from '../../profile/server';
+import { Auth0ProfileManagementService } from './Auth0ProfileManagementService';
+import { Auth0ProfileUserService } from './Auth0ProfileUserService';
+export declare class Auth0ProfileServices implements ProfileServices {
+    private readonly _userService;
+    private readonly _managementService;
+    constructor(args: Auth0ProfileServices.ConstructorArgs);
+    getManagementService(): ProfileManagementService;
+    getUserService(): ProfileUserService;
+}
+export declare namespace Auth0ProfileServices {
+    type ConstructorArgs = Auth0ProfileUserService.ConstructorArgs | Auth0ProfileManagementService.ConstructorArgs;
+}

package/dist/react/auth0/server/Auth0ProfileServices.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0ProfileServices = void 0;
+const Auth0ProfileManagementService_1 = require("./Auth0ProfileManagementService");
+const Auth0ProfileUserService_1 = require("./Auth0ProfileUserService");
+// class
+class Auth0ProfileServices {
+    constructor(args) {
+        this._userService = new Auth0ProfileUserService_1.Auth0ProfileUserService(args);
+        this._managementService = new Auth0ProfileManagementService_1.Auth0ProfileManagementService(args);
+    }
+    getManagementService() {
+        return this._managementService;
+    }
+    getUserService() {
+        return this._userService;
+    }
+}
+exports.Auth0ProfileServices = Auth0ProfileServices;