@nascentdigital/funnel-core 6.1.1 → 6.1.3

package/dist/schema/Block.d.ts

@@ -1,6 +1,5 @@
 import { StringKeyOf } from 'type-fest';
 import { Transform } from '../types';
-import type { BlockLayout, PanelLayout, PanelSlot } from '../ui/block-layout';
 import { Field } from './field';
 import { Fields } from './Fields';
 import { Optional } from './Optional';
@@ -14,12 +13,9 @@ export declare class Block<TId extends string = string, TFields extends Fields =
     readonly fields: TFields;
     readonly editableFields: Fields.UnwrapOptional<TFields>;
     readonly config: Block.Config.UnwrapOptional<TConfig>;
-    readonly getConfig?: Block.GetConfig<TConfig, TFields>;
-    readonly getLayout?: Block.GetLayout<TConfig, TFields>;
+    readonly getConfig?: Block.GetConfig<TFields, TConfig>;
     readonly defaultContent?: Block.DefaultContent<TFields>;
-    readonly defaultPanelLayouts?: Block.DefaultPanelLayouts;
-    readonly defaultLayoutConfigs?: Block.DefaultLayoutConfigs<TConfig>;
-    private constructor();
+    protected constructor(args: Block.ConstructorArgs<TId, TFields, TConfig>);
     optional(): Optional<Block<TId, TFields, TConfig>>;
     unwrap(): this;
     modify(args: Block.ModifyArgs<TId, TFields, TConfig>): Block<TId, TFields, TConfig>;
@@ -34,14 +30,6 @@ export declare class Block<TId extends string = string, TFields extends Fields =
      * Set default content when block gets created.
      */
     withContent(defaultContent: Block.DefaultContent<TFields>): Block<TId, TFields, TConfig>;
-    /**
-     * Specify a default layout for a set of active panels.
-     */
-    useLayout(layout: PanelLayout.WithMultiSlots, activePanels: string[] | string): Block<TId, TFields, TConfig>;
-    /**
-     * Specify default configs for a layout.
-     */
-    useConfig(panelLayout: PanelLayout | PanelLayout[], config: Block.Config.Value<TConfig>): Block<TId, TFields, TConfig>;
     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 {
@@ -54,9 +42,18 @@ export declare namespace Block {
         };
         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>>;
+    type Config = Record<string, Optional.Maybe<Field.Type.Simple.Configuration>>;
+    namespace Config {
+        type UnwrapOptional<TConfig extends Config> = {
+            [key in keyof TConfig]: Optional.InnerType<TConfig[key]>;
+        };
+        type Value<TConfig extends Config> = {
+            [key in keyof TConfig]?: Field.Value<Optional.InnerType<TConfig[key]>>;
+        };
+    }
+    type GetConfig<TFields extends Fields = Fields, TConfig extends Config = Config> = Transform<GetConfig.Args<TFields, TConfig>, GetConfig.Result<TConfig>>;
     namespace GetConfig {
-        type Args<TConfig extends Config, TFields extends Fields> = {
+        type Args<TFields extends Fields, TConfig extends Config> = {
             block: Block<any, TFields, TConfig>;
             config: Partial<Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
             fields: Partial<Data.ForFields<TFields>> | Partial<LinkedData.ForFields<TFields>>;
@@ -67,25 +64,7 @@ export declare namespace Block {
             updatedConfigSchema?: Partial<Config.UnwrapOptional<TConfig>>;
         };
     }
-    type GetLayout<TConfig extends Config = Config, TFields extends Fields = Fields> = Transform<GetLayout.Args<TConfig, TFields>, BlockLayout>;
-    namespace GetLayout {
-        type Args<TConfig extends Config, TFields extends Fields> = {
-            config: Partial<Data.ForConfig<Config.UnwrapOptional<TConfig>>> | Partial<LinkedData.ForConfig<Config.UnwrapOptional<TConfig>>>;
-            fields: Partial<Data.ForFields<TFields>> | Partial<LinkedData.ForFields<TFields>>;
-        };
-    }
     type DefaultContent<TFields extends Fields = Fields> = Array<keyof TFields>;
-    type DefaultPanelLayouts = Partial<Record<PanelLayout, Set<PanelSlot>[]>>;
-    type DefaultLayoutConfigs<TConfig extends Config = Config> = Partial<Record<PanelLayout, Config.Value<TConfig>>>;
-    type Config = Record<string, Optional.Maybe<Field.Type.Simple.Configuration>>;
-    namespace Config {
-        type UnwrapOptional<TConfig extends Config> = {
-            [key in keyof TConfig]: Optional.InnerType<TConfig[key]>;
-        };
-        type Value<TConfig extends Config> = {
-            [key in keyof TConfig]?: Field.Value<Optional.InnerType<TConfig[key]>>;
-        };
-    }
     type Data<T extends Block = Block> = {
         type: 'block';
         id: T['id'];
@@ -132,11 +111,8 @@ export declare namespace Block {
         fields: TFields;
         editableFields: Fields.UnwrapOptional<TFields>;
         config?: TConfig;
-        getConfig?: GetConfig<TConfig, TFields>;
-        getLayout?: GetLayout<TConfig, TFields>;
+        getConfig?: GetConfig<TFields, TConfig>;
         defaultContent?: DefaultContent<TFields>;
-        defaultPanelLayouts?: DefaultPanelLayouts;
-        defaultLayoutConfigs?: DefaultLayoutConfigs<TConfig>;
     };
     type ModifyArgs<TId extends string, TFields extends Fields, TConfig extends Config> = Partial<Pick<ConstructorArgs<TId, TFields, TConfig>, 'name' | 'hint' | 'required'>>;
     type FactoryArgs<TId extends string, TFields extends Fields, TConfig extends Config = Config> = Omit<ConstructorArgs<TId, TFields, TConfig>, 'editableFields' | 'required'>;

package/dist/schema/Block.js

@@ -29,10 +29,7 @@ class Block {
             }, {})
             : {};
         this.getConfig = args.getConfig;
-        this.getLayout = args.getLayout;
         this.defaultContent = args.defaultContent;
-        this.defaultPanelLayouts = args.defaultPanelLayouts;
-        this.defaultLayoutConfigs = args.defaultLayoutConfigs;
     }
     optional() {
         return new Optional_1.Optional(this);
@@ -42,7 +39,7 @@ class Block {
     }
     modify(args) {
         // create new block (re-map required fields)
-        return new Block(Object.assign({ id: this.id, name: this.name, hint: this.hint, required: this.required, version: this.version, fields: this.fields, editableFields: this.editableFields, config: this.config, getConfig: this.getConfig, getLayout: this.getLayout, defaultContent: this.defaultContent, defaultPanelLayouts: this.defaultPanelLayouts, defaultLayoutConfigs: this.defaultLayoutConfigs }, args));
+        return new Block(Object.assign({ id: this.id, name: this.name, hint: this.hint, required: this.required, version: this.version, fields: this.fields, editableFields: this.editableFields, config: this.config, getConfig: this.getConfig, defaultContent: this.defaultContent }, args));
     }
     /**
      * Rename a block's name which is used in the editor.
@@ -77,10 +74,7 @@ class Block {
             }, Object.assign({}, this.editableFields)),
             config: this.config,
             getConfig: this.getConfig,
-            getLayout: this.getLayout,
-            defaultContent: this.defaultContent,
-            defaultPanelLayouts: this.defaultPanelLayouts,
-            defaultLayoutConfigs: this.defaultLayoutConfigs,
+            defaultContent: this.defaultContent
         });
     }
     override(override) {
@@ -97,10 +91,7 @@ class Block {
             editableFields: Object.assign(Object.assign({}, this.editableFields), overrides),
             config: this.config,
             getConfig: this.getConfig,
-            getLayout: this.getLayout,
-            defaultContent: this.defaultContent,
-            defaultPanelLayouts: this.defaultPanelLayouts,
-            defaultLayoutConfigs: this.defaultLayoutConfigs,
+            defaultContent: this.defaultContent
         });
     }
     extend(fields) {
@@ -114,10 +105,7 @@ class Block {
             editableFields: Object.assign(Object.assign({}, this.editableFields), Fields_1.Fields.unwrap(fields)),
             config: this.config,
             getConfig: this.getConfig,
-            getLayout: this.getLayout,
-            defaultContent: this.defaultContent,
-            defaultPanelLayouts: this.defaultPanelLayouts,
-            defaultLayoutConfigs: this.defaultLayoutConfigs,
+            defaultContent: this.defaultContent
         });
     }
     /**
@@ -134,62 +122,7 @@ class Block {
             editableFields: this.editableFields,
             config: this.config,
             getConfig: this.getConfig,
-            getLayout: this.getLayout,
-            defaultContent: defaultContent,
-            defaultPanelLayouts: this.defaultPanelLayouts,
-            defaultLayoutConfigs: this.defaultLayoutConfigs,
-        });
-    }
-    /**
-     * Specify a default layout for a set of active panels.
-     */
-    useLayout(layout, activePanels) {
-        var _a;
-        // update default panel layouts
-        const defaultPanelLayouts = (_a = this.defaultPanelLayouts) !== null && _a !== void 0 ? _a : {};
-        defaultPanelLayouts[layout] = utils_1.ArrayUtils.coerce(activePanels).map(panels => new Set(panels.toUpperCase().split('')));
-        // return new block
-        return new Block({
-            id: this.id,
-            name: this.name,
-            hint: this.hint,
-            required: this.required,
-            version: this.version,
-            fields: this.fields,
-            editableFields: this.editableFields,
-            config: this.config,
-            getConfig: this.getConfig,
-            getLayout: this.getLayout,
-            defaultContent: this.defaultContent,
-            defaultPanelLayouts,
-            defaultLayoutConfigs: this.defaultLayoutConfigs,
-        });
-    }
-    /**
-     * Specify default configs for a layout.
-     */
-    useConfig(panelLayout, config) {
-        var _a;
-        // update default layout configs
-        const defaultLayoutConfigs = (_a = this.defaultLayoutConfigs) !== null && _a !== void 0 ? _a : {};
-        utils_1.ArrayUtils.coerce(panelLayout).forEach(layout => {
-            defaultLayoutConfigs[layout] = config;
-        });
-        // return new block
-        return new Block({
-            id: this.id,
-            name: this.name,
-            hint: this.hint,
-            required: this.required,
-            version: this.version,
-            fields: this.fields,
-            editableFields: this.editableFields,
-            config: this.config,
-            getConfig: this.getConfig,
-            getLayout: this.getLayout,
-            defaultContent: this.defaultContent,
-            defaultPanelLayouts: this.defaultPanelLayouts,
-            defaultLayoutConfigs
+            defaultContent: defaultContent
         });
     }
     static create(args) {
@@ -203,10 +136,7 @@ class Block {
             editableFields: Fields_1.Fields.unwrap(args.fields),
             config: args.config,
             getConfig: args.getConfig,
-            getLayout: args.getLayout,
-            defaultContent: args.defaultContent,
-            defaultPanelLayouts: args.defaultPanelLayouts,
-            defaultLayoutConfigs: args.defaultLayoutConfigs,
+            defaultContent: args.defaultContent
         });
     }
 }

package/dist/schema/blocks/PanelledBlock.d.ts

@@ -0,0 +1,81 @@
+import { Transform } from '../../types';
+import type { BlockLayout, PanelLayout, PanelSlot } from '../../ui';
+import { Block } from '../Block';
+import { Fields, Fields as FieldsModel } from '../Fields';
+export declare class PanelledBlock<TId extends string = string, TFields extends PanelledBlock.Fields = any, TConfig extends PanelledBlock.Config = any> extends Block<TId, TFields, TConfig> {
+    readonly getLayout?: PanelledBlock.GetLayout<TFields, TConfig>;
+    readonly defaultPanelLayouts: PanelledBlock.DefaultPanelLayouts;
+    readonly defaultLayoutConfigs: PanelledBlock.DefaultLayoutConfigs<TConfig>;
+    protected constructor({ getConfig, getLayout, defaultPanelLayouts, defaultLayoutConfigs, ...args }: PanelledBlock.ConstructorArgs<TId, TFields, TConfig>);
+    modify(args: Block.ModifyArgs<TId, TFields, TConfig>): PanelledBlock<TId, TFields, TConfig>;
+    /**
+     * Rename a block's name which is used in the editor.
+     */
+    rename(name: string): PanelledBlock<TId, TFields, TConfig>;
+    hide(...keys: ReadonlyArray<Fields.OptionalKeys<TFields>>): PanelledBlock<TId, TFields, TConfig>;
+    override(override: Fields.Override<TFields>): PanelledBlock<TId, TFields, TConfig>;
+    extend<TAdditionalFields extends Fields>(fields: TAdditionalFields): PanelledBlock<TId, TFields & TAdditionalFields, TConfig>;
+    /**
+     * Set default content when block gets created.
+     */
+    withContent(defaultContent: Block.DefaultContent<TFields>): Block<TId, TFields, TConfig>;
+    /**
+     * Specify a default layout for a set of active panels.
+     */
+    useLayout(layout: PanelLayout.WithMultiSlots, activePanels: string[] | string): PanelledBlock<TId, TFields, TConfig>;
+    /**
+     * Specify default configs for a layout.
+     */
+    useConfig(panelLayout: PanelLayout | PanelLayout[], config: PanelledBlock.Config.Value<TConfig>): PanelledBlock<TId, TFields, TConfig>;
+    static create<TId extends string, TFields extends PanelledBlock.Fields, TConfig extends PanelledBlock.Config>(args: PanelledBlock.FactoryArgs<TId, TFields, TConfig>): PanelledBlock<TId, TFields, TConfig>;
+}
+export declare namespace PanelledBlock {
+    type Fields = FieldsModel;
+    namespace Fields {
+        type UnwrapOptional<TFields extends Fields> = FieldsModel.UnwrapOptional<TFields>;
+    }
+    type Config = Block.Config;
+    namespace Config {
+        type UnwrapOptional<TConfig extends Config> = Block.Config.UnwrapOptional<TConfig>;
+        type Value<TConfig extends Config> = Block.Config.Value<TConfig>;
+    }
+    type GetConfig<TFields extends Fields = Fields, TConfig extends Config = Config> = Transform<GetConfig.Args<TFields, TConfig>, GetConfig.Result<TConfig>>;
+    namespace GetConfig {
+        type Args<TFields extends Fields, TConfig extends Config> = {
+            block: PanelledBlock<any, TFields, TConfig>;
+            config: Partial<Block.Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            fields: Partial<Block.Data.ForFields<TFields>> | Partial<Block.LinkedData.ForFields<TFields>>;
+        };
+        type Result<TConfig extends Config> = {
+            updatedConfig?: Partial<Block.Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            defaultConfig?: Partial<Block.Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            updatedConfigSchema?: Partial<Config.UnwrapOptional<TConfig>>;
+        };
+    }
+    type GetLayout<TFields extends Fields = Fields, TConfig extends Config = Config> = Transform<GetLayout.Args<TFields, TConfig>, BlockLayout>;
+    namespace GetLayout {
+        type Args<TFields extends Fields, TConfig extends Config> = {
+            config: Partial<Block.Data.ForConfig<Config.UnwrapOptional<TConfig>>> | Partial<Block.LinkedData.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            fields: Partial<Block.Data.ForFields<TFields>> | Partial<Block.LinkedData.ForFields<TFields>>;
+        };
+    }
+    type DefaultPanelLayouts = Partial<Record<PanelLayout, Set<PanelSlot>[]>>;
+    type DefaultLayoutConfigs<TConfig extends Config = Config> = Partial<Record<PanelLayout, Config.Value<TConfig>>>;
+    type ConstructorArgs<TId extends string, TFields extends Fields, TConfig extends Config = Config> = {
+        id: TId;
+        name: string;
+        hint?: string;
+        required?: boolean;
+        version: number;
+        fields: TFields;
+        editableFields: Fields.UnwrapOptional<TFields>;
+        config?: TConfig;
+        getConfig?: GetConfig<TFields, TConfig>;
+        getLayout?: GetLayout<TFields, TConfig>;
+        defaultContent?: Block.DefaultContent<TFields>;
+        defaultPanelLayouts?: DefaultPanelLayouts;
+        defaultLayoutConfigs?: DefaultLayoutConfigs<TConfig>;
+    };
+    type ModifyArgs<TId extends string, TFields extends Fields, TConfig extends Config> = Partial<Pick<ConstructorArgs<TId, TFields, TConfig>, 'name' | 'hint' | 'required'>>;
+    type FactoryArgs<TId extends string, TFields extends Fields, TConfig extends Config = Config> = Omit<ConstructorArgs<TId, TFields, TConfig>, 'editableFields' | 'required'>;
+}

package/dist/schema/blocks/PanelledBlock.js

@@ -0,0 +1,194 @@
+"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.PanelledBlock = void 0;
+const errors_1 = require("../../errors");
+const utils_1 = require("../../utils");
+const Block_1 = require("../Block");
+const Fields_1 = require("../Fields");
+// class
+class PanelledBlock extends Block_1.Block {
+    constructor(_a) {
+        var { getConfig, getLayout, defaultPanelLayouts, defaultLayoutConfigs } = _a, args = __rest(_a, ["getConfig", "getLayout", "defaultPanelLayouts", "defaultLayoutConfigs"]);
+        // construct base
+        super(Object.assign(Object.assign({}, args), { getConfig: getConfig }));
+        // initialize instance variables
+        this.getLayout = getLayout;
+        this.defaultPanelLayouts = defaultPanelLayouts !== null && defaultPanelLayouts !== void 0 ? defaultPanelLayouts : {};
+        this.defaultLayoutConfigs = defaultLayoutConfigs !== null && defaultLayoutConfigs !== void 0 ? defaultLayoutConfigs : {};
+    }
+    modify(args) {
+        // create new block (re-map required fields)
+        return new PanelledBlock(Object.assign({ id: this.id, name: this.name, hint: this.hint, required: this.required, version: this.version, fields: this.fields, editableFields: this.editableFields, config: this.config, getConfig: this.getConfig, getLayout: this.getLayout, defaultContent: this.defaultContent, defaultPanelLayouts: this.defaultPanelLayouts, defaultLayoutConfigs: this.defaultLayoutConfigs }, args));
+    }
+    /**
+     * Rename a block's name which is used in the editor.
+     */
+    rename(name) {
+        return this.modify({ name });
+    }
+    hide(...keys) {
+        // create new block with removed fields
+        return new PanelledBlock({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            version: this.version,
+            required: this.required,
+            fields: this.fields,
+            editableFields: keys.reduce((fields, key) => {
+                // handle field if not already pruned
+                const field = fields[key];
+                if (field) {
+                    // throw if field is required
+                    if (field.required) {
+                        throw new errors_1.InvalidOperationError(`Cannot hide required field: ${String(key)} in block: ${this.name}`);
+                    }
+                    // otherwise delete field if not already pruned
+                    else {
+                        delete fields[key];
+                    }
+                }
+                // keep reducing
+                return fields;
+            }, Object.assign({}, this.editableFields)),
+            config: this.config,
+            getLayout: this.getLayout,
+            defaultContent: this.defaultContent,
+            defaultPanelLayouts: this.defaultPanelLayouts,
+            defaultLayoutConfigs: this.defaultLayoutConfigs
+        });
+    }
+    override(override) {
+        // get overrides from function
+        const overrides = override(this.fields);
+        // create new block with persisted field spec and overridden fields in unwrapped fields
+        return new PanelledBlock({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            version: this.version,
+            required: this.required,
+            fields: this.fields,
+            editableFields: Object.assign(Object.assign({}, this.editableFields), overrides),
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout,
+            defaultContent: this.defaultContent,
+            defaultPanelLayouts: this.defaultPanelLayouts,
+            defaultLayoutConfigs: this.defaultLayoutConfigs
+        });
+    }
+    extend(fields) {
+        return new PanelledBlock({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            required: this.required,
+            version: this.version,
+            fields: Object.assign(Object.assign({}, this.fields), fields),
+            editableFields: Object.assign(Object.assign({}, this.editableFields), Fields_1.Fields.unwrap(fields)),
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout,
+            defaultContent: this.defaultContent,
+            defaultPanelLayouts: this.defaultPanelLayouts,
+            defaultLayoutConfigs: this.defaultLayoutConfigs
+        });
+    }
+    /**
+     * Set default content when block gets created.
+     */
+    withContent(defaultContent) {
+        return new Block_1.Block({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            required: this.required,
+            version: this.version,
+            fields: this.fields,
+            editableFields: this.editableFields,
+            config: this.config,
+            getConfig: this.getConfig,
+            defaultContent: defaultContent
+        });
+    }
+    /**
+     * Specify a default layout for a set of active panels.
+     */
+    useLayout(layout, activePanels) {
+        // update default panel layouts
+        const defaultPanelLayouts = Object.assign({}, this.defaultPanelLayouts);
+        defaultPanelLayouts[layout] = utils_1.ArrayUtils.coerce(activePanels).map(panels => new Set(panels.toUpperCase().split('')));
+        // return new block
+        return new PanelledBlock({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            required: this.required,
+            version: this.version,
+            fields: this.fields,
+            editableFields: this.editableFields,
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout,
+            defaultContent: this.defaultContent,
+            defaultPanelLayouts,
+            defaultLayoutConfigs: this.defaultLayoutConfigs,
+        });
+    }
+    /**
+     * Specify default configs for a layout.
+     */
+    useConfig(panelLayout, config) {
+        // update default layout configs
+        const defaultLayoutConfigs = Object.assign({}, this.defaultLayoutConfigs);
+        utils_1.ArrayUtils.coerce(panelLayout).forEach(layout => {
+            defaultLayoutConfigs[layout] = config;
+        });
+        // return new block
+        return new PanelledBlock({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            required: this.required,
+            version: this.version,
+            fields: this.fields,
+            editableFields: this.editableFields,
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout,
+            defaultContent: this.defaultContent,
+            defaultPanelLayouts: this.defaultPanelLayouts,
+            defaultLayoutConfigs
+        });
+    }
+    static create(args) {
+        // create new block with both field spec and unwrapped fields
+        return new PanelledBlock({
+            id: args.id,
+            name: args.name,
+            hint: args.hint,
+            version: args.version,
+            fields: args.fields,
+            editableFields: Fields_1.Fields.unwrap(args.fields),
+            config: args.config,
+            getConfig: args.getConfig,
+            getLayout: args.getLayout,
+            defaultContent: args.defaultContent,
+            defaultPanelLayouts: args.defaultPanelLayouts,
+            defaultLayoutConfigs: args.defaultLayoutConfigs,
+        });
+    }
+}
+exports.PanelledBlock = PanelledBlock;

package/dist/schema/blocks/index.d.ts

@@ -0,0 +1 @@
+export * from './PanelledBlock';

package/dist/schema/blocks/index.js

@@ -0,0 +1,17 @@
+"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("./PanelledBlock"), exports);

package/dist/schema/index.d.ts

@@ -1,4 +1,5 @@
 export * from './field/index';
+export * from './blocks';
 export * from './Asset';
 export * from './AssetScope';
 export * from './Block';

package/dist/schema/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./field/index"), exports);
+__exportStar(require("./blocks"), exports);
 __exportStar(require("./Asset"), exports);
 __exportStar(require("./AssetScope"), exports);
 __exportStar(require("./Block"), exports);

package/dist/ui/fields/Field.d.ts

@@ -8,6 +8,7 @@ export declare class Field<TSchema extends Schema.Field.Type = Schema.Field.Type
     readonly id: string;
     readonly name: string;
     readonly required: boolean;
+    readonly tags: ReadonlySet<string>;
     private readonly publishedValue;
     private _initialValue;
     private _value;
@@ -75,6 +76,7 @@ export declare namespace Field {
         initialValue?: Value<TSchema>;
         required: boolean;
         customValidator?: FieldValidator;
+        tags?: string[] | string;
     };
     type Value<TSchema extends Schema.Field.Type = Schema.Field.Type> = Schema.Field.Data<TSchema>;
     interface Event extends EventBus.Event<'Field', Event.Type> {
@@ -85,4 +87,7 @@ export declare namespace Field {
         function filter(event: EventBus.Event): event is Event;
         function create(event: EventBus.Args<Event>): Event;
     }
+    const Tag: {
+        readonly config: "config";
+    };
 }

package/dist/ui/fields/Field.js

@@ -51,6 +51,7 @@ class Field {
         this.name = args.name;
         this.required = args.required;
         this.publishedValue = args.publishedValue;
+        this.tags = new Set(utils_1.ArrayUtils.coerce(args.tags));
         this._initialValue = (_a = args.initialValue) !== null && _a !== void 0 ? _a : this.defaultValue;
         this._value = this._initialValue;
         this._editing = false;
@@ -343,4 +344,8 @@ exports.Field = Field;
         }
         Event.create = create;
     })(Event = Field.Event || (Field.Event = {}));
+    // tags
+    Field.Tag = {
+        config: 'config'
+    };
 })(Field || (exports.Field = Field = {}));

package/dist/utils/ObjectUtils.d.ts

@@ -18,6 +18,11 @@ 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 all undefined properties (shallow) dropped
+     * @param object - the object to process
+     */
+    function dropUndefined<T extends object>(object: T): Partial<T>;
     /**
      * 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

@@ -53,6 +53,24 @@ var ObjectUtils;
         return splitProps(mixedProps, keys).props;
     }
     ObjectUtils.drop = drop;
+    /**
+     * Creates a new object with all undefined properties (shallow) dropped
+     * @param object - the object to process
+     */
+    function dropUndefined(object) {
+        return Object.entries(object).reduce((cleaned, [key, value]) => {
+            // don't include undefined properties
+            if (value === undefined) {
+                return cleaned;
+            }
+            // add property to cleaned object
+            else {
+                cleaned[key] = value;
+                return cleaned;
+            }
+        }, {});
+    }
+    ObjectUtils.dropUndefined = dropUndefined;
     /**
      * 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": "6.1.1",
+  "version": "6.1.3",
   "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": "697c3651dedb43a6e6ff373a495cb29c7e7e1fc6"
+  "gitHead": "f22371fb54de07cd115522c18e5c2c51ba72aa49"
 }