@nascentdigital/funnel-editor-contentful 4.6.7 → 5.0.2

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;
+    scope: string;
+    tags?: string[];
+    url: string;
+    size: number;
+    metadata: object;
+    media: Contentful.Link.Asset;
+};
+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,89 @@
+"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) {
+        // setup
+        var _a, _b, _c;
+        // upload file
+        const uploadResult = await sdk.cma.upload.create({}, {
+            file: await args.file.arrayBuffer()
+        });
+        // create contentful asset
+        const locale = sdk.locales.default;
+        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]: 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;
+        console.debug('[ContentfulAsset] serializing asset', entry);
+        // 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: (_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;
+    pageRefIds?: string;
+    state: string;
+    errors: boolean;
+    publishedOn?: number;
+    references?: Contentful.Link[];
+};
+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[];
+    };
+}

package/dist/core/contentful/ContentfulRefs.js

@@ -0,0 +1,152 @@
+"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.ContentfulRefs = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const components_1 = require("@nascentdigital/funnel-editor/components");
+const ContentfulAsset_1 = require("./ContentfulAsset");
+const ContentfulCollection_1 = require("./ContentfulCollection");
+const ContentfulPage_1 = require("./ContentfulPage");
+// namespace
+var ContentfulRefs;
+(function (ContentfulRefs) {
+    function find(data) {
+        // prepare sets
+        const assets = new Set();
+        const pages = new Set();
+        const collections = new Set();
+        // extract actual refs
+        funnel_core_1.ObjectUtils.walk(data, ({ value }) => {
+            // track assets
+            if (funnel_core_1.Schema.Asset.filter(value)) {
+                // track file (if it's real)
+                const assetId = funnel_core_1.Schema.Asset.getId(value);
+                if (assetId) {
+                    assets.add(assetId);
+                }
+                // don't recurse
+                return false;
+            }
+            // track page links
+            else if (funnel_core_1.Schema.Field.Data.InternalLink.filter(value)) {
+                // track page (only if the id's real)
+                const pageId = funnel_core_1.Schema.Field.Data.InternalLink.getId(value);
+                if (pageId && pageId !== funnel_core_1.Schema.Page.Id.draft) {
+                    pages.add(pageId);
+                }
+                // don't recurse
+                return false;
+            }
+            // transform collection refs
+            else if (funnel_core_1.Schema.Field.Data.Collection.Ref.filter(value)) {
+                // track collection (only if the id's real)
+                const collectionId = funnel_core_1.Schema.Field.Data.Collection.Ref.getId(value);
+                if (collectionId && collectionId !== funnel_core_1.Schema.Collection.Id.draft) {
+                    collections.add(collectionId);
+                }
+                // don't recurse
+                return false;
+            }
+            // transform page refs
+            else if (funnel_core_1.Schema.Field.Data.Page.filter(value)) {
+                // track page (only if the id's real)
+                const pageId = funnel_core_1.Schema.Field.Data.Page.getId(value);
+                if (pageId && pageId !== funnel_core_1.Schema.Page.Id.draft) {
+                    pages.add(pageId);
+                }
+                // don't recurse
+                return false;
+            }
+            // otherwise recurse deeper
+            else {
+                return true;
+            }
+        });
+        // return refs
+        return {
+            assets,
+            pages,
+            collections
+        };
+    }
+    ContentfulRefs.find = find;
+    function serialize(refs, locale) {
+        var _a, _b, _c, _d;
+        // create empty refs
+        const assets = [];
+        const pages = [];
+        const collections = [];
+        // loop over references and serialize
+        const { Entry: entries = [], Asset: files = [] } = (_a = refs.includes) !== null && _a !== void 0 ? _a : {};
+        for (const entry of entries) {
+            switch (entry.sys.contentType.sys.id) {
+                // asset
+                case ContentfulAsset_1.ContentfulAsset.contentTypeId: {
+                    // try to find file
+                    const fileId = entry.fields.media[locale].sys.id;
+                    const file = files.find(file => file.sys.id === fileId);
+                    if (!file) {
+                        throw new funnel_core_1.NotFoundError(`cannot find Contentful media "${fileId}" for asset "${entry.sys.id}"`);
+                    }
+                    console.debug('[ContentfulRefs/serialize] parsing asset', { entry, file });
+                    assets.push({
+                        __root: 'asset',
+                        type: 'asset',
+                        value: {
+                            id: entry.sys.id,
+                            name: entry.fields.name[locale],
+                            description: (_d = (_b = entry.fields.description[locale]) !== null && _b !== void 0 ? _b : (_c = file.fields.description) === null || _c === void 0 ? void 0 : _c[locale]) !== null && _d !== void 0 ? _d : undefined,
+                            type: entry.fields.type[locale],
+                            brand: entry.fields.brand[locale],
+                            scope: entry.fields.scope[locale],
+                            tags: [],
+                            url: 'https:' + file.fields.file[locale].url,
+                            size: entry.fields.size[locale],
+                            metadata: entry.fields.metadata[locale]
+                        }
+                    });
+                    break;
+                }
+                // page
+                case ContentfulPage_1.ContentfulPage.contentTypeId: {
+                    // convert to link and get template
+                    const pageEntry = entry;
+                    const _e = ContentfulPage_1.ContentfulPage.serializeRemoteLink(pageEntry, locale), { type, tags } = _e, data = __rest(_e, ["type", "tags"]);
+                    const template = funnel_core_1.Schema.Site.getPage(type, data.region);
+                    // push link
+                    pages.push(Object.assign({ template, tags: components_1.TagSerializer.deserializeTags({
+                            groups: template.tags,
+                            tagsData: tags
+                        }) }, data));
+                    break;
+                }
+                // collection
+                case ContentfulCollection_1.ContentfulCollection.contentTypeId: {
+                    // convert to link and get template
+                    const collectionEntry = entry;
+                    const data = ContentfulCollection_1.ContentfulCollection.serializeRemote(collectionEntry, locale);
+                    // push data
+                    collections.push(data);
+                    break;
+                }
+            }
+        }
+        // return
+        return {
+            assets,
+            pages,
+            collections
+        };
+    }
+    ContentfulRefs.serialize = serialize;
+})(ContentfulRefs || (exports.ContentfulRefs = ContentfulRefs = {}));

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

@@ -0,0 +1,5 @@
+export * from './Contentful';
+export * from './ContentfulAsset';
+export * from './ContentfulCollection';
+export * from './ContentfulPage';
+export * from './ContentfulRefs';

package/dist/core/contentful/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("./Contentful"), exports);
+__exportStar(require("./ContentfulAsset"), exports);
+__exportStar(require("./ContentfulCollection"), exports);
+__exportStar(require("./ContentfulPage"), exports);
+__exportStar(require("./ContentfulRefs"), exports);

package/dist/core/index.d.ts

@@ -1,3 +1,4 @@
-export * from './api';
-export * from './domain';
+export * from './bridge';
+export * from './client';
+export * from './contentful';
 export * from './repository';

package/dist/core/index.js

@@ -14,6 +14,7 @@ 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("./api"), exports);
-__exportStar(require("./domain"), exports);
+__exportStar(require("./bridge"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./contentful"), exports);
 __exportStar(require("./repository"), exports);