web-ui-pack/formElement.js

import WUPBaseElement from "./baseElement";
import { nestedProperty, promiseWait, scrollIntoView } from "./indexHelpers";
import WUPSpinElement from "./spinElement";
import { WUPcssButton } from "./styles";
/* c8 ignore next */
/* istanbul ignore next */
!WUPSpinElement && console.error("!"); // It's required otherwise import is ignored by webpack
export var SubmitActions;
(function (SubmitActions) {
    /** Disable any action */
    SubmitActions[SubmitActions["none"] = 0] = "none";
    /** Scroll to first error (if exists) and focus control */
    SubmitActions[SubmitActions["goToError"] = 1] = "goToError";
    /** Validate until first error is found (otherwise validate all) */
    SubmitActions[SubmitActions["validateUntiFirst"] = 2] = "validateUntiFirst";
    /** Collect to model only changed values */
    SubmitActions[SubmitActions["collectChanged"] = 4] = "collectChanged";
    /** Reset isDirty and assign $value to $initValue for controls (on success only) */
    SubmitActions[SubmitActions["reset"] = 8] = "reset";
    /** Lock the whole form during the pending state (set $isPending = true or provide `promise` to submitEvent.waitFor);
     * Otherwise user can submit several times in a short time;
     * If promise resolves during the short-time pending state won't be set, otherwise it takes at least 300ms via helper {@link promiseWait} */
    SubmitActions[SubmitActions["lockOnPending"] = 16] = "lockOnPending";
})(SubmitActions || (SubmitActions = {}));
const tagName = "wup-form";
const formStore = [];
/** Wrapper of FormHTMLElement that collect values from controls
 * @example
 *  // init form
 *  const form = document.createElement("wup-form");
 *  form.$options.autoComplete = false;
 *  form.$initModel = { email: "test-me@google.com" };
 *  form.addEventListener("$submit", (e) => console.warn(e.$model) );
 *  form.$onSubmit = async (e)=>{ await postHere(e.$model); } // equal to form.addEventListener
 *  // init control
 *  const el = document.createElement("wup-text");
 *  el.$options.name = "email";
 *  el.$options.validations = { required: true, email: true };
 *  form.appendChild(el);
 *  const btn = form.appendChild(document.createElement("button"));
 *  btn.textContent = "Submit";
 *  btn.type = "submit";
 *  document.body.appendChild(form);
 *  // or HTML
 *  <wup-form autoComplete autoFocus>
 *    <wup-text name="email" />
 *    <button type="submit">Submit</submit>
 *  </wup-form>;
 * @tutorial Troubleshooting/rules:
 * * options like $initModel, $model overrides control.$initValue, control.$value (every control that matches by $options.name)
 * * In React ref-parent called after ref-children. So if you want to set control.$initValue over form.$initModel use empty setTimeout on ref-control
 * @example
 * <wup-form
      ref={(el) => {
        if (el) {
          el.$initModel = { email: "test-me@google.com" };
          el.$onSubmit = async (ev)=>{
             await postHere();
          }
        }
      }}
    >
      <wup-text
        ref={(el) => {
          if (el) {
            setTimeout(() => {
              el.$options.name = "email";
              el.$initValue = "";
            });
          }
        }}
        <button type="submit">Submit</button>
      />
  </wup-form>
 */
export default class WUPFormElement extends WUPBaseElement {
    /** Returns this.constructor // watch-fix: https://github.com/Microsoft/TypeScript/issues/3841#issuecomment-337560146 */
    #ctr = this.constructor;
    /** Options that need to watch for changes; use gotOptionsChanged() */
    static get observedOptions() {
        return ["disabled", "readOnly", "autoComplete", "autoSave"];
    }
    /* Array of attribute names to listen for changes */
    static get observedAttributes() {
        return ["disabled", "readonly", "autocomplete", "autosave"];
    }
    static get $styleRoot() {
        return `:root {
      --btn-submit-bg: var(--base-btn-bg);
      --btn-submit-text: var(--base-btn-text);
      --btn-submit-focus: var(--base-btn-focus);
    }`;
    }
    static get $style() {
        return `${super.$style}
        :host {
          position: relative;
          display: block;
          max-width: 500px;
          margin: auto;
        }
        ${WUPcssButton(":host [type='submit']")}`;
    }
    /** Find form related to control,register and apply initModel if initValue undefined */
    static $tryConnect(control) {
        const form = formStore.find((f) => f.contains(control));
        form?.$controls.push(control);
        return form;
    }
    /** Map model to control-values */
    static $modelToControls(m, controls, prop) {
        const out = { hasProp: undefined };
        controls.forEach((c) => {
            const key = c.$options.name;
            if (key) {
                const v = m && nestedProperty.get(m, key, out);
                if (out.hasProp) {
                    c[prop] = v;
                }
            }
        });
    }
    /** Collect model from control-values */
    static $modelFromControls(prevModel, controls, prop, isOnlyChanged) {
        if (isOnlyChanged) {
            controls.forEach((c) => c.$options.name && c.$isChanged && nestedProperty.set(prevModel, c.$options.name, c[prop]));
        }
        else {
            controls.forEach((c) => c.$options.name && nestedProperty.set(prevModel, c.$options.name, c[prop]));
        }
        return prevModel;
    }
    /** Default options - applied to every element. Change it to configure default behavior */
    static $defaults = {
        submitActions: 1 /* SubmitActions.goToError */ | 2 /* SubmitActions.validateUntiFirst */ | 8 /* SubmitActions.reset */ | 16 /* SubmitActions.lockOnPending */,
    };
    /** Dispatched on submit. Return promise to lock form and show spinner */
    $onSubmit;
    /** Dispatched on submit */
    // It's not required but called: $onsubmit?: (ev: WUP.Form.SubmitEvent<Model>) => void;
    /** All controls related to form */
    $controls = [];
    /** Returns related to form controls with $options.name != null */
    get $controlsAttached() {
        return this.$controls.filter((c) => c.$options.name != null);
    }
    _model;
    /** Model related to every control inside (with $options.name);
     *  @see {@link BaseControl.prototype.$value} */
    get $model() {
        return Object.assign(this._model || {}, this.#ctr.$modelFromControls({}, this.$controls, "$value"));
    }
    set $model(m) {
        if (m !== this._model) {
            this._model = m;
            this.#ctr.$modelToControls(m, this.$controls, "$value");
        }
    }
    _initModel;
    /** Default/init model related to every control inside;
     *  @see {@link BaseControl.prototype.$initValue} */
    get $initModel() {
        // it's required to avoid case when model has more props than controls
        return this.#ctr.$modelFromControls(this._initModel || {}, this.$controls, "$initValue");
    }
    set $initModel(m) {
        if (m !== this._initModel) {
            this._initModel = m;
            this.#ctr.$modelToControls(m, this.$controls, "$initValue");
        }
    }
    /** Pending state (spinner + lock form if SubmitActions.lockOnPending enabled) */
    get $isPending() {
        return this.#stopPending !== undefined;
    }
    set $isPending(v) {
        if (v !== this.$isPending) {
            this.changePending(v);
        }
    }
    /** Returns true if all nested controls (with name) are valid */
    get $isValid() {
        return this.$controlsAttached.every((c) => c.$isValid);
    }
    /** Returns true if some of controls value is changed by user */
    get $isChanged() {
        return this.$controls.some((c) => c.$options.name && c.$isChanged);
    }
    /** Called on every spin-render */
    renderSpin(target) {
        const spin = document.createElement("wup-spin");
        spin.$options.fit = true;
        spin.$options.overflowFade = false;
        spin.$options.overflowTarget = target;
        return spin;
    }
    #stopPending;
    /** Change pending state */
    changePending(v) {
        if (v === !!this.#stopPending) {
            return;
        }
        if (v) {
            const wasDisabled = this._opts.disabled;
            if (this._opts.submitActions & 16 /* SubmitActions.lockOnPending */) {
                this.$options.disabled = true;
            }
            const btns = [];
            const spins = [];
            this.querySelectorAll("[type='submit']").forEach((b) => {
                spins.push(this.appendChild(this.renderSpin(b)));
                b._wupDisabled = b.disabled;
                b.disabled = true;
                btns.push(b);
            });
            this.#stopPending = () => {
                this.#stopPending = undefined;
                this.$options.disabled = wasDisabled;
                btns.forEach((b) => (b.disabled = b._wupDisabled));
                spins.forEach((s) => s.remove());
            };
        }
        else {
            this.#stopPending();
        }
    }
    /** Called on submit before validation */
    gotSubmit(e, submitter) {
        e.preventDefault();
        const willEv = new Event("$willSubmit", { bubbles: true, cancelable: true });
        // willEv.$model = null;
        willEv.$relatedEvent = e;
        willEv.$relatedForm = this;
        willEv.$submitter = submitter;
        this.dispatchEvent(willEv);
        if (willEv.defaultPrevented) {
            return;
        }
        // validate
        let errCtrl;
        let arrCtrl = this.$controlsAttached;
        if (this._opts.submitActions & 2 /* SubmitActions.validateUntiFirst */) {
            errCtrl = arrCtrl.find((c) => c.validateBySubmit() && c.canShowError);
        }
        else {
            arrCtrl.forEach((c) => {
                const err = c.validateBySubmit();
                if (err && !errCtrl && c.canShowError) {
                    errCtrl = c;
                }
            });
        }
        // analyze - go to error
        if (errCtrl) {
            if (this._opts.submitActions & 1 /* SubmitActions.goToError */) {
                const el = errCtrl;
                scrollIntoView(el, { offsetTop: -30, onlyIfNeeded: true }).then(() => el.focus());
            }
            return;
        }
        // collect changes only from valid controls: because some controls has canShowError: false
        arrCtrl = arrCtrl.filter((c) => c.canShowError);
        // collect values to model
        const onlyChanged = this._opts.submitActions & 4 /* SubmitActions.collectChanged */;
        const m = this.#ctr.$modelFromControls({}, arrCtrl, "$value", !!onlyChanged);
        // fire events
        const ev = new Event("$submit", { cancelable: false, bubbles: true });
        ev.$model = m;
        ev.$relatedForm = this;
        ev.$relatedEvent = e;
        ev.$submitter = submitter;
        const needReset = this._opts.submitActions & 8 /* SubmitActions.reset */;
        setTimeout(() => {
            this.dispatchEvent(ev);
            const p1 = this.$onSubmit?.call(this, ev);
            // SubmitEvent constructor doesn't exist on some browsers: https://developer.mozilla.org/en-US/docs/Web/API/SubmitEvent/SubmitEvent
            const ev2 = new (window.SubmitEvent || Event)("submit", { submitter, cancelable: false, bubbles: true });
            /* istanbul ignore else */
            if (!window.SubmitEvent) {
                ev2.submitter = submitter;
            }
            this.dispatchEvent(ev2);
            promiseWait(Promise.all([p1, ev.$waitFor]), 300, (v) => this.changePending(v)).then(() => {
                this._opts.autoSave && this.storageSave(null); // clear storage after submit
                if (needReset) {
                    arrCtrl.forEach((v) => (v.$isDirty = false));
                    this.$initModel = this.$model;
                }
            });
        });
    }
    /** Auto-safe debounce timeout */
    #autoSaveT;
    #autoSaveRemEv;
    #hasControlChanges;
    gotChanges(propsChanged) {
        super.gotChanges(propsChanged);
        this._opts.disabled = this.getAttr("disabled", "bool");
        this._opts.readOnly = this.getAttr("readonly", "bool", this._opts.readOnly);
        this._opts.autoComplete = this.getAttr("autocomplete", "bool", this._opts.autoComplete);
        this._opts.autoFocus = this.getAttr("autofocus", "bool", this._opts.autoFocus);
        this.setAttr("readonly", this._opts.readOnly, true);
        this.setAttr("disabled", this._opts.disabled, true);
        this._opts.autoSave = this.getAttr("autosave", "boolOrString", this._opts.autoSave);
        if (this._opts.autoSave) {
            this.#autoSaveRemEv = this.appendEvent(this, "$change", () => {
                if (this._preventStorageSave) {
                    return;
                }
                this.#autoSaveT && clearTimeout(this.#autoSaveT);
                this.#autoSaveT = setTimeout(() => this._opts.autoSave && this.storageSave(), 700);
            });
            // works only on init
            !propsChanged &&
                setTimeout(() => {
                    const m = this.storageGet();
                    if (m) {
                        this._preventStorageSave = true;
                        this.$model = { ...this._initModel, ...m, ...this._model };
                        setTimeout(() => delete this._preventStorageSave);
                    }
                }, 2); // timeout required to wait for init controls
        }
        else if (this.#autoSaveRemEv) {
            this.#autoSaveRemEv.call(this);
            this.#autoSaveRemEv = undefined;
        }
        const p = propsChanged;
        if (this.#hasControlChanges || p?.includes("disabled")) {
            this.$controls.forEach((c) => c.gotFormChanges(propsChanged));
            this.#hasControlChanges = undefined;
        }
    }
    gotOptionsChanged(e) {
        const p = e.props;
        if (p.includes("autoComplete") || p.includes("readOnly")) {
            this.#hasControlChanges = true;
        }
        super.gotOptionsChanged(e);
    }
    gotAttributeChanged(name, oldValue, newValue) {
        if (name === "autocomplete" || name === "readonly") {
            this.#hasControlChanges = true;
        }
        super.gotAttributeChanged(name, oldValue, newValue);
    }
    gotReady() {
        super.gotReady();
        this.appendEvent(this, "keydown", (e) => e.key === "Enter" &&
            !e.defaultPrevented &&
            !e.submitPrevented && // textarea related
            !e.shiftKey &&
            !e.ctrlKey &&
            this.gotSubmit(e, e.target instanceof HTMLElement ? e.target : this), { passive: false });
        this.appendEvent(this, "click", (e) => {
            if (!e.defaultPrevented) {
                let t = e.target;
                while (t instanceof HTMLElement && t !== this) {
                    if (t.type === "submit") {
                        this.gotSubmit(e, t);
                        return;
                    }
                    t = t.parentElement;
                }
            }
        }, { passive: false });
    }
    connectedCallback() {
        super.connectedCallback();
        this.setAttribute("role", "form");
        formStore.push(this);
    }
    /** Returns storage key based on url+control-names or `$options.autoSave` if `string` */
    get storageKey() {
        const sn = this._opts.autoSave;
        return typeof sn === "string"
            ? sn
            : `${window.location.pathname}?${this.$controls
                .map((c) => c.$options.name)
                .filter((v) => v)
                .sort()
                .join(",")}`;
    }
    /** Get & parse value from storage according to option `autoSave`, $model */
    storageGet() {
        try {
            const key = this.storageKey;
            const sv = window.localStorage.getItem(key);
            if (sv) {
                const m = JSON.parse(sv);
                let hasVals = false;
                this.$controls.forEach((c) => {
                    const n = c.$options.name;
                    if (!n) {
                        return;
                    }
                    const v = m[n];
                    if (v === undefined) {
                        return;
                    }
                    const parsed = typeof v === "string" ? c.parse(v) : v;
                    nestedProperty.set(m, n, parsed);
                    if (n.includes(".")) {
                        delete m[n];
                    }
                    hasVals = true;
                });
                if (!hasVals) {
                    return null;
                }
                return m;
            }
        }
        catch (err) {
            this.throwError(err); // re-throw error when storage is full
        }
        return null;
    }
    _preventStorageSave;
    /** Save/remove model (only changes) to storage according to option `autoSave`, $model
     * @returns model saved to localStorage or Null if removed */
    storageSave(model = {}) {
        try {
            const storage = window.localStorage;
            if (model == null) {
                storage.removeItem(this.storageKey);
                return null;
            }
            const m = {}; // plain model without nested objects
            let hasChanges = false;
            this.$controls.forEach((c) => {
                // ignore password controls and controls without names
                if (c.$options.name && c.tagName !== "WUP-PWD") {
                    const v = c.$value;
                    if (c.$isChanged && v !== undefined) {
                        if (typeof v === "object" && !v.toJSON && !Array.isArray(v)) {
                            return; // skip complex objects that not serializable: otherwise it can throw err on parse
                        }
                        m[c.$options.name] = v; // get only changed values
                        hasChanges = true;
                    }
                }
            });
            if (hasChanges) {
                storage.setItem(this.storageKey, JSON.stringify(m));
                return m;
            }
            storage.removeItem(this.storageKey);
        }
        catch (err) {
            this.throwError(err); // re-throw error when storage is full
        }
        return null;
    }
    disconnectedCallback() {
        super.disconnectedCallback();
        formStore.splice(formStore.indexOf(this), 1);
    }
}
customElements.define(tagName, WUPFormElement);
// todo show success result in <wup-alert> at the right angle + add autoSubmit option