@nascentdigital/funnel-core 4.4.21 → 4.5.1

package/dist/schema/Block.d.ts

@@ -1,3 +1,4 @@
+import { StringKeyOf } from 'type-fest';
 import { Transform } from '../types';
 import { BlockLayout } from '../ui/block-layout';
 import { Field } from './field';
@@ -26,6 +27,15 @@ export declare class Block<TId extends string = string, TFields extends Fields =
     static create<TId extends string, TFields extends Fields, TConfig extends Block.Config>(args: Block.FactoryArgs<TId, TFields, TConfig>): Block<TId, TFields, TConfig>;
 }
 export declare namespace Block {
+    type Property<TFields extends Fields = Fields> = Property.Unified<TFields> | Property.Split<TFields>;
+    namespace Property {
+        type Unified<TFields extends Fields = Fields> = StringKeyOf<TFields>;
+        type Split<TFields extends Fields = Fields> = {
+            field: StringKeyOf<TFields>;
+            config: string;
+        };
+        function normalize<TFields extends Fields>(property: Property<TFields>): Split<TFields>;
+    }
     type GetConfig<TConfig extends Config = Config, TFields extends Fields = Fields> = Transform<GetConfig.Args<TConfig, TFields>, GetConfig.Result<TConfig>>;
     namespace GetConfig {
         type Args<TConfig extends Config, TFields extends Fields> = {

package/dist/schema/Block.js

@@ -120,3 +120,16 @@ class Block {
     }
 }
 exports.Block = Block;
+// extension
+(function (Block) {
+    let Property;
+    (function (Property) {
+        // helpers
+        function normalize(property) {
+            return typeof property === 'string'
+                ? { field: property, config: property }
+                : property;
+        }
+        Property.normalize = normalize;
+    })(Property = Block.Property || (Block.Property = {}));
+})(Block || (exports.Block = Block = {}));

package/dist/schema/Fields.d.ts

@@ -1,5 +1,6 @@
+import { StringKeyOf } from 'type-fest';
 import { Transform } from '../types';
-import { EnumField, Field, RichTextField, TextField } from './field';
+import { AssetField, EnumField, Field, ListField, RichTextField, TextField } from './field';
 import { Optional } from './Optional';
 export type Fields = Record<string, Optional.Maybe<Field.Type>>;
 export declare namespace Fields {
@@ -25,6 +26,18 @@ export declare namespace Fields {
     type TextLikeFields<TFields extends Fields> = {
         [key in keyof TFields as TFields[key] extends TextLikeField ? key : TFields[key] extends _Optional<TextLikeField> ? key : never]: TFields[key];
     };
+    type AssetFields<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends AssetField ? key : TFields[key] extends _Optional<AssetField> ? key : never]: TFields[key];
+    };
+    namespace AssetFields {
+        type Keys<TFields extends Fields> = StringKeyOf<AssetFields<TFields>>;
+    }
+    type ListFields<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends ListField ? key : TFields[key] extends _Optional<ListField> ? key : never]: TFields[key];
+    };
+    namespace ListFields {
+        type Keys<TFields extends Fields> = StringKeyOf<ListFields<TFields>>;
+    }
     function unwrap<TFields extends Fields>(fields: TFields): UnwrapOptional<TFields>;
 }
 type _Optional<T extends Optional.Content> = Optional<T>;

package/dist/schema/field/Field.d.ts

@@ -91,8 +91,8 @@ export declare namespace Field {
             value: Value.ForCompositeType<T>;
         };
         type ForOptionalType<T extends Optional.Maybe<Type>> = T extends Optional<any> ? Data<Optional.InnerType<T>> | undefined : T extends Type ? Data<T> : never;
-        function isTextField(data: Field.Data | undefined): data is Field.Data<TextField>;
-        function getText(data: Field.Data | undefined): string | undefined;
+        function isTextField(data: Field.Data | Field.LinkedData | undefined): data is Field.Data<TextField>;
+        function getText(data: Field.Data | Field.LinkedData | undefined): string | undefined;
         namespace InternalLink {
             type Link = {
                 type: LinkField['type'];

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

@@ -20,17 +20,17 @@ export declare class AssetField<TValue extends AssetField.LinkedValue = AssetFie
 export declare namespace AssetField {
     type Tags = Tags.Image | Tags.Video;
     namespace Tags {
-        const image: TagGroup<"nd.image", "ad" | "icon" | "brand" | "hero" | "background" | "person" | "logo" | "product" | "lifestyle">;
+        const image: TagGroup<"nd.image", "ad" | "icon" | "logo" | "brand" | "hero" | "background" | "person" | "product" | "lifestyle">;
         type Image = TagGroup.Keys<typeof image>;
         namespace Image {
-            function parse(tags?: Image | ReadonlyArray<Image>): Tag<"nd.image", "ad" | "icon" | "brand" | "hero" | "background" | "person" | "logo" | "product" | "lifestyle">[] | undefined;
+            function parse(tags?: Image | ReadonlyArray<Image>): Tag<"nd.image", "ad" | "icon" | "logo" | "brand" | "hero" | "background" | "person" | "product" | "lifestyle">[] | undefined;
         }
         const video: TagGroup<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">;
         type Video = TagGroup.Keys<typeof video>;
         namespace Video {
             function parse(tags?: Video | ReadonlyArray<Video>): Tag<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">[] | undefined;
         }
-        function parse(tags?: Tags | ReadonlyArray<Tags>): (Tag<"nd.image", "ad" | "icon" | "brand" | "hero" | "background" | "person" | "logo" | "product" | "lifestyle"> | Tag<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">)[] | undefined;
+        function parse(tags?: Tags | ReadonlyArray<Tags>): (Tag<"nd.image", "ad" | "icon" | "logo" | "brand" | "hero" | "background" | "person" | "product" | "lifestyle"> | Tag<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">)[] | undefined;
     }
     type Value<T extends LinkedValue = LinkedValue> = Pick<T, 'id' | 'type' | 'url'>;
     namespace Value {

package/dist/ui/block-layout/BlockLayout.d.ts

@@ -10,13 +10,16 @@ export declare namespace BlockLayout {
     type Container = Row | Row.Nested | Column | Column.Nested | Stack | Stack.Nested;
     namespace Container {
         type Base = {
+            nested: false;
             alignX?: Alignment;
             alignY?: Alignment;
         };
         type Nested = {
+            nested: true;
             items: ReadonlyArray<Panel>;
             mobileOrder?: MobileOrder;
         };
+        function filter(item: Container | Panel): item is Container;
     }
     type Row = Container.Base & {
         type: 'row';
@@ -24,21 +27,21 @@ export declare namespace BlockLayout {
         ratio: ResponsiveValue<Ratio>;
     };
     namespace Row {
-        type Nested = Omit<Row, 'items'> & Container.Nested;
+        type Nested = Omit<Row, 'items' | 'nested'> & Container.Nested;
     }
     type Column = Container.Base & {
         type: 'column';
         items: ReadonlyArray<Row.Nested | Stack.Nested | Panel>;
     };
     namespace Column {
-        type Nested = Omit<Column, 'items'> & Container.Nested;
+        type Nested = Omit<Column, 'items' | 'nested'> & Container.Nested;
     }
     type Stack = Container.Base & {
         type: 'stack';
         items: ReadonlyArray<Row.Nested | Column.Nested | Panel>;
     };
     namespace Stack {
-        type Nested = Omit<Stack, 'items'> & Container.Nested;
+        type Nested = Omit<Stack, 'items' | 'nested'> & Container.Nested;
     }
     type NestedItem = Row.Nested | Column.Nested | Stack.Nested | Panel;
     type Panel = Message | Visual | List;
@@ -46,10 +49,10 @@ export declare namespace BlockLayout {
         type Key = Panel['type'] | string;
         type Base = {
             key: Key;
-            mobileOrder?: MobileOrder;
-            alignX?: Alignment;
-            alignY?: Alignment;
-            size?: Size;
+            mobileOrder: MobileOrder;
+            alignX: Alignment;
+            alignY: Alignment;
+            size: Size;
             fullBleed: ResponsiveValue<boolean>;
         };
     }
@@ -63,10 +66,21 @@ export declare namespace BlockLayout {
     };
     type List = Panel.Base & {
         type: 'list';
+        layout: ResponsiveValue<List.Layout>;
         itemType: List.ItemType;
+        itemAlign: ResponsiveValue<Alignment>;
+        itemCount: ResponsiveValue<number>;
     };
     namespace List {
-        type ItemType = 'message' | 'message+visual';
+        type Layout = 'column' | 'row' | 'grid';
+        namespace Layout {
+            const values: ReadonlyArray<Layout>;
+            function parse(value: string, fallback?: Layout): Layout;
+        }
+        namespace ItemCount {
+            function parse(value: string, fallback?: number): number;
+        }
+        type ItemType = 'message' | 'message+visual' | 'visual' | 'icon' | 'logo';
         namespace ItemType {
             const values: ReadonlyArray<ItemType>;
             function parse(value: string, fallback?: ItemType): ItemType;
@@ -88,7 +102,7 @@ export declare namespace BlockLayout {
     type MobileOrder = 'first' | 'last' | 'auto';
     namespace MobileOrder {
         const values: ReadonlyArray<MobileOrder>;
-        function parse(value: string, fallback?: MobileOrder): MobileOrder | undefined;
+        function parse(value: string, fallback?: MobileOrder): MobileOrder;
     }
     type Size = 'xs' | 'sm' | 'md' | 'lg' | 'full';
     namespace Size {
@@ -110,19 +124,19 @@ export declare namespace BlockLayout {
         const values: ReadonlyArray<AspectRatio>;
         function parse(value: string, fallback?: AspectRatio): AspectRatio;
     }
-    type ResponsiveValue<T extends string | boolean = string | boolean> = {
+    type ResponsiveValue<T extends string | boolean | number = string | boolean | number> = {
         base: T;
         mobile: T;
         desktop: T;
     };
     namespace ResponsiveValue {
-        type ParseArgs<T extends string | boolean> = {
+        type ParseArgs<T extends string | boolean | number> = {
             element: ParsedElement;
             property: string;
-            parser: (value: string, fallback: T) => T;
-            fallback: T | PartialBy<ResponsiveValue<T>, 'desktop' | 'mobile'>;
+            parser: (value: string, fallback: T | undefined) => T;
+            fallback?: T | PartialBy<ResponsiveValue<T>, 'desktop' | 'mobile'>;
         };
-        function parse<T extends string | boolean>({ element, property, parser, fallback: fallbackRaw }: ParseArgs<T>): ResponsiveValue<T>;
+        function parse<T extends string | boolean | number>({ element, property, parser, fallback: fallbackRaw }: ParseArgs<T>): ResponsiveValue<T>;
     }
     type ResponsiveClassNames<T extends ResponsiveValue> = T['base'] extends string ? ResponsiveClassNames.ForString<T, T['base']> : T['base'] extends boolean ? ResponsiveClassNames.ForBoolean<T, T['base']> : never;
     namespace ResponsiveClassNames {

package/dist/ui/block-layout/BlockLayout.js

@@ -21,12 +21,77 @@ const errors_1 = require("../../errors");
 // extension
 var BlockLayout;
 (function (BlockLayout) {
+    let Container;
+    (function (Container) {
+        // helpers
+        function filter(item) {
+            switch (item.type) {
+                case 'row':
+                case 'column':
+                case 'stack':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        Container.filter = filter;
+    })(Container = BlockLayout.Container || (BlockLayout.Container = {}));
     let List;
     (function (List) {
+        let Layout;
+        (function (Layout) {
+            // values
+            Layout.values = ['column', 'row', 'grid'];
+            // helper
+            function parse(value, fallback) {
+                // return if it's a match
+                if (Layout.values.includes(value)) {
+                    return value;
+                }
+                // or fallback if we have one
+                else if (value === undefined && fallback) {
+                    return fallback;
+                }
+                // or throw
+                else {
+                    throw new errors_1.ArgumentError(`Invalid BlockLayout.List.Layout "${value}"`, 'value');
+                }
+            }
+            Layout.parse = parse;
+        })(Layout = List.Layout || (List.Layout = {}));
+        // item count
+        let ItemCount;
+        (function (ItemCount) {
+            function parse(value, fallback) {
+                // handle value if not specified
+                if (!value) {
+                    if (fallback !== undefined) {
+                        return fallback;
+                    }
+                    else {
+                        throw new errors_1.ArgumentError('Missing BlockLayout.List.ItemCount', 'value');
+                    }
+                }
+                // try to parse value
+                const number = Number.parseInt(value);
+                if (Number.isNaN(number) || number < 1 || !Number.isInteger(number)) {
+                    throw new errors_1.ArgumentError(`Invalid BlockLayout.List.ItemCount "${value}"`, 'value');
+                }
+                // otherwise return the number
+                return number;
+            }
+            ItemCount.parse = parse;
+        })(ItemCount = List.ItemCount || (List.ItemCount = {}));
         let ItemType;
         (function (ItemType) {
             // values
-            ItemType.values = ['message', 'message+visual'];
+            ItemType.values = [
+                'message',
+                'message+visual',
+                'visual',
+                'icon',
+                'logo'
+            ];
             // helper
             function parse(value, fallback) {
                 // return if it's a match
@@ -34,7 +99,7 @@ var BlockLayout;
                     return value;
                 }
                 // or fallback if we have one
-                else if (fallback) {
+                else if (value === undefined && fallback) {
                     return fallback;
                 }
                 // or throw
@@ -56,7 +121,7 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else if (fallback) {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
             // or throw
@@ -77,7 +142,7 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else if (fallback) {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
             // or throw
@@ -97,7 +162,7 @@ var BlockLayout;
                 return true;
             }
             // return false if the string is 'false'
-            else if (value === 'false') {
+            else if (value === undefined && value === 'false') {
                 return false;
             }
             // or fallback if we have one
@@ -122,9 +187,13 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
+            // or throw
+            else {
+                throw new errors_1.ArgumentError(`Invalid BlockLayout.MobileOrder "${value}"`, 'value');
+            }
         }
         MobileOrder.parse = parse;
     })(MobileOrder = BlockLayout.MobileOrder || (BlockLayout.MobileOrder = {}));
@@ -139,7 +208,7 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else if (fallback) {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
             // or throw
@@ -160,7 +229,7 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else if (fallback) {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
             // or throw
@@ -181,7 +250,7 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else if (fallback) {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
             // or throw
@@ -202,7 +271,7 @@ var BlockLayout;
                 return value;
             }
             // or fallback if we have one
-            else if (fallback) {
+            else if (value === undefined && fallback) {
                 return fallback;
             }
             // or throw
@@ -218,12 +287,14 @@ var BlockLayout;
             var _a, _b;
             // capture base
             const { attributes } = element;
-            const fallbackBase = typeof fallbackRaw === 'string' || typeof fallbackRaw === 'boolean'
-                ? fallbackRaw
-                : fallbackRaw.base;
+            const fallbackBase = fallbackRaw === undefined
+                ? undefined
+                : typeof fallbackRaw === 'string' || typeof fallbackRaw === 'boolean' || typeof fallbackRaw === 'number'
+                    ? fallbackRaw
+                    : fallbackRaw.base;
             const base = parser(attributes[property], fallbackBase);
             // normalize the fallback
-            const fallback = typeof fallbackRaw === 'string' || typeof fallbackRaw === 'boolean'
+            const fallback = fallbackRaw === undefined || typeof fallbackRaw === 'string' || typeof fallbackRaw === 'boolean' || typeof fallbackRaw === 'number'
                 ? { base, mobile: base, desktop: base }
                 : { base, mobile: (_a = fallbackRaw.mobile) !== null && _a !== void 0 ? _a : base, desktop: (_b = fallbackRaw.desktop) !== null && _b !== void 0 ? _b : base };
             // fetch the values from the element
@@ -295,7 +366,7 @@ function parseRoot(element) {
     // create root
     switch (tag) {
         case 'row':
-            return Object.assign(Object.assign({ type: 'row' }, itemAttributes), { ratio: BlockLayout.ResponsiveValue.parse({
+            return Object.assign(Object.assign({ type: 'row', nested: false }, itemAttributes), { ratio: BlockLayout.ResponsiveValue.parse({
                     element,
                     property: 'ratio',
                     parser: BlockLayout.Ratio.parse,
@@ -305,12 +376,12 @@ function parseRoot(element) {
                     expectedTags: ParsedElement.tags.filter(t => t !== tag)
                 }))) });
         case 'col':
-            return Object.assign(Object.assign({ type: 'column' }, itemAttributes), { items: children.map(data => parseNestedItem(ParsedElement.parse({
+            return Object.assign(Object.assign({ type: 'column', nested: false }, itemAttributes), { items: children.map(data => parseNestedItem(ParsedElement.parse({
                     data,
                     expectedTags: ParsedElement.tags.filter(t => t !== tag)
                 }))) });
         case 'stack':
-            return Object.assign(Object.assign({ type: 'stack' }, itemAttributes), { items: children.map(data => parseNestedItem(ParsedElement.parse({
+            return Object.assign(Object.assign({ type: 'stack', nested: false }, itemAttributes), { items: children.map(data => parseNestedItem(ParsedElement.parse({
                     data,
                     expectedTags: ParsedElement.tags.filter(t => t !== tag)
                 }))) });
@@ -325,7 +396,7 @@ function parseNestedItem(element) {
     // create container
     switch (tag) {
         case 'row':
-            return Object.assign(Object.assign({ type: 'row' }, itemAttributes), { ratio: BlockLayout.ResponsiveValue.parse({
+            return Object.assign(Object.assign({ type: 'row', nested: true }, itemAttributes), { ratio: BlockLayout.ResponsiveValue.parse({
                     element,
                     property: 'ratio',
                     parser: BlockLayout.Ratio.parse,
@@ -336,7 +407,7 @@ function parseNestedItem(element) {
                 })))) });
         case 'col':
         case 'stack':
-            return Object.assign(Object.assign({ type: tag === 'col' ? 'column' : tag }, itemAttributes), { items: children.map(data => parsePanel(Object.assign({}, ParsedElement.parse({
+            return Object.assign(Object.assign({ type: tag === 'col' ? 'column' : tag, nested: true }, itemAttributes), { items: children.map(data => parsePanel(Object.assign({}, ParsedElement.parse({
                     data,
                     expectedTags: ParsedElement.tags.filter(t => t !== 'row' && t !== 'col')
                 })))) });
@@ -373,7 +444,20 @@ function parsePanel(element) {
                     fallback: 'auto'
                 }), fullBleed }, itemAttributes);
         case 'list':
-            return Object.assign({ type: 'list', key, itemType: BlockLayout.List.ItemType.parse(attributes['itemType'], 'message+visual'), fullBleed }, itemAttributes);
+            return Object.assign({ type: 'list', key, layout: BlockLayout.ResponsiveValue.parse({
+                    element,
+                    property: 'layout',
+                    parser: BlockLayout.List.Layout.parse
+                }), itemType: BlockLayout.List.ItemType.parse(attributes['itemType']), itemAlign: BlockLayout.ResponsiveValue.parse({
+                    element,
+                    property: 'itemAlign',
+                    parser: BlockLayout.Alignment.parse,
+                    fallback: 'start'
+                }), itemCount: BlockLayout.ResponsiveValue.parse({
+                    element,
+                    property: 'itemCount',
+                    parser: BlockLayout.List.ItemCount.parse
+                }), fullBleed }, itemAttributes);
         default:
             throw new errors_1.ArgumentError(`Invalid XML BlockLayout - encountered "${tag}" where instead of BlockLayout.Panel`);
     }

package/dist/utils/ObjectUtils.d.ts

@@ -17,6 +17,7 @@ export declare namespace ObjectUtils {
     };
     function splitProps<TProps extends object, TSubKey extends keyof Required<TProps>>(mixedProps: TProps, keys: ReadonlyArray<TSubKey>): SplitProps<TProps, TSubKey>;
     function slice<TProps extends object, TSubKey extends keyof Required<TProps>>(mixedProps: TProps, ...keys: ReadonlyArray<TSubKey>): Pick<TProps, TSubKey>;
+    function drop<TProps extends object, TSubKey extends keyof Required<TProps>>(mixedProps: TProps, ...keys: ReadonlyArray<TSubKey>): Omit<TProps, TSubKey>;
     /**
      * Creates a new object with the updated entry (adding it if required)
      * @param object - the existing object to copy + change

package/dist/utils/ObjectUtils.js

@@ -50,6 +50,10 @@ var ObjectUtils;
         return splitProps(mixedProps, keys).splitProps;
     }
     ObjectUtils.slice = slice;
+    function drop(mixedProps, ...keys) {
+        return splitProps(mixedProps, keys).props;
+    }
+    ObjectUtils.drop = drop;
     /**
      * Creates a new object with the updated entry (adding it if required)
      * @param object - the existing object to copy + change

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nascentdigital/funnel-core",
-  "version": "4.4.21",
+  "version": "4.5.1",
   "repository": {
     "url": "git+https://github.com/nascentdigital/funnel.git",
     "directory": "libs/core"
@@ -65,5 +65,5 @@
     "jest-tsd": "^0.2.2",
     "ts-jest": "^29.3.2"
   },
-  "gitHead": "fedc672d83d223518b78c5d81814c1bcbda24035"
+  "gitHead": "3348c90ff56f3dd931ab564f8a6ad13d454a4ca1"
 }