@nascentdigital/funnel-core 6.1.5 → 6.1.6

package/dist/schema/Block.d.ts

@@ -14,7 +14,6 @@ export declare class Block<TId extends string = string, TFields extends Fields =
     readonly editableFields: Fields.UnwrapOptional<TFields>;
     readonly config: Block.Config.UnwrapOptional<TConfig>;
     readonly getConfig?: Block.GetConfig<TFields, TConfig>;
-    readonly defaultContent?: Block.DefaultContent<TFields>;
     protected constructor(args: Block.ConstructorArgs<TId, TFields, TConfig>);
     optional(): Optional<Block<TId, TFields, TConfig>>;
     unwrap(): this;
@@ -26,10 +25,6 @@ export declare class Block<TId extends string = string, TFields extends Fields =
     hide(...keys: ReadonlyArray<Fields.OptionalKeys<TFields>>): Block<TId, TFields, TConfig>;
     override(override: Fields.Override<TFields>): Block<TId, TFields, TConfig>;
     extend<TAdditionalFields extends Fields>(fields: TAdditionalFields): Block<TId, TFields & TAdditionalFields, TConfig>;
-    /**
-     * Set default content when block gets created.
-     */
-    withContent(defaultContent: Block.DefaultContent<TFields>): 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 {
@@ -64,7 +59,6 @@ export declare namespace Block {
             updatedConfigSchema?: Partial<Config.UnwrapOptional<TConfig>>;
         };
     }
-    type DefaultContent<TFields extends Fields = Fields> = Array<keyof TFields>;
     type Data<T extends Block = Block> = {
         type: 'block';
         id: T['id'];
@@ -112,7 +106,6 @@ export declare namespace Block {
         editableFields: Fields.UnwrapOptional<TFields>;
         config?: TConfig;
         getConfig?: GetConfig<TFields, TConfig>;
-        defaultContent?: DefaultContent<TFields>;
     };
     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,7 +29,6 @@ class Block {
             }, {})
             : {};
         this.getConfig = args.getConfig;
-        this.defaultContent = args.defaultContent;
     }
     optional() {
         return new Optional_1.Optional(this);
@@ -39,7 +38,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, defaultContent: this.defaultContent }, 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 }, args));
     }
     /**
      * Rename a block's name which is used in the editor.
@@ -73,8 +72,7 @@ class Block {
                 return fields;
             }, Object.assign({}, this.editableFields)),
             config: this.config,
-            getConfig: this.getConfig,
-            defaultContent: this.defaultContent
+            getConfig: this.getConfig
         });
     }
     override(override) {
@@ -90,8 +88,7 @@ class Block {
             fields: this.fields,
             editableFields: Object.assign(Object.assign({}, this.editableFields), overrides),
             config: this.config,
-            getConfig: this.getConfig,
-            defaultContent: this.defaultContent
+            getConfig: this.getConfig
         });
     }
     extend(fields) {
@@ -104,25 +101,7 @@ class Block {
             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,
-            defaultContent: this.defaultContent
-        });
-    }
-    /**
-     * Set default content when block gets created.
-     */
-    withContent(defaultContent) {
-        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,
-            defaultContent: defaultContent
+            getConfig: this.getConfig
         });
     }
     static create(args) {
@@ -135,8 +114,7 @@ class Block {
             fields: args.fields,
             editableFields: Fields_1.Fields.unwrap(args.fields),
             config: args.config,
-            getConfig: args.getConfig,
-            defaultContent: args.defaultContent
+            getConfig: args.getConfig
         });
     }
 }

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

@@ -3,10 +3,11 @@ 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 defaultContent?: PanelledBlock.DefaultContent<TFields>;
     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>);
+    protected constructor({ getConfig, defaultContent, 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.
@@ -18,7 +19,7 @@ export declare class PanelledBlock<TId extends string = string, TFields extends
     /**
      * Set default content when block gets created.
      */
-    withContent(defaultContent: Block.DefaultContent<TFields>): Block<TId, TFields, TConfig>;
+    withContent(defaultContent: PanelledBlock.DefaultContent<TFields>): PanelledBlock<TId, TFields, TConfig>;
     /**
      * Specify a default layout for a set of active panels.
      */
@@ -39,6 +40,7 @@ export declare namespace PanelledBlock {
         type UnwrapOptional<TConfig extends Config> = Block.Config.UnwrapOptional<TConfig>;
         type Value<TConfig extends Config> = Block.Config.Value<TConfig>;
     }
+    type DefaultContent<TFields extends Fields = Fields> = Array<keyof TFields>;
     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> = {
@@ -72,7 +74,7 @@ export declare namespace PanelledBlock {
         config?: TConfig;
         getConfig?: GetConfig<TFields, TConfig>;
         getLayout?: GetLayout<TFields, TConfig>;
-        defaultContent?: Block.DefaultContent<TFields>;
+        defaultContent?: DefaultContent<TFields>;
         defaultPanelLayouts?: DefaultPanelLayouts;
         defaultLayoutConfigs?: DefaultLayoutConfigs<TConfig>;
     };

package/dist/schema/blocks/PanelledBlock.js

@@ -19,10 +19,11 @@ 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"]);
+        var { getConfig, defaultContent, getLayout, defaultPanelLayouts, defaultLayoutConfigs } = _a, args = __rest(_a, ["getConfig", "defaultContent", "getLayout", "defaultPanelLayouts", "defaultLayoutConfigs"]);
         // construct base
         super(Object.assign(Object.assign({}, args), { getConfig: getConfig }));
         // initialize instance variables
+        this.defaultContent = defaultContent;
         this.getLayout = getLayout;
         this.defaultPanelLayouts = defaultPanelLayouts !== null && defaultPanelLayouts !== void 0 ? defaultPanelLayouts : {};
         this.defaultLayoutConfigs = defaultLayoutConfigs !== null && defaultLayoutConfigs !== void 0 ? defaultLayoutConfigs : {};
@@ -110,7 +111,7 @@ class PanelledBlock extends Block_1.Block {
      * Set default content when block gets created.
      */
     withContent(defaultContent) {
-        return new Block_1.Block({
+        return new PanelledBlock({
             id: this.id,
             name: this.name,
             hint: this.hint,
@@ -120,7 +121,10 @@ class PanelledBlock extends Block_1.Block {
             editableFields: this.editableFields,
             config: this.config,
             getConfig: this.getConfig,
-            defaultContent: defaultContent
+            getLayout: this.getLayout,
+            defaultContent: defaultContent,
+            defaultPanelLayouts: this.defaultPanelLayouts,
+            defaultLayoutConfigs: this.defaultLayoutConfigs,
         });
     }
     /**

package/dist/services/Logger.d.ts

@@ -0,0 +1,72 @@
+export declare class Logger {
+    private static _configurations?;
+    private static readonly _loggers;
+    readonly context: string;
+    readonly configuration: Logger.Configuration;
+    static configure(configurations: Logger.Configurations.Args): void;
+    static get(context?: Logger.Context.WithoutRoot): Logger;
+    private constructor();
+    error(message: string, ...args: any[]): void;
+    e(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    w(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    i(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    d(message: string, ...args: any[]): void;
+    verbose(message: string, ...args: any[]): void;
+    v(message: string, ...args: any[]): void;
+    trace(message: string, ...args: any[]): void;
+    t(message: string, ...args: any[]): void;
+    private log;
+}
+export declare namespace Logger {
+    type Context = Context.Root | `${string}` | `${string}${Context.Delimiter}${string}` | `${string}${Context.Delimiter}${string}${Context.Delimiter}${string}` | `${string}${Context.Delimiter}${string}${Context.Delimiter}${string}${Context.Delimiter}${string}`;
+    namespace Context {
+        const root: "";
+        type Root = typeof root;
+        const delimiter: ":";
+        type Delimiter = typeof delimiter;
+        type WithoutRoot = Exclude<Context, Root>;
+    }
+    type Level = 'error' | 'warn' | 'info' | 'debug' | 'verbose' | 'trace';
+    namespace Level {
+        const values: ReadonlyArray<Level>;
+        function compare(lhs: Level, rhs: Level): number;
+        function parse(value: string): Level | undefined;
+    }
+    type LevelOptions = Readonly<LevelOptions.Mutable>;
+    namespace LevelOptions {
+        type Flexible = Level | ReadonlyArray<Level> | LevelOptions;
+        type Mutable = Record<Level, boolean>;
+        function coerce(levelOrOptions: Flexible): LevelOptions;
+        function filter(levelOrOptions: Flexible): levelOrOptions is LevelOptions;
+        function fromLevels(levels: ReadonlyArray<Level>): LevelOptions;
+    }
+    type Configuration = {
+        levels: LevelOptions;
+        color?: string;
+        bgColor?: string;
+    };
+    namespace Configuration {
+        const defaults: Readonly<Configuration>;
+        type Flexible = {
+            levels?: LevelOptions.Flexible;
+            color?: string;
+            bgColor?: string;
+        };
+    }
+    type Configurations = Readonly<Record<Context, Readonly<Configuration>>>;
+    namespace Configurations {
+        type Args = {
+            root: Configuration.Flexible;
+            contexts?: Readonly<Record<Context.WithoutRoot, Readonly<Configuration.Flexible>>>;
+        };
+        type Parsed = Readonly<Record<Context, Readonly<Partial<Configuration>>>>;
+        function parse({ root, contexts }: Args): Parsed;
+    }
+    type ConstructorArgs = {
+        context: string;
+        configuration: Configuration;
+    };
+}

package/dist/services/Logger.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+// class
+class Logger {
+    static configure(configurations) {
+        // set configuration
+        Logger._configurations = Object.assign({ [Logger.Context.root]: Logger.Configuration.defaults }, Logger.Configurations.parse(configurations));
+        // reset loggers
+        Logger._loggers.clear();
+    }
+    static get(context) {
+        var _a;
+        // helper to get logger
+        const loggers = Logger._loggers;
+        const configurations = (_a = Logger._configurations) !== null && _a !== void 0 ? _a : { [Logger.Context.root]: Logger.Configuration.defaults };
+        let currentConfiguration = configurations[Logger.Context.root];
+        const getLogger = (context) => {
+            var _a, _b, _c;
+            // get logger (or create one)
+            let logger = loggers.get(context);
+            if (!logger) {
+                const maybeConfiguration = configurations[context];
+                const configuration = {
+                    levels: (_a = maybeConfiguration === null || maybeConfiguration === void 0 ? void 0 : maybeConfiguration.levels) !== null && _a !== void 0 ? _a : currentConfiguration.levels,
+                    color: (_b = maybeConfiguration === null || maybeConfiguration === void 0 ? void 0 : maybeConfiguration.color) !== null && _b !== void 0 ? _b : currentConfiguration.color,
+                    bgColor: (_c = maybeConfiguration === null || maybeConfiguration === void 0 ? void 0 : maybeConfiguration.bgColor) !== null && _c !== void 0 ? _c : currentConfiguration.bgColor
+                };
+                logger = new Logger({ context, configuration });
+                loggers.set(context, logger);
+            }
+            // return logger
+            return logger;
+        };
+        // walk context in parts, building along the way (this is required to get configurations right)
+        const contextParts = context
+            ? context.split(Logger.Context.delimiter)
+            : [];
+        let logger = getLogger(Logger.Context.root);
+        for (const contextPart of contextParts) {
+            // get new logger
+            const context = logger.context === Logger.Context.root
+                ? contextPart
+                : `${logger.context}${Logger.Context.delimiter}${contextPart}`;
+            logger = getLogger(context);
+            // update logger levels (used for cascading/inheriting nearest options)
+            currentConfiguration = logger.configuration;
+        }
+        // return logger
+        return logger;
+    }
+    constructor({ context, configuration }) {
+        // initialize instance variables
+        this.context = context;
+        this.configuration = configuration;
+    }
+    error(message, ...args) {
+        this.e(message, ...args);
+    }
+    e(message, ...args) {
+        this.log('error', message, args);
+    }
+    warn(message, ...args) {
+        this.w(message, ...args);
+    }
+    w(message, ...args) {
+        this.log('warn', message, args);
+    }
+    info(message, ...args) {
+        this.i(message, ...args);
+    }
+    i(message, ...args) {
+        this.log('info', message, args);
+    }
+    debug(message, ...args) {
+        this.d(message, ...args);
+    }
+    d(message, ...args) {
+        this.log('debug', message, args);
+    }
+    verbose(message, ...args) {
+        this.v(message, ...args);
+    }
+    v(message, ...args) {
+        this.log('verbose', message, args);
+    }
+    trace(message, ...args) {
+        this.t(message, ...args);
+    }
+    t(message, ...args) {
+        this.log('trace', message, args);
+    }
+    log(level, message, argsRaw) {
+        // skip if level isn't included
+        const { context: contextRaw, configuration: { color, bgColor, levels } } = this;
+        if (!levels[level]) {
+            return;
+        }
+        // basic formating if there's no color
+        const context = contextRaw === Logger.Context.root ? '$' : contextRaw;
+        let formattedMessage;
+        let args;
+        if (!color && !bgColor) {
+            formattedMessage = `[${context}] ${message}`;
+            args = argsRaw;
+        }
+        // or format for browser
+        else if (typeof global.window !== 'undefined') {
+            formattedMessage = `[%c${context}%c] ${message}`;
+            args = [
+                `color: ${color !== null && color !== void 0 ? color : 'inherit'}; background: ${bgColor !== null && bgColor !== void 0 ? bgColor : 'inherit'};`,
+                'color: inherit; background: inherit;',
+                ...argsRaw
+            ];
+        }
+        // or for console
+        else {
+            formattedMessage = `[${context}] ${message}`;
+            args = argsRaw;
+        }
+        // log based on level
+        switch (level) {
+            case 'error':
+                console.error(formattedMessage, ...args);
+                break;
+            case 'warn':
+                console.warn(formattedMessage, ...args);
+                break;
+            case 'info':
+                console.log(formattedMessage, ...args);
+                break;
+            case 'debug':
+                console.debug(formattedMessage, ...args);
+                break;
+            case 'verbose':
+                console.debug(formattedMessage, ...args);
+                break;
+            case 'trace':
+                console.trace(formattedMessage, ...args);
+                break;
+        }
+    }
+}
+exports.Logger = Logger;
+Logger._loggers = new Map();
+// namespace
+(function (Logger) {
+    let Context;
+    (function (Context) {
+        // root
+        Context.root = '';
+        // delimiter
+        Context.delimiter = ':';
+        // helpers
+    })(Context = Logger.Context || (Logger.Context = {}));
+    let Level;
+    (function (Level) {
+        // values
+        Level.values = [
+            'trace', 'verbose', 'debug', 'info', 'warn', 'error'
+        ];
+        // helpers
+        function compare(lhs, rhs) {
+            return lhs === rhs
+                ? 0
+                : Level.values.indexOf(lhs) < Level.values.indexOf(rhs)
+                    ? -1
+                    : 1;
+        }
+        Level.compare = compare;
+        function parse(value) {
+            const normalizedValue = value.trim().toLowerCase();
+            return Level.values.includes(normalizedValue)
+                ? normalizedValue
+                : undefined;
+        }
+        Level.parse = parse;
+    })(Level = Logger.Level || (Logger.Level = {}));
+    let LevelOptions;
+    (function (LevelOptions) {
+        // helpers
+        function coerce(levelOrOptions) {
+            // skip if it's already options
+            if (filter(levelOrOptions)) {
+                return levelOrOptions;
+            }
+            // or use level as minimum options
+            else if (typeof levelOrOptions === 'string') {
+                return Level.values.reduce((options, level) => {
+                    // enable option if at least min level
+                    options[level] = Level.compare(level, levelOrOptions) >= 0;
+                    // keep reducing
+                    return options;
+                }, {});
+            }
+            // or use levels from array of items (presence indicates active)
+            else {
+                return fromLevels(levelOrOptions);
+            }
+        }
+        LevelOptions.coerce = coerce;
+        function filter(levelOrOptions) {
+            return typeof levelOrOptions !== 'string' && !Array.isArray(levelOrOptions);
+        }
+        LevelOptions.filter = filter;
+        function fromLevels(levels) {
+            // create options for any items that are indicated
+            return Level.values.reduce((options, level) => {
+                // enable/disable based on capture
+                options[level] = levels.includes(level);
+                // keep reducing
+                return options;
+            }, {});
+        }
+        LevelOptions.fromLevels = fromLevels;
+    })(LevelOptions = Logger.LevelOptions || (Logger.LevelOptions = {}));
+    let Configuration;
+    (function (Configuration) {
+        // defaults
+        Configuration.defaults = {
+            levels: {
+                trace: false,
+                verbose: false,
+                debug: false,
+                info: false,
+                warn: true,
+                error: true
+            }
+        };
+    })(Configuration = Logger.Configuration || (Logger.Configuration = {}));
+    let Configurations;
+    (function (Configurations) {
+        // helpers
+        function parse({ root, contexts = {} }) {
+            // create configuration
+            const configurations = {};
+            // bind root
+            configurations[Context.root] = {
+                levels: root.levels ? LevelOptions.coerce(root.levels) : undefined,
+                color: root.color,
+                bgColor: root.bgColor
+            };
+            // bind contexts
+            Object.entries(contexts).forEach(([context, configuration]) => {
+                configurations[context] = {
+                    levels: configuration.levels ? LevelOptions.coerce(configuration.levels) : undefined,
+                    color: configuration.color,
+                    bgColor: configuration.bgColor
+                };
+            });
+            // return configuration
+            return configurations;
+        }
+        Configurations.parse = parse;
+    })(Configurations = Logger.Configurations || (Logger.Configurations = {}));
+})(Logger || (exports.Logger = Logger = {}));

package/dist/services/index.d.ts

@@ -1,3 +1,4 @@
-export * from './EventBus';
 export * from './humanVerification';
 export * from './leadGen';
+export * from './EventBus';
+export * from './Logger';

package/dist/services/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./EventBus"), exports);
 __exportStar(require("./humanVerification"), exports);
 __exportStar(require("./leadGen"), exports);
+__exportStar(require("./EventBus"), exports);
+__exportStar(require("./Logger"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nascentdigital/funnel-core",
-  "version": "6.1.5",
+  "version": "6.1.6",
   "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": "567edc7796b910ef548506fd659f267b80187c29"
+  "gitHead": "63e7e3fa90a0d490576311a388e8a0d99bd4b5e4"
 }