@nascentdigital/funnel-core 4.4.4

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextField = void 0;
+const index_1 = require("../index");
+// class
+class TextField extends index_1.Field {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(args);
+        this.type = 'text';
+        // initialize instance variables
+        this.semantics = (_a = args.semantics) !== null && _a !== void 0 ? _a : 'short';
+        this.exact = args.exact;
+        this.minLength = args.minLength;
+        this.maxLength = args.maxLength;
+        // set mask/regex based on semantics
+        switch (args.semantics) {
+            case 'slug':
+                this.regex = TextField.Regex.slug();
+                break;
+            case 'email':
+                this.regex = TextField.Regex.email();
+                break;
+            case 'phone':
+                this.regex = /^\d{10}$/;
+                break;
+            case 'phone-intl':
+                this.regex = /^\d{10,14}$/;
+                break;
+            case 'integer':
+                this.regex = /^\d*$/;
+                break;
+            case 'password':
+                this.regex = TextField.Regex.password();
+                break;
+            default:
+                this.regex = args.regex;
+                break;
+        }
+    }
+    modify(args) {
+        return new TextField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, semantics: this.semantics, regex: this.regex, exact: this.exact, minLength: this.minLength, maxLength: this.maxLength }, args));
+    }
+}
+exports.TextField = TextField;
+// extension
+(function (TextField) {
+    let Value;
+    (function (Value) {
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'text',
+                value
+            };
+        }
+        Value.toData = toData;
+        function coerceData(value) {
+            return value === undefined
+                ? undefined
+                : toData(value);
+        }
+        Value.coerceData = coerceData;
+    })(Value = TextField.Value || (TextField.Value = {}));
+    // regex
+    let Regex;
+    (function (Regex) {
+        function email() {
+            return /^[\w-_.]+@([\w-_]+\.)+\w{2,4}$/;
+        }
+        Regex.email = email;
+        function slug() {
+            return /^(?!.*--)[a-z\d]+(-([a-z\d]+))*$/;
+        }
+        Regex.slug = slug;
+        function password() {
+            return /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@.,<>|{}$!%*?&_:;/\\()\-+#^[\]])[A-Za-z\d@.,<>|{}$!%*?&_:;/\\()\-+#^[\]]{8,}$/;
+        }
+        Regex.password = password;
+    })(Regex = TextField.Regex || (TextField.Regex = {}));
+})(TextField || (exports.TextField = TextField = {}));

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

@@ -0,0 +1,25 @@
+import { Timestamp } from '../../../types';
+import { Field } from '../index';
+export declare class TimestampField extends Field<TimestampField> {
+    readonly type: "timestamp";
+    readonly timezone: Timestamp.Timezone;
+    readonly minTime?: Timestamp;
+    readonly maxTime?: Timestamp;
+    readonly defaultHour?: Timestamp.Hour;
+    constructor(args: TimestampField.ConstructorArgs);
+    modify(args: TimestampField.ModifyArgs): TimestampField;
+}
+export declare namespace TimestampField {
+    type Value = Timestamp;
+    namespace Value {
+        function fromData(data: Field.Data<TimestampField> | undefined): Timestamp | undefined;
+        function toData(value: Value): Field.Data<TimestampField>;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        timezone?: Timestamp.Timezone;
+        minTime?: Timestamp;
+        maxTime?: Timestamp;
+        defaultHour?: Timestamp.Hour;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampField = void 0;
+const types_1 = require("../../../types");
+const index_1 = require("../index");
+// class
+class TimestampField extends index_1.Field {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(args);
+        this.type = 'timestamp';
+        // initialize instance variables
+        this.timezone = (_a = args.timezone) !== null && _a !== void 0 ? _a : types_1.Timestamp.Timezone.fallback;
+        this.minTime = args.minTime;
+        this.maxTime = args.maxTime;
+        this.defaultHour = args.defaultHour;
+    }
+    modify(args) {
+        return new TimestampField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, timezone: this.timezone, minTime: this.minTime, maxTime: this.maxTime, defaultHour: this.defaultHour }, args));
+    }
+}
+exports.TimestampField = TimestampField;
+// extension
+(function (TimestampField) {
+    let Value;
+    (function (Value) {
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'timestamp',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = TimestampField.Value || (TimestampField.Value = {}));
+})(TimestampField || (exports.TimestampField = TimestampField = {}));

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

@@ -0,0 +1,13 @@
+export * from './AssetField';
+export * from './BooleanField';
+export * from './CollectionField';
+export * from './DateField';
+export * from './DynamicPagesField';
+export * from './EmbeddedVideoField';
+export * from './EnumField';
+export * from './FormField';
+export * from './LinkField';
+export * from './PageField';
+export * from './RichTextField';
+export * from './TextField';
+export * from './TimestampField';

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

@@ -0,0 +1,29 @@
+"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("./AssetField"), exports);
+__exportStar(require("./BooleanField"), exports);
+__exportStar(require("./CollectionField"), exports);
+__exportStar(require("./DateField"), exports);
+__exportStar(require("./DynamicPagesField"), exports);
+__exportStar(require("./EmbeddedVideoField"), exports);
+__exportStar(require("./EnumField"), exports);
+__exportStar(require("./FormField"), exports);
+__exportStar(require("./LinkField"), exports);
+__exportStar(require("./PageField"), exports);
+__exportStar(require("./RichTextField"), exports);
+__exportStar(require("./TextField"), exports);
+__exportStar(require("./TimestampField"), exports);

package/dist/schema/field/composite/ListField.d.ts

@@ -0,0 +1,47 @@
+import { Field, ObjectField } from '../index';
+export declare class ListField<TContent extends ListField.Content = ListField.Content> extends Field<ListField<TContent>> {
+    readonly type = "list";
+    readonly itemTypes: TContent;
+    readonly min: number;
+    readonly max: number;
+    constructor({ min, max, ...args }: ListField.ConstructorArgs<TContent>);
+    modify(args: ListField.ModifyArgs<TContent>): ListField<TContent>;
+}
+export declare namespace ListField {
+    type Content = Record<string, Content.Type>;
+    namespace Content {
+        type Type = Field.Type.Simple | ObjectField;
+        type NonAggregate = Record<string, Field.Type.Simple.NonAggregate>;
+        type Aggregate = Record<string, Field.Type.Simple.Aggregate | ObjectField>;
+        function isAggregate(content: Content): content is Aggregate;
+    }
+    type Value<T extends ListField = ListField> = Value.ForItem<T['itemTypes']>[];
+    namespace Value {
+        type ForItem<TContent extends Content = Content> = Field.Data<TContent[keyof TContent]> & {
+            schema: keyof TContent;
+            id: string;
+        };
+        function purifyItem<TField extends Field.Type>(item?: ForItem): Field.Data<TField> | undefined;
+        function fromData(data: Field.Data<ListField<Content>> | undefined): Value<ListField<Content>>;
+        function toData(value: Value<ListField<Content>>): Field.Data<ListField<Content>>;
+    }
+    type LinkedValue<T extends ListField = ListField> = LinkedValue.ForItem<T['itemTypes']>[];
+    namespace LinkedValue {
+        type ForItem<TContent extends Content = Content> = Field.LinkedData<TContent[keyof TContent]> & {
+            schema: keyof TContent;
+            id: string;
+        };
+        function purifyItem<TField extends Field.Type>(item?: ForItem): Field.LinkedData<TField> | undefined;
+        function fromData(data: Field.LinkedData<ListField<Content>> | undefined): LinkedValue<ListField<Content>>;
+        function toData(value: LinkedValue<ListField<Content>>): Field.LinkedData<ListField<Content>>;
+    }
+    type LinkedItem<T> = T & {
+        id: string;
+    };
+    type ConstructorArgs<TContent extends Content> = Field.ConstructorArgs & {
+        itemTypes: TContent;
+        min: number;
+        max: number;
+    };
+    type ModifyArgs<TContent extends Content> = Omit<Partial<ConstructorArgs<TContent>>, 'required'>;
+}

package/dist/schema/field/composite/ListField.js

@@ -0,0 +1,107 @@
+"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.ListField = void 0;
+const errors_1 = require("../../../errors");
+const index_1 = require("../index");
+// class
+class ListField extends index_1.Field {
+    constructor(_a) {
+        var { min, max } = _a, args = __rest(_a, ["min", "max"]);
+        // construct base
+        super(args);
+        this.type = 'list';
+        // validate args
+        if (min < 1) {
+            console.error(`[ListField] ${args.name} has non-positive "min" value`);
+            throw new errors_1.ArgumentError('List "min" must be positive - mark as "optional" instead', 'min');
+        }
+        else if (max < min) {
+            console.error(`[ListField] ${args.name} has "max" value that is less than "min"`);
+            throw new errors_1.ArgumentError('List "max" cannot be less than "min"', 'max');
+        }
+        // initialize instance variables
+        this.itemTypes = args.itemTypes;
+        this.min = min;
+        this.max = max;
+    }
+    modify(args) {
+        return new ListField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, itemTypes: this.itemTypes, min: this.min, max: this.max }, args));
+    }
+}
+exports.ListField = ListField;
+// extension
+(function (ListField) {
+    let Content;
+    (function (Content) {
+        // helpers
+        function isAggregate(content) {
+            return Object.values(content).every(index_1.Field.Type.Simple.Aggregate.filter);
+        }
+        Content.isAggregate = isAggregate;
+    })(Content = ListField.Content || (ListField.Content = {}));
+    let Value;
+    (function (Value) {
+        // strips out metadata to leave pure item
+        function purifyItem(item) {
+            // skip if there's no item
+            if (!item) {
+                return undefined;
+            }
+            // or purify
+            const { id, schema } = item, pureItem = __rest(item, ["id", "schema"]);
+            return pureItem;
+        }
+        Value.purifyItem = purifyItem;
+        // serialization
+        function fromData(data) {
+            var _a;
+            return (_a = data === null || data === void 0 ? void 0 : data.value) !== null && _a !== void 0 ? _a : [];
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'list',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = ListField.Value || (ListField.Value = {}));
+    let LinkedValue;
+    (function (LinkedValue) {
+        // strips out metadata to leave pure item
+        function purifyItem(item) {
+            // skip if there's no item
+            if (!item) {
+                return undefined;
+            }
+            // or purify
+            const { id, schema } = item, pureItem = __rest(item, ["id", "schema"]);
+            return pureItem;
+        }
+        LinkedValue.purifyItem = purifyItem;
+        // serialization
+        function fromData(data) {
+            var _a;
+            return (_a = data === null || data === void 0 ? void 0 : data.value) !== null && _a !== void 0 ? _a : [];
+        }
+        LinkedValue.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'list',
+                value
+            };
+        }
+        LinkedValue.toData = toData;
+    })(LinkedValue = ListField.LinkedValue || (ListField.LinkedValue = {}));
+})(ListField || (exports.ListField = ListField = {}));

package/dist/schema/field/composite/ObjectField.d.ts

@@ -0,0 +1,56 @@
+import { Optional } from '../../Optional';
+import { Field, ListField, AssetField } from '../index';
+export declare class ObjectField<TContent extends ObjectField.Content = ObjectField.Content> extends Field<ObjectField<TContent>> {
+    readonly type: "object";
+    readonly content: TContent;
+    readonly preview: Readonly<ObjectField.Preview<TContent>>;
+    constructor(args: ObjectField.ConstructorArgs<TContent>);
+    modify(args: ObjectField.ModifyArgs): ObjectField<TContent>;
+}
+export declare namespace ObjectField {
+    type _Optional<T extends Optional.Content> = Optional<T>;
+    export type Content = Record<string, Content.Item>;
+    export namespace Content {
+        type Type = Field.Type.Simple | ListField<ListField.Content> | ObjectField;
+        type Item = Optional.Maybe<Type>;
+        type Optional<TContent extends Content> = {
+            [key in keyof TContent as TContent[key] extends _Optional<any> ? key : never]: TContent[key];
+        };
+        type Required<TContent extends Content> = {
+            [key in keyof TContent as TContent[key] extends _Optional<any> ? never : key]: TContent[key];
+        };
+        type Text<TContent extends Content> = {
+            [key in keyof TContent as TContent[key] extends Optional.Maybe<Field.Type.Simple.Text> ? key : never]: TContent[key];
+        };
+        type Asset<TContent extends Content> = {
+            [key in keyof TContent as TContent[key] extends Optional.Maybe<AssetField> ? key : never]: TContent[key];
+        };
+    }
+    export type Value<T extends ObjectField = ObjectField> = Value.ForContent<T['content']>;
+    namespace Value {
+        type ForContent<T extends Content> = {
+            [key in keyof T as T[key] extends _Optional<any> ? never : key]: Field.Data.ForOptionalType<T[key]>;
+        } & {
+            [key in keyof T as T[key] extends _Optional<any> ? key : never]?: Field.Data.ForOptionalType<T[key]>;
+        };
+    }
+    export type LinkedValue<T extends ObjectField = ObjectField> = LinkedValue.ForContent<T['content']>;
+    namespace LinkedValue {
+        type ForContent<T extends Content> = {
+            [key in keyof T as T[key] extends _Optional<any> ? never : key]: Field.LinkedData.ForOptionalType<T[key]>;
+        } & {
+            [key in keyof T as T[key] extends _Optional<any> ? key : never]?: Field.LinkedData.ForOptionalType<T[key]>;
+        };
+    }
+    export type ConstructorArgs<TContent extends Content> = Field.ConstructorArgs & {
+        preview: Preview<TContent>;
+        content: TContent;
+    };
+    export type ModifyArgs = Partial<Field.ConstructorArgs>;
+    export type Preview<TContent extends Content = Content> = {
+        title: keyof Content.Required<Content.Text<TContent>>;
+        subtitle?: keyof Content.Text<TContent>;
+        visual?: keyof Content.Asset<TContent>;
+    };
+    export {};
+}

package/dist/schema/field/composite/ObjectField.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectField = void 0;
+const index_1 = require("../index");
+// class
+class ObjectField extends index_1.Field {
+    constructor(args) {
+        // construct base
+        super(args);
+        this.type = 'object';
+        // initialize instance variables
+        this.content = args.content;
+        this.preview = args.preview;
+    }
+    modify(args) {
+        return new ObjectField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, content: this.content, preview: this.preview }, args));
+    }
+}
+exports.ObjectField = ObjectField;

package/dist/schema/field/composite/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ListField';
+export * from './ObjectField';

package/dist/schema/field/composite/index.js

@@ -0,0 +1,18 @@
+"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("./ListField"), exports);
+__exportStar(require("./ObjectField"), exports);

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

@@ -0,0 +1,3 @@
+export * from './Field';
+export * from './base';
+export * from './composite';

package/dist/schema/field/index.js

@@ -0,0 +1,19 @@
+"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("./Field"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./composite"), exports);

package/dist/schema/index.d.ts

@@ -0,0 +1,25 @@
+export * from './field/index';
+export * from './Asset';
+export * from './AssetScope';
+export * from './Block';
+export * from './ChangeSet';
+export * from './Collection';
+export * from './CollectionModel';
+export * from './CollectionSnapshot';
+export * from './Fields';
+export * from './Form';
+export * from './LinkedCollectionModel';
+export * from './LinkedData';
+export * from './LinkedPageModel';
+export * from './Optional';
+export * from './Page';
+export * from './PageModel';
+export * from './PageQuery';
+export * from './PageRoute';
+export * from './PageSnapshot';
+export * from './Section';
+export * from './Seo';
+export * from './Site';
+export * from './SiteModel';
+export * from './Tag';
+export * from './TagGroup';

package/dist/schema/index.js

@@ -0,0 +1,41 @@
+"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("./field/index"), exports);
+__exportStar(require("./Asset"), exports);
+__exportStar(require("./AssetScope"), exports);
+__exportStar(require("./Block"), exports);
+__exportStar(require("./ChangeSet"), exports);
+__exportStar(require("./Collection"), exports);
+__exportStar(require("./CollectionModel"), exports);
+__exportStar(require("./CollectionSnapshot"), exports);
+__exportStar(require("./Fields"), exports);
+__exportStar(require("./Form"), exports);
+__exportStar(require("./LinkedCollectionModel"), exports);
+__exportStar(require("./LinkedData"), exports);
+__exportStar(require("./LinkedPageModel"), exports);
+__exportStar(require("./Optional"), exports);
+__exportStar(require("./Page"), exports);
+__exportStar(require("./PageModel"), exports);
+__exportStar(require("./PageQuery"), exports);
+__exportStar(require("./PageRoute"), exports);
+__exportStar(require("./PageSnapshot"), exports);
+__exportStar(require("./Section"), exports);
+__exportStar(require("./Seo"), exports);
+__exportStar(require("./Site"), exports);
+__exportStar(require("./SiteModel"), exports);
+__exportStar(require("./Tag"), exports);
+__exportStar(require("./TagGroup"), exports);

package/dist/services/EventBus.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { PartialBy } from '../types';
+export declare class EventBus {
+    private readonly _events$;
+    constructor();
+    get events$(): Observable<EventBus.Event>;
+    publish({ timestamp, ...event }: EventBus.Event): void;
+}
+export declare namespace EventBus {
+    interface Event<TDomain extends string = string, TType extends string = string> {
+        domain: TDomain;
+        type: TType;
+        timestamp: number;
+    }
+    type Args<TEvent extends Event> = Omit<TEvent, 'domain' | 'timestamp'>;
+    function createEvent<TEvent extends Event>({ timestamp, ...args }: PartialBy<TEvent, 'timestamp'>): TEvent;
+}

package/dist/services/EventBus.js

@@ -0,0 +1,37 @@
+"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.EventBus = void 0;
+const rxjs_1 = require("rxjs");
+// class
+class EventBus {
+    constructor() {
+        this._events$ = new rxjs_1.Subject();
+    }
+    get events$() {
+        return this._events$.asObservable();
+    }
+    publish(_a) {
+        var { timestamp } = _a, event = __rest(_a, ["timestamp"]);
+        this._events$.next(Object.assign(Object.assign({}, event), { timestamp: timestamp !== undefined ? timestamp : Date.now() }));
+    }
+}
+exports.EventBus = EventBus;
+// extension
+(function (EventBus) {
+    function createEvent(_a) {
+        var { timestamp } = _a, args = __rest(_a, ["timestamp"]);
+        return Object.assign(Object.assign({}, args), { timestamp: timestamp !== null && timestamp !== void 0 ? timestamp : Date.now() });
+    }
+    EventBus.createEvent = createEvent;
+})(EventBus || (exports.EventBus = EventBus = {}));

package/dist/services/humanVerification/IHumanVerification.d.ts

@@ -0,0 +1,8 @@
+export interface IHumanVerification {
+    verify(args: IHumanVerification.VerifyUserIsHumanArgs): Promise<void>;
+}
+export declare namespace IHumanVerification {
+    type VerifyUserIsHumanArgs = {
+        verificationToken: string;
+    };
+}

package/dist/services/humanVerification/IHumanVerification.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/humanVerification/index.d.ts

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

package/dist/services/humanVerification/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("./IHumanVerification"), exports);

package/dist/services/index.d.ts

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