@nascentdigital/funnel-core 4.5.7 → 4.6.0

package/dist/schema/LinkedPage.js

@@ -0,0 +1,103 @@
+"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.LinkedPage = void 0;
+const LinkedData_1 = require("./LinkedData");
+// class
+class LinkedPage {
+    constructor(args) {
+        // set instance variables
+        this._data = args.data;
+        this._linkedStore = args.linkedStore;
+        this._nav = this.get('_nd-nav');
+        // dynamically add getters for each content item
+        this._content = {};
+        Object.keys(this._data.content).forEach(key => {
+            Object.defineProperty(this._content, key, {
+                get: () => this.get(key)
+            });
+        });
+    }
+    get url() {
+        return this._data.url;
+    }
+    get seo() {
+        var _a;
+        return (_a = this._data.discover) === null || _a === void 0 ? void 0 : _a.seo;
+    }
+    get header() {
+        var _a, _b, _c;
+        // get header fields
+        const { headerTheme, header } = (_b = (_a = this._nav) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : {};
+        // return header fields and config
+        return {
+            fields: (_c = header === null || header === void 0 ? void 0 : header.value) === null || _c === void 0 ? void 0 : _c.fields,
+            config: { theme: headerTheme }
+        };
+    }
+    get footer() {
+        var _a, _b, _c;
+        // get footer fields
+        const { footer, footerTheme } = (_b = (_a = this._nav) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : {};
+        // return footer fields and config
+        return {
+            fields: (_c = footer === null || footer === void 0 ? void 0 : footer.value) === null || _c === void 0 ? void 0 : _c.fields,
+            config: { theme: footerTheme }
+        };
+    }
+    get data() {
+        return this._data;
+    }
+    get content() {
+        return this._content;
+    }
+    get(key) {
+        // get content by key
+        const unlinkedData = this._data.content[key];
+        // throw if data not found
+        if (!unlinkedData) {
+            return undefined;
+        }
+        // link data
+        return LinkedData_1.LinkedData.resolveStatic({
+            unlinkedData,
+            stores: this._linkedStore,
+            skipEntitiesScan: true
+        });
+    }
+    static async create(args) {
+        // find and resolve all dynamic references
+        const dynamicRefs = LinkedData_1.LinkedData.findDynamicRefs(args.data);
+        const dynamic = await LinkedData_1.LinkedData.resolveDynamicRefs({ dynamicRefs, resolvers: args.resolvers });
+        // resolve references in entities
+        const _a = args.data, { data } = _a, entities = __rest(_a, ["data"]);
+        const result = LinkedData_1.LinkedData.resolveStatic({
+            unlinkedData: entities,
+            stores: { dynamic }
+        });
+        // create linked store
+        const { pages, collections, files } = result;
+        const linkedStore = {
+            pages: Object.values(pages),
+            collections: Object.values(collections),
+            assets: Object.values(files),
+            dynamic
+        };
+        // return new linked page
+        return new LinkedPage({
+            data,
+            linkedStore
+        });
+    }
+}
+exports.LinkedPage = LinkedPage;

package/dist/schema/Page.d.ts

@@ -50,10 +50,10 @@ export declare namespace Page {
     namespace Update {
         type Page = Page.Name | Page.Tags | Page.Slug | Page.Url | Page.Preview | Page.Errors | Page.Publication;
         namespace Page {
-            type Factory<TProp extends keyof Data> = {
+            type Factory<TProp extends keyof LegacyData> = {
                 type: 'page';
                 property: TProp;
-                value: UndefinedToNull<Data[TProp]>;
+                value: UndefinedToNull<LegacyData[TProp]>;
             };
             export type Name = Factory<'name'>;
             export type Tags = Factory<'tags'>;
@@ -128,6 +128,31 @@ export declare namespace Page {
         };
     }
     type Data<TPage extends Page = Page, TRegion extends string = string> = {
+        __root: 'page';
+        id: Id;
+        groupId: GroupId;
+        brand: string;
+        type: Type;
+        tags: TagGroup.Data;
+        slug?: string;
+        url: string;
+        region: TRegion;
+        language: Language;
+        name: string;
+        discover: Data.Discover;
+        preview?: Data.Preview<TPage>;
+        content: Data.Content<TPage>;
+        state: State;
+        errors: boolean;
+        changeSetId?: ChangeSet.Id;
+        snapshotId?: PageSnapshot.Id;
+        snapshot?: PageSnapshot;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+        publication?: number;
+    };
+    type LegacyData<TPage extends Page = Page, TRegion extends string = string> = {
         __root: 'page';
         id: Id;
         groupId: GroupId;
@@ -144,7 +169,7 @@ export declare namespace Page {
         content: Data.Content<TPage>;
         files: Asset.Linked[];
         pages: Data.AsPreview[];
-        collections: Collection.Data[];
+        collections: Collection.LegacyData[];
         state: State;
         errors: boolean;
         changeSetId?: ChangeSet.Id;
@@ -167,42 +192,47 @@ export declare namespace Page {
             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<TPage extends Page = Page, TRegion extends string = string> = PartialBy<Pick<Data<TPage, TRegion>, AsDraft.Prop | 'discover'>, 'discover'>;
+        type AsDraft<TPage extends Page = Page, TRegion extends string = string> = PartialBy<Pick<LegacyData<TPage, TRegion>, AsDraft.Prop | 'discover'>, 'discover'>;
         namespace AsDraft {
             type Prop = Exclude<Props.Id, 'id'> | Extract<Props.Audit, 'changeSetId'>;
             const props: ReadonlyArray<Prop>;
         }
-        type AsNew<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsNew.Prop>;
+        type AsNew<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, AsNew.Prop>;
         namespace AsNew {
             type Prop = Exclude<Props.Id, 'id' | 'groupId' | 'url'> | Extract<Props.Audit, 'changeSetId'>;
             const props: ReadonlyArray<Prop>;
         }
-        type AsNewLanguage<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsNewLanguage.Prop>;
+        type AsNewLanguage<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, AsNewLanguage.Prop>;
         namespace AsNewLanguage {
             type Prop = Extract<Props.Id, 'brand' | 'groupId' | 'slug' | 'language'>;
             const props: ReadonlyArray<Prop>;
             function filter<TPage extends Page = Page, TRegion extends string = string>(page: AsNew<TPage, TRegion> | AsNewLanguage<TPage, TRegion>): page is AsNewLanguage<TPage, TRegion>;
         }
-        type AsRef<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsRef.Prop>;
+        type AsRef<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, AsRef.Prop>;
         namespace AsRef {
             type Prop = Extract<Props.Id, 'id' | 'url'>;
             const props: ReadonlyArray<Prop>;
         }
-        type AsLink<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsLink.Prop>;
+        type AsLink<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, AsLink.Prop>;
         namespace AsLink {
             type Prop = Props.Id | Props.Audit;
             const props: ReadonlyArray<Prop>;
-            function from(data: Data): AsLink;
+            function from(data: LegacyData): AsLink;
         }
-        type AsPreview<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsPreview.Prop>;
+        type AsPreview<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, AsPreview.Prop>;
         namespace AsPreview {
             type Prop = Props.Id | Extract<Props.Content, 'preview'> | Props.Links | Props.Audit;
             const props: ReadonlyArray<Prop>;
-            function from(data: Data): AsPreview;
-            function filter(data: Data | AsPreview): data is Preview;
+            function from(data: LegacyData): AsPreview;
+            function filter(data: LegacyData | AsPreview): data is Preview;
+        }
+        type AsContent<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, AsContent.Prop>;
+        namespace AsContent {
+            type Prop = Exclude<Props.All, Props.Backup>;
+            const props: ReadonlyArray<Prop>;
         }
         type AsGroup<TPage extends Page = Page, TRegion extends string = string> = {
             group: {
@@ -214,10 +244,10 @@ export declare namespace Page {
                 preset?: string;
                 instances: AsGroup.Instance[];
             };
-            page?: Data<TPage, TRegion>;
+            page?: FlattenedData<TPage, TRegion>;
         };
         namespace AsGroup {
-            type Instance<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, Instance.Prop>;
+            type Instance<TPage extends Page = Page, TRegion extends string = string> = Pick<LegacyData<TPage, TRegion>, Instance.Prop>;
             namespace Instance {
                 type Prop = Extract<Props.Id, 'id' | 'name' | 'language' | 'url' | 'slug' | 'tags'> | Exclude<Props.Audit, 'publication'>;
                 const props: ReadonlyArray<Prop>;
@@ -230,9 +260,17 @@ export declare namespace Page {
         type Content<TPage extends Page = Page<any>> = {
             [key in keyof TPage['content']]: TPage['content'][key] extends Section ? Section.Data<TPage['content'][key]> : TPage['content'][key] extends Optional.Maybe<Block> ? Block.Data.ForOptional<TPage['content'][key]> : never;
         };
-        function filter(value: any): value is Data;
+        function filter(value: any): value is LegacyData;
     }
-    type LinkedData<TPage extends Page = Page> = Omit<Data<TPage>, 'discover' | 'preview' | 'content' | 'snapshots'> & {
+    type References = {
+        files: Record<Asset.Id, Asset.Linked>;
+        pages: Record<Page.Id, Data>;
+        collections: Record<Collection.Id, Collection.Data.AsLink>;
+    };
+    type FlattenedData<TPage extends Page = Page, TRegion extends string = string> = References & {
+        data: Data<TPage, TRegion>;
+    };
+    type LinkedData<TPage extends Page = Page> = Omit<LegacyData<TPage>, 'discover' | 'preview' | 'content' | 'snapshots'> & {
         discover: LinkedData.Discover;
         preview?: LinkedData.Preview<TPage>;
         content: LinkedData.Content<TPage>;

package/dist/schema/Page.js

@@ -147,6 +147,15 @@ exports.Page = Page;
             }
             AsPreview.filter = filter;
         })(AsPreview = Data.AsPreview || (Data.AsPreview = {}));
+        let AsContent;
+        (function (AsContent) {
+            AsContent.props = [
+                ...Props.id,
+                ...Props.content,
+                ...Props.links,
+                ...Props.audit
+            ];
+        })(AsContent = Data.AsContent || (Data.AsContent = {}));
         let AsGroup;
         (function (AsGroup) {
             let Instance;

package/dist/schema/PageModel.d.ts

@@ -44,7 +44,7 @@ export declare namespace PageModel {
     type SyncArgs = {
         route: PageRoute;
     };
-    type TargetArea = Extract<keyof Page.Data, 'discover' | 'preview' | 'content'>;
+    type TargetArea = Extract<keyof Page.LegacyData, 'discover' | 'preview' | 'content'>;
     namespace TargetArea {
         type Root = Page.Data.Content<any>;
         type Extraction = {

package/dist/schema/PageModel.js

@@ -841,7 +841,7 @@ class PageModel {
                         keywords: field_1.Field.Data.newValue('list')
                     }
                 }
-            }, preview: {}, content: {}, files: [], pages: [], collections: [], errors: true, state: 'draft', createdOn: now, updatedOn: now }));
+            }, preview: {}, content: {}, errors: true, state: 'draft', createdOn: now, updatedOn: now }));
     }
 }
 exports.PageModel = PageModel;

package/dist/schema/PageSnapshot.d.ts

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

package/dist/schema/field/base/CollectionField.d.ts

@@ -11,7 +11,7 @@ export declare class CollectionField<TCollection extends Collection = Collection
 export declare namespace CollectionField {
     type Value<TCollection extends Collection = Collection> = Value.ForRef<TCollection> | Value.ForInline<TCollection>;
     namespace Value {
-        type ForRef<TCollection extends Collection = Collection> = Pick<Collection.Data<TCollection>, 'id' | 'type'>;
+        type ForRef<TCollection extends Collection = Collection> = Pick<Collection.LegacyData<TCollection>, 'id' | 'type'>;
         namespace ForRef {
             function filter<TCollection extends Collection = Collection>(value: any): value is ForRef<TCollection>;
             function toData(value: ForRef): Field.Data.Collection.Ref;

package/dist/schema/field/base/DynamicPagesField.d.ts

@@ -1,3 +1,4 @@
+import { Tagged } from 'type-fest';
 import type { Page } from '../../Page';
 import type { PageQuery } from '../../PageQuery';
 import { Field } from '../index';
@@ -6,26 +7,27 @@ export declare class DynamicPagesField extends Field<DynamicPagesField> {
     readonly types: Page.Type[] | 'all';
     readonly size: number;
     constructor(args: DynamicPagesField.ConstructorArgs);
-    get schema(): DynamicPagesField.Schema;
+    get meta(): DynamicPagesField.Schema;
     modify(args: DynamicPagesField.ModifyArgs): DynamicPagesField;
 }
 export declare namespace DynamicPagesField {
+    type Hash = Tagged<string, 'funnel.DynamicPages.hash'>;
     type Query = Pick<PageQuery.Data, 'types' | 'sort' | 'excludeIds' | 'limit'>;
     type SavedQuery = Pick<Query, 'types' | 'sort'>;
     type Value = SavedQuery & {
-        staticPages?: any[];
+        schema: Schema;
+        staticPages?: Field.Data.Page[];
     };
     namespace Value {
         function fromData(data: Field.Data<DynamicPagesField> | undefined): Value | undefined;
         function toData(value: Value): Field.Data<DynamicPagesField>;
         function coerceData(value: Value | undefined): Field.Data<DynamicPagesField> | undefined;
+        function hash({ value }: Field.Data<DynamicPagesField>): Hash;
     }
     type LinkedValue = {
-        __schema: Schema;
-        pages: Array<Page.LinkedData.AsPreview>;
+        pages: Page.LinkedData.AsPreview[];
     };
     type Schema = {
-        types: Page.Type[] | 'all';
         size: number;
     };
     type ConstructorArgs = Field.ConstructorArgs & {

package/dist/schema/field/base/DynamicPagesField.js

@@ -1,4 +1,15 @@
 "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.DynamicPagesField = void 0;
 const index_1 = require("../index");
@@ -13,9 +24,8 @@ class DynamicPagesField extends index_1.Field {
         this.types = (_a = args.types) !== null && _a !== void 0 ? _a : 'all';
         this.size = args.size;
     }
-    get schema() {
+    get meta() {
         return {
-            types: this.types,
             size: this.size
         };
     }
@@ -46,5 +56,11 @@ exports.DynamicPagesField = DynamicPagesField;
                 : toData(value);
         }
         Value.coerceData = coerceData;
+        function hash({ value }) {
+            const { staticPages } = value, query = __rest(value, ["staticPages"]);
+            const staticPageIds = staticPages === null || staticPages === void 0 ? void 0 : staticPages.map(page => page.value.id);
+            return JSON.stringify(Object.assign(Object.assign({}, query), { staticPageIds }));
+        }
+        Value.hash = hash;
     })(Value = DynamicPagesField.Value || (DynamicPagesField.Value = {}));
 })(DynamicPagesField || (exports.DynamicPagesField = DynamicPagesField = {}));

package/dist/schema/field/base/PageField.d.ts

@@ -13,7 +13,7 @@ export declare namespace PageField {
     type Link = PageField<'link'>;
     type Preview = PageField<'preview'>;
     type Full = PageField<'full'>;
-    type Value<TScope extends Scope = Scope> = Pick<Page.Data, 'id' | 'type'> & {
+    type Value<TScope extends Scope = Scope> = Pick<Page.LegacyData, 'id' | 'type'> & {
         scope: TScope;
     };
     namespace Value {

package/dist/schema/index.d.ts

@@ -10,7 +10,7 @@ export * from './Fields';
 export * from './Form';
 export * from './LinkedCollectionModel';
 export * from './LinkedData';
-export * from './LinkedPageModel';
+export * from './LinkedPage';
 export * from './Optional';
 export * from './Page';
 export * from './PageModel';

package/dist/schema/index.js

@@ -26,7 +26,7 @@ __exportStar(require("./Fields"), exports);
 __exportStar(require("./Form"), exports);
 __exportStar(require("./LinkedCollectionModel"), exports);
 __exportStar(require("./LinkedData"), exports);
-__exportStar(require("./LinkedPageModel"), exports);
+__exportStar(require("./LinkedPage"), exports);
 __exportStar(require("./Optional"), exports);
 __exportStar(require("./Page"), exports);
 __exportStar(require("./PageModel"), exports);

package/dist/types/TrackedValue.d.ts

@@ -0,0 +1,8 @@
+export type TrackedValue<TValue> = {
+    changed: boolean;
+    previous: TValue;
+    current: TValue;
+};
+export declare namespace TrackedValue {
+    function filter<TValue>(value: any): value is TrackedValue<TValue>;
+}

package/dist/types/TrackedValue.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackedValue = void 0;
+// extensions
+var TrackedValue;
+(function (TrackedValue) {
+    // constants
+    const keys = new Set(['changed', 'previous', 'current']);
+    // filters
+    function filter(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value)
+            && Object.keys(value).every(key => keys.has(key))
+            && 'changed' in value && typeof value.changed === 'boolean'
+            && 'previous' in value
+            && 'current' in value;
+    }
+    TrackedValue.filter = filter;
+})(TrackedValue || (exports.TrackedValue = TrackedValue = {}));

package/dist/types/index.d.ts

@@ -11,5 +11,6 @@ export * from './Provider';
 export * from './RequiredBy';
 export * from './Result';
 export * from './Timestamp';
+export * from './TrackedValue';
 export * from './Transform';
 export * from './UndefinedToNull';

package/dist/types/index.js

@@ -27,5 +27,6 @@ __exportStar(require("./Provider"), exports);
 __exportStar(require("./RequiredBy"), exports);
 __exportStar(require("./Result"), exports);
 __exportStar(require("./Timestamp"), exports);
+__exportStar(require("./TrackedValue"), exports);
 __exportStar(require("./Transform"), exports);
 __exportStar(require("./UndefinedToNull"), exports);

package/dist/ui/Placement.d.ts

@@ -1,4 +1,5 @@
 import { Frame, Insets, Rect, Size } from './geometry';
+import { TrackedValue } from '../types/TrackedValue';
 export type Placement = Placement.Side | `${Placement.Side}-${Placement.Anchor}`;
 export declare namespace Placement {
     type Side = 'top' | 'bottom' | 'left' | 'right';
@@ -15,7 +16,9 @@ export declare namespace Placement {
         anchorRect: Rect;
         anchorOffset?: number;
         placement: Placement;
-        contentSize: Readonly<Size>;
+        contentSize: Readonly<Size> | Readonly<TrackedValue<Size>>;
+        viewportSize: Readonly<Size> | Readonly<TrackedValue<Size>>;
+        previousFrame?: Partial<Frame>;
     };
-    function forContent({ containerRect, containerPadding, anchorRect, anchorOffset, placement, contentSize }: ForContentArgs): Partial<Frame>;
+    function forContent({ containerRect, containerPadding, anchorRect, anchorOffset, placement, contentSize: trackedContentSize, viewportSize: trackedViewportSize, previousFrame }: ForContentArgs): Partial<Frame>;
 }