@nascentdigital/funnel-editor 4.4.18

package/dist/core/hooks/useHotkeyScopeLock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHotkeyScopeLock = useHotkeyScopeLock;
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+const react_hotkeys_hook_1 = require("react-hotkeys-hook");
+// hook
+function useHotkeyScopeLock(lock) {
+    // bind hooks + refs
+    const scope = (0, react_1.useId)();
+    const scopeSnapshotRef = (0, react_1.useRef)(undefined);
+    const { activeScopes: activeScopesRaw, enableScope, disableScope } = (0, react_hotkeys_hook_1.useHotkeysContext)();
+    const activeScopes = (0, client_1.useLatestValue)(activeScopesRaw);
+    // wire dismiss on escape (when open)
+    (0, react_1.useEffect)(() => {
+        // lock scope if locking AND not locked
+        const scopeSnapshot = scopeSnapshotRef.current;
+        const isLocked = scopeSnapshot !== undefined;
+        if (lock && !isLocked) {
+            // snapshot
+            scopeSnapshotRef.current = activeScopes;
+            // freeze active scopes
+            activeScopes.forEach(scope => disableScope(scope));
+            // enable scope lock
+            enableScope(scope);
+        }
+        // or unlock if unlocking AND locked
+        else if (!lock && isLocked) {
+            // disable scope lock
+            disableScope(scope);
+            // unfreeze previously active scopes (makes them active again)
+            scopeSnapshot === null || scopeSnapshot === void 0 ? void 0 : scopeSnapshot.forEach(scope => enableScope(scope));
+        }
+    }, [scope, activeScopes, enableScope, disableScope, lock]);
+    // return result
+    return {
+        scope,
+        active: activeScopes.includes(scope)
+    };
+}

package/dist/core/hooks/usePage.d.ts

@@ -0,0 +1,9 @@
+import { Page } from '../domain';
+export declare function usePossiblePage(): Page | undefined;
+export declare function usePage(): Page;
+export declare const PageContext: import("react").Context<PageContext.Data>;
+export declare namespace PageContext {
+    type Data = {
+        page?: Page;
+    };
+}

package/dist/core/hooks/usePage.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageContext = void 0;
+exports.usePossiblePage = usePossiblePage;
+exports.usePage = usePage;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+// hook
+function usePossiblePage() {
+    // bind context + touch
+    const { page } = (0, react_1.useContext)(exports.PageContext);
+    const touch = (0, client_1.useTouch)();
+    // listen to page changes
+    (0, react_1.useEffect)(() => {
+        // skip if page isn't bound
+        if (!page) {
+            return;
+        }
+        // subscribe to changes
+        const subscription = page.events$.subscribe(() => touch());
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [page, touch]);
+    // return page
+    return page;
+}
+function usePage() {
+    // resolve page
+    const page = usePossiblePage();
+    // throw if there's no page (should never happen)
+    if (!page) {
+        throw new funnel_core_1.InvalidOperationError('Attempt to access Page outside of PageContext');
+    }
+    // return page
+    return page;
+}
+// context
+exports.PageContext = (0, react_1.createContext)({});

package/dist/core/hooks/usePageCollection.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { Pages } from '../domain';
+export declare function usePageCollection(pageType: Schema.Page.Type): Pages | undefined;

package/dist/core/hooks/usePageCollection.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePageCollection = usePageCollection;
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+const useSite_1 = require("./useSite");
+// hook
+function usePageCollection(pageType) {
+    // bind state + hooks
+    const [collection, setCollection] = (0, react_1.useState)();
+    const site = (0, useSite_1.useSite)();
+    const touch = (0, client_1.useTouch)();
+    const { ready: siteReady } = site;
+    // create new collection when site is ready
+    (0, react_1.useEffect)(() => {
+        // clear if site's not ready
+        if (!siteReady) {
+            setCollection(undefined);
+        }
+        // or create collection
+        else {
+            setCollection(site.getPages(pageType));
+        }
+    }, [site, siteReady, pageType]);
+    // listen to collection changes
+    (0, react_1.useEffect)(() => {
+        // skip if collection isn't bound
+        if (!collection) {
+            return;
+        }
+        // subscribe to changes
+        const subscription = collection.events$.subscribe(() => touch());
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [collection, touch]);
+    // return collection
+    return collection;
+}

package/dist/core/hooks/usePageRef.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from '@nascentdigital/funnel-core';
+export declare function usePageRef(pageId?: Schema.Page.Id): import("..").Page.Ref | undefined;

package/dist/core/hooks/usePageRef.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePageRef = usePageRef;
+const usePage_1 = require("./usePage");
+// hook
+function usePageRef(pageId) {
+    // bind hooks
+    const page = (0, usePage_1.usePage)();
+    // return ref if it exists
+    return page === null || page === void 0 ? void 0 : page.getPageRef(pageId);
+}

package/dist/core/hooks/usePageRefStore.d.ts

@@ -0,0 +1,7 @@
+import { IPageRefStore } from '../domain';
+export declare function usePossiblePageRefStore(): IPageRefStore | undefined;
+export declare function usePageRefStore(): IPageRefStore;
+export declare const PageRefStoreContext: import("react").Context<PageRefStoreContext.Data>;
+export declare namespace PageRefStoreContext {
+    type Data = IPageRefStore | undefined;
+}

package/dist/core/hooks/usePageRefStore.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageRefStoreContext = void 0;
+exports.usePossiblePageRefStore = usePossiblePageRefStore;
+exports.usePageRefStore = usePageRefStore;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+// hook
+function usePossiblePageRefStore() {
+    // bind hooks
+    const store = (0, react_1.useContext)(exports.PageRefStoreContext);
+    const touch = (0, client_1.useTouch)();
+    // refresh on sync change
+    (0, react_1.useEffect)(() => {
+        // skip if it's not bound
+        if (!store) {
+            return;
+        }
+        // touch when sync changes
+        const subscription = store.stable$.subscribe(touch);
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [store, touch]);
+    // return store
+    return store;
+}
+function usePageRefStore() {
+    // bind hooks
+    const store = usePossiblePageRefStore();
+    // throw if there's no store (should never happen)
+    if (!store) {
+        throw new funnel_core_1.InvalidOperationError('Attempt to access IPageStore outside of PageRefStoreContext or valid route');
+    }
+    // return store
+    return store;
+}
+// context
+exports.PageRefStoreContext = (0, react_1.createContext)(undefined);

package/dist/core/hooks/usePageRepository.d.ts

@@ -0,0 +1,2 @@
+import { PageRepository } from '../repository';
+export declare function usePageRepository(): PageRepository;

package/dist/core/hooks/usePageRepository.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePageRepository = usePageRepository;
+const react_1 = require("react");
+const client_1 = require("../client");
+const repository_1 = require("../repository");
+// hook
+function usePageRepository() {
+    const editorApi = (0, client_1.useEditorApi)();
+    return (0, react_1.useMemo)(() => new repository_1.PageRepository(editorApi), [editorApi]);
+}

package/dist/core/hooks/usePages.d.ts

@@ -0,0 +1,7 @@
+import { Pages } from '../domain';
+export declare function usePages(pages: Pages | undefined, options?: usePages.Options): void;
+export declare namespace usePages {
+    type Options = {
+        sync?: boolean;
+    };
+}

package/dist/core/hooks/usePages.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePages = usePages;
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+// hook
+function usePages(pages, options = {}) {
+    // bind props + touch
+    const { sync = false } = options;
+    const touch = (0, client_1.useTouch)();
+    // listen to page changes
+    (0, react_1.useEffect)(() => {
+        // skip if page isn't bound
+        if (!pages) {
+            return;
+        }
+        // subscribe to changes
+        const subscription = pages.events$.subscribe(() => touch());
+        // auto-sync if enabled and required
+        const { state } = pages;
+        if (sync && (state === 'ready' || state === 'error')) {
+            pages.sync().catch(console.error);
+        }
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [pages, touch, sync]);
+}

package/dist/core/hooks/useSite.d.ts

@@ -0,0 +1,9 @@
+import { Site } from '../domain';
+export declare function usePossibleSite(): Site | undefined;
+export declare function useSite(): Site;
+export declare const SiteContext: import("react").Context<SiteContext.Data>;
+export declare namespace SiteContext {
+    type Data = {
+        site?: Site;
+    };
+}

package/dist/core/hooks/useSite.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiteContext = void 0;
+exports.usePossibleSite = usePossibleSite;
+exports.useSite = useSite;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+// hook
+function usePossibleSite() {
+    // bind context + touch
+    const { site } = (0, react_1.useContext)(exports.SiteContext);
+    const touch = (0, client_1.useTouch)();
+    // listen to site changes
+    (0, react_1.useEffect)(() => {
+        // skip if site isn't bound
+        if (!site) {
+            return;
+        }
+        // subscribe to changes
+        const subscription = site.events$.subscribe(() => touch());
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [site, touch]);
+    // return site
+    return site;
+}
+function useSite() {
+    // resolve site
+    const site = usePossibleSite();
+    // throw if there's no site (should never happen)
+    if (!site) {
+        throw new funnel_core_1.InvalidOperationError('Attempt to access Site outside of SiteContext or valid route');
+    }
+    // return site
+    return site;
+}
+// context
+exports.SiteContext = (0, react_1.createContext)({});

package/dist/core/hooks/useTempFields.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { TranslateSchema } from '../domain';
+export declare function useTempFields<TFields extends Record<string, Schema.Optional.Maybe<Schema.Field.Type>>>(schemasRaw: TFields, dependencies?: any[]): TranslateSchema.Fields<TFields>;
+export declare namespace useTempFields {
+    type Args = {
+        schemas: Record<string, Schema.Field.Type>;
+    };
+}

package/dist/core/hooks/useTempFields.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTempFields = useTempFields;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+const repository_1 = require("../repository");
+// hook
+function useTempFields(schemasRaw, dependencies = []) {
+    // bind hooks + fields (track a ref so we don't constantly rebind fields unless deps change)
+    const schemasRef = (0, react_1.useRef)(schemasRaw);
+    const dependenciesRef = (0, react_1.useRef)(dependencies);
+    const previousDependencies = dependenciesRef.current;
+    // update schemas if dependencies have changed
+    if (!funnel_core_1.Value.equals(dependencies, previousDependencies)) {
+        // update schemas
+        schemasRef.current = schemasRaw;
+        // update dependencies
+        dependenciesRef.current = dependencies;
+    }
+    const schemas = schemasRef.current;
+    const fields = (0, react_1.useMemo)(() => {
+        // create temp bus
+        const eventBus = new funnel_core_1.EventBus();
+        // map fields into editor variants
+        return Object.entries(schemas).reduce((fields, [key, schema]) => {
+            // create field if there's a definition
+            if (schema) {
+                const id = key;
+                fields[id] = repository_1.FieldSerializer.deserializeField({
+                    id,
+                    eventBus,
+                    schema: schema.unwrap(),
+                    content: undefined,
+                    snapshot: undefined
+                });
+            }
+            // keep reducing
+            return fields;
+        }, {});
+    }, [schemas]);
+    // listen to fields events (force a re-render of child)
+    const touch = (0, client_1.useTouch)();
+    (0, react_1.useEffect)(() => {
+        // subscribe to changes
+        const subscriptions = Object.values(fields).map(fieldRaw => {
+            const field = fieldRaw;
+            return field.events$.subscribe(() => touch());
+        });
+        // unsubscribe on unmount
+        return () => subscriptions.forEach(subscription => subscription.unsubscribe());
+    }, [touch, fields]);
+    // return fields
+    return fields;
+}

package/dist/core/hooks/useUserBrowser.d.ts

@@ -0,0 +1,5 @@
+import { UserBrowser } from '../domain';
+export declare function useUserBrowser(): UserBrowser;
+export declare namespace useUserBrowser {
+    type Args = Omit<UserBrowser.ConstructorArgs, 'editorApi'>;
+}

package/dist/core/hooks/useUserBrowser.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserBrowser = useUserBrowser;
+const client_1 = require("@nascentdigital/funnel-ui/client");
+const react_1 = require("react");
+const client_2 = require("../client");
+const domain_1 = require("../domain");
+// hook
+function useUserBrowser() {
+    // bind browser + touch
+    const editorApi = (0, client_2.useEditorApi)();
+    const browser = (0, react_1.useMemo)(() => new domain_1.UserBrowser({ editorApi }), [editorApi]);
+    const touch = (0, client_1.useTouch)();
+    // listen to browser changes
+    (0, react_1.useEffect)(() => {
+        // subscribe to changes
+        const subscription = browser.events$.subscribe(() => touch());
+        // initiate sync (if possible)
+        if (browser.state !== 'syncing') {
+            browser.sync()
+                .catch(console.error);
+        }
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [browser, touch]);
+    // return browser
+    return browser;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,12 @@
+export * from './app';
+export * from './auth';
+export * from './client';
+export * from './components';
+export * from './domain';
+export * from './hooks';
+export * from './repository';
+export * from './routing';
+export * from './screens';
+export * from './settings';
+export * from './site-config';
+export * from './splash';

package/dist/core/index.js

@@ -0,0 +1,28 @@
+"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("./app"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./components"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./repository"), exports);
+__exportStar(require("./routing"), exports);
+__exportStar(require("./screens"), exports);
+__exportStar(require("./settings"), exports);
+__exportStar(require("./site-config"), exports);
+__exportStar(require("./splash"), exports);

package/dist/core/repository/CollectionRepository.d.ts

@@ -0,0 +1,29 @@
+import { CollectionClient } from '@nascentdigital/funnel-cms';
+import { EventBus, FieldModel } from '@nascentdigital/funnel-core';
+import { UpdateCollectionCommand } from '../../api/collections';
+import { EditorApiClient } from '../client';
+import { Collection, CollectionFieldProxy } from '../domain';
+import { CollectionTarget } from './CollectionTarget';
+export declare class CollectionRepository {
+    readonly editorApi: EditorApiClient;
+    constructor(editorApi: EditorApiClient);
+    load(args: CollectionTarget.WithEventBus): Promise<import("../domain").CollectionGroup | undefined>;
+    create({ eventBus, ...args }: CollectionRepository.CreateNewArgs): Promise<import("../domain").CollectionGroup>;
+    createLanguage(args: CollectionRepository.CreateLanguageArgs): Promise<import("../domain").CollectionGroup>;
+    save(collection: Collection): Promise<Collection>;
+    unpublish(collection: Collection): Promise<void>;
+    serializeCollectionUpdate(collection: Collection | CollectionFieldProxy, savables: CollectionRepository.Savable[]): UpdateCollectionCommand.Data;
+    private serializeFieldsUpdate;
+    private serializeObjectFieldUpdate;
+    private serializeFieldUpdate;
+    private serializeListUpdate;
+}
+export declare namespace CollectionRepository {
+    type CreateNewArgs = Omit<CollectionClient.Create.NewArgs, 'brand' | 'type' | 'version'> & Pick<Collection.ConstructorArgs, 'template'> & {
+        eventBus?: EventBus;
+    };
+    type CreateLanguageArgs = Omit<CollectionClient.Create.NewLanguageArgs, 'brand'> & Pick<Collection.ConstructorArgs, 'template'> & {
+        eventBus: EventBus;
+    };
+    type Savable = FieldModel;
+}