@redneckz/wildless-cms-uni-blocks 0.14.675 → 0.14.676

package/mobile/bundle/bundle.umd.js

@@ -414,32 +414,53 @@
         className,
     ].join(' ');
 
-    class EventBus {
-        subscribers = {};
-        subjectsStateMap = {};
-        subscribe(type, listener) {
-            this.subscribers[type] = (this.subscribers[type] || []).concat(listener);
-            const latestEvent = this.subjectsStateMap[type];
-            if (latestEvent) {
-                listener(latestEvent);
-            }
-            return () => {
-                this.unsubscribe(type, listener);
-            };
-        }
-        unsubscribe(type, listener) {
-            this.subscribers[type] = this.subscribers[type]?.filter((s) => s !== listener);
-        }
-        fire(type, event) {
-            const isSubjectDeclared = type in this.subjectsStateMap;
-            if (isSubjectDeclared) {
-                this.subjectsStateMap[type] = event;
-            }
-            this.subscribers[type]?.forEach((s) => s(event));
-        }
-        subject(type, event) {
-            this.subjectsStateMap[type] = event;
-        }
+    class EventBus {
+        watchers = new Set();
+        subscribersMap = {};
+        subjectsStateMap = {};
+        emitter = this;
+        observable = this;
+        watch(watcher) {
+            this.watchers.add(watcher);
+            return () => {
+                this.watchers.delete(watcher);
+            };
+        }
+        subscribe(type, listener) {
+            this.subscribersMap[type] ||= new Set();
+            this.subscribersMap[type]?.add(listener);
+            const initialEvent = this.subjectsStateMap[type];
+            initialEvent && listener(initialEvent);
+            return () => {
+                this.subscribersMap[type]?.delete(listener);
+            };
+        }
+        fire(type, event) {
+            const isSubjectDeclared = type in this.subjectsStateMap;
+            if (isSubjectDeclared) {
+                this.subject(type, event);
+            }
+            else {
+                this.fireSubscribers(type, event);
+            }
+        }
+        subject(type, event) {
+            if (this.subjectsStateMap[type] !== event) {
+                this.subjectsStateMap[type] = event ?? undefined;
+                this.fireSubscribers(type, event);
+            }
+            return () => {
+                delete this.subjectsStateMap[type];
+            };
+        }
+        fireSubscribers(type, event) {
+            for (const _ of this.subscribersMap[type] ?? []) {
+                _(event ?? null);
+            }
+            for (const _ of this.watchers) {
+                _({ type, event: event ?? null });
+            }
+        }
     }
 
     const defaultEventBus = new EventBus();
@@ -725,26 +746,166 @@
     const leftOrRightImage = (img, directionRight) => directionRight ? { rightImage: img } : { leftImage: img };
     const renderTags = (tags) => (tags?.length ? jsx(Tags, { tags: tags }) : null);
 
+    class JSONBox {
+        _;
+        constructor(_) {
+            this._ = _;
+        }
+        of(_) {
+            return new this.constructor(_ instanceof JSONBox ? _._ : _);
+        }
+        filter(predicate) {
+            return this.from(this.entries().filter(predicate));
+        }
+        map(mapper) {
+            return this.from(this.entries().map(mapper));
+        }
+        flatMap(mapper) {
+            return this.from(this.entries().flatMap(mapper));
+        }
+        reduce(reducer, initial) {
+            return this.entries().reduce(reducer.bind(this), initial);
+        }
+    }
+
+    const trueF = () => true;
+    const and = (a, b) => (...args) => a(...args) && b(...args);
+
+    const table = (...table) => (...input) => {
+        const [, unit] = assertNonEmpty$1(table.find(([predicate]) => predicate(...input)));
+        return unit(...input);
+    };
+    function assertNonEmpty$1(value) {
+        if (!value) {
+            throw new Error('Value should be fulfilled');
+        }
+        return value;
+    }
+
     const isJSONArray = (_) => Boolean(_ && Array.isArray(_));
-    const isJSONRecord = (_) => Boolean(_ && !Array.isArray(_) && typeof _ === 'object');
-    const isJSONRef = (_) => Boolean(isJSONRecord(_) && typeof _.$ref === 'string');
+    const isJSONRecord = (_) => Boolean(_ && typeof _ === 'object' && !isJSONArray(_));
 
-    const mapJSONNode = (json, handlers) => {
-        if (isJSONRef(json)) {
-            return handlers.ref(json);
+    const identity$1 = (x) => x;
+
+    const t0 = (fn = identity$1) => ([_]) => fn(_);
+    const t1 = (fn = identity$1) => ([, _]) => fn(_);
+
+    function unbox(box) {
+        return box instanceof JSONBox ? box._ : box;
+    }
+
+    class JSONArrayBox extends JSONBox {
+        from(entries) {
+            return this.of(entries.map(t1(unbox)));
         }
-        else if (isJSONRecord(json)) {
-            return handlers.record(json);
+        entries() {
+            return (this._ ?? []).map((node, p) => [p, this.of(node)]);
         }
-        else if (isJSONArray(json)) {
-            return handlers.array(json);
+        size() {
+            return this._?.length ?? 0;
         }
-        else {
-            return handlers.scalar ? handlers.scalar(json) : json;
+        get(p) {
+            return this.of(typeof p === 'number' ? this._?.[p] : undefined);
+        }
+        set(p, child) {
+            return this.of(isJSONArray(this._)
+                ? Array.from({ length: Math.max(this._.length, Number(p) + 1) }, (x, i) => (i === p ? child : this._[i]))
+                : Array.from({ length: Number(p) + 1 }, (x, i) => (i === p ? child : undefined)));
+        }
+    }
+
+    class JSONLeafBox extends JSONBox {
+        from() {
+            return this;
+        }
+        entries() {
+            return [];
+        }
+        size() {
+            return 0;
+        }
+        get(p) {
+            return this.of(p !== undefined ? undefined /* no childs */ : this._ /* self */);
+        }
+        set(p, child) {
+            return this.of(child);
+        }
+    }
+
+    class JSONRecordBox extends JSONBox {
+        from(entries) {
+            return this.of(Object.fromEntries(entries.map(([p, box]) => [p, unbox(box)])));
+        }
+        entries() {
+            return Object.entries(this._ ?? {}).map(([p, node]) => [p, this.of(node)]);
+        }
+        size() {
+            return Object.keys(this._ ?? {}).length;
+        }
+        get(p) {
+            return this.of(typeof p === 'string' ? this._?.[p] : undefined);
         }
+        set(p, child) {
+            return this.of({ ...this._, [p]: child });
+        }
+    }
+
+    class JSONBoxDefault extends JSONBox {
+        proto = table([p => isJSONArray(this._) || typeof p === 'number', () => JSONArrayBox.prototype], [p => isJSONRecord(this._) || typeof p === 'string', () => JSONRecordBox.prototype], [trueF, () => JSONLeafBox.prototype]);
+        from(entries) {
+            return this.proto(undefined).from.call(this, entries);
+        }
+        entries() {
+            return this.proto(undefined).entries.call(this);
+        }
+        size() {
+            return this.proto(undefined).size.call(this);
+        }
+        get(p) {
+            return this.proto(p).get.call(this, p);
+        }
+        set(p, child) {
+            return this.proto(p).set.call(this, p, child);
+        }
+    }
+
+    const box = (_) => (_ instanceof JSONBox ? _ : new JSONBoxDefault(_));
+
+    const boxed = (fn) => {
+        const boxedFn = (node, ...args) => unbox(fn(box(node), ...args));
+        boxedFn.fn = fn;
+        return boxedFn;
     };
 
-    const mergeRecords = (entries) => entries.reduce((acc, _) => Object.assign(acc, _), {});
+    const ROOT = [];
+    const endsWith = (suffix) => suffix
+        .map((predicate, i) => (path) => cmp(predicate)(path[i + path.length - suffix.length]))
+        .reduceRight(and, trueF);
+    const cmp = (a) => a instanceof Function ? a : (b) => a === b;
+
+    const reduce = (reducer) => (node, initial, path = ROOT) => box(node)
+        .entries()
+        .reduce((acc, [p, _]) => reduce(reducer)(_, acc, path.concat(p)), reducer(initial, [path, box(node)]));
+
+    const set = boxed((target, [path, node]) => {
+        const [p, ...tail] = path;
+        return target.set(p, tail.length ? set(target.get(p), [tail, node]) : node);
+    });
+
+    const fromEntries = boxed((initial, tree) => tree.reduce(set.fn, initial));
+
+    const leafs = (node) => reduce((acc, [path, _]) => (isLeaf(_) ? [...acc, [path, unbox(_)]] : acc))(node, []);
+    const isLeaf = (_) => _.size() === 0;
+
+    const map = (mapper, initial = {}) => (node) => fromEntries(initial, leafs(node).map(_ => mapper(_)));
+
+    const init = (list) => list.slice(0, -1);
+
+    boxed((target, path = ROOT) => path.reduce((_, p) => _.get(p), target));
+
+    const remove = boxed((target, [p, ...tail]) => tail.length ? target.set(p, remove(target.get(p), tail)) : target.filter(([i]) => i !== p));
+
+    const isJSONRefPath = endsWith(['$ref']);
 
     const parseJPointer = (uri) => uri.includes('#')
         ? uri
@@ -754,46 +915,17 @@
         : [];
 
     const resolveJPointer = (json, uri) => parseJPointer(uri).reduce(selectNodeByKey, json);
-    const selectNodeByKey = (json, key) => {
-        if (!json || !key) {
-            return json;
-        }
-        if (isJSONRecord(json)) {
-            return json[key];
-        }
-        else if (isJSONArray(json)) {
-            return json[parseInt(key, 10)];
-        }
-        else {
-            return json;
-        }
-    };
+    const selectNodeByKey = table([isJSONArray, (json, key) => json[parseInt(key, 10)]], [isJSONRecord, (json, key) => json[key]], [trueF, identity$1]);
 
-    const resolveRef = (json, resolver) => mapJSONNode(json, {
-        ref: ({ $ref, ...rest }) => resolveRef($ref ? resolveJPointer(resolver($ref), $ref) : rest, resolver),
-        record: record => mergeRecords(Object.entries(record).map(([key, value]) => ({ [key]: resolveRef(value, resolver) }))),
-        array: list => list.map(_ => resolveRef(_, resolver))
-    });
+    const resolveRef = (json, resolver) => map(([path, node]) => isJSONRefPath(path)
+        ? [init(path), resolveJPointer(resolver(node), node)]
+        : [path, node])(json);
 
-    const visitRef = (json, visitor, path = []) => {
-        mapJSONNode(json, {
-            ref: json => visitor(json.$ref, path),
-            record: record => {
-                for (const key in record)
-                    visitRef(record[key], visitor, [...path, key]);
-            },
-            array: list => {
-                for (let i = 0; i < list.length; i++)
-                    visitRef(list[i], visitor, [...path, i]);
-            }
-        });
-    };
+    const refEntries = (json) => leafs(json).filter(t0(isJSONRefPath));
 
-    const collectRef = (json) => {
-        const refs = [];
-        visitRef(json, _ => refs.push(_));
-        return refs;
-    };
+    const unique$1 = (list) => [...new Set(list)];
+
+    const collectRef = (json) => unique$1(refEntries(json).map(([, _]) => _));
 
     async function fetchJSON(url, options) {
         try {
@@ -3156,10 +3288,10 @@
     const LegalFormField = JSX(({ field, input }) => (jsx(InputControl, { label: "\u041E\u041F\u0424", placeholder: "\u041E\u041E\u041E, \u041F\u0410\u041E  \u0438 \u0434\u0440.", ...getValidation(field('legalForm'), validatorObj.legalForm, input?.required), ...input })));
 
     const OUT_SERVICE_BASE_URL = `${API_BASE_URI}/outservice`;
-    const EMPTY_REGIONS = [];
+    const EMPTY_REGIONS$1 = [];
     async function getOutServiceRegions() {
         const data = await fetchJSON(`${OUT_SERVICE_BASE_URL}/outserviceregions`);
-        return data && Array.isArray(data) ? data : EMPTY_REGIONS;
+        return data && Array.isArray(data) ? data : EMPTY_REGIONS$1;
     }
 
     const LocalitiesField = JSX(({ field, input }) => {
@@ -3292,9 +3424,11 @@
     const arrayToOptions = (array) => (array ?? []).map((_) => ({ key: _, value: _ }));
 
     const REGIONS_URL = `${API_BASE_URI}/regions`;
+    const EMPTY_REGIONS = [];
+    // TODO Почему url можно менять? Разве смысл не в инкапсуляции api url. Тоже под рефакторинг попадает
     function useRegions(url = REGIONS_URL) {
         const { data } = useAsyncData(url, fetchJSONUnsafe);
-        return Array.isArray(data) ? data : [];
+        return Array.isArray(data) ? data : EMPTY_REGIONS;
     }
 
     const RegionField = JSX(({ field, input, url }) => {
@@ -6010,7 +6144,7 @@
             : [cellsNode, []];
         const [isVisible, setIsVisible] = useState(false);
         useEffect(() => defaultEventBus.subscribe('fold', (event) => {
-            if (options?.parent !== undefined && event.parent === options?.parent) {
+            if (event && options?.parent !== undefined && event.parent === options?.parent) {
                 setIsVisible(event.isUnfolded);
             }
         }), [options?.parent]);
@@ -7914,47 +8048,166 @@
     };
     const ErrorBlock = JSX(({ className = '', title, description, error, button, ...rest }) => (jsxs(BlockWrapper, { className: style('flex flex-col justify-center items-center', className), defaultPadding: style('p-6xl'), version: "transparent", ...rest, children: [jsx("div", { className: "flex justify-center", children: renderErrorContent(error) }), jsx(Headline, { title: title, description: description, headlineVersion: "XL", isEmbedded: true, className: "mb-2xl last:mb-0" }), button?.text ? (jsx(LinkButton, { version: button?.version, text: button?.text, ...button })) : null] })));
 
-    const useLatestEvent = (eventBus, type, initialEvent) => {
-        const [latestEvent, setLatestEvent] = useState(initialEvent || null);
-        useEffect(() => eventBus.subscribe(type, (_) => setLatestEvent(_)), [eventBus, type]);
-        const fireEvent = useCallback((_) => eventBus.fire(type, _), [eventBus, type]);
-        return [latestEvent, fireEvent];
-    };
+    function copy(source, target) {
+        for (const [k, v] of source.entries()) {
+            if (v !== null && v !== undefined) {
+                target.setItem(k, v);
+            }
+            else {
+                target.removeItem(k);
+            }
+        }
+    }
+
+    function replicate(primary, secondary) {
+        copy(primary, secondary);
+        copy(secondary, primary);
+        return primary.bus.watch(({ type, event }) => {
+            if (event !== null && event !== undefined) {
+                secondary.setItem(type, event);
+            }
+            else {
+                secondary.removeItem(type);
+            }
+        });
+    }
+
+    class StorageAdapter {
+        storage;
+        bus;
+        get size() {
+            return this.storage?.length ?? 0;
+        }
+        constructor(storage, bus = new EventBus()) {
+            this.storage = storage;
+            this.bus = bus;
+        }
+        hasItem(key) {
+            return Boolean(this.storage?.getItem(String(key)));
+        }
+        getItem(key) {
+            const _ = this.storage?.getItem(String(key)) ?? null;
+            try {
+                return JSON.parse(String(_));
+            }
+            catch (ex) {
+                return null;
+            }
+        }
+        entries() {
+            return Array.from({ length: this.size }, (_, i) => {
+                const k = String(this.storage?.key(i));
+                return [k, this.getItem(k)];
+            });
+        }
+        setItem(key, value) {
+            if (value !== null) {
+                this.storage?.setItem(String(key), JSON.stringify(value));
+            }
+            else {
+                this.storage?.removeItem(String(key));
+            }
+            this.bus?.subject(key, value);
+        }
+        removeItem(key) {
+            this.storage?.removeItem(String(key));
+            this.bus?.subject(key, null);
+        }
+    }
+
+    class Store {
+        bus;
+        store = new Map();
+        get size() {
+            return this.store.size;
+        }
+        constructor(bus = new EventBus()) {
+            this.bus = bus;
+        }
+        hasItem(key) {
+            return this.store.has(key);
+        }
+        getItem(key) {
+            return this.store.get(key);
+        }
+        entries() {
+            return this.store.entries();
+        }
+        setItem(key, value) {
+            this.store.set(key, value);
+            this.bus.subject(key, value);
+        }
+        removeItem(key) {
+            this.store.delete(key);
+            this.bus.subject(key, null);
+        }
+    }
+
+    function useRerender() {
+        const [, setCount] = useState(0);
+        return useCallback(() => setCount(_ => (_ + 1) % (1 << 16)), []);
+    }
+
+    const DEFAULT_METHODS = {};
+    /**
+     * MobX like reactivity (simplified).
+     * Can be used to migrate from Redux/MobX or something else
+     *
+     * @param store
+     * @returns reactive proxy backed by store
+     */
+    function useStore(store, methods = DEFAULT_METHODS) {
+        const deps = useRef(null);
+        const render = useRerender();
+        useEffect(() => store.bus.watch(ev => {
+            if (deps.current?.has(String(ev.type))) {
+                render();
+            }
+        }), [store, render]);
+        return useMemo(() => new Proxy(methods, {
+            get(_, key) {
+                deps.current ||= new Set();
+                deps.current.add(key);
+                return store.getItem(key);
+            },
+            has(_, key) {
+                deps.current ||= new Set();
+                deps.current.add(key);
+                return store.hasItem(key);
+            },
+            set(_, key, value) {
+                store.setItem(key, value);
+                return true;
+            },
+            deleteProperty(_, key) {
+                store.removeItem(key);
+                return true;
+            }
+        }), [store]);
+    }
+
+    const localStore = new Store(); // localStorage cache
+    replicate(localStore, new StorageAdapter(globalThis?.localStorage));
+    function useLocalStore(methods) {
+        return useStore(localStore, methods);
+    }
 
     const REGION_URL = `${API_BASE_URI}/region`;
-    const LOCATION_STORAGE_KEY = 'location';
     function useLocation(defaultLocation = 'Москва') {
-        const [currentLocation, fireCurrentLocation] = useLatestEvent(defaultEventBus, 'location', restoreLocation() ?? { name: defaultLocation });
-        const selectCurrentLocation = useCallback((_) => {
-            storeLocation(_);
-            fireCurrentLocation(_);
-        }, []);
-        const { data } = useAsyncData(hasStoredLocation() ? null : REGION_URL, fetchJSONUnsafe);
-        useEffect(() => {
-            if (data && !hasStoredLocation()) {
-                fireCurrentLocation(data);
-            }
-        }, [data]);
-        return [currentLocation ?? { name: defaultLocation }, selectCurrentLocation];
+        const locationStore = useLocalStore();
+        return locationStore.location ?? { name: defaultLocation };
+    }
+    function useDefaultLocation(defaultLocation = 'Москва') {
+        const locationStore = useLocalStore();
+        const preselectLocation = useCallback(async () => {
+            if (!locationStore.location) {
+                const region = await fetchJSON(REGION_URL);
+                locationStore.location = region ?? { name: defaultLocation };
+            }
+        }, [locationStore, defaultLocation]);
+        useAsyncData(REGION_URL, preselectLocation);
+        return locationStore;
     }
-    const hasStoredLocation = () => Boolean(globalThis.localStorage?.getItem(LOCATION_STORAGE_KEY));
-    const restoreLocation = () => {
-        try {
-            const data = globalThis.localStorage?.getItem(LOCATION_STORAGE_KEY);
-            return data && JSON.parse(data);
-        }
-        catch (ex) {
-            return null;
-        }
-    };
-    const storeLocation = (_) => {
-        try {
-            globalThis.localStorage?.setItem(LOCATION_STORAGE_KEY, JSON.stringify(_));
-        }
-        catch (ex) {
-            // Do nothing
-        }
-    };
 
     var Currency;
     (function (Currency) {
@@ -8096,7 +8349,7 @@
     }
 
     const ExchangeRateTile = JSX(({ className = '', title = 'Курсы обмена валют', button, ...rest }) => {
-        const [currentLocation] = useLocation();
+        const currentLocation = useLocation();
         const exchangeRates = useFetchExchangeRateData(currentLocation);
         const currencyRates = getCurrencyRates(exchangeRates?.exchangeRate?.currencies);
         const currencyRatesBuy = currencyRates.filter((_) => _.buyExchangeRate);
@@ -8583,7 +8836,7 @@
         designDisabledPeople: (item) => Boolean(item.designDisabledPeople),
     };
     const AtmsMap = JSX(({ descriptionData, className }) => {
-        const [currentLocation] = useLocation();
+        const currentLocation = useLocation();
         const regionCode = currentLocation?.code ?? '000';
         const { data: officesData, isLoad } = useAtms(regionCode);
         return (jsx(OfficesAtmsMapLayout, { className: className, filterItems: filterItems, data: officesData, isLoad: isLoad, initFilterState: INITIAL_FILTRATION_STATE, renderCard: renderAtmCard, getBalloon: getAtmPoint, title: `Банкоматы филиала ${currentLocation?.name}`, descriptionData: descriptionData }));
@@ -8636,7 +8889,7 @@
     };
 
     const OfficesMap = JSX(({ className }) => {
-        const [currentLocation] = useLocation();
+        const currentLocation = useLocation();
         const regionCode = currentLocation?.code ?? '000';
         const { data, isLoad } = useOffices(regionCode);
         return (jsx(OfficesAtmsMapLayout, { className: className, data: data?.branches, isLoad: isLoad, remoteWorkplaces: data?.remoteWorkplaces, renderCard: renderOfficeCard, renderRemoteWorkplaceCard: renderRemoteWorkplaceCard, getBalloon: getOfficePoint, getBalloonRemoteWorkplaces: getRemoteWorkplacePoint, title: `Офисы филиала ${currentLocation?.name}` }));
@@ -8885,6 +9138,9 @@
             pop();
         }, [dialogs, onClose]);
         useEffect(() => defaultEventBus.subscribe('dialog', (action) => {
+            if (!action) {
+                return;
+            }
             switch (action.type) {
                 case 'open':
                     push(action);
@@ -8993,27 +9249,33 @@
         return (jsxs("form", { className: `font-sans relative ${className}`, children: [jsx("div", { className: "absolute rounded h-full flex items-center justify-center pl-m max-w-44 gap-s pointer-events-none", children: searchTerm ? null : (jsx("label", { htmlFor: "search-bar-input", className: `text-secondary-text `, children: "\u041F\u043E\u0438\u0441\u043A \u043F\u043E \u0444\u0438\u043B\u0438\u0430\u043B\u0430\u043C" })) }), jsx("input", { id: "search-bar-input", className: style(inputValidStyle, `h-12 pl-m w-full peer text-l text-black rounded-md box-border`), value: searchTerm, onChange: (e) => onSearch(e.target.value.toLowerCase()), type: "text", name: "location-search-bar-input" })] }));
     });
 
-    const SEARCH_TERM_MIN_LENGTH = 3;
-    const LocationDialog = JSX(({ foreignOffices, branches }) => {
-        const [currentLocation, selectCurrentLocation] = useLocation(branches?.default);
+    const SelectedLocation = JSX(({ defaultLocation }) => {
+        const currentLocation = useLocation(defaultLocation);
         const link = useLink();
         const { href } = link({ href: `/branches/${currentLocation.slug}` });
+        return currentLocation ? (jsx("div", { className: "mb-s", children: jsxs(Paragraph, { size: "text-l", color: "text-primary-text", children: ["\u0421\u0435\u0439\u0447\u0430\u0441 \u0432\u044B\u0431\u0440\u0430\u043D:", jsx(LinkWrapper, { href: href, className: "inline mx-2xs text-primary-main", children: currentLocation.name })] }) })) : null;
+    });
+
+    const SEARCH_TERM_MIN_LENGTH = 3;
+    const LocationDialog = JSX(({ foreignOffices, branches }) => {
+        const locationStore = useDefaultLocation(branches?.default);
         const [query, setQuery] = useState('');
-        const regions = cleanUpRegions(useRegions()).sort((a, b) => a.name.localeCompare(b.name));
-        const regionsGroupByLetter = groupBy(regions, regionFirstLetter);
+        const rawRegions = useRegions();
+        const regions = useMemo(() => cleanUpRegions(rawRegions).sort((a, b) => a.name.localeCompare(b.name)), [rawRegions]);
+        const regionsGroupByLetter = useMemo(() => groupBy(regions, regionFirstLetter), [regions]);
         const { close } = useDialogManager();
-        const handleChangeLocation = useCallback((region) => {
-            selectCurrentLocation(region);
+        const handleChangeLocation = useCallback((_) => {
+            locationStore.location = _;
             close();
-        }, []);
-        return (jsxs(Dialog, { className: "pb-20", head: jsxs("div", { children: [jsx(Text, { size: "text-h4", color: "text-primary-text", children: "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0444\u0438\u043B\u0438\u0430\u043B" }), currentLocation ? (jsx("div", { className: "mb-s", children: jsxs(Paragraph, { size: "text-l", color: "text-primary-text", children: ["\u0421\u0435\u0439\u0447\u0430\u0441 \u0432\u044B\u0431\u0440\u0430\u043D:", jsx(LinkWrapper, { href: href, className: "inline mx-2xs text-primary-main", children: currentLocation.name })] }) })) : null, jsx(SearchBar, { onSearch: setQuery, searchTerm: query })] }), children: [query && query.length >= SEARCH_TERM_MIN_LENGTH ? (jsx("div", { children: regions
+        }, [locationStore]);
+        return (jsxs(Dialog, { className: "pb-20", head: jsxs("div", { children: [jsx(Text, { size: "text-h4", color: "text-primary-text", children: "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0444\u0438\u043B\u0438\u0430\u043B" }), jsx(SelectedLocation, { defaultLocation: branches?.default }), jsx(SearchBar, { onSearch: setQuery, searchTerm: query })] }), children: [query && query.length >= SEARCH_TERM_MIN_LENGTH ? (jsx("div", { children: regions
                         .filter(({ name }) => name && jaroWinklerDistance(name.toLowerCase())(query.toLowerCase()) >= 0.8)
                         .map(renderRegion(branches?.dataSelect, handleChangeLocation)) })) : (jsx("div", { className: "columns-1 sm:columns-3 md:columns-4 lg:columns-5", children: Array.from(regionsGroupByLetter.entries()).map(renderRegionGroup(handleChangeLocation, branches?.dataSelect)) })), renderForeignOffices(foreignOffices)] }));
     });
-    const regionFirstLetter = (region) => region.name?.charAt(0) || '';
+    const regionFirstLetter = (region) => region.name?.charAt(0) ?? '';
     const cleanUpRegions = (regions) => regions.map((region) => ({
         ...region,
-        name: region.name?.replace(/республика|область|край'/gi, '').trim() || '',
+        name: region.name?.replace(/республика|область|край'/gi, '').trim() ?? '',
     }));
 
     const useLocationDialog = (props) => {
@@ -9026,7 +9288,7 @@
 
     const BurgerMenuDialog = JSX(({ menuRef, menuItem, locationDialogProps, closeAll }) => {
         const locationDialog = useLocationDialog(locationDialogProps || {});
-        const [{ name: location }] = useLocation();
+        const { name: location } = useLocation();
         const menuDimensions = menuRef?.current?.getBoundingClientRect();
         const basePath = getBasePath(env.SITE_URL);
         const handleIframeLoad = () => {
@@ -9589,6 +9851,9 @@
             setPopup(null);
         }, []);
         useEffect(() => defaultEventBus.subscribe('popup', (action) => {
+            if (!action) {
+                return;
+            }
             switch (action.type) {
                 case 'open':
                 case 'update':
@@ -9622,6 +9887,7 @@
         const { slots, blocks, fallback, ...pageContent } = data;
         const resolvedPageContent = useJSONRef(pageContent, fallback);
         useClickHandler();
+        useDefaultLocation();
         const options = {
             key: '',
             page: { slots, blocks, fallback, ...resolvedPageContent },
@@ -9643,7 +9909,7 @@
         slots: () => [HEADER_SLOT, FOOTER_SLOT, STICKY_FOOTER_SLOT],
     });
 
-    const packageVersion = "0.14.674";
+    const packageVersion = "0.14.675";
 
     exports.Blocks = Blocks;
     exports.ContentPage = ContentPage;