favesalon-embed 1.0.4 → 1.0.6

package/dist/favesalon-embed/shadow-css-98135883.js

@@ -0,0 +1,387 @@
+/*
+ Stencil Client Platform v2.22.3 | MIT Licensed | https://stenciljs.com
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ *
+ * This file is a port of shadowCSS from webcomponents.js to TypeScript.
+ * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
+ * https://github.com/angular/angular/blob/master/packages/compiler/src/shadow_css.ts
+ */
+const safeSelector = (selector) => {
+    const placeholders = [];
+    let index = 0;
+    // Replaces attribute selectors with placeholders.
+    // The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
+    selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
+        const replaceBy = `__ph-${index}__`;
+        placeholders.push(keep);
+        index++;
+        return replaceBy;
+    });
+    // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
+    // WS and "+" would otherwise be interpreted as selector separators.
+    const content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
+        const replaceBy = `__ph-${index}__`;
+        placeholders.push(exp);
+        index++;
+        return pseudo + replaceBy;
+    });
+    const ss = {
+        content,
+        placeholders,
+    };
+    return ss;
+};
+const restoreSafeSelector = (placeholders, content) => {
+    return content.replace(/__ph-(\d+)__/g, (_, index) => placeholders[+index]);
+};
+const _polyfillHost = '-shadowcsshost';
+const _polyfillSlotted = '-shadowcssslotted';
+// note: :host-context pre-processed to -shadowcsshostcontext.
+const _polyfillHostContext = '-shadowcsscontext';
+const _parenSuffix = ')(?:\\((' + '(?:\\([^)(]*\\)|[^)(]*)+?' + ')\\))?([^,{]*)';
+const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
+const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
+const _cssColonSlottedRe = new RegExp('(' + _polyfillSlotted + _parenSuffix, 'gim');
+const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
+const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
+const _shadowDOMSelectorsRe = [/::shadow/g, /::content/g];
+const _selectorReSuffix = '([>\\s~+[.,{:][\\s\\S]*)?$';
+const _polyfillHostRe = /-shadowcsshost/gim;
+const _colonHostRe = /:host/gim;
+const _colonSlottedRe = /::slotted/gim;
+const _colonHostContextRe = /:host-context/gim;
+const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+const stripComments = (input) => {
+    return input.replace(_commentRe, '');
+};
+const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g;
+const extractCommentsWithHash = (input) => {
+    return input.match(_commentWithHashRe) || [];
+};
+const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+const _curlyRe = /([{}])/g;
+const _selectorPartsRe = /(^.*?[^\\])??((:+)(.*)|$)/;
+const OPEN_CURLY = '{';
+const CLOSE_CURLY = '}';
+const BLOCK_PLACEHOLDER = '%BLOCK%';
+const processRules = (input, ruleCallback) => {
+    const inputWithEscapedBlocks = escapeBlocks(input);
+    let nextBlockIndex = 0;
+    return inputWithEscapedBlocks.escapedString.replace(_ruleRe, (...m) => {
+        const selector = m[2];
+        let content = '';
+        let suffix = m[4];
+        let contentPrefix = '';
+        if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
+            content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
+            suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
+            contentPrefix = '{';
+        }
+        const cssRule = {
+            selector,
+            content,
+        };
+        const rule = ruleCallback(cssRule);
+        return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
+    });
+};
+const escapeBlocks = (input) => {
+    const inputParts = input.split(_curlyRe);
+    const resultParts = [];
+    const escapedBlocks = [];
+    let bracketCount = 0;
+    let currentBlockParts = [];
+    for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
+        const part = inputParts[partIndex];
+        if (part === CLOSE_CURLY) {
+            bracketCount--;
+        }
+        if (bracketCount > 0) {
+            currentBlockParts.push(part);
+        }
+        else {
+            if (currentBlockParts.length > 0) {
+                escapedBlocks.push(currentBlockParts.join(''));
+                resultParts.push(BLOCK_PLACEHOLDER);
+                currentBlockParts = [];
+            }
+            resultParts.push(part);
+        }
+        if (part === OPEN_CURLY) {
+            bracketCount++;
+        }
+    }
+    if (currentBlockParts.length > 0) {
+        escapedBlocks.push(currentBlockParts.join(''));
+        resultParts.push(BLOCK_PLACEHOLDER);
+    }
+    const strEscapedBlocks = {
+        escapedString: resultParts.join(''),
+        blocks: escapedBlocks,
+    };
+    return strEscapedBlocks;
+};
+const insertPolyfillHostInCssText = (selector) => {
+    selector = selector
+        .replace(_colonHostContextRe, _polyfillHostContext)
+        .replace(_colonHostRe, _polyfillHost)
+        .replace(_colonSlottedRe, _polyfillSlotted);
+    return selector;
+};
+const convertColonRule = (cssText, regExp, partReplacer) => {
+    // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
+    return cssText.replace(regExp, (...m) => {
+        if (m[2]) {
+            const parts = m[2].split(',');
+            const r = [];
+            for (let i = 0; i < parts.length; i++) {
+                const p = parts[i].trim();
+                if (!p)
+                    break;
+                r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
+            }
+            return r.join(',');
+        }
+        else {
+            return _polyfillHostNoCombinator + m[3];
+        }
+    });
+};
+const colonHostPartReplacer = (host, part, suffix) => {
+    return host + part.replace(_polyfillHost, '') + suffix;
+};
+const convertColonHost = (cssText) => {
+    return convertColonRule(cssText, _cssColonHostRe, colonHostPartReplacer);
+};
+const colonHostContextPartReplacer = (host, part, suffix) => {
+    if (part.indexOf(_polyfillHost) > -1) {
+        return colonHostPartReplacer(host, part, suffix);
+    }
+    else {
+        return host + part + suffix + ', ' + part + ' ' + host + suffix;
+    }
+};
+const convertColonSlotted = (cssText, slotScopeId) => {
+    const slotClass = '.' + slotScopeId + ' > ';
+    const selectors = [];
+    cssText = cssText.replace(_cssColonSlottedRe, (...m) => {
+        if (m[2]) {
+            const compound = m[2].trim();
+            const suffix = m[3];
+            const slottedSelector = slotClass + compound + suffix;
+            let prefixSelector = '';
+            for (let i = m[4] - 1; i >= 0; i--) {
+                const char = m[5][i];
+                if (char === '}' || char === ',') {
+                    break;
+                }
+                prefixSelector = char + prefixSelector;
+            }
+            const orgSelector = prefixSelector + slottedSelector;
+            const addedSelector = `${prefixSelector.trimRight()}${slottedSelector.trim()}`;
+            if (orgSelector.trim() !== addedSelector.trim()) {
+                const updatedSelector = `${addedSelector}, ${orgSelector}`;
+                selectors.push({
+                    orgSelector,
+                    updatedSelector,
+                });
+            }
+            return slottedSelector;
+        }
+        else {
+            return _polyfillHostNoCombinator + m[3];
+        }
+    });
+    return {
+        selectors,
+        cssText,
+    };
+};
+const convertColonHostContext = (cssText) => {
+    return convertColonRule(cssText, _cssColonHostContextRe, colonHostContextPartReplacer);
+};
+const convertShadowDOMSelectors = (cssText) => {
+    return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
+};
+const makeScopeMatcher = (scopeSelector) => {
+    const lre = /\[/g;
+    const rre = /\]/g;
+    scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
+    return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
+};
+const selectorNeedsScoping = (selector, scopeSelector) => {
+    const re = makeScopeMatcher(scopeSelector);
+    return !re.test(selector);
+};
+const injectScopingSelector = (selector, scopingSelector) => {
+    return selector.replace(_selectorPartsRe, (_, before = '', _colonGroup, colon = '', after = '') => {
+        return before + scopingSelector + colon + after;
+    });
+};
+const applySimpleSelectorScope = (selector, scopeSelector, hostSelector) => {
+    // In Android browser, the lastIndex is not reset when the regex is used in String.replace()
+    _polyfillHostRe.lastIndex = 0;
+    if (_polyfillHostRe.test(selector)) {
+        const replaceBy = `.${hostSelector}`;
+        return selector
+            .replace(_polyfillHostNoCombinatorRe, (_, selector) => injectScopingSelector(selector, replaceBy))
+            .replace(_polyfillHostRe, replaceBy + ' ');
+    }
+    return scopeSelector + ' ' + selector;
+};
+const applyStrictSelectorScope = (selector, scopeSelector, hostSelector) => {
+    const isRe = /\[is=([^\]]*)\]/g;
+    scopeSelector = scopeSelector.replace(isRe, (_, ...parts) => parts[0]);
+    const className = '.' + scopeSelector;
+    const _scopeSelectorPart = (p) => {
+        let scopedP = p.trim();
+        if (!scopedP) {
+            return '';
+        }
+        if (p.indexOf(_polyfillHostNoCombinator) > -1) {
+            scopedP = applySimpleSelectorScope(p, scopeSelector, hostSelector);
+        }
+        else {
+            // remove :host since it should be unnecessary
+            const t = p.replace(_polyfillHostRe, '');
+            if (t.length > 0) {
+                scopedP = injectScopingSelector(t, className);
+            }
+        }
+        return scopedP;
+    };
+    const safeContent = safeSelector(selector);
+    selector = safeContent.content;
+    let scopedSelector = '';
+    let startIndex = 0;
+    let res;
+    const sep = /( |>|\+|~(?!=))\s*/g;
+    // If a selector appears before :host it should not be shimmed as it
+    // matches on ancestor elements and not on elements in the host's shadow
+    // `:host-context(div)` is transformed to
+    // `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`
+    // the `div` is not part of the component in the 2nd selectors and should not be scoped.
+    // Historically `component-tag:host` was matching the component so we also want to preserve
+    // this behavior to avoid breaking legacy apps (it should not match).
+    // The behavior should be:
+    // - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)
+    // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
+    //   `:host-context(tag)`)
+    const hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;
+    // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
+    let shouldScope = !hasHost;
+    while ((res = sep.exec(selector)) !== null) {
+        const separator = res[1];
+        const part = selector.slice(startIndex, res.index).trim();
+        shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
+        const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
+        scopedSelector += `${scopedPart} ${separator} `;
+        startIndex = sep.lastIndex;
+    }
+    const part = selector.substring(startIndex);
+    shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
+    scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
+    // replace the placeholders with their original values
+    return restoreSafeSelector(safeContent.placeholders, scopedSelector);
+};
+const scopeSelector = (selector, scopeSelectorText, hostSelector, slotSelector) => {
+    return selector
+        .split(',')
+        .map((shallowPart) => {
+        if (slotSelector && shallowPart.indexOf('.' + slotSelector) > -1) {
+            return shallowPart.trim();
+        }
+        if (selectorNeedsScoping(shallowPart, scopeSelectorText)) {
+            return applyStrictSelectorScope(shallowPart, scopeSelectorText, hostSelector).trim();
+        }
+        else {
+            return shallowPart.trim();
+        }
+    })
+        .join(', ');
+};
+const scopeSelectors = (cssText, scopeSelectorText, hostSelector, slotSelector, commentOriginalSelector) => {
+    return processRules(cssText, (rule) => {
+        let selector = rule.selector;
+        let content = rule.content;
+        if (rule.selector[0] !== '@') {
+            selector = scopeSelector(rule.selector, scopeSelectorText, hostSelector, slotSelector);
+        }
+        else if (rule.selector.startsWith('@media') ||
+            rule.selector.startsWith('@supports') ||
+            rule.selector.startsWith('@page') ||
+            rule.selector.startsWith('@document')) {
+            content = scopeSelectors(rule.content, scopeSelectorText, hostSelector, slotSelector);
+        }
+        const cssRule = {
+            selector: selector.replace(/\s{2,}/g, ' ').trim(),
+            content,
+        };
+        return cssRule;
+    });
+};
+const scopeCssText = (cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector) => {
+    cssText = insertPolyfillHostInCssText(cssText);
+    cssText = convertColonHost(cssText);
+    cssText = convertColonHostContext(cssText);
+    const slotted = convertColonSlotted(cssText, slotScopeId);
+    cssText = slotted.cssText;
+    cssText = convertShadowDOMSelectors(cssText);
+    if (scopeId) {
+        cssText = scopeSelectors(cssText, scopeId, hostScopeId, slotScopeId);
+    }
+    cssText = cssText.replace(/-shadowcsshost-no-combinator/g, `.${hostScopeId}`);
+    cssText = cssText.replace(/>\s*\*\s+([^{, ]+)/gm, ' $1 ');
+    return {
+        cssText: cssText.trim(),
+        slottedSelectors: slotted.selectors,
+    };
+};
+const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
+    const hostScopeId = scopeId + '-h';
+    const slotScopeId = scopeId + '-s';
+    const commentsWithHash = extractCommentsWithHash(cssText);
+    cssText = stripComments(cssText);
+    const orgSelectors = [];
+    if (commentOriginalSelector) {
+        const processCommentedSelector = (rule) => {
+            const placeholder = `/*!@___${orgSelectors.length}___*/`;
+            const comment = `/*!@${rule.selector}*/`;
+            orgSelectors.push({ placeholder, comment });
+            rule.selector = placeholder + rule.selector;
+            return rule;
+        };
+        cssText = processRules(cssText, (rule) => {
+            if (rule.selector[0] !== '@') {
+                return processCommentedSelector(rule);
+            }
+            else if (rule.selector.startsWith('@media') ||
+                rule.selector.startsWith('@supports') ||
+                rule.selector.startsWith('@page') ||
+                rule.selector.startsWith('@document')) {
+                rule.content = processRules(rule.content, processCommentedSelector);
+                return rule;
+            }
+            return rule;
+        });
+    }
+    const scoped = scopeCssText(cssText, scopeId, hostScopeId, slotScopeId);
+    cssText = [scoped.cssText, ...commentsWithHash].join('\n');
+    if (commentOriginalSelector) {
+        orgSelectors.forEach(({ placeholder, comment }) => {
+            cssText = cssText.replace(placeholder, comment);
+        });
+    }
+    scoped.slottedSelectors.forEach((slottedSelector) => {
+        cssText = cssText.replace(slottedSelector.orgSelector, slottedSelector.updatedSelector);
+    });
+    return cssText;
+};
+
+export { scopeCss };

package/dist/{esm → favesalon-embed}/style-detail.entry.js

@@ -1,8 +1,8 @@
-import { r as registerInstance, h } from './index-0494771f.js';
-import { d as dayjs_min, H as HttpService, i as isVideoMedia, g as getSalonImage, s as shortDateYearFormat } from './services-257442e2.js';
-import { r as relativeTime } from './relativeTime-baa50aa2.js';
+import { r as registerInstance, h } from './index-888e99e3.js';
+import { d as dayjs_min, H as HttpService, i as isVideoMedia, g as getSalonImage, s as shortDateYearFormat } from './services-d71be591.js';
+import { r as relativeTime } from './relativeTime-268e64b0.js';
 import { C as Colors } from './colors-ea36347a.js';
-import './_commonjsHelpers-66ac50f5.js';
+import './_commonjsHelpers-a4f66ccd.js';
 
 const indexCss = ".salon-modal.salon-modal--lookbook-detail .salon-modal--close{display:none !important}.salon-modal.salon-modal--lookbook-detail .salon-modal--content{background-color:#fff;position:fixed;top:0;right:0;bottom:0;left:0;width:100%;height:100%;z-index:1000;overflow-y:auto}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--image{height:240px !important}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--thumbnails{text-align:center}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--thumbnail{display:inline-block;margin-top:12px;margin-right:12px;height:40px;width:60px}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--button{border:none;position:absolute;top:50%;z-index:20;height:40px;width:40px;-moz-border-radius:50px;-webkit-border-radius:50px;border-radius:50px;-moz-transform:translate(0, -50%);-webkit-transform:translate(0, -50%);transform:translate(0, -50%)}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--prev{left:24px}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--next{right:24px}@media (min-width: 768px){.salon-modal.salon-modal--lookbook-detail .style-detail--slides--image{height:360px !important}}@media (min-width: 992px){.salon-modal.salon-modal--lookbook-detail .style-detail--slides--image{height:480px !important}.salon-modal.salon-modal--lookbook-detail .style-detail--slides--thumbnail{height:56px;width:72px}}";
 
@@ -121,7 +121,17 @@ const StyleDetail = class {
       return (h("div", { class: "salon-modal salon-modal--lookbook-detail" }, h("div", { class: "salon-modal--inner" }, h("div", { class: "salon-modal--content" }, h("div", { class: "style-detail" }, h("div", { class: "style-detail--header" }, h("div", { style: {
           position: 'relative',
           overflow: 'hidden',
-        } }, h("div", { style: Object.assign({ backgroundColor: Colors.Gray01, backgroundSize: 'cover', backgroundRepeat: 'no-repeat', backgroundPosition: '0 0', filter: 'blur(30px)', position: 'absolute', inset: '0', zIndex: '1' }, this.currentMedia && !isVideoMedia(this.currentMedia) ? { backgroundImage: `url("${this.currentMedia.imageThumb}")` } : {}) }), h("div", { style: {
+        } }, h("div", { style: {
+          backgroundColor: Colors.Gray01,
+          backgroundSize: 'cover',
+          backgroundRepeat: 'no-repeat',
+          backgroundPosition: '0 0',
+          filter: 'blur(30px)',
+          position: 'absolute',
+          inset: '0',
+          zIndex: '1',
+          ...this.currentMedia && !isVideoMedia(this.currentMedia) ? { backgroundImage: `url("${this.currentMedia.imageThumb}")` } : {},
+        } }), h("div", { style: {
           zIndex: '2',
           position: 'relative',
           width: '100%',
@@ -176,12 +186,20 @@ const StyleDetail = class {
           position: 'relative',
         } }, this.albumMedias.map((media, idx) => {
         const isStyleVideo = isVideoMedia(media);
-        return (h("div", { class: "style-detail--slides--thumbnail", style: Object.assign(Object.assign({ backgroundColor: Colors.Gray01, borderRadius: '4px', overflow: 'hidden', position: 'relative', cursor: 'pointer' }, this.currentMediaIdx !== idx ? { opacity: '0.75' } : {}), !isStyleVideo ? {
-            backgroundImage: `url("${media.imageThumb || media.imageThumbMedium}")`,
-            backgroundRepeat: 'no-repeat',
-            backgroundPosition: 'center center',
-            backgroundSize: 'cover',
-          } : {}), onClick: () => {
+        return (h("div", { class: "style-detail--slides--thumbnail", style: {
+            backgroundColor: Colors.Gray01,
+            borderRadius: '4px',
+            overflow: 'hidden',
+            position: 'relative',
+            cursor: 'pointer',
+            ...this.currentMediaIdx !== idx ? { opacity: '0.75' } : {},
+            ...!isStyleVideo ? {
+              backgroundImage: `url("${media.imageThumb || media.imageThumbMedium}")`,
+              backgroundRepeat: 'no-repeat',
+              backgroundPosition: 'center center',
+              backgroundSize: 'cover',
+            } : {},
+          }, onClick: () => {
             this.currentMedia = media;
             this.currentMediaIdx = idx;
           } }, isStyleVideo && (h("div", null, h("video", { muted: true, width: "100%", height: "100%", poster: media.imageThumb }, h("source", { src: media.mediaUrl, type: "video/mp4" })), h("i", { class: "ri-play-circle-fill", style: {

package/dist/favesalon-embed/user-avatar.entry.js

@@ -0,0 +1,52 @@
+import { r as registerInstance, h } from './index-888e99e3.js';
+import { C as Colors } from './colors-ea36347a.js';
+
+const indexCss = "";
+
+const UserAvatar = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.size = 24;
+    this.name = undefined;
+    this.description = undefined;
+    this.nameStyle = undefined;
+    this.shortName = undefined;
+    this.avatar = undefined;
+  }
+  render() {
+    return (h("div", { style: { display: "flex", alignItems: "center" } }, this.avatar && (h("div", { style: {
+        border: `1px solid ${Colors.White}`,
+        backgroundImage: `url("${this.avatar}")`,
+        backgroundColor: Colors.Gray01,
+        backgroundPosition: 'center center',
+        backgroundSize: 'cover',
+        borderRadius: '50%',
+        height: `${this.size}px`,
+        width: `${this.size}px`,
+        minWidth: `${this.size}px`,
+      } })), !this.avatar && (h("div", { style: {
+        border: `1px solid ${Colors.White}`,
+        backgroundColor: Colors.Gray01,
+        borderRadius: '50%',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        height: `${this.size}px`,
+        width: `${this.size}px`,
+        minWidth: `${this.size}px`,
+      } }, this.shortName)), this.name && (h("div", { style: {
+        flexShrink: '1',
+        flexGrow: '1',
+        marginLeft: '12px',
+        overflow: 'hidden',
+        whiteSpace: 'nowrap',
+        textOverflow: 'ellipsis',
+      } }, h("div", { style: {
+        ...this.nameStyle,
+      } }, this.name), this.description && h("div", { style: { color: '#999999' } }, this.description)))));
+  }
+};
+;
+UserAvatar.style = indexCss;
+
+export { UserAvatar as user_avatar };

package/dist/favesalon-embed/user-form.entry.js

@@ -0,0 +1,44 @@
+import { r as registerInstance, h } from './index-888e99e3.js';
+
+const userFormCss = ":host{display:block}";
+
+var FormType;
+(function (FormType) {
+  FormType["Login"] = "Login";
+  FormType["Register"] = "Register";
+  FormType["Activate"] = "Activate";
+  FormType["ResetPassword"] = "ResetPassword";
+  FormType["ChangePassword"] = "ChangePassword";
+})(FormType || (FormType = {}));
+const UserForm = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.onSuccess = undefined;
+    this.type = undefined;
+    this.currentUser = undefined;
+  }
+  render() {
+    if (this.type === FormType.Register) {
+      return (h("div", null, h("div", { style: { marginBottom: '24px' } }, h("h3", { style: { fontSize: '24px', margin: '8px 0' } }, "Create an account"), h("div", { style: { marginBottom: '4px' } }, "Already have an account? ", h("span", { onClick: () => this.type = FormType.Login, style: { cursor: 'pointer', textDecoration: 'underline' } }, "Signin now"))), h("register-form", { onSuccess: (user) => {
+          this.currentUser = user;
+          this.type = FormType.Activate;
+        } })));
+    }
+    if (this.type === FormType.Activate) {
+      return (h("div", null, h("div", { style: { marginBottom: '24px' } }, h("h3", { style: { fontSize: '24px', margin: '8px 0' } }, "Activate account"), h("div", { style: { marginBottom: '4px' } }, "We\u2019ve sent you a confirmation code. Please check your email inbox and enter the code below")), h("activate-form", { username: (this.currentUser || {}).email, password: (this.currentUser || {}).password, onSuccess: (user) => this.onSuccess(user) })));
+    }
+    if (this.type === FormType.ResetPassword) {
+      return (h("div", null, h("div", { style: { marginBottom: '24px' } }, h("h3", { style: { fontSize: '24px', margin: '8px 0' } }, "Reset password"), h("div", { style: { marginBottom: '4px' } }, "Already have an account? ", h("span", { onClick: () => this.type = FormType.Login, style: { cursor: 'pointer', textDecoration: 'underline' } }, "Signin now"))), h("reset-password-form", { onSuccess: (user) => {
+          this.currentUser = user;
+          this.type = FormType.ChangePassword;
+        } })));
+    }
+    if (this.type === FormType.ChangePassword) {
+      return (h("div", null, h("div", { style: { marginBottom: '24px' } }, h("h3", { style: { fontSize: '24px', margin: '8px 0' } }, "Change password"), h("div", { style: { marginBottom: '4px' } }, "We\u2019ve sent you a confirmation code. Please check your email inbox and enter the code below")), h("change-password-form", { username: (this.currentUser || {}).email, onSuccess: (user) => this.onSuccess(user) })));
+    }
+    return (h("div", null, h("div", { style: { marginBottom: '24px' } }, h("h3", { style: { fontSize: '24px', margin: '8px 0' } }, "Please login to continue"), h("div", { style: { marginBottom: '4px' } }, "Don\u2019t have an account? ", h("span", { onClick: () => this.type = FormType.Register, style: { cursor: 'pointer', textDecoration: 'underline' } }, "Signup now"))), h("login-form", { onSuccess: (user) => this.onSuccess(user) }), h("div", { style: { marginTop: '16px' } }, "Forgot your password? ", h("span", { onClick: () => this.type = FormType.ResetPassword, style: { cursor: 'pointer', textDecoration: 'underline' } }, "Reset now"))));
+  }
+};
+UserForm.style = userFormCss;
+
+export { UserForm as user_form };

package/dist/{collection/utils/utils.js → favesalon-embed/utils-fd30fb29.js}

@@ -1,13 +1,13 @@
-export function wait(time = 1000) {
+function wait(time = 1000) {
   return new Promise(resolve => setTimeout(() => resolve({}), time));
 }
-export function format(first, middle, last) {
+function format(first, middle, last) {
   return (first || '') + (middle ? ` ${middle}` : '') + (last ? ` ${last}` : '');
 }
-export function formatWebsiteUrl(website) {
+function formatWebsiteUrl(website) {
   return !!website ? website.indexOf('http') > -1 ? website : `http://${website}` : null;
 }
-export function formatFullAddress(salon) {
+function formatFullAddress(salon) {
   const { businessAddress, city, state, zipcode, } = salon || {};
   const stateFields = [state, zipcode].filter(field => !!field);
   if (businessAddress) {
@@ -18,6 +18,15 @@ export function formatFullAddress(salon) {
   }
   return null;
 }
-export function getRatingText() {
+function getRatingText() {
   return ['', 'Poor', 'Sufficient', 'Average', 'Well', 'Very good'];
 }
+function formatPhoneNumber(phone) {
+  return String(phone || '')
+    .replace('(', '')
+    .replace(')', '')
+    .replace('-', '')
+    .replaceAll(' ', '');
+}
+
+export { formatWebsiteUrl as a, formatFullAddress as b, formatPhoneNumber as f, getRatingText as g };

package/dist/types/components/activate-form/activate-form.d.ts

@@ -0,0 +1,12 @@
+import { User } from '../../types/user';
+export declare class ActivateForm {
+  username: string;
+  password: string;
+  onSuccess: (user: User) => void;
+  isSubmitting: boolean;
+  error: string;
+  confirmCode: string;
+  onSubmit(evt: any): Promise<void>;
+  resendCode(evt: any): Promise<void>;
+  render(): any;
+}

package/dist/types/components/activate-form/test/activate-form.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/change-password-form/change-password-form.d.ts

@@ -0,0 +1,12 @@
+import { User } from '../../types/user';
+export declare class ChangePasswordForm {
+  username: string;
+  onSuccess: (user: User) => void;
+  isSubmitting: boolean;
+  error: string;
+  confirmCode: string;
+  password: string;
+  onSubmit(evt: any): Promise<void>;
+  resendCode(evt: any): Promise<void>;
+  render(): any;
+}

package/dist/types/components/chat-box/index.d.ts

@@ -3,6 +3,7 @@ export declare class ChatBox {
   primaryColor: string;
   accessToken: string;
   senderId: string;
+  salonId: string;
   chatRooms: ChatRoom[];
   activeRoom: ChatRoom;
   componentWillLoad(): void;

package/dist/types/components/chat-button/index.d.ts

@@ -2,9 +2,12 @@ import { User } from '../../types/user';
 import { ChatMessage, ChatRoom } from '../../types/chat';
 export declare class ChatButton {
   primaryColor: string;
-  accessToken: string;
-  senderId: string;
   receiverId: string;
+  accessToken?: string;
+  senderId?: string;
+  senderIdState: string;
+  accessTokenState: string;
+  isChatVerificationExpanded: boolean;
   senderInfo: User;
   receiverInfo: User;
   chatRoom: ChatRoom;
@@ -12,5 +15,6 @@ export declare class ChatButton {
   isChatExpanded: boolean;
   componentWillLoad(): void;
   fetchData(): Promise<void>;
+  onVerificationSuccess(user: User): void;
   render(): any;
 }

package/dist/types/components/chat-button/notify-sounds.d.ts

@@ -0,0 +1,5 @@
+export declare class NotifySounds {
+  componentDidLoad(): void;
+  private playSound;
+  render(): any;
+}

package/dist/types/components/chat-rooms/index.d.ts

@@ -1,12 +1,18 @@
 import { ChatRoom } from '../../types/chat';
+import { User } from '../../types/user';
 export declare class ChatRooms {
   senderId: number;
+  salonId: number;
   chatRooms: ChatRoom[];
+  clients: User[];
   activeRoom: ChatRoom;
+  accessToken: string;
   onClickRoom: (chatRoom: ChatRoom) => void;
   keyword: string;
   private clickRoom;
   private onSearchRooms;
   private renderChatRoom;
+  private initChatRoom;
+  private renderClient;
   render(): any;
 }