@nascentdigital/funnel-core 4.4.4

package/dist/errors/SerializedIsometricError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedIsometricError = void 0;
+const Value_1 = require("../utils/Value");
+// extension
+var SerializedIsometricError;
+(function (SerializedIsometricError) {
+    // guard
+    function filter(value) {
+        return Value_1.Value.typeOf(value) === 'object'
+            && 'moduleId' in value
+            && Value_1.Value.typeOf(value.moduleId) === 'string';
+    }
+    SerializedIsometricError.filter = filter;
+})(SerializedIsometricError || (exports.SerializedIsometricError = SerializedIsometricError = {}));

package/dist/errors/api/ApiError.d.ts

@@ -0,0 +1,15 @@
+import { IsometricError } from '../IsometricError';
+import { IsometricErrorModule } from '../IsometricErrorModule';
+import { SerializedIsometricError } from '../SerializedIsometricError';
+export declare class ApiError extends IsometricError {
+    readonly status: number;
+    constructor(args: ApiError.ConstructorArgs);
+    serialize(): SerializedIsometricError;
+}
+export declare namespace ApiError {
+    const moduleId: IsometricErrorModule.Id;
+    type ConstructorArgs = IsometricError.ConstructorArgs.WithoutModuleId & {
+        status: number;
+    };
+    type Options = Omit<ConstructorArgs, 'status' | 'message'>;
+}

package/dist/errors/api/ApiError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+const IsometricError_1 = require("../IsometricError");
+// error
+class ApiError extends IsometricError_1.IsometricError {
+    constructor(args) {
+        // construct base
+        super(Object.assign(Object.assign({}, args), { moduleId: ApiError.moduleId }));
+        // initialize instance variables
+        this.status = args.status;
+    }
+    serialize() {
+        const { status } = this;
+        return Object.assign(Object.assign({}, super.serialize()), { status });
+    }
+}
+exports.ApiError = ApiError;
+// extension
+(function (ApiError) {
+    // constants
+    ApiError.moduleId = 'api';
+})(ApiError || (exports.ApiError = ApiError = {}));

package/dist/errors/api/ApiErrors.d.ts

@@ -0,0 +1,7 @@
+import { IsometricError } from '../IsometricError';
+import { IsometricErrorModule } from '../IsometricErrorModule';
+import { SerializedIsometricError } from '../SerializedIsometricError';
+export declare class ApiErrors implements IsometricErrorModule {
+    readonly id: IsometricErrorModule.Id;
+    deserialize(data: SerializedIsometricError): IsometricError | undefined;
+}

package/dist/errors/api/ApiErrors.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiErrors = void 0;
+const Value_1 = require("../../utils/Value");
+const ApiError_1 = require("./ApiError");
+const ArgumentError_1 = require("./ArgumentError");
+const ConflictError_1 = require("./ConflictError");
+const DependencyError_1 = require("./DependencyError");
+const IllegalStateError_1 = require("./IllegalStateError");
+const InvalidOperationError_1 = require("./InvalidOperationError");
+const NotAuthenticatedError_1 = require("./NotAuthenticatedError");
+const NotAuthorizedError_1 = require("./NotAuthorizedError");
+const NotAvailableError_1 = require("./NotAvailableError");
+const NotFoundError_1 = require("./NotFoundError");
+const NotImplementedError_1 = require("./NotImplementedError");
+const OfflineError_1 = require("./OfflineError");
+const RangeError_1 = require("./RangeError");
+const ServerError_1 = require("./ServerError");
+const TimeoutError_1 = require("./TimeoutError");
+// module
+class ApiErrors {
+    constructor() {
+        this.id = ApiError_1.ApiError.moduleId;
+    }
+    deserialize(data) {
+        // skip if module doesn't match
+        if (data.moduleId !== this.id) {
+            return undefined;
+        }
+        // convert
+        switch (data.name) {
+            // re-hydrate error
+            case ArgumentError_1.ArgumentError.name:
+                return new ArgumentError_1.ArgumentError(data.message, Value_1.Value.parseString(data.argumentName));
+            case ConflictError_1.ConflictError.name:
+                return new ConflictError_1.ConflictError(data.message);
+            case DependencyError_1.DependencyError.name:
+                return new DependencyError_1.DependencyError(data.message);
+            case IllegalStateError_1.IllegalStateError.name:
+                return new IllegalStateError_1.IllegalStateError(data.message);
+            case InvalidOperationError_1.InvalidOperationError.name:
+                return new InvalidOperationError_1.InvalidOperationError(data.message);
+            case NotAuthenticatedError_1.NotAuthenticatedError.name:
+                return new NotAuthenticatedError_1.NotAuthenticatedError(data.message);
+            case NotAuthorizedError_1.NotAuthorizedError.name:
+                return new NotAuthorizedError_1.NotAuthorizedError(data.message);
+            case NotAvailableError_1.NotAvailableError.name:
+                return new NotAvailableError_1.NotAvailableError(data.message);
+            case NotFoundError_1.NotFoundError.name:
+                return new NotFoundError_1.NotFoundError(data.message);
+            case NotImplementedError_1.NotImplementedError.name:
+                return new NotImplementedError_1.NotImplementedError(data.message);
+            case OfflineError_1.OfflineError.name:
+                return new OfflineError_1.OfflineError(data.message);
+            case RangeError_1.RangeError.name:
+                return new RangeError_1.RangeError(data.message);
+            case ServerError_1.ServerError.name:
+                return new ServerError_1.ServerError(data.message);
+            case TimeoutError_1.TimeoutError.name:
+                return new TimeoutError_1.TimeoutError(data.message);
+            // or ignore if not matching
+            default:
+                return undefined;
+        }
+    }
+}
+exports.ApiErrors = ApiErrors;

package/dist/errors/api/ArgumentError.d.ts

@@ -0,0 +1,7 @@
+import { SerializedIsometricError } from '../SerializedIsometricError';
+import { ApiError } from './ApiError';
+export declare class ArgumentError extends ApiError {
+    readonly argumentName: string | undefined;
+    constructor(message?: string, argumentName?: string, options?: ApiError.Options);
+    serialize(): SerializedIsometricError;
+}

package/dist/errors/api/ArgumentError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class ArgumentError extends ApiError_1.ApiError {
+    constructor(message = 'Invalid arguments', argumentName, options = {}) {
+        // construct base
+        super(Object.assign({ status: 400, message }, options));
+        // capture argument
+        this.argumentName = argumentName;
+    }
+    serialize() {
+        const { argumentName = null } = this;
+        return Object.assign(Object.assign({}, super.serialize()), { argumentName });
+    }
+}
+exports.ArgumentError = ArgumentError;

package/dist/errors/api/ConcurrencyError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class ConcurrencyError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/ConcurrencyError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcurrencyError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class ConcurrencyError extends ApiError_1.ApiError {
+    constructor(message = 'Concurrency error', options = {}) {
+        super(Object.assign({ status: 423, message }, options));
+    }
+}
+exports.ConcurrencyError = ConcurrencyError;

package/dist/errors/api/ConflictError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class ConflictError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/ConflictError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class ConflictError extends ApiError_1.ApiError {
+    constructor(message = 'A conflict is preventing this operation from succeeding', options = {}) {
+        super(Object.assign({ status: 409, message }, options));
+    }
+}
+exports.ConflictError = ConflictError;

package/dist/errors/api/DependencyError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class DependencyError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/DependencyError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class DependencyError extends ApiError_1.ApiError {
+    constructor(message = 'Upstream operation failed', options = {}) {
+        super(Object.assign({ status: 424, message }, options));
+    }
+}
+exports.DependencyError = DependencyError;

package/dist/errors/api/IllegalStateError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class IllegalStateError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/IllegalStateError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IllegalStateError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class IllegalStateError extends ApiError_1.ApiError {
+    constructor(message = 'Preconditions not met', options = {}) {
+        super(Object.assign({ status: 412, message }, options));
+    }
+}
+exports.IllegalStateError = IllegalStateError;

package/dist/errors/api/InvalidOperationError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class InvalidOperationError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/InvalidOperationError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOperationError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class InvalidOperationError extends ApiError_1.ApiError {
+    constructor(message = 'Invalid operation', options = {}) {
+        super(Object.assign({ status: 405, message }, options));
+    }
+}
+exports.InvalidOperationError = InvalidOperationError;

package/dist/errors/api/NotAuthenticatedError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class NotAuthenticatedError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/NotAuthenticatedError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthenticatedError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class NotAuthenticatedError extends ApiError_1.ApiError {
+    constructor(message = 'Authentication is invalid or missing', options = {}) {
+        super(Object.assign({ status: 401, message }, options));
+    }
+}
+exports.NotAuthenticatedError = NotAuthenticatedError;

package/dist/errors/api/NotAuthorizedError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class NotAuthorizedError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/NotAuthorizedError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class NotAuthorizedError extends ApiError_1.ApiError {
+    constructor(message = 'User does not have permissions for this method', options = {}) {
+        super(Object.assign({ status: 403, message }, options));
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/dist/errors/api/NotAvailableError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class NotAvailableError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/NotAvailableError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAvailableError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class NotAvailableError extends ApiError_1.ApiError {
+    constructor(message = 'Not available', options = {}) {
+        super(Object.assign({ status: 503, message }, options));
+    }
+}
+exports.NotAvailableError = NotAvailableError;

package/dist/errors/api/NotFoundError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class NotFoundError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/NotFoundError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class NotFoundError extends ApiError_1.ApiError {
+    constructor(message = 'Not found', options = {}) {
+        super(Object.assign({ status: 404, message }, options));
+    }
+}
+exports.NotFoundError = NotFoundError;

package/dist/errors/api/NotImplementedError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class NotImplementedError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/NotImplementedError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotImplementedError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class NotImplementedError extends ApiError_1.ApiError {
+    constructor(message = 'Not implemented', options = {}) {
+        super(Object.assign({ status: 501, message }, options));
+    }
+}
+exports.NotImplementedError = NotImplementedError;

package/dist/errors/api/OfflineError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class OfflineError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/OfflineError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class OfflineError extends ApiError_1.ApiError {
+    constructor(message = 'Unable to connect to network', options = {}) {
+        super(Object.assign({ status: 0, message }, options));
+    }
+}
+exports.OfflineError = OfflineError;

package/dist/errors/api/RangeError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class RangeError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/RangeError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class RangeError extends ApiError_1.ApiError {
+    constructor(message = 'Invalid range', options = {}) {
+        super(Object.assign({ status: 416, message }, options));
+    }
+}
+exports.RangeError = RangeError;

package/dist/errors/api/ServerError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class ServerError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/ServerError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class ServerError extends ApiError_1.ApiError {
+    constructor(message = 'Server error', options = {}) {
+        super(Object.assign({ status: 500, message }, options));
+    }
+}
+exports.ServerError = ServerError;

package/dist/errors/api/TimeoutError.d.ts

@@ -0,0 +1,4 @@
+import { ApiError } from './ApiError';
+export declare class TimeoutError extends ApiError {
+    constructor(message?: string, options?: ApiError.Options);
+}

package/dist/errors/api/TimeoutError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+const ApiError_1 = require("./ApiError");
+// error
+class TimeoutError extends ApiError_1.ApiError {
+    constructor(message = 'Timeout', options = {}) {
+        super(Object.assign({ status: 408, message }, options));
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/errors/api/index.d.ts

@@ -0,0 +1,16 @@
+export * from './ApiError';
+export * from './ApiErrors';
+export * from './ArgumentError';
+export * from './ConflictError';
+export * from './DependencyError';
+export * from './IllegalStateError';
+export * from './InvalidOperationError';
+export * from './NotAuthenticatedError';
+export * from './NotAuthorizedError';
+export * from './NotAvailableError';
+export * from './NotFoundError';
+export * from './NotImplementedError';
+export * from './OfflineError';
+export * from './RangeError';
+export * from './ServerError';
+export * from './TimeoutError';

package/dist/errors/api/index.js

@@ -0,0 +1,32 @@
+"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("./ApiError"), exports);
+__exportStar(require("./ApiErrors"), exports);
+__exportStar(require("./ArgumentError"), exports);
+__exportStar(require("./ConflictError"), exports);
+__exportStar(require("./DependencyError"), exports);
+__exportStar(require("./IllegalStateError"), exports);
+__exportStar(require("./InvalidOperationError"), exports);
+__exportStar(require("./NotAuthenticatedError"), exports);
+__exportStar(require("./NotAuthorizedError"), exports);
+__exportStar(require("./NotAvailableError"), exports);
+__exportStar(require("./NotFoundError"), exports);
+__exportStar(require("./NotImplementedError"), exports);
+__exportStar(require("./OfflineError"), exports);
+__exportStar(require("./RangeError"), exports);
+__exportStar(require("./ServerError"), exports);
+__exportStar(require("./TimeoutError"), exports);

package/dist/errors/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './IsometricError';
+export * from './IsometricErrorModule';
+export * from './IsometricErrorUtils';
+export * from './SerializedIsometricError';

package/dist/errors/index.js

@@ -0,0 +1,26 @@
+"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 });
+const api_1 = require("./api");
+const IsometricErrorUtils_1 = require("./IsometricErrorUtils");
+// exports
+__exportStar(require("./api"), exports);
+__exportStar(require("./IsometricError"), exports);
+__exportStar(require("./IsometricErrorModule"), exports);
+__exportStar(require("./IsometricErrorUtils"), exports);
+__exportStar(require("./SerializedIsometricError"), exports);
+// register base modules
+IsometricErrorUtils_1.IsometricErrorUtils.registerModule(api_1.ApiErrors);

package/dist/forms/FormModel.d.ts

@@ -0,0 +1,47 @@
+import { Observable } from 'rxjs';
+import { Field, Fields, Form } from '../schema';
+import { EventBus } from '../services';
+import { Field as UIField, FieldModel as UIFieldModel } from '../ui';
+import { IFormService } from './IFormService';
+export declare class FormModel {
+    readonly schema: Form;
+    readonly fields: ReadonlyArray<UIFieldModel>;
+    readonly consentFields?: ReadonlyArray<UIField>;
+    private readonly _eventBus;
+    private readonly _service;
+    private _state;
+    private _allFields;
+    constructor(args: FormModel.ConstructorArgs);
+    get events$(): Observable<FormModel.Event>;
+    get valid(): boolean;
+    get canSubmit(): boolean;
+    get submitting(): boolean;
+    get submitted(): boolean;
+    get submitFailed(): FormModel.FailedState | undefined;
+    getField(id: string): UIFieldModel;
+    reset(): void;
+    initialize(): Promise<void>;
+    submit(): Promise<void>;
+    private getData;
+    private updateState;
+    private raiseEvent;
+}
+export declare namespace FormModel {
+    type ConstructorArgs = {
+        schema: Form;
+        service: IFormService;
+    };
+    type Data<TFields extends Fields = Fields> = {
+        [T in keyof TFields]: Field.Value.ForOptionalType<TFields[T]>;
+    };
+    type FailedState = 'submitFailedValidation' | 'submitFailedServer';
+    type State = 'initializing' | 'ready' | 'submitting' | 'submitted' | FailedState;
+    type Events = Event | UIFieldModel.Event;
+    interface Event extends EventBus.Event<'Form', Event.Type> {
+    }
+    namespace Event {
+        type Type = State;
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}