@nascentdigital/funnel-editor 4.4.18

package/dist/core/auth/AuthContext.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthContext = void 0;
+const react_1 = require("react");
+// context
+exports.AuthContext = (0, react_1.createContext)({});

package/dist/core/auth/Authenticator.d.ts

@@ -0,0 +1,36 @@
+import { User } from '@nascentdigital/funnel-cms';
+import { EditorApiClient } from '../client';
+export declare class Authenticator {
+    readonly editorApi: EditorApiClient;
+    private _state$;
+    private _state;
+    private _token?;
+    private readonly _user$;
+    private readonly _initializePromise;
+    constructor(editorApi: EditorApiClient);
+    get state$(): import("rxjs").Observable<Authenticator.State>;
+    get state(): Authenticator.State;
+    private set state(value);
+    get isReady(): boolean;
+    get authenticated(): boolean;
+    get user$(): import("rxjs").Observable<User<string>>;
+    get user(): User;
+    set user(user: User);
+    login(email: string, password: string): Promise<boolean>;
+    authenticate(jwt: string): Promise<boolean>;
+    logout(): void;
+    private initialize;
+    private onAuthenticate;
+    private onAuthenticated;
+}
+export declare namespace Authenticator {
+    type Provider = 'cms' | 'google' | 'apple';
+    namespace Provider {
+        function parse(value: string): Provider | undefined;
+    }
+    type State = 'unknown' | 'unauthenticated' | 'authenticating' | 'authenticated';
+    type OauthCallback = {
+        provider: Provider;
+        code: string;
+    };
+}

package/dist/core/auth/Authenticator.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Authenticator = void 0;
+const funnel_cms_1 = require("@nascentdigital/funnel-cms");
+const rxjs_1 = require("rxjs");
+// class
+class Authenticator {
+    constructor(editorApi) {
+        this.editorApi = editorApi;
+        // initialize instance variables
+        this._state$ = new rxjs_1.Subject();
+        this._state = 'unknown';
+        this._user$ = new rxjs_1.BehaviorSubject(funnel_cms_1.User.UNAUTHENTICATED);
+        this._initializePromise = this.initialize();
+    }
+    get state$() {
+        return this._state$
+            .asObservable()
+            .pipe((0, rxjs_1.distinctUntilChanged)());
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        if (this._state !== value) {
+            this._state = value;
+            this._state$.next(value);
+        }
+    }
+    get isReady() {
+        return this._state === 'unauthenticated'
+            || this._state === 'authenticated';
+    }
+    get authenticated() {
+        return this._state === 'authenticated';
+    }
+    get user$() {
+        return this._user$.asObservable();
+    }
+    get user() {
+        return this._user$.getValue();
+    }
+    set user(user) {
+        this._user$.next(user);
+    }
+    async login(email, password) {
+        // ensure initialized
+        await this._initializePromise;
+        // try to authenticate with jwt
+        try {
+            console.debug('[Authenticator] login');
+            // set state to authenticating
+            this.state = 'authenticating';
+            // login to obtain jwt
+            const jwt = await this.editorApi.login({ email, password });
+            // verify jwt
+            return this.onAuthenticate(jwt);
+        }
+        // handle error
+        catch (e) {
+            // clear session
+            this.logout();
+            // indicate failure
+            throw e;
+        }
+    }
+    async authenticate(jwt) {
+        // ensure initialized
+        await this._initializePromise;
+        // try to authenticate with jwt
+        try {
+            console.debug('[Authenticator] authenticating');
+            // set state to authenticating
+            this.state = 'authenticating';
+            // verify jwt
+            return this.onAuthenticate(jwt);
+        }
+        // handle error
+        catch (e) {
+            console.error('[Authenticator] login failed', e);
+            // clear session
+            this.logout();
+            // indicate failure
+            return false;
+        }
+    }
+    logout() {
+        // reset local storage
+        localStorage.clear();
+        // clear in-memory auth data
+        delete this._token;
+        this.editorApi.token = undefined;
+        this._user$.next(funnel_cms_1.User.UNAUTHENTICATED);
+        // update state
+        this.state = 'unauthenticated';
+    }
+    async initialize() {
+        var _a, _b;
+        console.debug('[Authenticator] initializing');
+        // fetch token from session
+        const token = (_a = localStorage.getItem(TOKEN_STORAGE_KEY)) !== null && _a !== void 0 ? _a : undefined;
+        this._token = token;
+        // bail if token isn't set
+        if (!token) {
+            console.debug('[Authenticator] no token found');
+            this.state = 'unauthenticated';
+            return;
+        }
+        // get user using cms
+        let user;
+        try {
+            user = (_b = await this.editorApi.checkToken(token)) !== null && _b !== void 0 ? _b : undefined;
+        }
+        catch (e) {
+            console.error('[Authenticator] failed to fetch user', e);
+        }
+        // bail if there's no user
+        if (!user) {
+            console.debug('[Authenticator] invalid token');
+            this.logout();
+        }
+        // or mark authenticated
+        else {
+            console.debug('[Authenticator] token validated');
+            this.onAuthenticated(user, token);
+        }
+    }
+    async onAuthenticate(jwt) {
+        var _a;
+        // try to leverage jwt
+        const user = (_a = await this.editorApi.checkToken(jwt)) !== null && _a !== void 0 ? _a : undefined;
+        if (!user) {
+            console.error('[Authenticator] token failed to fetch user');
+            // clear session
+            this.logout();
+            // indicate failure
+            return false;
+        }
+        // or complete login
+        else {
+            // bind session
+            this.onAuthenticated(user, jwt);
+            // indicate success
+            return true;
+        }
+    }
+    onAuthenticated(user, token) {
+        // set token (also in cms, localstorage)
+        this._token = token;
+        this.editorApi.token = token;
+        localStorage.setItem(TOKEN_STORAGE_KEY, token);
+        // set user
+        this._user$.next(new funnel_cms_1.User(user));
+        console.debug('[Authenticator] authenticated user', user);
+        // update state
+        this.state = 'authenticated';
+        // TODO: register an unauthenticated callback from api client
+    }
+}
+exports.Authenticator = Authenticator;
+// extension
+(function (Authenticator) {
+    let Provider;
+    (function (Provider) {
+        // helper
+        function parse(value) {
+            const normalizedValue = value.trim().toLowerCase();
+            switch (normalizedValue) {
+                case 'cms':
+                case 'google':
+                case 'apple':
+                    return normalizedValue;
+                default:
+                    return undefined;
+            }
+        }
+        Provider.parse = parse;
+    })(Provider = Authenticator.Provider || (Authenticator.Provider = {}));
+})(Authenticator || (exports.Authenticator = Authenticator = {}));
+// helpers
+const TOKEN_STORAGE_KEY = '_funnel.token';

package/dist/core/auth/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Auth';
+export * from './AuthContainer';
+export * from './AuthContext';
+export * from './Authenticator';
+export * from './useAuthenticator';

package/dist/core/auth/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("./Auth"), exports);
+__exportStar(require("./AuthContainer"), exports);
+__exportStar(require("./AuthContext"), exports);
+__exportStar(require("./Authenticator"), exports);
+__exportStar(require("./useAuthenticator"), exports);

package/dist/core/auth/useAuthenticator.d.ts

@@ -0,0 +1 @@
+export declare function useAuthenticator(): import("./Authenticator").Authenticator;

package/dist/core/auth/useAuthenticator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuthenticator = useAuthenticator;
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const AuthContext_1 = require("./AuthContext");
+// auth hook
+function useAuthenticator() {
+    // bind state + context
+    const { authenticator } = (0, react_1.useContext)(AuthContext_1.AuthContext);
+    const touch = (0, hooks_1.useTouch)();
+    // update when state changes
+    (0, react_1.useEffect)(() => {
+        // subscribe on mount
+        const subscriptions = [
+            authenticator.state$.subscribe(touch),
+            authenticator.user$.subscribe(touch)
+        ];
+        // unsubscribe on unmount
+        return () => subscriptions.forEach(subscription => subscription.unsubscribe());
+    }, [authenticator, touch]);
+    // return authenticator
+    return authenticator;
+}

package/dist/core/client/EditorApiClient.d.ts

@@ -0,0 +1,72 @@
+import { AssetUploadClient, IAssetApiClient } from '@nascentdigital/funnel-cms';
+import { Schema } from '@nascentdigital/funnel-core';
+import { CreateFileCommand, CreatePageCommand, CreateUserCommand, DeleteFileCommand, DeleteUserCommand, DuplicatePageCommand, ExecuteUpgradeCommand, FindPagesCommand, GetCurrentUserCommand, GetFileCommand, GetFilesCommand, GetPageCommand, GetPageCountsCommand, GetPageDependantsCommand, GetPageDependenciesCommand, GetPageGroup, GetPagesOverviewCommand, GetPageSummariesCommand, GetSiteConfigCommand, GetUpgradeStatusCommand, GetUserCommand, GetUsersCommand, ResetUserCommand, SearchPagesCommand, TouchPageCommand, UnpublishPageCommand, UpdateFileCommand, UpdatePageCommand, UpdateSiteConfigCommand, UpdateUserCommand } from '../../api';
+import { CmsAuthCommand } from '../../api/auth';
+import { CommitChangeSetCommand, GetChangeSetCommand, ListChangeSetGroupsCommand, ListChangeSetsCommand, RevertChangeSetCommand } from '../../api/changeset';
+import { CreateCollectionCommand, DuplicateCollectionCommand, GetCollectionCommand, GetCollectionDependantsCommand, GetCollectionDependenciesCommand, GetCollectionGroupCommand, GetCollectionItemsCommand, GetCollectionsOverviewCommand, UnpublishCollectionCommand, UpdateCollectionCommand } from '../../api/collections';
+import { AppState } from '../app';
+import { PageOverview } from '../domain';
+export declare class EditorApiClient implements IAssetApiClient {
+    readonly appState: AppState;
+    private _token?;
+    constructor(appState: AppState);
+    get token(): string | undefined;
+    set token(token: string | undefined);
+    login(data: CmsAuthCommand.Data): Promise<CmsAuthCommand.Result>;
+    checkToken(token: string): Promise<GetCurrentUserCommand.Result>;
+    getPreviewUrl(url: string): string;
+    getAssets(data: GetFilesCommand.Data): Promise<GetFilesCommand.Result>;
+    getAsset(data: GetFileCommand.Data): Promise<GetFileCommand.Result>;
+    uploadFile(args: Omit<AssetUploadClient.OnUpload.Args, 'api'>): Promise<AssetUploadClient.OnUpload.Result>;
+    createAsset(data: CreateFileCommand.Data): Promise<CreateFileCommand.Result>;
+    updateAsset(data: UpdateFileCommand.Data): Promise<UpdateFileCommand.Result>;
+    deleteAsset(data: DeleteFileCommand.Data): Promise<DeleteFileCommand.Result>;
+    getUsers(data?: GetUsersCommand.Data): Promise<GetUsersCommand.Result>;
+    getUser(data: GetUserCommand.Data): Promise<GetUserCommand.Result>;
+    createUser(data: CreateUserCommand.Data): Promise<CreateUserCommand.Result>;
+    updateUser(data: UpdateUserCommand.Data): Promise<UpdateUserCommand.Result>;
+    resetUser(data: ResetUserCommand.Data): Promise<ResetUserCommand.Result>;
+    deleteUser(data: DeleteUserCommand.Data): Promise<DeleteUserCommand.Result>;
+    getPagesOverview(data: GetPagesOverviewCommand.Data): Promise<PageOverview[]>;
+    searchPages(data: SearchPagesCommand.Data): Promise<SearchPagesCommand.Result>;
+    findPages(data: FindPagesCommand.Data): Promise<FindPagesCommand.Result>;
+    getPageCounts(data: GetPageCountsCommand.Data): Promise<GetPageCountsCommand.Result>;
+    getPageSummaries(data: GetPageSummariesCommand.Data): Promise<GetPageSummariesCommand.Result>;
+    getPageGroup(data: GetPageGroup.Data): Promise<GetPageGroup.Result>;
+    getPage(data: GetPageCommand.Data): Promise<GetPageCommand.Result>;
+    createPage(data: CreatePageCommand.Data): Promise<CreatePageCommand.Result>;
+    duplicatePage(data: DuplicatePageCommand.Data): Promise<DuplicatePageCommand.Result>;
+    updatePage(data: UpdatePageCommand.Data): Promise<UpdatePageCommand.Result>;
+    touchPage(data: TouchPageCommand.Data): Promise<TouchPageCommand.Result>;
+    unpublishPage(data: UnpublishPageCommand.Data): Promise<UnpublishPageCommand.Result>;
+    getPageDependants(data: GetPageDependantsCommand.Data): Promise<GetPageDependantsCommand.Result>;
+    getPageDependencies(data: GetPageDependenciesCommand.Data): Promise<GetPageDependenciesCommand.Result>;
+    getCollectionsOverview(data: GetCollectionsOverviewCommand.Data): Promise<EditorApiClient.CollectionOverview[]>;
+    getCollectionItems(data: GetCollectionItemsCommand.Data): Promise<GetCollectionItemsCommand.Result>;
+    getCollectionGroup(data: GetCollectionGroupCommand.Data): Promise<GetCollectionGroupCommand.Result>;
+    getCollection(data: GetCollectionCommand.Data): Promise<GetCollectionCommand.Result>;
+    createCollection(data: CreateCollectionCommand.Data): Promise<CreateCollectionCommand.Result>;
+    duplicateCollection(data: DuplicateCollectionCommand.Data): Promise<DuplicateCollectionCommand.Result>;
+    updateCollection(data: UpdateCollectionCommand.Data): Promise<UpdateCollectionCommand.Result>;
+    unpublishCollection(data: UnpublishCollectionCommand.Data): Promise<UnpublishCollectionCommand.Result>;
+    getCollectionDependants(data: GetCollectionDependantsCommand.Data): Promise<GetCollectionDependantsCommand.Result>;
+    getCollectionDependencies(data: GetCollectionDependenciesCommand.Data): Promise<GetCollectionDependenciesCommand.Result>;
+    listChangeSetGroups(): Promise<ListChangeSetGroupsCommand.Result>;
+    listChangeSets(data: ListChangeSetsCommand.Data): Promise<ListChangeSetsCommand.Result>;
+    getChangeSet(data: GetChangeSetCommand.Data): Promise<GetChangeSetCommand.Result>;
+    commitChangeSet(data: CommitChangeSetCommand.Data): Promise<CommitChangeSetCommand.Result>;
+    revertChangeSet(data: RevertChangeSetCommand.Data): Promise<RevertChangeSetCommand.Result>;
+    getUpgradeStatus(): Promise<GetUpgradeStatusCommand.Result>;
+    executeUpgrade(): Promise<ExecuteUpgradeCommand.Result>;
+    getSiteConfig(): Promise<GetSiteConfigCommand.Result>;
+    updateSiteConfig(data: UpdateSiteConfigCommand.Data): Promise<UpdateSiteConfigCommand.Result>;
+    private sendCommand;
+    private send;
+}
+export declare namespace EditorApiClient {
+    type CollectionOverview = {
+        template: Schema.Collection;
+        type: Schema.Collection.Type;
+        count: number;
+    };
+}

package/dist/core/client/EditorApiClient.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorApiClient = void 0;
+const funnel_cms_1 = require("@nascentdigital/funnel-cms");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const qs_1 = __importDefault(require("qs"));
+const api_1 = require("../../api");
+const domain_1 = require("../domain");
+// class
+class EditorApiClient {
+    constructor(appState) {
+        this.appState = appState;
+    }
+    get token() {
+        return this._token;
+    }
+    set token(token) {
+        this._token = token;
+    }
+    async login(data) {
+        return this.send({
+            params: { auth: 'cms' },
+            body: data
+        });
+    }
+    async checkToken(token) {
+        return this.send({
+            body: { type: 'getCurrentUser' },
+            token
+        });
+    }
+    getPreviewUrl(url) {
+        return `/api/preview?token=${this._token}&redirect=${url}`;
+    }
+    async getAssets(data) {
+        return this.sendCommand('getAssets', data);
+    }
+    async getAsset(data) {
+        return this.sendCommand('getAsset', data);
+    }
+    async uploadFile(args) {
+        return funnel_cms_1.AssetUploadClient.get().onUpload(Object.assign(Object.assign({}, args), { api: this }));
+    }
+    createAsset(data) {
+        return this.sendCommand('createAsset', data);
+    }
+    async updateAsset(data) {
+        return this.sendCommand('updateAsset', data);
+    }
+    async deleteAsset(data) {
+        return this.sendCommand('deleteAsset', data);
+    }
+    async getUsers(data) {
+        return this.sendCommand('getUsers', data);
+    }
+    async getUser(data) {
+        return this.sendCommand('getUser', data);
+    }
+    async createUser(data) {
+        return this.sendCommand('createUser', data);
+    }
+    async updateUser(data) {
+        return this.sendCommand('updateUser', data);
+    }
+    async resetUser(data) {
+        return this.sendCommand('resetUser', data);
+    }
+    async deleteUser(data) {
+        return this.sendCommand('deleteUser', data);
+    }
+    async getPagesOverview(data) {
+        // get overview
+        const overview = await this.sendCommand('getPagesOverview', data);
+        // enrich with templates and flip to array
+        const templates = Object.values(funnel_core_1.Schema.Site.current().regions[data.region]);
+        return templates.map(template => {
+            var _a, _b;
+            // extract static page overview
+            const { type } = template;
+            if (template.variant === 'static') {
+                return new domain_1.StaticPageOverview(Object.assign({ template,
+                    type, refs: {} }, ((_a = overview.static.find(page => page.type === type)) !== null && _a !== void 0 ? _a : {})));
+            }
+            // or dynamic one
+            else {
+                return new domain_1.DynamicPageOverview(Object.assign({ template,
+                    type, count: 0 }, ((_b = overview.dynamic.find(page => page.type === type)) !== null && _b !== void 0 ? _b : {})));
+            }
+        });
+    }
+    async searchPages(data) {
+        return this.sendCommand('searchPages', data);
+    }
+    async findPages(data) {
+        return this.sendCommand('findPages', data);
+    }
+    async getPageCounts(data) {
+        return this.sendCommand('getPageCounts', data);
+    }
+    async getPageSummaries(data) {
+        return this.sendCommand('getPageSummaries', data);
+    }
+    async getPageGroup(data) {
+        return this.sendCommand('getPageGroup', data);
+    }
+    async getPage(data) {
+        return this.sendCommand('getPage', data);
+    }
+    async createPage(data) {
+        return this.sendCommand('createPage', data);
+    }
+    async duplicatePage(data) {
+        return this.sendCommand('duplicatePage', data);
+    }
+    async updatePage(data) {
+        return this.sendCommand('updatePage', data);
+    }
+    async touchPage(data) {
+        return this.sendCommand('touchPage', data);
+    }
+    async unpublishPage(data) {
+        return this.sendCommand('unpublishPage', data);
+    }
+    async getPageDependants(data) {
+        return this.sendCommand('getPageDependants', data);
+    }
+    async getPageDependencies(data) {
+        return this.sendCommand('getPageDependencies', data);
+    }
+    async getCollectionsOverview(data) {
+        // get overview
+        const overview = await this.sendCommand('getCollectionsOverview', data);
+        // enrich with templates and flip to array
+        const templates = funnel_core_1.Schema.Site.current().collections;
+        return templates.map(template => {
+            var _a;
+            return (Object.assign({ template, type: template.type, count: 0 }, ((_a = overview.find(collection => collection.type === template.type)) !== null && _a !== void 0 ? _a : {})));
+        });
+    }
+    async getCollectionItems(data) {
+        return this.sendCommand('getCollectionItems', data);
+    }
+    async getCollectionGroup(data) {
+        return this.sendCommand('getCollectionGroup', data);
+    }
+    async getCollection(data) {
+        return this.sendCommand('getCollection', data);
+    }
+    async createCollection(data) {
+        return this.sendCommand('createCollection', data);
+    }
+    async duplicateCollection(data) {
+        return this.sendCommand('duplicateCollection', data);
+    }
+    async updateCollection(data) {
+        return this.sendCommand('updateCollection', data);
+    }
+    async unpublishCollection(data) {
+        return this.sendCommand('unpublishCollection', data);
+    }
+    async getCollectionDependants(data) {
+        return this.sendCommand('getCollectionDependants', data);
+    }
+    async getCollectionDependencies(data) {
+        return this.sendCommand('getCollectionDependencies', data);
+    }
+    listChangeSetGroups() {
+        return this.sendCommand('listChangeSetGroups', {});
+    }
+    listChangeSets(data) {
+        return this.sendCommand('listChangeSets', data);
+    }
+    getChangeSet(data) {
+        return this.sendCommand('getChangeSet', data);
+    }
+    commitChangeSet(data) {
+        return this.sendCommand('commitChangeSet', data);
+    }
+    revertChangeSet(data) {
+        return this.sendCommand('revertChangeSet', data);
+    }
+    async getUpgradeStatus() {
+        return this.sendCommand('upgradeStatus', {});
+    }
+    async executeUpgrade() {
+        return this.sendCommand('executeUpgrade', {});
+    }
+    async getSiteConfig() {
+        return this.sendCommand('getSiteConfig', {});
+    }
+    async updateSiteConfig(data) {
+        return this.sendCommand('updateSiteConfig', data);
+    }
+    sendCommand(command, data) {
+        // fail if there's no token
+        const token = this._token;
+        if (!token && !api_1.EditorApiCommand.Type.isAnonymous(command)) {
+            throw new funnel_core_1.InvalidOperationError('Cannot access editor without an accessToken');
+        }
+        // send request
+        return this.send({
+            token,
+            body: { type: command, data }
+        });
+    }
+    async send({ token, params, body }) {
+        var _a;
+        // try to send request
+        try {
+            // send request
+            const base = '/api/editor';
+            const query = qs_1.default.stringify(params !== null && params !== void 0 ? params : {});
+            const url = query.length === 0
+                ? base
+                : `${base}?${query}`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+                body: JSON.stringify(body)
+            });
+            // throw if response failed
+            await funnel_core_1.IsometricErrorUtils.checkResponse(response);
+            // mark as online
+            this.appState.offline = false;
+            // parse response
+            const json = await response.json();
+            // return response (assume it's a result)
+            return funnel_core_1.Value.typeOf(json) === 'object'
+                ? (_a = json.data) !== null && _a !== void 0 ? _a : undefined
+                : undefined;
+        }
+        catch (e) {
+            // forward iso-errors
+            if (e instanceof funnel_core_1.IsometricError) {
+                // handle lockdown
+                if (e instanceof funnel_cms_1.LockdownError) {
+                    this.appState.blocked = true;
+                }
+                // throw
+                throw e;
+            }
+            // or assume it's offline
+            else {
+                this.appState.offline = true;
+                throw new funnel_core_1.OfflineError();
+            }
+        }
+    }
+}
+exports.EditorApiClient = EditorApiClient;

package/dist/core/client/EditorApiContainer.d.ts

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+export declare function EditorApiContainer({ children }: EditorApiContainer.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace EditorApiContainer {
+    type Props = PropsWithChildren;
+}

package/dist/core/client/EditorApiContainer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorApiContainer = EditorApiContainer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const app_1 = require("../app");
+const EditorApiClient_1 = require("./EditorApiClient");
+const EditorApiContext_1 = require("./EditorApiContext");
+// container
+function EditorApiContainer({ children }) {
+    // bind context
+    const appStete = (0, app_1.useAppState)();
+    const context = (0, react_1.useMemo)(() => ({ client: new EditorApiClient_1.EditorApiClient(appStete) }), [appStete]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(EditorApiContext_1.EditorApiContext.Provider, { value: context, children: children }));
+}

package/dist/core/client/EditorApiContext.d.ts

@@ -0,0 +1,7 @@
+import { EditorApiClient } from './EditorApiClient';
+export declare const EditorApiContext: import("react").Context<EditorApiContext.Type>;
+export declare namespace EditorApiContext {
+    type Type = {
+        client: EditorApiClient;
+    };
+}

package/dist/core/client/EditorApiContext.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorApiContext = void 0;
+const react_1 = require("react");
+// context
+exports.EditorApiContext = (0, react_1.createContext)({});

package/dist/core/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './EditorApiClient';
+export * from './EditorApiContainer';
+export * from './useEditorApi';

package/dist/core/client/index.js

@@ -0,0 +1,19 @@
+"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("./EditorApiClient"), exports);
+__exportStar(require("./EditorApiContainer"), exports);
+__exportStar(require("./useEditorApi"), exports);