@justifi/webcomponents 4.6.4 → 4.7.0-rc.1

package/dist/cjs/form-1e732a9d.js

@@ -0,0 +1,731 @@
+'use strict';
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function createErrorClass(createImpl) {
+    const _super = (instance) => {
+        Error.call(instance);
+        instance.stack = new Error().stack;
+    };
+    const ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+}
+
+const UnsubscriptionError = createErrorClass((_super) => function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors
+        ? `${errors.length} errors occurred during unsubscription:
+${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}`
+        : '';
+    this.name = 'UnsubscriptionError';
+    this.errors = errors;
+});
+
+function arrRemove(arr, item) {
+    if (arr) {
+        const index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+    }
+}
+
+class Subscription {
+    constructor(initialTeardown) {
+        this.initialTeardown = initialTeardown;
+        this.closed = false;
+        this._parentage = null;
+        this._finalizers = null;
+    }
+    unsubscribe() {
+        let errors;
+        if (!this.closed) {
+            this.closed = true;
+            const { _parentage } = this;
+            if (_parentage) {
+                this._parentage = null;
+                if (Array.isArray(_parentage)) {
+                    for (const parent of _parentage) {
+                        parent.remove(this);
+                    }
+                }
+                else {
+                    _parentage.remove(this);
+                }
+            }
+            const { initialTeardown: initialFinalizer } = this;
+            if (isFunction(initialFinalizer)) {
+                try {
+                    initialFinalizer();
+                }
+                catch (e) {
+                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                }
+            }
+            const { _finalizers } = this;
+            if (_finalizers) {
+                this._finalizers = null;
+                for (const finalizer of _finalizers) {
+                    try {
+                        execFinalizer(finalizer);
+                    }
+                    catch (err) {
+                        errors = errors !== null && errors !== void 0 ? errors : [];
+                        if (err instanceof UnsubscriptionError) {
+                            errors = [...errors, ...err.errors];
+                        }
+                        else {
+                            errors.push(err);
+                        }
+                    }
+                }
+            }
+            if (errors) {
+                throw new UnsubscriptionError(errors);
+            }
+        }
+    }
+    add(teardown) {
+        var _a;
+        if (teardown && teardown !== this) {
+            if (this.closed) {
+                execFinalizer(teardown);
+            }
+            else {
+                if (teardown instanceof Subscription) {
+                    if (teardown.closed || teardown._hasParent(this)) {
+                        return;
+                    }
+                    teardown._addParent(this);
+                }
+                (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+            }
+        }
+    }
+    _hasParent(parent) {
+        const { _parentage } = this;
+        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+    }
+    _addParent(parent) {
+        const { _parentage } = this;
+        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+    }
+    _removeParent(parent) {
+        const { _parentage } = this;
+        if (_parentage === parent) {
+            this._parentage = null;
+        }
+        else if (Array.isArray(_parentage)) {
+            arrRemove(_parentage, parent);
+        }
+    }
+    remove(teardown) {
+        const { _finalizers } = this;
+        _finalizers && arrRemove(_finalizers, teardown);
+        if (teardown instanceof Subscription) {
+            teardown._removeParent(this);
+        }
+    }
+}
+Subscription.EMPTY = (() => {
+    const empty = new Subscription();
+    empty.closed = true;
+    return empty;
+})();
+const EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+    return (value instanceof Subscription ||
+        (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
+}
+function execFinalizer(finalizer) {
+    if (isFunction(finalizer)) {
+        finalizer();
+    }
+    else {
+        finalizer.unsubscribe();
+    }
+}
+
+const config = {
+    onUnhandledError: null,
+    onStoppedNotification: null,
+    Promise: undefined,
+    useDeprecatedSynchronousErrorHandling: false,
+    useDeprecatedNextContext: false,
+};
+
+const timeoutProvider = {
+    setTimeout(handler, timeout, ...args) {
+        const { delegate } = timeoutProvider;
+        if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+            return delegate.setTimeout(handler, timeout, ...args);
+        }
+        return setTimeout(handler, timeout, ...args);
+    },
+    clearTimeout(handle) {
+        const { delegate } = timeoutProvider;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+    },
+    delegate: undefined,
+};
+
+function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(() => {
+        const { onUnhandledError } = config;
+        if (onUnhandledError) {
+            onUnhandledError(err);
+        }
+        else {
+            throw err;
+        }
+    });
+}
+
+function noop() { }
+
+const COMPLETE_NOTIFICATION = (() => createNotification('C', undefined, undefined))();
+function errorNotification(error) {
+    return createNotification('E', undefined, error);
+}
+function nextNotification(value) {
+    return createNotification('N', value, undefined);
+}
+function createNotification(kind, value, error) {
+    return {
+        kind,
+        value,
+        error,
+    };
+}
+
+function errorContext(cb) {
+    {
+        cb();
+    }
+}
+
+class Subscriber extends Subscription {
+    constructor(destination) {
+        super();
+        this.isStopped = false;
+        if (destination) {
+            this.destination = destination;
+            if (isSubscription(destination)) {
+                destination.add(this);
+            }
+        }
+        else {
+            this.destination = EMPTY_OBSERVER;
+        }
+    }
+    static create(next, error, complete) {
+        return new SafeSubscriber(next, error, complete);
+    }
+    next(value) {
+        if (this.isStopped) {
+            handleStoppedNotification(nextNotification(value), this);
+        }
+        else {
+            this._next(value);
+        }
+    }
+    error(err) {
+        if (this.isStopped) {
+            handleStoppedNotification(errorNotification(err), this);
+        }
+        else {
+            this.isStopped = true;
+            this._error(err);
+        }
+    }
+    complete() {
+        if (this.isStopped) {
+            handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+        }
+        else {
+            this.isStopped = true;
+            this._complete();
+        }
+    }
+    unsubscribe() {
+        if (!this.closed) {
+            this.isStopped = true;
+            super.unsubscribe();
+            this.destination = null;
+        }
+    }
+    _next(value) {
+        this.destination.next(value);
+    }
+    _error(err) {
+        try {
+            this.destination.error(err);
+        }
+        finally {
+            this.unsubscribe();
+        }
+    }
+    _complete() {
+        try {
+            this.destination.complete();
+        }
+        finally {
+            this.unsubscribe();
+        }
+    }
+}
+const _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+    return _bind.call(fn, thisArg);
+}
+class ConsumerObserver {
+    constructor(partialObserver) {
+        this.partialObserver = partialObserver;
+    }
+    next(value) {
+        const { partialObserver } = this;
+        if (partialObserver.next) {
+            try {
+                partialObserver.next(value);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    }
+    error(err) {
+        const { partialObserver } = this;
+        if (partialObserver.error) {
+            try {
+                partialObserver.error(err);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+        else {
+            handleUnhandledError(err);
+        }
+    }
+    complete() {
+        const { partialObserver } = this;
+        if (partialObserver.complete) {
+            try {
+                partialObserver.complete();
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    }
+}
+class SafeSubscriber extends Subscriber {
+    constructor(observerOrNext, error, complete) {
+        super();
+        let partialObserver;
+        if (isFunction(observerOrNext) || !observerOrNext) {
+            partialObserver = {
+                next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
+                error: error !== null && error !== void 0 ? error : undefined,
+                complete: complete !== null && complete !== void 0 ? complete : undefined,
+            };
+        }
+        else {
+            let context;
+            if (this && config.useDeprecatedNextContext) {
+                context = Object.create(observerOrNext);
+                context.unsubscribe = () => this.unsubscribe();
+                partialObserver = {
+                    next: observerOrNext.next && bind(observerOrNext.next, context),
+                    error: observerOrNext.error && bind(observerOrNext.error, context),
+                    complete: observerOrNext.complete && bind(observerOrNext.complete, context),
+                };
+            }
+            else {
+                partialObserver = observerOrNext;
+            }
+        }
+        this.destination = new ConsumerObserver(partialObserver);
+    }
+}
+function handleUnhandledError(error) {
+    {
+        reportUnhandledError(error);
+    }
+}
+function defaultErrorHandler(err) {
+    throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+    const { onStoppedNotification } = config;
+    onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
+}
+const EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop,
+};
+
+const observable = (() => (typeof Symbol === 'function' && Symbol.observable) || '@@observable')();
+
+function identity(x) {
+    return x;
+}
+
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce((prev, fn) => fn(prev), input);
+    };
+}
+
+class Observable {
+    constructor(subscribe) {
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+    }
+    lift(operator) {
+        const observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+    }
+    subscribe(observerOrNext, error, complete) {
+        const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+        errorContext(() => {
+            const { operator, source } = this;
+            subscriber.add(operator
+                ?
+                    operator.call(subscriber, source)
+                : source
+                    ?
+                        this._subscribe(subscriber)
+                    :
+                        this._trySubscribe(subscriber));
+        });
+        return subscriber;
+    }
+    _trySubscribe(sink) {
+        try {
+            return this._subscribe(sink);
+        }
+        catch (err) {
+            sink.error(err);
+        }
+    }
+    forEach(next, promiseCtor) {
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor((resolve, reject) => {
+            const subscriber = new SafeSubscriber({
+                next: (value) => {
+                    try {
+                        next(value);
+                    }
+                    catch (err) {
+                        reject(err);
+                        subscriber.unsubscribe();
+                    }
+                },
+                error: reject,
+                complete: resolve,
+            });
+            this.subscribe(subscriber);
+        });
+    }
+    _subscribe(subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    }
+    [observable]() {
+        return this;
+    }
+    pipe(...operations) {
+        return pipeFromArray(operations)(this);
+    }
+    toPromise(promiseCtor) {
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor((resolve, reject) => {
+            let value;
+            this.subscribe((x) => (value = x), (err) => reject(err), () => resolve(value));
+        });
+    }
+}
+Observable.create = (subscribe) => {
+    return new Observable(subscribe);
+};
+function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+    return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+}
+
+const ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = 'ObjectUnsubscribedError';
+    this.message = 'object unsubscribed';
+});
+
+class Subject extends Observable {
+    constructor() {
+        super();
+        this.closed = false;
+        this.currentObservers = null;
+        this.observers = [];
+        this.isStopped = false;
+        this.hasError = false;
+        this.thrownError = null;
+    }
+    lift(operator) {
+        const subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    }
+    _throwIfClosed() {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+    }
+    next(value) {
+        errorContext(() => {
+            this._throwIfClosed();
+            if (!this.isStopped) {
+                if (!this.currentObservers) {
+                    this.currentObservers = Array.from(this.observers);
+                }
+                for (const observer of this.currentObservers) {
+                    observer.next(value);
+                }
+            }
+        });
+    }
+    error(err) {
+        errorContext(() => {
+            this._throwIfClosed();
+            if (!this.isStopped) {
+                this.hasError = this.isStopped = true;
+                this.thrownError = err;
+                const { observers } = this;
+                while (observers.length) {
+                    observers.shift().error(err);
+                }
+            }
+        });
+    }
+    complete() {
+        errorContext(() => {
+            this._throwIfClosed();
+            if (!this.isStopped) {
+                this.isStopped = true;
+                const { observers } = this;
+                while (observers.length) {
+                    observers.shift().complete();
+                }
+            }
+        });
+    }
+    unsubscribe() {
+        this.isStopped = this.closed = true;
+        this.observers = this.currentObservers = null;
+    }
+    get observed() {
+        var _a;
+        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    }
+    _trySubscribe(subscriber) {
+        this._throwIfClosed();
+        return super._trySubscribe(subscriber);
+    }
+    _subscribe(subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+    }
+    _innerSubscribe(subscriber) {
+        const { hasError, isStopped, observers } = this;
+        if (hasError || isStopped) {
+            return EMPTY_SUBSCRIPTION;
+        }
+        this.currentObservers = null;
+        observers.push(subscriber);
+        return new Subscription(() => {
+            this.currentObservers = null;
+            arrRemove(observers, subscriber);
+        });
+    }
+    _checkFinalizedStatuses(subscriber) {
+        const { hasError, thrownError, isStopped } = this;
+        if (hasError) {
+            subscriber.error(thrownError);
+        }
+        else if (isStopped) {
+            subscriber.complete();
+        }
+    }
+    asObservable() {
+        const observable = new Observable();
+        observable.source = this;
+        return observable;
+    }
+}
+Subject.create = (destination, source) => {
+    return new AnonymousSubject(destination, source);
+};
+class AnonymousSubject extends Subject {
+    constructor(destination, source) {
+        super();
+        this.destination = destination;
+        this.source = source;
+    }
+    next(value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    }
+    error(err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    }
+    complete() {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    _subscribe(subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    }
+}
+
+class BehaviorSubject extends Subject {
+    constructor(_value) {
+        super();
+        this._value = _value;
+    }
+    get value() {
+        return this.getValue();
+    }
+    _subscribe(subscriber) {
+        const subscription = super._subscribe(subscriber);
+        !subscription.closed && subscriber.next(this._value);
+        return subscription;
+    }
+    getValue() {
+        const { hasError, thrownError, _value } = this;
+        if (hasError) {
+            throw thrownError;
+        }
+        this._throwIfClosed();
+        return _value;
+    }
+    next(value) {
+        super.next((this._value = value));
+    }
+}
+
+class FormController {
+  constructor(schema) {
+    this.values = new BehaviorSubject({});
+    this.errors = new BehaviorSubject({});
+    this._initialValues = {};
+    this._values = {};
+    this._errors = {};
+    this._isValid = true;
+    this._schema = schema;
+  }
+  processArrayError(obj, property, remainingProperties, message) {
+    // Extract array name and index from the property string
+    const [arrayName, indexStr] = property
+      .match(/^([a-zA-Z0-9]+)\[(\d+)\]/)
+      .slice(1);
+    const index = parseInt(indexStr, 10);
+    // Ensure the array exists and has an entry at the given index
+    obj[arrayName] = obj[arrayName] || [];
+    obj[arrayName][index] = obj[arrayName][index] || {};
+    // Recursively set the error if there are remaining properties, else set the error message
+    if (remainingProperties.length) {
+      this.setNestedError(obj[arrayName][index], remainingProperties, message);
+    }
+    else {
+      obj[arrayName][index] = message;
+    }
+  }
+  processRegularError(obj, property, remainingProperties, message) {
+    // Ensure the property exists
+    obj[property] = obj[property] || {};
+    // Recursively set the error if there are remaining properties, else set the error message
+    if (remainingProperties.length) {
+      this.setNestedError(obj[property], remainingProperties, message);
+    }
+    else {
+      obj[property] = message;
+    }
+  }
+  setNestedError(obj, properties, message) {
+    const property = properties.shift();
+    const isArrayError = property.includes('[');
+    if (isArrayError) {
+      this.processArrayError(obj, property, properties, message);
+    }
+    else {
+      this.processRegularError(obj, property, properties, message);
+    }
+  }
+  setError(obj, path, message) {
+    // Convert path to properties array
+    const properties = Array.isArray(path) ? path : path.split('.');
+    this.setNestedError(obj, properties, message);
+  }
+  async validate(context) {
+    this._isValid = true;
+    this._errors = {};
+    try {
+      await this._schema.validate(this._values, { context, abortEarly: false });
+    }
+    catch (err) {
+      this._isValid = false;
+      err.inner.forEach((item) => {
+        this.setError(this._errors, item.path, item.message);
+      });
+    }
+    this.errors.next(this._errors);
+    return this._isValid;
+  }
+  async validateAndSubmit(submitHandler, context) {
+    const isValid = await this.validate(context || {});
+    if (isValid) {
+      submitHandler();
+    }
+  }
+  setInitialValues(values) {
+    this._initialValues = values;
+    this._values = values;
+    this.values.next(this._values);
+  }
+  setValues(values) {
+    this._values = Object.assign(Object.assign({}, this._values), values);
+    this.values.next(this._values);
+  }
+  resetValues() {
+    this._values = this._initialValues;
+    this.values.next(this._values);
+  }
+  getInitialValues() {
+    return this._initialValues;
+  }
+}
+
+exports.FormController = FormController;
+
+//# sourceMappingURL=form-1e732a9d.js.map