@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.1

package/dist/core/bridge/AppMessage.d.ts

@@ -0,0 +1,19 @@
+import { Tagged } from 'type-fest';
+export type AppDomain = 'app';
+export interface AppMessage {
+    domain: AppDomain;
+    type: string;
+    timestamp: number;
+}
+export type AppContextId = Tagged<string, 'funnel.AppContextId'>;
+export interface TrackedAppMessage extends AppMessage {
+    source: AppContextId;
+}
+export interface AppBlockNavMessage extends AppMessage {
+    type: 'blockNav';
+    itemId: string;
+}
+export declare namespace AppBlockNavMessage {
+    function create(itemId: string): AppBlockNavMessage;
+    function guard(message: AppMessage): message is AppBlockNavMessage;
+}

package/dist/core/bridge/AppMessage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppBlockNavMessage = void 0;
+var AppBlockNavMessage;
+(function (AppBlockNavMessage) {
+    function create(itemId) {
+        return {
+            domain: 'app',
+            type: 'blockNav',
+            timestamp: Date.now(),
+            itemId
+        };
+    }
+    AppBlockNavMessage.create = create;
+    function guard(message) {
+        return message.domain === 'app' && message.type === 'blockNav';
+    }
+    AppBlockNavMessage.guard = guard;
+})(AppBlockNavMessage || (exports.AppBlockNavMessage = AppBlockNavMessage = {}));

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

@@ -0,0 +1,4 @@
+export * from './AppBridgeContainer';
+export * from './AppBridgeContext';
+export * from './AppMessage';
+export * from './useAppBridge';

package/dist/core/bridge/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("./AppBridgeContainer"), exports);
+__exportStar(require("./AppBridgeContext"), exports);
+__exportStar(require("./AppMessage"), exports);
+__exportStar(require("./useAppBridge"), exports);

package/dist/core/bridge/useAppBridge.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { AppMessage } from './AppMessage';
+export type AppMessageSubmission = Omit<AppMessage, 'source'>;
+export type UseAppBridgetHook = {
+    sendMessage(message: AppMessageSubmission): void;
+    messages$: Observable<AppMessage>;
+};
+export declare function useAppBridge(): UseAppBridgetHook;

package/dist/core/bridge/useAppBridge.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppBridge = useAppBridge;
+const react_1 = require("react");
+const AppBridgeContext_1 = require("./AppBridgeContext");
+// hook
+function useAppBridge() {
+    // bind context
+    const { id, eventBus, channel } = (0, react_1.useContext)(AppBridgeContext_1.AppBridgeContext);
+    // helpers
+    const sendMessage = (message) => {
+        // track the message
+        const trackedMessage = Object.assign({ source: id }, message);
+        // send to local bus
+        eventBus.next(trackedMessage);
+        // echo to remote bus (if any)
+        channel.postMessage(trackedMessage);
+    };
+    // return hook interface
+    return {
+        sendMessage,
+        messages$: eventBus.asObservable()
+    };
+}

package/dist/core/contentful/Contentful.d.ts

@@ -0,0 +1,33 @@
+import type { BaseAppSDK } from '@contentful/app-sdk';
+import { EntryAPI } from '@contentful/app-sdk/dist/types/entry.types';
+import { QueryOptions } from 'contentful-management/dist/typings/common-types';
+import { EntryProps } from 'contentful-management/dist/typings/entities/entry';
+export declare namespace Contentful {
+    type Base = {
+        id: string;
+        createdOn: number;
+        updatedOn: number;
+    };
+    type LinkType = 'Asset' | 'Entry' | 'Upload';
+    type Link<TType extends LinkType = LinkType> = {
+        sys: {
+            type: 'Link';
+            linkType: TType;
+            id: string;
+        };
+    };
+    namespace Link {
+        type Asset = Link<'Asset'>;
+        type Entry = Link<'Entry'>;
+    }
+    function toLink(id: string, linkType: LinkType): Link;
+    type Fields<TData extends Record<string, any>> = {
+        [TKey in Exclude<keyof TData, keyof Base>]: {
+            [locale: string]: TData[TKey];
+        };
+    };
+    function allEntries<T = EntryProps>(sdk: BaseAppSDK, baseQuery?: QueryOptions): Promise<T[]>;
+    function allEntriesNormalized<T extends Base>(sdk: BaseAppSDK, baseQuery?: QueryOptions): Promise<T[]>;
+    function normalize<T extends Base>(entry: EntryAPI): T;
+    function normalizeRemote<T extends Base>({ sys, fields }: EntryProps, locale: string): T;
+}

package/dist/core/contentful/Contentful.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contentful = void 0;
+var Contentful;
+(function (Contentful) {
+    function toLink(id, linkType) {
+        return {
+            sys: {
+                type: 'Link',
+                linkType,
+                id
+            }
+        };
+    }
+    Contentful.toLink = toLink;
+    async function allEntries(sdk, baseQuery = {}) {
+        // setup
+        let skip = 0;
+        const limit = baseQuery.limit || 1000;
+        let total = 1;
+        const allItems = [];
+        // loop until no more pages
+        while (skip < total) {
+            const response = await sdk.cma.entry.getMany({
+                query: Object.assign(Object.assign({}, baseQuery), { limit,
+                    skip })
+            });
+            total = response.total;
+            allItems.push(...response.items);
+            skip += limit;
+        }
+        // return
+        return allItems;
+    }
+    Contentful.allEntries = allEntries;
+    async function allEntriesNormalized(sdk, baseQuery = {}) {
+        // locale
+        const locale = sdk.locales.default;
+        // fetch items
+        const items = await allEntries(sdk, baseQuery);
+        // normalize
+        return items.map(item => normalizeRemote(item, locale));
+    }
+    Contentful.allEntriesNormalized = allEntriesNormalized;
+    function normalize(entry) {
+        // get sys
+        const sys = entry.getSys();
+        // simplify fields (remove locale)
+        const normalizedFields = {};
+        for (const key in entry.fields) {
+            normalizedFields[key] = entry.fields[key].getValue();
+        }
+        // return normalized form
+        return Object.assign({ id: sys.id, createdOn: new Date(sys.createdAt).getTime(), updatedOn: new Date(sys.updatedAt).getTime() }, normalizedFields);
+    }
+    Contentful.normalize = normalize;
+    function normalizeRemote({ sys, fields }, locale) {
+        // simplify fields (remove locale)
+        const normalizedFields = {};
+        for (const key in fields) {
+            normalizedFields[key] = fields[key][locale];
+        }
+        // return normalized form
+        return Object.assign({ id: sys.id, createdOn: new Date(sys.createdAt).getTime(), updatedOn: new Date(sys.updatedAt).getTime() }, normalizedFields);
+    }
+    Contentful.normalizeRemote = normalizeRemote;
+})(Contentful || (exports.Contentful = Contentful = {}));

package/dist/core/contentful/ContentfulAsset.d.ts

@@ -0,0 +1,23 @@
+import { EditorAppSDK } from '@contentful/app-sdk';
+import { Schema } from '@nascentdigital/funnel-core';
+import { IAssetRepository } from '@nascentdigital/funnel-editor/components';
+import type { EntryProps } from 'contentful-management/dist/typings/entities/entry';
+import { Contentful } from './Contentful';
+export type ContentfulAsset = Contentful.Base & {
+    name: string;
+    description?: string | null;
+    brand?: string | null;
+    type: string;
+    media: Contentful.Link.Asset;
+    metadata: object;
+    scope: string;
+    tags?: string | null;
+    url: string;
+    size: number;
+};
+export declare namespace ContentfulAsset {
+    const contentTypeId: "asset";
+    type Remote = EntryProps<Contentful.Fields<ContentfulAsset>>;
+    function upload(args: IAssetRepository.UploadFile.Args, sdk: EditorAppSDK): Promise<Remote>;
+    function serialize(entry: Remote, locale: string): Schema.Asset.Linked;
+}

package/dist/core/contentful/ContentfulAsset.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulAsset = void 0;
+// extension
+var ContentfulAsset;
+(function (ContentfulAsset) {
+    // consts
+    ContentfulAsset.contentTypeId = 'asset';
+    // helpers
+    async function upload(args, sdk) {
+        var _a, _b, _c;
+        // setup
+        const locale = sdk.locales.default;
+        // upload file
+        const uploadResult = await sdk.cma.upload.create({}, {
+            file: await args.file.arrayBuffer()
+        });
+        // create contentful asset
+        const contentfulAsset = await sdk.cma.asset.create({}, {
+            fields: {
+                title: { [locale]: args.name },
+                description: { [locale]: (_a = args.description) !== null && _a !== void 0 ? _a : '' },
+                file: {
+                    [locale]: {
+                        contentType: args.file.type,
+                        fileName: args.name,
+                        uploadFrom: {
+                            sys: {
+                                type: 'Link',
+                                linkType: 'Upload',
+                                id: uploadResult.sys.id
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // process contentful asset (creates url etc.) and return
+        const processedAsset = await sdk.cma.asset.processForAllLocales({}, contentfulAsset);
+        // create funnel asset then return
+        return await sdk.cma.entry.create({ contentTypeId: ContentfulAsset.contentTypeId }, {
+            fields: {
+                name: { [locale]: args.name },
+                description: { [locale]: (_b = args.description) !== null && _b !== void 0 ? _b : null },
+                brand: { [locale]: (_c = args.brand) !== null && _c !== void 0 ? _c : null },
+                type: { [locale]: args.type },
+                scope: { [locale]: args.scope },
+                tags: { [locale]: JSON.stringify(args.tags) },
+                url: { [locale]: 'https:' + processedAsset.fields.file[locale].url },
+                size: { [locale]: args.size },
+                metadata: { [locale]: args.metadata },
+                media: {
+                    [locale]: {
+                        sys: {
+                            type: 'Link',
+                            linkType: 'Asset',
+                            id: processedAsset.sys.id
+                        }
+                    }
+                }
+            }
+        });
+    }
+    ContentfulAsset.upload = upload;
+    function serialize(entry, locale) {
+        var _a, _b;
+        // extract fields
+        const { name, description, type, brand, metadata, scope, tags, url, size } = entry.fields;
+        // create asset
+        return {
+            __root: 'asset',
+            type: 'asset',
+            value: {
+                id: entry.sys.id,
+                name: name[locale],
+                description: description === null || description === void 0 ? void 0 : description[locale],
+                type: type[locale],
+                brand: (_a = brand === null || brand === void 0 ? void 0 : brand[locale]) !== null && _a !== void 0 ? _a : undefined,
+                metadata: metadata[locale],
+                scope: scope[locale],
+                tags: JSON.parse((_b = tags === null || tags === void 0 ? void 0 : tags[locale]) !== null && _b !== void 0 ? _b : '[]'),
+                url: url[locale],
+                size: size[locale]
+            }
+        };
+    }
+    ContentfulAsset.serialize = serialize;
+})(ContentfulAsset || (exports.ContentfulAsset = ContentfulAsset = {}));

package/dist/core/contentful/ContentfulCollection.d.ts

@@ -0,0 +1,29 @@
+import { EntryAPI } from '@contentful/app-sdk/dist/types/entry.types';
+import { Schema } from '@nascentdigital/funnel-core';
+import { EntryProps } from 'contentful-management/dist/typings/entities/entry';
+import { Contentful } from './Contentful';
+export type ContentfulCollection = Contentful.Base & {
+    groupId: string;
+    name: string;
+    type: string;
+    brand?: string;
+    language: string;
+    version: number;
+    tags?: string;
+    fields: object;
+    references?: Contentful.Link[];
+    pageRefIds?: string;
+    state: string;
+    errors: boolean;
+    publishedOn?: number;
+};
+export declare namespace ContentfulCollection {
+    const contentTypeId: "collection";
+    type Remote = EntryProps<Contentful.Fields<ContentfulCollection>>;
+    function serialize(entry: EntryAPI): Schema.Collection.Data;
+    function serializeRemoteRef(entry: Remote, locale: string): Schema.Collection.Data.AsRef;
+    function serializeRemote(entry: Remote, locale: string): Schema.Collection.Data;
+    function serializeRemoteWithRefs(entry: Remote, locale: string): Schema.Collection.FlattenedData;
+    function deserialize(data: Schema.Collection.Data): ContentfulCollection;
+    function deserializeLinks(collection: ContentfulCollection): Contentful.Link[];
+}

package/dist/core/contentful/ContentfulCollection.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCollection = void 0;
+const Contentful_1 = require("./Contentful");
+const ContentfulRefs_1 = require("./ContentfulRefs");
+// extension
+var ContentfulCollection;
+(function (ContentfulCollection) {
+    // consts
+    ContentfulCollection.contentTypeId = 'collection';
+    // helpers
+    function serialize(entry) {
+        // normalize
+        const normalized = Contentful_1.Contentful.normalize(entry);
+        // create collection data
+        return normalizedToData(normalized);
+    }
+    ContentfulCollection.serialize = serialize;
+    function serializeRemoteRef(entry, locale) {
+        // normalize
+        const normalized = Contentful_1.Contentful.normalizeRemote(entry, locale);
+        // return collection ref data
+        return normalizedToRef(normalized);
+    }
+    ContentfulCollection.serializeRemoteRef = serializeRemoteRef;
+    function serializeRemote(entry, locale) {
+        // normalize
+        const normalized = Contentful_1.Contentful.normalizeRemote(entry, locale);
+        // create collection data
+        return normalizedToData(normalized);
+    }
+    ContentfulCollection.serializeRemote = serializeRemote;
+    function serializeRemoteWithRefs(entry, locale) {
+        // normalize
+        const normalized = Contentful_1.Contentful.normalizeRemote(entry, locale);
+        // create collection flattened data
+        return normalizeToFlattened(normalized);
+    }
+    ContentfulCollection.serializeRemoteWithRefs = serializeRemoteWithRefs;
+    function deserialize(data) {
+        var _a;
+        return {
+            id: data.id,
+            groupId: data.groupId,
+            type: data.type,
+            version: data.version,
+            language: data.language,
+            state: data.state,
+            name: data.name,
+            fields: data.fields,
+            tags: JSON.stringify((_a = data.tags) !== null && _a !== void 0 ? _a : []),
+            errors: data.errors,
+            createdOn: data.createdOn,
+            updatedOn: data.updatedOn
+        };
+    }
+    ContentfulCollection.deserialize = deserialize;
+    function deserializeLinks(collection) {
+        const refs = ContentfulRefs_1.ContentfulRefs.find({ fields: collection.fields });
+        const entryIds = [
+            ...refs.assets.values(),
+            ...refs.pages.values(),
+            ...refs.collections.values()
+        ];
+        return entryIds.map(id => Contentful_1.Contentful.toLink(id, 'Entry'));
+    }
+    ContentfulCollection.deserializeLinks = deserializeLinks;
+    // private helpers
+    function normalizedToRef(data) {
+        var _a;
+        return {
+            id: data.id,
+            groupId: data.groupId,
+            version: data.version,
+            type: data.type,
+            brand: data.brand,
+            language: data.language,
+            state: data.state,
+            name: data.name,
+            tags: JSON.parse((_a = data.tags) !== null && _a !== void 0 ? _a : '[]'),
+            errors: data.errors,
+            createdOn: data.createdOn,
+            updatedOn: data.updatedOn,
+            publishedOn: data.publishedOn
+        };
+    }
+    function normalizedToData(data) {
+        return Object.assign(Object.assign({ __root: 'collection' }, normalizedToRef(data)), { fields: data.fields });
+    }
+    function normalizeToFlattened(data) {
+        return {
+            data: normalizedToData(data),
+            files: {},
+            collections: {}
+        };
+    }
+})(ContentfulCollection || (exports.ContentfulCollection = ContentfulCollection = {}));

package/dist/core/contentful/ContentfulPage.d.ts

@@ -0,0 +1,31 @@
+import { EntryAPI } from '@contentful/app-sdk/dist/types/entry.types';
+import { Schema } from '@nascentdigital/funnel-core';
+import { EntryProps } from 'contentful-management/dist/typings/entities/entry';
+import { Contentful } from './Contentful';
+export type ContentfulPage = Contentful.Base & {
+    groupId: string;
+    type: string;
+    name: string;
+    brand: string;
+    region: string;
+    language: string;
+    slug?: string;
+    tags: string;
+    url: string;
+    discover: object;
+    preview?: object;
+    content: object;
+    state: string;
+    errors: boolean;
+    publishedOn?: number;
+    publication?: number;
+};
+export declare namespace ContentfulPage {
+    const contentTypeId: "page";
+    type Remote = EntryProps<Contentful.Fields<ContentfulPage>>;
+    function serialize(entry: EntryAPI): Schema.Page.Data;
+    function serializeRemoteLink(entry: Remote, locale: string): Schema.Page.Data.AsLink;
+    function deserialize(data: Schema.Page.Data): ContentfulPage;
+    function deserializeLinks(page: ContentfulPage): Contentful.Link[];
+    function normalizedToLink(data: ContentfulPage): Schema.Page.Data.AsLink;
+}

package/dist/core/contentful/ContentfulPage.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulPage = void 0;
+const Contentful_1 = require("./Contentful");
+const ContentfulRefs_1 = require("./ContentfulRefs");
+// extension
+var ContentfulPage;
+(function (ContentfulPage) {
+    // consts
+    ContentfulPage.contentTypeId = 'page';
+    // helpers
+    function serialize(entry) {
+        // normalize entry
+        const normalized = Contentful_1.Contentful.normalize(entry);
+        // return data
+        return Object.assign(Object.assign({ __root: 'page' }, normalizedToLink(normalized)), { discover: normalized.discover, preview: normalized.preview, content: normalized.content });
+    }
+    ContentfulPage.serialize = serialize;
+    function serializeRemoteLink(entry, locale) {
+        // normalize entry
+        const normalized = Contentful_1.Contentful.normalizeRemote(entry, locale);
+        // return link data
+        return normalizedToLink(normalized);
+    }
+    ContentfulPage.serializeRemoteLink = serializeRemoteLink;
+    function deserialize(data) {
+        var _a;
+        return {
+            id: data.id,
+            createdOn: data.createdOn,
+            updatedOn: data.updatedOn,
+            name: data.name,
+            groupId: data.groupId,
+            type: data.type,
+            brand: data.brand,
+            region: data.region,
+            language: data.language,
+            slug: data.slug,
+            url: data.url,
+            tags: JSON.stringify((_a = data.tags) !== null && _a !== void 0 ? _a : []),
+            discover: data.discover,
+            preview: data.preview,
+            content: data.content,
+            errors: data.errors,
+            state: data.state,
+            publishedOn: data.publishedOn,
+            publication: data.publication
+        };
+    }
+    ContentfulPage.deserialize = deserialize;
+    function deserializeLinks(page) {
+        const refs = ContentfulRefs_1.ContentfulRefs.find({ content: page.content });
+        const entryIds = [
+            ...refs.assets.values(),
+            ...refs.pages.values(),
+            ...refs.collections.values()
+        ];
+        return entryIds.map(id => Contentful_1.Contentful.toLink(id, 'Entry'));
+    }
+    ContentfulPage.deserializeLinks = deserializeLinks;
+    // private helpers
+    function normalizedToLink(data) {
+        var _a;
+        return {
+            id: data.id,
+            groupId: data.groupId,
+            type: data.type,
+            brand: data.brand,
+            region: data.region,
+            language: data.language,
+            state: data.state,
+            name: data.name,
+            url: data.url,
+            slug: data.slug,
+            errors: data.errors,
+            publishedOn: data.publishedOn,
+            publication: data.publication,
+            tags: JSON.parse((_a = data.tags) !== null && _a !== void 0 ? _a : '[]'),
+            createdOn: data.createdOn,
+            updatedOn: data.updatedOn
+        };
+    }
+    ContentfulPage.normalizedToLink = normalizedToLink;
+})(ContentfulPage || (exports.ContentfulPage = ContentfulPage = {}));

package/dist/core/contentful/ContentfulRefs.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from '@nascentdigital/funnel-core';
+import { Asset, IPage } from '@nascentdigital/funnel-editor/components';
+import type { EntryReferenceProps } from 'contentful-management/dist/typings/entities/entry';
+export declare namespace ContentfulRefs {
+    type Computed = {
+        assets: Set<Schema.Asset.Id>;
+        pages: Set<Schema.Page.Id>;
+        collections: Set<Schema.Collection.Id>;
+    };
+    function find(data: any): Computed;
+    function serialize(refs: EntryReferenceProps, locale: string): {
+        assets: Asset[];
+        pages: IPage.Ref[];
+        collections: Schema.Collection.Data.AsLink[];
+    };
+}