@nascentdigital/funnel-core 4.5.7 → 4.6.1

package/dist/schema/Collection.d.ts

@@ -36,10 +36,10 @@ export declare namespace Collection {
     namespace Update {
         type Collection = Collection.Name | Collection.Tags | Collection.Errors;
         namespace Collection {
-            type Factory<TProp extends keyof Data> = {
+            type Factory<TProp extends keyof LegacyData> = {
                 type: 'collection';
                 property: TProp;
-                value: UndefinedToNull<Data[TProp]>;
+                value: UndefinedToNull<LegacyData[TProp]>;
             };
             export type Name = Factory<'name'>;
             export type Tags = Factory<'tags'>;
@@ -75,6 +75,27 @@ export declare namespace Collection {
         };
     }
     type Data<T extends Collection = Collection> = {
+        __root: 'collection';
+        id: Id;
+        groupId: GroupId;
+        type: T['type'];
+        tags: TagGroup.Data;
+        brand?: string;
+        language: Language;
+        version: number;
+        name: string;
+        fields: Data.ForFields<T['fields']>;
+        pageIds?: Page.Id[];
+        state: State;
+        errors: boolean;
+        changeSetId?: ChangeSet.Id;
+        snapshotId?: CollectionSnapshot.Id;
+        snapshot?: CollectionSnapshot;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+    };
+    type LegacyData<T extends Collection = Collection> = {
         __root: 'collection';
         id: Id;
         groupId: GroupId;
@@ -109,20 +130,20 @@ export declare namespace Collection {
             const audit: ReadonlyArray<Audit>;
             type Backup = Extract<All, 'snapshot'>;
             const backup: ReadonlyArray<Backup>;
-            type All = keyof Data;
+            type All = keyof LegacyData;
             const all: ReadonlyArray<All>;
         }
-        type AsDraft = Pick<Data, AsDraft.Prop>;
+        type AsDraft = Pick<LegacyData, AsDraft.Prop>;
         namespace AsDraft {
             type Prop = Exclude<Props.Id, 'id'> | Extract<Props.Audit, 'changeSetId'>;
             const props: ReadonlyArray<Prop>;
         }
-        type AsNew = Pick<Data, AsNew.Prop>;
+        type AsNew = Pick<LegacyData, AsNew.Prop>;
         namespace AsNew {
             type Prop = Exclude<Props.Id, 'id' | 'groupId'> | Extract<Props.Audit, 'changeSetId'>;
             const props: ReadonlyArray<Prop>;
         }
-        type AsNewLanguage = Pick<Data, AsNewLanguage.Prop>;
+        type AsNewLanguage = Pick<LegacyData, AsNewLanguage.Prop>;
         namespace AsNewLanguage {
             type Prop = Extract<Props.Id, 'type' | 'brand' | 'groupId' | 'version' | 'language'> | Extract<Props.Audit, 'changeSetId'>;
             const props: ReadonlyArray<Prop>;
@@ -138,7 +159,7 @@ export declare namespace Collection {
             type Prop = Props.Id | Props.Content | Extract<Props.Links, 'pageIds'> | Props.Audit;
             const props: ReadonlyArray<Prop>;
         }
-        type AsContent = Pick<Data, AsContent.Prop>;
+        type AsContent = Pick<LegacyData, AsContent.Prop>;
         namespace AsContent {
             type Prop = Props.Id | Props.Content | Props.Links | Props.Audit;
             const props: ReadonlyArray<Prop>;
@@ -151,7 +172,7 @@ export declare namespace Collection {
                 name: string;
                 instances: AsGroup.Instance[];
             };
-            collection?: Data;
+            collection?: FlattenedData;
         };
         namespace AsGroup {
             type Instance = Pick<Data, Instance.Prop>;
@@ -172,12 +193,22 @@ export declare namespace Collection {
             [key in keyof T as T[key] extends Optional<Field.Type> ? key : never]?: Field.Data.ForOptionalType<T[key]>;
         };
     }
+    type References = {
+        files: Record<Asset.Id, Asset.Linked>;
+        collections: Record<Collection.Id, Collection.Data.AsLink>;
+    };
+    type FlattenedData<T extends Collection = Collection> = References & {
+        data: Data<T>;
+    };
+    namespace FlattenedData {
+        function filter(value: any): value is FlattenedData;
+    }
     type LinkedData<T extends Collection = Collection> = LinkedData.FromRef<T> | LinkedData.FromInline<T>;
     namespace LinkedData {
-        type FromRef<T extends Collection = Collection> = Omit<Data<T>, 'fields'> & {
+        type FromRef<T extends Collection = Collection> = Omit<LegacyData<T>, 'fields'> & {
             fields: ForFields<T['fields']>;
         };
-        type FromInline<T extends Collection = Collection> = Pick<Data<T>, Exclude<Data.AsInline.Prop, 'fields'>> & {
+        type FromInline<T extends Collection = Collection> = Pick<LegacyData<T>, Exclude<Data.AsInline.Prop, 'fields'>> & {
             fields: ForFields<T['fields']>;
         };
         type ForFields<T extends Fields = Fields> = {

package/dist/schema/Collection.js

@@ -162,4 +162,17 @@ exports.Collection = Collection;
         }
         Data.filter = filter;
     })(Data = Collection.Data || (Collection.Data = {}));
+    let FlattenedData;
+    (function (FlattenedData) {
+        function filter(value) {
+            return utils_1.Value.typeOf(value) === 'object'
+                && 'data' in value
+                && Data.filter(value.data)
+                && 'files' in value
+                && utils_1.Value.typeOf(value.files) === 'object'
+                && 'collections' in value
+                && utils_1.Value.typeOf(value.collections) === 'object';
+        }
+        FlattenedData.filter = filter;
+    })(FlattenedData = Collection.FlattenedData || (Collection.FlattenedData = {}));
 })(Collection || (exports.Collection = Collection = {}));

package/dist/schema/CollectionModel.d.ts

@@ -1,7 +1,7 @@
 import { Collection } from './Collection';
 export declare class CollectionModel {
-    readonly data: Collection.Data;
-    constructor(data: Collection.Data);
+    readonly data: Collection.LegacyData;
+    constructor(data: Collection.LegacyData);
     /**
      * Synchronizes computed properties with the latest `CollectionModel` data (e.g. updating `name`)
      */
@@ -21,7 +21,7 @@ export declare class CollectionModel {
     private setValue;
     private find;
     private findInValue;
-    static from(data: Collection.Data): CollectionModel;
+    static from(data: Collection.LegacyData): CollectionModel;
     static fromDraft(data: Collection.Data.AsDraft): CollectionModel;
 }
 export declare namespace CollectionModel {

package/dist/schema/CollectionSnapshot.d.ts

@@ -1,7 +1,7 @@
 import { Tagged } from 'type-fest';
 import { RequiredBy } from '../types';
 import type { Collection } from './Collection';
-export type CollectionSnapshot = RequiredBy<Pick<Collection.Data, Exclude<Collection.Data.Props.Id, 'id'> | Collection.Data.Props.Content | 'createdOn' | 'updatedOn' | 'changeSetId'>, 'changeSetId'> & {
+export type CollectionSnapshot = RequiredBy<Pick<Collection.LegacyData, Exclude<Collection.Data.Props.Id, 'id'> | Collection.Data.Props.Content | 'createdOn' | 'updatedOn' | 'changeSetId'>, 'changeSetId'> & {
     id: CollectionSnapshot.Id;
 };
 export declare namespace CollectionSnapshot {

package/dist/schema/LinkedCollectionModel.d.ts

@@ -5,5 +5,5 @@ import { Collection } from './Collection';
 export declare class LinkedCollectionModel<TCollection extends Collection> {
     readonly data: Collection.LinkedData<TCollection>;
     constructor(data: Collection.LinkedData<TCollection>);
-    static fromCollectionData<TCollection extends Collection>(unlinkedData: Collection.Data<TCollection>): LinkedCollectionModel<TCollection>;
+    static fromCollectionData<TCollection extends Collection>(unlinkedData: Collection.LegacyData<TCollection>): LinkedCollectionModel<TCollection>;
 }

package/dist/schema/LinkedData.d.ts

@@ -6,39 +6,58 @@ import { DynamicPagesField, Field } from './field';
 import { Page } from './Page';
 export declare namespace LinkedData {
     /**
-     * Link data, only resolving static links
+     * Link data, only resolving static references
      */
-    function resolveStatic<TLinked>(args: Omit<LinkArgs, 'resolvers'>): TLinked;
+    export function resolveStatic<TLinked>(args: Omit<LinkedDataArgs, 'resolvers'>): TLinked;
     /**
-     * Link data, resolving static and dynamic links
+     * Link data, resolving static and dynamic references
      */
-    function resolve<TLinked>(args: LinkArgs): Promise<TLinked>;
-    type LinkArgs = {
+    export function resolve<TLinked>(args: LinkedDataArgs): Promise<TLinked>;
+    /**
+     * Find all dynamic references in data
+     */
+    export function findDynamicRefs(unlinkedData: UnlinkedData): DynamicRefs;
+    /**
+     * Resolve dynamic references using resolvers
+     */
+    export function resolveDynamicRefs({ dynamicRefs, resolvers: { page: pageResolver } }: ResolveDynamicPagesArgs): Promise<DynamicEntities>;
+    export type LinkedDataArgs = {
         unlinkedData: UnlinkedData;
         resolvers: DynamicResolvers;
         persona?: string;
         stores?: TransformFromStores;
+        skipEntitiesScan?: boolean;
+    };
+    type ResolveDynamicPagesArgs = {
+        dynamicRefs: DynamicRefs;
+        resolvers: DynamicResolvers;
     };
-    type UnlinkedData = ReadonlyObjectDeep<any>;
-    type StaticallyLinkedData = Tagged<UnlinkedData, 'linked.statically'>;
-    type TransformFromStores = {
+    export type UnlinkedData = ReadonlyObjectDeep<any>;
+    export type DynamicRefs = Map<DynamicPagesField.Hash, Field.Data.DynamicPages[]>;
+    export type DynamicEntities = Map<DynamicPagesField.Hash, Page.LinkedData.AsPreview[]>;
+    export type StaticallyLinkedData = Tagged<UnlinkedData, 'linked.statically'>;
+    export type TransformFromStores = {
+        pages?: ReadonlyArray<Page.Data>;
         assets?: ReadonlyArray<Asset.Linked>;
         collections?: ReadonlyArray<Collection.Data.AsLink>;
+        dynamic?: DynamicEntities;
     };
-    type References = {
+    export type Entities = {
         pages: Map<Page.Id, Page.Data>;
         collections: Map<Collection.Id, Collection.Data.AsLink>;
         assets: Map<Asset.Id, Asset.Linked>;
+        dynamic: DynamicEntities;
     };
-    type UnlinkedReferences = {
+    export type References = {
         pageRefs: Map<Page.Id, Field.Data.Page[]>;
         collectionRefs: Map<Collection.Id, Field.Data.Collection.Ref[]>;
         assetRefs: Map<Asset.Id, Asset[]>;
-        dynamicPages: Field.Data.DynamicPages[];
+        dynamicRefs: DynamicRefs;
     };
-    type PageQuery = DynamicPagesField.Query;
-    type PageResolver = (value: PageQuery) => Promise<Page.Data.AsPreview[]>;
-    type DynamicResolvers = {
+    export type PageQuery = DynamicPagesField.Query;
+    export type PageResolver = (value: PageQuery) => Promise<Page.Data.AsPreview[]>;
+    export type DynamicResolvers = {
         page: PageResolver;
     };
+    export {};
 }

package/dist/schema/LinkedData.js

@@ -11,66 +11,87 @@ const Page_1 = require("./Page");
 var LinkedData;
 (function (LinkedData) {
     /**
-     * Link data, only resolving static links
+     * Link data, only resolving static references
      */
     function resolveStatic(args) {
-        // base transform (only static linking)
-        const { data } = baseTransform(args);
+        // base setup
+        const { data, references, entities } = setup(args);
+        // dereference data (mutates data)
+        link({ references, entities });
         // return statically linked data
         return data;
     }
     LinkedData.resolveStatic = resolveStatic;
     /**
-     * Link data, resolving static and dynamic links
+     * Link data, resolving static and dynamic references
      */
     async function resolve(args) {
-        // base transform (only static linking)
-        const { data, unlinkedReferences } = baseTransform(args);
-        // resolve dynamic links (mutates data)
-        await resolveDynamicLinks({ unlinkedReferences, resolvers: args.resolvers });
+        // base setup
+        const { data, references, entities } = setup(args);
+        // resolve dynamic references
+        entities.dynamic = await resolveDynamicRefs({
+            dynamicRefs: references.dynamicRefs,
+            resolvers: args.resolvers
+        });
+        // dereference data (mutates data)
+        link({ references, entities });
         // return linked data
         return data;
     }
     LinkedData.resolve = resolve;
     // base transform
-    function baseTransform(args) {
-        // clone unlinked data (this will be mutated)
+    function setup(args) {
+        // clone unlinked data (prevent data passed in from being mutated)
         const unlinkedData = utils_1.ObjectUtils.clone(args.unlinkedData);
         // resolve persona values (mutates data)
         resolvePersonas({ data: unlinkedData, persona: args.persona });
-        // find all references in data
-        const references = findReferences(unlinkedData);
-        // load references from store (mutates references)
+        // find all entities in data
+        const entities = args.skipEntitiesScan
+            ? createEmptyEntities()
+            : findEntities(unlinkedData);
+        // load entities from store
         if (args.stores) {
-            loadStores({ stores: args.stores, references });
+            loadFromStores({ stores: args.stores, entities });
         }
         // find all unlinked references
-        const unlinkedReferences = findUnlinkedReferences(unlinkedData);
-        // resolve static links (mutates data)
-        resolveStaticLinks({ references, unlinkedReferences });
+        const references = findReferences(unlinkedData);
         // return
         return {
-            references, unlinkedReferences, data: unlinkedData
+            entities, references, data: unlinkedData
         };
     }
     // load stores
-    function loadStores({ stores, references }) {
-        const { assets = [], collections = [] } = stores;
+    function loadFromStores({ stores, entities }) {
+        const { pages = [], assets = [], collections = [], dynamic } = stores;
+        // load pages
+        pages.forEach(page => {
+            entities.pages.set(page.id, page);
+        });
         // load assets
         assets.forEach(asset => {
-            references.assets.set(asset.value.id, asset);
+            entities.assets.set(asset.value.id, asset);
         });
         // load collections
         collections.forEach(collection => {
-            references.collections.set(collection.id, collection);
+            entities.collections.set(collection.id, collection);
+        });
+        // load dynamic entities
+        dynamic === null || dynamic === void 0 ? void 0 : dynamic.forEach((value, key) => {
+            entities.dynamic.set(key, value);
         });
     }
-    // find references
-    function findReferences(unlinkedData) {
-        // create empty references
+    function createEmptyEntities() {
+        // create empty entities
         const pages = new Map();
         const collections = new Map();
         const assets = new Map();
+        const dynamic = new Map();
+        // return entities
+        return { pages, collections, assets, dynamic };
+    }
+    function findEntities(unlinkedData) {
+        // create empty entities
+        const { pages, collections, assets, dynamic } = createEmptyEntities();
         // walk unlinked data
         utils_1.ObjectUtils.walk(unlinkedData, ({ value }) => {
             // page data
@@ -112,16 +133,49 @@ var LinkedData;
             // otherwise just keep walking
             return true;
         });
-        // return references
-        return { pages, collections, assets };
+        // return entities
+        return { pages, collections, assets, dynamic };
     }
-    // find unlinked references
-    function findUnlinkedReferences(unlinkedData) {
+    /**
+     * Find all dynamic references in data
+     */
+    function findDynamicRefs(unlinkedData) {
+        // create empty unlinked references
+        const dynamicPageRefs = new Map();
+        // helper
+        const upsertRef = (id, value, map) => {
+            const refs = map.get(id);
+            if (refs) {
+                refs.push(value);
+            }
+            else {
+                map.set(id, [value]);
+            }
+        };
+        // walk unlinked data
+        utils_1.ObjectUtils.walk(unlinkedData, ({ value }) => {
+            // dynamic ref
+            if (field_1.Field.Data.DynamicPages.filter(value)) {
+                const dynamicId = field_1.DynamicPagesField.Value.hash(value);
+                upsertRef(dynamicId, value, dynamicPageRefs);
+                return false;
+            }
+            // otherwise just keep walking
+            return true;
+        });
+        // return unlinked references
+        return dynamicPageRefs;
+    }
+    LinkedData.findDynamicRefs = findDynamicRefs;
+    /**
+     * Find all references in data
+     */
+    function findReferences(unlinkedData) {
         // create empty unlinked references
         const pageRefs = new Map();
         const collectionRefs = new Map();
         const assetRefs = new Map();
-        const dynamicPages = [];
+        const dynamicRefs = new Map();
         // helper
         const upsertRef = (id, value, map) => {
             const refs = map.get(id);
@@ -154,20 +208,23 @@ var LinkedData;
             }
             // dynamic ref
             else if (field_1.Field.Data.DynamicPages.filter(value)) {
-                dynamicPages.push(value);
+                const dynamicId = field_1.DynamicPagesField.Value.hash(value);
+                upsertRef(dynamicId, value, dynamicRefs);
                 return true;
             }
             // otherwise just keep walking
             return true;
         });
         // return unlinked references
-        return { pageRefs, collectionRefs, assetRefs, dynamicPages };
+        return { pageRefs, collectionRefs, assetRefs, dynamicRefs };
     }
-    // resolve static links
-    function resolveStaticLinks({ references, unlinkedReferences }) {
+    /**
+     * Link entities to references
+     */
+    function link({ entities, references }) {
         // setup
-        const { pages, collections, assets } = references;
-        const { pageRefs, collectionRefs, assetRefs } = unlinkedReferences;
+        const { pages, collections, assets, dynamic } = entities;
+        const { pageRefs, collectionRefs, assetRefs, dynamicRefs } = references;
         // resolve page refs
         pageRefs.forEach((refs, id) => {
             const pageData = pages.get(id);
@@ -202,6 +259,24 @@ var LinkedData;
                 delete ref.__ref;
             });
         });
+        // dynamic page refs
+        dynamicRefs.forEach((refs, hash) => {
+            const pagePreviews = dynamic.get(hash);
+            // for each reference change to new shape
+            refs.forEach(ref => {
+                var _a;
+                const staticPagesData = (_a = ref.value.staticPages) !== null && _a !== void 0 ? _a : [];
+                ref.value = pagePreviews
+                    ? {
+                        // @ts-expect-error changing type
+                        pages: [
+                            ...staticPagesData.map(item => item.value),
+                            ...pagePreviews
+                        ]
+                    }
+                    : ref.value;
+            });
+        });
     }
     function resolvePersonas({ data, persona }) {
         var _a;
@@ -234,55 +309,34 @@ var LinkedData;
             delete field.personas;
         }
     }
-    // resolve dynamic links
-    async function resolveDynamicLinks({ unlinkedReferences, resolvers: { page: pageResolver } }) {
-        // TODO: get limit from some meta data in content, assuming 3 for now
-        const TEMP_LIMIT = 3;
-        // setup
-        const { dynamicPages } = unlinkedReferences;
-        // go through each dynamic ref and resolve query
-        await Promise.all(dynamicPages.map(async (dynamicPages) => {
-            const { types, sort, staticPages: staticPagesRaw = [] } = dynamicPages.value;
-            const staticPages = staticPagesRaw.map(item => item.value);
-            // if we have enough static items, linked value becomes static values
-            // TODO: remove hardcoded schema in value
-            if (staticPages.length >= TEMP_LIMIT) {
-                dynamicPages.value = {
-                    // @ts-expect-error changing type on purpose
-                    __schema: {
-                        types: ['case-study'],
-                        size: TEMP_LIMIT
-                    },
-                    pages: staticPages
-                };
+    /**
+     * Resolve dynamic references using resolvers
+     */
+    async function resolveDynamicRefs({ dynamicRefs, resolvers: { page: pageResolver } }) {
+        // create unique requests for dynamic references
+        const requests = Array.from(dynamicRefs).map(async ([hash, data]) => {
+            // only grab the first dynamic reference (should all be the same)
+            const { types, sort, staticPages = [], schema } = data[0].value;
+            // we have enough already (don't need to resolve)
+            if (staticPages.length >= schema.size) {
+                return [hash, []];
             }
-            // otherwise we need to fetch items, combining
+            // otherwise we need to resolve reference
             else {
                 // get ids to exclude
-                const excludeIds = staticPages.map(page => page.id);
+                const excludeIds = staticPages.map(page => page.value.id);
                 // fetch only needed amount
-                const limit = TEMP_LIMIT - staticPages.length;
+                const limit = schema.size - staticPages.length;
                 // fetch dynamic items
                 const resolvedPages = await pageResolver({ types, excludeIds, sort, limit });
                 const linkedResolvedPages = resolveStatic({
                     unlinkedData: resolvedPages
                 });
-                console.debug('[LinkData] dynamic pages', resolvedPages);
-                // stitch static and dynamic items
-                // TODO: remove hardcoded schema in value
-                dynamicPages.value = {
-                    // @ts-expect-error changing type on purpose
-                    __schema: {
-                        types: ['case-study'],
-                        size: TEMP_LIMIT
-                    },
-                    pages: [
-                        ...staticPages,
-                        ...linkedResolvedPages
-                    ]
-                };
-                console.debug('[LinkData] final value', dynamicPages.value);
+                return [hash, linkedResolvedPages];
             }
-        }));
+        });
+        // go through each ref and resolve
+        return new Map(await Promise.all(requests));
     }
+    LinkedData.resolveDynamicRefs = resolveDynamicRefs;
 })(LinkedData || (exports.LinkedData = LinkedData = {}));

package/dist/schema/LinkedPage.d.ts

@@ -0,0 +1,37 @@
+import { LinkedData } from './LinkedData';
+import { Page } from './Page';
+export declare class LinkedPage<TPage extends Page> {
+    private readonly _data;
+    private readonly _linkedStore;
+    private readonly _nav;
+    private readonly _content;
+    private constructor();
+    get url(): string;
+    get seo(): import("./Seo").Seo.Data;
+    get header(): {
+        fields: any;
+        config: {
+            theme: any;
+        };
+    };
+    get footer(): {
+        fields: any;
+        config: {
+            theme: any;
+        };
+    };
+    get data(): Page.Data<TPage, string>;
+    get content(): Page.LinkedData.Content<TPage>;
+    private get;
+    static create<TPage extends Page>(args: LinkedPage.CreateArgs<TPage>): Promise<LinkedPage<TPage>>;
+}
+export declare namespace LinkedPage {
+    type CreateArgs<TPage extends Page> = {
+        data: Page.FlattenedData<TPage>;
+        resolvers: LinkedData.DynamicResolvers;
+    };
+    type ConstructorArgs<TPage extends Page> = {
+        data: Page.Data<TPage>;
+        linkedStore: LinkedData.TransformFromStores;
+    };
+}